gloomberb 0.16.4 → 0.16.6

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

@@ -65,6 +65,7 @@ function IndexDetail({ row, width, height, focused }: { row: CdxRow; width: numb
       detail: `${formatPercentileRank(year.percentile, "1Y")} · ${index.date ?? "--"}` },
     { id: "1d", label: "1D", value: formatMove(index.quote, index.change1D) },
     { id: "1w", label: "1W", value: formatMove(index.quote, index.change1W) },
+    { id: "1m", label: "1M", value: formatMove(index.quote, index.change1M ?? null) },
     { id: "range", label: "1Y range", value: `${formatLevel(index.quote, year.low)} to ${formatLevel(index.quote, year.high)}` },
     { id: "contract", label: "Contract", value: formatContract(index.maturity), detail: `${index.couponBp}bp coupon` },
     { id: "prints", label: "Prints", value: index.prints == null ? "--" : String(index.prints) },
@@ -100,7 +101,7 @@ export function CdxPane({ focused, width, height }: PaneProps) {
     info,
   });
 
-  // The 1W move and the print count ride beside the board's own 1D column.
+  // The 1W and 1M moves and the print count ride beside the board's own 1D column.
   const extraColumns = useMemo(() => [
     {
       column: { id: "week", label: "1W", width: 10, align: "right" as const },
@@ -110,6 +111,14 @@ export function CdxPane({ focused, width, height }: PaneProps) {
         color: signedMoveColor(row.week, row.adverseMove, theme),
       }),
     },
+    {
+      column: { id: "month", label: "1M", width: 10, align: "right" as const },
+      sortValue: (row: CdxRow) => row.month,
+      renderCell: (row: CdxRow) => ({
+        text: formatMove(row.index.quote, row.index.change1M ?? null),
+        color: signedMoveColor(row.month, row.adverseMove, theme),
+      }),
+    },
     {
       column: { id: "prints", label: "PRINTS", width: 7, align: "right" as const },
       sortValue: (row: CdxRow) => row.index.prints,

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

@@ -32,6 +32,7 @@ function validateCdxBoard(payload: CdxBoardPayload): CdxBoardPayload {
     !index || typeof index.id !== "string" || typeof index.name !== "string"
     || (index.quote !== "spread" && index.quote !== "price")
     || !finiteOrNull(index.level) || !finiteOrNull(index.change1D) || !finiteOrNull(index.change1W)
+    || (index.change1M !== undefined && !finiteOrNull(index.change1M))
     || !finiteOrNull(index.prints) || (index.date !== null && !isDate(index.date)) || !validPoints(index.points))) {
     throw new Error("The server returned an invalid index CDS board");
   }
@@ -50,8 +51,11 @@ function validateSovrBoard(payload: SovrBoardPayload): SovrBoardPayload {
 
 type BoardClient = Pick<typeof apiClient, "getCloudCdxBoard" | "getCloudSovrBoard">;
 
-export async function fetchCdxBoard(client: BoardClient = apiClient): Promise<CdxBoardPayload> {
-  try { return validateCdxBoard(await client.getCloudCdxBoard({ days: BOARD_DAYS })); }
+/** Days of history the server serves at most, for a history export. */
+export const CDX_MAX_DAYS = 1100;
+
+export async function fetchCdxBoard(client: BoardClient = apiClient, days = BOARD_DAYS): Promise<CdxBoardPayload> {
+  try { return validateCdxBoard(await client.getCloudCdxBoard({ days })); }
   catch (error) { throw unavailableOnServer(error, "Index CDS levels are not available yet."); }
 }
 

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

@@ -1,56 +1,130 @@
-import type { HeadlessPaneDefinition } from "../../../types/plugin";
-import { fetchCdxBoard, fetchSovrBoard, loadCurrencyMoves } from "./client";
-import { cdxRows, formatContract, formatCurrencyMove, formatLevel, formatMove, sovrRows } from "./model";
+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 { cdxRows, formatContract, formatCurrencyMove, formatLevel, formatMove, quoteUnits, sovrRows } from "./model";
 
 const percentile = (value: unknown) => value == null ? "--" : Number(value).toFixed(0);
+const numberOrNull = (value: unknown) => typeof value === "number" ? value : null;
+/** A row's quote, from the unit its level is in. */
+const rowQuote = (row: HeadlessPaneRow): CreditIndexQuote => row.unit === "bp" ? "spread" : "price";
 
-export const cdxHeadless: HeadlessPaneDefinition<"rows"> = {
+/**
+ * Levels and moves are numbers with their unit beside them (`unit`,
+ * `changeUnit`): text draws them as the board does (`58.3bp`, `106.69`,
+ * `+0.17`), exports write the number and name the unit.
+ */
+const levelColumn: HeadlessPaneColumn = {
+  key: "level", header: "5Y", align: "right", unitKey: "unit",
+  textFormat: (value, row) => formatLevel(rowQuote(row), numberOrNull(value)),
+};
+const moveColumn = (key: string, header: string, unitKey: string): HeadlessPaneColumn => ({
+  key, header, align: "right", unitKey,
+  textFormat: (value, row) => formatMove(rowQuote(row), numberOrNull(value)),
+});
+
+/** The publisher a board's payload names, spelled out: `DTCC PPD` is DTCC's public price dissemination. */
+function boardPublisher(source: string | null | undefined): string | undefined {
+  return source?.trim().replace(/\bPPD\b/, "Public Price Dissemination") || undefined;
+}
+
+/** `IG`, `cdx hy`, `itraxx main`, `crossover`: an index by its code, its name or the name's last word. */
+function findIndex(indexes: readonly CdxBoardIndex[], query: string): CdxBoardIndex | null {
+  const key = (text: string) => text.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const wanted = key(query) === "crossover" ? "xover" : key(query);
+  return indexes.find((index) => [index.id, index.name, index.name.split(" ").at(-1) ?? ""]
+    .some((name) => key(name) === wanted)) ?? null;
+}
+
+/**
+ * Each day's level on the contract on the run that day, newest first, over
+ * the last `days`: the chart as a table. Its key is `day`, not `date`, so the
+ * history is not read as the board's own observation dates.
+ */
+function historySection(index: CdxBoardIndex, days: number) {
+  const unit = quoteUnits(index.quote).level;
+  const latest = index.points.at(-1)?.date;
+  const from = latest ? new Date(Date.parse(`${latest}T00:00:00Z`) - days * 86_400_000).toISOString().slice(0, 10) : "";
+  return {
+    title: `${index.name} 5Y daily ${index.quote === "spread" ? "spread" : "price"}`,
+    columns: [
+      { key: "day", header: "Date" },
+      { ...levelColumn, header: index.quote === "spread" ? "Spread" : "Price" },
+      { key: "prints", header: "Prints", align: "right" as const },
+      { key: "maturity", header: "Contract", textFormat: (value: unknown) => formatContract(typeof value === "string" ? value : null) },
+    ],
+    rows: index.points.filter((point) => point.date > from).reverse()
+      .map((point) => ({ day: point.date, level: point.level, unit, prints: point.prints, maturity: point.maturity })),
+  };
+}
+
+const CDX_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "name", header: "Index" },
+  levelColumn,
+  moveColumn("change1D", "1D", "changeUnit"),
+  moveColumn("change1W", "1W", "changeUnit"),
+  moveColumn("change1M", "1M", "changeUnit"),
+  { key: "percentile", header: "Pctl 1Y", align: "right", format: percentile },
+  { key: "prints", header: "Prints", align: "right" },
+  { key: "contract", header: "Contract" },
+  { key: "date", header: "As of" },
+];
+
+export const cdxHeadless: HeadlessPaneDefinition<"bundle"> = {
   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",
+    limitations: ["Daily medians of public DTCC prints on the on-the-run 5Y contract.", "HY and EM quote in price, and move in points."] },
+  shape: "bundle",
   freshness: { source: "DTCC", status: "not-a-feed", basis: "daily medians of public trades", cadence: "daily", observedKey: "date" },
-  argument: { kind: "none" },
-  options: [],
-  columns: [
-    { key: "name", header: "Index" },
-    { key: "level", header: "5Y", align: "right" },
-    { key: "change1D", header: "1D", align: "right" },
-    { key: "change1W", header: "1W", align: "right" },
-    { key: "percentile", header: "Pctl 1Y", align: "right", format: percentile },
-    { key: "prints", header: "Prints", align: "right" },
-    { key: "contract", header: "Contract" },
-    { key: "date", header: "As of" },
-  ],
+  argument: { kind: "free-text", optional: true, placeholder: "index",
+    description: "An index (IG, HY, EM, MAIN, XOVER) for its daily history; omit for the board." },
+  options: [{ key: "days", type: "integer", minimum: 30, maximum: CDX_MAX_DAYS, defaultValue: 365,
+    description: "Days of a named index's daily levels." }],
   describe: "Index CDS",
-  async load(_args, ctx) {
-    const payload = await fetchCdxBoard(ctx.apiClient);
-    return {
-      rows: cdxRows(payload.indexes, payload.asOf).map((row) => ({
+  async load(args, ctx) {
+    const days = Number(args.options.days ?? 365);
+    // The 1Y rank always reads a full year, whatever history is asked for.
+    const payload = await fetchCdxBoard(ctx.apiClient, Math.max(days, 365));
+    const query = typeof args.argument === "string" ? args.argument.trim() : "";
+    const index = query ? findIndex(payload.indexes, query) : null;
+    if (query && !index) throw new Error(`No index ${query}. Use one of: ${payload.indexes.map((entry) => entry.id).join(", ")}.`);
+    const publisher = boardPublisher(payload.source);
+    const rows = cdxRows(index ? [index] : payload.indexes, payload.asOf).map((row) => {
+      const units = quoteUnits(row.index.quote);
+      return {
         name: row.label,
-        level: formatLevel(row.index.quote, row.index.level),
-        change1D: formatMove(row.index.quote, row.index.change1D),
-        change1W: formatMove(row.index.quote, row.index.change1W),
+        level: row.index.level,
+        unit: units.level,
+        change1D: row.index.change1D,
+        change1W: row.index.change1W,
+        change1M: row.index.change1M ?? null,
+        changeUnit: units.move,
         percentile: row.percentile,
         prints: row.index.prints,
         contract: formatContract(row.index.maturity),
         date: row.index.date,
-      })),
+      };
+    });
+    return {
+      sections: [
+        { title: "On the run, 5Y", columns: CDX_COLUMNS, rows },
+        ...(index ? [historySection(index, days)] : []),
+      ],
       metadata: { asOf: payload.asOf },
+      ...(publisher ? { freshness: { publisher } } : {}),
     };
   },
 };
 
 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"] },
+    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: [
     { key: "name", header: "Sovereign" },
-    { key: "level", header: "5Y", align: "right" },
-    { key: "change1M", header: "1M", align: "right" },
+    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" },
@@ -60,16 +134,19 @@ export const sovrHeadless: HeadlessPaneDefinition<"rows"> = {
     const payload = await fetchSovrBoard(ctx.apiClient);
     const moves = await loadCurrencyMoves(payload.sovereigns.map((row) => row.currency),
       (symbol) => ctx.marketData.getPriceHistory(symbol, "", "3M"));
+    const publisher = boardPublisher(payload.source);
     return {
       rows: sovrRows(payload.sovereigns, payload.asOf, moves).map((row) => ({
         name: row.label,
-        level: formatLevel("spread", row.sovereign.level),
-        change1M: formatMove("spread", row.sovereign.change1M),
+        level: row.sovereign.level,
+        unit: quoteUnits("spread").level,
+        change1M: row.sovereign.change1M,
         currency: formatCurrencyMove(row.sovereign.currency, row.currencyMove),
         percentile: row.percentile,
         date: row.sovereign.date,
       })),
       metadata: { asOf: payload.asOf },
+      ...(publisher ? { freshness: { publisher } } : {}),
     };
   },
 };

package/src/plugins/builtin/credit-boards/index.tsx

@@ -5,6 +5,7 @@ import { cdxBoardCache, sovrBoardCache } from "./client";
 import { cdxHeadless, sovrHeadless } from "./headless";
 import { CDX_PANE_ID } from "./model";
 import { CreditBoardsPane } from "./pane";
+import { CREDIT_BOARD_SERIES } from "./series";
 
 /** One board. A later command retargets this instance; a fresh id would open a second window. */
 function openCreditBoard(context: PaneTemplateContext, tab: "index" | "sovereign"): PaneTemplateInstanceConfig {
@@ -16,6 +17,7 @@ function openCreditBoard(context: PaneTemplateContext, tab: "index" | "sovereign
 }
 
 export const creditBoardsModule: PluginModule = {
+  series: CREDIT_BOARD_SERIES,
   panes: [
     {
       id: CDX_PANE_ID,

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

@@ -20,6 +20,14 @@ function pointHistory(points: readonly CreditBoardPoint[]): PricePoint[] {
   return points.map((point) => ({ date: new Date(`${point.date}T00:00:00Z`), close: point.level }));
 }
 
+/**
+ * The units a quote's level and moves are in, as exports name them: a spread
+ * and its moves in bp; HY and EM quote in price, and move in points of it.
+ */
+export function quoteUnits(quote: CreditIndexQuote): { level: "bp" | "price"; move: "bp" | "pts" } {
+  return quote === "spread" ? { level: "bp", move: "bp" } : { level: "price", move: "pts" };
+}
+
 /** Spreads in bp with a decimal; prices as quoted, to the cent. */
 export function formatLevel(quote: CreditIndexQuote, value: number | null): string {
   if (value == null || !Number.isFinite(value)) return "--";
@@ -90,8 +98,9 @@ export function formatContract(maturity: string | null): string {
 export interface CdxRow extends MarketBoardRow {
   index: CdxBoardIndex;
   year: YearStatistics;
-  /** The 1W move as shown. */
+  /** The 1W and 1M moves as shown. */
   week: number | null;
+  month: number | null;
 }
 
 export function cdxRows(indexes: readonly CdxBoardIndex[], asOf: string | null): CdxRow[] {
@@ -112,6 +121,7 @@ export function cdxRows(indexes: readonly CdxBoardIndex[], asOf: string | null):
       index,
       year,
       week: shown(index.quote, index.change1W),
+      month: shown(index.quote, index.change1M ?? null),
     };
   });
 }

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

@@ -0,0 +1,66 @@
+import type { CreditBoardPoint } from "../../../api-client/credit-boards";
+import type { SeriesDefinition, SeriesLoadResult } from "../../../series/types";
+import { cachedSeriesWarning } 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. */
+const INDEXES = [
+  { code: "IG", name: "CDX IG 5Y", quote: "spread" },
+  { code: "HY", name: "CDX HY 5Y", quote: "price" },
+  { code: "EM", name: "CDX EM 5Y", quote: "price" },
+  { code: "MAIN", name: "iTraxx Main 5Y", quote: "spread" },
+  { code: "XOVER", name: "iTraxx Crossover 5Y", quote: "spread" },
+] as const;
+
+/** The sovereigns the SOVR tab follows, by ISO code. */
+const SOVEREIGNS: ReadonlyArray<readonly [code: string, name: string]> = [
+  ["BR", "Brazil"], ["MX", "Mexico"], ["CO", "Colombia"], ["TR", "Turkey"], ["ZA", "South Africa"],
+  ["CN", "China"], ["ID", "Indonesia"], ["CL", "Chile"], ["PE", "Peru"], ["PH", "Philippines"],
+  ["AR", "Argentina"], ["PA", "Panama"], ["SA", "Saudi Arabia"], ["MY", "Malaysia"], ["EG", "Egypt"],
+  ["KR", "Korea"], ["IT", "Italy"], ["FR", "France"], ["ES", "Spain"], ["GR", "Greece"],
+  ["IE", "Ireland"], ["JP", "Japan"], ["IL", "Israel"], ["PL", "Poland"], ["QA", "Qatar"],
+  ["AD", "Abu Dhabi"], ["BH", "Bahrain"], ["OM", "Oman"], ["MA", "Morocco"], ["NG", "Nigeria"],
+  ["DO", "Dominican Republic"], ["CI", "Ivory Coast"],
+];
+
+function boardPoints(
+  rows: ReadonlyArray<{ id: string; points: readonly CreditBoardPoint[] }>,
+  id: string,
+  label: string,
+  resource: { stale?: boolean; refreshError?: string | null },
+): 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 } : {}),
+  };
+}
+
+export const CREDIT_BOARD_SERIES: readonly SeriesDefinition[] = [
+  ...INDEXES.map((index): SeriesDefinition => ({
+    id: `cdx:${index.code.toLowerCase()}`,
+    name: index.name,
+    unit: index.quote === "spread" ? "bp" : "points",
+    frequency: "daily",
+    group: "Credit",
+    tags: ["CDS", "index CDS", index.quote, "credit default swap"],
+    load: async () => {
+      const resource = await loadCdxBoard();
+      return boardPoints(resource.payload.indexes, index.code, index.name, resource);
+    },
+  })),
+  ...SOVEREIGNS.map(([code, name]): SeriesDefinition => ({
+    id: `sovereign-cds:${code.toLowerCase()}`,
+    name: `${name} 5Y sovereign CDS`,
+    unit: "bp",
+    frequency: "daily",
+    group: "Credit",
+    tags: ["CDS", "sovereign", code, "credit default swap"],
+    load: async () => {
+      const resource = await loadSovrBoard();
+      return boardPoints(resource.payload.sovereigns, code, name, resource);
+    },
+  })),
+];

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

@@ -8,7 +8,7 @@ import {
   CREDIT_SERIES,
   normalizeCreditSeries,
   type CreditConditionRow,
-  type CreditSeriesId,
+  type CreditSeriesDefinition,
 } from "./model";
 
 export interface CreditConditionsLoadResult {
@@ -21,11 +21,11 @@ export interface CreditConditionsLoadResult {
 const HISTORY_LIMIT = 300;
 
 export type CreditSeriesLoader = (
-  seriesId: CreditSeriesId,
+  seriesId: string,
   options: { limit: number; sortOrder: "desc" },
 ) => Promise<CloudFredSeriesPayload>;
 
-function requestFor(seriesId: CreditSeriesId): FredSeriesRequest {
+function requestFor(seriesId: string): FredSeriesRequest {
   return { seriesId, limit: HISTORY_LIMIT, sortOrder: "desc" };
 }
 
@@ -33,15 +33,17 @@ function trimHistory(data: CloudFredSeriesPayload): CloudFredSeriesPayload {
   return { ...data, observations: data.observations.slice(0, HISTORY_LIMIT) };
 }
 
-function seriesError(seriesId: CreditSeriesId, error: unknown): string {
+function seriesError(seriesId: string, error: unknown): string {
   const message = error instanceof Error ? error.message : String(error);
   return message.startsWith(`${seriesId}:`) ? message : `${seriesId}: ${message}`;
 }
 
-export function getCachedCreditConditions(): CreditConditionsLoadResult | null {
+export function getCachedCreditConditions(
+  series: readonly CreditSeriesDefinition[] = CREDIT_SERIES,
+): CreditConditionsLoadResult | null {
   const rows: CreditConditionRow[] = [];
   const errors: string[] = [];
-  for (const definition of CREDIT_SERIES) {
+  for (const definition of series) {
     const cached = getCachedFredSeries(requestFor(definition.seriesId), { allowExpired: true });
     if (!cached) continue;
     try {
@@ -59,7 +61,7 @@ export function getCachedCreditConditions(): CreditConditionsLoadResult | null {
 }
 
 async function loadSeries(
-  definition: typeof CREDIT_SERIES[number],
+  definition: CreditSeriesDefinition,
   force: boolean,
   loader: CreditSeriesLoader,
 ) {
@@ -87,15 +89,16 @@ async function loadSeries(
 export async function loadCreditConditions(
   force = false,
   loader: CreditSeriesLoader = (seriesId, options) => apiClient.getCloudFredSeries(seriesId, options),
+  series: readonly CreditSeriesDefinition[] = CREDIT_SERIES,
 ): Promise<CreditConditionsLoadResult> {
   const settled = await Promise.allSettled(
-    CREDIT_SERIES.map((definition) => loadSeries(definition, force, loader)),
+    series.map((definition) => loadSeries(definition, force, loader)),
   );
   const rows: CreditConditionRow[] = [];
   const errors: string[] = [];
   settled.forEach((result, index) => {
     if (result.status === "rejected") {
-      const seriesId = CREDIT_SERIES[index]!.seriesId;
+      const seriesId = series[index]!.seriesId;
       errors.push(seriesError(seriesId, result.reason));
       return;
     }

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

@@ -7,6 +7,7 @@ import {
   type CreditConditionsLoadResult,
   type CreditSeriesLoader,
 } from "./client";
+import { creditRegion, creditSeriesIn } from "./model";
 
 const COLUMNS = [
   { key: "label", header: "Index" },
@@ -26,7 +27,7 @@ interface CreditConditionsHeadlessDependencies {
 }
 
 const defaultDependencies: CreditConditionsHeadlessDependencies = {
-  load: (_args, loader) => loadCreditConditions(false, loader),
+  load: (args, loader) => loadCreditConditions(false, loader, creditSeriesIn(creditRegion(args.options.region))),
 };
 
 function createCreditConditionsHeadless(
@@ -35,7 +36,17 @@ function createCreditConditionsHeadless(
   return {
     shape: "rows",
     argument: { kind: "none" },
-    options: [],
+    options: [{
+      key: "region",
+      description: "Indexes to list. FRED publishes euro high yield but no euro investment grade spread.",
+      type: "enum",
+      values: [
+        { value: "all" },
+        { value: "us", aliases: ["usa", "united states", "america"] },
+        { value: "euro", aliases: ["eu", "eur", "europe", "eurozone", "euro area", "ea"] },
+      ],
+      defaultValue: "all",
+    }],
     columns: COLUMNS,
     describe: "Credit Spreads",
     freshness: { source: "FRED", status: "not-a-feed", basis: "daily index levels", cadence: "daily", observedKey: "date" },

package/src/plugins/builtin/credit-conditions/index.tsx

@@ -1,4 +1,4 @@
-import { useMemo } from "react";
+import { useCallback, useMemo } from "react";
 import {
   ChartTableHeader,
   CompositeChart,
@@ -18,12 +18,14 @@ import { useAsyncResource } from "../../../react/async-resource";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
 import { formatPercentileRank } from "../../../utils/format";
+import { usePaneSettingValue } from "../../../state/app/context";
 import { usePluginPaneState } from "../../runtime";
 import type { PluginModule } from "../plugin-module";
+import { CREDIT_SPREAD_SERIES } from "./series";
 import { useAutoRefresh } from "../../../react/auto-refresh";
 import { getCachedCreditConditions, loadCreditConditions } from "./client";
 import { creditConditionsHeadless } from "./headless";
-import { CREDIT_SERIES, type CreditConditionRow } from "./model";
+import { creditRegion, creditSeriesIn, type CreditConditionRow } from "./model";
 
 
 const EMPTY_ROWS: CreditConditionRow[] = [];
@@ -85,7 +87,10 @@ function SpreadDetail({ row, width, height, focused }: { row: CreditConditionRow
 }
 
 export function CreditConditionsPane({ paneId, focused, width, height }: PaneProps) {
-  const resource = useAsyncResource(loadCreditConditions, { initialData: getCachedCreditConditions });
+  const [regionSetting] = usePaneSettingValue<unknown>("region", "all");
+  const series = useMemo(() => creditSeriesIn(creditRegion(regionSetting)), [regionSetting]);
+  const load = useCallback((force: boolean) => loadCreditConditions(force, undefined, series), [series]);
+  const resource = useAsyncResource(load, { initialData: () => getCachedCreditConditions(series) });
   const { loading, load: refresh, reload } = resource;
   const stale = resource.data?.stale ?? false;
   const error = resource.error ?? resource.data?.errors[0] ?? null;
@@ -100,7 +105,7 @@ export function CreditConditionsPane({ paneId, focused, width, height }: PanePro
   useAutoRefresh(lastUpdated, refresh);
 
   usePaneRefreshKey(reload, { focused, enabled: !loading });
-  const partial = rows.length > 0 && rows.length < CREDIT_SERIES.length;
+  const partial = rows.length > 0 && rows.length < series.length;
   // Each row carries its own date in the AS OF column; a spread between
   // indexes from different sessions is a limitation behind the warning.
   usePaneNoticeFooter({
@@ -110,10 +115,10 @@ export function CreditConditionsPane({ paneId, focused, width, height }: PanePro
   });
   const footerInfo = useMemo<PaneFooterSegment[]>(() => [
     ...(rows.length > 0 ? [{ id: "delayed", parts: [{ text: "delayed", tone: "muted" as const }] }] : []),
-    ...(partial ? [{ id: "partial", parts: [{ text: `PARTIAL ${rows.length}/${CREDIT_SERIES.length}`, tone: "warning" as const, bold: true }] }] : []),
+    ...(partial ? [{ id: "partial", parts: [{ text: `PARTIAL ${rows.length}/${series.length}`, tone: "warning" as const, bold: true }] }] : []),
     ...(stale ? [{ id: "stale", parts: [{ text: "STALE", tone: "warning" as const }] }] : []),
     ...loadingErrorFooterInfo(loading, error),
-  ], [error, loading, partial, rows.length, stale]);
+  ], [error, loading, partial, rows.length, series.length, stale]);
   usePaneFooter(paneId, () => ({ info: footerInfo }), [footerInfo, paneId]);
 
   if (rows.length === 0) {
@@ -137,6 +142,7 @@ export function CreditConditionsPane({ paneId, focused, width, height }: PanePro
 }
 
 export const creditConditionsModule: PluginModule = {
+  series: CREDIT_SPREAD_SERIES,
   panes: [{
     id: "credit-conditions",
     name: "Credit Spreads",
@@ -144,14 +150,17 @@ export const creditConditionsModule: PluginModule = {
     component: CreditConditionsPane,
     defaultPosition: "right",
     defaultMode: "floating",
-    defaultFloatingSize: { width: 72, height: 18 },
+    defaultFloatingSize: { width: 72, height: 22 },
+    settings: { title: "Credit Spreads", fields: [{ key: "region", label: "Region", type: "select", options: [
+      { value: "all", label: "All" }, { value: "us", label: "US" }, { value: "euro", label: "Euro" },
+    ] }] },
   }],
   paneTemplates: [{
     id: "credit-conditions-pane",
     paneId: "credit-conditions",
     label: "Credit Spreads",
-    description: "ICE BofA US corporate option-adjusted spreads from FRED.",
-    keywords: ["credit", "spread", "oas", "corporate", "high yield", "investment grade", "macro"],
+    description: "ICE BofA option-adjusted spreads from FRED: US investment grade and high yield by rating, and euro high yield.",
+    keywords: ["credit", "spread", "oas", "corporate", "high yield", "investment grade", "macro", "euro", "europe", "bb", "ccc", "rating"],
     shortcut: { prefix: "CRD" },
     headless: creditConditionsHeadless,
   }],

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

@@ -1,20 +1,28 @@
 import type { CloudFredSeriesPayload } from "../../../api-client";
 import { historyStatistics } from "../../../components/chart/curve/model";
+import { ICE_SPREAD_SERIES, type IceCreditSeries } from "../../../time-series/ice-credit";
 
-export const CREDIT_SERIES = [
-  { seriesId: "BAMLC0A0CM", label: "US IG" },
-  { seriesId: "BAMLC0A1CAAA", label: "AAA" },
-  { seriesId: "BAMLC0A2CAA", label: "AA" },
-  { seriesId: "BAMLC0A3CA", label: "A" },
-  { seriesId: "BAMLC0A4CBBB", label: "BBB" },
-  { seriesId: "BAMLH0A0HYM2", label: "US HY" },
-] as const;
+export type CreditSeriesDefinition = Pick<IceCreditSeries, "seriesId" | "label" | "region">;
 
-export type CreditSeriesId = typeof CREDIT_SERIES[number]["seriesId"];
+/** US investment grade and high yield by rating, then euro high yield. */
+export const CREDIT_SERIES: readonly CreditSeriesDefinition[] = ICE_SPREAD_SERIES
+  .map(({ seriesId, label, region }) => ({ seriesId, label, region }));
+
+const CREDIT_REGIONS = ["all", "us", "euro"] as const;
+type CreditRegion = typeof CREDIT_REGIONS[number];
+
+export function creditRegion(value: unknown): CreditRegion {
+  return CREDIT_REGIONS.includes(value as CreditRegion) ? value as CreditRegion : "all";
+}
+
+export function creditSeriesIn(region: CreditRegion): readonly CreditSeriesDefinition[] {
+  return region === "all" ? CREDIT_SERIES : CREDIT_SERIES.filter((series) => series.region === region);
+}
 
 export interface CreditConditionRow {
-  seriesId: CreditSeriesId;
+  seriesId: string;
   label: string;
+  region: IceCreditSeries["region"];
   title: string;
   units: string;
   frequency: string;
@@ -37,7 +45,7 @@ function roundTenth(value: number): number {
 }
 
 export function normalizeCreditSeries(
-  definition: typeof CREDIT_SERIES[number],
+  definition: CreditSeriesDefinition,
   payload: CloudFredSeriesPayload,
   stale = false,
 ): CreditConditionRow {

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

@@ -0,0 +1,16 @@
+import { fredSeriesUrl } from "../../../sources/gloomberb-cloud/fred-series";
+import type { SeriesDefinition } from "../../../series/types";
+import { ICE_CREDIT_SERIES } from "../../../time-series/ice-credit";
+
+/** Corporate bond option-adjusted spreads by rating and region, and the effective yields of the US indexes. */
+export const CREDIT_SPREAD_SERIES: readonly SeriesDefinition[] = ICE_CREDIT_SERIES.map((series) => ({
+  id: `fred:${series.seriesId}`,
+  name: series.name,
+  unit: "%",
+  frequency: "daily",
+  group: "Credit",
+  tags: [series.measure, ...series.tags, "corporate bonds"],
+  publisher: "FRED",
+  url: fredSeriesUrl(series.seriesId),
+  expression: `FRED:${series.seriesId}`,
+}));