gloomberb 0.16.1 → 0.16.3

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

@@ -5,13 +5,28 @@ import { compositeAxisTicks } from "../../../components/chart/composite/format";
 import type { CompositeAxisDomain } from "../../../components/chart/composite/types";
 import { FUTURES_CONTRACTS, tickDecimals } from "../futures/contracts";
 import { formatPercentileRank } from "../../../utils/format";
+import { cryptoPairCoin, isFuturesSymbol } from "../shared/crypto-pair";
+import { parseReportTime } from "../../../utils/utc-time";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
 
+/**
+ * CME crypto futures have a curve but no FUT board row, so their name and tick
+ * live here rather than in the catalogue the board lists. Outright ticks:
+ * BTC $5, ETH $0.50, SOL $0.05, XRP $0.0005 (each $25 a contract).
+ */
+const CRYPTO_CURVE_ROOTS: readonly { code: string; name: string; tick: number }[] = [
+  { code: "BTC", name: "Bitcoin", tick: 5 }, { code: "ETH", name: "Ether", tick: 0.5 },
+  { code: "SOL", name: "Solana", tick: 0.05 }, { code: "XRP", name: "XRP", tick: 0.0005 },
+];
+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: `${row.code} ${row.name}` })),
+  ...FUTURES_CONTRACTS.filter((row) => row.curve !== false).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) })),
 ];
 
