gloomberb 0.17.2 → 0.17.4

package/src/cli/pane-functions/headless.ts

@@ -5,6 +5,7 @@ import { findNamedCollection } from "../../portfolio/collection-name";
 import { apiClient } from "../../api-client";
 import type { MarketContext } from "../types";
 import type {
+  HeadlessArgumentExpansion,
   HeadlessBundleResult,
   HeadlessBundleSection,
   HeadlessPaneColumn,
@@ -37,6 +38,7 @@ import type { ResolvedSeries } from "../../time-series/types";
 import type { PaneFunctionReport } from "./report";
 import type { ResolvedPaneFunction } from "./resolver";
 import { isRecord } from "../../utils/guards";
+import { splitSymbolArgs } from "../symbol-args";
 import { formatUtcTime, localTimeSuffix } from "../../utils/utc-time";
 import { deriveHeadlessFreshness, formatFreshnessLine, staleRowsText, type ReportFreshness } from "./freshness";
 import { accessGateStatus, errorsAccessGate, isProLock } from "./access-gate";
@@ -74,7 +76,7 @@ function normalizeSymbol(value: string): string {
 function normalizeSymbolList(value: string): string[] {
   const symbols: string[] = [];
   const seen = new Set<string>();
-  for (const part of value.split(/[,\s]+/)) {
+  for (const part of splitSymbolArgs([value])) {
     const symbol = normalizeSymbol(part);
     if (!symbol || seen.has(symbol)) continue;
     seen.add(symbol);
@@ -162,22 +164,17 @@ async function loadHeadlessPaneModel(
   return result;
 }
 
-/**
- * Loads the same renderer-neutral model used by `fn`.
- * Both reports and screenshot payloads execute this loader.
- */
-export async function loadResolvedHeadlessPaneModel(
+type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities">> & {
+  dataProvider: HeadlessPaneContext["marketData"];
+};
+
+/** What a headless loader reads the market, the account and the saved collections through. */
+function createHeadlessPaneContext(
   resolved: ResolvedPaneFunction,
-  context: Pick<MarketContext, "config" | "store" | "refresh"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities">> & {
-    dataProvider: HeadlessPaneContext["marketData"];
-  },
-  rawArgument: string,
-  signal: AbortSignal = new AbortController().signal,
-): Promise<LoadedHeadlessPaneModel> {
-  const definition = resolved.headless;
-  if (!definition) throw new Error(`${resolved.token} has no headless pane model.`);
-  const args = buildHeadlessPaneLoadArgs(definition, resolved.token, rawArgument, resolved.options);
-  const headlessContext: HeadlessPaneContext = {
+  context: HeadlessMarketContext,
+  signal: AbortSignal,
+): HeadlessPaneContext {
+  return {
     marketData: context.dataProvider,
     apiClient,
     config: context.config,
@@ -203,7 +200,40 @@ export async function loadResolvedHeadlessPaneModel(
       return { symbol: parsed.symbol, exchange: parsed.exchange ?? ticker?.metadata.exchange };
     },
   };
-  const result = await loadHeadlessPaneModel(definition, args, headlessContext);
+}
+
+/**
+ * The argument a function widens before it runs (`expandArgument`, RV's
+ * `--peers`), with the settings that say how; null when it runs as typed.
+ */
+export async function expandResolvedArgument(
+  resolved: ResolvedPaneFunction,
+  context: HeadlessMarketContext,
+  rawArgument: string,
+  signal: AbortSignal = new AbortController().signal,
+): Promise<HeadlessArgumentExpansion | null> {
+  const definition = resolved.headless;
+  if (!definition?.expandArgument) return null;
+  const args = buildHeadlessPaneLoadArgs(definition, resolved.token, rawArgument, resolved.options);
+  const expansion = await definition.expandArgument(args, createHeadlessPaneContext(resolved, context, signal));
+  throwIfAborted(signal);
+  return expansion;
+}
+
+/**
+ * Loads the same renderer-neutral model used by `fn`.
+ * Both reports and screenshot payloads execute this loader.
+ */
+export async function loadResolvedHeadlessPaneModel(
+  resolved: ResolvedPaneFunction,
+  context: HeadlessMarketContext,
+  rawArgument: string,
+  signal: AbortSignal = new AbortController().signal,
+): Promise<LoadedHeadlessPaneModel> {
+  const definition = resolved.headless;
+  if (!definition) throw new Error(`${resolved.token} has no headless pane model.`);
+  const args = buildHeadlessPaneLoadArgs(definition, resolved.token, rawArgument, resolved.options);
+  const result = await loadHeadlessPaneModel(definition, args, createHeadlessPaneContext(resolved, context, signal));
   return { definition, args, result };
 }
 
@@ -527,6 +557,36 @@ function splitErrors(result: HeadlessPaneResult): { locked: string[]; failed: st
   return { locked: errors.filter(isProLock), failed: errors.filter((error) => !isProLock(error)) };
 }
 
+/**
+ * Why a report with nothing in it is empty, when its pane gave no reason of
+ * its own: the free view left it empty (the report carries a Pro line), or the
+ * symbols asked for are not covered by the function (or hold nothing for the
+ * options chosen). Null when something has
+ * rows, a table states its own reason, an error explains it, or no symbol was
+ * asked for (a board that is empty says nothing about coverage).
+ */
+function emptyReportReason(
+  definition: HeadlessPaneDefinition,
+  result: HeadlessPaneResult,
+  args: HeadlessPaneLoadArgs,
+  token: string | undefined,
+): string | null {
+  if (resultRowCount(definition, result) > 0) return null;
+  const ownReason = definition.shape === "rows" ? !!(result as HeadlessRowsResult).empty
+    : definition.shape === "bundle" && (result as HeadlessBundleResult).sections.some((section) => "empty" in section && !!section.empty);
+  const { locked, failed } = splitErrors(result);
+  if (ownReason || failed.length) return null;
+  if (locked.length) return "Locked: Gloom Pro";
+  const symbols = result.symbols ?? args.symbols;
+  if (!symbols.length) return null;
+  // An option the reader chose (a range, a tab) can leave a covered symbol empty, so coverage is not claimed then.
+  const narrowed = definition.options.some((option) => {
+    const value = args.options[option.key];
+    return value !== undefined && value !== "" && String(value) !== String(option.defaultValue ?? "");
+  });
+  return narrowed ? `No data for ${symbols.join(", ")} with these options.` : `No data for ${symbols.join(", ")}: not covered${token ? ` by ${token}` : ""}.`;
+}
+
 function textNotices(result: HeadlessPaneResult): string[] {
   const notices = result.metadata?.notices;
   if (!Array.isArray(notices)) return [];
@@ -634,15 +694,20 @@ export function renderHeadlessPaneText(
   args: HeadlessPaneLoadArgs,
   fallbackTitle: string,
   freshness: ReportFreshness = deriveHeadlessFreshness(definition, result),
+  /** The function's token, which an empty report names as the one that does not cover the symbol. */
+  token?: string,
 ): string {
   // A long title wraps to a narrow --width like the text under a table; each line stays bold.
   const lines = [...wrapToTerminal(reportTitle(definition, args, result, fallbackTitle)).split("\n").map(cliStyles.bold), ""];
   const notices = textNotices(result);
   if (notices.length) lines.push(...notices, "");
-  switch (definition.shape) {
+  const reason = emptyReportReason(definition, result, args, token);
+  // Said once, not under the heading of each empty table.
+  if (reason) lines.push(reason);
+  else switch (definition.shape) {
     case "rows": {
       const rowsResult = result as HeadlessRowsResult;
-      lines.push(renderRows(rowsResult.rows, rowsResult.columns, definition.columns, rowsResult.empty));
+      lines.push(renderRows(rowsResult.rows, rowsResult.textColumns ?? rowsResult.columns, definition.columns, rowsResult.empty));
       break;
     }
     case "bundle":
@@ -756,6 +821,7 @@ export async function buildHeadlessFunctionReport(
       loaded.args,
       resolved.label,
       freshness,
+      resolved.token,
     ),
     tables: headlessReportTables(
       loaded.definition,

package/src/cli/pane-functions/index.ts

@@ -1,5 +1,5 @@
 import { extname, isAbsolute, relative, resolve } from "path";
-import type { CliCommandContext } from "../../types/plugin";
+import type { CliCommandContext, HeadlessArgumentExpansion } from "../../types/plugin";
 import type { MarketContext } from "../types";
 import { withMarketData } from "../context";
 import { cliStyles, renderStats, type CliStatEntry } from "../../utils/cli-output";
@@ -8,6 +8,7 @@ import {
   findFunctionCode,
   renderPaneCatalogReport,
   selectPaneCatalogMatches,
+  suggestPaneFunctions,
   type PaneFunctionCatalog,
 } from "./catalog";
 import { createPaneCatalog } from "./discovery";
@@ -19,6 +20,7 @@ import {
 } from "./options";
 import { applyListingArgument, resolvePaneFunction, UnknownPaneFunctionError, type ResolvedPaneFunction } from "./resolver";
 import { buildFunctionReport } from "./report";
+import { expandResolvedArgument } from "./headless";
 import { defaultScreenshotPath, renderDesktopShot, shotSizeWarnings, shotStatusIssues } from "./screenshot";
 import {
   buildPaneCatalogEntries,
@@ -29,6 +31,7 @@ import { ListingArgError, listingReadNotes, loadForListing, quotedListingChoiceN
 import { knownGapMessage, settingsPointer, topicPointer } from "../known-gaps";
 import { selectReportTables } from "../report-tables";
 import { cliOutputWritten } from "../result";
+import type { CatalogCommandHit } from "../unknown-command";
 import { CLI_EXIT_CODES } from "../exit-codes";
 import {
   GLOSSARY,
@@ -55,8 +58,14 @@ async function withPaneRuntime<T>(
     const context: MarketContext = ctx.cliOptions.refresh ? { ...market, refresh: true } : market;
     const registry = await createPaneCatalog(context, ctx.plugins);
     try {
-      const parsed = await applyListingArgument(registry, context, parsePaneFunctionArgs(args, ctx.cliOptions), settings.command);
-      const resolved = await resolvePaneFunction(registry, context, parsed, settings);
+      let parsed = await applyListingArgument(registry, context, parsePaneFunctionArgs(args, ctx.cliOptions), settings.command);
+      let resolved = await resolvePaneFunction(registry, context, parsed, settings);
+      // A function that widens its argument (RV's --peers) runs, reports and captures the widened one.
+      const expansion = await withPersistedCloudSession(context, () => expandResolvedArgument(resolved, context, parsed.arg));
+      if (expansion) {
+        parsed = { ...parsed, arg: expansion.argument };
+        resolved = withExpansion(await resolvePaneFunction(registry, context, parsed, settings), expansion);
+      }
       return await run({ parsed, context, registry, resolved });
     } finally {
       registry.destroy();
@@ -64,6 +73,15 @@ async function withPaneRuntime<T>(
   });
 }
 
+/** The resolved function with what its expansion adds to the pane: settings, and a title that says how. */
+function withExpansion(resolved: ResolvedPaneFunction, { settings = {}, title }: HeadlessArgumentExpansion): ResolvedPaneFunction {
+  return {
+    ...resolved,
+    optionSettings: { ...resolved.optionSettings, ...settings },
+    instance: { ...resolved.instance, ...(title ? { title } : {}), settings: { ...resolved.instance.settings, ...settings } },
+  };
+}
+
 /** A word that can be a function code: letters and digits, with the dots and dashes some codes carry. */
 const FUNCTION_CODE_WORD = /^[\w.$-]{1,24}$/;
 
@@ -102,6 +120,42 @@ export async function functionCodeCommand(
   }
 }
 
+/** How many functions an unknown command word is answered with. */
+const COMMAND_HIT_LIMIT = 3;
+
+/**
+ * The functions the catalog finds for a word typed as a command (`gloomberb
+ * comps`): what `catalog <word>` would list first, as many as are close.
+ * Empty when the word finds none or the catalog cannot be read.
+ */
+export async function catalogCommandHits(ctx: CliCommandContext, token: string): Promise<CatalogCommandHit[]> {
+  const word = token.trim();
+  if (!/^[a-z][\w-]{1,30}$/i.test(word)) return [];
+  try {
+    return await withMarketData(ctx, async (market) => {
+      const registry = await createPaneCatalog(market, ctx.plugins);
+      try {
+        return (await suggestPaneFunctions(registry, market, word)).slice(0, COMMAND_HIT_LIMIT).map((entry) => ({
+          code: entry.token,
+          label: entry.label,
+          argKind: entry.argKind ?? null,
+          argPlaceholder: entry.argPlaceholder ?? null,
+          peers: entry.capability.options.some((option) => option.key === "peers" && option.type === "boolean"),
+        }));
+      } finally {
+        registry.destroy();
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+/** Whether a list report has no row with data: it is empty, or every row is a name without any. */
+function foundNothing(data: { rowCount: number; unavailableSymbols: readonly string[] }): boolean {
+  return data.rowCount === 0 || data.unavailableSymbols.length >= data.rowCount;
+}
+
 export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
   await runPaneCliCommand(ctx, async () => {
     await withPaneRuntime(ctx, args, async ({ parsed, context, resolved }) => {
@@ -161,6 +215,8 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
         text: () => glossary ? `${report.text}\n\n${renderReportGlossary(resolved.token, glossary)}` : report.text,
         ...(tabular ? { tables: selectReportTables(report.tables, resolved.tableSection) } : {}),
       });
+      // The report is printed as it is; a list that found data for none of its names says so in the exit status too.
+      if (resolved.headless?.failsWithoutData && foundNothing(report.data)) process.exitCode = CLI_EXIT_CODES.error;
     }, { strictHeadlessOptions: true, tableSection: true });
   });
 }
@@ -283,7 +339,7 @@ function runGlossary(term: string, ctx: CliCommandContext): void {
   const { exact, partial } = lookupGlossary(term);
   const entries = [...exact, ...partial];
   if (entries.length === 0) {
-    ctx.fail(`No glossary entry for "${term}".`, "gloomberb catalog glossary lists every term.");
+    ctx.fail(`No glossary entry for "${term}".`, knownGapMessage(term) ?? "gloomberb catalog glossary lists every term.");
   }
   ctx.printResult({ data: entries.map(glossaryRecord) }, { text: () => renderGlossaryEntries(entries).join("\n") });
 }

package/src/cli/pane-functions/market-session.ts

@@ -10,6 +10,7 @@ import {
 import { currentFxClosureStart } from "../../utils/fx-market-hours";
 import { zonedDateKey } from "../../utils/zoned-date-time";
 import type { ReportTime } from "../../utils/utc-time";
+import type { QuoteIndexSession } from "../../types/financials";
 
 /** Where the venues behind a quote report stand, as a report says it after the delay. */
 type ReportMarketState = "open" | "pre-market" | "after-hours" | "closed";
@@ -27,6 +28,8 @@ export interface SessionObservation {
   exchange: string;
   marketState?: string;
   time: ReportTime | null;
+  /** The regular sessions an index quote carries, for a publisher the app has no calendar for. */
+  calendar?: QuoteIndexSession;
 }
 
 interface VenueSession {
@@ -35,16 +38,19 @@ interface VenueSession {
   /** The latest regular session that has closed: its local date and open. */
   last?: { date: string; open: number | null };
   timeZone?: string;
+  /** The sessions are the quote's own, not a calendar of the venue. */
+  quoted?: true;
 }
 
 const CLOSED_STATES = new Set(["CLOSED", "PREPRE", "POSTPOST"]);
+const US_EXCHANGE_TIME_ZONE = "America/New_York";
 
 /**
  * A venue's session now, from its calendar (weekends and published holidays),
  * or from the state its source reports when the app has no calendar for it,
  * such as an index publisher or a futures exchange. Null when neither says.
  */
-function venueSession(exchange: string, marketState: string | undefined, now: number): VenueSession | null {
+function venueSession(exchange: string, marketState: string | undefined, now: number, calendar?: QuoteIndexSession): VenueSession | null {
   if (isAlwaysOpenExchange(exchange)) return { state: "always" };
   const next = nextRegularSessionOpen(exchange, now);
   if (next) {
@@ -61,10 +67,24 @@ function venueSession(exchange: string, marketState: string | undefined, now: nu
     return { state: "closed", next, last, timeZone };
   }
   if (marketState === "REGULAR") return { state: "open" };
-  if (marketState === "PRE") return { state: "pre-market" };
-  if (marketState === "POST") return { state: "after-hours" };
-  if (marketState && CLOSED_STATES.has(marketState)) return { state: "closed" };
-  return null;
+  const stated = marketState === "PRE" ? "pre-market" : marketState === "POST" ? "after-hours" : marketState && CLOSED_STATES.has(marketState) ? "closed" : null;
+  if (!stated) return null;
+  return calendar ? { state: stated, ...quotedSessions(calendar, now) } : { state: stated };
+}
+
+/**
+ * An index publisher's sessions (SNP, DJI, NASDAQ GIDS) as its quote dates
+ * them, read like a venue's calendar: the open still to come, and the latest
+ * regular session that has closed.
+ */
+function quotedSessions({ timeZone, current, regular }: QuoteIndexSession, now: number): Pick<VenueSession, "next" | "last" | "timeZone" | "quoted"> {
+  const closed = [...regular, current].filter((window) => window.end <= now).sort((left, right) => right.end - left.end)[0];
+  return {
+    timeZone,
+    quoted: true,
+    ...(current.start > now ? { next: { date: zonedDateKey(current.start, timeZone), open: current.start } } : {}),
+    ...(closed ? { last: { date: zonedDateKey(closed.start, timeZone), open: closed.start } } : {}),
+  };
 }
 
 /** The venue spot FX pairs trade on. It has no session calendar here; its week is in `fx-market-hours`. */
@@ -101,9 +121,52 @@ function closeDateOf(observation: SessionObservation, session: VenueSession, now
 function closeMarketOf(exchange: string, session: VenueSession): string | null {
   if (exchange === FX_VENUE) return "FX";
   if (!session.last || !session.timeZone) return null;
+  // An index publisher's name is no market: a session dated in New York is the US's, any other is a bare date.
+  if (session.quoted) return session.timeZone === US_EXCHANGE_TIME_ZONE ? "US" : null;
   return isUsListingExchange(exchange) ? "US" : exchange;
 }
 
+/** One market's session behind a report that mixes markets: its local date, and whether that session has closed. */
+export interface VenueSessionDate {
+  /** `US` for the US listing venues, which share one calendar, the venue's code elsewhere (`XETRA`, `EPA`). */
+  market: string;
+  /** The session's local date, `YYYY-MM-DD`. */
+  date: string;
+  /** The newest row on that market is its latest close. */
+  close: boolean;
+}
+
+/**
+ * Each market's session, for a report whose rows trade on more than one
+ * (a US line beside Xetra and Paris ones): the newest row of each, dated in
+ * its venue's own day, in the order the markets first appear. Empty when the
+ * rows share one market, or fewer than two can be placed.
+ */
+export function reportVenueSessionDates(observations: readonly SessionObservation[], now: number): VenueSessionDate[] {
+  const newestByMarket = new Map<string, { observation: SessionObservation & { time: ReportTime }; session: VenueSession }>();
+  for (const observation of observations) {
+    const exchange = canonicalExchange(observation.exchange);
+    const time = observation.time;
+    if (!exchange || !time) continue;
+    const session = venueSession(exchange, observation.marketState, now);
+    if (!session || session.state === "always") continue;
+    const market = exchange === FX_VENUE ? "FX" : isUsListingExchange(exchange) ? "US" : exchange;
+    const current = newestByMarket.get(market);
+    if (!current || time.time > current.observation.time.time) newestByMarket.set(market, { observation: { ...observation, time }, session });
+  }
+  if (newestByMarket.size < 2) return [];
+  return [...newestByMarket].map(([market, { observation, session }]) => {
+    // A venue in its session whose newest row is from an earlier day has not printed today: that row is its last close.
+    const exchange = canonicalExchange(observation.exchange);
+    const latestClose = session.state === "open" && session.timeZone ? latestRegularSessionClose(exchange, now) : null;
+    const last = latestClose ? { date: latestClose.date, open: latestRegularSessionOpen(exchange, latestClose.close) } : session.last;
+    const closeDate = closeDateOf(observation, { ...session, last }, now);
+    const date = closeDate
+      ?? (session.timeZone ? zonedDateKey(observation.time.time, session.timeZone) : new Date(observation.time.time).toISOString().slice(0, 10));
+    return { market, date, close: closeDate != null };
+  });
+}
+
 /**
  * Where the markets behind a quote report stand now, and whether the newest
  * observation is a close, and whose. Null market when the venues disagree
@@ -120,7 +183,7 @@ export function reportMarketSession(
     const exchange = canonicalExchange(observation.exchange);
     if (!exchange) continue;
     const key = `${exchange}:${observation.marketState ?? ""}`;
-    const session = sessions.get(key) ?? venueSession(exchange, observation.marketState, now);
+    const session = sessions.get(key) ?? venueSession(exchange, observation.marketState, now, observation.calendar);
     if (!session) continue;
     sessions.set(key, session);
     if (observation.time && (!newest || observation.time.time > (newest.observation.time?.time ?? -Infinity))) {

package/src/cli/pane-functions/resolver.ts

@@ -12,6 +12,7 @@ import { normalizeTickerInput } from "../../tickers/search";
 import { slugifyName } from "../../utils/slugify";
 import { ListingArgError, listingReadNotes, resolveCliListing, usListingsOnlyMessage } from "../listing-arg";
 import { listingAbroadVenue } from "../../utils/sec";
+import { splitSymbolArgs, stripStrayEdges } from "../symbol-args";
 import type { MarketContext } from "../types";
 import {
   buildPaneFunctionLookup,
@@ -135,10 +136,11 @@ export async function applyListingArgument(
   }
   const exchange = typeof args.options.exchange === "string" ? args.options.exchange : undefined;
   const { exchange: _exchange, ...options } = args.options;
-  const typed = takesOneTicker ? [args.arg] : args.arg.split(/[,\s]+/).filter(Boolean);
+  const typed = takesOneTicker ? [args.arg] : splitSymbolArgs([args.arg]);
   if (typed.length === 0) return args;
   let listings = await Promise.all(typed.map((raw) => resolveCliListing(raw, exchange, context, { ownExchangeWins: typed.length > 1 })));
-  const notes: string[] = [];
+  // A separator stuck to the end of a pasted list (`UPST;`) is not part of a symbol; it is named.
+  const notes: string[] = takesOneTicker ? [] : stripStrayEdges(args.arg).notes;
   const usOnly = headless?.usListingsOnly;
   const abroad = usOnly ? listings.filter((listing) => listingAbroadVenue(listing.key) != null) : [];
   if (usOnly && abroad.length > 0) {

package/src/cli/pane-functions/screenshot.ts

@@ -936,6 +936,8 @@ export async function renderDesktopShot({
   watermark,
   statusLine = false,
   fitRows = false,
+  fitReader = false,
+  maxHeightCells,
   options,
   captureImage = true,
   onStalledReport,
@@ -953,6 +955,10 @@ export async function renderDesktopShot({
   statusLine?: boolean;
   /** No `--height` was asked for: a pane that fits its rows (FUT) grows to show them all. */
   fitRows?: boolean;
+  /** A pane whose reader has a page open grows to show all of its text (a report's, which saves no image). */
+  fitReader?: boolean;
+  /** How tall a pane that fits its rows or its reader may grow, in cells, where the height limit of a saved image does not apply. */
+  maxHeightCells?: number;
   options: Record<string, string | true>;
   captureImage?: boolean;
   /**
@@ -999,7 +1005,14 @@ export async function renderDesktopShot({
       loadModel,
     );
     if (statusLine && captureImage) payload.statusLine = true;
-    if (fitRows && resolved.pane.shotFitsRows) payload.maxHeightCells = shotMaxHeightCells(scale ?? 1);
+    const fitRoles = [
+      ...(fitRows && resolved.pane.shotFitsRows ? ["data-table-body-scroll"] : []),
+      ...(fitReader && resolved.pane.shotFitsReader ? ["detail-scroll-body"] : []),
+    ];
+    if (fitRoles.length > 0) {
+      payload.maxHeightCells = maxHeightCells ?? shotMaxHeightCells(scale ?? 1);
+      payload.fitRoles = fitRoles;
+    }
     // Loads while the page renders.
     const report = payload.statusLine ? reportShotFreshness(resolved, loadModel) : undefined;
     // The same load says whether the report is complete, with or without a status line.

package/src/cli/scroll-truncation.ts

@@ -6,7 +6,11 @@ export interface ScrollBoxMetrics {
   scrollLeft: number;
   scrollWidth: number;
   clientWidth: number;
-  /** The box draws a scrollbar on that axis, which says it overflows even when the measures cannot. */
+  /**
+   * The box draws a scrollbar on that axis, which says it overflows even when the measures cannot:
+   * a table's body, which draws only the rows near the viewport. A plain scroll box draws one by
+   * default and holds all its content, so its measures say it.
+   */
   scrollbarY: boolean;
   scrollbarX: boolean;
 }

package/src/cli/symbol-args.ts

@@ -1,11 +1,49 @@
+/** 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");
+
 /**
  * Symbols given as command arguments, each of which may hold several split by
  * commas, semicolons, spaces, tabs or newlines (a pasted list), with the blanks
- * dropped and the typed case kept. Every command that takes a symbol list splits
- * its arguments here, and `not-a-ticker` reads the typed spelling back from them.
+ * dropped, the quote marks around each entry removed and the typed case kept.
+ * Every command that takes a symbol list splits its arguments here, and
+ * `not-a-ticker` reads the typed spelling back from them.
  */
 export function splitSymbolArgs(args: readonly string[]): string[] {
-  return args.flatMap((arg) => arg.replace(/^\uFEFF/, "").split(/[\s,;]+/)).filter(Boolean);
+  return args
+    .flatMap((arg) => arg.replace(/^\uFEFF/, "").split(/[\s,;]+/))
+    .map((entry) => entry.replace(QUOTE_EDGES, ""))
+    .filter(Boolean);
+}
+
+/** The list separators in `text`, each once: `,;` for a stray `;,;`. */
+function separatorsIn(text: string): string {
+  return [...new Set([...text].filter((char) => char === "," || char === ";"))].join("");
+}
+
+/**
+ * A pasted list, or one cell of a file, without the separators and quote marks
+ * stuck to its ends (`UPST;`, `"GME",`). The separators it dropped are named
+ * (`Ignored the stray ";" after UPST.`) rather than swallowed, and never reach
+ * a listing search as part of a symbol, which would ask for `UPST;`.
+ */
+export function stripStrayEdges(text: string): { text: string; notes: string[] } {
+  const junk = `[\\s,;${QUOTE_MARKS}]`;
+  const leading = text.match(new RegExp(`^${junk}+`))?.[0] ?? "";
+  const rest = text.slice(leading.length);
+  const trailing = rest.match(new RegExp(`${junk}+$`))?.[0] ?? "";
+  const inner = rest.slice(0, rest.length - trailing.length);
+  const entries = splitSymbolArgs([inner]);
+  const [first, last] = [entries[0], entries.at(-1)];
+  const before = separatorsIn(leading);
+  const after = separatorsIn(trailing);
+  const notes = !first
+    ? (before || after ? [`Ignored the stray "${separatorsIn(leading + trailing)}".`] : [])
+    : [
+      ...before ? [`Ignored the stray "${before}" before ${first}.`] : [],
+      ...after ? [`Ignored the stray "${after}" after ${last}.`] : [],
+    ];
+  return { text: inner, notes };
 }
 
 /** How a symbol is compared for repeats: AAPL, aapl and $AAPL are one. */

package/src/cli/symbol-list.ts

@@ -1,6 +1,6 @@
 import { readFile } from "fs/promises";
 import { fstatSync } from "fs";
-import { splitSymbolArgs, uniqueSymbols } from "./symbol-args";
+import { splitSymbolArgs, stripStrayEdges, uniqueSymbols } from "./symbol-args";
 
 /** Header cells that name a spreadsheet's symbol column, compared without case, spaces or punctuation. */
 const SYMBOL_HEADERS = new Set(["symbol", "symbols", "ticker", "tickers", "code", "stockcode", "securitycode", "instrument"]);
@@ -129,13 +129,25 @@ export class SymbolListError extends Error {
 /**
  * The symbols a command was given: as arguments, from `--file`, and from
  * standard input when an argument is `-` or nothing else was given and input
- * is piped in. Repeats are dropped.
+ * is piped in. Repeats are dropped. A separator stuck to a symbol in a file, or
+ * left on the end of what was typed (`UPST;`), is dropped with the quote marks
+ * around it, and each is named in `strays` so the command can say so.
  */
-export async function readSymbolList(source: SymbolListSource): Promise<{ symbols: string[]; repeated: number }> {
+export async function readSymbolList(source: SymbolListSource): Promise<{ symbols: string[]; repeated: number; strays: string[] }> {
   const readStdin = source.readStdin ?? (() => Bun.stdin.text());
   const wantsStdin = source.args.includes("-") || source.file === "-";
-  const typed = splitSymbolArgs(source.args.filter((arg) => arg !== "-"));
+  const typedArgs = source.args.filter((arg) => arg !== "-");
+  const typed = splitSymbolArgs(typedArgs);
   const collected = [...typed];
+  // A separator left on the end of what was typed: `UPST;`, or a list that ends in a comma.
+  const strays = new Set<string>(stripStrayEdges(typedArgs.join(" ")).notes);
+  const addCells = (cells: readonly string[]) => {
+    for (const cell of cells) {
+      const cleaned = stripStrayEdges(cell);
+      cleaned.notes.forEach((note) => strays.add(note));
+      collected.push(cleaned.text);
+    }
+  };
   if (source.file != null && source.file !== "-") {
     if (!source.file.trim() || source.file.startsWith("--")) throw new SymbolListError("--file needs a path, such as --file symbols.csv.");
     let text: string;
@@ -145,10 +157,10 @@ export async function readSymbolList(source: SymbolListSource): Promise<{ symbol
       const code = (error as NodeJS.ErrnoException).code;
       throw new SymbolListError(code === "ENOENT" ? `No file at ${source.file}.` : `Could not read ${source.file}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    collected.push(...parseSymbolText(text));
+    addCells(parseSymbolText(text));
   }
   if (wantsStdin || (typed.length === 0 && source.file == null && (source.stdinPiped ?? stdinIsPiped()))) {
-    collected.push(...parseSymbolText(await readStdin()));
+    addCells(parseSymbolText(await readStdin()));
   }
-  return uniqueSymbols(collected);
+  return { ...uniqueSymbols(collected), strays: [...strays] };
 }