@gloom-sh/terminal 0.19.1 → 0.19.3

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

@@ -3,7 +3,10 @@ import type { CotBoardPayload, CotClass, CotClassSummary, CotContractPayload, Co
 import { createPluginCache } from "../../../data/plugin-cache";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import type { PricePoint } from "../../../types/financials";
-import { COT_CLASSES, cotPriceMapping } from "./model";
+import { COT_CLASSES, cotFrontPriceUnit, cotPriceMapping } from "./model";
+import { futuresPriceUnit, loadFuturesContractTerms, loadFuturesPriceUnit } from "../../../market-data/futures-contract";
+import { futuresBoardContract } from "../../../market-data/futures-board";
+import { settleWithin } from "../../../utils/async-deadline";
 
 export const cotBoardCache = createPluginCache<CotBoardPayload>({ kind: "cot-board", source: "gloom-cloud", schemaVersion: 1,
   policy: { staleMs: 15 * 60_000, expireMs: 8 * 24 * 60 * 60_000 } });
@@ -88,7 +91,12 @@ export async function fetchCotContract(contractCode: string, family: CotFamily,
   catch (error) { throw unavailable(error); }
 }
 export interface CotDetailData { payload: CotContractPayload; price: PricePoint[]; priceSymbol: string | null; priceAsOf: string | null; priceWarning: string | null }
-export async function loadCotDetail(contractCode: string, family: CotFamily, client: Pick<typeof apiClient, "getCloudCotContract" | "getCloudHistory"> = apiClient,
+/**
+ * A market's report and its front price. The price's unit is not waited for
+ * here: it joins the legend when it is known (loadCotPriceUnit).
+ */
+export async function loadCotDetail(contractCode: string, family: CotFamily,
+  client: Pick<typeof apiClient, "getCloudCotContract" | "getCloudHistory"> = apiClient,
   positions: CotPositions = "futures-only"): Promise<CotDetailData> {
   const payload = await fetchCotContract(contractCode, family, client, positions);
   const mapping = cotPriceMapping(contractCode);
@@ -109,3 +117,21 @@ export async function loadCotDetail(contractCode: string, family: CotFamily, cli
       priceWarning: result.stale ? "Front-price history is stale." : price.length ? null : "Front-price history unavailable." };
   } catch { return { payload, price: [], priceSymbol: mapping.priceSymbol, priceAsOf: null, priceWarning: "Front-price history unavailable. Positioning remains available." }; }
 }
+
+/** How long the front price's legend waits for the contract terms before it writes the catalog's unit. */
+const COT_PRICE_UNIT_WAIT_MS = 1_500;
+
+/**
+ * The unit a market's front price is written in, as its legend writes it
+ * after the price (cotFrontPriceUnit): `USD/gal` for heating oil. It is the
+ * contract terms' unit, else the futures catalog's where the terms fail or
+ * have not answered within `waitMs`; null for a market with no front price.
+ * The chart draws without it, so a slow answer never holds the detail up.
+ */
+export async function loadCotPriceUnit(contractCode: string, client: Pick<typeof apiClient, "getCloudFuturesContract"> = apiClient,
+  waitMs = COT_PRICE_UNIT_WAIT_MS): Promise<string | null> {
+  const symbol = cotPriceMapping(contractCode)?.priceSymbol;
+  if (!symbol) return null;
+  const terms = await settleWithin(loadFuturesPriceUnit(symbol, (key) => loadFuturesContractTerms(key, client)), waitMs);
+  return cotFrontPriceUnit(contractCode, terms ?? futuresPriceUnit(futuresBoardContract(symbol), null));
+}

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

@@ -1,7 +1,7 @@
 import type { CotClass, CotClassSummary, CotContractPayload, CotHistoryPoint } from "../../../api-client/cot";
 import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchCotBoard, fetchCotContract } from "./client";
-import { COT_CLASSES, COT_FAMILIES, COT_MAJOR_CODES, COT_POSITIONS, COT_SCOPES, cotClass, cotContractCode, cotContractUnitText, cotFamily, cotInteger, cotMarketName, cotPositions, cotPositionsText, cotScope, cotUnknownMarketMessage } from "./model";
+import { COT_CLASSES, COT_FAMILIES, COT_MAJOR_CODES, COT_POSITIONS, COT_SCOPES, cotClass, cotContractCode, cotContractUnitText, cotFamily, cotInteger, cotMarketName, cotPositions, cotPositionsText, cotProxyFor, cotProxyNote, cotScope, cotUnknownMarketMessage } from "./model";
 import { COMMODITIES_VIEW_STATE } from "../commodities-energy/view-state";
 import { REPORT_ROWS } from "../shared/headless-options";
 
