gloomberb 0.16.0 → 0.16.2

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

@@ -1,4 +1,4 @@
-import { useCallback, useMemo, useRef, useState } from "react";
+import { useCallback, useMemo, useRef, useState, type ReactNode } from "react";
 import {
   DataTableView,
   usePaneFooter,
@@ -8,34 +8,42 @@ import {
   type PaneFooterSegment,
 } from "../../../components";
 import { handleRefreshKey } from "../../../components/data-table/table-pane";
+import { CountryFlag } from "../../../components/ui/country-flag";
 import { getSharedMarketDataCoordinator } from "../../../market-data/coordinator";
 import { useFxRatesMap } from "../../../market-data/hooks";
 import { resolveEntryData } from "../../../market-data/selectors";
 import { usePaneSettingValue } from "../../../state/app/context";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
-import { TextAttributes } from "../../../ui";
+import { TextAttributes, useUiCapabilities } from "../../../ui";
 import { useAssetData } from "../../runtime";
 import { summarizeFxRates, fxStatusLabel } from "../../../utils/fx-status";
 import type { PluginModule } from "../plugin-module";
 import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import { useAutoRefresh, useUpdatedAgo } from "../../../react/auto-refresh";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
-import { isStreamCarryingQuote } from "../shared/use-quote-board";
-import { fxLegQuoteKey, fxLegReferenceRate, fxLegTargets, fxLegs, liveFxLegEntry } from "./live-legs";
-import { MAJOR_CURRENCIES, formatRate, resolveCurrencies, type MajorCurrency } from "./pairs";
+import { fxLegQuoteKey, fxLegReferenceRate, fxLegTargets, fxLegs, fxLegsBehind, liveFxLegEntry } from "./live-legs";
+import { CURRENCY_FLAG_REGIONS, FX_CURRENCIES, formatRate, resolveCurrencies, type FxCurrency } from "./pairs";
+import { crossMovePercent, directionTint, nextTintLevel } from "./direction";
+import { fxMatrixSettings } from "./settings";
 import { createFxExportMetadata } from "./export";
 
 const FX_MATRIX_PANE_ID = "fx-matrix";
 /** Stable identity: a fresh literal here would reload the board every render. */
 const NO_SAVED_CURRENCIES: string[] = [];
 const BASE_COLUMN_WIDTH = 5;
+/** Room for a flag, a space and the code once the desktop draws the flag. */
+const FLAGGED_BASE_COLUMN_WIDTH = 6;
+const CURRENCY_FLAGS = new Map<string, ReactNode>(
+  FX_CURRENCIES.map((currency) => [currency, <CountryFlag region={CURRENCY_FLAG_REGIONS[currency]} />]),
+);
 const RATE_COLUMN_WIDTH = 10;
 /** Snapshot rates reload at this pace while the feed is not carrying every leg. */
 const FX_FALLBACK_REFRESH_MS = 60_000;
 
 function FxMatrixPane({ focused, width, height }: PaneProps) {
   const dataProvider = useAssetData();
+  const flagged = useUiCapabilities().nativePaneChrome === true;
   const [savedCurrencies] = usePaneSettingValue<string[]>("currencies", NO_SAVED_CURRENCIES);
   const currencies = useMemo(() => resolveCurrencies(savedCurrencies), [savedCurrencies]);
   const [selectedCurrency, setSelectedCurrency] = useState<string | null>(null);
@@ -80,6 +88,22 @@ function FxMatrixPane({ focused, width, height }: PaneProps) {
     }
     return references;
   }, [legEntries, legs, rates]);
