gloomberb 0.16.4 → 0.16.5

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

@@ -3,7 +3,7 @@ import type { CurvePalette, CurveSeries } from "../../../components/chart/curve/
 import { spanDigits } from "../../../components/chart-table";
 import { compositeAxisTicks } from "../../../components/chart/composite/format";
 import type { CompositeAxisDomain } from "../../../components/chart/composite/types";
-import { FUTURES_CONTRACTS, tickDecimals } from "../futures/contracts";
+import { FUTURES_CONTRACTS, futuresBoardContractForTicker, futuresContractByCode, tickDecimals } from "../../../market-data/futures-board";
 import { formatPercentileRank } from "../../../utils/format";
 import { cryptoPairCoin, isFuturesSymbol } from "../shared/crypto-pair";
 import { parseReportTime } from "../../../utils/utc-time";
@@ -21,7 +21,7 @@ const CRYPTO_CURVE_ROOTS: readonly { code: string; name: string; tick: number }[
 const rootLabel = (code: string, name: string) => name === code ? code : `${code} ${name}`;
 
 export const CURVE_ROOTS = [
-  ...FUTURES_CONTRACTS.filter((row) => row.curve !== false).map((row) => ({ value: row.code, label: rootLabel(row.code, row.name) })),
+  ...FUTURES_CONTRACTS.map((row) => ({ value: row.code, label: rootLabel(row.code, row.name) })),
   { value: "VX", label: "VX VIX Futures" },
   ...CRYPTO_CURVE_ROOTS.map((row) => ({ value: row.code, label: rootLabel(row.code, row.name) })),
 ];
@@ -34,24 +34,40 @@ export function normalizeCurveRoot(value: unknown): string | null {
   return CURVE_ROOTS.some((row) => row.value === root) ? root : null;
 }
 
-/** What a root nothing lists is told, with roots that work. */
+/** What a root CTM does not list is told: the roots that work, with the FUT board's, VIX and CME crypto named by group. */
 export function unsupportedCurveRootMessage(value: unknown): string {
+  const typed = String(value).trim().toUpperCase().replace(/=F$/, "");
   const examples = ["ES", "CL", "GC", "ZN"].filter((root) => CURVE_ROOTS.some((row) => row.value === root));
-  return `Unsupported futures root: ${String(value)}. Try ${examples.join(", ")}.`;
+  return `No futures curve for ${typed || "that root"}: CTM covers the FUT board's roots, VIX and CME crypto, such as ${examples.join(", ")}.`;
 }
 
+/**
+ * Board roots whose bare code opens their curve from the ticker under the
+ * cursor. Several are also listed securities (ES Eversource, NG NovaGold, PL
+ * Planet Labs), but they followed the cursor before the board was checked
+ * against listed securities and keep doing so. A root added after that (ZM is
+ * Zoom, KE, LE, HE and ALI are tickers too) follows the cursor only as its
+ * `=F` symbol or a code no security answers to (`bareCode`: ZL, OJ, LBR), the
+ * rule FUT and COT apply, so a new board row defaults to the security.
+ */
+const CURSOR_BARE_ROOTS: ReadonlySet<string> = new Set(["ES", "CL", "BZ", "NG", "RB", "HO", "GC", "SI", "HG", "PL", "PA", "ZC", "ZS", "KC", "SB", "CC"]);
+
 /**
  * The root for the ticker under the cursor, when CTM is opened without an
  * argument. The crypto roots are also US ticker symbols (Grayscale's mini
  * trusts are BTC and ETH), so a bare one is the equity's, never the future's:
  * only a futures symbol (BTC=F) or a coin pair (BTC-USD) names the crypto curve.
+ * A typed argument is different: `CTM ZM` is soybean meal even though ZM is also Zoom.
  */
 export function curveRootForTicker(ticker: unknown): string | null {
   if (typeof ticker !== "string") return null;
   const coin = cryptoPairCoin(ticker);
   if (coin) return CRYPTO_CURVE_ROOTS.some((row) => row.code === coin) ? coin : null;
   const root = normalizeCurveRoot(ticker);
-  return root && CRYPTO_CURVE_ROOTS.some((row) => row.code === root) && !isFuturesSymbol(ticker) ? null : root;
+  if (!root) return null;
+  if (CRYPTO_CURVE_ROOTS.some((row) => row.code === root)) return isFuturesSymbol(ticker) ? root : null;
+  const isBoardRoot = futuresContractByCode(root) != null;
+  return isBoardRoot && !CURSOR_BARE_ROOTS.has(root) ? futuresBoardContractForTicker(ticker)?.code ?? null : root;
 }
 
 /**
@@ -67,7 +83,7 @@ function curvePriceDecimals(root: string): number {
   const rateTick = RATE_TICKS[root];
   if (rateTick != null) return tickDecimals(rateTick);
   if (root === "VX") return 4;
-  const tick = FUTURES_CONTRACTS.find((row) => row.code === root)?.tick ?? CRYPTO_CURVE_ROOTS.find((row) => row.code === root)?.tick;
+  const tick = futuresContractByCode(root)?.tick ?? CRYPTO_CURVE_ROOTS.find((row) => row.code === root)?.tick;
   return tick == null ? 5 : Math.max(2, tickDecimals(tick));
 }
 
@@ -84,6 +100,39 @@ export function curveChangeText(value: number | null, root: string): string {
   return value != null && value > 0 && /[1-9]/.test(text) ? `+${text}` : text;
 }
 
+/** A price as a number at the root's display precision, for reports: 59.299805 reads 59.3, never float noise. */
+export function curveRoundedPrice(value: number | null | undefined, root: string): number | null {
+  return value == null || !Number.isFinite(value) ? null : Number(value.toFixed(curvePriceDecimals(root)));
+}
+
+/** The unit the catalogue gives a root whose contract terms the server does not send: "EUR / MWh" for Dutch TTF gas. */
+export function catalogueCurveUnit(root: string): string | null {
+  return futuresContractByCode(root)?.unit ?? null;
+}
+
+/**
+ * What a price counts: the exchange's unit ("USD / troy oz") where the root's
+ * terms are known, the catalogue's where they are not, else the quote unit.
+ */
+export function curveUnitLabel(data: Pick<FuturesCurvePayload, "root" | "spec" | "quoteUnit" | "currency">): string | null {
+  return data.spec?.unit ?? catalogueCurveUnit(data.root) ?? data.quoteUnit ?? data.currency ?? null;
+}
+
+/** A contract as traders write it: GCZ26.CMX is GCZ26; a VX symbol stays as Cboe lists it. */
+export function curveContractCode(symbol: string): string {
+  return symbol.replace(/\.[A-Z]+$/, "");
+}
+
+/**
+ * The front spread named by the contracts it subtracts, "GCF27-GCZ26": the
+ * next contract less the front one. The front is the first contract the
+ * market trades, which can be past a delivery month nobody holds, so a bare
+ * "M2-M1" would not say which rows it means.
+ */
+export function curveSpreadLabel(slope: Pick<FuturesCurvePayload["slope"], "frontSymbol" | "nextSymbol">): string {
+  return slope.frontSymbol && slope.nextSymbol ? `${curveContractCode(slope.nextSymbol)}-${curveContractCode(slope.frontSymbol)}` : "M2-M1";
+}
+
 /**
  * Axis gridlines sit on round values, so they need no tick precision: one
  * decimal count across the gutter, as many as the plotted range asks for and
@@ -188,13 +237,14 @@ export function curveContractChanges(data: FuturesCurvePayload): CurveContractCh
 
 const CHANGE_COLUMNS: Readonly<Record<string, CurveLookback>> = { change1w: "1W", change1m: "1M" };
 
-type CurveSortKey = "symbol" | "expiration" | "price" | "change" | "openInterest" | "volume" | "percentile" | "asOf";
+type CurveSortKey = "symbol" | "expiration" | "price" | "settlement" | "firstNotice" | "change" | "openInterest" | "volume" | "percentile" | "asOf";
 
 const BASIS_COLUMNS: Readonly<Record<string, "vsSpotPct" | "annualisedBasisPct">> = { vsSpot: "vsSpotPct", annBasis: "annualisedBasisPct" };
 
 export function sortCurveContracts(rows: readonly FuturesContract[], id: string, direction: SortDirection,
   changes?: CurveContractChanges, basis?: CurveBasisRows): FuturesContract[] {
-  const keys: Record<string, CurveSortKey> = { symbol: "symbol", expiry: "expiration", price: "price", change: "change", oi: "openInterest", volume: "volume", percentile: "percentile", asOf: "asOf" };
+  const keys: Record<string, CurveSortKey> = { symbol: "symbol", expiry: "expiration", price: "price", settle: "settlement", notice: "firstNotice",
+    change: "change", oi: "openInterest", volume: "volume", percentile: "percentile", asOf: "asOf" };
   const key = keys[id] ?? "expiration";
   const lookback = CHANGE_COLUMNS[id];
   const basisKey = BASIS_COLUMNS[id];
@@ -399,6 +449,9 @@ export function archivedFuturesCurve(root: string, curve: FuturesCurveAsOfPayloa
       symbol: row.symbol, label: row.label, expiration: row.expiration, price: row.price, change: null, asOf: rowDate(row, stale),
       currency: curve.currency ?? "USD", quoteUnit: curve.quoteUnit ?? curve.currency ?? "USD", volume: row.volume,
       openInterest: row.openInterest, delayMinutes: null, stale, percentile: null, samples: 0, historyStart: null, historyEnd: null,
+      // Only a row the archive confirms is a settlement; an unconfirmed one is that session's last trade.
+      settlement: !stale && row.settled === true ? row.price : null,
+      lastTrade: row.lastTrade ?? row.expiration, firstNotice: row.firstNotice ?? null, inDelivery: row.inDelivery ?? false,
     }];
   }).sort((a, b) => a.expiration.localeCompare(b.expiration));
   const ghosts = (["1W", "1M"] as const).map((label) => {
@@ -407,8 +460,10 @@ export function archivedFuturesCurve(root: string, curve: FuturesCurveAsOfPayloa
       points: past ? past.contracts.flatMap((row) => row.expiration
         ? [{ symbol: row.symbol, expiration: row.expiration, price: row.price, asOf: rowDate(row, archivedRowStale(row, past)) }] : []) : [] };
   });
-  // The front pair on the curve's own session; carried prices do not make a spread.
-  const [front, next] = contracts.filter((row) => !row.stale);
+  // The front pair on the curve's own session: settlements where the archive has them, else that session's
+  // last trades. Carried prices, and a last trade beside a settlement, do not make a spread.
+  const settled = contracts.filter((row) => row.settlement != null);
+  const [front, next] = settled.length >= 2 ? settled : settled.length ? [] : contracts.filter((row) => !row.stale);
   const value = front && next ? next.price! - front.price! : null;
   const days = front && next ? (Date.parse(next.expiration) - Date.parse(front.expiration)) / DAY_MS : 0;
   const roll = front && next && front.price! > 0 && next.price! > 0 && days > 0 ? (front.price! / next.price! - 1) * 365 / days * 100 : null;
@@ -419,6 +474,6 @@ export function archivedFuturesCurve(root: string, curve: FuturesCurveAsOfPayloa
     slope: { frontSymbol: front?.symbol ?? null, nextSymbol: next?.symbol ?? null, value, annualizedRollYield: roll, percentile: null,
       rollPercentile: null, samples: 0, historyStart: null, historyEnd: null, asOf: front && next ? curve.asOf : null,
       state: value == null ? "unavailable" : Math.abs(value) < 1e-10 ? "flat" : value > 0 ? "contango" : "backwardation" },
-    gaps: curve.gaps,
+    gaps: curve.gaps, spec: curve.spec ?? null, settlementDate: settled.length ? curve.asOf : null,
   };
 }

package/src/plugins/builtin/futures-curve/pane.tsx

@@ -4,6 +4,7 @@ import { fitChartTableColumns } from "../../../components/chart-table";
 import { curveStrip, curveSurfaceMinRows } from "../../../components/chart/curve";
 import { isAccessDenied } from "../../../api-client/errors";
 import type { FuturesContract } from "../../../api-client/futures-curve";
+import { futuresTickText } from "../../../market-data/futures-contract";
 import { useAsyncResource, usePaneSettingValue, usePluginPaneState, useShortcut } from "../../../public/react";
 import { usePaneInstance, usePaneTitle } from "../../../state/app/context";
 import { useThemeColors } from "../../../theme/theme-context";
@@ -16,14 +17,19 @@ import { futuresSessionRefreshInterval } from "../shared/futures-session";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { useQuoteBoard } from "../shared/use-quote-board";
 import { getCachedFuturesCurve, loadFuturesCurve, loadFuturesCurveAsOf } from "./client";
-import { basisSpotSymbol, curveAsOfDate, curveAxisPrice, curveBasisPercent, curveBasisRows, curveChangeText, curveContractChanges, curvePrice, curveRank, curveSpot, curveSpotLabel, curveTimestamp, DEFAULT_CURVE_HORIZON, futuresCurveSeries, newestQuote, normalizeCurveRoot, sortCurveContracts, thinContractCount, thinContractsNotice, unsupportedCurveRootMessage, type CurveContractChanges } from "./model";
+import { basisSpotSymbol, curveAsOfDate, curveAxisPrice, curveBasisPercent, curveBasisRows, curveChangeText, curveContractChanges, curveContractCode, curvePrice, curveRank, curveSpot, curveSpotLabel, curveSpreadLabel, curveTimestamp, curveUnitLabel, DEFAULT_CURVE_HORIZON, futuresCurveSeries, newestQuote, normalizeCurveRoot, sortCurveContracts, thinContractCount, thinContractsNotice, unsupportedCurveRootMessage, type CurveContractChanges } from "./model";
 
 const TABS = [{ value: "curve", label: "Curve" }, { value: "contracts", label: "Contracts" }];
+// One column order for every root. SETTLE is the exchange settlement for the
+// curve's settlement session, LAST the latest trade; the header dates SETTLE.
 const COLUMNS: DataTableColumn[] = [
   // The longest symbol is a three-letter root with its month and venue: RTYH27.CME.
   { id: "symbol", label: "CONTRACT", width: 11, align: "left" },
   { id: "expiry", label: "EXPIRY", width: 10, align: "left" },
-  { id: "price", label: "PRICE", width: 12, align: "right" },
+  { id: "notice", label: "1ST NOTICE", width: 10, align: "left" },
+  // A Treasury price keeps its 1/256 tick: 103.50000000.
+  { id: "settle", label: "SETTLE", width: 12, align: "right" },
+  { id: "price", label: "LAST", width: 12, align: "right" },
   // A Treasury change keeps its 1/256 tick: +0.11718750.
   { id: "change", label: "CHG", width: 11, align: "right" },
   { id: "percentile", label: "PCTL", width: 5, align: "right" },
@@ -31,25 +37,28 @@ const COLUMNS: DataTableColumn[] = [
   { id: "volume", label: "VOLUME", width: 10, align: "right" },
   { id: "asOf", label: "AS OF UTC", width: 16, align: "left" },
 ];
+const CONTRACTS_DROP_ORDER = ["percentile", "volume", "oi", "notice"];
+const column = (id: string) => COLUMNS.find((entry) => entry.id === id)!;
 // The curve's rows move with the look-back curves drawn above them; the
 // footer carries the quote time every row would otherwise repeat. The session
 // change stays on Contracts, where the full table has the width for it.
 const CURVE_COLUMNS: DataTableColumn[] = [
-  ...COLUMNS.slice(0, 3),
+  column("symbol"), column("expiry"), column("settle"), column("price"),
   { id: "change1w", label: "VS 1W", width: 10, align: "right" },
   { id: "change1m", label: "VS 1M", width: 10, align: "right" },
-  ...COLUMNS.slice(4, -1),
+  column("percentile"), column("oi"), column("volume"),
 ];
+const CURVE_DROP_ORDER = ["percentile", "volume", "change1m", "oi"];
 // A crypto curve also reads against spot. Its widths are the tightest each column
 // holds (BTCV26.CME, 128000.00), so the two new columns fit beside the rest, and
 // a narrow pane drops the least useful ones before a number would be clipped.
 const BASIS_CURVE_COLUMNS: DataTableColumn[] = [
-  { ...CURVE_COLUMNS[0]!, width: 10 }, CURVE_COLUMNS[1]!, { ...CURVE_COLUMNS[2]!, width: 10 },
+  { ...column("symbol"), width: 10 }, column("expiry"), { ...column("settle"), width: 10 }, { ...column("price"), width: 10 },
   { id: "vsSpot", label: "VS SPOT", width: 9, align: "right" },
   { id: "annBasis", label: "ANN BASIS", width: 11, align: "right" },
-  ...CURVE_COLUMNS.slice(3),
+  ...CURVE_COLUMNS.slice(4),
 ];
-const BASIS_DROP_ORDER = ["percentile", "volume", "change1m", "oi"];
+const BASIS_DROP_ORDER = ["percentile", "volume", "change1m", "oi", "settle"];
 const NO_SYMBOLS: string[] = [];
 /** The spot's age is judged against the clock, so a quote that stops moving still goes stale on screen. */
 const SPOT_CLOCK_MS = 30_000;
@@ -135,17 +144,31 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
   const statItems: StatItem[] = data ? [
     { id: "roll", label: "Ann. roll yield", value: signedPercent(data.slope.annualizedRollYield),
       detail: curveRank(data.slope.rollPercentile, data.slope.samples) },
-    { id: "spread", label: "M2-M1", value: data.slope.value == null ? "--" : curvePrice(data.slope.value, root),
+    // Named by the contracts it subtracts: the front is the first month the market trades, not always the first row.
+    { id: "spread", label: curveSpreadLabel(data.slope), value: data.slope.value == null ? "--" : curvePrice(data.slope.value, root),
       detail: [data.slope.state, curveRank(data.slope.percentile, data.slope.samples), slopeDate].filter(Boolean).join(" · ") },
+    ...data.spec ? [{ id: "contract", label: "Contract", value: data.spec.size, detail: `tick ${futuresTickText(data.spec)}` }] : [],
   ] : [];
   const { strip: tabStrip, rows: tabRows } = usePaneTabs({ tabs: TABS, activeValue: tab, onSelect: setTab, focused, dense: true });
   // The query bar takes one row below the tabs, and a refused date one more.
   const bodyHeight = Math.max(1, height - tabRows - 1 - (dateError ? 1 : 0));
-  const columns = useMemo(() => !curveTab ? COLUMNS : basisActive ? fitChartTableColumns(BASIS_CURVE_COLUMNS, width, BASIS_DROP_ORDER) : CURVE_COLUMNS,
-    [basisActive, curveTab, width]);
+  // A Cboe price is the settlement itself, so its curve has no separate last trade.
+  const settlesOnly = data?.source === "cboe";
+  const settleLabel = data?.settlementDate ? `SETTLE ${data.settlementDate.slice(5)}` : "SETTLE";
+  // Cash-settled roots (ES, CL's Brent, VX) have no first notice day to show.
+  const noNotice = !data?.contracts.some((row) => row.firstNotice);
+  const columns = useMemo(() => {
+    // Labelled before fitting: a dated header is wider than the column's numbers.
+    const shown = (list: DataTableColumn[]) => list.filter((entry) => !(settlesOnly && entry.id === "price") && !(noNotice && entry.id === "notice"))
+      .map((entry) => entry.id === "settle" ? { ...entry, label: settleLabel } : entry);
+    return !curveTab ? fitChartTableColumns(shown(COLUMNS), width, CONTRACTS_DROP_ORDER)
+      : basisActive ? fitChartTableColumns(shown(BASIS_CURVE_COLUMNS), width, BASIS_DROP_ORDER)
+        : fitChartTableColumns(shown(CURVE_COLUMNS), width, CURVE_DROP_ORDER);
+  }, [basisActive, curveTab, noNotice, settleLabel, settlesOnly, width]);
   const formatValue = useCallback((value: number) => curvePrice(value, root), [root]);
   const formatChange = useCallback((value: number) => curveChangeText(value, root), [root]);
-  const caption = `${sentenceCase(data?.quoteUnit ?? data?.currency ?? "price")} by contract month`;
+  const unit = data ? curveUnitLabel(data) : null;
+  const caption = `${sentenceCase(unit ?? "price")} by contract month`;
   // The strip keeps the curve's shape and the selected contract in one row.
   const strip = curveTab ? curveStrip(curves, formatValue, { caption: "Price", selectedPointId: selectedId }) : null;
   // Delayed contract quotes move all session; the curve follows them once a
@@ -177,8 +200,11 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
   // A past date with no archived curve says why in the body, not behind the warning.
   const emptyPast = !!requestedDate && !!data && !data.contracts.length;
   // Thin contracts join the data warnings: the info row has no room for them beside the quote times.
+  // A long in these can be assigned delivery: the hedge a trader rolls before first notice.
+  const delivering = data?.contracts.filter((row) => row.inDelivery).map((row) => curveContractCode(row.symbol)) ?? [];
   usePaneNoticeFooter({ registrationId: "futures-curve:notices", focused,
-    notices: emptyPast ? [] : [...data?.gaps ?? [], ...thinCount ? [thinContractsNotice(thinCount)] : []] });
+    notices: emptyPast ? [] : [...data?.gaps ?? [], ...thinCount ? [thinContractsNotice(thinCount)] : [],
+      ...delivering.length ? [`${delivering.join(", ")} ${delivering.length === 1 ? "is" : "are"} past first notice.`] : []] });
   const delay = Math.max(0, ...(data?.contracts.map((row) => row.delayMinutes ?? 0) ?? []));
   usePaneStatusFooter({ registrationId: "futures-curve", loading: resource.loading, error: resource.error,
     hints: [
@@ -186,7 +212,7 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
       ...requestedDate ? [{ id: "latest", key: "c", label: "urrent", title: "Current Curve", onPress: () => selectDate("") }] : [],
     ],
     info: data ? [
-      { id: "source", parts: [{ text: `${requestedDate ? "daily archive" : data.source === "cboe" ? "settlement" : delay > 0 ? `${delay}m delayed` : "dated quotes"} · ${data.quoteUnit ?? data.currency ?? "units unavailable"} · ${curveTimestamp(newest)}${newest?.includes("T") ? " UTC" : ""}`, tone: "muted" }] },
+      { id: "source", parts: [{ text: `${requestedDate ? "daily archive" : data.source === "cboe" ? "settlement" : delay > 0 ? `${delay}m delayed` : "dated quotes"} · ${unit ?? "units unavailable"} · ${curveTimestamp(newest)}${newest?.includes("T") ? " UTC" : ""}`, tone: "muted" }] },
       ...(staleCount ? [{ id: "stale", parts: [{ text: `${staleCount} of ${data.contracts.length} stale`, tone: "warning" as const }] }] : []),
       ...(spot ? [{ id: "spot", parts: [spot.status === "ok" ? { text: curveSpotLabel(spot, root, clock), tone: "muted" as const }
         : { text: `Basis blank: ${spot.reason}`, tone: "warning" as const }] }] : []),
@@ -202,10 +228,18 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
     strip,
   } : null;
   const renderCell = useCallback((row: FuturesContract, column: DataTableColumn) => {
-    if (column.id === "symbol") return { text: row.symbol };
-    if (column.id === "expiry") return { text: row.expiration, color: colors.textMuted };
-    // Without the AS OF column, a stale quote shows on its price, and so does a print too old for the spot.
-    if (column.id === "price") return { text: curvePrice(row.price, root), color: curveTab && (row.stale || basis.get(row.symbol)?.thin) ? colors.warning : undefined };
+    // A contract past first notice can be assigned delivery.
+    if (column.id === "symbol") return { text: row.symbol, color: row.inDelivery ? colors.warning : undefined };
+    if (column.id === "expiry") return { text: row.lastTrade ?? row.expiration, color: colors.textMuted };
+    if (column.id === "notice") return { text: row.firstNotice ?? "--", color: row.inDelivery ? colors.warning : colors.textMuted };
+    if (column.id === "settle") return { text: curvePrice(row.settlement ?? null, root) };
+    // A past curve's settled row has no separate last trade: its price is the settlement.
+    if (column.id === "price") {
+      const lastTrade = requestedDate && row.settlement != null ? null : row.price;
+      // Beside its settlement the last trade is the secondary price; without one it is the row's price.
+      return { text: curvePrice(lastTrade, root), color: curveTab && (row.stale || basis.get(row.symbol)?.thin) ? colors.warning
+        : row.settlement != null ? colors.textMuted : undefined };
+    }
     if (column.id === "change") {
       const text = curveChangeText(row.change ?? null, root);
       return { text, color: text.startsWith("+") ? colors.positive : text.startsWith("-") && /[1-9]/.test(text) ? colors.negative : colors.textMuted };
@@ -222,7 +256,7 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
     if (column.id === "oi") return { text: integer(row.openInterest) };
     if (column.id === "volume") return { text: integer(row.volume) };
     return { text: curveTimestamp(row.asOf), color: row.stale ? colors.warning : colors.textMuted };
-  }, [basis, changes, colors, curveTab, root]);
+  }, [basis, changes, colors, curveTab, requestedDate, root]);
   return <Box width={width} height={height} flexDirection="column">
     {tabStrip}
     <QueryBar width={width} filters={[{

package/src/plugins/builtin/fx-matrix/index.tsx

@@ -20,6 +20,7 @@ import { TextAttributes, useUiCapabilities } from "../../../ui";
 import { useAssetData } from "../../runtime";
 import { summarizeFxRates, fxStatusLabel } from "../../../utils/fx-status";
 import type { PluginModule } from "../plugin-module";
+import { fxRateObservations } from "../shared/fx-rate-freshness";
 import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import { useAutoRefresh, useUpdatedAgo } from "../../../react/auto-refresh";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
@@ -28,7 +29,6 @@ import { CURRENCY_FLAG_REGIONS, FX_CURRENCIES, formatRate, resolveCurrencies, ty
 import { crossMovePercent, directionTint, nextTintLevel } from "./direction";
 import { FX_MATRIX_REPORT_OPTIONS, fxMatrixReportNotices, fxMatrixSettings } from "./settings";
 import { createFxExportMetadata } from "./export";
-import { fxRateObservations } from "./freshness";
 
 const FX_MATRIX_PANE_ID = "fx-matrix";
 /** Stable identity: a fresh literal here would reload the board every render. */

package/src/plugins/builtin/gpu/board.tsx

@@ -12,7 +12,7 @@ import { Box, Text, TextAttributes, useUiCapabilities } from "../../../ui";
 import { loadGpuHistory } from "./client";
 import { GpuPriceLadder } from "./ladder";
 import {
-  gpuAvailability, gpuBoardSections, gpuChange, gpuChangeColor, gpuChangeWindows, gpuHeadline, gpuPrice, gpuPriceLadder, gpuShortSource, gpuSparklineSeries, gpuTime, gpuVariant,
+  gpuAvailability, gpuBoardSections, gpuChange, gpuChangeColor, gpuChangesLocked, gpuChangeWindows, gpuHeadline, gpuPrice, gpuPriceLadder, gpuShortSource, gpuSparklineSeries, gpuTime, gpuVariant,
   type GpuChangeKey,
 } from "./model";
 
@@ -23,10 +23,10 @@ const CHANGE_LABELS: Record<GpuChangeKey, string> = { change1d: "1D", change7d:
 /** A line needs three observations; two are a step, not a trend. */
 const MIN_TREND_POINTS = 3;
 
-export function GpuModelQuery({ rows, model, setModel, width, allowAll = true }: {
-  rows: readonly GpuBoardRow[]; model: string; setModel: (value: string) => void; width: number; allowAll?: boolean;
+/** The GPU picker: the GPUs on the board, or on a free board every GPU, since each has its own free preview. */
+export function GpuModelQuery({ models, model, setModel, width, allowAll = true }: {
+  models: readonly string[]; model: string; setModel: (value: string) => void; width: number; allowAll?: boolean;
 }) {
-  const models = useMemo(() => [...new Set(rows.map((row) => row.gpuModel))].sort(), [rows]);
   return <QueryBar width={width} filters={[{ id: "gpu", label: "GPU", value: model, ...(allowAll ? { defaultValue: "" } : {}),
     options: [...(allowAll ? [{ value: "", label: "All GPUs" }] : []), ...models.map((value) => ({ value, label: value }))], onChange: setModel }]} />;
 }
@@ -79,9 +79,9 @@ function boardColumns(width: number, options: { windows: GpuChangeKey[]; trend:
   ];
 }
 
-export function GpuBoard({ rows, asOf, model, setModel, selectedId, select, width, height, focused }: {
-  rows: GpuBoardRow[]; asOf: string | null; model: string; setModel: (value: string) => void; selectedId: string; select: (row: GpuBoardRow, open?: boolean) => void;
-  width: number; height: number; focused: boolean;
+export function GpuBoard({ rows, models, asOf, model, setModel, selectedId, select, emptyTitle, width, height, focused }: {
+  rows: GpuBoardRow[]; models: readonly string[]; asOf: string | null; model: string; setModel: (value: string) => void; selectedId: string; select: (row: GpuBoardRow, open?: boolean) => void;
+  emptyTitle: string; width: number; height: number; focused: boolean;
 }) {
   const colors = useThemeColors();
   const sections = useMemo(() => gpuBoardSections(rows, model), [rows, model]);
@@ -95,6 +95,8 @@ export function GpuBoard({ rows, asOf, model, setModel, selectedId, select, widt
   const medium = width >= 100;
   const asOfDay = asOf?.slice(0, 10) ?? null;
   const columns = boardColumns(width, { windows, trend, range: visible.some((row) => row.stats), availability: visible.some((row) => row.availability) });
+  // A free preview row's moves are Pro's; the cell says so, and the footer's upgrade hint unlocks them.
+  const lockedCell: DataTableCell = { text: "Pro", value: null, color: colors.textDim };
 
   const renderCell = (item: BoardRow, column: DataTableColumn, _index: number, state: { selected: boolean }): DataTableCell => {
     if (!isSectionedItemRow(item)) return EMPTY_TABLE_CELL;
@@ -121,8 +123,9 @@ export function GpuBoard({ rows, asOf, model, setModel, selectedId, select, widt
         if (!quartiles && stats.min === stats.max) return { text: "" };
         return { text: quartiles ? `${gpuPrice(stats.p25)}–${gpuPrice(stats.p75)}` : `${gpuPrice(stats.min)}–${gpuPrice(stats.max)}`, color: colors.textDim };
       }
-      case "unavailableChange": return { text: "-", value: null, color: colors.textMuted };
+      case "unavailableChange": return gpuChangesLocked(row) ? lockedCell : { text: "-", value: null, color: colors.textMuted };
       case "change1d": case "change7d": case "change30d": {
+        if (gpuChangesLocked(row)) return lockedCell;
         const value = row[column.id];
         return value == null ? { text: "-", value: null, color: colors.textMuted } : { text: gpuChange(value), value, color: gpuChangeColor(value, colors) };
       }
@@ -148,7 +151,7 @@ export function GpuBoard({ rows, asOf, model, setModel, selectedId, select, widt
     }
   };
 
-  const query = <GpuModelQuery rows={rows} model={model} setModel={setModel} width={width} />;
+  const query = <GpuModelQuery models={models} model={model} setModel={setModel} width={width} />;
   return <DataTableView<BoardRow> columns={columns} items={items} rootWidth={width} rootHeight={height} focused={focused}
     rootBefore={ladder.length ? <ChartTableHeader width={width} height={height} tableRows={items.length} tableColumns={columns} query={query}
       chart={{ maxRows: ladder.length + 1, minRows: Math.min(3, ladder.length + 1), strip: null,
@@ -159,5 +162,5 @@ export function GpuBoard({ rows, asOf, model, setModel, selectedId, select, widt
       onChange: (_id, row) => { if (row && isSectionedItemRow(row)) select(row.item); } }}
     isNavigable={isSectionedItemRow} renderSectionHeader={renderSectionedRowHeader}
     getItemKey={rowKey} onActivate={(row) => { if (isSectionedItemRow(row)) select(row.item, true); }} sortColumnId={null} sortDirection="asc"
-    selectedTextOverridesCellColor renderCell={renderCell} emptyStateTitle="No GPU rental prices match." />;
+    selectedTextOverridesCellColor renderCell={renderCell} emptyStateTitle={emptyTitle} />;
 }

package/src/plugins/builtin/gpu/changes.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useMemo } from "react";
-import type { GpuBoardRow, GpuEvent } from "../../../api-client/gpu";
+import type { GpuEvent } from "../../../api-client/gpu";
 import {
   Badge, buildSectionedRows, DataTableView, EMPTY_TABLE_CELL, isSectionedItemRow, PaneStatusBody, renderSectionedRowHeader,
   usePaneNoticeFooter, usePaneStatusFooter, type DataTableCell, type DataTableColumn, type SectionedRow,
@@ -30,8 +30,8 @@ function changeColumns(width: number, allModels: boolean, availabilityWidth: num
 }
 
 /** Dated price moves, newest day first: provider, old to new, and the move as a chip coloured by its sign. */
-export function GpuChanges({ board, model, setModel, reloadBoard, width, height, focused }: {
-  board: GpuBoardRow[]; model: string; setModel: (value: string) => void; reloadBoard: () => void; width: number; height: number; focused: boolean;
+export function GpuChanges({ models, model, setModel, reloadBoard, width, height, focused }: {
+  models: readonly string[]; model: string; setModel: (value: string) => void; reloadBoard: () => void; width: number; height: number; focused: boolean;
 }) {
   const colors = useThemeColors();
   const loader = useCallback((force: boolean) => loadGpuEvents(model || undefined, force), [model]);
@@ -84,7 +84,7 @@ export function GpuChanges({ board, model, setModel, reloadBoard, width, height,
 
   return <PaneStatusBody loading={resource.loading && !resource.data} error={!resource.data ? resource.error : null} subject="GPU price changes">
     <DataTableView<ChangeRow> columns={columns} items={items} rootWidth={width} rootHeight={height} focused={focused}
-      rootBefore={<GpuModelQuery rows={board} model={model} setModel={setModel} width={width} />}
+      rootBefore={<GpuModelQuery models={models} model={model} setModel={setModel} width={width} />}
       selection={{ kind: "id", selectedId: selected && items.some((item) => item.key === selected) ? selected : firstId, getId: rowKey,
         onChange: (id) => setSelected(String(id)) }}
       isNavigable={isSectionedItemRow} renderSectionHeader={renderSectionedRowHeader}

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

@@ -4,7 +4,7 @@ import type { GpuBoardPayload, GpuEventsPayload, GpuHistoryPayload, GpuHistoryQu
 import { createPluginCache } from "../../../data/plugin-cache";
 import type { DataProvider } from "../../../types/data-provider";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
-import { equityFiveDayReturn, GPU_EQUITIES } from "./model";
+import { equityFiveDayReturn, GPU_EQUITIES, gpuPreviewRows, type GpuPreviewRow } from "./model";
 
 export const GPU_NOT_AVAILABLE = "GPU rental prices are not available yet.";
 const cacheOptions = { source: "gloom-cloud", schemaVersion: 3, policy: { staleMs: 5 * 60_000, expireMs: 7 * 86_400_000 } };
@@ -116,6 +116,24 @@ export const loadGpuHistory = (seriesId: string, force = false) => loadCloudReso
   () => fetchGpuHistory({ seriesId, limit: 10_000 }), { force, validate: validateHistory });
 export const loadGpuReferences = (force = false) => loadCloudResource(gpuHistoryCache, scopedKey("reference-catalog"),
   () => fetchGpuHistory({ basis: "reference", limit: 10_000 }), { force, validate: validateHistory });
+/**
+ * The free board is three rows of one GPU. The rows it leaves out for the
+ * GPUs a reader asks about come from each GPU's own free preview, the latest
+ * rows the history serves without an account. A Pro board needs none.
+ */
+export function gpuPreviewModels(board: Pick<GpuBoardPayload, "access" | "rows">, models: readonly string[]): string[] {
+  if (!board.access?.locked) return [];
+  return [...new Set(models)].filter((model) => model && !board.rows.some((row) => row.gpuModel === model));
+}
+export async function fetchGpuModelPreviews(models: readonly string[], client: Pick<GpuApi, "getCloudGpuHistory"> = apiClient): Promise<GpuPreviewRow[]> {
+  const previews = await Promise.all(models.map((gpuModel) => fetchGpuHistory({ gpuModel, limit: 10 }, client)));
+  return previews.flatMap((payload) => gpuPreviewRows(payload.points));
+}
+export const loadGpuModelPreviews = async (models: readonly string[], force = false): Promise<GpuPreviewRow[]> => {
+  const previews = await Promise.all(models.map((gpuModel) => loadCloudResource(gpuHistoryCache, scopedKey(`preview:${gpuModel}`),
+    () => fetchGpuHistory({ gpuModel, limit: 10 }), { force, validate: validateHistory })));
+  return previews.flatMap((preview) => gpuPreviewRows(preview.payload.points));
+};
 export const loadGpuEvents = (gpuModel?: string, force = false) => loadCloudResource(gpuEventsCache, scopedKey(gpuModel ?? "all"),
   () => fetchGpuEvents(gpuModel), { force, validate: validateEvents });
 

package/src/plugins/builtin/gpu/equities.tsx

@@ -16,11 +16,10 @@ import { displayWidth, truncateToDisplayWidth } from "../../../utils/format";
 import { quoteBoardFooterInfo, quoteBoardStatus, renderQuoteBoardCell, useQuoteBoard } from "../shared/use-quote-board";
 import { GpuModelQuery } from "./board";
 import { loadGpuEquityHistory } from "./client";
-import { GPU_EQUITIES, GPU_EQUITY_GROUPS, gpuChange, gpuChangeColor, gpuEquityRows, gpuPrice, gpuShortSource, gpuVariant } from "./model";
+import { GPU_EQUITIES, GPU_EQUITY_GROUPS, gpuChange, gpuChangeColor, gpuChangesLocked, gpuEquityGap, gpuEquityRows, gpuPrice, gpuShortSource, gpuVariant, type GpuEquityRow } from "./model";
 
 const SYMBOLS = GPU_EQUITIES.map(({ symbol }) => symbol);
-type EquityRow = ReturnType<typeof gpuEquityRows>[number];
-type Row = SectionedRow<EquityRow>;
+type Row = SectionedRow<GpuEquityRow>;
 const rowKey = (row: Row) => row.key;
 
 function equityColumns(width: number): DataTableColumn[] {
@@ -39,8 +38,9 @@ function equityColumns(width: number): DataTableColumn[] {
 }
 
 /** Related shares by what ties them to GPU rents, each beside the list price that ties it. */
-export function GpuEquities({ board, model, setModel, reloadBoard, width, height, focused }: {
-  board: GpuBoardRow[]; model: string; setModel: (value: string) => void; reloadBoard: () => void; width: number; height: number; focused: boolean;
+export function GpuEquities({ board, models, locked, model, setModel, reloadBoard, width, height, focused }: {
+  board: GpuBoardRow[]; models: readonly string[]; locked: boolean; model: string; setModel: (value: string) => void; reloadBoard: () => void;
+  width: number; height: number; focused: boolean;
 }) {
   const colors = useThemeColors();
   const provider = useAssetData();
@@ -54,7 +54,7 @@ export function GpuEquities({ board, model, setModel, reloadBoard, width, height
   const history = useAsyncResource(loader);
   useAutoRefresh(history.updatedAt, history.load);
   usePaneRefreshKey(() => { reloadBoard(); refresh(); void history.reload(); }, { focused });
-  const rows = useMemo(() => gpuEquityRows(board, model || "H100"), [board, model]);
+  const rows = useMemo(() => gpuEquityRows(board, model || "H100", locked), [board, model, locked]);
   const items = useMemo(() => buildSectionedRows(GPU_EQUITY_GROUPS.map((group) => ({ label: group.label,
     items: rows.filter((row) => (group.roles as readonly string[]).includes(row.role)) })), (row) => row.symbol), [rows]);
   const historyMap = useMemo(() => new Map(history.data?.map((entry) => [entry.symbol, entry]) ?? []), [history.data]);
@@ -70,10 +70,13 @@ export function GpuEquities({ board, model, setModel, reloadBoard, width, height
     if (!isSectionedItemRow(item)) return EMPTY_TABLE_CELL;
     const row = item.item;
     const reference = row.reference;
+    // A figure the free preview leaves out reads Pro; a share with no series names the one it lacks.
+    const lockedCell: DataTableCell = { text: "Pro", value: null, color: colors.textDim };
+    const gapCell = row.gap === "pro" ? lockedCell : { text: "" };
     switch (column.id) {
       case "symbol": return { text: row.symbol, color: colors.textBright, attributes: TextAttributes.BOLD };
       case "source": {
-        if (!reference) return { text: "", color: colors.textDim };
+        if (!reference) return { text: gpuEquityGap(row) ?? "", color: colors.textDim };
         const name = gpuShortSource(reference);
         const variant = [row.gpuModel, ...gpuVariant(reference)].join(" ");
         // The name keeps its room; the variant gives way first.
@@ -83,9 +86,10 @@ export function GpuEquities({ board, model, setModel, reloadBoard, width, height
           {rest >= 4 ? <Text fg={state.selected ? colors.selectedText : colors.textDim}>{`  ${truncateToDisplayWidth(variant, rest)}`}</Text> : null}
         </Box> };
       }
-      case "gpuPrice": return reference ? { text: gpuPrice(reference.pricePerGpuHr), value: reference.pricePerGpuHr, color: colors.textBright } : { text: "" };
+      case "gpuPrice": return reference ? { text: gpuPrice(reference.pricePerGpuHr), value: reference.pricePerGpuHr, color: colors.textBright } : gapCell;
       case "gpuChange": {
-        if (!reference) return { text: "" };
+        if (!reference) return gapCell;
+        if (gpuChangesLocked(reference)) return lockedCell;
         const value = reference.change7d;
         return value == null ? { text: "-", value: null, color: colors.textMuted } : { text: gpuChange(value), value, color: gpuChangeColor(value, colors) };
       }
@@ -102,7 +106,7 @@ export function GpuEquities({ board, model, setModel, reloadBoard, width, height
     }
   }, [colors]);
   return <DataTableView<Row> columns={equityColumns(width)} items={items} rootWidth={width} rootHeight={height} focused={focused}
-    rootBefore={<GpuModelQuery rows={board} model={model || "H100"} setModel={setModel} width={width} allowAll={false} />}
+    rootBefore={<GpuModelQuery models={models} model={model || "H100"} setModel={setModel} width={width} allowAll={false} />}
     selection={{ kind: "id", selectedId: selected, getId: rowKey, onChange: (id) => setSelected(String(id)) }} getItemKey={rowKey}
     isNavigable={isSectionedItemRow} renderSectionHeader={renderSectionedRowHeader}
     getRowVersion={(row) => isSectionedItemRow(row) ? [quotes.get(row.item.symbol)?.quote?.lastUpdated, quotes.get(row.item.symbol)?.loading,