gloomberb 0.16.4 → 0.16.5

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

@@ -1,17 +1,29 @@
+import type { EarningsTiming } from "../../../api-client/earnings";
 import type { PricePoint } from "../../../types/financials";
 import { zonedDateTimeParts } from "../../../utils/zoned-date-time";
-import { MACRO_EVENT_KINDS, type MacroEventKind, type MacroRelease } from "./releases";
+import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, type MacroEventKind, type MacroRelease } from "./releases";
 
 const DAY_MS = 86_400_000;
 /** Longest calendar gap between two closes that is still one session apart: Thursday to Monday over a Friday holiday. */
 const MAX_SESSION_GAP_DAYS = 4;
 
+/** One of the ticker's own earnings reports, reduced to what dates its reaction. */
+export interface MacroDayEarningsReport {
+  /** Report date, New York. */
+  date: string;
+  timing: EarningsTiming | null;
+  /** The session the earnings history measures the report's move on, once the report is priced. */
+  reactionSession?: string | null;
+}
+
 export interface MacroDayEvent {
   kind: MacroEventKind;
   /** Release day, New York date. */
   date: string;
   /** The session whose close carries the reaction: the release day, or the next session when the market was shut. */
   session: string;
+  /** The session is also the reaction session of the ticker's own earnings report: the move is the report's, not the release's. */
+  earnings: boolean;
   /** Close before the release to the session's close. */
   move: number;
   /** |move| over the normal day's average |move|. */
@@ -32,15 +44,22 @@ export interface MacroDayModel {
   symbol: string;
   /** Newest first. */
   events: MacroDayEvent[];
+  /** Without the earnings days. */
   byKind: Record<MacroEventKind, MacroDayStats>;
-  /** Every release day of the three kinds together; a day with two releases counts once. */
+  /** Every release day of the three kinds together, without the earnings days; a day with two releases counts once. */
   allEvents: MacroDayStats;
-  /** Sessions with no release of the three kinds. */
+  /** Release days that are the ticker's earnings reaction, which no other figure counts; a day with two releases counts once. */
+  earnings: MacroDayStats;
+  /** Sessions with no release of the three kinds, and none of the earnings days among them. */
   normal: MacroDayStats;
   start: string | null;
   asOf: string | null;
 }
 
+/** The release's name, with the earnings marker on a day that is the ticker's own report reaction. */
+export const macroDayEventLabel = (event: Pick<MacroDayEvent, "kind" | "earnings">) =>
+  event.earnings ? `${MACRO_EVENT_LABELS[event.kind]} (earnings)` : MACRO_EVENT_LABELS[event.kind];
+
 /** Daily labels at UTC midnight name that date; any other stamp reads in New York. */
 function sessionDate(time: number): string {
   if (time % DAY_MS === 0) return new Date(time).toISOString().slice(0, 10);
@@ -59,6 +78,27 @@ function stats(moves: number[], normalAbs: number | null): MacroDayStats {
     multiple: normalAbs ? meanAbs / normalAbs : null };
 }
 
+/**
+ * The sessions whose close carries a report's reaction, on the history's own
+ * calendar. A priced report names its session in the earnings history. Any
+ * other reads as the earnings history reads it: before the open and during
+ * the session react the same day, after the close the next session. A report
+ * with no time on record may have reacted on either, so both count.
+ */
+function earningsReactionSessions(reports: readonly MacroDayEarningsReport[], sessions: readonly string[]): Set<string> {
+  const reacted = new Set<string>();
+  for (const report of reports) {
+    if (report.reactionSession) { reacted.add(report.reactionSession); continue; }
+    const sameDay = report.timing === "bmo" || report.timing === "dmh";
+    const afterClose = report.timing === "amc";
+    const same = sessions.find((date) => date >= report.date);
+    const next = sessions.find((date) => date > report.date);
+    if (!afterClose && same) reacted.add(same);
+    if (!sameDay && next) reacted.add(next);
+  }
+  return reacted;
+}
+
 /**
  * Close to close on the release day: 8:30 ET releases land before the open
  * and 14:00 FOMC statements before the close, so the release day's close
@@ -66,7 +106,9 @@ function stats(moves: number[], normalAbs: number | null): MacroDayStats {
  * is read on the next session, from the close before the release. A release
  * whose close-to-close would span a gap in the history is left out rather
  * than read across it. A lone missing bar on the release day itself cannot
- * be told from a holiday and is read on the next session.
+ * be told from a holiday and is read on the next session. A release whose
+ * session is also the reaction to the ticker's own earnings is kept, marked,
+ * and counted in neither the release figures nor the normal days.
  */
 export function projectMacroDays(history: readonly PricePoint[], options: {
   symbol: string;
@@ -74,6 +116,8 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
   releases: readonly MacroRelease[];
   /** The release list's last covered day. */
   coveredThrough: string;
+  /** The ticker's own earnings reports; none when they could not be read. */
+  earnings?: readonly MacroDayEarningsReport[];
 }): MacroDayModel {
   const { coveredThrough } = options;
   const byDate = new Map<string, number>();
@@ -86,7 +130,7 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
   const last = sessions.at(-1) ?? null;
   const empty = (): MacroDayStats => stats([], null);
   if (!last) return { symbol: options.symbol, events: [], byKind: { cpi: empty(), jobs: empty(), fomc: empty() },
-    allEvents: empty(), normal: empty(), start: null, asOf: null };
+    allEvents: empty(), earnings: empty(), normal: empty(), start: null, asOf: null };
 
   // Sessions after the published lists end may be unlisted release days, so they are left out of both sides.
   const end = last < coveredThrough ? last : coveredThrough;
@@ -105,7 +149,7 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
   }
 
   const reactionSessions = new Set<string>();
