gloomberb 0.18.2 → 0.18.4

package/src/utils/cli-output.ts

@@ -4,24 +4,39 @@ export interface CliTableColumn {
   header: string;
   align?: CliAlign;
   width?: number;
-  /** Cap for this column when the table is fitted to a terminal. Piped output stays whole. */
+  /** Cap for this column when the table is fitted to a terminal: longer cells are cut there. Piped output stays whole. */
   maxWidth?: number;
-  /** The narrowest a text column is cut to, so it never shrinks to a stub that reads like another row's; a narrower table moves columns under their rows. */
+  /** The narrowest a text column wraps to (MIN_WRAPPED_COLUMN_WIDTH unless set), or a `shrink: true` column is cut to; a narrower table moves columns under their rows. */
   minWidth?: number;
-  /** Dropped, rightmost first, before other columns are shortened to fit a terminal. */
+  /** Dropped, rightmost first, before any column is cut or moved to fit a terminal. */
   optional?: boolean;
   /** Among optional columns, a higher priority is dropped sooner; equal ones go rightmost first. */
   dropPriority?: number;
-  /** False keeps the column whole when fitting, for identifiers a user types into the next command. */
+  /**
+   * By default a fitted table never cuts a cell, so a date, a figure, a
+   * symbol or a title stays whole: text wraps in its cell and columns move
+   * under their rows. False keeps the column on one line. True is the
+   * explicit opt-out: the table cuts the column's cells, down to its header
+   * and `minWidth`, before columns move, for free text that names nothing,
+   * such as a description.
+   */
   shrink?: boolean;
   /**
-   * When the table cannot fit even with its text shortened, columns move to
-   * lines under their row, each value after its header: a higher priority
-   * moves sooner, equal ones go rightmost first. The first column stays.
+   * When the table does not fit, columns move to lines under their row, each
+   * value whole after its header: first the ones too wide to sit beside the
+   * first column, then a higher priority sooner, then long text, then
+   * rightmost first. The first column stays.
    */
   stackPriority?: number;
   /** Once moved under the rows, only the first `stackRows` rows print the column; 0 leaves it out. */
   stackRows?: number;
+  /**
+   * Left out of a table fitted to fewer terminal columns than this, whether
+   * or not it would fit: a detail a narrow table has no room for beside what
+   * it is about (a filing's acceptance time beside its filed date). Piped
+   * output keeps it.
+   */
+  minTableWidth?: number;
 }
 
 export interface CliTableOptions {
@@ -43,6 +58,8 @@ const COLUMN_GAP = 2;
 const MIN_SHRUNK_COLUMN_WIDTH = 8;
 // Text columns first shrink right to left down to this width, then all shrink together.
 const SOFT_MIN_COLUMN_WIDTH = 20;
+// Text wraps in its cell down to this width, or its longest word, before columns move under the rows.
+const MIN_WRAPPED_COLUMN_WIDTH = 16;
 // Cells that say "no value": a moved column prints nothing for them.
 const EMPTY_CELL = /^(?:|-{1,2}|—|–)$/;
 // A date, or a date and time, as reports print them (`2026-10-09`, `2026-10`, `2026-10-09 20:15 UTC`).
@@ -50,20 +67,93 @@ const DATE_CELL = /^\d{4}-\d{2}(?:-\d{2})?(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)
 // A number with its sign, currency, unit or range (`-1.0bp`, `$1,200`, `3.75-4.00%`, `481.75c`).
 const NUMBER_PART = String.raw`[+\-−±]?[$€£¥]?\d[\d,]*(?:\.\d+)?`;
 const NUMBER_TOKEN = new RegExp(String.raw`^\(?${NUMBER_PART}(?:[-–]${NUMBER_PART})?(?:%|¢|[a-zA-Z]{1,3})?\)?$`);
-// What may sit between the numbers of one cell (`3.875% 82% / 4.125% 18%`, `+25bp ↑`).
-const NUMBER_JOINER = /^(?:\/|·|→|↑|↓|[-–])$/;
+// What may sit between the numbers of one cell (`3.875% 82% / 4.125% 18%`, `+25bp ↑`, plain `+25bp up`).
+const NUMBER_JOINER = /^(?:\/|·|→|↑|↓|[-–]|to|up|down)$/;
+// What a plain table writes in a cell with no value.
+const PLAIN_EMPTY_CELL = "—";
 let colorEnabledOverride: boolean | null = null;
 let widthOverride: number | null = null;
+let plainOverride: boolean | null = null;
 
 function colorEnabled(): boolean {
   if (colorEnabledOverride != null) return colorEnabledOverride;
-  return !!process.stdout.isTTY && process.env.NO_COLOR !== "1" && process.env.TERM !== "dumb";
+  if (plainOverride === true) return false;
+  return !!process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
 }
 
 export function setCliColorEnabledOverride(value: boolean | null): void {
   colorEnabledOverride = value;
 }
 
+/**
+ * Plain output, for a screen reader, very large text or a pipe: tables have
+ * no rule under their header, keep every column they have with "—" in an
+ * empty cell, and say their arrows in words (`plainWords`), as do the
+ * markers the CLI writes itself (`cliArrow`); a user's own text is never
+ * rewritten. Colour is off unless `--color` asks for it. The CLI turns it on
+ * for NO_COLOR and output that is not a terminal (`plainByDefault`), and
+ * `--plain` / `--no-plain` decide it either way; unset, it is off.
+ */
+export function setCliPlainOverride(value: boolean | null): void {
+  plainOverride = value;
+}
+
+export function cliPlainEnabled(): boolean {
+  return plainOverride === true;
+}
+
+/**
+ * Whether output is plain without `--plain` or `--no-plain`: NO_COLOR is set
+ * to a value (an empty one is unset, as the convention says), or stdout is
+ * not a terminal.
+ */
+export function plainByDefault(env: Record<string, string | undefined> = process.env, stdout: { isTTY?: boolean } = process.stdout): boolean {
+  return !!env.NO_COLOR || !stdout.isTTY;
+}
+
+const ARROW_WORDS: Record<string, string> = { "→": "to", "←": "from", "↑": "up", "↓": "down", "▲": "up", "▼": "down" };
+const ARROW = /[←→↑↓▲▼]/;
+
+/**
+ * An arrow the CLI writes itself, beside text it did not (`gold → gold's
+ * market news`), in words when output is plain: "to" for `→`. Table cells
+ * and headers are worded by `renderTable`; nothing else is rewritten.
+ */
+export function cliArrow(arrow: "→" | "←" | "↑" | "↓"): string {
+  return cliPlainEnabled() ? ARROW_WORDS[arrow]! : arrow;
+}
+
+/**
+ * Arrows as the words they stand for, so a screen reader says them: a range
+ * `2026-04-03 → 04-06` reads "2026-04-03 to 04-06", `+25bp ↑` "+25bp up",
+ * the keys `←/→` "left/right". Text without an arrow is returned as it is.
+ * For a plain table's cells and headers, never a whole output.
+ */
+export function plainWords(text: string): string {
+  if (!ARROW.test(text)) return text;
+  return text
+    .replace(/←\s*\/\s*→/g, "left/right")
+    .replace(/↑\s*\/\s*↓/g, "up/down")
+    .replace(/([ \t]*)([←→↑↓▲▼])([ \t]*)/g, (match: string, lead: string, arrow: string, _trail: string, offset: number, whole: string) => {
+      // An arrow that starts a line keeps the line's indent; one that ends it leaves no space after its word.
+      const atStart = offset === 0 || whole[offset - 1] === "\n";
+      const end = offset + match.length;
+      const atEnd = end === whole.length || whole[end] === "\n";
+      return `${atStart ? lead : " "}${ARROW_WORDS[arrow]}${atEnd ? "" : " "}`;
+    });
+}
+
+/** A table header's sort mark in words: `MKT VAL ▼` is "MKT VAL (sorted descending)". */
+function plainHeader(header: string): string {
+  const sorted = header.replace(/\s*([▲▼])\s*$/, (_match, mark: string) => ` (sorted ${mark === "▲" ? "ascending" : "descending"})`);
+  return plainWords(sorted.trimStart());
+}
+
+/** A plain table's cell: arrows in words, and "—" for no value. */
+function plainCell(cell: string): string {
+  return EMPTY_CELL.test(stripAnsi(cell).trim()) ? PLAIN_EMPTY_CELL : plainWords(cell);
+}
+
 function applyAnsi(text: string, code: string): string {
   if (!colorEnabled()) return text;
   return `\x1b[${code}m${text}\x1b[0m`;
@@ -341,95 +431,132 @@ interface TableEntry {
   column: CliTableColumn;
   index: number;
   width: number;
-  /** The narrowest the column may be cut to. */
+  /** The narrowest the column may get. */
   floor: number;
-  /** Every filled cell is a date or a figure. */
-  figures: boolean;
+  /** Text that wraps onto more lines of its cell rather than being cut. */
+  wraps: boolean;
+  /** Words rather than dates, figures or fixed-width values. */
+  text: boolean;
+}
+
+/**
+ * How narrow a column may get. Cells are whole by default: a date, a figure,
+ * a symbol, a name or a title cut short reads as another one. Text wraps in
+ * its cell down to its longest word or `minWidth` (MIN_WRAPPED_COLUMN_WIDTH
+ * unless set); `shrink: false` keeps it on one line. Only free text marked
+ * `shrink: true` is cut, to its header and `minWidth`.
+ */
+function columnFloor(column: CliTableColumn, width: number, cells: readonly string[], capped: boolean): Pick<TableEntry, "floor" | "wraps" | "text"> {
+  if (column.width != null || column.align === "right" || isWholeColumn(cells)) return { floor: width, wraps: false, text: false };
+  // Cut at its `maxWidth`, as the column asks.
+  if (capped) return { floor: width, wraps: false, text: true };
+  if (column.shrink === true) {
+    return { floor: Math.min(width, Math.max(MIN_SHRUNK_COLUMN_WIDTH, visibleLength(column.header), column.minWidth ?? 0)), wraps: false, text: true };
+  }
+  if (column.shrink === false) return { floor: width, wraps: false, text: true };
+  const words = cells.flatMap((cell) => stripAnsi(cell).split(/\s+/));
+  const longestWord = Math.max(visibleLength(column.header), ...words.map((word) => visibleLength(word)));
+  return { floor: Math.min(width, Math.max(longestWord, column.minWidth ?? MIN_WRAPPED_COLUMN_WIDTH)), wraps: true, text: true };
+}
+
+/** A cell's text wrapped to `width`, each line closing the colour it opens and the next reopening it, so it never bleeds into the next column. */
+function wrapCell(text: string, width: number): string[] {
+  const lines = wrapText(text, width);
+  if (lines.length < 2 || !text.includes("\x1b[")) return lines;
+  let open = "";
+  return lines.map((line) => {
+    const carried = open;
+    for (const code of line.match(ANSI_PATTERN) ?? []) open = code === "\x1b[0m" ? "" : `${open}${code}`;
+    return `${carried}${line}${open ? "\x1b[0m" : ""}`;
+  });
+}
+
+interface TableLayout {
+  kept: TableEntry[];
+  stacked: TableEntry[];
 }
 
-/** The narrowest a column may get: whole for figures and ids; text keeps its header and its `minWidth`. */
-function columnFloor(column: CliTableColumn, width: number): number {
-  if (column.width != null || column.align === "right" || column.shrink === false) return width;
-  return Math.min(width, Math.max(MIN_SHRUNK_COLUMN_WIDTH, visibleLength(column.header), column.minWidth ?? 0));
+/** Which of two columns moves under the rows sooner: by the first value that differs. */
+function movesSooner(left: readonly number[], right: readonly number[]): boolean {
+  const at = left.findIndex((value, index) => value !== right[index]);
+  return at >= 0 && left[at]! > right[at]!;
 }
 
 /**
- * The columns that stay in the table, at widths that fit `available`, and the
- * ones moved under each row. Text shrinks first, as it always has. A table
- * still too wide keeps every date and figure whole and moves columns under
- * the rows, by `stackPriority`, then rightmost first, until the rest fits.
- * Null when the first column alone does not fit.
+ * The ways a table too wide can fit `available`, each moving one more column
+ * under the rows, where its values print whole. In each, text wraps in its
+ * cell and free text marked `shrink: true` is cut, down to their floors.
+ * Columns move in this order: the ones too wide to ever sit beside the first
+ * column (a long headline, a note), then by `stackPriority`, then long text
+ * (a name, a title) before dates and figures, then rightmost first. The
+ * first column stays. The list ends at the first layout that keeps every
+ * column it shows whole on one line: moving more only adds lines.
  */
-function fitTableLayout(entries: TableEntry[], available: number): { kept: TableEntry[]; stacked: TableEntry[] } | null {
-  const fit = (kept: TableEntry[], wholeFigures: boolean) => fitColumnWidths(
-    kept.map((entry) => entry.width),
-    kept.map((entry) => (wholeFigures && entry.figures ? entry.width : entry.floor)),
-    available,
-  );
+function tableLayouts(entries: TableEntry[], available: number): TableLayout[] {
+  const fit = (kept: TableEntry[]) => fitColumnWidths(kept.map((entry) => entry.width), kept.map((entry) => entry.floor), available);
+  const first = entries[0]!;
+  const room = available - first.floor - COLUMN_GAP;
+  const order = (entry: TableEntry) => [
+    entry.floor > room ? 1 : 0,
+    entry.column.stackPriority ?? 0,
+    entry.text && entry.width > SOFT_MIN_COLUMN_WIDTH ? 1 : 0,
+    entry.index,
+  ];
+  const layouts: TableLayout[] = [];
   let kept = entries;
   const stacked: TableEntry[] = [];
-  let widths = fit(kept, false);
-  if (!widths) widths = fit(kept, true);
-  while (!widths && kept.length > 1) {
-    const moved = kept.slice(1).reduce((pick, entry) => (
-      (entry.column.stackPriority ?? 0) >= (pick.column.stackPriority ?? 0) ? entry : pick
-    ));
+  for (;;) {
+    const widths = fit(kept);
+    if (widths) {
+      layouts.push({ kept: kept.map((entry, position) => ({ ...entry, width: widths[position]! })), stacked: [...stacked] });
+      if (widths.every((width, position) => width >= kept[position]!.width)) break;
+    }
+    if (kept.length === 1) break;
+    const moved = kept.slice(1).reduce((pick, entry) => (movesSooner(order(entry), order(pick)) ? entry : pick));
     kept = kept.filter((entry) => entry !== moved);
     stacked.push(moved);
-    widths = fit(kept, true);
   }
-  if (!widths) return null;
-  const fitted = widths;
-  return { kept: kept.map((entry, position) => ({ ...entry, width: fitted[position]! })), stacked };
+  // The first column alone is wider than the table may be: text wraps and free text is cut to the
+  // whole width; a symbol or a figure stays whole.
+  if (layouts.length === 0) layouts.push({ kept: [{ ...first, width: first.wraps || first.column.shrink === true ? available : first.width }], stacked });
+  return layouts;
 }
 
-export function renderTable(columns: CliTableColumn[], rows: string[][], options: CliTableOptions = {}): string {
+function renderTableLayout(
+  columns: CliTableColumn[],
+  rows: string[][],
+  options: CliTableOptions,
+  shown: readonly TableEntry[],
+  stacked: readonly TableEntry[],
+  available: number | null,
+  /** Cells wrap or are cut to their column's width: the table was fitted to `available`. */
+  fitted: boolean,
+): string {
   const indent = " ".repeat(options.indent ?? 0);
-  const maxWidth = options.maxWidth === undefined ? cliTerminalWidth() : options.maxWidth;
-  const available = maxWidth == null ? null : maxWidth - indent.length;
-  let shown = columns.map((column, index) => {
-    const cellWidths = rows.map((row) => visibleLength(row[index] ?? ""));
-    return { column, index, width: column.width ?? Math.max(visibleLength(column.header), ...cellWidths) };
-  });
-  let stacked: Array<(typeof shown)[number]> = [];
-  // Cells are only cut when the table was fitted to a terminal; piped output keeps them whole.
-  let truncate = false;
-  if (available != null && tableWidth(shown.map((entry) => entry.width)) > available) {
-    while (tableWidth(shown.map((entry) => entry.width)) > available) {
-      const dropped = shown.reduce<(typeof shown)[number] | undefined>((pick, entry) => (
-        entry.column.optional && (!pick || (entry.column.dropPriority ?? 0) >= (pick.column.dropPriority ?? 0)) ? entry : pick
-      ), undefined);
-      if (!dropped) break;
-      shown = shown.filter((entry) => entry !== dropped);
-    }
-    const layout = fitTableLayout(shown.map((entry) => {
-      const width = entry.column.maxWidth == null
-        ? entry.width
-        : Math.min(entry.width, Math.max(entry.column.maxWidth, visibleLength(entry.column.header)));
-      return { ...entry, width, floor: columnFloor(entry.column, width), figures: isWholeColumn(rows.map((row) => row[entry.index] ?? "")) };
-    }), available);
-    // A first column that cannot fit even alone keeps every cell whole rather than losing data and overflowing anyway.
-    if (layout) {
-      shown = layout.kept;
-      stacked = layout.stacked.filter((entry) => entry.column.stackRows !== 0).sort((left, right) => left.index - right.index);
-      truncate = true;
-    }
-  }
-
   const renderRow = (cells: string[], style?: (text: string) => string) => {
-    const rendered = shown.map(({ column, index, width }, position) => {
-      const cell = truncate ? truncateDisplay(cells[index] ?? "", width) : cells[index] ?? "";
-      // The last left-aligned column is not padded so lines carry no trailing spaces.
-      const padded = position === shown.length - 1 && (column.align ?? "left") === "left"
-        ? cell
-        : padDisplay(cell, width, column.align ?? "left");
-      return style ? style(padded) : padded;
+    const columnLines = shown.map(({ index, width, wraps }) => {
+      const cell = cells[index] ?? "";
+      if (!fitted) return [cell];
+      return wraps ? wrapCell(cell, width) : [truncateDisplay(cell, width)];
     });
-    return `${indent}${rendered.join(" ".repeat(COLUMN_GAP))}`.trimEnd();
+    // A cell that wraps makes its row taller; the other cells sit on the row's first line.
+    const height = Math.max(1, ...columnLines.map((lines) => lines.length));
+    return Array.from({ length: height }, (_, line) => {
+      const rendered = shown.map(({ column, width }, position) => {
+        const cell = columnLines[position]![line] ?? "";
+        // The last left-aligned column is not padded so lines carry no trailing spaces.
+        const padded = position === shown.length - 1 && (column.align ?? "left") === "left"
+          ? cell
+          : padDisplay(cell, width, column.align ?? "left");
+        return style && (line === 0 || cell) ? style(padded) : padded;
+      });
+      return `${indent}${rendered.join(" ".repeat(COLUMN_GAP))}`.trimEnd();
+    }).join("\n");
   };
 
   const header = renderRow(columns.map((column) => column.header), cliStyles.bold);
-  const divider = `${indent}${shown.map(({ width }) => cliStyles.muted("─".repeat(width))).join(" ".repeat(COLUMN_GAP))}`;
+  // A plain table has no rule under its header: a screen reader reads it as a row of dashes.
+  const divider = cliPlainEnabled() ? [] : [`${indent}${shown.map(({ width }) => cliStyles.muted("─".repeat(width))).join(" ".repeat(COLUMN_GAP))}`];
   const belowIndent = `${indent}${" ".repeat(COLUMN_GAP)}`;
   const belowWidth = Math.max(1, (available ?? 0) - COLUMN_GAP);
   const renderBelow = (index: number) => (options.below?.[index] ?? []).flatMap((line) => (
@@ -463,5 +590,57 @@ export function renderTable(columns: CliTableColumn[], rows: string[][], options
     if (line) lines.push(line);
     return lines.map((text) => `${belowIndent}${text}`.trimEnd());
   };
-  return [header, divider, ...rows.flatMap((row, index) => [renderRow(row), ...renderStacked(row, index), ...renderBelow(index)])].join("\n");
+  return [header, ...divider, ...rows.flatMap((row, index) => [renderRow(row), ...renderStacked(row, index), ...renderBelow(index)])].join("\n");
+}
+
+/**
+ * A table fitted to the terminal (or `--width`), or whole when output is
+ * piped. A table too wide never cuts a cell short, unless its column is free
+ * text marked `shrink: true`: text wraps in its cell and columns move under
+ * their rows, each value whole after its header. Of the ways that fit, the
+ * one with the fewest lines prints, the one that moves fewer columns on a tie.
+ * Plain output (`setCliPlainOverride`) has no rule under the header, words
+ * for arrows and "—" in every empty cell.
+ */
+export function renderTable(columns: CliTableColumn[], rows: string[][], options: CliTableOptions = {}): string {
+  if (cliPlainEnabled()) {
+    columns = columns.map((column) => ({ ...column, header: plainHeader(column.header) }));
+    rows = rows.map((row) => columns.map((_, index) => plainCell(row[index] ?? "")));
+    if (options.below) options = { ...options, below: options.below.map((lines) => lines?.map(plainWords)) };
+  }
+  const maxWidth = options.maxWidth === undefined ? cliTerminalWidth() : options.maxWidth;
+  const available = maxWidth == null ? null : maxWidth - (options.indent ?? 0);
+  let shown = columns.map((column, index) => {
+    const cellWidths = rows.map((row) => visibleLength(row[index] ?? ""));
+    return { column, index, width: column.width ?? Math.max(visibleLength(column.header), ...cellWidths), floor: 0, wraps: false, text: false };
+  }).filter(({ column }) => maxWidth == null || column.minTableWidth == null || maxWidth >= column.minTableWidth);
+  // Cells are only cut or wrapped when the table is fitted to a terminal; piped output keeps them whole.
+  if (available == null || tableWidth(shown.map((entry) => entry.width)) <= available) {
+    return renderTableLayout(columns, rows, options, shown, [], available, false);
+  }
+  while (tableWidth(shown.map((entry) => entry.width)) > available) {
+    const dropped = shown.reduce<(typeof shown)[number] | undefined>((pick, entry) => (
+      entry.column.optional && (!pick || (entry.column.dropPriority ?? 0) >= (pick.column.dropPriority ?? 0)) ? entry : pick
+    ), undefined);
+    if (!dropped) break;
+    shown = shown.filter((entry) => entry !== dropped);
+  }
+  const entries = shown.map((entry) => {
+    const width = entry.column.maxWidth == null
+      ? entry.width
+      : Math.min(entry.width, Math.max(entry.column.maxWidth, visibleLength(entry.column.header)));
+    return { ...entry, width, ...columnFloor(entry.column, width, rows.map((row) => row[entry.index] ?? ""), width < entry.width) };
+  });
+  let best = "";
+  let bestLines = Infinity;
+  for (const layout of tableLayouts(entries, available)) {
+    const stacked = layout.stacked.filter((entry) => entry.column.stackRows !== 0).sort((left, right) => left.index - right.index);
+    const text = renderTableLayout(columns, rows, options, layout.kept, stacked, available, true);
+    const lines = text.split("\n").length;
+    if (lines < bestLines) {
+      best = text;
+      bestLines = lines;
+    }
+  }
+  return best;
 }

package/src/utils/contract-month.ts

@@ -0,0 +1,16 @@
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+
+/**
+ * A futures contract month as every pane and report writes it, "Oct 2026":
+ * "Oct 26" reads as the 26th of October. `month` is 0-11; a two-digit year
+ * (the 26 of HGZ26) is in this century.
+ */
+export function contractMonthLabel(year: number, month: number): string {
+  return `${MONTHS[month] ?? String(month + 1).padStart(2, "0")} ${year < 100 ? 2000 + year : year}`;
+}
+
+/** A delivery month, "2026-10", "2026-10-01" or a broker's "202610", as contractMonthLabel writes it; null when it is no month. */
+export function deliveryMonthLabel(deliveryMonth: string | null | undefined): string | null {
+  const match = /^(\d{4})-?(0[1-9]|1[0-2])(?:$|-)/.exec(deliveryMonth ?? "");
+  return match ? contractMonthLabel(Number(match[1]), Number(match[2]) - 1) : null;
+}

package/src/utils/crypto-pair.ts

@@ -9,6 +9,8 @@ const FIAT_CURRENCY_CODES = new Set([
 ]);
 
 const USD_COIN_PAIR = /^([A-Z0-9]+)[-/]USD$/;
+// The other currencies and coins the crypto venue quotes a coin in (BTC-EUR, ETH-BTC).
+const QUOTED_COIN_PAIR = /^([A-Z0-9]+)[-/](?:USDT|USDC|EUR|GBP|BTC|ETH)$/;
 
 /** A coin quoted in dollars (BTC-USD, ETH/USD). EUR-USD is spot FX, not a coin. */
 function isUsdCoinPair(symbol: string): boolean {
@@ -16,15 +18,24 @@ function isUsdCoinPair(symbol: string): boolean {
   return base !== undefined && !FIAT_CURRENCY_CODES.has(base);
 }
 
+/** A coin quoted in another currency or coin (BTC-EUR, ETH-BTC). EUR-GBP is spot FX, not a coin. */
+function isQuotedCoinPair(symbol: string): boolean {
+  const base = QUOTED_COIN_PAIR.exec(symbol.trim().toUpperCase())?.[1];
+  return base !== undefined && !isIsoCurrencyCode(base);
+}
+
 /**
  * A series that trades around the clock: anything on the crypto venue (CCC), or
  * a coin quoted in dollars whether or not the caller named that venue. A bare
- * BTC-USD is the coin, not a US listing; a bare BTC (no quote) is a US fund.
+ * BTC-USD is the coin, not a US listing; a bare BTC (no quote) is a US fund. A
+ * bare coin quoted in euros or in another coin (BTC-EUR) is the coin too, never
+ * a US listing whose session closed at 16:00 New York.
  */
 export function isRoundTheClockCoin(symbol?: string, exchange?: string): boolean {
   const parsed = symbol ? parsePublicTickerKey(symbol) : null;
-  if (canonicalExchange(parsed?.exchange ?? exchange) === "CCC" || canonicalExchange(exchange) === "CCC") return true;
-  return !!parsed && isUsdCoinPair(parsed.symbol);
+  const venue = canonicalExchange(parsed?.exchange ?? exchange) || canonicalExchange(exchange);
+  if (venue === "CCC" || canonicalExchange(exchange) === "CCC") return true;
+  return !!parsed && (isUsdCoinPair(parsed.symbol) || (!venue && isQuotedCoinPair(parsed.symbol)));
 }
 
 const SLASH_COIN_PAIR = /^([A-Z0-9]{1,15})\/(USD|EUR|GBP|USDT|USDC|BTC)$/;
@@ -59,3 +70,50 @@ const CRYPTO_PAIR = /^[A-Z0-9]{1,15}-(?:USD|EUR|GBP|USDT|USDC|BTC)$/;
 export function isCryptoPairSymbol(symbol: string): boolean {
   return CRYPTO_PAIR.test(symbol);
 }
+
+/**
+ * The coins whose bare ticker is most often typed for the coin itself, with
+ * how stories and notes name each: the name a listing's own may not say
+ * plainly ("Bitcoin USD").
+ */
+export const MAJOR_COIN_NAMES: ReadonlyMap<string, string> = new Map([
+  ["BTC", "bitcoin"],
+  ["ETH", "ethereum"],
+  ["SOL", "solana"],
+  ["XRP", "XRP"],
+  ["DOGE", "dogecoin"],
+  ["ADA", "cardano"],
+  ["LTC", "litecoin"],
+  ["BCH", "bitcoin cash"],
+  ["AVAX", "avalanche"],
+  ["DOT", "polkadot"],
+  ["LINK", "chainlink"],
+  ["BNB", "BNB"],
+]);
+
+const COIN_PAIR = /^([A-Z0-9]{1,15})[-/](?:USD|EUR|GBP|USDT|USDC|BTC)$/;
+// What a pair's listing name adds after the coin's: its quote currency, an id in brackets.
+const PAIR_NAME_SUFFIX = /(?:\s*\([^)]*\))+$|\s+(?:USD|EUR|GBP|USDT|USDC|BTC|US Dollars?)$/i;
+
+/**
+ * The coin a crypto pair trades, as stories name it: "bitcoin" for BTC-USD
+ * (or BTC-USD on CCC), from the major coins' names, else the listing's name
+ * without its quote currency ("Hyperliquid USD" is "hyperliquid"). Null for a
+ * symbol that is not a coin pair, and for a coin with no name to search for:
+ * its code alone (TON, UNI) is too often a word.
+ */
+export function coinSearchName(symbol: string | undefined, exchange?: string, listingName?: string | null): string | null {
+  if (!symbol || !isRoundTheClockCoin(symbol, exchange)) return null;
+  const parsed = parsePublicTickerKey(symbol).symbol.trim().toUpperCase();
+  const code = COIN_PAIR.exec(parsed)?.[1] ?? parsed;
+  if (isIsoCurrencyCode(code)) return null;
+  const major = MAJOR_COIN_NAMES.get(code);
+  if (major) return major;
+  let name = listingName?.trim() ?? "";
+  for (let previous = ""; previous !== name;) {
+    previous = name;
+    name = name.replace(PAIR_NAME_SUFFIX, "").trim();
+  }
+  if (name.length < 3 || name.toUpperCase() === code || !/\p{L}/u.test(name)) return null;
+  return name === name.toUpperCase() ? name : name.toLowerCase();
+}

package/src/utils/currency-pair.ts

@@ -84,3 +84,29 @@ export function looksLikeCurrencyPair(symbol: string): boolean {
   const halves = /^([A-Z]{3})[^A-Z0-9]?([A-Z]{3})(?:=X)?$/.exec(code)?.slice(1) ?? /^([A-Z]{3})=X$/.exec(code)?.slice(1) ?? [];
   return halves.some(isCurrencyCode);
 }
+
+/**
+ * Which currency of a pair markets quote it per: EUR, GBP, AUD and NZD go
+ * before the dollar, the dollar before CAD, CHF and the rest, and the yen goes
+ * last (EUR/USD, USD/CAD, USD/JPY, EUR/CAD, CAD/JPY).
+ */
+const PAIR_BASE_ORDER = ["EUR", "GBP", "AUD", "NZD", "USD", "CAD", "CHF"];
+
+function pairBaseRank(code: string): number {
+  const at = PAIR_BASE_ORDER.indexOf(code);
+  if (at >= 0) return at;
+  return code === "JPY" ? PAIR_BASE_ORDER.length + 1 : PAIR_BASE_ORDER.length;
+}
+
+/**
+ * A rate of `quote` per unit of `currency`, written the way markets quote
+ * the pair, as `fx` reads a pair: 0.0067 USD per JPY is USD/JPY 149.25, and
+ * 1.4 CAD per USD stays USD/CAD 1.4. Two codes of the same rank keep their
+ * order.
+ */
+export function quotedFxPair(currency: string, quote: string, rate: number): { pair: string; rate: number } {
+  const from = currency.trim().toUpperCase(), into = quote.trim().toUpperCase();
+  return pairBaseRank(into) < pairBaseRank(from)
+    ? { pair: `${into}/${from}`, rate: 1 / rate }
+    : { pair: `${from}/${into}`, rate };
+}

package/src/utils/currency-units.ts

@@ -104,6 +104,25 @@ export function heldCurrencyUnit(currency?: string | null): CurrencyUnitInfo {
   return currency?.trim().toUpperCase() === US_CENTS ? { currency: "USD", divisor: 100 } : resolveCurrencyUnit(currency);
 }
 
+/**
+ * The codes whose USD rates convert money held in `currencies`: each as a
+ * rate is asked for (upper-cased), and a minor unit's major currency too,
+ * which convertCurrency reads a hundredth of when the unit has no rate of its
+ * own. Gloom Cloud serves none for GBX or ILA, and ZAc and GBp are kept in
+ * their own case, which no upper-cased rate matches.
+ */
+export function fxRateCurrencies(currencies: Iterable<string | null | undefined>): string[] {
+  const codes = new Set<string>();
+  for (const currency of currencies) {
+    const raw = currency?.trim();
+    if (!raw) continue;
+    codes.add(raw.toUpperCase());
+    const unit = heldCurrencyUnit(raw);
+    if (unit.divisor !== 1 && unit.currency) codes.add(unit.currency);
+  }
+  return [...codes].sort((left, right) => left.localeCompare(right));
+}
+
 interface ExchangeSubUnitOptions {
   allowDefaultCurrency?: boolean;
   allowMissingCurrency?: boolean;
@@ -114,6 +133,16 @@ function normalizeExchange(value?: string | null): string {
   return (value ?? "").trim().toUpperCase();
 }
 
+/**
+ * A currency code as a position saves it: upper-cased, except a minor unit
+ * whose code is written in its own case (GBp, ZAc), which stays as typed so
+ * pence are not read as pounds. GBX and gbp read as pence and pounds.
+ */
+export function normalizeHeldCurrencyCode(code: string | null | undefined): string {
+  const raw = (code ?? "").trim();
+  return SUB_UNIT_CURRENCIES[raw] && raw !== raw.toUpperCase() ? raw : raw.toUpperCase();
+}
+
 export function resolveCurrencyUnit(currency?: string | null): CurrencyUnitInfo {
   const raw = (currency ?? "").trim();
   if (!raw) {

package/src/utils/datetime-format.ts

@@ -39,6 +39,16 @@ export function formatRelativeAge(timestamp: number | undefined, now = Date.now(
   return elapsed ? `${elapsed.count}${elapsed.unit} ago` : "just now";
 }
 
+/** Time until something scheduled, on the same ladder: "in <1m", "in 25m", "in 3h", "in 3h 20m". */
+export function formatCountdown(ms: number): string {
+  if (ms <= 60_000) return "in <1m";
+  const totalMin = Math.floor(ms / 60_000);
+  if (totalMin < 60) return `in ${totalMin}m`;
+  const h = Math.floor(totalMin / 60);
+  const m = totalMin % 60;
+  return m > 0 ? `in ${h}h ${m}m` : `in ${h}h`;
+}
+
 // Reuse the locale formatter when a feed contains older items. Constructing
 // one for every row dominates opening a long transcript, even without edits.
 const olderRelativeDateFormatter = new Intl.DateTimeFormat("en-US", {

package/src/utils/debug-log.ts

@@ -146,7 +146,7 @@ class DebugLog {
   exportAsText(filter?: { level?: LogLevel; source?: string }): string {
     const entries = this.getEntries(filter);
     const lines: string[] = [
-      `Gloomberb Debug Log — exported ${new Date().toISOString()}`,
+      `Gloom Debug Log — exported ${new Date().toISOString()}`,
       `Total entries: ${entries.length}`,
       "=".repeat(80),
       "",