gloomberb 0.16.0 → 0.16.2

package/src/plugins/builtin/correlation/matrix/model.ts

@@ -2,7 +2,8 @@ import { pricePointIntegrity, type PriceHistoryIntegrity } from "../../../../uti
 import type { QueryEntry } from "../../../../market-data/result-types";
 import { colors } from "../../../../theme/colors";
 import type { PricePoint } from "../../../../types/financials";
-import { dailyCloses, correlateDailyCloses, type CorrelationResult, type DailyClose } from "../compute";
+import { dailyCloses, correlateDailyCloses, type ChangeBasis, type CorrelationResult, type DailyClose } from "../compute";
+import { geoSeriesToken } from "../geo";
 import type { CorrelationRangePreset } from "../settings";
 import { clipPriceHistoryToRange } from "../../../../time-series/history-window";
 
@@ -17,6 +18,8 @@ export type SeriesStatus = "loading" | "ready" | "insufficient" | "empty" | "err
 export interface CorrelationSeries {
   symbol: string;
   prices: DailyClose[];
+  /** Prices correlate returns; a map series correlates its daily change. */
+  basis?: ChangeBasis;
   status: SeriesStatus;
   observationCount: number;
   integrity?: PriceHistoryIntegrity[];
@@ -25,7 +28,10 @@ export interface CorrelationSeries {
   fetchedAt?: number | null;
 }
 
+/** A map series shows its alias (HORMUZ, SUEZ.TANKER): the GEO prefix would leave no room for the name. */
 export function displaySymbol(symbol: string): string {
+  const geo = geoSeriesToken(symbol);
+  if (geo) return geo.length > 10 ? geo.slice(0, 10) : geo;
   return symbol.length > 5 ? symbol.slice(0, 5) : symbol;
 }
 
@@ -87,6 +93,15 @@ export function buildCorrelationSeries(symbol: string, history: readonly PricePo
   };
 }
 