-  const found: Omit<MacroDayEvent, "multiple">[] = [];
+  const found: Omit<MacroDayEvent, "multiple" | "earnings">[] = [];
   for (const release of options.releases) {
     if (release.date <= start || release.date > end || !isWeekday(release.date)) continue;
     const at = sessions.findIndex((date) => date >= release.date);
@@ -120,12 +164,14 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
   const normalMoves = [...moves].filter(([date]) => !reactionSessions.has(date)).map(([, move]) => move);
   const normal = stats(normalMoves, null);
   const normalAbs = normal.meanAbs;
-  const events = found.map((event) => ({ ...event, multiple: normalAbs ? Math.abs(event.move) / normalAbs : null }))
+  const reacted = earningsReactionSessions(options.earnings ?? [], sessions);
+  const events = found.map((event) => ({ ...event, earnings: reacted.has(event.session), multiple: normalAbs ? Math.abs(event.move) / normalAbs : null }))
     .sort((left, right) => right.date.localeCompare(left.date) || left.kind.localeCompare(right.kind));
   const byKind = Object.fromEntries(MACRO_EVENT_KINDS.map((kind) =>
-    [kind, stats(events.filter((event) => event.kind === kind).map((event) => event.move), normalAbs)])) as Record<MacroEventKind, MacroDayStats>;
-  const allEvents = stats([...reactionSessions].map((session) => moves.get(session)!), normalAbs);
-  return { symbol: options.symbol, events, byKind, allEvents, normal, start, asOf: end };
+    [kind, stats(events.filter((event) => event.kind === kind && !event.earnings).map((event) => event.move), normalAbs)])) as Record<MacroEventKind, MacroDayStats>;
+  const sessionMoves = (flagged: boolean) => [...reactionSessions].filter((session) => reacted.has(session) === flagged).map((session) => moves.get(session)!);
+  return { symbol: options.symbol, events, byKind, allEvents: stats(sessionMoves(false), normalAbs), earnings: stats(sessionMoves(true), normalAbs),
+    normal, start, asOf: end };
 }
 
 /**

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

@@ -9,8 +9,8 @@ import { useAutoRefresh } from "../../../react/auto-refresh";
 import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
-import { loadMacroDayHistory, loadMacroReleases } from "./client";
-import { projectMacroDays, type MacroDayEvent, type MacroDayModel } from "./model";
+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";
 
 export const LOOKBACK_OPTIONS = [{ value: "1", label: "1Y" }, { value: "2", label: "2Y" }, { value: "3", label: "3Y" }, { value: "5", label: "5Y" }];
@@ -23,14 +23,22 @@ function pct(value: number | null | undefined, signed = true): string {
 }
 const times = (value: number | null | undefined) => value == null ? "--" : `${value.toFixed(1)}x`;
 
-const COLUMNS: DataTableColumn[] = [
-  { id: "date", label: "Date", width: 19, align: "left" },
-  { id: "release", label: "Release", width: 8, align: "left" },
+const EARNINGS_MARK = "earnings";
+const DATE: DataTableColumn = { id: "date", label: "Date", width: 19, align: "left" };
+const MOVE: DataTableColumn[] = [
   { id: "move", label: "Move", width: 9, align: "right" },
   { id: "multiple", label: "vs Normal", width: 10, align: "right" },
 ];
-/** One release selected: every row would repeat its name. */
-const ONE_RELEASE_COLUMNS = COLUMNS.filter((column) => column.id !== "release");
+
+/**
+ * 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[] {
+  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];
+}
 
 function figures(model: MacroDayModel, release: string): StatItem[] {
   const normal: StatItem = { id: "normal", label: "Normal day", value: pct(model.normal.meanAbs, false), detail: "avg |move|" };
@@ -39,7 +47,8 @@ function figures(model: MacroDayModel, release: string): 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 };
-    }), normal];
+    }), ...(model.earnings.count ? [{ id: "earnings", label: "Earnings day", value: pct(model.earnings.meanAbs, false),
+      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;
@@ -64,12 +73,10 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
   const loader = useCallback(async (force: boolean) => {
     controller.current?.abort();
     controller.current = new AbortController();
-    const [snapshot, releases] = await Promise.all([
-      loadMacroDayHistory({ instrument: instrument!, forceRefresh: force, signal: controller.current.signal }),
-      loadMacroReleases({ force }),
-    ]);
+    const request = { instrument: instrument!, forceRefresh: force, signal: controller.current.signal };
+    const [snapshot, releases, earnings] = await Promise.all([loadMacroDayHistory(request), loadMacroReleases({ force }), loadMacroDayEarnings(request)]);
     if (!snapshot.history.length && snapshot.error) throw new Error(snapshot.error);
-    return { ...snapshot, releases };
+    return { ...snapshot, releases, earnings };
   }, [instrumentKey]);
   const history = useAsyncResource(instrument ? loader : null);
   useEffect(() => () => controller.current?.abort(), [loader]);
@@ -77,26 +84,29 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
   usePaneRefreshKey(() => { void history.reload(); }, { focused });
 
   const model = useMemo(() => history.data ? projectMacroDays(history.data.history, { symbol: symbol ?? "", lookbackYears: Number(lookback) || 5,
-    releases: history.data.releases.releases, coveredThrough: history.data.releases.coveredThrough }) : null, [history.data, lookback, symbol]);
+    releases: history.data.releases.releases, coveredThrough: history.data.releases.coveredThrough, earnings: history.data.earnings.reports }) : null,
+  [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 columns = useMemo(() => columnsFor(release, rows), [release, rows]);
 
   usePaneNoticeFooter({ registrationId: "macro-day-notices", focused,
-    notices: [...new Set([identityError, history.error, history.data?.error, releasesNotice].filter((value): value is string => !!value))] });
+    notices: [...new Set([identityError, history.error, history.data?.error, releasesNotice, earningsNotice].filter((value): value is string => !!value))] });
   usePaneFooter("macro-day", () => ({ info: [
     ...(history.loading ? [{ id: "loading", parts: [{ text: "loading history", tone: "muted" as const }] }] : []),
-    ...(history.data?.stale ? [{ id: "stale", parts: [{ text: "stale history", tone: "warning" as const }] }] : []),
+    ...(history.data?.stale || history.data?.earnings.stale ? [{ id: "stale", parts: [{ text: "stale history", tone: "warning" as const }] }] : []),
     ...(model?.asOf ? [{ id: "date", parts: [{ text: `daily closes ${model.start} to ${model.asOf}`, tone: "muted" as const }] }] : []),
-  ] }), [history.loading, history.data?.stale, model?.start, model?.asOf]);
+  ] }), [history.loading, history.data?.stale, history.data?.earnings.stale, model?.start, model?.asOf]);
 
   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: MACRO_EVENT_LABELS[event.kind] };
+    if (column.id === "release") return { text: release === "all" ? macroDayEventLabel(event) : event.earnings ? EARNINGS_MARK : "" };
     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 };
-  }, [colors]);
+  }, [colors, release]);
 
   const contentHeight = Math.max(4, height - 1 - statGridRows(stats, width));
   const key = (event: MacroDayEvent) => `${event.kind}:${event.date}`;
@@ -110,7 +120,7 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
       error={!model ? history.error ?? identityError ?? null : null} empty={!!model && !model.events.length}>
       {model ? <>
         <StatGrid items={stats} width={width} />
-        <DataTableView<MacroDayEvent> focused={focused} columns={release === "all" ? COLUMNS : ONE_RELEASE_COLUMNS} items={rows} rootWidth={width} rootHeight={contentHeight}
+        <DataTableView<MacroDayEvent> focused={focused} columns={columns} items={rows} rootWidth={width} rootHeight={contentHeight}
           getItemKey={key} emptyStateTitle="No release days." 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 ?? ""],

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

@@ -77,18 +77,24 @@ const twoDigits = (value: number) => String(value).padStart(2, "0");
 /** A New York calendar day ("2026-10-09") as the footer names it: "Oct 9". */
 const dayLabel = (day: string) => formatShortDate(day, { year: false, utc: true, fallback: day });
 