@@ -67,6 +67,7 @@ export const cotHeadless: HeadlessPaneDefinition<"bundle"> = {
     if (args.argument) {
       const code = cotContractCode(args.argument);
       if (!code) throw new Error(cotUnknownMarketMessage(args.argument));
+      const proxy = cotProxyFor(args.argument);
       const data = await fetchCotContract(code, family, ctx.apiClient, positions);
       const classes = data.positions.map((row) => row.id);
       const limit = args.options.limit == null ? null : Number(args.options.limit);
@@ -80,6 +81,8 @@ export const cotHeadless: HeadlessPaneDefinition<"bundle"> = {
           ...classes.map((id) => ({ key: `${camelClass(id)}Net`, header: `${data.positions.find((row) => row.id === id)?.label ?? id} net`, align: "right" as const, format: signed }))],
         rows: weeks.map((row) => ({ reportDate: row.reportDate, openInterest: row.openInterest,
           ...Object.fromEntries(row.positions.map((position) => [`${camelClass(position.id)}Net`, position.net])) })) }],
+      // "jet fuel" reads heating oil's positions, and says so.
+      ...(proxy ? { notes: [cotProxyNote(proxy)] } : {}),
       errors: data.gaps, metadata: { ...data, complete: data.status === "available" } };
     }
     const traderClass = cotClass(family, args.options.traderClass);

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

@@ -1,13 +1,12 @@
 import type { PluginModule } from "../plugin-module";
 import { cotBoardCache } from "./client";
 import { cotHeadless } from "./headless";
