gloomberb 0.17.2 → 0.17.3

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,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   Button,
   DataTableView,
@@ -28,6 +28,7 @@ import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
 import { quoteObservation } from "../shared/report-freshness";
 import {
   boardErrorMessage,
+  boardHeadlineQuote,
   quoteBoardFooterInfo,
   quoteBoardStatus,
   useQuoteBoard,
@@ -59,6 +60,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 +136,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 +145,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) => {
@@ -297,6 +324,7 @@ export function FuturesPane({ focused, width, height }: PaneProps) {
       onVisibleRangeChange={setVisibleRange}
       renderSectionHeader={renderSectorHeader}
       renderCell={renderCell}
+      getRowVersion={getRowVersion}
       selectedTextOverridesCellColor
       reportEveryRow
       emptyStateTitle={searchQuery.trim()
@@ -361,7 +389,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, 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"
@@ -67,6 +70,59 @@ export function quotedContractMonth(
   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 +145,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 +181,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 +199,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 +228,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/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")!;

package/src/plugins/builtin/mna/client.ts

@@ -9,7 +9,7 @@ import type {
 } from "../../../api-client/mna";
 import type { HeadlessPaneApiClient } from "../../../types/plugin";
 import { createPluginCache } from "../../../data/plugin-cache";
-import { loadCloudResource, unavailableOnServer, type CloudResource } from "../shared/cloud-resource";
+import { cachedCloudResource, loadCloudResource, unavailableOnServer, type CloudResource } from "../shared/cloud-resource";
 
 /**
  * Deals change when a story or a filing lands, a few times an hour at most,
@@ -119,6 +119,10 @@ const listKey = (params: MnaDealsParams, pro: boolean) =>
   JSON.stringify([params.status ?? "pending", params.target ?? "all", params.region ?? "all",
     params.symbol?.toUpperCase() ?? "", params.query?.trim().toLowerCase() ?? "", params.offset ?? 0, pro ? "full" : "delayed"]);
 
+export function cachedMnaDeals(params: MnaDealsParams, pro: boolean) {
+  return cachedCloudResource(mnaDealsCache, listKey(params, pro), validateMnaDeals);
+}
+
 export function loadMnaDeals(params: MnaDealsParams, pro: boolean, force = false): Promise<CloudResource<MnaDealsPayload>> {
   return loadCloudResource(mnaDealsCache, listKey(params, pro), () => fetchMnaDeals(params), {
     force,
@@ -126,8 +130,14 @@ export function loadMnaDeals(params: MnaDealsParams, pro: boolean, force = false
   });
 }
 
+const dealKey = (id: string, pro: boolean) => `${id}:${pro ? "full" : "delayed"}`;
+
+export function cachedMnaDeal(id: string, pro: boolean) {
+  return cachedCloudResource(mnaDealCache, dealKey(id, pro), validateMnaDeal);
+}
+
 export function loadMnaDeal(id: string, pro: boolean, force = false): Promise<CloudResource<MnaDealPayload>> {
-  return loadCloudResource(mnaDealCache, `${id}:${pro ? "full" : "delayed"}`, () => fetchMnaDeal(id), {
+  return loadCloudResource(mnaDealCache, dealKey(id, pro), () => fetchMnaDeal(id), {
     force,
     validate: validateMnaDeal,
   });

package/src/plugins/builtin/mna/detail.tsx

@@ -22,7 +22,7 @@ import { Box, useRendererHost } from "../../../ui";
 import { useAssetData, usePluginTickerActions } from "../../runtime";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { useQuoteBoard } from "../shared/use-quote-board";
-import { loadMnaDeal } from "./client";
+import { cachedMnaDeal, loadMnaDeal } from "./client";
 import {
   dealSpread,
   formatDealValue,
@@ -136,7 +136,7 @@ export function MnaDealDetail({ id, seed, focused, width, height }: {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [id, pro, session.requestKey],
   );
-  const resource = useAsyncResource(loader, { clearOnError: isAccessDenied });
+  const resource = useAsyncResource(loader, { initialData: () => cachedMnaDeal(id, pro), clearOnError: isAccessDenied });
   const payload = resource.data?.payload ?? null;
   const deal = payload?.deal ?? seed;
   const events = payload?.events ?? NO_EVENTS;

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

@@ -37,7 +37,7 @@ import { useCloudAccessFooter } from "../shared/cloud-upgrade";
 import { Blurred, UpgradeLabel } from "../shared/locked-rows";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { useQuoteBoard } from "../shared/use-quote-board";
-import { appendMnaDeals, fetchMnaDeals, loadMnaDeals } from "./client";
+import { appendMnaDeals, cachedMnaDeals, fetchMnaDeals, loadMnaDeals } from "./client";
 import { MnaDealDetail, mnaDealTitle } from "./detail";
 import { DistressBoard } from "./distress/pane";
 import {
@@ -220,7 +220,7 @@ function MnaDealsView({ focused, width, height, symbol }: {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [paramsKey, pro, session.requestKey],
   );
-  const resource = useAsyncResource(loader, { clearOnError: isAccessDenied });
+  const resource = useAsyncResource(loader, { initialData: () => cachedMnaDeals(params, pro), clearOnError: isAccessDenied });
   const first = resource.data?.payload ?? null;
   const [paged, setPaged] = useState<{ owner: MnaDealsPayload; payload: MnaDealsPayload } | null>(null);
   const data = paged && paged.owner === first ? paged.payload : first;

package/src/plugins/builtin/notes/owner.tsx

@@ -1,8 +1,9 @@
 import { useSyncExternalStore } from "react";
 import type { TeamSummary } from "../../../api-client";
 import { ChoiceDialog } from "../../../components/ui/choice-dialog";
+import { Notice } from "../../../components/ui/status";
 import { QueryBar } from "../../../components/ui/query-bar";
-import { Box, Text } from "../../../ui";
+import { Box } from "../../../ui";
 import type { DialogApi, PromptContext } from "../../../ui/dialog";
 import { colors } from "../../../theme/colors";
 import { teamAccentHex, teamPrefix } from "../../../team/model";
@@ -118,12 +119,12 @@ export async function resolveNoteConflict(dialog: DialogApi, error: NoteConflict
 
 export function ReadOnlyBanner({ owner, teams }: { owner: NoteOwner; teams: readonly TeamSummary[] }) {
   return (
-    <Box height={1} paddingLeft={1}>
-      <Text fg={colors.warning}>
+    <Box paddingLeft={1}>
+      <Notice>
         {owner.kind === "user"
           ? "Offline: notes are read-only until Gloom Cloud is reachable."
           : `Offline: ${ownerLabel(owner, teams)} notes are read-only.`}
-      </Text>
+      </Notice>
     </Box>
   );
 }

package/src/plugins/builtin/notes/ticker-notes-tab.tsx

@@ -1,9 +1,8 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Box, Text, type TextareaRenderable } from "../../../ui";
+import { Box, type TextareaRenderable } from "../../../ui";
 import { useShortcut } from "../../../react/input";
 import { isPlainKey } from "../../../utils/keyboard";
 import type { TickerResearchTabProps } from "../../../types/plugin";
-import { colors } from "../../../theme/colors";
 import { MarkdownEditor } from "../../../components/markdown-editor";
 import { EmptyState, usePaneFooter } from "../../../components";
 import { usePluginAppActions, usePluginPaneState } from "../../runtime";
@@ -178,7 +177,7 @@ export function createNotesTab(registry: NotesStoreRegistry) {
         : [{ id: "mode", parts: [{ text: notesFiles.readOnly ? "read-only" : notesFocused ? "editing" : "viewing", tone: "muted" as const }] }],
     }), [loadError, notesFiles.readOnly, notesFocused]);
 
-    if (!ticker) return <Text fg={colors.textDim}>Select a ticker to view notes.</Text>;
+    if (!ticker) return <EmptyState title="Select a ticker." />;
 
     return (
       <Box flexDirection="column" flexGrow={1}>