gloomberb 0.16.3 → 0.16.5

package/src/plugins/builtin/sectors/index.tsx

@@ -12,6 +12,7 @@ import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import type { Quote } from "../../../types/financials";
+import type { ExtendedSession } from "../../../market-data/market/status";
 import { useAutoRefresh, useUpdatedAgo } from "../../../react/auto-refresh";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
 import { isStreamCarryingQuote, useVisibleBoardSymbols } from "../shared/use-quote-board";
@@ -33,6 +34,7 @@ import {
   nextSortPreference,
   normalizeRowsForCollection,
   overlayLiveSectorQuote,
+  sectorExtendedSessions,
   sectorRowFollowsQuote,
   sectorRowIssues,
   sortRows,
@@ -149,7 +151,6 @@ function EtfBoard({ collectionId, focused, width, height, rootBefore }: EtfBoard
   const fetchGenRef = useRef(0);
   const [loadError, setLoadError] = useState<string | null>(null);
 
-  const columns = useMemo(() => buildSectorColumns(width), [width]);
   const rows = useMemo(
     () => normalizeRowsForCollection(rowsByCollection, activeCollection.id, activeItems),
     [activeCollection.id, activeItems, rowsByCollection],
@@ -203,6 +204,12 @@ function EtfBoard({ collectionId, focused, width, height, rootBefore }: EtfBoard
     return carried && !!quote && sectorRowFollowsQuote(row, quote);
   }), [freshnessNow, liveEntries, liveStreaming, rows, subscriptionStartedAt]);
   const sortedRows = useMemo(() => sortRows(liveRows, sortPreference), [liveRows, sortPreference]);
+  // A pre-market or after-hours column only while a fund has such a print.
+  const extendedSessionsKey = sectorExtendedSessions(liveRows).join(",");
+  const columns = useMemo(
+    () => buildSectorColumns(width, extendedSessionsKey ? extendedSessionsKey.split(",") as ExtendedSession[] : []),
+    [extendedSessionsKey, width],
+  );
   const lastRefreshMs = lastRefreshByCollection[activeCollection.id] ?? null;
   const loading = rows.some((row) => row.loading);
   /**
@@ -296,6 +303,16 @@ function EtfBoard({ collectionId, focused, width, height, rootBefore }: EtfBoard
           text: row.changePercent !== null ? formatPercentRaw(shownPercent(row.changePercent)) : "—",
           color: row.changePercent !== null ? priceColor(shownPercent(row.changePercent)) : colors.textDim,
         };
+      case "preMarket":
+      case "afterHours": {
+        // The extended print's move from the close in LAST.
+        const move = row.extendedSession === (column.id === "preMarket" ? "PRE" : "POST") ? row.extendedChangePercent ?? null : null;
+        return {
+          text: move !== null ? formatPercentRaw(shownPercent(move)) : "—",
+          value: move,
+          color: move !== null ? priceColor(shownPercent(move)) : colors.textDim,
+        };
+      }
       case "return1M":
         return {
           text: row.loading && row.return1M === null ? "…" : row.return1M !== null ? formatPercentRaw(shownPercent(row.return1M)) : "—",

package/src/plugins/builtin/sectors/sector-model.ts

@@ -1,8 +1,15 @@
 import type { DataTableColumn } from "../../../components";
+import { getTableWidth, tableColumnWidth } from "../../../components/ui/table-layout";
 import type { PricePoint, Quote } from "../../../types/financials";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
 import { getPricePointTimestamp } from "../../../utils/price-history";
 import { mergePriceHistoryIntegrity, pricePointIntegrity, type PriceHistoryIntegrity } from "../../../utils/price-history-integrity";
+import {
+  getExtendedSessionDisplay,
+  getRegularSessionDisplay,
+  marketStateLabel,
+  type ExtendedSession,
+} from "../../../market-data/market/status";
 import {
   getSectorCollection,
   type SectorCollectionId,
@@ -12,8 +19,21 @@ import {
 const DAY_MS = 24 * 60 * 60 * 1000;
 export const DEFAULT_COLLECTION_ID: SectorCollectionId = "sectors";
 
-export interface SectorRow extends SectorDef {
+/**
+ * The pre-market or after-hours print beside a row's regular close, measured
+ * from that close (getExtendedSessionDisplay); all null without one.
+ */
+export interface SectorExtendedFields {
+  extendedSession?: ExtendedSession | null;
+  extendedPrice?: number | null;
+  extendedChange?: number | null;
+  extendedChangePercent?: number | null;
+}
+
+export interface SectorRow extends SectorDef, SectorExtendedFields {
+  /** The regular session's price: its close once it is over, never an extended print. */
   price: number | null;
+  /** The regular session's move, as `ticker` reports it. */
   changePercent: number | null;
   return1M: number | null;
   return1Y: number | null;
@@ -33,7 +53,7 @@ export interface SectorRow extends SectorDef {
   return1YStartDate?: string | null;
 }
 
-type SectorColumnId = "name" | "etf" | "price" | "changePercent" | "return1M" | "return1Y" | "bar";
+type SectorColumnId = "name" | "etf" | "price" | "changePercent" | "preMarket" | "afterHours" | "return1M" | "return1Y" | "bar";
 export type SectorColumn = DataTableColumn & { id: SectorColumnId };
 export type SectorRowsByCollection = Record<SectorCollectionId, SectorRow[]>;
 export type SectorRefreshByCollection = Partial<Record<SectorCollectionId, number>>;
@@ -48,6 +68,45 @@ export const DEFAULT_SORT_PREFERENCE: SectorSortPreference = {
   direction: "desc",
 };
 
+const NO_EXTENDED_PRINT: Required<SectorExtendedFields> = {
+  extendedSession: null,
+  extendedPrice: null,
+  extendedChange: null,
+  extendedChangePercent: null,
+};
+
+/** A quote's pre-market or after-hours print, from the regular close a row shows, as row fields. */
+export function sectorExtendedFields(quote: Quote | null | undefined): Required<SectorExtendedFields> {
+  const extended = getExtendedSessionDisplay(quote);
+  if (!extended || !Number.isFinite(extended.price)) return NO_EXTENDED_PRINT;
+  return {
+    extendedSession: extended.session,
+    extendedPrice: extended.price,
+    extendedChange: Number.isFinite(extended.change) ? extended.change! : null,
+    extendedChangePercent: Number.isFinite(extended.changePercent) ? extended.changePercent! : null,
+  };
+}
+
+function extendedFieldsOf(row: SectorExtendedFields | undefined): Required<SectorExtendedFields> {
+  return {
+    extendedSession: row?.extendedSession ?? null,
+    extendedPrice: row?.extendedPrice ?? null,
+    extendedChange: row?.extendedChange ?? null,
+    extendedChangePercent: row?.extendedChangePercent ?? null,
+  };
+}
+
+function sameExtended(left: SectorExtendedFields, right: SectorExtendedFields): boolean {
+  return (left.extendedSession ?? null) === (right.extendedSession ?? null)
+    && (left.extendedPrice ?? null) === (right.extendedPrice ?? null)
+    && (left.extendedChangePercent ?? null) === (right.extendedChangePercent ?? null);
+}
+
+/** The extended sessions some row has a print for, in the order their columns go. */
+export function sectorExtendedSessions(rows: readonly SectorExtendedFields[]): ExtendedSession[] {
+  return (["PRE", "POST"] as const).filter((session) => rows.some((row) => row.extendedSession === session));
+}
+
 /** Full length at a 5% session move, which covers all but crash days. */
 const MOVE_BAR_FULL_SCALE_PERCENT = 5;
 
@@ -99,6 +158,7 @@ export function normalizeRowsForCollection(
       quoteIssue: existing?.quoteIssue ?? null,
       lastReportedPrice: existing?.lastReportedPrice ?? null,
       quoteUpdatedAt: existing?.quoteUpdatedAt ?? null,
+      ...extendedFieldsOf(existing),
       returnIntegrity: existing?.returnIntegrity ?? {},
       returnAsOfDate: existing?.returnAsOfDate ?? null,
       return1MStartDate: existing?.return1MStartDate ?? null,
@@ -138,6 +198,7 @@ const UNAVAILABLE_SECTOR_ROW: Partial<SectorRow> = {
   lastReportedPrice: null,
   quoteUpdatedAt: null,
   returnIntegrity: {},
+  ...NO_EXTENDED_PRINT,
 };
 
 function sameSectorRow(left: SectorRow, right: SectorRow): boolean {
@@ -276,33 +337,49 @@ export function sectorRowIssues(row: SectorRow): string[] {
   return issues;
 }
 
-export function buildSectorColumns(width: number): SectorColumn[] {
-  const etfWidth = 4;
-  const priceWidth = 8;
-  const changeWidth = 8;
-  const returnWidth = 8;
-  const showBar = width >= 67;
-  const compactBar = width < 82;
-  const barWidth = showBar
-    ? compactBar ? 6 : Math.max(8, Math.min(18, Math.floor(width * 0.16)))
-    : 0;
-  const columnCount = showBar ? 7 : 6;
-  const fixedWidth = etfWidth + priceWidth + changeWidth + returnWidth * 2 + barWidth;
-  const nameWidth = Math.max(10, Math.min(22, width - 2 - columnCount - fixedWidth));
-
-  const columns: SectorColumn[] = [
-    { id: "name", label: "SECTOR", width: nameWidth, align: "left", flexGrow: 1 },
-    { id: "etf", label: "ETF", width: etfWidth, align: "left" },
-    { id: "price", label: "LAST", width: priceWidth, align: "right" },
-    { id: "changePercent", label: "1D", width: changeWidth, align: "right" },
-    { id: "return1M", label: "1M", width: returnWidth, align: "right" },
-    { id: "return1Y", label: "1Y", width: returnWidth, align: "right" },
+const EXTENDED_COLUMN_WIDTH = 9;
+/** The longest name in either collection ("Consumer Staples"), which a narrow pane keeps whole as long as it can. */
+const FULL_NAME_WIDTH = 16;
+
+/**
+ * The board's columns at `width`. A pre-market or after-hours column follows
+ * 1D for each session in `extendedSessions`. A narrow pane gives up the move
+ * bar first, then that column, before it cuts a sector's name.
+ */
+export function buildSectorColumns(width: number, extendedSessions: readonly ExtendedSession[] = []): SectorColumn[] {
+  const lead: SectorColumn[] = [
+    { id: "etf", label: "ETF", width: 4, align: "left" },
+    { id: "price", label: "LAST", width: 8, align: "right" },
+    { id: "changePercent", label: "1D", width: 8, align: "right" },
+  ];
+  const returns: SectorColumn[] = [
+    { id: "return1M", label: "1M", width: 8, align: "right" },
+    { id: "return1Y", label: "1Y", width: 8, align: "right" },
+  ];
+  const extendedColumns = extendedSessions.map((session): SectorColumn => ({
+    id: session === "PRE" ? "preMarket" : "afterHours",
+    // Named for the session it trades in, as the header labels it.
+    label: marketStateLabel(session),
+    width: EXTENDED_COLUMN_WIDTH,
+    align: "right",
+  }));
+  // Measured the way the table draws them (a header and its sort mark widen a
+  // column, gaps between them); the name adds its own width and a gap.
+  const nameRoom = (columns: SectorColumn[]) => width - getTableWidth(columns) - 1;
+  const shownExtended = extendedColumns.length > 0 && nameRoom([...lead, ...extendedColumns, ...returns]) >= FULL_NAME_WIDTH
+    ? extendedColumns
+    : [];
+  const extendedWidth = shownExtended.reduce((total, column) => total + tableColumnWidth(column) + 1, 0);
+  const barWidth = width - extendedWidth < 82 ? 6 : Math.max(8, Math.min(18, Math.floor(width * 0.16)));
+  // Labelled with the window it encodes: it sits after 1Y but tracks 1D.
+  const bar: SectorColumn = { id: "bar", label: "1D MOVE", width: barWidth, align: "left" };
+  const withBar = [...lead, ...shownExtended, ...returns, bar];
+  const showBar = width - extendedWidth >= 67 && nameRoom(withBar) >= FULL_NAME_WIDTH;
+  const columns = showBar ? withBar : [...lead, ...shownExtended, ...returns];
+  return [
+    { id: "name", label: "SECTOR", width: Math.max(10, Math.min(22, nameRoom(columns))), align: "left", flexGrow: 1 },
+    ...columns,
   ];
-  if (showBar) {
-    // Labelled with the window it encodes: it sits after 1Y but tracks 1D.
-    columns.push({ id: "bar", label: "1D MOVE", width: barWidth, align: "left" });
-  }
-  return columns;
 }
 
 function getSortValue(columnId: SectorColumnId, row: SectorRow): string | number | null {
@@ -315,6 +392,9 @@ function getSortValue(columnId: SectorColumnId, row: SectorRow): string | number
       return row.price;
     case "changePercent":
       return row.changePercent;
+    case "preMarket":
+    case "afterHours":
+      return row.extendedSession === (columnId === "preMarket" ? "PRE" : "POST") ? row.extendedChangePercent ?? null : null;
     case "return1M":
       return row.return1M;
     case "return1Y":
@@ -338,6 +418,8 @@ export function nextSortPreference(current: SectorSortPreference, columnId: stri
     return {
       columnId: typedColumnId,
       direction: typedColumnId === "changePercent"
+        || typedColumnId === "preMarket"
+        || typedColumnId === "afterHours"
         || typedColumnId === "return1M"
         || typedColumnId === "return1Y"
         || typedColumnId === "bar"
@@ -373,17 +455,30 @@ export function sectorQuoteSessionDate(quote: Quote): string | null {
 /**
  * A live quote extends a loaded row only inside the session its returns are
  * measured to. Every fund shares that session, so a pre-market print (the
- * next session) or a quote older than the snapshot leaves the row alone and
- * the board keeps ranking on one completed session. The 1M and 1Y returns
- * keep their baselines: the row's own return and price imply the start close.
+ * next session) or a quote older than the snapshot leaves the row's price
+ * alone and the board keeps ranking on one completed session. The 1M and 1Y
+ * returns keep their baselines: the row's own return and price imply the
+ * start close.
  */
 function isLiveSectorQuote(row: SectorRow, quote: Quote | null | undefined): quote is Quote {
-  if (!quote || quote.stale === true || !finitePositive(quote.price)) return false;
-  if (!finitePositive(row.price) || !row.returnAsOfDate) return false;
-  if (row.quoteUpdatedAt != null && quote.lastUpdated < row.quoteUpdatedAt) return false;
+  if (!isCurrentSectorQuote(row, quote) || !finitePositive(getRegularSessionDisplay(quote)?.price)) return false;
   return sectorQuoteSessionDate(quote) === row.returnAsOfDate;
 }
 
+/** A usable quote no older than the snapshot behind a loaded row. */
+function isCurrentSectorQuote(row: SectorRow, quote: Quote | null | undefined): quote is Quote {
+  if (!quote || quote.stale === true) return false;
+  if (!finitePositive(row.price) || !row.returnAsOfDate) return false;
+  return row.quoteUpdatedAt == null || quote.lastUpdated >= row.quoteUpdatedAt;
+}
+
+/** A pre-market print of the session after the row's, which moves only the extended column. */
+function isNextPreMarketQuote(row: SectorRow, quote: Quote): boolean {
+  if (quote.marketState !== "PRE" && quote.marketState !== "PREPRE") return false;
+  const session = sectorQuoteSessionDate(quote);
+  return !!session && !!row.returnAsOfDate && session > row.returnAsOfDate;
+}
+
 /**
  * Whether the feed keeps a loaded row as current as a snapshot reload would,
  * given a quote the feed is carrying. It does when the quote belongs to the
@@ -402,18 +497,32 @@ export function sectorRowFollowsQuote(row: SectorRow, quote: Quote): boolean {
   return quote.marketState === "PRE" || quote.marketState === "PREPRE";
 }
 
+/**
+ * A row with the feed's quote on it. Price and 1D are the regular session,
+ * as `ticker` reads them, so they hold at the close; a pre-market or
+ * after-hours print moves only the extended column, measured from that close.
+ */
 export function overlayLiveSectorQuote(row: SectorRow, quote: Quote | null | undefined): SectorRow {
-  if (!isLiveSectorQuote(row, quote) || row.price == null) return row;
-  const changePercent = Number.isFinite(quote.changePercent) ? quote.changePercent : row.changePercent;
-  if (quote.price === row.price && changePercent === row.changePercent) return row;
-  const scale = quote.price / row.price;
-  const rescale = (value: number | null) => (value == null ? null : ((1 + value / 100) * scale - 1) * 100);
+  if (!isCurrentSectorQuote(row, quote) || row.price == null) return row;
+  if (!isLiveSectorQuote(row, quote)) {
+    if (!isNextPreMarketQuote(row, quote)) return row;
+    const extended = sectorExtendedFields(quote);
+    return sameExtended(extended, row) ? row : { ...row, ...extended };
+  }
+  const headline = getRegularSessionDisplay(quote)!;
+  const extended = sectorExtendedFields(quote);
+  const changePercent = Number.isFinite(headline.changePercent) ? headline.changePercent! : row.changePercent;
+  if (headline.price === row.price && changePercent === row.changePercent && sameExtended(extended, row)) return row;
+  const scale = headline.price / row.price;
+  // A held close leaves the returns exactly as they were.
+  const rescale = (value: number | null) => (value == null || scale === 1 ? value : ((1 + value / 100) * scale - 1) * 100);
   return {
     ...row,
-    price: quote.price,
-    lastReportedPrice: quote.price,
+    price: headline.price,
+    lastReportedPrice: headline.price,
     changePercent,
     return1M: rescale(row.return1M),
     return1Y: rescale(row.return1Y),
+    ...extended,
   };
 }

package/src/plugins/builtin/series-inventory.ts

@@ -0,0 +1,91 @@
+/**
+ * Every chart a built-in pane draws, and whether its series is in the data
+ * catalog. `series-inventory.test.ts` fails when a module starts drawing a
+ * chart without an entry here, when an entry names a series nobody
+ * registers, or when a built-in registers a series this list does not name,
+ * so the audit cannot drift from the code.
+ *
+ * `series` lists catalog ids, with a trailing `*` for a prefix. A chart that
+ * is not in the catalog says why:
+ * - `not-a-time-series`: plotted against something other than dates (a
+ *   curve by maturity, a surface, a treemap, strikes, a distribution).
+ * - `derived`: a chart composer study draws it from catalog series
+ *   (correlation, realized volatility, a spread between two tickers).
+ * - `per-item`: one deal, trial, filing or model run, with no stable id to list.
+ * - `account`: built from the user's own portfolio or inputs.
+ * - `not-yet`: a dated series that could be registered and is not yet.
+ */
+type SeriesInventoryStatus =
+  /** `runtime`: registered while the app runs (files, accounts), so none exist in a test. */
+  | { series: readonly string[]; runtime?: true }
+  | { notInCatalog: "not-a-time-series" | "derived" | "per-item" | "account" | "not-yet"; reason: string };
+
+export type SeriesInventoryEntry = SeriesInventoryStatus & {
+  /** The module's folder under `src/plugins/builtin`. */
+  module: string;
+  /** What the pane draws. */
+  chart: string;
+};
+
+export const SERIES_INVENTORY: readonly SeriesInventoryEntry[] = [
+  { module: "chart-composer", chart: "Any ticker field: price, volume, fundamentals, valuation multiples", series: ["field:*", "option:*"] },
+  { module: "chart-composer", chart: "CSV files in the profile's series folder", series: ["user:*"], runtime: true },
+  { module: "ticker-detail", chart: "Price history and the overview's sparklines", series: ["field:market.*"] },
+  { module: "fear-greed", chart: "Fear & Greed index and its seven indicator charts, with their moving averages", series: ["fear-greed:*"] },
+  { module: "volatility", chart: "VIX curve history, the 3M/30D ratio and the cross-asset volatility board", series: ["volatility:*", "fred:VIXCLS", "fred:VXVCLS"] },
+  { module: "iv-history", chart: "A ticker's implied volatility by tenor", series: ["implied-vol:*"] },
+  { module: "realized-vol", chart: "Realized volatility cone and rolling windows", notInCatalog: "derived", reason: "The composer's realized volatility study draws it from any price series." },
+  { module: "vol-surface", chart: "Implied volatility surface by strike and expiry", notInCatalog: "not-a-time-series", reason: "A surface over strike and tenor." },
+  { module: "options-positioning", chart: "Open interest and gamma by strike and expiry", notInCatalog: "not-a-time-series", reason: "Plotted by strike and expiry, not by date." },
+  { module: "options-scenario", chart: "Option payoff by underlying price", notInCatalog: "not-a-time-series", reason: "A payoff curve over prices." },
+  { module: "kelly-sizer", chart: "Position size against win rate", notInCatalog: "account", reason: "Drawn from the inputs typed into the sizer." },
+  { module: "yield-curve", chart: "Treasury curve and each maturity's history", series: ["ust:*", "fred:T10Y2Y", "fred:T10Y3M", "fred:DFII*"] },
+  { module: "yield-curve", chart: "Government curves for Germany, the UK, Japan, Canada and euro AAA", series: ["bond-yield:*"] },
+  { module: "rate-path", chart: "Implied policy path by meeting", notInCatalog: "not-a-time-series", reason: "A path over future meetings; the rates it starts from are FRED series in the catalog." },
+  { module: "money-markets", chart: "Money market rates, bill yields, liquidity and net liquidity", series: ["money-markets:*", "fred:SOFR", "fred:EFFR", "fred:IORB", "fred:OBFR", "fred:DTB*", "fred:RRPONTSYD", "fred:WDTGAL", "fred:WRESBAL", "fred:WALCL"] },
+  { module: "central-bank-rates", chart: "Policy rate history for each central bank", series: ["policy-rate:*"] },
+  { module: "econ", chart: "Release history of each economic calendar event", series: ["fred:*"] },
+  { module: "econ-statistics", chart: "Inflation, labor and growth statistics with their ranges", series: ["fred:CPIAUCNS", "fred:CPILFENS", "fred:PCEPI", "fred:PCEPILFE", "fred:PPIFID", "fred:UNRATE", "fred:PAYEMS", "fred:ICSA", "fred:JTSJOL", "fred:GDPC1", "fred:INDPRO"] },
+  { module: "cpi", chart: "CPI components, month on month and year on year", series: ["fred:CPI*", "fred:CUSR*"] },
+  { module: "market-valuation", chart: "Whole-market valuation ratios against their history", series: ["market-valuation:*"] },
+  { module: "credit-conditions", chart: "Corporate bond spreads by rating", series: ["fred:BAML*"] },
+  { module: "credit-boards", chart: "Index CDS (CDX, iTraxx) and sovereign 5Y CDS", series: ["cdx:*", "sovereign-cds:*"] },
+  { module: "cds", chart: "A company's 5Y CDS spread", series: ["cds:*"] },
+  { module: "credit-documents", chart: "Principal due by year", notInCatalog: "not-a-time-series", reason: "A maturity schedule, not a history." },
+  { module: "debt-maturities", chart: "A company's principal and the share due soon, across annual filings", series: ["debt-maturities:*"] },
+  { module: "debt-maturities", chart: "A company's maturity wall", notInCatalog: "not-a-time-series", reason: "A schedule by maturity year from one filing; its total and near-term shares across filings are in the catalog." },
+  { module: "doe", chart: "Weekly oil and gas inventories against their five-year range", series: ["doe:*"] },
+  { module: "cot", chart: "Net positioning by trader class, over the front-month price", series: ["cot:*"] },
+  { module: "futures", chart: "Front-month futures board, charted from the board", series: ["fut:*"] },
+  { module: "futures-curve", chart: "Futures curve by contract month", notInCatalog: "not-a-time-series", reason: "Plotted by delivery month; each front month is in the catalog as FUT:code." },
+  { module: "crypto-board", chart: "Price sparklines for the large coins", series: ["crypto:*"] },
+  { module: "perps", chart: "Perpetual funding, open interest, premium and long/short account share", series: ["perps:*"] },
+  { module: "perps", chart: "Perpetual mark price", notInCatalog: "not-yet", reason: "The pair's price is in the catalog; the perpetual's own mark price could be a crypto series." },
+  { module: "short-interest", chart: "A ticker's short interest and days to cover", series: ["short-interest:*"] },
+  { module: "short-volume", chart: "A ticker's daily short volume ratio", series: ["short-volume:*"] },
+  { module: "social-mentions", chart: "A ticker's daily posts", series: ["social-mentions:*"] },
+  { module: "jobs", chart: "A company's open job postings", series: ["jobs:*"] },
+  { module: "attention", chart: "Research hours on a ticker, hour by hour", series: ["attention:*"] },
+  { module: "company-attention", chart: "A company's weekly open roles and daily app attention score", series: ["hiring:*", "app-attention:*"] },
+  { module: "gpu", chart: "GPU rental list index per model", series: ["gpu:*"] },
+  { module: "gpu", chart: "GPU rental prices per provider listing", notInCatalog: "per-item", reason: "One provider listing each, listed by the server and changing without a release." },
+  { module: "power", chart: "Interconnection queue capacity and project generation", notInCatalog: "per-item", reason: "Per project and per queue filter." },
+  { module: "awards", chart: "A company's government award totals by period", series: ["awards:*"] },
+  { module: "company-kpis", chart: "A company's reported operating metrics", notInCatalog: "per-item", reason: "Each company reports its own metrics, with no shared list to register." },
+  { module: "estimate-revisions", chart: "Consensus estimate for one fiscal period over time", notInCatalog: "per-item", reason: "One fiscal period of one company." },
+  { module: "earnings", chart: "Implied and actual moves around past earnings", notInCatalog: "per-item", reason: "One bar per earnings event." },
+  { module: "dividend-yield", chart: "A ticker's trailing 12-month cash dividends", series: ["dividends:*"] },
+  { module: "pe-band", chart: "Price against P/E multiples", notInCatalog: "derived", reason: "The composer charts price and the P/E fields for any ticker." },
+  { module: "research", chart: "Analyst price targets over price", notInCatalog: "per-item", reason: "Targets are dated events on one ticker." },
+  { module: "catalysts", chart: "Clinical trial enrollment", notInCatalog: "per-item", reason: "One trial." },
+  { module: "mna", chart: "Deal spread for one merger", notInCatalog: "per-item", reason: "One deal." },
+  { module: "correlation", chart: "Rolling correlation of two tickers and the matrix", notInCatalog: "derived", reason: "The composer's correlation study draws it for any two series." },
+  { module: "relative-rotation", chart: "Relative strength and momentum against a benchmark", notInCatalog: "derived", reason: "Built from two price series; the rotation plot is not dated." },
+  { module: "seasonality", chart: "Average returns by month and weekday", notInCatalog: "not-a-time-series", reason: "Plotted by calendar month, not by date." },
+  { module: "backtest", chart: "A strategy's equity curve", notInCatalog: "account", reason: "One run of the user's own strategy settings." },
+  { module: "analytics", chart: "Portfolio value, drawdown and factor exposure", notInCatalog: "account", reason: "Built from the user's own portfolio; the factor legs are tickers in the catalog." },
+  { module: "holders", chart: "Holders treemap", notInCatalog: "not-a-time-series", reason: "A treemap of one filing date." },
+  { module: "market-heatmap", chart: "Market heat map", notInCatalog: "not-a-time-series", reason: "A treemap of today's moves." },
+  { module: "portfolio-list", chart: "Portfolio treemap", notInCatalog: "not-a-time-series", reason: "A treemap of current positions." },
+  { module: "world-venue-map", chart: "Chokepoint transits and the map's place series", series: ["geo:*"] },
+];

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

@@ -12,7 +12,7 @@ import { requestAccountManagementTab } from "../account-management/navigation";
 import { resolvePlanAccess, usePlanAccess, type PlanAccess } from "../../../api-client/plan-access";
 import { useViewport } from "../../../react/input";
 import { useOptionalDialog } from "../../../ui/dialog";
-import { promptCloudUpgrade } from "../cloud/upgrade-dialog";
+import { promptCloudUpgrade } from "../../../account/upgrade-dialog";
 
 const CLOUD_UPGRADE_URL = "https://gloom.sh/cloud?upgrade=pro";
 

package/src/plugins/builtin/shared/command-tab.ts

@@ -0,0 +1,69 @@
+import { useEffect, useRef } from "react";
+import { usePluginPaneState } from "../../../public/react";
+import { usePaneInstance } from "../../../state/app/context";
+import type { PaneTemplateDef, PaneTemplateInstanceConfig } from "../../../types/plugin";
+
+/**
+ * A command's request (a market, a record), stamped so a later command can ask again: a pane the command reuses
+ * sees the newer stamp even when it asks for the same thing.
+ */
+export function commandRequestParams(params: Record<string, string>): Record<string, string> {
+  return { ...params, tabAt: String(Date.now()) };
+}
+
+/** A command's request to show one tab, stamped so a later command can ask again. */
+export function commandTabParams(tab: string, params?: Record<string, string>): Record<string, string> {
+  return commandRequestParams({ ...(params ?? {}), tab });
+}
+
+/** The template's pane, with the command's tab written onto the instance. */
+function stampCommandTab(instance: PaneTemplateInstanceConfig | null, tab: string): PaneTemplateInstanceConfig | null {
+  return instance ? { ...instance, params: commandTabParams(tab, instance.params) } : null;
+}
+
+export function withCommandTab(template: PaneTemplateDef, tab: string): PaneTemplateDef {
+  const create = template.createInstance;
+  return {
+    ...template,
+    createInstance: (context, options) => {
+      const created = create?.(context, options);
+      if (!created) return null;
+      return created instanceof Promise ? created.then((instance) => stampCommandTab(instance, tab)) : stampCommandTab(created, tab);
+    },
+  };
+}
+
+/**
+ * A value a command asked this pane to show, kept in pane state like a choice made in the pane: the stored
+ * choice wins until a newer command arrives. `read` takes the value from the command's params, null when the
+ * command names none. Another pane's params, such as Ticker Research around a nested tab, are ignored.
+ */
+export function useCommandValue<T>(
+  paneId: string,
+  stateKey: string,
+  read: (params: Readonly<Record<string, string>>) => T | null,
+  fallback: T,
+): [T, (next: T) => void] {
+  const instance = usePaneInstance();
+  const params = instance?.paneId === paneId ? instance.params : undefined;
+  const requested = params ? read(params) : null;
+  const requestAt = params?.tabAt ?? "";
+  const [value, setValue] = usePluginPaneState<T>(stateKey, requested ?? fallback);
+  const seen = useRef(requestAt);
+  useEffect(() => {
+    if (requested === null || requestAt === seen.current) return;
+    seen.current = requestAt;
+    setValue(requested);
+  }, [requestAt, requested, setValue]);
+  return [value, setValue];
+}
+
+/** The tab a command asked this pane to show, one of `tabs`. */
+export function useCommandTab<T extends string>(
+  paneId: string,
+  stateKey: string,
+  tabs: readonly T[],
+  fallback: T,
+): [T, (next: T) => void] {
+  return useCommandValue<T>(paneId, stateKey, (params) => (tabs as readonly string[]).includes(params.tab ?? "") ? params.tab as T : null, fallback);
+}

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

@@ -0,0 +1,55 @@
+import type { EarningsDateStatus, EarningsEpsBasis } from "../../../types/financials";
+
+/**
+ * How every earnings surface (ERN, EE, the corporate-actions events and
+ * their headless rows) reads and names a reported quarter's EPS basis and a
+ * report date's status. Gloom Cloud resolves one figure per quarter; this
+ * keeps the panes from naming it differently.
+ */
+
+const BASES: ReadonlySet<string> = new Set<EarningsEpsBasis>(["gaap", "adjusted"]);
+const STATUSES: ReadonlySet<string> = new Set<EarningsDateStatus>(["reported", "confirmed", "projected"]);
+
+/** A server value read defensively: anything unrecognised is an unknown basis. */
+export function earningsEpsBasis(value: unknown): EarningsEpsBasis | null {
+  return typeof value === "string" && BASES.has(value) ? value as EarningsEpsBasis : null;
+}
+
+export function earningsDateStatus(value: unknown): EarningsDateStatus | null {
+  return typeof value === "string" && STATUSES.has(value) ? value as EarningsDateStatus : null;
+}
+
+/** The per-ticker calendar flags an estimated date; it says nothing about a date it does not flag. */
+export function dateStatusFromEstimateFlag(isDateEstimate: boolean | null | undefined): EarningsDateStatus | null {
+  return isDateEstimate === true ? "projected" : isDateEstimate === false ? "confirmed" : null;
+}
+
+export type EpsBasisName = "GAAP" | "adjusted" | "unknown";
+
+/** What the basis names mean, in every report's metadata. */
+export const EPS_BASIS_NOTE = "One reported EPS per quarter. GAAP: the quarter's diluted statement EPS. adjusted: the consensus-basis figure the estimate is measured against, which leaves out items the statements include. unknown: no statement on a comparable share basis to tell.";
+
+/** The basis as rows, exports and tools name it. */
+export function epsBasisName(basis: EarningsEpsBasis | null): EpsBasisName {
+  return basis === "gaap" ? "GAAP" : basis === "adjusted" ? "adjusted" : "unknown";
+}
+
+/** The basis in a table cell or a detail line. */
+export function epsBasisShort(basis: EarningsEpsBasis | null): string {
+  return basis === "gaap" ? "GAAP" : basis === "adjusted" ? "adj" : "?";
+}
+
+/** Actual over estimate minus one, against the estimate's size so a negative estimate reads the right way. */
+export function epsSurprise(actual: number | null | undefined, estimate: number | null | undefined): number | null {
+  if (actual == null || estimate == null || estimate === 0) return null;
+  return (actual - estimate) / Math.abs(estimate);
+}
+
+/** A fiscal quarter end month (YYYY-MM) holds a period end in that month, or a 52/53-week end a few days either side. */
+export function inFiscalMonth(periodEnd: string | null | undefined, fiscalPeriod: string | null | undefined): boolean {
+  const month = /^(\d{4})-(\d{2})$/.exec(fiscalPeriod ?? "");
+  const end = Date.parse(`${periodEnd ?? ""}T00:00:00Z`);
+  if (!month || !Number.isFinite(end)) return false;
+  const monthEnd = Date.UTC(Number(month[1]), Number(month[2]), 0);
+  return end >= monthEnd - 35 * 86_400_000 && end <= monthEnd + 10 * 86_400_000;
+}

package/src/plugins/builtin/shared/fred-points.ts

@@ -0,0 +1,20 @@
+import { apiClient } from "../../../api-client";
+import { loadCachedFredSeries } from "../../../sources/gloomberb-cloud/fred-series";
+
+/** A FRED series from `start` on, oldest first, through the shared FRED cache. */
+export async function loadFredPoints(seriesId: string, start?: Date): Promise<{
+  points: Array<{ date: string; value: number | null }>;
+  stale: boolean;
+  refreshError?: string;
+}> {
+  const startDate = start ? start.toISOString().slice(0, 10) : "1900-01-01";
+  const result = await loadCachedFredSeries(
+    { seriesId, startDate, sortOrder: "asc" },
+    () => apiClient.getCloudFredSeries(seriesId, { startDate, sortOrder: "asc" }),
+  );
+  return {
+    points: (result.data.observations ?? []).map((row) => ({ date: row.date, value: row.value })),
+    stale: result.stale,
+    ...(result.refreshError ? { refreshError: result.refreshError } : {}),
+  };
+}