gloomberb 0.16.3 → 0.16.5

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

@@ -14,6 +14,7 @@ import type { PaneProps } from "../../../types/plugin";
 import { Box, Text, useUiCapabilities, type ScrollBoxRenderable } from "../../../ui";
 import { SignInWall } from "../cloud/auth-actions";
 import { CLOUD_PLAN_KEY, useCloudUpgradeAction } from "../shared/cloud-upgrade";
+import { useOpenDescription } from "../shared/open-description";
 import { Blurred, LockedOverlay, UpgradeLabel } from "../shared/locked-rows";
 import { listingCell } from "../shared/research-cells";
 import { isCloudSessionRequired, useResearchCloudSession } from "../shared/research-cloud-session";
@@ -47,6 +48,7 @@ export function CatalystView({ width, height, focused, symbol, litigation = fals
   const access = usePlanAccess();
   const accessKey = `${session.requestKey}:${access.hasProAccess ? "full" : "preview"}`;
   const { createPaneFromTemplate, openPluginCommandWorkflow } = usePluginAppActions();
+  const openDescription = useOpenDescription();
   const openUpgrade = useCloudUpgradeAction("catl");
   const [initialTab] = usePaneSettingValue("tab", "calendar");
   const [savedTab, setTab] = usePluginPaneState("catalyst:tab", initialTab);
@@ -100,7 +102,7 @@ export function CatalystView({ width, height, focused, symbol, litigation = fals
   const { strip, rows: tabRows } = usePaneTabs(!openId ? { tabs: [...CATALYST_TABS].map((item) => litigation && item.value === "calendar" ? { ...item, label: "Dockets" } : item), activeValue: tab, onSelect: (value) => { setTab(value); setSelectedId(null); }, focused, dense: true } : null);
   const selectedSymbol = selected ? catalystSymbol(selected) : symbol;
   const hints: PaneHint[] = [
-    ...(!openId && selectedSymbol ? [{ id: "description", key: "d", label: "es", onPress: () => createPaneFromTemplate("new-ticker-detail-pane", { symbol: selectedSymbol }) },
+    ...(!openId && selectedSymbol ? [{ id: "description", key: "d", label: "es", onPress: () => openDescription(selectedSymbol) },
       { id: "financials", key: "f", label: "a", onPress: () => createPaneFromTemplate("financial-analysis-pane", { symbol: selectedSymbol }) },
       { id: "chart", key: "g", label: "raph", onPress: () => createPaneFromTemplate("chart-composer-pane", { arg: selectedSymbol }) },
       { id: "related", key: "t", label: litigation ? "o calendar" : "o litigation", onPress: () => createPaneFromTemplate(litigation ? "catalysts-pane" : "litigation-pane", { symbol: selectedSymbol }) }] : []),

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

@@ -6,17 +6,30 @@ import {
 } from "../../../api-client";
 import type { CloudCdsHistoryParams } from "../../../api-client/paths";
 import type { InstrumentSearchResult } from "../../../types/instrument";
-import { normalizeCdsTrades, type CdsTrade } from "./model";
+import { mapWithConcurrency } from "../../../utils/concurrency";
+import {
+  cdsReferenceEntity,
+  issuerNameOf,
+  normalizeCdsTrades,
+  spreadSummary,
+  type CdsIssuerSummary,
+  type CdsSpreadLevels,
+  type CdsTrade,
+} from "./model";
 
 /** One trading week of public dissemination is what "recent activity" means here. */
-const CDS_HISTORY_DAYS = 5;
+export const CDS_TRADE_DAYS = 5;
 const CDS_TRADE_LIMIT = 500;
 
 export interface CdsActivity {
   source: string;
   asOf: string | null;
+  /** What was asked for, as typed: a ticker or a name. Null for the market-wide view. */
+  query: string | null;
   /** The issuer name actually sent, after any symbol lookup. */
   issuer: string | null;
+  /** How many days of the tape the trades cover. */
+  days: number;
   trades: CdsTrade[];
 }
 
@@ -27,7 +40,8 @@ export type InstrumentSearch = (query: string, limit?: number) => Promise<Instru
 
 /**
  * A bare ticker with normal symbol punctuation and no spaces. Anything longer or
- * containing a space is already a company name and is sent to the backend as-is.
+ * containing a space is already a company name and is sent as the tape would
+ * name it.
  */
 const TICKER_LIKE = /^[A-Za-z0-9][A-Za-z0-9.^:-]{0,11}$/;
 const US_PRIMARY_EXCHANGES = new Set(["AMEX", "NASDAQ", "NYSE", "NYSEAMERICAN", "NYSEARCA"]);
@@ -42,22 +56,28 @@ function isPrimaryUsCommonStock(result: InstrumentSearchResult): boolean {
 
 /**
  * The backend matches DTCC issuer names, so a ticker has to become a company
- * name first. An untracked symbol has no local metadata to expand it, and its
- * quote name never arrives for a fixed binding, so the shared instrument search
- * is the only reliable expansion. A search outage falls back to the raw input
- * rather than taking the CDS request down with it.
+ * name first: its reference entity when the debt sits with another entity,
+ * else the listed company's name without its share class ("Alphabet Inc.",
+ * not "Alphabet Inc. Class A Common Stock"). An untracked symbol has no local
+ * metadata to expand it, and its quote name never arrives for a fixed
+ * binding, so the shared instrument search is the only reliable expansion. A
+ * search outage falls back to the raw input rather than taking the CDS
+ * request down with it.
  */
-async function resolveIssuerName(
+export async function resolveIssuerName(
   issuer: string,
   searchInstruments: InstrumentSearch,
 ): Promise<string> {
-  if (!TICKER_LIKE.test(issuer)) return issuer;
+  if (!TICKER_LIKE.test(issuer)) return issuerNameOf(issuer);
+  const referenceEntity = cdsReferenceEntity(issuer);
+  if (referenceEntity) return referenceEntity;
   try {
     const results = await searchInstruments(issuer);
     const symbol = issuer.toUpperCase();
     const exactMatches = results.filter((result) => result.symbol.toUpperCase() === symbol);
     const match = exactMatches.find(isPrimaryUsCommonStock) ?? exactMatches[0] ?? results[0];
-    return match?.name?.trim() || issuer;
+    const name = match?.name?.trim();
+    return name ? issuerNameOf(name) : issuer;
   } catch {
     return issuer;
   }
@@ -68,16 +88,19 @@ export async function loadCdsActivity(
   fetchCds: CdsFetch = (params) => apiClient.getCloudCds(params),
   searchInstruments: InstrumentSearch = (query, limit) => apiClient.searchInstruments(query, limit),
 ): Promise<CdsActivity> {
-  const resolved = issuer ? await resolveIssuerName(issuer, searchInstruments) : null;
+  const query = issuer?.trim() || null;
+  const resolved = query ? await resolveIssuerName(query, searchInstruments) : null;
   const response = await fetchCds({
     ...(resolved ? { issuer: resolved } : {}),
-    days: CDS_HISTORY_DAYS,
+    days: CDS_TRADE_DAYS,
     limit: CDS_TRADE_LIMIT,
   });
   return {
     source: response.source,
     asOf: response.asOf,
+    query,
     issuer: resolved,
+    days: CDS_TRADE_DAYS,
     trades: normalizeCdsTrades(response.trades ?? []),
   };
 }
@@ -100,10 +123,44 @@ export type CdsHistoryFetch = (params: CloudCdsHistoryParams) => Promise<CloudCd
 export async function loadCdsSpreadHistory(
   issuer: string,
   fetchHistory: CdsHistoryFetch = (params) => apiClient.getCloudCdsHistory(params),
+  days = CDS_SPREAD_HISTORY_DAYS,
 ): Promise<CdsSpreadHistory> {
-  const response = await fetchHistory({ issuer, days: CDS_SPREAD_HISTORY_DAYS });
+  const response = await fetchHistory({ issuer, days });
   const points = (response.points ?? [])
     .filter((point) => /^\d{4}-\d{2}-\d{2}$/.test(point.date) && Number.isFinite(point.spreadBp))
     .toSorted((left, right) => left.date.localeCompare(right.date));
   return { issuer: response.issuer, points };
 }
+
+/** The month of 5Y line a listed issuer's level is read from, the shortest the backend serves. */
+const CDS_LEVEL_DAYS = 30;
+const CDS_LEVEL_CONCURRENCY = 8;
+
+export type CdsSpreadLevelsLoader = (issuers: readonly Pick<CdsIssuerSummary, "key" | "issuer">[]) => Promise<CdsSpreadLevels>;
+
+/**
+ * The latest 5Y level of every listed issuer, from the same line the pane
+ * charts, so the list can be ranked by it. A name with no level in the last
+ * month is left out; it fails only when no name could be read at all.
+ */
+export async function loadCdsSpreadLevels(
+  issuers: readonly Pick<CdsIssuerSummary, "key" | "issuer">[],
+  fetchHistory: CdsHistoryFetch = (params) => apiClient.getCloudCdsHistory(params),
+): Promise<CdsSpreadLevels> {
+  const levels = new Map<string, { spreadBp: number; date: string }>();
+  let failed = 0;
+  let lastError: unknown = null;
+  await mapWithConcurrency(issuers, CDS_LEVEL_CONCURRENCY, async ({ key, issuer }) => {
+    try {
+      const summary = spreadSummary((await loadCdsSpreadHistory(issuer, fetchHistory, CDS_LEVEL_DAYS)).points);
+      if (summary) levels.set(key, { spreadBp: summary.spreadBp, date: summary.date });
+    } catch (error) {
+      failed += 1;
+      lastError = error;
+    }
+  });
+  if (issuers.length > 0 && failed === issuers.length) {
+    throw lastError instanceof Error ? lastError : new Error("5Y spreads unavailable.");
+  }
+  return levels;
+}

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

@@ -1,32 +1,49 @@
 import type {
+  HeadlessBundleResult,
+  HeadlessBundleSection,
   HeadlessPaneDefinition,
+  HeadlessPaneEntry,
   HeadlessPaneLoadArgs,
-  HeadlessRowsResult,
 } from "../../../types/plugin";
 import {
+  CDS_TRADE_DAYS,
   loadCdsActivity,
+  loadCdsSpreadHistory,
+  loadCdsSpreadLevels,
   type CdsActivity,
   type CdsFetch,
+  type CdsHistoryFetch,
+  type CdsSpreadHistory,
   type InstrumentSearch,
 } from "./client";
 import {
   DEFAULT_ISSUER_SORT,
   DEFAULT_TRADE_SORT,
+  cdsFreshness,
+  displayIssuerName,
   formatBp,
   formatEventTime,
   formatNotional,
+  formatSpreadChange,
+  formatSpreadRange,
   formatUpfront,
+  lastTradeOf,
+  noTradesMessage,
   sortIssuers,
   sortTrades,
+  spreadSummary,
   summarizeIssuers,
+  withSpreadLevels,
+  type CdsSpreadLevels,
   type CdsTrade,
 } from "./model";
 
 const ISSUER_COLUMNS = [
   { key: "issuer", header: "Issuer" },
   { key: "trades", header: "Trades", align: "right" as const },
-  { key: "lastTradeAt", header: "Last UTC", format: (value: unknown) => formatEventTime(Number(value)) },
-  { key: "latestSpreadBp", header: "Spread", align: "right" as const, format: (value: unknown) => formatBp(value as number | null) },
+  { key: "lastTradeAt", header: "Last UTC", shrink: false, format: (value: unknown) => formatEventTime(Number(value)) },
+  { key: "spread5yBp", header: "5Y spread", align: "right" as const, format: (value: unknown) => formatBp(value as number | null) },
+  { key: "spread5yDate", header: "5Y date", shrink: false, format: (value: unknown) => (typeof value === "string" ? value : "--") },
 ];
 
 function tradeForFormatting(row: Record<string, unknown>): CdsTrade {
@@ -34,7 +51,7 @@ function tradeForFormatting(row: Record<string, unknown>): CdsTrade {
 }
 
 const TRADE_COLUMNS = [
-  { key: "eventAt", header: "Time UTC", format: (value: unknown) => formatEventTime(Number(value)) },
+  { key: "eventAt", header: "Time UTC", shrink: false, format: (value: unknown) => formatEventTime(Number(value)) },
   { key: "issuer", header: "Issuer" },
   { key: "maturity", header: "Maturity" },
   {
@@ -48,27 +65,94 @@ const TRADE_COLUMNS = [
   { key: "spreadBp", header: "Spread", align: "right" as const, format: (value: unknown) => formatBp(value as number | null) },
   {
     key: "upfront",
-    header: "Upfront",
+    header: "Abs upfront",
     align: "right" as const,
     format: (_value: unknown, row: Record<string, unknown>) => formatUpfront(tradeForFormatting(row)),
   },
 ];
 
-function projectCdsHeadless(activity: CdsActivity, issuer: string | null): HeadlessRowsResult {
-  if (issuer) {
+/**
+ * The pane's figures over its 5Y chart, as label and value lines: the level,
+ * its date, the 1M move on the same contract (`--` across a roll) and the
+ * range charted. JSON keeps the numbers; text and CSV read as the pane does.
+ */
+function spreadEntries(history: CdsSpreadHistory): HeadlessPaneEntry[] {
+  const summary = spreadSummary(history.points);
+  if (!summary) return [];
+  return [
+    { key: "spreadBp", label: "5Y spread", value: summary.spreadBp, formatted: formatBp(summary.spreadBp) },
+    { key: "date", label: "Date", value: summary.date },
+    {
+      key: "change1mBp",
+      label: "1M change",
+      value: summary.change1mBp,
+      formatted: summary.change1mBp == null ? "--" : formatSpreadChange(summary.change1mBp),
+    },
+    ...(summary.range ? [{
+      key: "range",
+      label: "Range",
+      value: summary.range,
+      formatted: `${formatSpreadRange(summary.range)} since ${summary.range.since}`,
+    }] : []),
+  ];
+}
+
+interface CdsReportInputs {
+  activity: CdsActivity;
+  /** The issuer's 5Y line, or the error that kept it out. */
+  history?: CdsSpreadHistory | Error | null;
+  /** Each listed issuer's 5Y level, or the error that kept them out. */
+  levels?: CdsSpreadLevels | Error | null;
+}
+
+function projectCdsHeadless({ activity, history, levels }: CdsReportInputs): HeadlessBundleResult {
+  const errors: string[] = [];
+  const notes: string[] = [];
+  const empty = noTradesMessage({ query: activity.query, issuer: activity.issuer, days: activity.days });
+  const metadata = { issuer: activity.issuer, days: activity.days };
+  if (activity.query) {
+    const line = history instanceof Error || !history ? null : history;
+    if (history instanceof Error) errors.push("5Y spread history unavailable.");
+    const entries = line ? spreadEntries(line) : [];
+    // The name the tape was queried for heads the figures, as in the pane, so a ticker says what it became.
+    const name = displayIssuerName(activity.issuer ?? line?.issuer ?? activity.query);
+    if (line && entries.length === 0) notes.push(`No 5Y spread level for ${name} in the last two years.`);
+    const sections: HeadlessBundleSection[] = [
+      ...(entries.length ? [{ title: name, entries }] : []),
+      {
+        title: "Trades",
+        columns: TRADE_COLUMNS,
+        rows: sortTrades(activity.trades, DEFAULT_TRADE_SORT).map((trade) => ({ ...trade })),
+        empty,
+      },
+    ];
     return {
-      columns: TRADE_COLUMNS,
-      rows: sortTrades(activity.trades, DEFAULT_TRADE_SORT).map((trade) => ({ ...trade })),
-      metadata: { source: activity.source, asOf: activity.asOf, issuer: activity.issuer },
+      sections,
+      metadata,
+      freshness: cdsFreshness(lastTradeOf(activity.trades, line?.points)),
+      ...(errors.length ? { errors } : {}),
+      ...(notes.length ? { notes } : {}),
     };
   }
+  if (levels instanceof Error) errors.push("5Y spreads unavailable.");
+  const issuers = withSpreadLevels(summarizeIssuers(activity.trades), levels instanceof Error ? null : levels ?? null);
   return {
-    columns: ISSUER_COLUMNS,
-    rows: sortIssuers(summarizeIssuers(activity.trades), DEFAULT_ISSUER_SORT).map((issuerRow) => ({ ...issuerRow })),
-    metadata: { source: activity.source, asOf: activity.asOf, issuer: null },
+    sections: [{
+      title: "Issuers",
+      columns: ISSUER_COLUMNS,
+      rows: sortIssuers(issuers, DEFAULT_ISSUER_SORT).map((issuerRow) => ({ ...issuerRow })),
+      empty,
+    }],
+    metadata,
+    freshness: cdsFreshness(lastTradeOf(activity.trades)),
+    ...(errors.length ? { errors } : {}),
   };
 }
 
+function settled<T>(pending: Promise<T>): Promise<T | Error> {
+  return pending.catch((error: unknown) => (error instanceof Error ? error : new Error(String(error))));
+}
+
 export interface CdsHeadlessDependencies {
   load(
     args: HeadlessPaneLoadArgs,
@@ -76,38 +160,51 @@ export interface CdsHeadlessDependencies {
     fetchCds: CdsFetch,
     searchInstruments: InstrumentSearch,
   ): Promise<CdsActivity>;
+  loadHistory?(issuer: string, fetchHistory: CdsHistoryFetch): Promise<CdsSpreadHistory>;
+  loadLevels?: typeof loadCdsSpreadLevels;
 }
 
 const defaultDependencies: CdsHeadlessDependencies = {
   load: (_args, issuer, fetchCds, searchInstruments) => (
     loadCdsActivity(issuer, fetchCds, searchInstruments)
   ),
+  loadHistory: (issuer, fetchHistory) => loadCdsSpreadHistory(issuer, fetchHistory),
+  loadLevels: loadCdsSpreadLevels,
 };
 
 export function createCdsHeadless(
   dependencies: CdsHeadlessDependencies = defaultDependencies,
-): HeadlessPaneDefinition<"rows"> {
+): HeadlessPaneDefinition<"bundle"> {
+  const loadHistory = dependencies.loadHistory ?? defaultDependencies.loadHistory!;
+  const loadLevels = dependencies.loadLevels ?? defaultDependencies.loadLevels!;
   return {
-    shape: "rows",
-    // Public dissemination of swap trades, held back by rule for some trades.
-    freshness: { source: "DTCC", status: "delayed" },
+    shape: "bundle",
+    description: `Single-name CDS from DTCC public dissemination. With no argument: the issuers traded in the last ${CDS_TRADE_DAYS} days, most active first, with trade count, last trade and 5Y spread. With a ticker or issuer: its 5Y spread (level, date, 1M change, range) and its trades.`,
+    freshness: cdsFreshness(null),
     argument: {
       kind: "free-text",
       placeholder: "ticker or issuer",
-      description: "Optional ticker or issuer. Omit for the most-active issuer view.",
+      description: "Optional ticker or issuer. Omit to list the most-active issuers with their 5Y spread.",
       optional: true,
     },
     options: [],
     describe: (args) => typeof args.argument === "string" ? `CDS | ${args.argument}` : "Single-Name CDS",
     async load(args, ctx) {
       const issuer = typeof args.argument === "string" ? args.argument : null;
+      const fetchHistory: CdsHistoryFetch = (params) => ctx.apiClient.getCloudCdsHistory(params);
       const activity = await dependencies.load(
         args,
         issuer,
         (params) => ctx.apiClient.getCloudCds(params),
         (query, limit) => ctx.apiClient.searchInstruments(query, limit),
       );
-      return projectCdsHeadless(activity, issuer);
+      if (activity.query) {
+        // The line follows the name the tape was queried for, as the pane's does.
+        const history = activity.issuer ? await settled(loadHistory(activity.issuer, fetchHistory)) : null;
+        return projectCdsHeadless({ activity, history });
+      }
+      const levels = await settled(loadLevels(summarizeIssuers(activity.trades), fetchHistory));
+      return projectCdsHeadless({ activity, levels });
     },
   };
 }

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

@@ -1,5 +1,6 @@
 import type { PaneTemplateCreateOptions } from "../../../types/plugin";
 import type { PluginModule } from "../plugin-module";
+import { SINGLE_NAME_CDS_SERIES } from "./series";
 import { CDS_PANE_ID } from "./model";
 import { CdsPane } from "./pane";
 import { cdsHeadless } from "./headless";
@@ -12,6 +13,7 @@ function explicitSymbol(options?: PaneTemplateCreateOptions): string | null {
 }
 
 export const cdsModule: PluginModule = {
+  series: SINGLE_NAME_CDS_SERIES,
   panes: [{
     id: CDS_PANE_ID,
     name: "Single-Name CDS",
@@ -27,7 +29,7 @@ export const cdsModule: PluginModule = {
     id: "cds-pane",
     paneId: CDS_PANE_ID,
     label: "Single-Name CDS",
-    description: "Single-name corporate CDS trades and 5Y spread history from DTCC public dissemination.",
+    description: "Single-name corporate CDS from DTCC public dissemination: with no argument, the issuers traded in the last 5 days with their 5Y spread; with a ticker or issuer, its 5Y spread history and trades.",
     keywords: ["cds", "credit", "default", "swap", "spread", "single name", "issuer", "dtcc", "protection"],
     shortcut: { prefix: "CDS", argPlaceholder: "ticker", argKind: "ticker", argOptional: true },
     headless: cdsHeadless,