gloomberb 0.17.2 → 0.17.4

package/src/plugins/builtin/equity-screener/live.ts

@@ -1,4 +1,4 @@
-import type { ScreenMetric, ScreenRow } from "../../../api-client/equity-screener";
+import type { ScreenDefinition, ScreenMetric, ScreenRow } from "../../../api-client/equity-screener";
 import { getExtendedSessionDisplay, type ExtendedSession, type ExtendedSessionDisplay } from "../../../market-data/market/status";
 import { quoteTradingDay } from "../../../market-data/quotes/day-range";
 import { getRegularSessionQuoteDisplay } from "../../../market-data/quotes/screener-live-quotes";
@@ -112,6 +112,32 @@ export function overlayScreenQuotes(rows: readonly ScreenRow[], quotes: Readonly
   return overlayRows(rows, (key) => quotes.get(key));
 }
 
+/** The fields a quote moves on a row (overlayLiveScreenRow). */
+const LIVE_SORT_FIELDS: ReadonlySet<string> = new Set(["price", "changePercent", "volume", "marketCap"]);
+
+/**
+ * Rows in the screen's order by the figures they show. A sort on a field the
+ * quotes move (price, change, volume, market cap) is redone on the overlaid
+ * values, so the column reads monotone: GRAB's snapshot cap, two closes old,
+ * kept it above MANH after its quote moved it below (GLO-754). Rows without a
+ * value stay last, and ties keep the snapshot's order. Any other sort is the
+ * snapshot's, which the overlay does not touch.
+ */
+export function sortLiveScreenRows<T extends ScreenRow>(rows: readonly T[], sort: ScreenDefinition["sort"]): T[] {
+  if (!LIVE_SORT_FIELDS.has(sort.field)) return [...rows];
+  const field = sort.field as "price" | "changePercent" | "volume" | "marketCap";
+  const sign = sort.direction === "desc" ? -1 : 1;
+  return rows
+    .map((row, index) => ({ row, index, value: row.metrics[field]?.value }))
+    .sort((a, b) => {
+      const aKnown = isFiniteNumber(a.value), bKnown = isFiniteNumber(b.value);
+      if (aKnown !== bKnown) return aKnown ? -1 : 1;
+      if (aKnown && bKnown && a.value !== b.value) return sign * (a.value! - b.value!);
+      return a.index - b.index;
+    })
+    .map(({ row }) => row);
+}
+
 /** The extended sessions some row has a print for, in the order their columns go. */
 export function screenExtendedSessions(rows: readonly LiveScreenRow[]): ExtendedSession[] {
   return (["PRE", "POST", "OVERNIGHT"] as const).filter((session) => rows.some((row) => row.extended?.session === session));

package/src/plugins/builtin/equity-screener/pane.tsx

@@ -48,6 +48,7 @@ import { EXTENDED_SESSION_LABELS, extendedSessionStateLabel, type ExtendedSessio
 import { useOpenDescription } from "../shared/open-description";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { INITIAL_STREAM_RANGE, streamWindowRows } from "../shared/use-quote-board";
+import { useSampledValue } from "../../../state/hooks/live-ticker-financials";
 import { usePlanAccess } from "../../../api-client/plan-access";
 import { SignInWall } from "../cloud/auth-actions";
 import { CriterionEditor } from "./criterion-editor";
@@ -71,12 +72,14 @@ import {
   screenRowId,
 } from "./model";
 import { useScreenResults } from "./results";
-import { overlayLiveScreenRows, screenExtendedMove, screenExtendedSessions, type LiveScreenRow } from "./live";
+import { overlayLiveScreenRows, screenExtendedMove, screenExtendedSessions, sortLiveScreenRows, type LiveScreenRow } from "./live";
 import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import { buildScreenerQuoteTargets } from "../../../market-data/quotes/screener-live-quotes";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
 import { getTableWidth } from "../../../components/ui/table-layout";
 
+/** How often a live sort re-reads the figures it orders by. */
+const LIVE_ORDER_SAMPLE_MS = 5_000;
 const TABS = [
   { value: "results", label: "Results" },
   { value: "criteria", label: "Criteria" },
@@ -290,7 +293,23 @@ function EquityScreenView({
     freshnessScopeKey: `equity-screener:${JSON.stringify(definition)}`,
     liveStreaming,
   });
-  const rows = useMemo(() => overlayLiveScreenRows(snapshotRows, liveEntries), [liveEntries, snapshotRows]);
+  const liveRows = useMemo(() => overlayLiveScreenRows(snapshotRows, liveEntries), [liveEntries, snapshotRows]);
+  // A sort on a field the quotes move is redone on the figures shown, so the
+  // column reads monotone. Re-sorting on every tick would reshuffle rows under
+  // the cursor; the order is taken from values sampled every few seconds,
+  // and at once when the screen or its pages change.
+  const orderRows = useSampledValue(
+    liveRows,
+    LIVE_ORDER_SAMPLE_MS,
+    `${data?.snapshot?.id ?? ""}:${JSON.stringify(definition.sort)}:${snapshotRows.length}`,
+  );
+  const rows = useMemo(() => {
+    const order = new Map(sortLiveScreenRows(orderRows, definition.sort).map((row, index) => [screenRowId(row), index]));
+    return liveRows
+      .map((row, index) => ({ row, index, place: order.get(screenRowId(row)) ?? Number.POSITIVE_INFINITY }))
+      .sort((a, b) => a.place - b.place || a.index - b.index)
+      .map(({ row }) => row);
+  }, [definition.sort, liveRows, orderRows]);
   const opened = rows.find((row) => screenRowId(row) === openId);
   const selected =
     opened ?? rows.find((row) => screenRowId(row) === selectedId) ?? rows[0];

package/src/plugins/builtin/fear-greed/charts.tsx

@@ -111,6 +111,7 @@ function SentimentPlot({
   valueFormat,
   updatedAt,
   overlays,
+  focused = false,
 }: {
   rating: FearGreedRating;
   points: FearGreedIndicator["points"];
@@ -118,6 +119,7 @@ function SentimentPlot({
   valueFormat: FearGreedValueFormat;
   updatedAt: Date | null;
   overlays?: StaticChartOverlay[];
+  focused?: boolean;
 }) {
   const chartWidth = Math.max(24, width - 2);
   const chartHeight = width >= 96 ? 12 : 10;
@@ -143,6 +145,7 @@ function SentimentPlot({
             mode="line"
             colors={palette}
             overlays={overlays}
+            focused={focused}
             showTimeAxis
             timeAxisColor={colors.textDim}
             yAxisColor={colors.textDim}
@@ -224,7 +227,7 @@ function ChartStats({
 
 // The gauge above already shows the score, its rating and what the series is,
 // so the history is the plot alone.
-export function IndexHistoryChart({ data, width }: { data: FearGreedData; width: number }) {
+export function IndexHistoryChart({ data, width, focused = false }: { data: FearGreedData; width: number; focused?: boolean }) {
   return (
     <Box flexDirection="column" paddingX={1}>
       <SentimentPlot
@@ -233,6 +236,7 @@ export function IndexHistoryChart({ data, width }: { data: FearGreedData; width:
         width={width}
         valueFormat="score"
         updatedAt={data.overall.updatedAt}
+        focused={focused}
       />
     </Box>
   );

package/src/plugins/builtin/fear-greed/pane.tsx

@@ -91,7 +91,7 @@ export function FearGreedPane({ paneId, focused, width, height }: PaneProps) {
             segments={FEAR_GREED_GAUGE_SEGMENTS}
             minWidth={isDesktopWeb ? Math.min(34, Math.max(1, width - 2)) : undefined}
           />
-          <IndexHistoryChart data={data} width={width} />
+          <IndexHistoryChart data={data} width={width} focused={focused} />
           <Box paddingX={1} marginTop={2}>
             <SectionHeading title="Indicators" />
           </Box>

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

@@ -1,6 +1,5 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
-  Button,
   DataTableView,
   PaneStatusBody,
   QueryBar,
@@ -28,6 +27,7 @@ import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
 import { quoteObservation } from "../shared/report-freshness";
 import {
   boardErrorMessage,
+  boardHeadlineQuote,
   quoteBoardFooterInfo,
   quoteBoardStatus,
   useQuoteBoard,
@@ -59,6 +59,7 @@ import {
   usesSessionText,
   type FuturesColumn,
 } from "./table";
+import { useFuturesBoardTerms } from "./use-board-terms";
 import { useFrontContractReturns } from "./use-front-returns";
 
 const FUTURES_PANE_ID = "futures";
@@ -134,6 +135,8 @@ export function FuturesPane({ focused, width, height }: PaneProps) {
   const paneVisible = usePaneVisible();
   const showsReturns = columns.some((column) => FUTURES_RETURN_COLUMNS[column.id]);
   const returns = useFrontContractReturns(listedContracts, quotes, dataProvider, showsReturns && paneVisible);
+  // The unit a price counts and the month a symbol rolled past, as `quote` reads them.
+  const terms = useFuturesBoardTerms(listedContracts, !!dataProvider && paneVisible);
 
   const visibleCollapsed = effectiveCollapsedSectors(collapsedSectors, searchQuery);
   const rows = useMemo(
@@ -141,15 +144,38 @@ export function FuturesPane({ focused, width, height }: PaneProps) {
       query: searchQuery,
       collapsed: collapsedSectors,
       returns,
+      terms,
     }),
-    [collapsedSectors, contractsBySector, quotes, returns, searchQuery, sortPreference],
+    [collapsedSectors, contractsBySector, quotes, returns, searchQuery, sortPreference, terms],
   );
 
   const sessionText = usesSessionText(width);
+  const quotesRef = useRef(quotes);
+  const returnsRef = useRef(returns);
+  const termsRef = useRef(terms);
+  quotesRef.current = quotes;
+  returnsRef.current = returns;
+  termsRef.current = terms;
   const renderCell = useCallback((
     row: FuturesTableRow,
     column: FuturesColumn,
-  ) => renderFuturesCell(row, column, quotes, { sessionText, returns }), [quotes, returns, sessionText]);
+  ) => renderFuturesCell(row, column, quotesRef.current, { sessionText, returns: returnsRef.current, terms: termsRef.current }), [sessionText]);
+  // Everything a cell reads: the headline figures the board shows, the quote's
+  // other fields, whether the last good quote is held over, and the returns.
+  const getRowVersion = useCallback((row: FuturesTableRow) => {
+    if (row.type !== "row") return row.sector;
+    const state = quotes.get(row.contract.symbol);
+    const quote = state?.quote ? boardHeadlineQuote(state.quote) : null;
+    const values = returns.get(row.contract.symbol);
+    const contract = terms.get(row.contract.symbol);
+    return [
+      state?.loading, state?.stale,
+      quote?.price, quote?.change, quote?.changePercent, quote?.previousClose, quote?.volume, quote?.lastUpdated, quote?.marketState, quote?.symbol, quote?.name,
+      values?.loading, values?.values["1W"], values?.values["1M"], values?.values.YTD,
+      contract?.loading, contract?.terms?.spec?.unit, contract?.terms?.deliveryMonth, contract?.terms?.nearest?.contract,
+      contract?.terms?.nearest?.lastTrade,
+    ].join(":");
+  }, [quotes, returns, terms]);
 
   const toggleSector = useCallback((sector: FuturesSector) => {
     setCollapsedSectors((current) => {
@@ -259,7 +285,7 @@ export function FuturesPane({ focused, width, height }: PaneProps) {
         height={height}
         error={errorMessage ?? "No quotes returned."}
         subject="Futures quotes"
-        actions={<Button label="Retry" variant="secondary" compact onPress={refresh} />}
+        retry={{ onRetry: refresh }}
       />
     );
   }
@@ -297,6 +323,7 @@ export function FuturesPane({ focused, width, height }: PaneProps) {
       onVisibleRangeChange={setVisibleRange}
       renderSectionHeader={renderSectorHeader}
       renderCell={renderCell}
+      getRowVersion={getRowVersion}
       selectedTextOverridesCellColor
       reportEveryRow
       emptyStateTitle={searchQuery.trim()
@@ -361,7 +388,7 @@ export const futuresModule: PluginModule = {
       paneId: FUTURES_PANE_ID,
       label: "Futures Board",
       description:
-        "Front-month futures across equity index, rates, energy, metals, agriculture, livestock, and FX with last price, session change, search, and collapsible sectors.",
+        "Each root's most active futures contract across equity index, equity sectors, rates, energy, metals, agriculture, livestock, and FX with last price, unit, session change, search, and collapsible sectors.",
       keywords: [
         "futures",
         "commodities",

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

@@ -1,8 +1,10 @@
+import type { FuturesContractTermsPayload } from "../../../api-client/futures-curve";
 import type { Quote } from "../../../types/financials";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
 import type { BoardQuoteMap } from "../shared/use-quote-board";
 import { FUTURES_SECTOR_ORDER, type FuturesContract, type FuturesSector } from "../../../market-data/futures-board";
 import type { FuturesReturnHorizon } from "./returns";
+import type { FuturesTermsMap } from "./use-board-terms";
 import type { FrontReturnsMap } from "./use-front-returns";
 
 export type FuturesTableRow =
@@ -14,6 +16,7 @@ export type FuturesColumnId =
   | "code"
   | "name"
   | "price"
+  | "unit"
   | "change"
   | "changePercent"
   | "return1w"
@@ -37,7 +40,8 @@ export function futuresRowId(row: FuturesTableRow): string {
   return row.type === "header" ? `header-${row.sector}` : row.contract.symbol;
 }
 
-const CONTRACT_MONTH = /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[ -](\d{4}|\d{2})$/i;
+/** "Nov 26" or "Futures,Nov-2026"; a hyphen takes only a whole year, since "Futures,Nov-20" is 2026 cut short. */
+const CONTRACT_MONTH = /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)(?: (\d{4}|\d{2})|-(\d{4}))$/i;
 
 /**
  * The alias stays the row identity while its quoted contract rolls, so the
@@ -63,10 +67,64 @@ export function quotedContractMonth(
   const match = CONTRACT_MONTH.exec(quote.name?.trim() ?? "");
   if (!match) return null;
   const month = MONTH_NAMES.findIndex((name) => name.toLowerCase() === match[1]!.toLowerCase());
-  const year = match[2]!.length === 2 ? 2000 + Number(match[2]) : Number(match[2]);
+  const written = match[2] ?? match[3]!;
+  const year = written.length === 2 ? 2000 + Number(written) : Number(written);
   return { year, month };
 }
 
+/** "2026-10-20" as "20 Oct". */
+function dayMonth(date: string): string {
+  return `${Number(date.slice(8, 10))} ${MONTH_NAMES[Number(date.slice(5, 7)) - 1]}`;
+}
+
+/**
+ * The row's headline: the contract its quote prices, as futuresContractName
+ * words it. While the continuous symbol has rolled to the most active month
+ * and a nearer one still trades, the headline says so, with the nearer one's
+ * last trade: "WTI Crude Oil Dec 26, most active (Nov expires 20 Oct)". The
+ * terms only add that note when they name the month the quote prices, so a
+ * roll between the two loads never mixes months, and place the month when the
+ * quote's name carries none. A name column too narrow for the note keeps the
+ * plain name.
+ */
+export function futuresContractHeadline(
+  contract: FuturesContract,
+  quote?: Quote | null,
+  terms?: Pick<FuturesContractTermsPayload, "deliveryMonth" | "nearest"> | null,
+  width = Number.POSITIVE_INFINITY,
+): string {
+  const quoted = quotedContractMonth(contract, quote);
+  const termsMonth = terms?.deliveryMonth && /^\d{4}-\d{2}$/.test(terms.deliveryMonth)
+    ? { year: Number(terms.deliveryMonth.slice(0, 4)), month: Number(terms.deliveryMonth.slice(5, 7)) - 1 }
+    : null;
+  const nearest = terms?.nearest;
+  const agree = quoted == null || termsMonth == null || (quoted.year === termsMonth.year && quoted.month === termsMonth.month);
+  // A quote whose name carries no month (or a cut one) is placed by its terms.
+  const month = agree ? quoted ?? termsMonth : quoted;
+  if (!month) return contract.name;
+  const active = `${MONTH_NAMES[month.month]} ${String(month.year).slice(-2)}`;
+  const plain = `${contract.name} ${active}`;
+  if (!nearest || !agree || nearest.deliveryMonth >= `${month.year}-${String(month.month + 1).padStart(2, "0")}`) return plain;
+  const nearer = MONTH_NAMES[Number(nearest.deliveryMonth.slice(5, 7)) - 1];
+  const expiry = nearest.lastTrade ? `expires ${dayMonth(nearest.lastTrade)}` : "still trading";
+  // The month the quote prices leads, so a column that clips the tail still shows it; one too narrow for
+  // "most active" shows the plain name.
+  const note = `, most active (${nearer} ${expiry})`;
+  return width >= plain.length + MOST_ACTIVE_MIN.length ? `${plain}${note}` : plain;
+}
+
+/** The least of the note a name column must fit to carry it. */
+const MOST_ACTIVE_MIN = ", most active";
+
+/**
+ * What a row's price counts, as `quote` says it: the exchange's unit from the
+ * contract terms ("USD / barrel"), the catalog's where the server has none
+ * ("EUR / MWh"), else null.
+ */
+export function futuresUnitLabel(contract: FuturesContract, terms?: Pick<FuturesContractTermsPayload, "spec"> | null): string | null {
+  return terms?.spec?.unit ?? contract.unit ?? null;
+}
+
 function matchesFuturesSearch(contract: FuturesContract, query: string, quote?: Quote | null): boolean {
   const normalized = query.trim().toLowerCase();
   if (!normalized) return true;
@@ -89,9 +147,12 @@ function getSortValue(
   contract: FuturesContract,
   quotes: BoardQuoteMap,
   returns?: FrontReturnsMap,
+  terms?: FuturesTermsMap,
 ): string | number | null {
   const quote = quotes.get(contract.symbol)?.quote;
   switch (columnId) {
+    case "unit":
+      return futuresUnitLabel(contract, terms?.get(contract.symbol)?.terms);
     case "status":
       return quote?.marketState === "REGULAR" ? 0 : 1;
     case "code":
@@ -122,12 +183,13 @@ function sortContracts(
   sortPreference: FuturesSortPreference,
   quotes: BoardQuoteMap,
   returns?: FrontReturnsMap,
+  terms?: FuturesTermsMap,
 ): FuturesContract[] {
   const columnId = sortPreference.columnId;
   if (!columnId) return contracts;
   return [...contracts].sort((left, right) => compareSortValues(
-    getSortValue(columnId, left, quotes, returns),
-    getSortValue(columnId, right, quotes, returns),
+    getSortValue(columnId, left, quotes, returns, terms),
+    getSortValue(columnId, right, quotes, returns, terms),
     sortPreference.direction,
   ));
 }
@@ -139,6 +201,8 @@ export interface BuildFuturesRowsOptions {
   collapsed?: ReadonlySet<FuturesSector>;
   /** Front-contract returns, for sorting on a returns column. */
   returns?: FrontReturnsMap;
+  /** Each row's contract terms, for sorting on the unit. */
+  terms?: FuturesTermsMap;
 }
 
 const NO_COLLAPSED_SECTORS: ReadonlySet<FuturesSector> = new Set();
@@ -166,7 +230,7 @@ export function buildFuturesRows(
   const query = options?.query ?? "";
   const collapsed = effectiveCollapsedSectors(options?.collapsed, query);
   for (const sector of FUTURES_SECTOR_ORDER) {
-    const contracts = sortContracts(contractsBySector.get(sector) ?? [], sortPreference, quotes, options?.returns)
+    const contracts = sortContracts(contractsBySector.get(sector) ?? [], sortPreference, quotes, options?.returns, options?.terms)
       .filter((contract) => matchesFuturesSearch(contract, query, quotes.get(contract.symbol)?.quote));
     if (contracts.length === 0) continue;
     rows.push({ type: "header", sector });

package/src/plugins/builtin/futures/series.ts

@@ -9,8 +9,8 @@ import { FUTURES_CONTRACTS, FUTURES_SECTOR_LABELS, type FuturesContract } from "
 const US_CENT_CONTRACTS: ReadonlySet<string> = new Set(["ZC", "ZS", "ZL", "ZW", "KE", "KC", "SB", "CT"]);
 
 /**
- * The unit the board prints, not a blanket dollar price. Index futures are
- * points, rates are points (the board prints decimals, not 32nds), cents
+ * The unit the board prints, not a blanket dollar price. Index and sector
+ * futures are points, rates are points (the board prints decimals, not 32nds), cents
  * contracts are USX, and a declared quote unit wins over USD. Currency
  * futures are dollars per unit of the foreign currency.
  */
@@ -18,7 +18,7 @@ function futuresSeriesUnit(contract: FuturesContract): string {
   if (contract.unit?.startsWith("US cents") || US_CENT_CONTRACTS.has(contract.code)) return "USX";
   if (contract.unit?.startsWith("EUR")) return "EUR";
   if (contract.unit?.startsWith("USD")) return "USD";
-  if (contract.sector === "equity-index" || contract.sector === "rates") return "points";
+  if (contract.sector === "equity-index" || contract.sector === "equity-sectors" || contract.sector === "rates") return "points";
   return "USD";
 }
 

package/src/plugins/builtin/futures/table.tsx

@@ -5,7 +5,8 @@ import { TextAttributes } from "../../../ui";
 import { formatCompact, formatNumber, formatPercentRaw } from "../../../utils/format";
 import { isBoardRowLoading, renderQuoteBoardCell, type BoardQuoteMap } from "../shared/use-quote-board";
 import { tickDecimals, type FuturesContract } from "../../../market-data/futures-board";
-import { FUTURES_RETURN_COLUMNS, futuresContractName, type FuturesColumnId, type FuturesTableRow } from "./model";
+import { FUTURES_RETURN_COLUMNS, futuresContractHeadline, futuresUnitLabel, type FuturesColumnId, type FuturesTableRow } from "./model";
+import type { FuturesTermsMap } from "./use-board-terms";
 import type { FrontReturnsMap } from "./use-front-returns";
 
 export type FuturesColumn = DataTableColumn & { id: FuturesColumnId };
@@ -21,6 +22,7 @@ export const FUTURES_COLUMN_DEFS: readonly FuturesColumnDef[] = [
   { id: "code", label: "Symbol", description: "Exchange contract code." },
   { id: "name", label: "Contract", description: "Contract name." },
   { id: "price", label: "Last", description: "Last traded price." },
+  { id: "unit", label: "Unit", description: "What a price counts, as the exchange quotes it (USD / barrel)." },
   { id: "change", label: "Change", description: "Change on the session." },
   { id: "changePercent", label: "Change %", description: "Percent change on the session." },
   { id: "return1w", label: "1W", description: "Front contract's return over one week." },
@@ -35,22 +37,32 @@ const DEFAULT_FUTURES_COLUMN_IDS = FUTURES_COLUMN_DEFS.map((column) => column.id
 
 /**
  * Extra columns only earn their width once the board is wide enough to keep a
- * readable contract name; a narrow pane drops them instead of clipping.
+ * readable contract name (24 cells or more); a narrow pane drops them instead
+ * of clipping. The unit a price counts outranks its session change in points,
+ * which the change in percent still gives. The previous close (the last price
+ * less the change) goes first, then each row's quote time (the status line
+ * dates the newest), which leaves a 1280-pixel shot room for "WTI Crude Oil
+ * Dec 26, most active (Nov expires 20 Oct)".
  */
 const COLUMN_MIN_PANE_WIDTH: Partial<Record<FuturesColumnId, number>> = {
-  return1w: 84,
-  return1m: 92,
-  returnYtd: 106,
-  volume: 116,
-  prevClose: 128,
-  time: 140,
+  change: 100,
+  return1w: 108,
+  return1m: 117,
+  returnYtd: 126,
+  volume: 136,
+  time: 170,
+  prevClose: 200,
 };
+/** From this width the unit column fits lumber's "USD / 1,000 board ft" whole. */
+const WIDE_UNIT_MIN_WIDTH = 200;
 const SESSION_TEXT_MIN_WIDTH = 100;
 
 const COLUMN_WIDTHS: Record<Exclude<FuturesColumnId, "name">, number> = {
   status: 1,
   code: 5,
   price: 12,
+  // "US cents / bushel"; lumber's longer unit fits from WIDE_UNIT_MIN_WIDTH.
+  unit: 17,
   change: 10,
   changePercent: 9,
   return1w: 8,
@@ -70,6 +82,7 @@ export function usesSessionText(width: number): boolean {
 
 function columnWidth(id: Exclude<FuturesColumnId, "name">, paneWidth: number): number {
   if (id === "status") return usesSessionText(paneWidth) ? 9 : 1;
+  if (id === "unit" && paneWidth >= WIDE_UNIT_MIN_WIDTH) return 20;
   return COLUMN_WIDTHS[id];
 }
 
@@ -95,7 +108,7 @@ export function createFuturesColumns(width: number, visibleIds?: readonly string
       // TIME is left-aligned like the text columns: the shared table trims a few
       // cells off the right edge of a floating pane, and a right-aligned value
       // there would lose digits.
-      align: id === "code" || id === "status" || id === "time" ? "left" : "right",
+      align: id === "code" || id === "status" || id === "unit" || id === "time" ? "left" : "right",
     };
   });
 }
@@ -105,6 +118,7 @@ const FUTURES_HEADER_LABELS: Record<FuturesColumnId, string> = {
   code: "SYM",
   name: "CONTRACT",
   price: "LAST",
+  unit: "UNIT",
   change: "CHG",
   changePercent: "CHG%",
   return1w: "1W",
@@ -200,7 +214,7 @@ export function renderFuturesCell(
   row: FuturesTableRow,
   column: FuturesColumn,
   quotes: BoardQuoteMap,
-  options?: { sessionText?: boolean; returns?: FrontReturnsMap },
+  options?: { sessionText?: boolean; returns?: FrontReturnsMap; terms?: FuturesTermsMap },
 ): DataTableCell {
   if (row.type === "header") return { text: "" };
 
@@ -216,7 +230,13 @@ export function renderFuturesCell(
         attributes: TextAttributes.BOLD,
       };
     case "name":
-      return { text: futuresContractName(contract, quote) };
+      return { text: futuresContractHeadline(contract, quote, options?.terms?.get(contract.symbol)?.terms, column.width) };
+    case "unit": {
+      const terms = options?.terms?.get(contract.symbol);
+      const unit = futuresUnitLabel(contract, terms?.terms);
+      if (unit) return { text: unit, color: colors.textDim };
+      return terms?.loading ? { text: "…", color: colors.textDim } : { text: "—", color: colors.textDim };
+    }
     case "volume":
       if (isBoardRowLoading(state)) return { text: "…", color: colors.textDim };
       if (!quote || quote.volume == null || !Number.isFinite(quote.volume)) {

package/src/plugins/builtin/futures/use-board-terms.ts

@@ -0,0 +1,89 @@
+import { useEffect, useMemo, useState } from "react";
+import type { FuturesContractTermsPayload } from "../../../api-client/futures-curve";
+import type { FuturesContract } from "../../../market-data/futures-board";
+import { loadFuturesContractTerms } from "../../../market-data/futures-contract";
+
+interface FuturesTermsState {
+  /** The row's terms are still being asked for. */
+  loading: boolean;
+  /** Null when the server has no terms for the symbol, or could not answer. */
+  terms: FuturesContractTermsPayload | null;
+}
+
+export type FuturesTermsMap = ReadonlyMap<string, FuturesTermsState>;
+
+/** The terms change with a roll, and a roll is decided once a day. */
+const TERMS_TTL_MS = 30 * 60_000;
+/** Forty-odd rows open at once; a few requests at a time keep the board's quotes first. */
+const TERMS_CONCURRENCY = 4;
+
+interface CachedTerms {
+  at: number;
+  /** Null when the server has no terms for the symbol, or could not answer. */
+  terms: FuturesContractTermsPayload | null;
+}
+
+const termsCache = new Map<string, CachedTerms>();
+const inFlight = new Map<string, Promise<void>>();
+
+function fresh(symbol: string, now: number): CachedTerms | undefined {
+  const cached = termsCache.get(symbol);
+  return cached && now - cached.at < TERMS_TTL_MS ? cached : undefined;
+}
+
+function loadTerms(symbol: string): Promise<void> {
+  const pending = inFlight.get(symbol);
+  if (pending) return pending;
+  const request = loadFuturesContractTerms(symbol)
+    .then((terms) => { termsCache.set(symbol, { at: Date.now(), terms }); })
+    .catch(() => { termsCache.set(symbol, { at: Date.now(), terms: null }); })
+    .finally(() => { inFlight.delete(symbol); });
+  inFlight.set(symbol, request);
+  return request;
+}
+
+/**
+ * Each listed row's contract terms, as `quote` reads them: the unit its price
+ * counts, and the nearer month still trading when its continuous symbol has
+ * rolled to the most active one. Only the rows the board lists are asked for,
+ * and a row whose terms have not arrived (or that has none) renders without them.
+ */
+export function useFuturesBoardTerms(contracts: readonly FuturesContract[], enabled: boolean): FuturesTermsMap {
+  const symbolKey = contracts.map((contract) => contract.symbol).join(",");
+  const [version, setVersion] = useState(0);
+
+  useEffect(() => {
+    if (!enabled || !symbolKey) return;
+    const now = Date.now();
+    const queue = symbolKey.split(",").filter((symbol) => !fresh(symbol, now));
+    if (queue.length === 0) return;
+    let cancelled = false;
+    const worker = async () => {
+      for (let symbol = queue.shift(); symbol; symbol = queue.shift()) {
+        await loadTerms(symbol);
+        if (!cancelled) setVersion((current) => current + 1);
+      }
+    };
+    void Promise.all(Array.from({ length: Math.min(TERMS_CONCURRENCY, queue.length) }, worker));
+    return () => {
+      cancelled = true;
+      queue.length = 0;
+    };
+  }, [enabled, symbolKey]);
+
+  return useMemo(() => {
+    const result = new Map<string, FuturesTermsState>();
+    if (!enabled) return result;
+    for (const symbol of symbolKey ? symbolKey.split(",") : []) {
+      const cached = termsCache.get(symbol);
+      result.set(symbol, { loading: !cached, terms: cached?.terms ?? null });
+    }
+    return result;
+    // `version` re-reads the cache as loads land.
+  }, [enabled, symbolKey, version]);
+}
+
+/** Forgets every cached row's terms (tests). */
+export function resetFuturesBoardTerms(): void {
+  termsCache.clear();
+}

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

@@ -73,7 +73,12 @@ export function HoldersView({ focused, width, height }: { focused: boolean; widt
   } : null, [dataProvider, exchange, symbol]);
   // Another ticker's holders stay up until its own answer, and a failed
   // refresh keeps the last holders; the failure goes to the footer.
-  const { data, loading, error, reload } = useAsyncResource<HolderData>(loadHolders, { keepPreviousData: true });
+  const { data, loading, error, reload } = useAsyncResource<HolderData>(loadHolders, {
+    initialData: () => symbol && dataProvider?.getCachedQuery
+      ? dataProvider.getCachedQuery("getHolders", [symbol, exchange]).getSnapshot().result?.value ?? null
+      : null,
+    keepPreviousData: true,
+  });
 
   // The values' own currency: dollars from the 13F filings on a London line, not its pence.
   const currency = holderValueCurrency(data, ticker?.metadata.currency || "USD")!;