+/** A root typed as an argument, a stored pane setting or a request: every listed root, crypto included. */
 export function normalizeCurveRoot(value: unknown): string | null {
   if (typeof value !== "string") return null;
   const raw = value.trim().toUpperCase().replace(/=F$/, "");
@@ -19,6 +34,26 @@ 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. */
+export function unsupportedCurveRootMessage(value: unknown): string {
+  const examples = ["ES", "CL", "GC", "ZN"].filter((root) => CURVE_ROOTS.some((row) => row.value === root));
+  return `Unsupported futures root: ${String(value)}. Try ${examples.join(", ")}.`;
+}
+
+/**
+ * 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.
+ */
+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;
+}
+
 /**
  * Treasury futures trade in fractions of a 32nd (ZT to 1/256, ZF 1/128, ZN
  * 1/64, ZB and UB 1/32), so the catalogue leaves their tick unset. A root
@@ -32,7 +67,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;
+  const tick = FUTURES_CONTRACTS.find((row) => row.code === root)?.tick ?? CRYPTO_CURVE_ROOTS.find((row) => row.code === root)?.tick;
   return tick == null ? 5 : Math.max(2, tickDecimals(tick));
 }
 
@@ -155,17 +190,166 @@ const CHANGE_COLUMNS: Readonly<Record<string, CurveLookback>> = { change1w: "1W"
 
 type CurveSortKey = "symbol" | "expiration" | "price" | "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): FuturesContract[] {
+  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 key = keys[id] ?? "expiration";
   const lookback = CHANGE_COLUMNS[id];
-  const value = (row: FuturesContract) => lookback ? changes?.get(row.symbol)?.[lookback] ?? null : row[key] ?? null;
+  const basisKey = BASIS_COLUMNS[id];
+  const value = (row: FuturesContract) => lookback ? changes?.get(row.symbol)?.[lookback] ?? null
+    : basisKey ? basis?.get(row.symbol)?.[basisKey] ?? null : row[key] ?? null;
   return [...rows].sort((a, b) => compareSortValues(value(a), value(b), direction));
 }
 
 const DAY_MS = 86_400_000;
 
+/**
+ * The quote each crypto root's basis is measured against: the terminal's USD
+ * pair, the same quote every other pane shows, not the CME reference rate, so
+ * a small gap to settlement is expected. A root missing here has no basis
+ * columns; add its spot symbol to give it some.
+ */
+const BASIS_SPOT_SYMBOLS: ReadonlyMap<string, string> = new Map([
+  ["BTC", "BTC-USD"], ["ETH", "ETH-USD"], ["SOL", "SOL-USD"], ["XRP", "XRP-USD"],
+]);
+
+export function basisSpotSymbol(root: string): string | null {
+  return BASIS_SPOT_SYMBOLS.get(root) ?? null;
+}
+
+/** Crypto trades around the clock, so a spot quote older than this no longer prices a live future. */
+const SPOT_STALE_MS = 10 * 60_000;
+/** A free account's quote is held back on purpose; that delay is not staleness, so it is allowed on top. */
+const DELAYED_SPOT_MS = 15 * 60_000;
+
+/** The spot a curve's basis uses, or why there is none. `asOf` is the quote's own time, never the fetch's. */
+export interface CurveSpot {
+  symbol: string;
+  price: number | null;
+  /** UTC ISO instant of the quote. */
+  asOf: string | null;
+  status: "ok" | "stale" | "missing";
+  reason: string | null;
+}
+
+export interface SpotQuote {
+  price: number;
+  lastUpdated: number;
+  stale?: boolean;
+  dataSource?: string;
+}
+
+const positive = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value) && value > 0;
+
+function quoteAge(ms: number): string {
+  const minutes = Math.floor(ms / 60_000);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  return hours < 48 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
+}
+
+/** Judges one spot quote at `now`: usable, older than the rule allows, or absent. */
+export function curveSpot(symbol: string, quote: SpotQuote | null | undefined, now: number): CurveSpot {
+  if (!quote || !positive(quote.price)) return { symbol, price: null, asOf: null, status: "missing", reason: `no ${symbol} quote` };
+  const time = quote.lastUpdated;
+  if (!Number.isFinite(time) || time <= 0) {
+    return { symbol, price: quote.price, asOf: null, status: "stale", reason: `${symbol} quote has no time` };
+  }
+  const asOf = new Date(time).toISOString().replace(".000Z", "Z");
+  const age = now - time;
+  const limit = SPOT_STALE_MS + (quote.dataSource === "delayed" ? DELAYED_SPOT_MS : 0);
+  if (age > limit) return { symbol, price: quote.price, asOf, status: "stale", reason: `${symbol} quote is ${quoteAge(age)} old` };
+  if (quote.stale === true) return { symbol, price: quote.price, asOf, status: "stale", reason: `${symbol} quote is stale` };
+  return { symbol, price: quote.price, asOf, status: "ok", reason: null };
+}
+
+/** How far the contract trades over (positive) or under spot, in percent. */
+export function vsSpotPct(futures: number | null | undefined, spot: number | null | undefined): number | null {
+  return positive(futures) && positive(spot) ? (futures / spot - 1) * 100 : null;
+}
+
+/** Calendar days from the UTC date of the spot's timestamp to the contract's expiration date. */
+export function daysToExpiry(spotTime: number, expiration: string): number | null {
+  const expiry = Date.parse(`${expiration}T00:00:00Z`);
+  if (!Number.isFinite(spotTime) || !Number.isFinite(expiry)) return null;
+  const spotDay = Date.parse(`${new Date(spotTime).toISOString().slice(0, 10)}T00:00:00Z`);
+  return Math.round((expiry - spotDay) / DAY_MS);
+}
+
+/** The premium over spot as a yearly rate, on a 365-day year. Blank on or past expiry, where it has no meaning. */
+export function annualisedBasisPct(futures: number | null | undefined, spot: number | null | undefined, days: number | null): number | null {
+  if (!positive(futures) || !positive(spot) || days == null || !Number.isFinite(days) || days <= 0) return null;
+  return (futures / spot - 1) * 365 / days * 100;
+}
+
+/** A contract that printed longer than this before the spot quote is too old to read against it. */
+const CONTRACT_PRINT_MAX_AGE_MS = 60 * 60_000;
+
+export interface ContractBasis {
+  vsSpotPct: number | null;
+  annualisedBasisPct: number | null;
+  /** Priced and not flagged stale, but its last print is over an hour before spot: a thin month. */
+  thin: boolean;
+}
+
+const NO_BASIS: ContractBasis = { vsSpotPct: null, annualisedBasisPct: null, thin: false };
+
+/**
+ * One contract's basis. Blank without a usable spot, and for a contract whose
+ * own price is missing or stale: an old future against a live spot misleads.
+ * So does a print more than an hour older than the spot (`thin`): the server's
+ * stale flag allows two sessions, which a quote that moves all day outruns. A
+ * date-only `asOf` is UTC midnight of that date, one that cannot be read
+ * counts as old, and a print newer than the spot is never old (the spot of a
+ * delayed feed trails the futures).
+ */
+export function contractBasis(row: Pick<FuturesContract, "price" | "stale" | "expiration" | "asOf">, spot: CurveSpot): ContractBasis {
+  if (spot.status !== "ok" || spot.asOf == null || row.stale) return NO_BASIS;
+  const vs = vsSpotPct(row.price, spot.price);
+  if (vs == null) return NO_BASIS;
+  const spotTime = Date.parse(spot.asOf);
+  const printed = parseReportTime(row.asOf)?.time ?? null;
+  if (printed == null || spotTime - printed > CONTRACT_PRINT_MAX_AGE_MS) return { ...NO_BASIS, thin: true };
+  return { vsSpotPct: vs, annualisedBasisPct: annualisedBasisPct(row.price, spot.price, daysToExpiry(spotTime, row.expiration)), thin: false };
+}
+
+/** A basis in percent, signed; one that rounds to zero stays unsigned. */
+export function curveBasisPercent(value: number | null, decimals: number): string {
+  if (value == null) return "--";
+  const text = Math.abs(value).toFixed(decimals);
+  return /[1-9]/.test(text) ? `${value > 0 ? "+" : "-"}${text}%` : `${text}%`;
+}
+
+/** The footer's spot: `spot BTC-USD 67,250.10 · 07:25 UTC`, with the date when the quote is not from today. */
+export function curveSpotLabel(spot: CurveSpot, root: string, now: number): string {
+  const decimals = curvePriceDecimals(root);
+  const price = spot.price == null ? "--" : spot.price.toLocaleString("en-US", { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
+  const stamp = curveTimestamp(spot.asOf);
+  const today = new Date(now).toISOString().slice(0, 10);
+  return `spot ${spot.symbol} ${price} · ${spot.asOf?.startsWith(today) ? stamp.slice(11) : stamp} UTC`;
+}
+
+/** The basis columns' sort values, which live beside the contract rather than on it. */
+export type CurveBasisRows = ReadonlyMap<string, ContractBasis>;
+
+export function curveBasisRows(rows: readonly FuturesContract[], spot: CurveSpot | null): CurveBasisRows {
+  return new Map(rows.map((row) => [row.symbol, spot ? contractBasis(row, spot) : NO_BASIS]));
+}
+
+/** The contracts a good spot left blank for their old print. */
+export function thinContractCount(basis: Iterable<ContractBasis>): number {
+  let count = 0;
+  for (const row of basis) if (row.thin) count += 1;
+  return count;
+}
+
+/** The footer warning that thin contracts have no basis: the pane's `!` notice, which keeps the footer row for the quote times. */
+export function thinContractsNotice(count: number): string {
+  return `Basis blank on ${count} thin contract${count === 1 ? "" : "s"} (last print over 1h before spot)`;
+}
+
 /** A past date for the as-of view: empty (or "latest") for the live curve, else YYYY-MM-DD no later than today. */
 export function curveAsOfDate(value: unknown, now = new Date()): string {
   const date = typeof value === "string" ? value.trim() : "";

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

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { chartTableChromeRows, ChartTableHeader, CurveSurface, curveGhostColors, DataTableView, Notice, PaneStatusBody, QueryBar, useChartTableSelection, usePaneNoticeFooter, usePaneStatusFooter, usePaneTabs, type DataTableColumn, type StatItem } from "../../../components";
+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";
@@ -13,8 +14,9 @@ import { nextHeaderSort, type SortDirection } from "../../../utils/sort-values";
 import { useAutoRefresh } from "../../../react/auto-refresh";
 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 { curveAsOfDate, curveAxisPrice, curveChangeText, curveContractChanges, curvePrice, curveRank, curveTimestamp, DEFAULT_CURVE_HORIZON, futuresCurveSeries, newestQuote, normalizeCurveRoot, sortCurveContracts, type CurveContractChanges } from "./model";
+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";
 
 const TABS = [{ value: "curve", label: "Curve" }, { value: "contracts", label: "Contracts" }];
 const COLUMNS: DataTableColumn[] = [
@@ -38,6 +40,19 @@ const CURVE_COLUMNS: DataTableColumn[] = [
   { id: "change1m", label: "VS 1M", width: 10, align: "right" },
   ...COLUMNS.slice(4, -1),
 ];
+// 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 },
+  { id: "vsSpot", label: "VS SPOT", width: 9, align: "right" },
+  { id: "annBasis", label: "ANN BASIS", width: 11, align: "right" },
+  ...CURVE_COLUMNS.slice(3),
+];
+const BASIS_DROP_ORDER = ["percentile", "volume", "change1m", "oi"];
+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;
 const signedPercent = (value: number | null) => value == null ? "--" : formatPercentRaw(value);
 const integer = (value: number | null) => value == null ? "--" : value.toLocaleString("en-US");
 const contractKey = (row: FuturesContract) => row.symbol;
@@ -50,7 +65,7 @@ export function FuturesCurvePane(props: PaneProps) {
   const requested = pane?.settings?.root ?? pane?.params?.root ?? "ES";
   const root = normalizeCurveRoot(requested);
   return root ? <FuturesCurveView key={root} {...props} root={root} />
-    : <PaneStatusBody error={`Unsupported futures root: ${String(requested)}`} subject="futures curve" />;
+    : <PaneStatusBody error={unsupportedCurveRootMessage(requested)} subject="futures curve" />;
 }
 
 function FuturesCurveView({ width, height, focused, root }: PaneProps & { root: string }) {
@@ -79,6 +94,23 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
   // A pending date change must never relabel the previous curve as the new one.
   const data = resource.data?.date === requestedDate ? resource.data.payload : null;
   usePaneTitle(`CTM ${root}`);
+  const curveTab = tab === "curve";
+  // The Curve tab of a crypto root reads against spot; a past date has no spot history.
+  const spotSymbol = basisSpotSymbol(root);
+  const basisActive = curveTab && !requestedDate && spotSymbol != null;
+  const spotSymbols = useMemo(() => basisActive ? [spotSymbol] : NO_SYMBOLS, [basisActive, spotSymbol]);
+  const { quotes: spotQuotes } = useQuoteBoard(spotSymbols);
+  const [clock, setClock] = useState(() => Date.now());
+  useEffect(() => {
+    if (!basisActive) return;
+    setClock(Date.now());
+    const timer = setInterval(() => setClock(Date.now()), SPOT_CLOCK_MS);
+    return () => clearInterval(timer);
+  }, [basisActive]);
+  const spotState = spotSymbol ? spotQuotes.get(spotSymbol) : undefined;
+  // Until the first answer there is nothing to say: no reason, only blank cells.
+  const spot = useMemo(() => !basisActive || !spotSymbol || !spotState || spotState.loading && !spotState.quote ? null
+    : curveSpot(spotSymbol, spotState.quote, clock), [basisActive, clock, spotState, spotSymbol]);
   const staleCount = data?.contracts.filter((row) => row.stale).length ?? 0;
   const newest = data ? newestQuote(data.contracts) : null;
   // A past curve is named by the session it holds: a weekend or holiday date shows the session before it.
@@ -86,8 +118,9 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
     requestedDate ? Date.parse(`${requestedDate}T00:00:00Z`) : Date.now(), requestedDate ? data.asOf ?? requestedDate : undefined) : [],
   [data, colors, horizon, requestedDate]);
   const changes = useMemo<CurveContractChanges>(() => data ? curveContractChanges(data) : new Map(), [data]);
-  const rows = useMemo(() => sortCurveContracts(data?.contracts ?? [], sort.columnId, sort.direction, changes), [data, sort, changes]);
-  const curveTab = tab === "curve";
+  const basis = useMemo(() => curveBasisRows(basisActive ? data?.contracts ?? [] : [], spot), [basisActive, data, spot]);
+  const thinCount = useMemo(() => thinContractCount(basis.values()), [basis]);
+  const rows = useMemo(() => sortCurveContracts(data?.contracts ?? [], sort.columnId, sort.direction, changes, basis), [data, sort, changes, basis]);
   // The curve tab lists the contracts the chart plots; Contracts keeps every one.
   const curveRows = useMemo(() => {
     const charted = new Set(curves[0]?.points.map((point) => point.id));
@@ -108,7 +141,8 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
   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 = curveTab ? CURVE_COLUMNS : COLUMNS;
+  const columns = useMemo(() => !curveTab ? COLUMNS : basisActive ? fitChartTableColumns(BASIS_CURVE_COLUMNS, width, BASIS_DROP_ORDER) : CURVE_COLUMNS,
+    [basisActive, curveTab, 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`;
@@ -142,7 +176,9 @@ 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;
-  usePaneNoticeFooter({ registrationId: "futures-curve:notices", focused, notices: emptyPast ? [] : data?.gaps ?? [] });
+  // Thin contracts join the data warnings: the info row has no room for them beside the quote times.
+  usePaneNoticeFooter({ registrationId: "futures-curve:notices", focused,
+    notices: emptyPast ? [] : [...data?.gaps ?? [], ...thinCount ? [thinContractsNotice(thinCount)] : []] });
   const delay = Math.max(0, ...(data?.contracts.map((row) => row.delayMinutes ?? 0) ?? []));
   usePaneStatusFooter({ registrationId: "futures-curve", loading: resource.loading, error: resource.error,
     hints: [
@@ -152,6 +188,8 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
     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" }] },
       ...(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 }] }] : []),
     ] : [],
   });
   const tableChromeRows = chartTableChromeRows(columns, width);
@@ -166,8 +204,8 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
   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.
-    if (column.id === "price") return { text: curvePrice(row.price, root), color: curveTab && row.stale ? colors.warning : undefined };
+    // 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 };
     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 };
@@ -176,11 +214,15 @@ function FuturesCurveView({ width, height, focused, root }: PaneProps & { root:
       const change = changes.get(row.symbol)?.[column.id === "change1w" ? "1W" : "1M"] ?? null;
       return { text: curveChangeText(change, root), color: colors.textMuted };
     }
+    if (column.id === "vsSpot" || column.id === "annBasis") {
+      const cell = basis.get(row.symbol);
+      return { text: column.id === "vsSpot" ? curveBasisPercent(cell?.vsSpotPct ?? null, 2) : curveBasisPercent(cell?.annualisedBasisPct ?? null, 1), color: colors.textMuted };
+    }
     if (column.id === "percentile") return { text: row.samples < 2 || row.percentile == null ? "--" : row.percentile.toFixed(0) };
     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 };
-  }, [changes, colors, curveTab, root]);
+  }, [basis, changes, colors, curveTab, root]);
   return <Box width={width} height={height} flexDirection="column">
     {tabStrip}
     <QueryBar width={width} filters={[{

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

@@ -2,6 +2,7 @@ import type { GpuObservation } from "../../../api-client/gpu";
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchGpuBoard, fetchGpuEvents, fetchGpuHistory, loadGpuEquityHistory } from "./client";
 import { GPU_TABS, gpuArgument, gpuBasisLabel, gpuChange, gpuEquityRows, gpuEventDate, gpuProvenanceLabel, gpuLabel, gpuRows, gpuSource, gpuTab } from "./model";
+import { quoteFreshnessFields } from "../shared/report-freshness";
 
 const observationRow = (row: GpuObservation) => ({ gpu: gpuLabel(row), source: gpuSource(row), basis: gpuBasisLabel(row.basis),
   price: row.pricePerGpuHr, availability: row.availability, observedAt: row.observedAt, effectiveAt: row.effectiveAt, provenance: row.provenance ?? "live", provenanceLabel: gpuProvenanceLabel(row, true),
@@ -26,9 +27,11 @@ export const gpuHeadless: HeadlessPaneDefinition<"bundle"> = {
     const tab = gpuTab(args.options.tab);
     const board = await fetchGpuBoard(ctx.apiClient);
     const metadata = { asOf: board.asOf, stale: board.stale, complete: board.status === "available" && !board.access?.locked, unit: "USD/GPU-hour", access: board.access };
+    // Prices observed on providers' pages, not a feed; each board row says whether its source has gone quiet.
+    const freshness = { source: "GPU cloud providers", status: "not-a-feed" as const, basis: "observed prices" };
     if (tab === "history") {
       const history = await fetchGpuHistory({ ...(model ? { gpuModel: model } : {}), limit: 10_000 }, ctx.apiClient);
-      return { sections: [{ title: "Dated observations", columns: [...columns.filter((column) => !column.key.startsWith("change")), { key: "provenanceLabel", header: "Record" }], rows: history.points.map(observationRow) }], complete: !history.access?.locked, metadata: { ...metadata, access: history.access ?? board.access }, errors: board.gaps };
+      return { sections: [{ title: "Dated observations", columns: [...columns.filter((column) => !column.key.startsWith("change")), { key: "provenanceLabel", header: "Record" }], rows: history.points.map(observationRow) }], freshness: { ...freshness, oldest: null }, complete: !history.access?.locked, metadata: { ...metadata, access: history.access ?? board.access }, errors: board.gaps };
     }
     if (tab === "changes") {
       const payload = await fetchGpuEvents(model || undefined, ctx.apiClient);
@@ -41,7 +44,7 @@ export const gpuHeadless: HeadlessPaneDefinition<"bundle"> = {
         oldPrice: event.oldPrice, newPrice: event.newPrice, changePct: event.changePct, kind: event.kind,
         oldMembers: event.oldMembers, newMembers: event.newMembers, provenance: event.provenance ?? "live",
         provenanceLabel: gpuProvenanceLabel(event, true), evidenceUrl: event.evidenceUrl ?? null, sourceUrl: event.sourceUrl ?? null,
-        oldAvailability: event.oldAvailability ?? null, newAvailability: event.newAvailability ?? null })) }], complete: !payload.access?.locked, metadata: { ...metadata, access: payload.access ?? board.access }, errors: board.gaps };
+        oldAvailability: event.oldAvailability ?? null, newAvailability: event.newAvailability ?? null })) }], freshness: { ...freshness, oldest: null }, complete: !payload.access?.locked, metadata: { ...metadata, access: payload.access ?? board.access }, errors: board.gaps };
     }
     if (tab === "equities") {
       const related = gpuEquityRows(board.rows, model || "H100");
@@ -51,6 +54,7 @@ export const gpuHeadless: HeadlessPaneDefinition<"bundle"> = {
         const history = histories.find((entry) => entry.symbol === row.symbol);
         return { symbol: row.symbol, role: row.role, price: quote?.price ?? null, change1d: quote?.changePercent ?? null,
           change5d: history?.value ?? null, fiveDayAsOf: history?.asOf ?? null, quoteAsOf: quote?.lastUpdated ? new Date(quote.lastUpdated).toISOString() : null,
+          ...quoteFreshnessFields(quote),
           gpu: row.reference ? gpuLabel(row.reference) : row.gpuModel, gpuSource: row.reference ? gpuSource(row.reference) : null, gpuChange7d: row.reference?.change7d ?? null };
       }));
       return { sections: [{ title: "Related equities", columns: [
@@ -62,6 +66,6 @@ export const gpuHeadless: HeadlessPaneDefinition<"bundle"> = {
     }
     const rows = gpuRows(board.rows, model).map((row) => ({ ...observationRow(row), change1d: row.change1d, change7d: row.change7d,
       change30d: row.change30d, stale: row.stale, sample: row.stats ?? null }));
-    return { sections: [{ title: "GPU rental prices", columns, rows }], complete: !board.access?.locked, metadata, errors: board.gaps };
+    return { sections: [{ title: "GPU rental prices", columns, rows }], freshness, complete: !board.access?.locked, metadata, errors: board.gaps };
   },
 };

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

@@ -1,8 +1,8 @@
 import { Box, Span, Text, TextAttributes, useUiCapabilities } from "../../../ui";
 import { useThemeColors } from "../../../theme/theme-context";
 import { blendHex } from "../../../theme/colors";
-import { displayWidth, truncateToDisplayWidth } from "../../../utils/format";
-import { gpuAxisTicks, gpuBasisColor, gpuBasisLabel, gpuPrice, type GpuLadderRow } from "./model";
+import { truncateToDisplayWidth } from "../../../utils/format";
+import { gpuAxisLabels, gpuBasisColor, gpuBasisLabel, gpuPrice, type GpuAxisLabel, type GpuLadderRow } from "./model";
 
 const LABEL_CELLS = 28;
 const VALUE_CELLS = 17;
@@ -10,14 +10,13 @@ const VALUE_CELLS = 17;
 const position = (value: number, low: number, high: number) => high > low ? (value - low) / (high - low) : 0.5;
 const percent = (ratio: number) => `${(Math.max(0, Math.min(1, ratio)) * 100).toFixed(2)}%`;
 
-/** The domain every basis shares, padded to whole axis steps so the ends never touch a band. */
-function gpuLadderDomain(rows: readonly GpuLadderRow[]): { low: number; high: number; ticks: number[] } | null {
+/** The domain every basis shares, padded so the ends never touch a band. */
+function gpuLadderDomain(rows: readonly GpuLadderRow[]): { low: number; high: number } | null {
   if (!rows.length) return null;
   const min = Math.min(...rows.map((row) => row.min));
   const max = Math.max(...rows.map((row) => row.max));
   const pad = Math.max((max - min) * 0.04, max * 0.02, 0.05);
-  const low = Math.max(0, min - pad), high = max + pad;
-  return { low, high, ticks: gpuAxisTicks(low, high).filter((tick) => tick >= low && tick <= high) };
+  return { low: Math.max(0, min - pad), high: max + pad };
 }
 
 /** Terminal cells of one track: thin rule for the range, heavy for the quartiles, a bar at the median. */
@@ -51,7 +50,10 @@ export function GpuPriceLadder({ rows, width, height, selected }: {
   const valueCells = wide ? VALUE_CELLS : 6;
   // Two cells of padding, two gaps, and one spare so the value never clips.
   const trackCellsWidth = Math.max(8, width - labelCells - valueCells - 5);
-  const { low, high, ticks } = domain;
+  const { low, high } = domain;
+  // Labels may hang into the empty label and value columns of the axis row, so the end ticks stay centred.
+  const room = { left: labelCells + 1, right: valueCells + 1 };
+  const labels = gpuAxisLabels(low, high, trackCellsWidth, room);
   return (
     <Box flexDirection="column" width={width} height={shown.length + 1} paddingX={1} data-gloom-role="gpu-price-ladder">
       {shown.map((row) => {
@@ -91,37 +93,31 @@ export function GpuPriceLadder({ rows, width, height, selected }: {
           </Box>
         );
       })}
-      <Box flexDirection="row" height={1} gap={1}>
-        <Box width={labelCells} flexShrink={0} />
-        <GpuLadderAxis ticks={ticks} low={low} high={high} width={trackCellsWidth} desktop={desktop} />
-      </Box>
+      <GpuLadderAxis labels={labels} width={trackCellsWidth} room={room} desktop={desktop} />
     </Box>
   );
 }
 
-function GpuLadderAxis({ ticks, low, high, width, desktop }: { ticks: number[]; low: number; high: number; width: number; desktop: boolean }) {
+/**
+ * Each label centred on its tick, on the scale the bands and markers use. The
+ * desktop places real elements by percentage, as it does the markers; the
+ * terminal writes the whole axis row so an end label can hang past the track.
+ */
+function GpuLadderAxis({ labels, width, room, desktop }: { labels: readonly GpuAxisLabel[]; width: number; room: { left: number; right: number }; desktop: boolean }) {
   const colors = useThemeColors();
-  const label = (tick: number) => `$${Number.isInteger(tick) ? tick : tick.toFixed(1)}`;
   if (desktop) {
     return (
-      <Box width={width} height={1} flexShrink={0} style={{ position: "relative" }}>
-        {ticks.map((tick, index) => {
-          const ratio = position(tick, low, high);
-          const align = index === 0 ? "0%" : index === ticks.length - 1 ? "-100%" : "-50%";
-          return <Box key={tick} style={{ position: "absolute", left: percent(ratio), transform: `translateX(${align})` }}>
-            <Text fg={colors.textDim}>{label(tick)}</Text>
-          </Box>;
-        })}
+      <Box flexDirection="row" height={1}>
+        <Box width={room.left} flexShrink={0} />
+        <Box width={width} height={1} flexShrink={0} style={{ position: "relative" }}>
+          {labels.map((label) => <Box key={label.value} style={{ position: "absolute", left: percent(label.ratio), transform: "translateX(-50%)", whiteSpace: "nowrap" }}>
+            <Text fg={colors.textDim}>{label.text}</Text>
+          </Box>)}
+        </Box>
       </Box>
     );
   }
-  const line = Array.from({ length: width }, () => " ");
-  for (const [index, tick] of ticks.entries()) {
-    const text = label(tick);
-    const center = Math.round(position(tick, low, high) * (width - 1));
-    const start = index === 0 ? 0 : index === ticks.length - 1 ? width - displayWidth(text) : center - Math.floor(text.length / 2);
-    if (start < 0 || start + text.length > width || line.slice(Math.max(0, start - 1), start + text.length + 1).some((char) => char !== " ")) continue;
-    for (let i = 0; i < text.length; i++) line[start + i] = text[i]!;
-  }
-  return <Box width={width} height={1} flexShrink={0}><Text fg={colors.textDim}>{line.join("")}</Text></Box>;
+  const line = Array.from({ length: room.left + width + room.right }, () => " ");
+  for (const label of labels) for (let i = 0; i < label.text.length; i++) line[room.left + label.start + i] = label.text[i]!;
+  return <Box height={1} flexShrink={0}><Text fg={colors.textDim}>{line.join("").trimEnd()}</Text></Box>;
 }

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

@@ -151,7 +151,7 @@ export function gpuPriceLadder(rows: readonly GpuBoardRow[], model: string): Gpu
 }
 
 /** Round dollar ticks for a price axis: one, two or five times a power of ten, four to six of them. */
-export function gpuAxisTicks(low: number, high: number): number[] {
+function gpuAxisTicks(low: number, high: number): number[] {
   if (!(high > low)) return [low];
   const raw = (high - low) / 5;
   const power = 10 ** Math.floor(Math.log10(raw));
@@ -161,6 +161,32 @@ export function gpuAxisTicks(low: number, high: number): number[] {
   return ticks;
 }
 
+export interface GpuAxisLabel { value: number; text: string; ratio: number; start: number }
+
+/**
+ * Labels for a price axis `cells` wide over `low`..`high`: each centred on its
+ * tick's own value, on the linear scale the bands and markers use (`ratio`, and
+ * `start`, the first cell on the terminal), with the decimals the tick step
+ * needs so neighbours never read alike ($2.0 $2.1 $2.2, $2.05 $2.10). A label
+ * that would touch its neighbour or run past the room beside the axis is left
+ * out, never moved off its value.
+ */
+export function gpuAxisLabels(low: number, high: number, cells: number, room: { left: number; right: number } = { left: 0, right: 0 }): GpuAxisLabel[] {
+  const ticks = gpuAxisTicks(low, high).filter((tick) => tick >= low && tick <= high);
+  const digits = [0, 1, 2, 3].find((places) => ticks.every((tick) => Math.abs(Number(tick.toFixed(places)) - tick) < 1e-9)) ?? 3;
+  const labels: GpuAxisLabel[] = [];
+  for (const value of ticks) {
+    const text = `$${value.toFixed(digits)}`;
+    const ratio = high > low ? (value - low) / (high - low) : 0.5;
+    // The cell a track draws this value in, so the label's middle sits on the marker's cell.
+    const start = Math.round(ratio * (cells - 1)) - Math.floor(text.length / 2);
+    const previous = labels.at(-1);
+    if (start < -room.left || start + text.length > cells + room.right || (previous && start <= previous.start + previous.text.length)) continue;
+    labels.push({ value, text, ratio, start });
+  }
+  return labels;
+}
+
 /** Published notices use their effective date; observed changes use the dated evidence. */
 export const gpuEventDate = (event: Pick<GpuEvent, "origin" | "effectiveAt" | "observedAt">) =>
   event.origin === "published" ? event.effectiveAt ?? event.observedAt : event.observedAt;