+const isTimestamp = (value: number | null | undefined): value is number =>
+  typeof value === "number" && Number.isFinite(value) && value > 0;
+
 /**
  * What a market board covers and when it is from, for the footer: how many of
  * the largest names it holds, the completed regular session it shows outside
- * that session, when the server put the snapshot together, 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 footer narrower than `maxWidth` loses the check first, then the snapshot,
- * then the session; after a failed refresh (`failed`) the age of the last good
- * check outlasts the snapshot. Null when not even the count fits.
+ * 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
+ * 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 },
+  board: { topCount: number; fetchedAt: number; regularSessionDate?: string | null; regularSessionClosedAt?: number | null },
   { now, checked = null, failed = false, maxWidth = Number.POSITIVE_INFINITY }:
     { now: number; checked?: string | null; failed?: boolean; maxWidth?: number },
 ): string | null {
@@ -96,11 +102,13 @@ export function heatmapBoardCaption(
   // Display order; `rank` is the order they give way in, highest first.
   const parts: Array<{ text: string; rank: number }> = [{ text: `top ${board.topCount}`, rank: 0 }];
   if (sessionDate) parts.push({ text: `${dayLabel(sessionDate)} session`, rank: 1 });
-  if (Number.isFinite(board.fetchedAt) && board.fetchedAt > 0) {
-    const { hour, minute } = zonedDateTimeParts(board.fetchedAt, NEW_YORK);
+  const closedAt = sessionDate && isTimestamp(board.regularSessionClosedAt) ? board.regularSessionClosedAt : null;
+  const time = closedAt ?? (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(board.fetchedAt, NEW_YORK);
-    const text = `snapshot ${day === (sessionDate ?? zonedDateKey(now, NEW_YORK)) ? clock : `${dayLabel(day)} ${clock}`}`;
+    const day = zonedDateKey(time, NEW_YORK);
+    const text = `${closedAt != 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-heatmap/portfolio.ts

@@ -5,7 +5,7 @@ import type { ColumnConfig } from "../../../types/config";
 import type { TickerFinancials } from "../../../types/financials";
 import {
   getRegularSessionMoveDisplay,
-  getSessionMoveDisplay,
+  getTradedSessionMoveDisplay,
   type ActiveQuoteDisplay,
   type ExtendedSession,
 } from "../../../market-data/market/status";
@@ -227,7 +227,7 @@ export function buildPortfolioHeatmapAssets({
     // Colored like the market boards: an open extended session's move, else the regular session's.
     const display: (ActiveQuoteDisplay & { session?: ExtendedSession }) | null = regularSession
       ? getRegularSessionMoveDisplay(quote)
-      : getSessionMoveDisplay(quote);
+      : getTradedSessionMoveDisplay(quote);
     const price = display != null && Number.isFinite(display.price) ? display.price : null;
     const size = positiveNumber(getSortValue(sizeColumn, ticker, snapshot, context));
     const hasChange = display?.changePercent != null && Number.isFinite(display.changePercent);

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

@@ -5,18 +5,19 @@ import type {
   CloudSessionMoversSide,
 } from "../../../api-client/market-movers";
 import type { DataProvider } from "../../../types/data-provider";
-import { CATEGORY_MAP, screenerQuoteFromQuote, type ScreenerTabId } from "./model";
+import { CATEGORY_MAP, moverRegularSession, screenerQuoteFromQuote, type MoverQuote, type ScreenerTabId } from "./model";
 import {
   fetchPreferredMarketMovers,
   fetchTrending,
   type MarketMoversResult,
   type PreferredMoversOptions,
-  type ScreenerQuote,
   type TrendingSymbol,
 } from "./screener";
 
 export interface MarketMoverTabResult extends MarketMoversResult {
   tab: ScreenerTabId;
+  /** In the list's order; Last and Chg% the regular session, as `ticker` reads them. */
+  quotes: MoverQuote[];
 }
 
 export interface MarketMoverTabDependencies {
@@ -36,9 +37,9 @@ const defaultDependencies: MarketMoverTabDependencies = {
 async function hydrateTrending(
   trending: readonly TrendingSymbol[],
   provider: DataProvider | null,
-): Promise<ScreenerQuote[]> {
+): Promise<MoverQuote[]> {
   const symbols = trending.slice(0, 25).map(({ symbol }) => symbol);
-  const bySymbol = new Map<string, ScreenerQuote>();
+  const bySymbol = new Map<string, MoverQuote>();
   if (!provider) return [];
   if (provider.getQuotesBatch) {
     const results = await provider.getQuotesBatch(
@@ -79,7 +80,8 @@ export async function loadMarketMoverTab(
     };
   }
   const result = await dependencies.fetchPreferred(CATEGORY_MAP[tab], 25, options);
-  return { ...result, tab };
+  // Ranked by the live print first, so reading each row's regular session keeps its place.
+  return { ...result, quotes: result.quotes.map(moverRegularSession), tab };
 }
 
 /** The server refused the list for the account's plan. */

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

@@ -34,6 +34,7 @@ import {
   type MarketMoverColumn,
   type MarketMoverRow,
   type MarketMoverSortPreference,
+  type MoverQuote,
   type ScreenerTabId,
   type TabId,
 } from "./model";
@@ -58,7 +59,7 @@ import {
 /** Stable identity: a fresh literal here would reload the board every render. */
 const NO_SAVED_SELECTION: string[] = [];
 const SESSION_CHECK_MS = 30_000;
-const NO_QUOTES: ScreenerQuote[] = [];
+const NO_QUOTES: MoverQuote[] = [];
 const moverKey = (row: Pick<ScreenerQuote, "symbol" | "exchange">) => publicTickerKey(row.symbol, row.exchange);
 
 /** What is trading in New York, re-read every half minute so the pane follows 04:00, 09:30 and 16:00. */
@@ -154,7 +155,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
 }) {
   const dataProvider = useAssetData();
   const { pinTicker } = usePluginTickerActions();
-  const [quotes, setQuotes] = useState<ScreenerQuote[]>([]);
+  const [quotes, setQuotes] = useState<MoverQuote[]>([]);
   const [loadedTab, setLoadedTab] = useState<TabId | null>(null);
   const visibleQuotes = loadedTab === activeTab ? quotes : NO_QUOTES;
   // The first load starts before the effect runs; an empty board is not "no data".

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

@@ -184,6 +184,36 @@ function moverExtended(quote: Quote): ExtendedSessionDisplay | null {
   return extended && isFiniteNumber(extended.price) ? extended : null;
 }
 
+/**
+ * A listed row as `ticker` reads its quote: Last and Chg% are the regular
+ * session's close and move, and a pre-market or after-hours print is its
+ * `extended`, measured from that close. The list ranked it by its live print
+ * first, so its place stays. A row without its quote's sessions (an older
+ * server) reads as it came.
+ */
+export function moverRegularSession({ sessions, ...row }: ScreenerQuote): MoverQuote {
+  if (!sessions || row.price == null) return row;
+  const quote: Quote = {
+    symbol: row.symbol,
+    price: row.price,
+    change: row.change ?? Number.NaN,
+    changePercent: row.changePercent ?? Number.NaN,
+    previousClose: row.previousClose,
+    currency: row.currency,
+    lastUpdated: row.lastUpdated ?? Number.NaN,
+    listingExchangeName: row.exchange || undefined,
+    ...sessions,
+  };
+  const headline = getRegularSessionDisplay(quote)!;
+  return {
+    ...row,
+    price: screenerNumber(headline.price),
+    change: screenerNumber(headline.change),
+    changePercent: screenerNumber(headline.changePercent),
+    extended: moverExtended(quote),
+  };
+}
+
 /**
  * A trending row from its quote: Last and Chg% are the regular session, as
  * `ticker` reads it, and a pre-market or after-hours print rides beside them.

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

@@ -8,7 +8,9 @@ import type {
   CloudMarketScreenerCategory,
   CloudMarketScreenerItem,
   CloudMarketScreenerPayload,
+  CloudMoverSessionFields,
 } from "../../../api-client/types";
+import type { MarketState } from "../../../types/financials";
 import { hasProAccess } from "../../../api-client/plan-access";
 
 const CACHE_KIND = "market-screener";
@@ -184,6 +186,32 @@ export function convertScreenerPriceUnit(value: number | undefined, from: string
     ? value / source.divisor * target.divisor : undefined;
 }
 
+const MARKET_STATES = new Set<string>(["PRE", "REGULAR", "POST", "PREPRE", "POSTPOST", "CLOSED"] satisfies MarketState[]);
+const SESSION_NUMBERS = [
+  "regularClose", "regularChange", "regularChangePercent",
+  "preMarketPrice", "preMarketChange", "preMarketChangePercent",
+  "postMarketPrice", "postMarketChange", "postMarketChangePercent",
+] as const;
+const isSessionDate = (value: unknown): value is string => typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value);
+
+/**
+ * A row's quote sessions as the server sends them beside its live print, or
+ * undefined when it sends none (an older server), so the row reads as it came.
+ */
+function parseScreenerSessions(row: Record<string, unknown>): CloudMoverSessionFields | undefined {
+  if (typeof row.marketState !== "string" || !MARKET_STATES.has(row.marketState)) return undefined;
+  const sessions: CloudMoverSessionFields = { marketState: row.marketState as MarketState };
+  if (isSessionDate(row.changeSessionDate)) sessions.changeSessionDate = row.changeSessionDate;
+  for (const key of SESSION_NUMBERS) {
+    const value = screenerNumber(row[key]);
+    if (value != null) sessions[key] = value;
+  }
+  if (sessions.regularClose != null && isSessionDate(row.regularCloseSessionDate)) {
+    sessions.regularCloseSessionDate = row.regularCloseSessionDate;
+  }
+  return sessions;
+}
+
 /** Validate numeric fields at the API boundary so absent values stay unavailable. */
 export function parseScreenerResponse(data: unknown): ScreenerQuote[] {
   if (!data || typeof data !== "object" || !("quotes" in data) || !Array.isArray(data.quotes)) {
@@ -202,6 +230,7 @@ export function parseScreenerResponse(data: unknown): ScreenerQuote[] {
       dayHigh: screenerNumber(q.dayHigh) ?? undefined, dayLow: screenerNumber(q.dayLow) ?? undefined,
       previousClose: screenerNumber(q.previousClose) ?? undefined, exchange: typeof q.exchange === "string" ? q.exchange : "",
       lastUpdated: typeof q.lastUpdated === "number" && Number.isFinite(q.lastUpdated) && q.lastUpdated > 0 ? q.lastUpdated : undefined,
+      sessions: parseScreenerSessions(q),
     }];
   });
 }
@@ -274,6 +303,8 @@ function mergeCloudScreenerItem(
     dayLow: screenerNumber(item.dayLow) ?? metadataPrice(metadata?.dayLow),
     exchange: item.exchange || metadata?.exchange || "",
     lastUpdated: item.lastUpdated,
+    previousClose: screenerNumber(item.previousClose) ?? undefined,
+    sessions: parseScreenerSessions(item as unknown as Record<string, unknown>),
   };
 }
 

