gloomberb 0.18.3 → 0.18.5

package/src/cli/result.ts

@@ -1,5 +1,6 @@
 import type { CliGlobalOptions } from "./options";
 import {
+  cliPlainEnabled,
   cliStyles,
   cliTerminalWidth,
   renderStats,
@@ -13,11 +14,14 @@ import {
 } from "../utils/cli-output";
 import { serializeCsv } from "../utils/csv";
 import { formatUtcTime, isEpochMilliseconds, isZonedIsoDateTime } from "../utils/utc-time";
-import { formatFreshnessLine, type ReportFreshness } from "./pane-functions/freshness";
+import { formatFreshnessLine, withSavedCopy, type ReportFreshness } from "./pane-functions/freshness";
 import { withSearchHints, type FredSeriesCheck } from "./not-a-ticker";
 import { renderReportCsv, renderReportNdjson, withCsvFooter, type CliReportTables } from "./report-tables";
 import {
+  EXPORT_DATING_COLUMNS,
   EXPORT_IDENTITY_COLUMNS,
+  exportDatingCells,
+  exportDatingFields,
   exportIdentityCells,
   exportIdentityFields,
   exportSource,
@@ -98,6 +102,11 @@ export interface CliResultRenderOptions<T = unknown, Row = Record<string, unknow
    * `metadata.rows` in JSON.
    */
   dateKey?: string;
+  /**
+   * The row key that splits the rows into series of their own, each windowed
+   * apart: with `symbol`, `--tail 5` keeps every symbol's newest five rows.
+   */
+  seriesKey?: string;
   /** How many rows to show when neither `--limit` nor `--tail` is given; every row when absent. */
   defaultLimit?: number;
   /**
@@ -114,6 +123,24 @@ export interface CliResultRenderOptions<T = unknown, Row = Record<string, unknow
   exportIdentity?: ExportIdentity | ((row: Row) => ExportIdentity);
   /** What CSV says after the source lines as `# note:` lines: what the rows do not show, such as where a series begins. */
   exportNotes?: readonly string[];
+  /**
+   * The rows are statistics dated by a period and a release (`econ`, `fred`):
+   * CSV and NDJSON rows also end with `period`, `released` and `retrieved`
+   * (`EXPORT_DATING_COLUMNS`) after the five fixed columns, from the `period`
+   * and `released` of each row's `exportIdentity`, and `as_of` is the release.
+   * A column the rows already have by name keeps its own values. Needs a
+   * cited source, as the fixed columns do.
+   */
+  exportDated?: boolean;
+  /**
+   * Why a row's figures are empty (`Not a ticker: ZZZZQQ.`, `Chg%: no previous
+   * close`), for the `status` column CSV writes after the row's own columns and
+   * the `status` field of an NDJSON row; empty for a whole row. The column is
+   * there whenever this is, with rows or without, so the header never depends
+   * on what loaded. A figure that is no number (NaN) is written empty and,
+   * without a reason here, named as `<header>: not available`.
+   */
+  exportStatus?: (row: Row) => string | null | undefined;
 }
 
 interface CliResultJsonEnvelope<T> extends Omit<CliResult<T>, "freshness" | "exportFreshness" | "failure"> {
@@ -149,11 +176,28 @@ function rowWindowOptions(options: CliGlobalOptions, renderOptions: Pick<CliResu
 function windowed<Row>(
   rows: readonly Row[],
   options: CliGlobalOptions,
-  renderOptions: Pick<CliResultRenderOptions, "dateKey" | "defaultLimit">,
+  renderOptions: Pick<CliResultRenderOptions, "dateKey" | "defaultLimit" | "seriesKey">,
 ): RowWindow<Row> {
-  const { dateKey } = renderOptions;
+  const { dateKey, seriesKey } = renderOptions;
   const dateOf = dateKey ? (row: Row) => (isPlainObject(row) ? row[dateKey] : undefined) : undefined;
-  return windowRows(rows, rowWindowOptions(options, renderOptions), dateOf);
+  const windowOptions = rowWindowOptions(options, renderOptions);
+  if (!seriesKey) return windowRows(rows, windowOptions, dateOf);
+  const series = new Map<unknown, Row[]>();
+  for (const row of rows) {
+    const key = isPlainObject(row) ? row[seriesKey] : undefined;
+    const group = series.get(key);
+    if (group) group.push(row);
+    else series.set(key, [row]);
+  }
+  const windows = [...series.values()].map((group) => windowRows(group, windowOptions, dateOf));
+  const count = windowOptions.tail ?? windowOptions.limit;
+  return {
+    rows: windows.flatMap((window) => window.rows),
+    total: rows.length,
+    kept: windows.find((window) => window.kept)?.kept ?? null,
+    note: windows.some((window) => window.note)
+      ? `showing the oldest ${count} ${count === 1 ? "row" : "rows"} of each ${seriesKey}; --tail ${count} for the latest` : null,
+  };
 }
 
 function asRows<T, Row>(data: T, rows?: (data: T) => Row[]): Row[] {
@@ -206,7 +250,7 @@ function formatTextValue(
   depth = 0,
   width: number | null = null,
 ): string {
-  const missing = context === "record" ? cliStyles.muted("-") : "";
+  const missing = context === "record" ? cliPlainEnabled() ? "—" : cliStyles.muted("-") : "";
   if (value == null || value === "") return missing;
   // Times print in UTC with the zone named, never in the host's zone; JSON and CSV keep the raw value.
   if (value instanceof Date) return formatUtcTime(value);
@@ -291,23 +335,80 @@ function serializeColumns<Row>(columns?: CliResultColumn<Row>[]) {
   }));
 }
 
+/** A number a spreadsheet cannot read: NaN or an infinity, which exports write empty, never as the word. */
+function isNonFiniteNumber(value: unknown): boolean {
+  return typeof value === "number" && !Number.isFinite(value);
+}
+
+/**
+ * What a row's status cell says: the command's reason, else the figures
+ * written empty for being no number. Empty when nothing is missing.
+ */
+function exportStatusText(reason: string | null | undefined, blanked: readonly string[]): string {
+  const own = reason?.trim();
+  if (own) return own;
+  return blanked.length > 0 ? `${blanked.join(", ")}: not available` : "";
+}
+
+/** `status`, or `value_status` beside a column of the table's own named Status. */
+function statusHeader(headers: readonly string[]): string {
+  return headers.some((header) => header.trim().toLowerCase() === "status") ? "value_status" : "status";
+}
+
 function renderCsv<Row extends Record<string, unknown>>(
   rows: Row[],
   columns?: CliResultColumn<Row>[],
   identity?: (row: Row) => string[],
+  status?: (row: Row) => string | null | undefined,
+  dating?: (row: Row) => string[],
 ): string {
   const resolvedColumns = columns && columns.length > 0
     ? columns
     : inferColumns(rows as Record<string, unknown>[]) as CliResultColumn<Row>[];
+  const headers = resolvedColumns.map((column) => column.header);
+  // A dated export's own `released` column keeps its values; the others close the row.
+  const datingAdded = dating
+    ? EXPORT_DATING_COLUMNS.flatMap((column, index) => headers.includes(column) ? [] : [index]) : [];
   return serializeCsv([
-    [...resolvedColumns.map((column) => column.header), ...identity ? EXPORT_IDENTITY_COLUMNS : []],
-    ...rows.map((row) => [
-      ...resolvedColumns.map((column) => (column.value ? column.value(row) : row[column.key])),
-      ...identity?.(row) ?? [],
-    ]),
+    [
+      ...headers,
+      ...status ? [statusHeader(headers)] : [],
+      ...identity ? EXPORT_IDENTITY_COLUMNS : [],
+      ...datingAdded.map((index) => EXPORT_DATING_COLUMNS[index]!),
+    ],
+    ...rows.map((row) => {
+      const values = resolvedColumns.map((column) => (column.value ? column.value(row) : row[column.key]));
+      const blanked = resolvedColumns.flatMap((column, index) => isNonFiniteNumber(values[index]) ? [column.header] : []);
+      const datingCells = dating?.(row) ?? [];
+      return [
+        ...values.map((value) => isNonFiniteNumber(value) ? "" : value),
+        ...status ? [exportStatusText(status(row), blanked)] : [],
+        ...identity?.(row) ?? [],
+        ...datingAdded.map((index) => datingCells[index] ?? ""),
+      ];
+    }),
   ]);
 }
 
+/**
+ * The key an NDJSON row says why its figures are empty under: `status`, or
+ * `value_status` beside a field of the row's own that the export writes under
+ * that name (an order's status), as CSV's header does.
+ */
+function ndjsonStatusKey(rows: readonly unknown[], columns?: readonly CliResultColumn<never>[]): string {
+  const own = columns && columns.length > 0
+    ? columns.some((column) => column.key === "status")
+    : rows.some((row) => isPlainObject(row) && "status" in row);
+  return own ? "value_status" : "status";
+}
+
+/** An NDJSON row: a figure that is no number is null, and the row says why its figures are empty when the command does. */
+function ndjsonRow<Row extends Record<string, unknown>>(row: Row, status: ((row: Row) => string | null | undefined) | undefined, statusKey: string): Record<string, unknown> {
+  const blanked = Object.entries(row).flatMap(([key, value]) => isNonFiniteNumber(value) ? [key] : []);
+  const own = blanked.length > 0 ? { ...row, ...Object.fromEntries(blanked.map((key) => [key, null])) } : row;
+  return status ? { ...own, [statusKey]: exportStatusText(status(row), blanked) || null } : own;
+}
+
 function stringField(row: Record<string, unknown>, key: string): string | null {
   const value = row?.[key];
   return typeof value === "string" && value.trim() ? value : null;
@@ -348,10 +449,11 @@ function renderTextTable<Row extends Record<string, unknown>>(
 ): string {
   const resolvedColumns = textColumns(rows, columns);
   const cells = rows.map((row) => resolvedColumns.map((column) => formatTextCell(column, row, "table")));
-  // A column no row fills is noise in a table; exports keep it.
+  // A column no row fills is noise in a table; exports keep it, and so does plain output, whose
+  // tables keep one shape from query to query with "—" in the empty cells.
   const filled = resolvedColumns
     .map((column, index) => ({ column, index }))
-    .filter(({ column, index }) => column.width != null || cells.some((row) => row[index] !== ""));
+    .filter(({ column, index }) => cliPlainEnabled() || column.width != null || cells.some((row) => row[index] !== ""));
   const shown = filled.length > 0 ? filled : resolvedColumns.map((column, index) => ({ column, index }));
   return renderTable(
     shown.map(({ column }) => ({
@@ -395,9 +497,13 @@ function overflowsTerminal<Row extends Record<string, unknown>>(rows: Row[]): bo
   return width > terminalWidth;
 }
 
-/** The closing source, as-of and status line of a text result, for output printed without `printResult`. */
-export function cliFreshnessFooter(freshness: ReportFreshness): string {
-  return cliStyles.muted(wrapToTerminal(formatFreshnessLine(freshness)));
+/**
+ * The closing source, as-of and status line of a text result, for output
+ * printed without `printResult`; `shown` is the data the line is drawn from,
+ * which says whether it came from a saved copy.
+ */
+export function cliFreshnessFooter(freshness: ReportFreshness, shown?: unknown): string {
+  return cliStyles.muted(wrapToTerminal(formatFreshnessLine(withSavedCopy(freshness, shown))));
 }
 
 export function serializeCliResult<T, Row extends Record<string, unknown> = Record<string, unknown>>(
@@ -405,8 +511,10 @@ export function serializeCliResult<T, Row extends Record<string, unknown> = Reco
   options: CliGlobalOptions,
   renderOptions: CliResultRenderOptions<T, Row> = {},
 ): string {
-  const { freshness, exportFreshness, failure, ...rest } = result;
-  const cited = freshness ?? exportFreshness;
+  const { freshness: reported, exportFreshness, failure, ...rest } = result;
+  // Rows shown from a saved copy, its refresh having failed, say so in place of live or delayed.
+  const freshness = reported && withSavedCopy(reported, result.data);
+  const cited = freshness ?? (exportFreshness && withSavedCopy(exportFreshness, result.data));
   if (options.format === "json") {
     const columns = serializeColumns(renderOptions.columns);
     const window = Array.isArray(result.data) ? windowed(result.data as unknown[], options, renderOptions) : null;
@@ -443,15 +551,32 @@ function serializeCliRows<T, Row extends Record<string, unknown>>(
   }
   const window = windowed(asRows(result.data, renderOptions.rows), options, renderOptions);
   const rows = window.rows;
+  const status = renderOptions.exportStatus;
   if (options.format === "ndjson") {
-    return rows.map((row) => JSON.stringify(cited && isPlainObject(row)
-      ? { ...row, ...exportIdentityFields(cited, rowIdentity(row as Row, renderOptions.exportIdentity)) }
-      : row)).join("\n");
+    const statusKey = ndjsonStatusKey(rows, renderOptions.columns as readonly CliResultColumn<never>[] | undefined);
+    return rows.map((row) => {
+      if (!isPlainObject(row)) return JSON.stringify(row);
+      const fields = ndjsonRow(row as Row, status, statusKey);
+      if (!cited) return JSON.stringify(fields);
+      const identity = rowIdentity(row as Row, renderOptions.exportIdentity);
+      // A dated export's own fields (a row's `released`) keep their values.
+      const dating = renderOptions.exportDated
+        ? Object.fromEntries(Object.entries(exportDatingFields(cited, identity)).filter(([key]) => !(key in fields))) : {};
+      return JSON.stringify({ ...fields, ...exportIdentityFields(cited, identity), ...dating });
+    }).join("\n");
   }
   if (options.format === "csv") {
-    if (!cited) return renderCsv(rows as Row[], renderOptions.columns);
-    const csv = renderCsv(rows as Row[], renderOptions.columns, (row) => exportIdentityCells(cited, rowIdentity(row, renderOptions.exportIdentity)));
-    return withCsvFooter(csv, [...exportSourceLines(cited), ...(renderOptions.exportNotes ?? []).map((note) => `note: ${note}`)]);
+    // The rows a window cut say so after them, as text and JSON do: a script has no other way to know.
+    const cutNote = window.note ? [`note: ${window.note}`] : [];
+    if (!cited) return withCsvFooter(renderCsv(rows as Row[], renderOptions.columns, undefined, status), cutNote);
+    const csv = renderCsv(
+      rows as Row[],
+      renderOptions.columns,
+      (row) => exportIdentityCells(cited, rowIdentity(row, renderOptions.exportIdentity)),
+      status,
+      renderOptions.exportDated ? (row) => exportDatingCells(cited, rowIdentity(row, renderOptions.exportIdentity)) : undefined,
+    );
+    return withCsvFooter(csv, [...exportSourceLines(cited), ...cutNote, ...(renderOptions.exportNotes ?? []).map((note) => `note: ${note}`)]);
   }
   if (renderOptions.text) {
     return renderOptions.text(result.data);
@@ -519,6 +644,22 @@ export function printCliResult<T, Row extends Record<string, unknown> = Record<s
       console.error(`${cliStyles.warning("warning:")} ${hinted(warning)}`);
     }
   }
+  // CSV says what its rows do not in closing `# note:` lines; NDJSON has no place for one among its rows,
+  // so the same notes go to stderr, where the warnings are.
+  if (options.format === "ndjson" && !options.quiet) {
+    for (const note of exportNdjsonNotes(result, options, renderOptions)) console.error(`note: ${note}`);
+  }
+}
+
+/** What a `--limit`, or the default a command caps its rows at, left out of a list, then the command's own notes: what CSV closes with as `# note:` lines. */
+function exportNdjsonNotes<T, Row extends Record<string, unknown>>(
+  result: CliResult<T>,
+  options: CliGlobalOptions,
+  renderOptions: CliResultRenderOptions<T, Row>,
+): string[] {
+  if (renderOptions.tables || renderOptions.text) return [];
+  const cut = windowed(asRows(result.data, renderOptions.rows), options, renderOptions).note;
+  return [...cut ? [cut] : [], ...renderOptions.exportNotes ?? []];
 }
 
 export function serializeCliError(error: CliErrorObject, options: CliGlobalOptions): string {

package/src/cli/series-search.ts

@@ -27,7 +27,7 @@ function fredSeriesIdOf(expression: string): string | null {
   return /^FRED:([A-Z0-9]+)$/i.exec(expression)?.[1]?.toUpperCase() ?? null;
 }
 
-/** The FRED series the plugins' catalog charts, as `gloomberb fred` takes them: DFEDTARU, ECBDFR. */
+/** The FRED series the plugins' catalog charts, as `gloom fred` takes them: DFEDTARU, ECBDFR. */
 export function catalogFredSeriesIds(plugins: readonly SeriesSource[]): Set<string> {
   return new Set(plugins.flatMap((plugin) => plugin.series ?? [])
     .flatMap((definition) => definition.expression ? [fredSeriesIdOf(definition.expression)] : [])
@@ -96,14 +96,14 @@ export function renderSeriesMatches(
   const shown = matches.slice(0, limit);
   const count = shown.length < matches.length ? `${shown.length} of ${matches.length}` : String(matches.length);
   const quoted = `"${query.replace(/"/g, "")}"`;
-  // A FRED series named by its id is also one `gloomberb fred` prints.
+  // A FRED series named by its id is also one `gloom fred` prints.
   const asked = query.trim().toUpperCase().replace(/^FRED:/, "");
   const fred = matches.find((match) => match.exact && fredSeriesIdOf(match.expression) === asked);
   const hint = fred
-    ? `Print it with gloomberb fred ${asked}; chart it with gloomberb fn G ${fred.expression}.`
+    ? `Print it with gloom fred ${asked}; chart it with gloom fn G ${fred.expression}.`
     : shown.length < matches.length
-    ? `Chart one with gloomberb fn G <chart>; gloomberb ${rest === "catalog" ? `catalog ${quoted}` : `shot CAT ${quoted}`} lists all ${matches.length}.`
-    : "Chart one with gloomberb fn G <chart>.";
+    ? `Chart one with gloom fn G <chart>; gloom ${rest === "catalog" ? `catalog ${quoted}` : `shot CAT ${quoted}`} lists all ${matches.length}.`
+    : "Chart one with gloom fn G <chart>.";
   return [
     `${renderSection(`Series for "${query}"`)} ${cliStyles.muted(`(${count})`)}`,
     renderTable(

package/src/cli/statement-filings.ts

@@ -1,6 +1,7 @@
 import { apiClient } from "../api-client";
 import type { BankFiguresPayload } from "../api-client/bank-figures";
 import type { FinancialStatement } from "../types/financials";
+import { fetchOfferingFilings, type OfferingFiling } from "../utils/cash-runway";
 import { logFailure } from "../utils/log-failure";
 import { nonUsSecListingVenue } from "../utils/sec";
 
@@ -42,6 +43,8 @@ export interface StatementReportSources {
   /** The company's 10-K, 10-Q, 8-K, 20-F and 40-F filings, newest first. */
   statementFilings(symbol: string): Promise<PeriodicFiling[]>;
   bankFigures(symbol: string): Promise<BankFiguresPayload>;
+  /** The company's latest offering prospectuses (424B5, 424B4), newest first. */
+  offeringFilings?(symbol: string): Promise<OfferingFiling[]>;
 }
 
 export const cloudStatementReportSources: StatementReportSources = {
@@ -62,8 +65,24 @@ export const cloudStatementReportSources: StatementReportSources = {
     });
   },
   bankFigures: (symbol) => apiClient.getCloudBankFigures(symbol),
+  offeringFilings: (symbol) => fetchOfferingFilings(apiClient, symbol),
 };
 
+/**
+ * A US listing's latest offering prospectuses, for the note that its cash
+ * predates one; nothing (and no request) for any other listing, or when
+ * `wanted` is false. A failed read leaves the note out.
+ */
+export async function loadOfferingFilings(
+  sources: StatementReportSources | undefined,
+  listing: { symbol: string; exchange?: string },
+  wanted: boolean,
+): Promise<OfferingFiling[]> {
+  if (!wanted || !sources?.offeringFilings || nonUsSecListingVenue(listing.symbol, listing.exchange)) return [];
+  return sources.offeringFilings(listing.symbol)
+    .catch(logFailure("cli.statement-filings", "Reading the offering filings failed", [] as OfferingFiling[]));
+}
+
 /** The filing a statement row's period was read from: its form when the filing list names it, and its filed date. */
 export interface StatementFiling {
   /** 10-Q, 10-K, 20-F or 40-F; null when the filing is not among those listed. */

package/src/cli/suffixed-listing-rows.ts

@@ -0,0 +1,49 @@
+import { saveConfig } from "../data/config/store";
+import { mergeSavedSuffixedListings } from "../portfolio/suffixed-listings";
+import type { CliCommandContext } from "../types/plugin";
+import { debugLog } from "../utils/debug-log";
+import { logFailure } from "../utils/log-failure";
+import { withConfigData, withMarketData } from "./scoped-context";
+import type { ConfigContext, MarketContext } from "./types";
+
+const log = debugLog.createLogger("cli.suffixed-listings");
+
+/**
+ * The profile with the rows a collection holds under a vendor's suffixed key
+ * (GARAN.IS) merged into their listing's row (`mergeSuffixedListings`), as
+ * the app does at launch, for a command about to change a portfolio or
+ * watchlist: what it reads is then what it saves over. A dry run writes
+ * nothing and reads the profile as it is. A merge that fails leaves the rows
+ * as they were.
+ */
+async function mergedForWrite<TContext extends ConfigContext>(ctx: Pick<CliCommandContext, "cliOptions">, context: TContext): Promise<TContext> {
+  if (ctx.cliOptions.dryRun) return context;
+  try {
+    const merged = await mergeSavedSuffixedListings(await context.store.loadAllTickers(), context.config, {
+      config: saveConfig,
+      tickers: (rows) => context.store.saveTickers(rows),
+    });
+    // In place: a market context's provider reads the config through this object.
+    if (merged) context.config = merged.config;
+    for (const kept of merged?.keptCustom ?? []) log.info("custom fields kept on the suffixed row", kept);
+  } catch (error) {
+    logFailure("cli.suffixed-listings", "Merging suffixed listing rows failed")(error);
+  }
+  return context;
+}
+
+/** `withConfigData` for a command that changes a portfolio or watchlist (`mergedForWrite`). Commands that only read use `withConfigData`. */
+export function withCollectionConfigData<TResult>(
+  ctx: Pick<CliCommandContext, "initConfigData" | "cliOptions">,
+  operation: (context: ConfigContext) => TResult | Promise<TResult>,
+): Promise<TResult> {
+  return withConfigData(async () => mergedForWrite(ctx, await ctx.initConfigData()), operation);
+}
+
+/** `withMarketData` for a command that changes a portfolio or watchlist (`mergedForWrite`). */
+export function withCollectionMarketData<TResult>(
+  ctx: Pick<CliCommandContext, "initMarketData" | "cliOptions">,
+  operation: (context: MarketContext) => TResult | Promise<TResult>,
+): Promise<TResult> {
+  return withMarketData(async () => mergedForWrite(ctx, await ctx.initMarketData()), operation);
+}

package/src/cli/symbol-args.ts

@@ -1,3 +1,6 @@
+import { isFigure, isNumberCell, protectFigureCommas, restoreFigureCommas } from "./symbol-cells";
+import { readTerminalListingCode, unknownBloombergMarket } from "../tickers/terminal-codes";
+
 /** The quote marks a pasted list wraps its entries in: "AAPL", 'MSFT', “NVDA”. */
 const QUOTE_MARKS = "\"'`\u2018\u2019\u201C\u201D";
 const QUOTE_EDGES = new RegExp(`^[${QUOTE_MARKS}]+|[${QUOTE_MARKS}]+$`, "g");
@@ -12,18 +15,37 @@ const LIST_SEPARATOR = /[,;\t\r\n]/;
  * in it is split on those, so an entry may be a company's name (`WHR,
  * Whirlpool Corporation, BRK.B`) or several symbols with spaces between them
  * (`brk.b bf-b` on a pasted line); one without them is split on spaces (`JNK
- * EMB BRK.B`). Which an entry with a space is takes a search: a command that
+ * EMB BRK.B`), or with `phrases` kept whole (`splitSymbolArgLines`). Which an
+ * entry with a space is takes a search: a command that
  * resolves its symbols reads them with `readNameEntries`, and a parser that
- * looks nothing up takes `splitSymbolWords`.
+ * looks nothing up takes `splitSymbolWords`. A comma inside a figure
+ * (`2.582,52`, `1,899.21`) is no separator: the figure stays one entry. One
+ * between plain digits is a decimal comma only on a line with another
+ * separator (`ED 2,5`); alone it splits codes (`9988,5`, `700,388`).
  */
-export function splitSymbolArgs(args: readonly string[]): string[] {
-  return args
-    .flatMap((arg) => {
-      const text = arg.replace(/^\uFEFF/, "");
-      return LIST_SEPARATOR.test(text) ? text.split(LIST_SEPARATOR) : text.split(/\s+/);
-    })
-    .map((entry) => entry.trim().replace(QUOTE_EDGES, "").trim().replace(/\s+/g, " "))
-    .filter(Boolean);
+export function splitSymbolArgs(args: readonly string[], options: { phrases?: boolean } = {}): string[] {
+  return args.flatMap((arg) => splitSymbolArgLines(arg, options).flat());
+}
+
+/**
+ * `splitSymbolArgs` of one argument, its entries kept by the line they are
+ * on, so a figure can be told to sit beside the symbol on its line. With
+ * `phrases`, an argument with spaces and no list separator is one entry, as
+ * an entry between commas is: a company's name (`"Beyond Meat"`) or symbols
+ * typed on one line (`"GME AMC"`), which `readNameEntries` tells apart.
+ */
+export function splitSymbolArgLines(arg: string, { phrases = false }: { phrases?: boolean } = {}): string[][] {
+  const lines = arg.replace(/^\uFEFF/, "").split(/\r\n?|\n/).map((line) => protectFigureCommas(line));
+  const separated = lines.length > 1 || lines.some((line) => LIST_SEPARATOR.test(line));
+  // A terminal's code (`VOD LN`, `JPM US Equity`), or words written as one (`AAPL GP`), is one entry.
+  return lines.map((line) => (separated ? line.split(/[,;\t]/) : phrases || isTerminalCodeLine(line) ? [line] : line.split(/\s+/))
+    .map((entry) => restoreFigureCommas(entry).trim().replace(QUOTE_EDGES, "").trim().replace(/\s+/g, " "))
+    .filter(Boolean));
+}
+
+function isTerminalCodeLine(line: string): boolean {
+  const text = line.trim().replace(QUOTE_EDGES, "").trim();
+  return /\s/.test(text) && (readTerminalListingCode(text) != null || unknownBloombergMarket(text) != null);
 }
 
 /**
@@ -31,15 +53,28 @@ export function splitSymbolArgs(args: readonly string[]): string[] {
  * spaces and no list separator into it: `quote "10 year yield"`, `quote
  * "Apple Inc"` or a pasted line `quote "AAPL MSFT"`. Which of those it is
  * takes a lookup (`readPhraseArgument`); `splitSymbolArgs` would split it
- * into words, each a symbol (10, YEAR, YIELD). Null for anything else:
- * several arguments, one word, or a list with commas.
+ * into words, each a symbol (10, YEAR, YIELD). A figure in it is part of
+ * the phrase (`"10.5 year yield"`, `"fed funds rate 5.25%"`). Null for
+ * anything else: several arguments, one word, a list with commas, or a
+ * pasted row of symbols each followed by its prices (`ED 2.582,52`, `AAPL
+ * 150.00 MSFT 300.00`), which is read as a list is.
  */
 export function quotedPhrase(args: readonly string[]): string | null {
   if (args.length !== 1) return null;
   const text = args[0]!.replace(/^\uFEFF/, "");
-  if (LIST_SEPARATOR.test(text)) return null;
+  if (LIST_SEPARATOR.test(protectFigureCommas(text))) return null;
   const phrase = text.trim().replace(QUOTE_EDGES, "").trim().replace(/\s+/g, " ");
-  return phrase.includes(" ") ? phrase : null;
+  return phrase.includes(" ") && !isPricedRow(phrase.split(" ")) ? phrase : null;
+}
+
+/**
+ * Words that are a sheet's row rather than a phrase: a number (`2.582,52`)
+ * among them, and each word that is no figure followed by one (`ED
+ * 2.582,52`), so no two words of a name or a phrase sit side by side.
+ */
+function isPricedRow(words: readonly string[]): boolean {
+  if (!words.some(isNumberCell) || isFigure(words[0]!)) return false;
+  return words.every((word, index) => isFigure(word) || (index + 1 < words.length && isFigure(words[index + 1]!)));
 }
 
 /**
@@ -50,7 +85,7 @@ export function quotedPhrase(args: readonly string[]): string | null {
  */
 export function splitSymbolWords(args: readonly string[]): string[] {
   return splitSymbolArgs(args)
-    .flatMap((entry) => entry.split(" "))
+    .flatMap((entry) => isTerminalCodeLine(entry) ? [entry] : entry.split(" "))
     .map((word) => word.replace(QUOTE_EDGES, ""))
     .filter(Boolean);
 }

package/src/cli/symbol-cells.ts

@@ -0,0 +1,120 @@
+/**
+ * What one cell of a pasted list or a typed argument is before anything is
+ * looked up: a symbol, a figure (a price, a weight, a share count) or junk
+ * a sheet leaves where a value is missing (`N/A`, `--`, `$$$`). Every list
+ * reader and every lookup of a list's symbols decide it here, so a price
+ * from a European sheet (`2.582,52`) is never searched for as a ticker.
+ */
+
+/** A sign before a figure: plus, hyphen-minus or the minus sign. */
+const SIGN = "[+\\-\u2212]";
+/** The currency marks a sheet writes beside an amount. */
+const CURRENCY = "[$\u20ac\u00a3\u00a5\u20b9\u20a9\u20bd\u20ba\u20aa\u0e3f\u20ab\u00a2]";
+/** Thousands written with an apostrophe (1'234.50) or a no-break or thin space (1 234,50). */
+const GROUP_MARK = "['\u2019\u00a0\u202f\u2009]";
+const FIGURE_BODY = [
+  // 1,899.21 and 1,899: commas between thousands.
+  "\\d{1,3}(?:,\\d{3})+(?:\\.\\d+)?",
+  // 2.582,52, 1.899 and 1.234.567: dots between thousands, a decimal comma.
+  "\\d{1,3}(?:\\.\\d{3})+(?:,\\d+)?",
+  `\\d{1,3}(?:${GROUP_MARK}\\d{3})+(?:[.,]\\d+)?`,
+  // 2,5 and 12,345, and 1234,56: a decimal comma.
+  "\\d{1,3},\\d+",
+  "\\d+,\\d{1,2}",
+  "\\d*\\.\\d+",
+  "\\d+",
+].join("|");
+const FIGURE = new RegExp(
+  `^(?:${SIGN}?${CURRENCY}?${SIGN}?(?:${FIGURE_BODY})(?:%|\u2030|${CURRENCY})?|\\(${CURRENCY}?(?:${FIGURE_BODY})%?\\))$`,
+  "u",
+);
+/** A run of digits and the marks between them, where a comma may be a decimal comma rather than a list's separator. */
+const FIGURE_RUN = new RegExp(`(?<![\\p{L}\\p{N}.])(?:${SIGN}|${CURRENCY})*\\d[\\d.,'\u2019\u00a0\u202f\u2009]*(?:%|\u2030|${CURRENCY})?`, "gu");
+/** Placeholders a sheet writes for a missing value, and its error values: N/A, n.a., #N/A, #VALUE!. */
+const PLACEHOLDER = /^(?:#?n\/a|n\.a\.?|#(?:value!|ref!|div\/0!|name\?|num!|null!|spill!|calc!|getting_data))$/i;
+/** Stands in for a comma inside a figure while a line is split on its separators. */
+const FIGURE_COMMA = "\u0000";
+/** Plain digits split by commas (`7203,10`, `5,700`): a decimal comma, or the line's separator between two codes. */
+const PLAIN_COMMA_RUN = /^\d+(?:,\d+)+$/;
+
+/**
+ * A figure as a sheet or a keyboard writes it, a bare whole number (7203)
+ * included: `2.582,52`, `1,899.21`, `-3.2%`, `€1.234,56`, `(1,234.56)`.
+ */
+export function isFigure(cell: string): boolean {
+  return FIGURE.test(cell.trim());
+}
+
+/**
+ * A figure that is never a symbol: one with a decimal or thousands mark, a
+ * sign, a percent or a currency mark (`1.899`, `2,5`, `+4`, `12%`, `$12`). A
+ * bare whole number is not one, as `7203` and `0700` are tickers on their own.
+ */
+export function isNumberCell(cell: string): boolean {
+  const text = cell.trim();
+  return FIGURE.test(text) && !/^\d+$/.test(text);
+}
+
+/** A cell that names nothing: no letter or digit (`$$$`, `--`, `-`, `…`), or a placeholder for a missing value (`N/A`, `#N/A`). */
+export function isJunkCell(cell: string): boolean {
+  const text = cell.trim();
+  return !/[\p{L}\p{N}]/u.test(text) || PLACEHOLDER.test(text);
+}
+
+/** Why a cell is not a symbol, as a lookup refuses it without asking anything; null for one that may be. */
+function notASymbolReason(cell: string): string | null {
+  if (isJunkCell(cell)) return "not a symbol";
+  if (isNumberCell(cell)) return "a number, not a symbol";
+  return null;
+}
+
+/** An entry of a list that cannot be a symbol, refused before any lookup and never looked up again. */
+export class NotASymbolError extends Error {
+  constructor(readonly input: string, readonly reason: string) {
+    super(`${input.trim()} is ${reason}.`);
+    this.name = "NotASymbolError";
+  }
+}
+
+/** `NotASymbolError` for a cell that is not a symbol, else null. */
+export function notASymbolError(cell: string): NotASymbolError | null {
+  const reason = notASymbolReason(cell);
+  return reason ? new NotASymbolError(cell, reason) : null;
+}
+
+/**
+ * Whether a comma between plain digits on a line is a decimal comma (`ED
+ * 2,5`, `CNX;1899,21`): the line has another separator, a tab, a semicolon or
+ * spaces between its cells. Otherwise the comma is the line's only separator
+ * and splits the digits into cells, as a sheet of codes exports them
+ * (`0700,25`, `7203,10`). Quoted cells and separators at the ends are not
+ * counted.
+ */
+export function hasDecimalCommas(line: string): boolean {
+  const bare = line.replace(/"(?:[^"]|"")*"/g, "\"\"").replace(/^[\s,;]+|[\s,;]+$/g, "");
+  return /[\t;]/.test(bare) || /[^\s,;]\s+[^\s,;]/.test(bare);
+}
+
+/**
+ * The text with each comma inside a figure swapped for a stand-in, so
+ * splitting on commas leaves the figure whole; `restoreFigureCommas` puts
+ * them back. A figure only a number can be (`2.582,52`, `1,899.21`, `2,5%`)
+ * keeps its comma. One of plain digits (`7203,10`) keeps it only where its
+ * comma is a decimal comma: `decimalCommas`, else `hasDecimalCommas` of each
+ * line. A run that is no figure keeps its commas as separators.
+ */
+export function protectFigureCommas(text: string, decimalCommas?: boolean): string {
+  if (decimalCommas == null) {
+    return text.split(/(\r\n?|\n)/).map((part, index) => index % 2 === 1 ? part : protectFigureCommas(part, hasDecimalCommas(part))).join("");
+  }
+  return text.replace(FIGURE_RUN, (run) => {
+    const body = run.replace(/[.,'\u2019]+$/, "");
+    const tail = run.slice(body.length);
+    const figure = body.includes(",") && isFigure(body) && (decimalCommas || !PLAIN_COMMA_RUN.test(body));
+    return figure ? `${body.replaceAll(",", FIGURE_COMMA)}${tail}` : run;
+  });
+}
+
+export function restoreFigureCommas(text: string): string {
+  return text.replaceAll(FIGURE_COMMA, ",");
+}