-import { COT_ROOT_OPTIONS, cotContractCode, cotContractCodeForTicker, cotRoot, cotUnknownMarketMessage } from "./model";
-import { CotPane } from "./pane";
+import { COT_ROOT_OPTIONS, cotContractCode, cotContractCodeForTicker, cotProxyFor, cotRoot, cotUnknownMarketMessage } from "./model";
 import { COT_SERIES } from "./series";
 
 export const cotModule: PluginModule = {
   series: COT_SERIES,
-  panes: [{ id: "cot", name: "CFTC Positioning", icon: "P", component: CotPane,
+  panes: [{ id: "cot", name: "CFTC Positioning", icon: "P", get component(): typeof import("./pane").CotPane { const { CotPane } = require("./pane"); return CotPane; },
     defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 106, height: 30 },
     tableExport: true, headless: cotHeadless }],
   paneTemplates: [{ id: "cot-cot", paneId: "cot", label: "CFTC Positioning",
@@ -19,7 +18,9 @@ export const cotModule: PluginModule = {
       const input = options?.arg?.trim();
       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,
+      // "jet fuel" opens heating oil, and the title says which market stands in.
+      const proxy = input ? cotProxyFor(input) : null;
+      return { title: code ? `COT ${cotRoot(code) ?? code}${proxy ? ` (${proxy.subject} proxy)` : ""}` : "CFTC Positioning", params: code ? { code } : undefined,
         settings: { report: options?.values?.report ?? "legacy" }, placement: "floating" as const };
     },
   }],

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

@@ -2,10 +2,14 @@ import type { CotClass, CotContractPayload, CotFamily, CotHistoryPoint, CotPosit
 import { staticSeries } from "../../../components/chart/static/series";
 import type { ResolvedSeries } from "../../../time-series/types";
 import type { PricePoint } from "../../../types/financials";
-import { formatPriceObservation } from "../../../market-data/market/format";
+import { formatMarketPriceWithCurrency, formatPriceObservation } from "../../../market-data/market/format";
+import { futuresPricePer } from "../../../market-data/futures-contract";
+import { unitCurrencyToken } from "../../../time-series/price-units";
 import { cleanFloat32Price } from "../../../cli/history-rows";
 import { cryptoPairCoin, isFuturesSymbol } from "../shared/crypto-pair";
-import { bestNameMatch, FUTURES_CONTRACTS, futuresBoardContract, futuresBoardContractForTicker, futuresContractByName, type FuturesContract } from "../../../market-data/futures-board";
+import {
+  bestNameMatch, FUTURES_CONTRACTS, futuresBoardContract, futuresBoardContractForTicker, futuresContractByCode, futuresContractByName, type FuturesContract,
+} from "../../../market-data/futures-board";
 
 export const COT_CLASSES: Record<CotFamily, Array<{ value: CotClass; label: string }>> = {
   legacy: [{ value: "noncommercial", label: "Noncommercial" }, { value: "commercial", label: "Commercial" }, { value: "nonreportable", label: "Nonreportable" }],
@@ -162,7 +166,35 @@ export function cotContractCode(value: unknown): string | null {
   if (alias) return alias;
   const market = typedMarket(value);
   if (market && "root" in market) return ROOTS[market.root]!.code;
-  return (market ? boardMarketCode(market.board) : null) ?? (market ? null : marketCode(input));
+  if (market) return boardMarketCode(market.board);
+  const proxy = proxyMarket(value);
+  const proxied = proxy ? futuresContractByCode(proxy.root) : null;
+  return (proxied ? boardMarketCode(proxied) : null) ?? marketCode(input);
+}
+/**
+ * Markets the CFTC does not report, opened as the one traders price and hedge
+ * them by: jet fuel (kerosene) as NY Harbor ULSD, heating oil (HO), which
+ * airlines' fuel hedges and analysts follow it with. Opened this way, the
+ * pane's title and the report say which market stands in.
+ */
+const PROXY_MARKETS: ReadonlyArray<{ names: readonly string[]; root: string; subject: string }> = [
+  { names: ["jet fuel", "jet fuels", "kerosene", "kerosine", "jet kerosene", "aviation fuel", "avtur"], root: "HO", subject: "jet fuel" },
+];
+function proxyMarket(value: string) {
+  const typed = value.trim().toLowerCase().replace(/[\s_-]+/g, " ");
+  return PROXY_MARKETS.find((proxy) => proxy.names.includes(typed)) ?? null;
+}
+/** What a typed name opens in place of a market the CFTC does not report ("jet fuel" opens HO), or null. */
+export function cotProxyFor(value: unknown): { subject: string; root: string } | null {
+  if (typeof value !== "string" || typedMarket(value) || rootAlias(value.trim().toUpperCase())) return null;
+  const proxy = proxyMarket(value);
+  return proxy ? { subject: proxy.subject, root: proxy.root } : null;
+}
+/** The line a report opened through a proxy says: "Jet fuel has no CFTC market: heating oil (NY Harbor ULSD, HO) is the usual proxy." */
+export function cotProxyNote(proxy: { subject: string; root: string }): string {
+  const subject = `${proxy.subject[0]!.toUpperCase()}${proxy.subject.slice(1)}`;
+  return `${subject} has no CFTC market: heating oil (NY Harbor ULSD, ${proxy.root}) is the usual proxy. Its price: gloom quote ${proxy.root}=F; `
+    + "US jet fuel stocks (EIA, weekly): gloom fn G CAP:doe:jet";
 }
 /** The markets the unknown-market hint names, by the code and the word a newcomer knows them by. */
 const SUGGESTED_MARKETS: ReadonlyArray<readonly [string, string]> = [
@@ -234,10 +266,27 @@ export function cotInteger(value: number | null, signed = false): string {
   return value == null ? "--" : `${signed && value > 0 ? "+" : ""}${value.toLocaleString("en-US", { maximumFractionDigits: 0 })}`;
 }
 
+/**
+ * The front price's unit as a quote of the future writes it after the price:
+ * `USD/gal` for heating oil ($4.6218/gal), `USD` for gold, from the
+ * contract's unit ("USD / gallon"). Null where the unit names no currency
+ * (index points, Treasury points) or is unknown: the price reads bare.
+ */
+export function cotFrontPriceUnit(code: string, contractUnit: string | null | undefined): string | null {
+  const currency = contractUnit ? unitCurrencyToken(contractUnit.split("/")[0] ?? "") : null;
+  if (!currency) return null;
+  const root = cotRoot(code) ?? undefined;
+  return `${currency}${futuresPricePer({ root, spec: { unit: contractUnit } } as Parameters<typeof futuresPricePer>[0], currency)}`;
+}
+
 /** Legend values stay exact: a compact 7.8K hides the futures price and -100K the net position. */
-export function cotLegendValue(value: number, series: Pick<ResolvedSeries, "id">): string {
+export function cotLegendValue(value: number, series: Pick<ResolvedSeries, "id"> & Partial<Pick<ResolvedSeries, "unit">>): string {
+  if (series.id !== "price") return cotInteger(value, true);
   // Drop the float32 tail of provider bars without rounding away a 1/128 Treasury tick.
-  return series.id === "price" ? formatPriceObservation(cleanFloat32Price(value)) : cotInteger(value, true);
+  const price = cleanFloat32Price(value);
+  // In its currency and per its quantity, as a quote of the future reads: $4.6218/gal.
+  const [currency, per] = [series.unit?.split("/")[0]?.trim(), series.unit?.includes("/") ? `/${series.unit.split("/")[1]}` : ""];
+  return currency ? `${formatMarketPriceWithCurrency(price, currency, { assetCategory: "FUT" })}${per}` : formatPriceObservation(price);
 }
 
 /**
@@ -263,7 +312,9 @@ export function cotNetPoints(history: readonly CotHistoryPoint[], traderClass: C
   }
   return points;
 }
-export function cotChartSeries(data: CotContractPayload, traderClass: CotClass, price: readonly PricePoint[], colors: { positive: string; warning: string }): ResolvedSeries[] {
+/** `priceUnit` is the front price's (cotFrontPriceUnit), which its legend value is written in. */
+export function cotChartSeries(data: CotContractPayload, traderClass: CotClass, price: readonly PricePoint[], colors: { positive: string; warning: string },
+  priceUnit: string | null = null): ResolvedSeries[] {
   const series: ResolvedSeries[] = [{
     ...staticSeries(cotNetPoints(data.history, traderClass), { id: "net", label: `${COT_CLASSES[data.reportFamily].find((row) => row.value === traderClass)?.label ?? traderClass} net`, color: colors.warning, calendarSpaced: true }),
     panelId: "net", unit: "contracts", unitGroup: "positions",
@@ -271,7 +322,7 @@ export function cotChartSeries(data: CotContractPayload, traderClass: CotClass,
   // Net positioning is the subject, so it leads the legend and the strip; the front price follows.
   if (price.length) series.push({
     ...staticSeries(price.map((row) => ({ date: row.date, observedAt: row.date, value: row.close })), { id: "price", label: "Front price", color: colors.positive, calendarSpaced: true }),
-    panelId: "price", unit: "", unitGroup: "price",
+    panelId: "price", unit: priceUnit ?? "", unitGroup: "price",
   });
   return series;
 }

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

@@ -12,7 +12,7 @@ import { Box } from "../../../ui";
 import { useAutoRefresh } from "../../../react/auto-refresh";
 import { compareSortValues, nextHeaderSort, type SortPreference } from "../../../utils/sort-values";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
-import { cachedCotBoard, loadCotBoard, loadCotDetail } from "./client";
+import { cachedCotBoard, loadCotBoard, loadCotDetail, loadCotPriceUnit } from "./client";
 import { COT_CLASSES, COT_FAMILIES, COT_MAJOR_CODES, COT_POSITIONS, COT_SCOPES, cotChartSeries, cotClass, cotContractUnitText, cotFamily, cotInteger, cotLegendValue, cotMarketName, cotPositions, cotPositionsText, cotScope, type CotScope } from "./model";
 
 const BOARD_COLUMNS: DataTableColumn[] = [
@@ -159,10 +159,14 @@ function CotDetail({ width, height, focused, code, family, positions, traderClas
   const session = useResearchCloudSession();
   const loader = useCallback(() => loadCotDetail(code, family, undefined, positions), [code, family, positions, session.requestKey]);
   const resource = useAsyncResource(loader, { clearOnError: isAccessDenied });
+  // The front price's unit joins the legend once the contract terms answer, or
+  // the catalog's after a short wait: the chart draws without waiting for it.
+  const unitLoader = useCallback(() => loadCotPriceUnit(code), [code]);
+  const priceUnit = useAsyncResource(unitLoader).data ?? null;
   const data = resource.data;
   const payload = data?.payload;
   const current = payload?.positions.find((row) => row.id === traderClass);
-  const series = useMemo(() => data ? cotChartSeries(data.payload, traderClass, data.price, colors) : [], [data, traderClass, colors]);
+  const series = useMemo(() => data ? cotChartSeries(data.payload, traderClass, data.price, colors, priceUnit) : [], [data, traderClass, colors, priceUnit]);
   // The selected class row already carries the net and both ranks, and the
   // legend names the class it charts, so the detail opens on the chart. A rank
   // over a short history is a limitation, so it sits behind the warning.

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

@@ -1,8 +1,8 @@
 import { apiClient } from "../../../api-client";
+import { sourceDidNotAnswer } from "../../../api-client/errors";
 import type { CpiBoardPayload, CpiRow } from "../../../api-client/cpi";
-import { ApiRequestError } from "../../../api-client/errors";
 import { createPluginCache } from "../../../data/plugin-cache";
-import { cachedCloudResource, loadCloudResource } from "../shared/cloud-resource";
+import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 
 /** What the pane says while the server has no months to serve: before the backend ships, or before its first read. */
 export const CPI_NOT_AVAILABLE = "US consumer prices are not available yet.";
@@ -54,11 +54,12 @@ export async function fetchCpiBoard(client: Pick<typeof apiClient, "getCloudCpiB
   try {
     payload = await client.getCloudCpiBoard();
   } catch (error) {
-    if (error instanceof ApiRequestError && (error.status === 404 || error.status === 503)) throw new Error(CPI_NOT_AVAILABLE);
-    throw error;
+    throw unavailableOnServer(error, CPI_NOT_AVAILABLE, [404, 503]);
   }
   const board = validateCpiBoard(payload);
-  if (board.status === "unavailable" || !board.release.period || !board.rows.length) throw new Error(CPI_NOT_AVAILABLE);
+  // The server's source did not answer this time: a saved copy answers, as it does a 5xx.
+  if (board.status === "unavailable") throw sourceDidNotAnswer(CPI_NOT_AVAILABLE);
+  if (!board.release.period || !board.rows.length) throw new Error(CPI_NOT_AVAILABLE);
   return board;
 }
 

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

@@ -3,7 +3,6 @@ import type { PluginModule } from "../plugin-module";
 import { cpiBoardCache } from "./client";
 import { cpiHeadless } from "./headless";
 import { CPI_ROW_OPTIONS, cpiRowOption } from "./model";
-import { CpiPane } from "./pane";
 
 /** Opens on the table, or on the component typed after the mnemonic. */
 function cpiInstance(options?: PaneTemplateCreateOptions): PaneTemplateInstanceConfig {
@@ -14,7 +13,7 @@ function cpiInstance(options?: PaneTemplateCreateOptions): PaneTemplateInstanceC
 }
 
 export const cpiModule: PluginModule = {
-  panes: [{ id: "cpi", name: "US Consumer Prices", icon: "C", component: CpiPane,
+  panes: [{ id: "cpi", name: "US Consumer Prices", icon: "C", get component(): typeof import("./pane").CpiPane { const { CpiPane } = require("./pane"); return CpiPane; },
     defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 100, height: 36 },
     tableExport: true, headless: cpiHeadless }],
   paneTemplates: [{

package/src/plugins/builtin/credit-boards/cdx-pane.tsx

@@ -32,6 +32,7 @@ import {
   formatLevel,
   formatMove,
   partialDayText,
+  SETTLEMENT_TEXT,
   type CdxRow,
 } from "./model";
 
@@ -69,7 +70,7 @@ function IndexDetail({ row, width, height, focused }: { row: CdxRow; width: numb
   const through = day.partial && day.changeDate ? `to ${day.changeDate}` : undefined;
   const items: StatItem[] = [
     { id: "level", label: index.quote === "spread" ? "5Y spread" : "5Y price", value: formatLevel(index.quote, index.level),
-      detail: `${formatPercentileRank(year.percentile, "1Y")} · ${index.date ?? "--"}` },
+      detail: [formatPercentileRank(year.percentile, "1Y"), index.date ?? "--", ...(index.kind === "settlement" ? [SETTLEMENT_TEXT] : [])].join(" · ") },
     ...(index.quote === "price" && index.spreadBp !== undefined ? [{ id: "spread", label: "Spread eq", value: formatLevel("spread", index.spreadBp ?? null),
       ...(index.recovery != null ? { detail: `${Math.round(index.recovery * 100)}% recovery` } : {}) }] : []),
     { id: "1d", label: "1D", value: formatMove(index.quote, day.change1D), ...(through ? { detail: through } : {}) },

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

@@ -84,8 +84,10 @@ export type PriceHistoryLoader = (symbol: string) => Promise<PricePoint[]>;
 
 /** Closes a month back are yesterday's news for half an hour. */
 const FX_HISTORY_TTL_MS = 30 * 60_000;
-/** Twenty-odd currencies at once; a few requests at a time keep the feed from refusing them. */
+/** Twenty-odd currencies, a few at a time from a source that takes them one by one. */
 const FX_HISTORY_CONCURRENCY = 4;
+/** All at once from a source that batches them: the API client sends them sixteen a request. */
+const FX_HISTORY_BATCHED_CONCURRENCY = 32;
 const fxMoves = createTtlCache<number | null>({ ttlMs: FX_HISTORY_TTL_MS });
 
 /** A load that fails reads as unknown for everyone waiting on it and is asked again next time, never remembered as unknown. */
@@ -97,10 +99,13 @@ function currencyMove(symbol: string, dollarsPerUnit: boolean, loadHistory: Pric
 /**
  * Each currency's 1M move against the dollar from its daily closes, shared
  * across panes. A currency with no pair or no history reads as unknown.
+ * `batched`: `loadHistory` asks a source that batches them
+ * (`DataProvider.batchesReads`) with `batch`, so they are all asked at once.
  */
 export async function loadCurrencyMoves(
   currencies: readonly string[],
   loadHistory: PriceHistoryLoader,
+  batched = false,
 ): Promise<Map<string, number | null>> {
   const queue = [...new Set(currencies)];
   const moves = new Map<string, number | null>();
@@ -110,6 +115,6 @@ export async function loadCurrencyMoves(
       moves.set(currency, pair ? await currencyMove(pair.symbol, pair.dollarsPerUnit, loadHistory) : null);
     }
   };
-  await Promise.all(Array.from({ length: Math.min(FX_HISTORY_CONCURRENCY, queue.length) }, worker));
+  await Promise.all(Array.from({ length: Math.min(batched ? FX_HISTORY_BATCHED_CONCURRENCY : FX_HISTORY_CONCURRENCY, queue.length) }, worker));
   return moves;
 }

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

@@ -1,6 +1,7 @@
 import type { HeadlessPaneColumn, HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/plugin";
 import type { CdxBoardIndex, CreditIndexQuote } from "../../../api-client/credit-boards";
 import { CDX_MAX_DAYS, fetchCdxBoard, fetchSovrBoard, loadCurrencyMoves } from "./client";
+import { readsInBatches } from "../../../market-data/batched-reads";
 import {
   cdxDay,
   cdxRows,
@@ -10,6 +11,7 @@ import {
   formatCurrencyMove,
   formatLevel,
   formatMove,
+  levelKinds,
   partialDayText,
   quoteUnits,
   sovrRows,
@@ -74,6 +76,8 @@ function historySection(index: CdxBoardIndex, days: number, now: number) {
   const priced = index.quote === "price" && index.points.some((point) => point.spreadBp !== undefined);
   const partial = today.partial && latest === index.date;
   const symbol = cdxSeries(index.id);
+  const shown = index.points.filter((point) => point.date > from).reverse();
+  const kinds = levelKinds(shown, (point) => point.kind);
   return {
     title: `${index.name} 5Y daily ${index.quote === "spread" ? "spread" : "price"}`,
     columns: [
@@ -83,11 +87,12 @@ function historySection(index: CdxBoardIndex, days: number, now: number) {
       { key: "prints", header: "Prints", align: "right" as const },
       { key: "maturity", header: "Contract", textFormat: (value: unknown) => formatContract(typeof value === "string" ? value : null) },
       ...(partial ? [dayColumn] : []),
+      ...kinds.columns,
     ],
-    rows: index.points.filter((point) => point.date > from).reverse().map((point) => ({
+    rows: shown.map((point) => ({
       day: point.date, level: point.level, unit,
       ...(priced ? { spreadBp: point.spreadBp ?? null, spreadUnit: "bp" } : {}),
-      prints: point.prints, maturity: point.maturity, series: symbol,
+      prints: point.prints, maturity: point.maturity, series: symbol, ...kinds.row(point),
       ...(partial && point.date === latest ? { session: partialDayText(point.prints, today.lastPrintAt), partial: true, lastPrintAt: today.lastPrintAt } : {}),
     })),
     rowUnitKey: "unit",
@@ -133,6 +138,7 @@ export const cdxHeadless: HeadlessPaneDefinition<"bundle"> = {
     const shown = index ? [index] : payload.indexes;
     // A server that predates the spread equivalent sends none: no column of blanks.
     const spreads = shown.some((entry) => entry.spreadBp !== undefined);
+    const kinds = levelKinds(shown, (entry) => entry.kind);
     const rows = cdxRows(shown, payload.asOf, now).map((row) => {
       const units = quoteUnits(row.index.quote);
       const priced = spreads && row.index.quote === "price";
@@ -151,6 +157,7 @@ export const cdxHeadless: HeadlessPaneDefinition<"bundle"> = {
         contract: formatContract(row.index.maturity),
         date: row.index.date,
         changeDate: row.day.changeDate,
+        ...kinds.row(row.index),
         ...(row.day.partial ? { session: partialDayText(row.index.prints, row.day.lastPrintAt), partial: true, lastPrintAt: row.day.lastPrintAt } : {}),
       };
     });
@@ -158,7 +165,7 @@ export const cdxHeadless: HeadlessPaneDefinition<"bundle"> = {
     return {
       sections: [
         {
-          title: "On the run, 5Y", columns: [...CDX_COLUMNS.filter((column) => spreads || column !== spreadColumn), ...(anyPartial ? [dayColumn] : [])], rows,
+          title: "On the run, 5Y", columns: [...CDX_COLUMNS.filter((column) => spreads || column !== spreadColumn), ...(anyPartial ? [dayColumn] : []), ...kinds.columns], rows,
           rowUnitKey: "unit", rowSymbolKey: "series", rowAsOfKey: "date", interval: "daily",
         },
         ...(index ? [historySection(index, days, now)] : []),
@@ -170,6 +177,15 @@ export const cdxHeadless: HeadlessPaneDefinition<"bundle"> = {
   },
 };
 
+const SOVR_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "name", header: "Sovereign" },
+  levelColumn,
+  moveColumn("change1M", "1M", "unit"),
+  { key: "currency", header: "Ccy 1M", align: "right" },
+  { key: "percentile", header: "Pctl 1Y", align: "right", format: percentile },
+  { key: "date", header: "As of" },
+];
+
 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."] },
@@ -178,14 +194,7 @@ export const sovrHeadless: HeadlessPaneDefinition<"rows"> = {
   argument: { kind: "free-text", optional: true, placeholder: "country",
     description: "A country (Brazil, BR) to list its row alone; omit for every sovereign." },
   options: [],
-  columns: [
-    { key: "name", header: "Sovereign" },
-    levelColumn,
-    moveColumn("change1M", "1M", "unit"),
-    { key: "currency", header: "Ccy 1M", align: "right" },
-    { key: "percentile", header: "Pctl 1Y", align: "right", format: percentile },
-    { key: "date", header: "As of" },
-  ],
+  columns: SOVR_COLUMNS,
   describe: "Sovereign CDS",
   async load(args, ctx) {
     const payload = await fetchSovrBoard(ctx.apiClient);
@@ -193,10 +202,13 @@ export const sovrHeadless: HeadlessPaneDefinition<"rows"> = {
     const country = query ? findSovereign(payload.sovereigns, query) : null;
     if (query && !country) throw new Error(`No sovereign ${query}. Use one of: ${payload.sovereigns.map((entry) => entry.name).join(", ")}.`);
     const sovereigns = country ? [country] : payload.sovereigns;
+    const batch = await readsInBatches(ctx.marketData, "getPriceHistory");
     const moves = await loadCurrencyMoves(sovereigns.map((row) => row.currency),
-      (symbol) => ctx.marketData.getPriceHistory(symbol, "", "3M"));
+      (symbol) => ctx.marketData.getPriceHistory(symbol, "", "3M", batch ? { batch } : undefined), batch);
     const publisher = boardPublisher(payload.source);
+    const kinds = levelKinds(sovereigns, (row) => row.kind);
     return {
+      ...(kinds.columns.length ? { columns: [...SOVR_COLUMNS, ...kinds.columns] } : {}),
       rows: sovrRows(sovereigns, payload.asOf, moves).map((row) => ({
         name: row.label,
         series: sovereignSeries(row.sovereign.id),
@@ -206,6 +218,7 @@ export const sovrHeadless: HeadlessPaneDefinition<"rows"> = {
         currency: formatCurrencyMove(row.sovereign.currency, row.currencyMove),
         percentile: rank(row.percentile),
         date: row.sovereign.date,
+        ...kinds.row(row.sovereign),
       })),
       rowUnitKey: "unit",
       rowSymbolKey: "series",

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

@@ -2,12 +2,14 @@ import type {
   CdxBoardIndex,
   CreditBoardPoint,
   CreditIndexQuote,
+  CreditLevelKind,
   SovrBoardSovereign,
 } from "../../../api-client/credit-boards";
 import { spanAxisFormatter, formatBpAxis } from "../../../components/chart-table/axis";
 import { historyStatistics } from "../../../components/chart/curve/model";
 import type { MarketBoardRow } from "../../../components/market-board";
 import type { PricePoint } from "../../../types/financials";
+import type { HeadlessPaneColumn } from "../../../types/plugin";
 
 const YEAR_DAYS = 365;
 /** A level older than this is not the current market. */
@@ -93,6 +95,33 @@ function utcClock(instant: string): string | null {
   return Number.isFinite(time) ? new Date(time).toISOString().slice(11, 16) : null;
 }
 
+/**
+ * How a level that is the day's settlement price, not its trades, is marked
+ * beside its date.
+ */
+export const SETTLEMENT_TEXT = "settlement";
+
+/**
+ * A report's mark for the levels that are settlement prices: blank for a
+ * level from the day's trades. Shown only when a row is one, and each row
+ * then carries `kind`.
+ */
+const levelKindColumn: HeadlessPaneColumn = {
+  key: "kind", header: "Level",
+  description: "Blank for a level from the day's trades. settlement for the day's end-of-day settlement price, which stands in "
+    + "on a day without enough agreeing trades; its prints are 0.",
+  format: (value) => value === "settlement" ? SETTLEMENT_TEXT : "",
+};
+
+/** `kind` on every row once one level is a settlement; nothing otherwise, so a report without one is unchanged. */
+export function levelKinds<T>(items: readonly T[], kindOf: (item: T) => CreditLevelKind | null | undefined) {
+  const shown = items.some((item) => kindOf(item) === "settlement");
+  return {
+    columns: shown ? [levelKindColumn] : [],
+    row: (item: T) => shown ? { kind: kindOf(item) ?? "traded" } : {},
+  };
+}
+
 /**
  * What a day still trading rests on: `so far, 38 prints, last 08:09 UTC`.
  * The print time is left out when the server does not say it.

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

@@ -1,6 +1,6 @@
 import type { CreditBoardPoint } from "../../../api-client/credit-boards";
 import type { SeriesDefinition, SeriesLoadResult } from "../../../series/types";
-import { cachedSeriesWarning } from "../shared/series-warning";
+import { cachedSeriesNote } from "../shared/series-warning";
 import { loadCdxBoard, loadSovrBoard } from "./client";
 
 /** The five on-the-run 5Y index contracts the CDX tab lists; IG and iTraxx quote spread, HY and EM price. */
@@ -27,14 +27,13 @@ function boardPoints(
   rows: ReadonlyArray<{ id: string; points: readonly CreditBoardPoint[] }>,
   id: string,
   label: string,
-  resource: { stale?: boolean; refreshError?: string | null },
+  resource: { stale?: boolean; refreshError?: string | null; savedAt?: number },
 ): SeriesLoadResult {
   const row = rows.find((entry) => entry.id === id);
   if (!row) throw new Error(`${label} is not on the board right now.`);
-  const warning = cachedSeriesWarning(resource);
   return {
     points: row.points.map((point) => ({ date: point.date, value: point.level })),
-    ...(warning ? { warning } : {}),
+    ...cachedSeriesNote(resource),
   };
 }
 

package/src/plugins/builtin/credit-boards/sovr-pane.tsx

@@ -25,12 +25,14 @@ import { formatAsOf } from "../cds/model";
 import { FIXED_INCOME_PANE_ID } from "../fixed-income/model";
 import { useCommandValue } from "../shared/command-tab";
 import { getCachedSovrBoard, loadCurrencyMoves, loadSovrBoard } from "./client";
+import { readsInBatches } from "../../../market-data/batched-reads";
 import {
   findSovereign,
   formatContract,
   formatCurrencyMove,
   formatLevel,
   formatMove,
+  SETTLEMENT_TEXT,
   sovrRows,
   type SovrRow,
 } from "./model";
@@ -65,7 +67,7 @@ function SovereignDetail({ row, width, height, focused }: { row: SovrRow; width:
   const { sovereign, year } = row;
   const items: StatItem[] = [
     { id: "level", label: "5Y spread", value: formatLevel("spread", sovereign.level),
-      detail: `${formatPercentileRank(year.percentile, "1Y")} · ${sovereign.date}` },
+      detail: [formatPercentileRank(year.percentile, "1Y"), sovereign.date, ...(sovereign.kind === "settlement" ? [SETTLEMENT_TEXT] : [])].join(" · ") },
     { id: "1m", label: "1M", value: formatMove("spread", sovereign.change1M) },
     { id: "1w", label: "1W", value: formatMove("spread", sovereign.change1W) },
     { id: "fx", label: "Currency 1M", value: formatCurrencyMove(sovereign.currency, row.currencyMove) },
@@ -99,9 +101,12 @@ export function SovrPane({ focused, width, height }: PaneProps) {
   // Each currency's month against the dollar, from the same daily closes the FX panes use.
   const currencies = useMemo(() => [...new Set(payload?.sovereigns.map((row) => row.currency) ?? [])].sort().join(","),
     [payload]);
-  const movesLoader = useCallback(() => provider && currencies
-    ? loadCurrencyMoves(currencies.split(","), (symbol) => provider.getPriceHistory(symbol, "", "3M"))
-    : Promise.resolve(NO_MOVES), [currencies, provider]);
+  const movesLoader = useCallback(async () => {
+    if (!provider || !currencies) return NO_MOVES;
+    // Every currency at once, in batch requests, from a source that batches them; a few at a time otherwise.
+    const batch = await readsInBatches(provider, "getPriceHistory");
+    return loadCurrencyMoves(currencies.split(","), (symbol) => provider.getPriceHistory(symbol, "", "3M", batch ? { batch } : undefined), batch);
+  }, [currencies, provider]);
   const moves = useAsyncResource(movesLoader, { keepPreviousData: true });
   const rows = useMemo(() => payload ? sovrRows(payload.sovereigns, payload.asOf, moves.data ?? NO_MOVES) : EMPTY_ROWS,
     [moves.data, payload]);

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

@@ -66,20 +66,28 @@ async function loadSeries(
   loader: CreditSeriesLoader,
 ) {
   const request = requestFor(definition.seriesId);
-  const result = await loadCachedFredSeries(
-    request,
-    async () => {
-      const data = trimHistory(await loader(definition.seriesId, {
-        limit: HISTORY_LIMIT,
-        sortOrder: "desc",
-      }));
-      // Reject incompatible source responses before they replace usable cache.
-      // The shared cache can then retain the dated prior value as stale fallback.
-      normalizeCreditSeries(definition, data);
-      return data;
-    },
-    { force },
-  );
+  let result: Awaited<ReturnType<typeof loadCachedFredSeries>>;
+  try {
+    result = await loadCachedFredSeries(
+      request,
+      async () => {
+        const data = trimHistory(await loader(definition.seriesId, {
+          limit: HISTORY_LIMIT,
+          sortOrder: "desc",
+        }));
+        // Reject incompatible source responses before they replace usable cache.
+        normalizeCreditSeries(definition, data);
+        return data;
+      },
+      { force },
+    );
+  } catch (error) {
+    // A refusal or a reply that fails validation is no saved copy's to answer: it is this row's
+    // error, beside the dated prior value already read, which stays as stale rather than vanish.
+    const kept = getCachedFredSeries(request, { allowExpired: true });
+    if (!kept) throw error;
+    return { row: normalizeCreditSeries(definition, kept.data, true), refreshError: error instanceof Error ? error.message : String(error) };
+  }
   return {
     row: normalizeCreditSeries(definition, result.data, result.stale),
     refreshError: result.refreshError,