@gloom-sh/terminal 0.18.5 → 0.19.1

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

@@ -9,6 +9,8 @@ import type { CloudCdsHistoryParams } from "../../../api-client/paths";
 import type { InstrumentSearchResult } from "../../../types/instrument";
 import {
   cdsReferenceEntity,
+  closestCoveredIssuers,
+  coveredIssuerMatch,
   issuerNameOf,
   normalizeCdsTrades,
   spreadLevelsOf,
@@ -29,6 +31,12 @@ export interface CdsActivity {
   query: string | null;
   /** The issuer name actually sent, after any symbol lookup. */
   issuer: string | null;
+  /**
+   * Set when a name matched no covered issuer and was sent as typed or as its
+   * listing's name: the covered issuers closest to what was typed, for the
+   * view to offer when the tape has nothing under it either.
+   */
+  unmatched?: { nearest: string[] } | null;
   /** How many days of the tape the trades cover. */
   days: number;
   trades: CdsTrade[];
@@ -38,61 +46,164 @@ export type CdsActivityLoader = (issuer: string | null) => Promise<CdsActivity>;
 
 export type CdsFetch = (params: { issuer?: string; days?: number; limit?: number }) => Promise<CloudCdsResponse>;
 export type InstrumentSearch = (query: string, limit?: number) => Promise<InstrumentSearchResult[]>;
+/** The names of the issuers whose 5Y line has a level, as the tape spells them. */
+export type CoveredIssuers = () => Promise<readonly string[]>;
 
 /**
- * A bare ticker with normal symbol punctuation and no spaces. Anything longer or
- * containing a space is already a company name and is sent as the tape would
- * name it.
+ * A ticker as typed: symbol punctuation, no spaces, and no lowercase letter.
+ * `WHR` and `BRK.B` are tickers; `goodyear` and `Paramount` are names.
  */
-const TICKER_LIKE = /^[A-Za-z0-9][A-Za-z0-9.^:-]{0,11}$/;
+const TICKER_LIKE = /^[A-Z0-9][A-Z0-9.^:-]{0,11}$/;
 const US_PRIMARY_EXCHANGES = new Set(["AMEX", "NASDAQ", "NYSE", "NYSEAMERICAN", "NYSEARCA"]);
 
+/** The US venues besides the primary exchanges a listing can trade on: a receipt's or a delisted company's line. */
+const US_OTHER_EXCHANGES = new Set(["ARCA", "BATS", "IEX", "OTC", "OTCMKTS", "PNK"]);
+
+const listingExchange = (result: InstrumentSearchResult) => (result.primaryExchange || result.exchange).toUpperCase().replace(/[^A-Z]/g, "");
+
 function isPrimaryUsCommonStock(result: InstrumentSearchResult): boolean {
-  const exchange = (result.primaryExchange || result.exchange).toUpperCase().replace(/[^A-Z]/g, "");
   const type = result.type.toLowerCase();
   return result.currency === "USD"
-    && US_PRIMARY_EXCHANGES.has(exchange)
+    && US_PRIMARY_EXCHANGES.has(listingExchange(result))
     && (type === "stk" || type === "equity" || type.includes("common stock"));
 }
 
+/** A line on a US venue in dollars (a receipt, a line over the counter); a listing abroad is not one. */
+function isUsLine(result: InstrumentSearchResult): boolean {
+  const exchange = listingExchange(result);
+  return (!result.currency || result.currency === "USD") && (US_PRIMARY_EXCHANGES.has(exchange) || US_OTHER_EXCHANGES.has(exchange));
+}
+
 /**
- * The backend matches DTCC issuer names, so a ticker has to become a company
- * 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.
+ * Whether a listing carries what was typed: the words in its name or a name
+ * search knows it by (`searchAliases`), or a ticker it had (`formerIssuer`:
+ * BRCM on Broadcom Inc.). The first US hit for a name that does not is
+ * another company.
  */
+function carriesTyped(result: InstrumentSearchResult, typed: string): boolean {
+  const symbol = typed.toUpperCase();
+  if (result.formerIssuer?.symbol?.toUpperCase() === symbol) return true;
+  return [result.name, ...result.searchAliases ?? [], result.formerIssuer?.name]
+    .some((name) => !!name && coveredIssuerMatch(typed, [name]) != null);
+}
+
+/** The covered issuers' names, from the same request as their levels. */
+export function coveredIssuersFrom(fetchLevels: CdsLevelsFetch): CoveredIssuers {
+  return async () => ((await fetchLevels()).levels ?? []).flatMap((level) => (typeof level.issuer === "string" ? [level.issuer] : []));
+}
+
+const defaultCoveredIssuers = coveredIssuersFrom(() => apiClient.getCloudCdsLevels());
+
+async function searchOrNone(searchInstruments: InstrumentSearch, query: string): Promise<InstrumentSearchResult[]> {
+  try {
+    return await searchInstruments(query);
+  } catch {
+    // Intentional ignore: a search outage sends the name as typed instead of failing the CDS request.
+    return [];
+  }
+}
+
+async function coveredOrNone(coveredIssuers: CoveredIssuers): Promise<readonly string[]> {
+  try {
+    return await coveredIssuers();
+  } catch {
+    // Intentional ignore: without the covered list the name goes on to the listing and the tape.
+    return [];
+  }
+}
+
+interface CdsIssuerResolution {
+  /** The name the tape is asked for. */
+  issuer: string;
+  /** Set when a name matched no covered issuer; see `CdsActivity.unmatched`. */
+  unmatched: { nearest: string[] } | null;
+}
+
+/**
+ * The backend matches DTCC issuer names, so what was typed has to become one.
+ *
+ * Any one-word input, whatever its case (`CHTR`, `chtr`), is first looked up
+ * among the tickers whose debt sits with another entity: CHTR is CCO
+ * Holdings, LLC.
+ *
+ * A ticker (`WHR`) becomes the listed company's name without its share class
+ * ("Alphabet Inc.", not "Alphabet Inc. Class A Common Stock"): its primary US
+ * common stock where exchanges reuse the symbol, else its US line. 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.
+ *
+ * Then the names of the covered issuers (`goodyear`, `GOODYEAR`, `paramount `
+ * are The Goodyear Tire & Rubber Company and Paramount Global), by words of
+ * three letters or more: `f` and `ge` go to the symbol they are. Only then a
+ * listing abroad with that exact symbol, and only when it names a covered
+ * issuer: Goodyear India, the first hit for `goodyear`, is no CDS name. Last,
+ * the primary US common stock with the symbol, or the first one whose name
+ * carries what was typed. Nothing matched, the input goes to the tape as
+ * typed, with the covered issuers closest to it.
+ *
+ * A longer name in capitals and lowercase is already a company name and is
+ * sent as written. A search outage falls back to the raw input rather than
+ * taking the CDS request down with it.
+ */
+async function resolveCdsIssuer(
+  query: string,
+  searchInstruments: InstrumentSearch,
+  coveredIssuers: CoveredIssuers = defaultCoveredIssuers,
+): Promise<CdsIssuerResolution> {
+  const ticker = TICKER_LIKE.test(query);
+  const oneWord = !/\s/.test(query);
+  if (!oneWord && query !== query.toLowerCase()) return { issuer: issuerNameOf(query), unmatched: null };
+  const referenceEntity = oneWord ? cdsReferenceEntity(query) : null;
+  if (referenceEntity) return { issuer: referenceEntity, unmatched: null };
+  const symbol = query.toUpperCase();
+  let results: InstrumentSearchResult[] | null = null;
+  let abroad: InstrumentSearchResult | undefined;
+  if (ticker) {
+    results = await searchOrNone(searchInstruments, query);
+    const exactMatches = results.filter((result) => result.symbol.toUpperCase() === symbol);
+    const name = (exactMatches.find(isPrimaryUsCommonStock) ?? exactMatches.find(isUsLine))?.name?.trim();
+    if (name) return { issuer: issuerNameOf(name), unmatched: null };
+    abroad = exactMatches.find((result) => !!result.name?.trim());
+  }
+  const covered = await coveredOrNone(coveredIssuers);
+  const named = coveredIssuerMatch(query, covered);
+  if (named) return { issuer: named, unmatched: null };
+  // A line abroad never wins on its own: only as the covered issuer it names.
+  const abroadIssuer = abroad ? coveredIssuerMatch(issuerNameOf(abroad.name.trim()), covered) : null;
+  if (abroadIssuer) return { issuer: abroadIssuer, unmatched: null };
+  results ??= await searchOrNone(searchInstruments, query);
+  const primary = results.filter(isPrimaryUsCommonStock);
+  const listing = (primary.find((result) => result.symbol.toUpperCase() === symbol) ?? primary.find((result) => carriesTyped(result, query)))?.name?.trim();
+  if (listing) {
+    const issuer = issuerNameOf(listing);
+    const listed = coveredIssuerMatch(issuer, covered);
+    return listed
+      ? { issuer: listed, unmatched: null }
+      : { issuer, unmatched: { nearest: closestCoveredIssuers(query, covered) } };
+  }
+  return { issuer: ticker ? query : issuerNameOf(query), unmatched: { nearest: closestCoveredIssuers(query, covered) } };
+}
+
+/** The name `resolveCdsIssuer` sends to the tape, for a caller that only needs that. */
 export async function resolveIssuerName(
   issuer: string,
   searchInstruments: InstrumentSearch,
+  coveredIssuers?: CoveredIssuers,
 ): Promise<string> {
-  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];
-    const name = match?.name?.trim();
-    return name ? issuerNameOf(name) : issuer;
-  } catch {
-    return issuer;
-  }
+  return (await resolveCdsIssuer(issuer, searchInstruments, coveredIssuers)).issuer;
 }
 
 export async function loadCdsActivity(
   issuer: string | null,
   fetchCds: CdsFetch = (params) => apiClient.getCloudCds(params),
   searchInstruments: InstrumentSearch = (query, limit) => apiClient.searchInstruments(query, limit),
+  coveredIssuers: CoveredIssuers = defaultCoveredIssuers,
 ): Promise<CdsActivity> {
   const query = issuer?.trim() || null;
-  const resolved = query ? await resolveIssuerName(query, searchInstruments) : null;
+  const resolved = query ? await resolveCdsIssuer(query, searchInstruments, coveredIssuers) : null;
   const response = await fetchCds({
-    ...(resolved ? { issuer: resolved } : {}),
+    ...(resolved ? { issuer: resolved.issuer } : {}),
     days: CDS_TRADE_DAYS,
     limit: CDS_TRADE_LIMIT,
   });
@@ -100,7 +211,8 @@ export async function loadCdsActivity(
     source: response.source,
     asOf: response.asOf,
     query,
-    issuer: resolved,
+    issuer: resolved?.issuer ?? null,
+    ...(resolved?.unmatched ? { unmatched: resolved.unmatched } : {}),
     days: CDS_TRADE_DAYS,
     trades: normalizeCdsTrades(response.trades ?? []),
   };

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

@@ -9,6 +9,7 @@ import type {
 } from "../../../types/plugin";
 import {
   CDS_TRADE_DAYS,
+  coveredIssuersFrom,
   loadCdsActivity,
   loadCdsSpreadHistory,
   loadCdsSpreadLevels,
@@ -17,6 +18,7 @@ import {
   type CdsHistoryFetch,
   type CdsLevelsFetch,
   type CdsSpreadHistory,
+  type CoveredIssuers,
   type InstrumentSearch,
 } from "./client";
 import { formatContract } from "../credit-boards/model";
@@ -35,6 +37,7 @@ import {
   formatSpreadMove,
   formatSpreadRange,
   formatUpfront,
+  hasPointsQuotes,
   issuerListSort,
   quotedLevel,
   lastTradeOf,
@@ -154,7 +157,7 @@ function tradeForFormatting(row: Record<string, unknown>): CdsTrade {
   return row as unknown as CdsTrade;
 }
 
-const TRADE_COLUMNS = [
+const TRADE_COLUMNS: HeadlessPaneColumn[] = [
   { key: "eventAt", header: "Time UTC", shrink: false, format: (value: unknown) => formatEventTime(Number(value)) },
   { key: "issuer", header: "Issuer" },
   { key: "maturity", header: "Maturity" },
@@ -175,6 +178,22 @@ const TRADE_COLUMNS = [
   },
 ];
 
+/**
+ * A print that quoted points upfront in its spread field reads in a Points
+ * column, shown when one did; exports write the number as quoted.
+ */
+const POINTS_COLUMN: HeadlessPaneColumn = {
+  key: "pointsUpfront",
+  header: "Points",
+  align: "right",
+  format: (value: unknown) => (typeof value === "number" ? String(value) : "--"),
+  textFormat: (value: unknown) => formatPoints(numberOrNull(value)),
+};
+
+const tradeColumns = (points: boolean): HeadlessPaneColumn[] => (
+  points ? [...TRADE_COLUMNS.slice(0, -1), POINTS_COLUMN, TRADE_COLUMNS.at(-1)!] : TRADE_COLUMNS
+);
+
 /**
  * The pane's figures over its 5Y chart, as label and value lines: the level,
  * its date, the 1W and 1M moves through the roll and the range charted, in
@@ -227,24 +246,29 @@ interface CdsReportInputs {
 function projectCdsHeadless({ activity, history, levels, sort, days = DAILY_DAYS.defaultValue }: 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.");
+    // A name that matched no covered issuer, with no trades and no line under it on the tape either.
+    const unmatched = activity.unmatched && !activity.trades.length && line && !line.issuer ? activity.unmatched : null;
+    const empty = noTradesMessage({ query: activity.query, issuer: activity.issuer, days: activity.days, unmatched });
     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);
+    // The name the tape was queried for heads the figures, as in the pane, so a ticker says what it became;
+    // a name sent as typed takes the one the tape answered with.
+    const name = displayIssuerName((activity.unmatched ? line?.issuer : null) ?? activity.issuer ?? line?.issuer ?? activity.query);
     const why = line ? noLevelMessage(line.noLevelReason, line.points.at(-1)?.date ?? null) : null;
     if (why) notes.push(`${why}.`);
-    else if (line && entries.length === 0) notes.push(`No 5Y spread level for ${name} in the last two years.`);
+    else if (unmatched) {
+      if (!unmatched.nearest.length) notes.push("fn CDS lists the covered issuers.");
+    } else if (line && entries.length === 0) notes.push(`No 5Y spread level for ${name} in the last two years.`);
     // The 5Y figures are dated by their level's day, each trade and each daily level by its own.
     const levelDate = line ? spreadSummary(line)?.date : undefined;
     const sections: HeadlessBundleSection[] = [
       ...(entries.length ? [{ title: name, entries, symbol: name, ...(levelDate ? { asOf: levelDate } : {}) }] : []),
       {
         title: "Trades",
-        columns: TRADE_COLUMNS,
+        columns: tradeColumns(hasPointsQuotes(activity.trades)),
         rows: sortTrades(activity.trades, DEFAULT_TRADE_SORT).map((trade) => ({ ...trade })),
         empty,
         rowSymbolKey: "issuer",
@@ -265,6 +289,7 @@ function projectCdsHeadless({ activity, history, levels, sort, days = DAILY_DAYS
       ...(notes.length ? { notes } : {}),
     };
   }
+  const empty = noTradesMessage({ query: null, issuer: null, days: activity.days });
   if (levels instanceof Error) errors.push("5Y spreads unavailable.");
   const issuers = withSpreadLevels(summarizeIssuers(activity.trades), levels instanceof Error ? null : levels ?? null);
   return {
@@ -294,14 +319,15 @@ export interface CdsHeadlessDependencies {
     issuer: string | null,
     fetchCds: CdsFetch,
     searchInstruments: InstrumentSearch,
+    coveredIssuers: CoveredIssuers,
   ): Promise<CdsActivity>;
   loadHistory?(issuer: string, fetchHistory: CdsHistoryFetch): Promise<CdsSpreadHistory>;
   loadLevels?: typeof loadCdsSpreadLevels;
 }
 
 const defaultDependencies: CdsHeadlessDependencies = {
-  load: (_args, issuer, fetchCds, searchInstruments) => (
-    loadCdsActivity(issuer, fetchCds, searchInstruments)
+  load: (_args, issuer, fetchCds, searchInstruments, coveredIssuers) => (
+    loadCdsActivity(issuer, fetchCds, searchInstruments, coveredIssuers)
   ),
   loadHistory: (issuer, fetchHistory) => loadCdsSpreadHistory(issuer, fetchHistory),
   loadLevels: loadCdsSpreadLevels,
@@ -353,6 +379,7 @@ export function createCdsHeadless(
         issuer,
         (params) => ctx.apiClient.getCloudCds(params),
         (query, limit) => ctx.apiClient.searchInstruments(query, limit),
+        coveredIssuersFrom(fetchLevels),
       );
       if (activity.query) {
         // The line follows the name the tape was queried for, as the pane's does.

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

@@ -5,6 +5,7 @@ import type { HeadlessPaneFreshness } from "../../../types/headless";
 import type { TickerRecord } from "../../../types/ticker";
 import { formatCompact } from "../../../utils/format";
 import { compareSortValues, type SortPreference } from "../../../utils/sort-values";
+import { typoDistance } from "../../../utils/typo-distance";
 import { formatMove } from "../credit-boards/model";
 
 export const CDS_PANE_ID = "cds";
@@ -20,7 +21,7 @@ const DECIMAL_TO_BP = 10_000;
 
 export interface CdsTrade {
   id: string;
-  /** Reported spelling, kept verbatim so a display name can be chosen later. */
+  /** The issuer's best spelling on the tape, the same on every print of it (see `normalizeCdsTrades`). */
   issuer: string;
   /** Alias-collapsed grouping key. Internal only; never shown or sent. */
   issuerKey: string;
@@ -31,8 +32,13 @@ export interface CdsTrade {
   notionalCapped: boolean;
   currency: string | null;
   couponBp: number | null;
-  /** Only what the report carried. Never derived from upfront or coupon. */
+  /**
+   * Only what the report carried. Never derived from upfront or coupon, and
+   * empty when the field held points upfront (`pointsUpfront`).
+   */
   spreadBp: number | null;
+  /** The quote of a print whose spread field held points upfront, not bp. */
+  pointsUpfront: number | null;
   /** Source inputs retained even when their notation cannot supply a bp rate. */
   reportedSpread: number | null;
   spreadNotation: string | null;
@@ -143,6 +149,66 @@ export function issuerGroupKey(name: string): string {
   return (meaningful.length > 0 ? meaningful : tokens).join(" ") || name.trim().toLowerCase();
 }
 
+/** Fewer letters than this are a symbol, not words of a name: `f` is Ford's ticker, not "F&G Annuities & Life". */
+const MIN_NAME_LETTERS = 3;
+
+/**
+ * The covered issuer a name stands for, by its words: the issuer of that very
+ * name, else one whose name holds those words in a row (`goodyear` is "The
+ * Goodyear Tire & Rubber Company"), one that starts with them first, then the
+ * shortest, so `ford` is Ford Motor Company and not Ford Motor Credit. Null
+ * when none does, and for fewer than three letters (`f`, `ge`), which are a
+ * symbol to look up.
+ */
+export function coveredIssuerMatch(name: string, covered: readonly string[]): string | null {
+  const wanted = issuerGroupKey(displayIssuerName(name));
+  if (wanted.replace(/[^\p{L}\p{N}]/gu, "").length < MIN_NAME_LETTERS) return null;
+  let best: { issuer: string; leading: boolean; words: number } | null = null;
+  for (const issuer of covered) {
+    const key = issuerGroupKey(displayIssuerName(issuer));
+    if (key === wanted) return displayIssuerName(issuer);
+    if (!` ${key} `.includes(` ${wanted} `)) continue;
+    const candidate = { issuer: displayIssuerName(issuer), leading: key.startsWith(`${wanted} `), words: key.split(" ").length };
+    if (!best
+      || (candidate.leading !== best.leading ? candidate.leading
+        : candidate.words !== best.words ? candidate.words < best.words
+          : candidate.issuer.localeCompare(best.issuer) < 0)) best = candidate;
+  }
+  return best?.issuer ?? null;
+}
+
+/** How many covered issuers an unmatched name offers. */
+const CLOSEST_ISSUERS = 3;
+
+/**
+ * How near a word is to one of a name's: a slip of the keys, or the same first
+ * letters (`goodyer`, `paramo`). Short words never count, or every name with
+ * "co" in it would be close.
+ */
+function wordCloseness(typed: string, word: string): number {
+  if (typed.length < 3 || word.length < 3) return 0;
+  if (typed.length >= 4 && typoDistance(typed, word) <= 1) return typed.length;
+  let shared = 0;
+  while (shared < Math.min(typed.length, word.length) && typed[shared] === word[shared]) shared += 1;
+  return shared >= 4 || (shared >= 3 && shared === typed.length) ? shared : 0;
+}
+
+/** The covered issuers closest to a name that matched none, closest first; none when nothing is near. */
+export function closestCoveredIssuers(name: string, covered: readonly string[]): string[] {
+  const typed = issuerGroupKey(displayIssuerName(name)).split(" ").filter(Boolean);
+  const scored = new Map<string, number>();
+  for (const issuer of covered) {
+    const words = issuerGroupKey(displayIssuerName(issuer)).split(" ");
+    const score = typed.reduce((sum, word) => sum + Math.max(0, ...words.map((other) => wordCloseness(word, other))), 0);
+    const shown = displayIssuerName(issuer);
+    if (score > 0 && score > (scored.get(shown) ?? 0)) scored.set(shown, score);
+  }
+  return [...scored]
+    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+    .slice(0, CLOSEST_ISSUERS)
+    .map(([issuer]) => issuer);
+}
+
 /**
  * DTCC writes a comma inside a field as `;` ("CCO Holdings;LLC",
  * "Amazon.com;Inc."), so a name gets its comma back before it is shown,
@@ -207,6 +273,37 @@ function couponToBasisPoints(fixedRate: number | null): number | null {
   return fixedRate * DECIMAL_TO_BP;
 }
 
+/**
+ * How far a reported quote may sit from the points its upfront works out to
+ * and still be read as those points: accrued and rounding move the amount by
+ * about a tenth of a point.
+ */
+const POINTS_MATCH_PTS = 0.5;
+const POINTS_MATCH_SHARE = 0.05;
+
+/**
+ * Some desks key a distressed name's points upfront into the spread field and
+ * leave the coupon blank: Whirlpool's Dec 2028 contract printed `0.00065`,
+ * 6.5 read as bp, beside 319,861 upfront on 5M, which is 6.4 points. Without a
+ * coupon nothing makes the field a running spread, and when the amount over
+ * the notional reads as the same number in points, it is that many points.
+ * A real spread that low on a running coupon would need the upfront to land on
+ * the same number by chance, below 5bp.
+ */
+function pointsUpfrontOf(
+  spreadBp: number | null,
+  couponBp: number | null,
+  upfront: number | null,
+  notional: number | null,
+): number | null {
+  if (couponBp != null || spreadBp == null || !(spreadBp > 0)) return null;
+  if (upfront == null || !Number.isFinite(upfront) || notional == null || !(notional > 0)) return null;
+  const impliedPts = (Math.abs(upfront) / notional) * 100;
+  const tolerance = Math.max(POINTS_MATCH_PTS, impliedPts * POINTS_MATCH_SHARE);
+  // The decimal the field holds carries float noise (0.001525 is 15.249999...).
+  return Math.abs(spreadBp - impliedPts) <= tolerance ? Math.round(spreadBp * 1e6) / 1e6 : null;
+}
+
 /**
  * When the trade was struck, not when the tape carried it. A lifecycle
  * correction is disseminated long after the fact, so using the event time would
@@ -232,32 +329,46 @@ function issuerOf(trade: CloudCdsTradePayload): string | null {
   return underlier && identifiesIssuer(underlier) ? displayIssuerName(underlier) : null;
 }
 
+/**
+ * The tape's prints as rows. One issuer reads as one name on every print:
+ * the tape spells Whirlpool three ways in a week ("WHIRLPOOL CORPORATION",
+ * "Whirlpool Corp", "Whirlpool Corporation"), and each row takes the spelling
+ * the issuer list shows for them all.
+ */
 export function normalizeCdsTrades(trades: readonly CloudCdsTradePayload[]): CdsTrade[] {
   const rows: CdsTrade[] = [];
+  const names = new Map<string, string>();
   for (const trade of trades) {
     const eventAt = tapeTime(trade);
     if (eventAt == null) continue;
     const issuer = issuerOf(trade);
     // Nothing names the reference entity, so the row would invent one.
     if (!issuer) continue;
+    const issuerKey = issuerGroupKey(issuer);
+    const named = names.get(issuerKey);
+    names.set(issuerKey, named ? preferredIssuerName(named, issuer) : issuer);
+    const couponBp = couponToBasisPoints(trade.fixedRate);
+    const reportedBp = spreadToBasisPoints(trade.reportedSpread, trade.spreadNotation);
+    const pointsUpfront = pointsUpfrontOf(reportedBp, couponBp, trade.upfrontAmount, trade.notionalAmount);
     rows.push({
       id: trade.disseminationId,
       issuer,
-      issuerKey: issuerGroupKey(issuer),
+      issuerKey,
       eventAt,
       maturity: trade.maturityDate ?? trade.expirationDate,
       notional: trade.notionalAmount,
       notionalCapped: trade.notionalCapped,
       currency: trade.notionalCurrency,
-      couponBp: couponToBasisPoints(trade.fixedRate),
-      spreadBp: spreadToBasisPoints(trade.reportedSpread, trade.spreadNotation),
+      couponBp,
+      spreadBp: pointsUpfront == null ? reportedBp : null,
+      pointsUpfront,
       reportedSpread: trade.reportedSpread,
       spreadNotation: trade.spreadNotation,
       upfront: trade.upfrontAmount,
       upfrontCurrency: trade.upfrontCurrency,
     });
   }
-  return rows;
+  return rows.map((row) => ({ ...row, issuer: names.get(row.issuerKey) ?? row.issuer }));
 }
 
 /**
@@ -405,13 +516,23 @@ export function cdsFreshness(lastTrade: number | string | null): HeadlessPaneFre
  * What an empty view says: the window searched and, for one name, the
  * reference entity the query became, with what was typed when that differs.
  */
-export function noTradesMessage({ query, issuer, days }: {
+export function noTradesMessage({ query, issuer, days, unmatched = null }: {
   query: string | null;
   issuer: string | null;
   days: number;
+  /**
+   * A name that matched no covered issuer, once the tape has no trades and no
+   * line under it either: what the view says instead is that no issuer
+   * matches, with the covered ones closest to what was typed.
+   */
+  unmatched?: { nearest: readonly string[] } | null;
 }): string {
   const window = `in the last ${days} days`;
   if (!query) return `No single-name CDS trades ${window}.`;
+  if (unmatched) {
+    const nearest = unmatched.nearest.length ? ` Closest covered issuers: ${unmatched.nearest.join(", ")}.` : "";
+    return `No CDS issuer matches ${query}.${nearest}`;
+  }
   const name = issuer && issuer.toUpperCase() !== query.toUpperCase() ? `${issuer} (${query})` : issuer ?? query;
   return `No CDS trades for ${name} ${window}.`;
 }
@@ -610,22 +731,25 @@ export function sortIssuers(
   });
 }
 
-export type TradeColumnId = "time" | "maturity" | "notional" | "currency" | "coupon" | "spread" | "upfront";
+export type TradeColumnId = "time" | "maturity" | "notional" | "currency" | "coupon" | "spread" | "points" | "upfront";
 export type TradeColumn = DataTableColumn & { id: TradeColumnId };
 export type TradeSortPreference = SortPreference<TradeColumnId>;
 
-export const TRADE_SORT_COLUMN_IDS: readonly TradeColumnId[] = [
-  "time",
-  "maturity",
-  "notional",
-  "coupon",
-  "spread",
-  "upfront",
-];
 export const DEFAULT_TRADE_SORT: TradeSortPreference = { columnId: "time", direction: "desc" };
 
-export function buildTradeColumns(width: number): TradeColumn[] {
-  const maturityWidth = Math.max(10, Math.min(12, width - 59));
+/** Whether any print was quoted in points upfront, which is when the trades show a Points column. */
+export function hasPointsQuotes(trades: readonly Pick<CdsTrade, "pointsUpfront">[]): boolean {
+  return trades.some((trade) => trade.pointsUpfront != null);
+}
+
+/** The columns `]` and `[` cycle the trades' sort through: the ones shown. */
+export function tradeSortColumnIds(points: boolean): readonly TradeColumnId[] {
+  return ["time", "maturity", "notional", "coupon", "spread", ...(points ? ["points" as const] : []), "upfront"];
+}
+
+/** A Points column sits beside Spread only when a print was quoted in points. */
+export function buildTradeColumns(width: number, points = false): TradeColumn[] {
+  const maturityWidth = Math.max(10, Math.min(12, width - 59 - (points ? 9 : 0)));
   return [
     { id: "time", label: "TIME UTC", width: 16, align: "left" },
     { id: "maturity", label: "MATURITY", width: maturityWidth, align: "left" },
@@ -633,6 +757,7 @@ export function buildTradeColumns(width: number): TradeColumn[] {
     { id: "currency", label: "CCY", width: 5, align: "left" },
     { id: "coupon", label: "COUPON", width: 9, align: "right" },
     { id: "spread", label: "SPREAD", width: 10, align: "right" },
+    ...(points ? [{ id: "points" as const, label: "POINTS", width: 9, align: "right" as const }] : []),
     { id: "upfront", label: "ABS UPFRONT", width: 13, align: "right" },
   ];
 }
@@ -651,6 +776,8 @@ function tradeSortValue(columnId: TradeColumnId, row: CdsTrade): string | number
       return row.couponBp;
     case "spread":
       return row.spreadBp;
+    case "points":
+      return row.pointsUpfront;
     case "upfront":
       return row.upfront;
   }