package/src/plugins/builtin/market-valuation/chart-series.ts

@@ -1,64 +1,27 @@
-import { chartSeriesProvider } from "../../../capabilities";
-import type { ChartSeriesCatalogItem, ChartSeriesCapability } from "../../../capabilities";
-import { colors } from "../../../theme/colors";
-import type { ResolvedSeries, TimeSeriesPoint } from "../../../time-series/types";
+import type { SeriesDefinition, SeriesLoadResult } from "../../../series/types";
 import { buildValuationSeries } from "./align";
 import { defaultValuationSeriesLoader, type ValuationSeriesLoader } from "./client";
 import { indicatorUnavailableReason, indicatorSeries, type IndicatorDef } from "./defs";
-import { findIndicator, INDICATORS } from "./indicators";
+import { INDICATORS } from "./indicators";
 import type { DatedSeries } from "./series";
 
-export const MARKET_VALUATION_CAPABILITY_ID = "market-valuation";
+/** `CAP:market-valuation:<indicator>`, the expression charts saved before the catalog had these. */
+const MARKET_VALUATION_NAMESPACE = "market-valuation";
 
-function catalogItem(indicator: IndicatorDef): ChartSeriesCatalogItem {
-  return {
-    seriesId: indicator.id,
-    label: indicator.label,
-    description: indicator.description,
-    detail: "Market valuation",
-    style: "line",
-  };
-}
-
-function matches(indicator: IndicatorDef, query: string): boolean {
-  const haystack = `${indicator.id} ${indicator.label} ${indicator.shortLabel} ${indicator.description}`;
-  return haystack.toLowerCase().includes(query);
+/** Shiller's series move once a month; the Z.1 and GDP ratios once a quarter. */
+function indicatorFrequency(indicator: IndicatorDef): "monthly" | "quarterly" {
+  return indicatorSeries(indicator).some((def) => def.source.kind === "shiller") ? "monthly" : "quarterly";
 }
 
 /**
- * A ratio is not a series anyone can fetch, so the pane's own computation is what
- * makes it chartable. Exposing it here lets G overlay, say, the Buffett indicator
- * against CPI without the pane being involved.
+ * A ratio is not a series anyone can fetch, so the pane's own computation is
+ * what makes it chartable: overlaying the Buffett indicator on CPI needs no
+ * valuation pane on screen.
  */
-export function createValuationChartSeriesCapability(
+export async function loadValuationIndicator(
+  indicator: IndicatorDef,
   loader: ValuationSeriesLoader = defaultValuationSeriesLoader,
-): ChartSeriesCapability {
-  return chartSeriesProvider({
-    id: MARKET_VALUATION_CAPABILITY_ID,
-    name: "Market Valuation",
-    provider: {
-      catalog: ({ limit }) => INDICATORS.slice(0, limit ?? INDICATORS.length).map(catalogItem),
-      search: ({ query, limit }) => {
-        const needle = query?.trim().toLowerCase();
-        const hits = needle
-          ? INDICATORS.filter((indicator) => matches(indicator, needle))
-          : [...INDICATORS];
-        return hits.slice(0, limit ?? hits.length).map(catalogItem);
-      },
-      resolve: async ({ seriesId }) => resolveValuationSeries(seriesId, loader),
-    },
-  });
-}
-
-export async function resolveValuationSeries(
-  seriesId: string,
-  loader: ValuationSeriesLoader = defaultValuationSeriesLoader,
-): Promise<ResolvedSeries> {
-  const indicator = findIndicator(seriesId);
-  if (indicator.id !== seriesId.trim().toLowerCase()) {
-    throw new Error(`Unknown valuation series ${seriesId}`);
-  }
-
+): Promise<SeriesLoadResult> {
   const unavailable = indicatorUnavailableReason(indicator);
   if (unavailable) throw new Error(unavailable);
   const legs = new Map<string, DatedSeries>();
@@ -74,26 +37,23 @@ export async function resolveValuationSeries(
   if (built.points.at(-1)?.ratio == null) {
     warnings.push(`${indicator.label}: latest observation unavailable (${built.points.at(-1)!.date})`);
   }
-  const points: TimeSeriesPoint[] = built.points.map((point) => {
-    const date = new Date(point.date);
-    return { date, observedAt: date, value: point.ratio };
-  });
-
   return {
-    id: `market-valuation:${indicator.id}`,
-    label: indicator.label,
-    color: colors.textBright,
-    // Source percentages need the same units as ratios scaled into percentages.
-    unit: indicator.axisUnit === "%" ? "%" : "x",
-    unitGroup: indicator.axisUnit === "%" ? "valuation-percent" : "valuation-ratio",
-    nativeFrequency: "daily",
-    dataShape: "scalar",
-    style: "line",
-    transform: "raw",
-    axis: "left",
-    panelId: "main",
-    interpolation: "none",
+    points: built.points.map((point) => ({ date: point.date, value: point.ratio })),
     ...(warnings.length ? { warning: warnings.join("; ") } : {}),
-    points,
   };
 }
+
+export function valuationSeriesDefinitions(
+  loader: ValuationSeriesLoader = defaultValuationSeriesLoader,
+): SeriesDefinition[] {
+  return INDICATORS.map((indicator) => ({
+    id: `${MARKET_VALUATION_NAMESPACE}:${indicator.id}`,
+    name: indicator.label,
+    unit: indicator.axisUnit === "%" ? "%" : "x",
+    frequency: indicatorFrequency(indicator),
+    group: "Valuation",
+    tags: [indicator.shortLabel, "market valuation"],
+    description: indicator.description,
+    load: () => loadValuationIndicator(indicator, loader),
+  }));
+}

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

@@ -1,6 +1,6 @@
 import type { PluginModule } from "../plugin-module";
 import { valuationCache } from "./cache";
-import { createValuationChartSeriesCapability } from "./chart-series";
+import { valuationSeriesDefinitions } from "./chart-series";
 import { INDICATORS, resolveIndicatorArg } from "./indicators";
 import { marketValuationHeadless } from "./headless";
 import { MarketValuationPane } from "./pane";
@@ -35,8 +35,8 @@ const KEYWORDS = [...new Set([
 ])];
 
 export const marketValuationModule: PluginModule = {
-  // Exposes each ratio as a chartable series, so G can overlay them on anything else.
-  capabilities: [createValuationChartSeriesCapability()],
+  // Each ratio is a catalog series, so G can overlay them on anything else.
+  series: valuationSeriesDefinitions(),
   panes: [{
     id: MARKET_VALUATION_PANE_ID,
     name: "Market Valuation",

package/src/plugins/builtin/market-valuation/indicators.ts

@@ -370,11 +370,6 @@ export const INDICATORS: readonly IndicatorDef[] = [
 
 export const DEFAULT_INDICATOR_ID = BUFFETT_INDICATOR.id;
 
-export function findIndicator(id: string | null | undefined): IndicatorDef {
-  const normalized = id?.trim().toLowerCase();
-  return INDICATORS.find((entry) => entry.id === normalized) ?? BUFFETT_INDICATOR;
-}
-
 /** Resolves shortcut arguments like `VAL cape` or `VAL buffett` onto an indicator. */
 export function resolveIndicatorArg(arg: string | null | undefined): IndicatorDef | null {
   const query = arg?.trim().toLowerCase();