+/** A map series' values as a matrix input: zero counts are kept, changes are level differences. */
+export function buildGeoCorrelationSeries(symbol: string, values: DailyClose[]): CorrelationSeries {
+  const observationCount = Math.max(0, values.length - 1);
+  return {
+    symbol, prices: values, basis: "difference", observationCount,
+    status: values.length === 0 ? "empty" : observationCount < MIN_CORRELATION_OBSERVATIONS ? "insufficient" : "ready",
+  };
+}
+
 export function rowHeaderColor(status: SeriesStatus): string {
   switch (status) {
     case "loading":
@@ -122,7 +137,7 @@ export function buildCorrelationMatrix(
       const rowSeries = seriesBySymbol.get(rowSym);
       const colSeries = seriesBySymbol.get(colSym);
       const result = rowSeries && colSeries
-        ? correlateDailyCloses(rowSeries.prices, colSeries.prices, MIN_CORRELATION_OBSERVATIONS)
+        ? correlateDailyCloses(rowSeries.prices, colSeries.prices, MIN_CORRELATION_OBSERVATIONS, rowSeries.basis, colSeries.basis)
         : { correlation: null, sampleSize: 0 };
       results.set(pairKey(rowSym, colSym), result);
       if (rowIndex < colIndex) {

package/src/plugins/builtin/correlation/matrix/selection.ts

@@ -1,6 +1,6 @@
 import { chartTableLayout } from "../../../../components/chart-table/layout";
-import { alignDailyCloses } from "../compute";
-import { buildRelationshipReturns, buildRollingCorrelationPoints } from "../relationship/model";
+import { alignDailyCloses, pairedChanges } from "../compute";
+import { buildRollingCorrelationPoints } from "../relationship/model";
 import type { CorrelationRangePreset } from "../settings";
 import type { CorrelationSeries } from "./model";
 
@@ -49,7 +49,9 @@ export function buildMatrixPairHistory(
   const aligned = alignDailyCloses(left?.prices ?? [], right?.prices ?? []).map((point) => ({
     ...point, date: new Date(`${point.dateKey}T00:00:00Z`),
   }));
-  const returns = buildRelationshipReturns(aligned);
+  const returns = pairedChanges(aligned, left?.basis, right?.basis).map(({ dateKey, left: leftReturn, right: rightReturn }) => ({
+    dateKey, date: new Date(`${dateKey}T00:00:00Z`), leftReturn, rightReturn,
+  }));
   const points = buildRollingCorrelationPoints(returns, window);
   const byTime = new Map(points.map((point) => [point.date.getTime(), point.close]));
   const values = points.map((point) => point.close);

package/src/plugins/builtin/correlation/relationship/model.ts

@@ -72,7 +72,7 @@ function alignRelationshipPrices(leftPoints: PricePoint[], rightPoints: PricePoi
   }));
 }
 
-export function buildRelationshipReturns(aligned: readonly Omit<RelationshipAlignedPoint, "ratio">[]): RelationshipReturnPoint[] {
+function buildRelationshipReturns(aligned: readonly Omit<RelationshipAlignedPoint, "ratio">[]): RelationshipReturnPoint[] {
   const returns: RelationshipReturnPoint[] = [];
   for (let index = 1; index < aligned.length; index++) {
     const previous = aligned[index - 1]!;

package/src/plugins/builtin/correlation/relationship/pane.tsx

@@ -43,6 +43,8 @@ import {
   buildRelationshipRatioSeries,
   buildRelationshipScatterPointsForDate,
   buildRelationshipStatItems,
+  formatRatioAxisValue,
+  formatRatioValue,
   type MultiLineChartSeries,
 } from "./view-model";
 
@@ -99,13 +101,13 @@ const MIN_PANEL_ROWS = 3;
 
 /** Each panel's axis reads at its own precision: whole index points, a ratio, a correlation. */
 function formatAxisValue(value: number, domain: CompositeAxisDomain): string {
-  if (domain.seriesIds.includes("ratio")) return formatNumber(value, Math.abs(value) >= 10 ? 1 : 3);
+  if (domain.seriesIds.includes("ratio")) return formatRatioAxisValue(value, domain);
   if (domain.seriesIds.includes("correlation")) return formatNumber(value, 2);
   return formatNumber(value, 0);
 }
 
 function formatLegendValue(value: number, series: ResolvedSeries): string {
-  if (series.id === "ratio") return formatNumber(value, 3);
+  if (series.id === "ratio") return formatRatioValue(value);
   if (series.id === "correlation") return formatNumber(value, 2);
   return formatNumber(value, 1);
 }

package/src/plugins/builtin/correlation/relationship/view-model.ts

@@ -1,7 +1,8 @@
 import type { ProjectedChartPoint } from "../../../../components/chart/core/data";
 import type { ScatterChartPoint } from "../../../../components/chart/static";
 import { colors } from "../../../../theme/colors";
-import { formatNumber } from "../../../../utils/format";
+import { formatNumber, formatSignificant } from "../../../../utils/format";
+import type { CompositeAxisDomain } from "../../../../components/chart/composite/types";
 import type { StatItem } from "../../../../components/ui";
 import type {
   RelationshipAlignedPoint,
@@ -20,6 +21,20 @@ function formatNullableNumber(value: number | null | undefined, decimals: number
   return typeof value === "number" && Number.isFinite(value) ? formatNumber(value, decimals) : "-";
 }
 
+/**
+ * A ratio's legend value at four significant digits, so a ratio of 0.000566
+ * does not read 0.001. Whole index points and correlations keep their own fixed decimals.
+ */
+export const formatRatioValue = (value: number) => formatSignificant(value);
+
+/** Ratio axis ticks need decimals that tell neighbours apart: 0.00040, 0.00045, 0.00050 where 0.001 would repeat. */
+export function formatRatioAxisValue(value: number, domain: Pick<CompositeAxisDomain, "min" | "max">): string {
+  if (Math.abs(value) >= 10) return formatNumber(value, 1);
+  const span = Math.abs(domain.max - domain.min);
+  const decimals = Number.isFinite(span) && span > 0 ? Math.min(10, Math.max(3, 1 - Math.floor(Math.log10(span)))) : 3;
+  return formatNumber(value, decimals);
+}
+
 export function buildIndexedPriceSeries(
   aligned: RelationshipAlignedPoint[],
   leftSymbol: string,

package/src/plugins/builtin/correlation/settings.ts

@@ -76,7 +76,7 @@ export function buildCorrelationSettingsDef(): PaneSettingsDef {
       {
         key: "symbolsText",
         label: "Tickers",
-        description: `Enter up to ${MAX_CORRELATION_TICKERS} tickers. Empty uses the default CORR preset.`,
+        description: `Enter up to ${MAX_CORRELATION_TICKERS} tickers or map series (GEO:HORMUZ). Empty uses the default CORR preset.`,
         type: "text",
         placeholder: formatTickerListInput(DEFAULT_CORRELATION_SYMBOLS),
       },

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

@@ -1,7 +1,7 @@
 import type { CotClass, CotClassSummary } from "../../../api-client/cot";
 import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchCotBoard, fetchCotContract } from "./client";
-import { COT_MAJOR_CODES, COT_SCOPES, cotClass, cotContractCode, cotInteger, cotMarketName, cotScope } from "./model";
+import { COT_MAJOR_CODES, COT_SCOPES, cotClass, cotContractCode, cotInteger, cotMarketName, cotScope, cotUnknownMarketMessage } from "./model";
 
 const camelClass = (id: CotClass) => id.replace(/-(\w)/g, (_match, letter: string) => letter.toUpperCase());
 const rounded = (value: number | null, digits: number) => value == null ? null : Number(value.toFixed(digits));
@@ -25,7 +25,10 @@ const POSITION_COLUMNS: HeadlessPaneColumn[] = [
 ];
 
 export const cotHeadless: HeadlessPaneDefinition<"bundle"> = {
-  shape: "bundle", argument: { kind: "free-text", optional: true, placeholder: "code or root", description: "CFTC market code or verified futures root; omit for the extremes board." },
+  shape: "bundle",
+  // Tuesday positions published the Friday after; two weeks without a new report means one was missed.
+  freshness: { source: "CFTC", status: "not-a-feed", basis: "weekly report", maxAgeMinutes: 14 * 24 * 60 },
+  argument: { kind: "free-text", optional: true, placeholder: "code or root", description: "CFTC market code or verified futures root; omit for the extremes board." },
   options: [{ key: "report", type: "enum", values: [{ value: "legacy" }, { value: "disaggregated" }], defaultValue: "legacy", description: "CFTC report family." },
     { key: "traderClass", type: "enum", values: ["noncommercial", "commercial", "producer", "swap", "managed-money", "other-reportable", "nonreportable"].map((value) => ({ value })), description: "Trader class for the extremes board; defaults by report family." },
     { key: "scope", type: "enum", values: COT_SCOPES.map(({ value }) => ({ value })), defaultValue: "major", description: "Markets on the extremes board, as in the pane." }],
@@ -35,7 +38,7 @@ export const cotHeadless: HeadlessPaneDefinition<"bundle"> = {
     const family = args.options.report === "disaggregated" ? "disaggregated" : "legacy";
     if (args.argument) {
       const code = cotContractCode(args.argument);
-      if (!code) throw new Error("Use a CFTC market code or supported futures root");
+      if (!code) throw new Error(cotUnknownMarketMessage(args.argument));
       const data = await fetchCotContract(code, family, ctx.apiClient);
       const classes = data.positions.map((row) => row.id);
       return { sections: [{ title: data.contract ? cotMarketName(data.contract.marketName) : code,

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

@@ -1,7 +1,7 @@
 import type { PluginModule } from "../plugin-module";
 import { cotBoardCache } from "./client";
 import { cotHeadless } from "./headless";
-import { COT_ROOT_OPTIONS, cotContractCode, cotRoot } from "./model";
+import { COT_ROOT_OPTIONS, cotContractCode, cotContractCodeForTicker, cotRoot, cotUnknownMarketMessage } from "./model";
 import { CotPane } from "./pane";
 
 export const cotModule: PluginModule = {
@@ -15,8 +15,8 @@ export const cotModule: PluginModule = {
       argOptions: () => COT_ROOT_OPTIONS }, headless: cotHeadless,
     createInstance: (context, options) => {
       const input = options?.arg?.trim();
-      const code = cotContractCode(input || context.activeTicker);
-      if (input && !code) throw new Error("Use a CFTC market code or supported futures root");
+      const code = input ? cotContractCode(input) : cotContractCodeForTicker(context.activeTicker);
+      if (input && !code) throw new Error(cotUnknownMarketMessage(input));
       return { title: code ? `COT ${cotRoot(code) ?? code}` : "CFTC Positioning", params: code ? { code } : undefined,
         settings: { report: options?.values?.report ?? "legacy" }, placement: "floating" as const };
     },

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

@@ -4,12 +4,13 @@ import type { ResolvedSeries } from "../../../time-series/types";
 import type { PricePoint } from "../../../types/financials";
 import { formatPriceObservation } from "../../../market-data/market/format";
 import { cleanFloat32Price } from "../../../cli/history-rows";
+import { cryptoPairCoin, isFuturesSymbol } from "../shared/crypto-pair";
 
 export const COT_CLASSES: Record<CotFamily, Array<{ value: CotClass; label: string }>> = {
   legacy: [{ value: "noncommercial", label: "Noncommercial" }, { value: "commercial", label: "Commercial" }, { value: "nonreportable", label: "Nonreportable" }],
   disaggregated: [{ value: "managed-money", label: "Managed Money" }, { value: "producer", label: "Producer/Merchant" }, { value: "swap", label: "Swap Dealers" }, { value: "other-reportable", label: "Other Reportables" }, { value: "nonreportable", label: "Nonreportable" }],
 };
-const ROOTS: Record<string, { code: string; exchange: string; priceSymbol: string | null; name: string }> = {
+const ROOTS: Record<string, { code: string; exchange: string; priceSymbol: string | null; name: string; crypto?: true }> = {
   ZN: { code: "043602", exchange: "CBT", priceSymbol: "ZN=F", name: "10-Year T-Note" },
   ZQ: { code: "045601", exchange: "CBT", priceSymbol: "ZQ=F", name: "30-Day Fed Funds" },
   CL: { code: "067651", exchange: "NYM", priceSymbol: "CL=F", name: "WTI Crude Oil" },
@@ -18,14 +19,27 @@ const ROOTS: Record<string, { code: string; exchange: string; priceSymbol: strin
   VX: { code: "1170E1", exchange: "CFE", priceSymbol: null, name: "VIX Futures" },
   SR3: { code: "134741", exchange: "CME", priceSymbol: null, name: "3-Month SOFR" },
   ES: { code: "13874A", exchange: "CME", priceSymbol: "ES=F", name: "E-Mini S&P 500" },
+  // CME crypto, verified against the CFTC board on 2026-10-09. Only the standard
+  // bitcoin and ether contracts return five years of front-price history; the
+  // micros, XRP and SOL come back with a single bar, so they chart no price.
+  BTC: { code: "133741", exchange: "CME", priceSymbol: "BTC=F", name: "Bitcoin", crypto: true },
+  ETH: { code: "146021", exchange: "CME", priceSymbol: "ETH=F", name: "Ether", crypto: true },
+  MBT: { code: "133742", exchange: "CME", priceSymbol: null, name: "Micro Bitcoin", crypto: true },
+  MET: { code: "146022", exchange: "CME", priceSymbol: null, name: "Micro Ether", crypto: true },
+  SOL: { code: "177741", exchange: "CME", priceSymbol: null, name: "Solana", crypto: true },
+  XRP: { code: "176740", exchange: "CME", priceSymbol: null, name: "XRP", crypto: true },
 };
 /** The roots `cotContractCode` accepts, labeled "ZQ 30-Day Fed Funds". */
-export const COT_ROOT_OPTIONS = Object.entries(ROOTS).map(([root, row]) => ({ value: root, label: `${root} ${row.name}` }));
+export const COT_ROOT_OPTIONS = Object.entries(ROOTS).map(([root, row]) => ({ value: root, label: root === row.name ? root : `${root} ${row.name}` }));
+/** The crypto roots named for a coin, which a coin pair (BTC-USD) can stand for. The micros have no pair. */
+const COIN_PAIR_ROOTS: ReadonlySet<string> = new Set(["BTC", "ETH", "SOL", "XRP"]);
 /**
  * Front-month price overlays for major markets without a root alias, each
  * checked to return five years of daily history (2026-09-24). Keyed by CFTC
  * code, never added to ROOTS: an alias would also claim the equity ticker under
  * the cursor (ZM, ZS, PL). No cash index stands in, so the dollar index has none.
+ * Bitcoin and ether are in ROOTS, where `cotContractCodeForTicker` keeps the
+ * same guard for their aliases.
  */
 const PRICE_OVERLAYS: Record<string, { exchange: string; priceSymbol: string }> = {
   "209742": { exchange: "CME", priceSymbol: "NQ=F" }, "239742": { exchange: "CME", priceSymbol: "RTY=F" },
@@ -37,7 +51,6 @@ const PRICE_OVERLAYS: Record<string, { exchange: string; priceSymbol: string }>
   "096742": { exchange: "CME", priceSymbol: "6B=F" }, "090741": { exchange: "CME", priceSymbol: "6C=F" },
   "232741": { exchange: "CME", priceSymbol: "6A=F" }, "092741": { exchange: "CME", priceSymbol: "6S=F" },
   "095741": { exchange: "CME", priceSymbol: "6M=F" },
-  "133741": { exchange: "CME", priceSymbol: "BTC=F" }, "146021": { exchange: "CME", priceSymbol: "ETH=F" },
   "023651": { exchange: "NYM", priceSymbol: "NG=F" }, "111659": { exchange: "NYM", priceSymbol: "RB=F" },
   "022651": { exchange: "NYM", priceSymbol: "HO=F" }, "06765T": { exchange: "NYM", priceSymbol: "BZ=F" },
   "085692": { exchange: "CMX", priceSymbol: "HG=F" }, "076651": { exchange: "NYM", priceSymbol: "PL=F" },
@@ -77,11 +90,31 @@ export const COT_SCOPES = [{ value: "major", label: "Major markets" }, { value:
 export type CotScope = typeof COT_SCOPES[number]["value"];
 export function cotScope(value: unknown): CotScope { return value === "all" ? "all" : "major"; }
 
+/** A CFTC code or root typed as an argument or stored in a pane: every alias, crypto included. */
 export function cotContractCode(value: unknown): string | null {
   if (typeof value !== "string") return null;
   const input = value.trim().toUpperCase().replace(/=F$/, "");
   return ROOTS[input === "VIX" ? "VX" : input]?.code ?? (/^[0-9A-Z]{5}[0-9A-Z+]$/.test(input) ? input : null);
 }
+/** What a market that is neither a root nor a CFTC code is told, with ones that work. */
+export function cotUnknownMarketMessage(value: unknown): string {
+  const roots = ["ES", "CL", "GC", "ZN"].filter((root) => ROOTS[root]);
+  return `Unknown market "${String(value)}". Try ${roots.join(", ")} or a CFTC market code such as ${ROOTS.GC!.code}.`;
+}
+/**
+ * The code for the ticker under the cursor, when COT is opened without an
+ * argument. The crypto aliases are also US ticker symbols (Grayscale's mini
+ * trusts are BTC and ETH, MetLife is MET), so a bare one is the equity's and
+ * never claims the market: only a futures symbol (BTC=F) or a coin pair
+ * (BTC-USD) does.
+ */
+export function cotContractCodeForTicker(ticker: unknown): string | null {
+  if (typeof ticker !== "string") return null;
+  const coin = cryptoPairCoin(ticker);
+  if (coin) return COIN_PAIR_ROOTS.has(coin) ? ROOTS[coin]!.code : null;
+  const input = ticker.trim().toUpperCase().replace(/=F$/, "");
+  return ROOTS[input]?.crypto && !isFuturesSymbol(ticker) ? null : cotContractCode(ticker);
+}
 /** The verified futures root a CFTC code belongs to, for titles readers recognize. */
 export function cotRoot(code: string): string | null {
   return Object.entries(ROOTS).find(([, row]) => row.code === code)?.[0] ?? null;

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

@@ -52,6 +52,8 @@ export const cpiHeadless: HeadlessPaneDefinition<"bundle"> = {
     const headline = data.rows.find((row) => row.code === "SA0") ?? null;
     const argument = Array.isArray(args.argument) ? args.argument.join(" ") : args.argument;
     const metadata = { ...data, complete: data.status === "available" };
+    const freshness = { source: "BLS", status: "not-a-feed" as const, basis: "monthly release",
+      asOf: data.release.releasedAt, nextExpectedAt: data.release.nextReleaseAt };
     if (argument) {
       const option = cpiRowOption(argument);
       const row = option ? data.rows.find((entry) => entry.id === option.value) : null;
@@ -66,12 +68,14 @@ export const cpiHeadless: HeadlessPaneDefinition<"bundle"> = {
             rows: historyRows(row, headline) },
         ],
         errors: data.gaps,
+        freshness,
         metadata: { ...metadata, rows: [row] },
       };
     }
     return {
       sections: [{ title: header, columns: SUMMARY_COLUMNS, rows: cpiRows(data).map((row) => reportRow(row)) }],
       errors: data.gaps,
+      freshness,
       metadata,
     };
   },

package/src/plugins/builtin/credit-boards/headless.ts

@@ -8,6 +8,7 @@ export const cdxHeadless: HeadlessPaneDefinition<"rows"> = {
   discovery: { aliases: ["CDX"], dataRequirements: ["Gloom Cloud index CDS endpoint"],
     limitations: ["Daily medians of public DTCC prints on the on-the-run 5Y contract", "HY and EM quote in price"] },
   shape: "rows",
+  freshness: { source: "DTCC", status: "not-a-feed", basis: "daily medians of public trades", cadence: "daily", observedKey: "date" },
   argument: { kind: "none" },
   options: [],
   columns: [
@@ -43,6 +44,7 @@ export const sovrHeadless: HeadlessPaneDefinition<"rows"> = {
   discovery: { aliases: ["SOVR", "WCDS"], dataRequirements: ["Gloom Cloud sovereign CDS endpoint"],
     limitations: ["Daily 5Y levels from public DTCC prints; thinly traded names can miss days"] },
   shape: "rows",
+  freshness: { source: "DTCC", status: "not-a-feed", basis: "daily levels of public trades", cadence: "daily", observedKey: "date" },
   argument: { kind: "none" },
   options: [],
   columns: [

package/src/plugins/builtin/credit-conditions/headless.ts

@@ -38,6 +38,7 @@ function createCreditConditionsHeadless(
     options: [],
     columns: COLUMNS,
     describe: "Credit Spreads",
+    freshness: { source: "FRED", status: "not-a-feed", basis: "daily index levels", cadence: "daily", observedKey: "date" },
     async load(args, ctx) {
       const result = await dependencies.load(
         args,

package/src/plugins/builtin/credit-documents/gauge.tsx

@@ -1,17 +1,14 @@
 import type { CreditHeadroom } from "../../../api-client/credit-documents";
+import { ratioBarGlyphs } from "../../../components/ui/ratio-bar";
 import { useThemeColors } from "../../../theme/theme-context";
 import { Box, Text, useUiCapabilities } from "../../../ui";
 import { covenantUsage, headroomTone } from "./model";
 
-const EIGHTHS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"];
 /** Where the limit sits along the gauge; the rest shows how far a breach runs past it. */
 const LIMIT_AT = 0.8;
 
-function blocks(cells: number): string {
-  const full = Math.floor(cells);
-  const eighth = Math.round((cells - full) * 8);
-  return eighth === 8 ? "█".repeat(full + 1) : `${"█".repeat(full)}${EIGHTHS[eighth]}`;
-}
+/** `cells` of a run `span` cells long, in eighth-cell block glyphs. */
+const blocks = (cells: number, span: number) => ratioBarGlyphs(cells / span, span, { resolution: "eighth" });
 
 /**
  * How much of a covenant's limit the reported metric uses, against a marker at
@@ -44,10 +41,10 @@ export function HeadroomGauge({ covenant, width, selected }: { covenant: CreditH
   // In cells the limit is a whole column: usage 1 fills up to it, a breach runs through it.
   const limit = Math.min(width - 1, Math.round(width * LIMIT_AT));
   const cells = Math.min(width, Math.max(0, usage) * limit);
-  const after = cells > limit + 1 ? blocks(cells - limit - 1) : "";
+  const after = cells > limit + 1 ? blocks(cells - limit - 1, width - limit - 1) : "";
   return (
     <Box flexDirection="row" width={width} overflow="hidden">
-      <Text fg={fill}>{blocks(Math.min(cells, limit)).padEnd(limit)}</Text>
+      <Text fg={fill}>{blocks(Math.min(cells, limit), limit).padEnd(limit)}</Text>
       <Text fg={marker} bg={cells > limit ? fill : undefined}>│</Text>
       {after ? <Text fg={fill}>{after}</Text> : null}
     </Box>

package/src/plugins/builtin/credit-documents/headless.ts

@@ -1,9 +1,11 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchCreditDocuments, fetchCreditInstrument, fetchCreditScreen } from "./client";
 import { CREDIT_TABS } from "./model";
+import { SEC_FILINGS } from "../shared/report-freshness";
 
 export const creditHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
+  freshness: SEC_FILINGS,
   argument: { kind: "ticker", description: "Issuer ticker, including exchange-qualified global symbols.", placeholder: "ticker" },
   discovery: { aliases: ["CRDOC"], dataRequirements: ["Gloom Cloud credit-document evidence"], limitations: [
     "Pro dataset; free accounts see a limited preview", "SEC credit documents with global issuer identifiers; other jurisdictions depend on connected sources",

package/src/plugins/builtin/crypto-board/headless.ts

@@ -40,6 +40,9 @@ export const cryptoBoardHeadless: HeadlessPaneDefinition<"rows"> = {
     aliases: ["CRYP"],
     dataRequirements: ["Gloom Cloud crypto markets"],
   },
+  // A board snapshot refreshed every few minutes; the pane streams, the report does not.
+  // Crypto trades around the clock, so a snapshot an hour old has stopped refreshing.
+  freshness: { status: "delayed", maxAgeMinutes: 60 },
   async load(args, ctx) {
     const kind = args.options.list === "stablecoin" ? "stablecoin" : "coin" satisfies CryptoAssetKind;
     const data = await fetchCryptoMarkets(ctx.apiClient);

package/src/plugins/builtin/custom-view/loader.ts

@@ -101,7 +101,7 @@ export async function loadViewSource(
   return {
     rows,
     columns,
-    errors: (loaded.result.errors ?? []).filter(Boolean),
+    errors: [...(loaded.result.errors ?? []), ...(loaded.result.notes ?? [])].filter(Boolean),
     sourceLabel: resolved.label,
   };
 }

package/src/plugins/builtin/debt-maturities/headless.ts

@@ -1,9 +1,11 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchDebtMaturities } from "./client";
 import { bucketShare, debtNotices } from "./model";
+import { SEC_FILINGS } from "../shared/report-freshness";
 
 export const debtMaturitiesHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
+  freshness: SEC_FILINGS,
   argument: {
     kind: "ticker",
     description: "SEC reporting issuer ticker.",
@@ -84,6 +86,8 @@ export const debtMaturitiesHeadless: HeadlessPaneDefinition<"bundle"> = {
         },
       ],
       metadata: { ...data },
+      // The latest filing dates the report; the history rows are past years, not stale data.
+      freshness: { asOf: data.latest?.asOf ?? null },
     };
   },
 };

package/src/plugins/builtin/debt-maturities/wall-bar.tsx

@@ -1,24 +1,18 @@
-import { Box, Text, useUiCapabilities } from "../../../ui";
+import { RatioBar } from "../../../components/ui/ratio-bar";
+import { Box, Text } from "../../../ui";
 import { colors } from "../../../theme/colors";
 import type { BucketBar } from "./model";
 
-const EIGHTHS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"];
 const CAP = "▸";
 
 /** Cells a capped bar keeps after its end for the cap. */
 export const WALL_CAP_RESERVE = 2;
 
-function blocks(cells: number): string {
-  const full = Math.floor(cells);
-  const eighth = Math.round((cells - full) * 8);
-  return eighth === 8 ? "█".repeat(full + 1) : `${"█".repeat(full)}${EIGHTHS[eighth]}`;
-}
-
 /**
  * One maturity bucket of the wall, inline in its table row. Dated buckets
  * share one scale; a bucket past it (Thereafter, open ended) runs to the end,
  * capped, so its length is never read as a measure; its PRINCIPAL cell says
- * how much. The desktop draws an element; the terminal draws block cells.
+ * how much.
  */
 export function WallBar({ bar, width, reserve, selected }: {
   bar: BucketBar | null;
@@ -27,37 +21,16 @@ export function WallBar({ bar, width, reserve, selected }: {
   reserve: number;
   selected: boolean;
 }) {
-  const isDesktopWeb = useUiCapabilities().nativePaneChrome === true;
   if (!bar || width <= 0) return <Text fg={colors.textDim}>{""}</Text>;
-  const scale = Math.max(1, width - reserve);
-  const labelColor = selected ? colors.selectedText : colors.text;
-
-  if (isDesktopWeb) {
-    return (
-      <Box width={width} flexDirection="row" alignItems="center" gap={1} overflow="hidden">
-        <Box flexGrow={1} flexShrink={1} minWidth={0} flexDirection="row" alignItems="center">
-          <Box
-            backgroundColor={colors.warning}
-            style={{
-              width: bar.capped ? "100%" : `${((bar.ratio * scale) / width * 100).toFixed(2)}%`,
-              height: "9px",
-              borderRadius: "2px",
-              minWidth: bar.ratio > 0 ? "2px" : "0",
-            }}
-          />
-        </Box>
-        {bar.capped ? <Text fg={labelColor}>{CAP}</Text> : null}
-      </Box>
-    );
-  }
-
-  if (bar.capped) {
-    return (
-      <Box flexDirection="row" width={width} overflow="hidden">
-        <Text fg={colors.warning}>{"█".repeat(scale)}</Text>
-        <Text fg={labelColor}>{` ${CAP}`}</Text>
-      </Box>
-    );
-  }
-  return <Text fg={colors.warning}>{blocks(bar.ratio * scale)}</Text>;
+  return (
+    <Box width={width} flexDirection="row" alignItems="center" overflow="hidden">
+      <RatioBar
+        ratio={bar.capped ? 1 : bar.ratio}
+        width={Math.max(1, width - reserve)}
+        color={colors.warning}
+        resolution="eighth"
+      />
+      {bar.capped ? <Text fg={selected ? colors.selectedText : colors.text}>{` ${CAP}`}</Text> : null}
+    </Box>
+  );
 }

package/src/plugins/builtin/dividend-yield/client.ts

@@ -6,6 +6,7 @@ import { resolveCurrencyUnit } from "../../../utils/currency-units";
 import { calendarMonthsBefore } from "../../../utils/calendar-date";
 import { inferCadence, trailingCashAt } from "./trailing-cash";
 import { dividendQuotePriceMetadata } from "./reference-price";
+import { mapQuote } from "../../../sources/gloomberb-cloud/normalizers";
 
 export const DIVIDENDS_CONNECTION_ID = "gloom-dividends";
 export const INCOMPLETE_DIVIDEND_HISTORY = "Incomplete cash history; totals unavailable.";
@@ -78,7 +79,8 @@ export async function fetchDividendData(
 ): Promise<DividendData> {
   const response = await trackRequest("dividends", () => apiClient.getMarketDividends(symbol, exchange));
   if (!response.data) throw new Error(`No dividend data found for ${symbol}`);
-  const { actions, quote, summary: quoteFields } = response.data;
+  const { actions, quote: rawQuote, summary: quoteFields } = response.data;
+  const quote = rawQuote ? mapQuote(rawQuote) : null;
   const summaryError = response.data.summaryError ?? (!quoteFields ? UNAVAILABLE_DIVIDEND_SUMMARY
     : [quoteFields.exDividendDate, quoteFields.dividendDate]
       .some((timestamp) => timestamp != null && reportedDividendDate(timestamp) === null)
@@ -111,7 +113,7 @@ export async function fetchDividendData(
   }
   return {
     payments, metrics, price, currency: currency || undefined, historyAvailable,
-    ...(suppliedPrice == null && price != null && quote ? dividendQuotePriceMetadata({ ...quote, change: quote.change ?? NaN, changePercent: quote.changePercent ?? NaN }) : {}),
+    ...(suppliedPrice == null && price != null && quote ? dividendQuotePriceMetadata(quote) : {}),
     ...(historyError ? { historyError } : {}), ...(summaryError ? { summaryError } : {}),
     providerId: actions?.providerId ?? "gloom", fetchedAt: actions?.fetchedAt,
     stale: response.stale === true || response.data.stale === true || actions?.stale === true,

package/src/plugins/builtin/dividend-yield/headless.ts

@@ -138,6 +138,7 @@ export function createDividendYieldHeadless(
 ): HeadlessPaneDefinition<"bundle"> {
   return {
     shape: "bundle",
+    freshness: { status: "not-a-feed", basis: "distribution history" },
     argument: {
       kind: "ticker",
       placeholder: "ticker",

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

@@ -15,6 +15,7 @@ import {
   formatDoeVsFive,
   formatDoeVsYear,
 } from "./model";
+import { newestReportTime, oldestReportTime } from "../../../utils/utc-time";
 
 const text = (value: unknown) => typeof value === "string" ? value : "--";
 
@@ -60,6 +61,10 @@ export function doeHeadless(defaultTab: DoeTab | "all"): HeadlessPaneDefinition<
     describe: "EIA weekly petroleum and natural gas storage",
     async load(args) {
       const data = await fetchDoeBoard();
+      // EIA's weekly reports; once the next one is a day overdue the tables have missed it.
+      const freshness = { source: "EIA", status: "not-a-feed" as const, basis: "weekly release",
+        asOf: newestReportTime(data.reports.map((report) => report.releasedAt)),
+        nextExpectedAt: oldestReportTime(data.reports.map((report) => report.nextReleaseAt)) };
       const argument = Array.isArray(args.argument) ? args.argument.join(" ") : args.argument;
       if (argument) {
         const option = doeSeriesOption(argument);
@@ -75,6 +80,7 @@ export function doeHeadless(defaultTab: DoeTab | "all"): HeadlessPaneDefinition<
               rows: seasonalRows(row) },
           ],
           errors: data.gaps,
+          freshness,
           metadata: { ...data, series: [row], complete: data.status === "available" },
         };
       }
@@ -86,6 +92,7 @@ export function doeHeadless(defaultTab: DoeTab | "all"): HeadlessPaneDefinition<
           rows: doeRows(data, tab).map(reportRow),
         })),
         errors: data.gaps,
+        freshness,
         metadata: { ...data, complete: data.status === "available" },
       };
     },