+  // A cell's direction is its cross against the pair's previous close. Only a
+  // leg whose rate is the live quote's and whose quote carries a previous close
+  // counts, USD (the base) as 1: the first rate this pane drew is no daily
+  // reference, and a snapshot rate or a stale quote has no previous close to
+  // read against.
+  const directionReferences = useMemo(() => {
+    const references = new Map<string, number>([["USD", 1]]);
+    for (const leg of legs) {
+      if (!liveEntries.has(leg.currency)) continue;
+      const reference = fxLegReferenceRate(leg, legEntries.get(fxLegQuoteKey(leg)));
+      if (reference != null) references.set(leg.currency, reference);
+    }
+    return references;
+  }, [legEntries, legs, liveEntries]);
+  // The step each cell showed last, which a tick near a boundary keeps.
+  const tintLevels = useRef(new Map<string, number>());
   // Export the provenance of this render's rates, even if a provider response
   // arrives before React commits the next render and the user exports now.
   const rateEntries = new Map(currencies.map((currency) => {
@@ -99,47 +123,59 @@ function FxMatrixPane({ focused, width, height }: PaneProps) {
   // current relaxes the snapshot reload: a quote another pane loaded, or one
   // the stream stopped sending, would otherwise freeze the matrix. With
   // streaming off, the legs' own quote poll is the feed.
-  const allLegsLive = legs.every((leg) => {
-    const entry = legEntries.get(fxLegQuoteKey(leg));
-    if (!liveStreaming) return liveEntries.has(leg.currency) && (entry?.fetchedAt ?? 0) >= subscriptionStartedAt;
-    return isStreamCarryingQuote(entry, subscriptionStartedAt, freshnessNow);
+  const legsBehind = fxLegsBehind(legs, legEntries, {
+    liveStreaming,
+    liveCurrencies: new Set(liveEntries.keys()),
+    startedAt: subscriptionStartedAt,
+    now: freshnessNow,
   });
+  const allLegsLive = legsBehind.length === 0;
 
-  const refresh = useCallback(() => {
+  const reload = useCallback((codes: readonly string[]) => {
     const coordinator = getSharedMarketDataCoordinator();
     if (!coordinator) return;
-    for (const currency of currencies) {
+    for (const currency of codes) {
       if (currency === "USD") continue;
       void coordinator.loadFxRate(currency, { forceRefresh: true }).catch(() => {});
     }
-  }, [currencies]);
+  }, []);
+  const refresh = useCallback(() => reload(currencies), [currencies, reload]);
 
-  useAutoRefresh(snapshotFetchedAt || null, refresh, { intervalMs: allLegsLive ? null : FX_FALLBACK_REFRESH_MS });
+  // The reload that stands in for the feed asks only for the legs it is
+  // behind on: a thin pair that rarely ticks must not make every selected
+  // currency reload each minute.
+  useAutoRefresh(snapshotFetchedAt || null, () => reload(allLegsLive ? currencies : legsBehind), {
+    intervalMs: allLegsLive ? null : FX_FALLBACK_REFRESH_MS,
+  });
 
   const columns = useMemo<DataTableColumn[]>(() => [
-    { id: "base", label: "", width: BASE_COLUMN_WIDTH, align: "left" },
+    { id: "base", label: "", width: flagged ? FLAGGED_BASE_COLUMN_WIDTH : BASE_COLUMN_WIDTH, align: "left" },
     ...currencies.map((currency) => ({
       id: currency,
       label: currency,
       width: RATE_COLUMN_WIDTH,
       align: "right" as const,
+      headerLeading: flagged ? CURRENCY_FLAGS.get(currency) : undefined,
     })),
-  ], [currencies]);
+  ], [currencies, flagged]);
 
   const renderCell = useCallback((
-    row: MajorCurrency,
+    row: FxCurrency,
     column: DataTableColumn,
+    _index: number,
+    rowState: { selected: boolean },
   ): DataTableCell => {
     if (column.id === "base") {
       return {
         text: row,
         color: colors.textBright,
         attributes: TextAttributes.BOLD,
+        leading: flagged ? CURRENCY_FLAGS.get(row) : undefined,
       };
     }
 
-    const quoteCurrency = column.id as MajorCurrency;
-    if (row === quoteCurrency) return { text: formatRate(1, quoteCurrency), color: colors.textDim };
+    const quoteCurrency = column.id as FxCurrency;
+    if (row === quoteCurrency) return { text: formatRate(1), color: colors.textDim };
 
     const base = rates.get(row);
     const quote = rates.get(quoteCurrency);
@@ -150,8 +186,21 @@ function FxMatrixPane({ focused, width, height }: PaneProps) {
       return { text: pending ? "…" : "—", color: colors.textDim };
     }
     const reference = (referenceRates.get(row) ?? base) / (referenceRates.get(quoteCurrency) ?? quote);
-    return { text: formatRate(base / quote, quoteCurrency, reference), color: colors.text };
-  }, [rates, referenceRates, status.loading]);
+    const rowReference = directionReferences.get(row);
+    const columnReference = directionReferences.get(quoteCurrency);
+    const level = nextTintLevel(
+      tintLevels.current,
+      `${row}/${quoteCurrency}`,
+      rowReference != null && columnReference != null
+        ? crossMovePercent(base, rowReference, quote, columnReference)
+        : null,
+    );
+    // The cursor row keeps its selection colours; the tint leans on them.
+    const backgroundColor = rowState.selected
+      ? directionTint(level, { background: colors.selected, text: colors.selectedText })
+      : directionTint(level, { background: colors.bg, text: colors.text });
+    return { text: formatRate(base / quote, reference), color: colors.text, backgroundColor };
+  }, [directionReferences, flagged, rates, referenceRates, status.loading]);
 
   const handleKeyDown = useCallback((event: DataTableKeyEvent) => handleRefreshKey(event, refresh), [refresh]);
 
@@ -166,7 +215,7 @@ function FxMatrixPane({ focused, width, height }: PaneProps) {
   }, [status.loading, statusText, updatedAgo]);
 
   return (
-    <DataTableView<MajorCurrency>
+    <DataTableView<FxCurrency>
       focused={focused}
       selection={{
         kind: "id",
@@ -203,18 +252,7 @@ export const fxMatrixModule: PluginModule = {
       defaultMode: "floating",
       defaultFloatingSize: { width: 105, height: 14 },
       tableExport: true,
-      settings: (context) => ({
-        title: "FX Cross Rates Settings",
-        values: {
-          currencies: resolveCurrencies(context.settings.currencies as string[] | undefined),
-        },
-        fields: [{
-          key: "currencies",
-          label: "Currencies",
-          type: "ordered-multi-select",
-          options: MAJOR_CURRENCIES.map((currency) => ({ value: currency, label: currency })),
-        }],
-      }),
+      settings: fxMatrixSettings,
     },
   ],
 

package/src/plugins/builtin/fx-matrix/live-legs.ts

@@ -2,6 +2,7 @@ import type { QueryEntry } from "../../../market-data/result-types";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import type { Quote } from "../../../types/financials";
+import { isStreamCarryingQuote } from "../shared/use-quote-board";
 
 /** Currencies the market quotes as USD per unit; the rest quote as units per USD. */
 const USD_QUOTED = new Set(["EUR", "GBP", "AUD", "NZD"]);
@@ -69,6 +70,22 @@ export function liveFxLegEntry(
   };
 }
 
+/**
+ * The legs the feed is not carrying, whose snapshot rates a reload has to
+ * stand in for. With streaming off the legs' own quote poll is the feed.
+ */
+export function fxLegsBehind(
+  legs: readonly FxLeg[],
+  entries: ReadonlyMap<string, QueryEntry<Quote>>,
+  feed: { liveStreaming: boolean; liveCurrencies: ReadonlySet<string>; startedAt: number; now: number },
+): string[] {
+  return legs.filter((leg) => {
+    const entry = entries.get(fxLegQuoteKey(leg));
+    if (!feed.liveStreaming) return !(feed.liveCurrencies.has(leg.currency) && (entry?.fetchedAt ?? 0) >= feed.startedAt);
+    return !isStreamCarryingQuote(entry, feed.startedAt, feed.now);
+  }).map((leg) => leg.currency);
+}
+
 /** USD per unit at the pair's previous close: a rate that holds still for the session. */
 export function fxLegReferenceRate(leg: FxLeg, entry: QueryEntry<Quote> | undefined): number | null {
   const close = resolveEntryData(entry)?.previousClose;

package/src/plugins/builtin/fx-matrix/pairs.ts

@@ -1,27 +1,81 @@
-
+/** The default board, in its default order. */
 export const MAJOR_CURRENCIES = ["USD", "EUR", "GBP", "JPY", "CHF", "CAD", "AUD", "NZD"] as const;
-export type MajorCurrency = typeof MAJOR_CURRENCIES[number];
 
 /**
- * Preserve conventional quote precision and meaningful digits on inverse JPY
- * crosses. The digits are counted at `referenceRate` (the cross at a rate that
- * holds still) when there is one, so a live rate ticking across a power of ten,
- * such as JPY/AUD near 0.0100, keeps its decimals.
+ * Every currency the board can carry, in the order its settings list them: the
+ * majors, the other liquid currencies, then emerging markets by region.
+ */
+export const FX_CURRENCIES = [
+  ...MAJOR_CURRENCIES,
+  "SEK", "NOK", "DKK", "HKD", "SGD", "CNY", "CNH",
+  "KRW", "TWD", "INR", "IDR", "MYR", "PHP", "THB", "VND", "PKR",
+  "PLN", "CZK", "HUF", "RON", "UAH", "TRY", "KZT",
+  "ILS", "SAR", "AED", "QAR", "EGP", "ZAR", "NGN", "KES",
+  "MXN", "BRL", "CLP", "COP", "PEN", "ARS",
+] as const;
+export type FxCurrency = typeof FX_CURRENCIES[number];
+
+/** The flag each currency wears on the desktop and web; the euro is the EU's, not one member's. */
+export const CURRENCY_FLAG_REGIONS: Record<FxCurrency, string> = {
+  USD: "US", EUR: "EU", GBP: "GB", JPY: "JP", CHF: "CH", CAD: "CA", AUD: "AU", NZD: "NZ",
+  SEK: "SE", NOK: "NO", DKK: "DK", HKD: "HK", SGD: "SG", CNY: "CN", CNH: "CN",
+  KRW: "KR", TWD: "TW", INR: "IN", IDR: "ID", MYR: "MY", PHP: "PH", THB: "TH", VND: "VN", PKR: "PK",
+  PLN: "PL", CZK: "CZ", HUF: "HU", RON: "RO", UAH: "UA", TRY: "TR", KZT: "KZ",
+  ILS: "IL", SAR: "SA", AED: "AE", QAR: "QA", EGP: "EG", ZAR: "ZA", NGN: "NG", KES: "KE",
+  MXN: "MX", BRL: "BR", CLP: "CL", COP: "CO", PEN: "PE", ARS: "AR",
+};
+
+/** One-pick selections in the pane settings. Each fills the currency list, which stays editable. */
+export const CURRENCY_SETS: readonly { id: string; label: string; currencies: readonly FxCurrency[] }[] = [
+  { id: "majors", label: "Majors", currencies: MAJOR_CURRENCIES },
+  { id: "g10", label: "G10", currencies: [...MAJOR_CURRENCIES, "SEK", "NOK"] },
+  {
+    id: "asia",
+    label: "Asia",
+    currencies: ["USD", "JPY", "CNY", "CNH", "HKD", "SGD", "TWD", "KRW", "INR", "IDR", "MYR", "PHP", "THB", "VND", "PKR"],
+  },
+  {
+    id: "emea",
+    label: "EMEA",
+    currencies: [
+      "USD", "EUR", "GBP", "CHF", "SEK", "NOK", "DKK", "PLN", "CZK", "HUF", "RON", "UAH", "TRY", "KZT",
+      "ILS", "SAR", "AED", "QAR", "EGP", "ZAR", "NGN", "KES",
+    ],
+  },
+  { id: "americas", label: "Americas", currencies: ["USD", "CAD", "MXN", "BRL", "CLP", "COP", "PEN", "ARS"] },
+  { id: "all", label: "All", currencies: FX_CURRENCIES },
+];
+
+/**
+ * Decimals follow the rate's size, counted at `referenceRate` (the cross at a
+ * rate that holds still) when there is one, so a live rate ticking across a
+ * power of ten, such as JPY/AUD near 0.0100, keeps its decimals. From 50 up a
+ * rate reads two decimals (149.25, 1340.50, 33000.12); below 0.1 it keeps five
+ * significant digits, to eight decimals; everything between reads four.
  */
-export function formatRate(rate: number, toCurrency: string, referenceRate = rate): string {
+export function formatRate(rate: number, referenceRate = rate): string {
   if (!Number.isFinite(rate) || rate <= 0) return "—";
   const basis = Number.isFinite(referenceRate) && referenceRate > 0 ? referenceRate : rate;
-  const decimals = basis < 0.1 ? Math.min(8, 4 - Math.floor(Math.log10(basis))) : toCurrency === "JPY" ? 2 : 4;
+  const decimals = basis < 0.1 ? Math.min(8, 4 - Math.floor(Math.log10(basis))) : basis >= 50 ? 2 : 4;
   return rate.toFixed(decimals);
 }
 
+function isFxCurrency(code: unknown): code is FxCurrency {
+  return typeof code === "string" && FX_CURRENCIES.includes(code as FxCurrency);
+}
+
 /**
- * The saved currency selection, falling back to the majors when it is empty or
- * holds codes this board does not carry.
+ * The saved currency selection in its saved order, falling back to the majors
+ * when it is empty or holds no code this board carries. Unknown codes and
+ * repeats drop out. A string is a typed list, as in `--currencies USD,EUR` or
+ * `--currencies asia`: codes and set names, in any case.
  */
-export function resolveCurrencies(saved?: readonly string[]): MajorCurrency[] {
-  const resolved = (saved ?? []).filter(
-    (code): code is MajorCurrency => MAJOR_CURRENCIES.includes(code as MajorCurrency),
-  );
+export function resolveCurrencies(saved?: unknown): FxCurrency[] {
+  const codes: readonly unknown[] = typeof saved === "string"
+    ? saved.split(/[\s,]+/).flatMap((token): readonly string[] => (
+      CURRENCY_SETS.find((set) => set.id === token.toLowerCase())?.currencies ?? [token.toUpperCase()]
+    ))
+    : Array.isArray(saved) ? saved : [];
+  const resolved = [...new Set(codes.filter(isFxCurrency))];
   return resolved.length > 0 ? resolved : [...MAJOR_CURRENCIES];
 }

package/src/plugins/builtin/fx-matrix/settings.ts

@@ -0,0 +1,62 @@
+import type { PaneSettingsContext, PaneSettingsDef } from "../../../types/plugin";
+import { CURRENCY_SETS, FX_CURRENCIES, resolveCurrencies } from "./pairs";
+
+const CUSTOM_SET = "custom";
+
+let currencyNames: Intl.DisplayNames | null | undefined;
+
+/** ISO has no code for the offshore yuan, so the runtime has no name for it. */
+const CURRENCY_NAMES: Partial<Record<string, string>> = { CNH: "Chinese Yuan (Offshore)" };
+
+/** A currency's English name for the picker, or null where the runtime has no names. */
+function currencyName(code: string): string | null {
+  if (CURRENCY_NAMES[code]) return CURRENCY_NAMES[code]!;
+  try {
+    currencyNames ??= new Intl.DisplayNames(["en"], { type: "currency" });
+    const name = currencyNames.of(code);
+    return name && name !== code ? name : null;
+  } catch {
+    currencyNames = null;
+    return null;
+  }
+}
+
+/**
+ * Currencies are chosen as an ordered list. A set fills that list in one pick;
+ * the list stays editable, and reads as Custom once it stops matching a set.
+ */
+export function fxMatrixSettings(context: PaneSettingsContext): PaneSettingsDef {
+  const currencies = resolveCurrencies(context.settings.currencies);
+  const matching = CURRENCY_SETS.find((set) => (
+    set.currencies.length === currencies.length && set.currencies.every((code, index) => code === currencies[index])
+  ));
+  return {
+    title: "FX Cross Rates Settings",
+    values: { currencies, currencySet: matching?.id ?? CUSTOM_SET },
+    fields: [
+      {
+        key: "currencySet",
+        label: "Currency set",
+        type: "select",
+        options: [
+          ...CURRENCY_SETS.map((set) => ({ value: set.id, label: set.label })),
+          { value: CUSTOM_SET, label: "Custom" },
+        ],
+      },
+      {
+        key: "currencies",
+        label: "Currencies",
+        type: "ordered-multi-select",
+        searchable: true,
+        options: FX_CURRENCIES.map((code) => ({ value: code, label: code, description: currencyName(code) ?? undefined })),
+      },
+    ],
+    applyValue: (settings, field, value) => {
+      if (field.key !== "currencySet") return { ...settings, [field.key]: value };
+      // The set is a way to fill the list, never a setting of its own.
+      const { currencySet: _unused, ...rest } = settings;
+      const set = CURRENCY_SETS.find((candidate) => candidate.id === value);
+      return set ? { ...rest, currencies: [...set.currencies] } : rest;
+    },
+  };
+}

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;