gloomberb 0.18.2 → 0.18.4

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

@@ -21,10 +21,12 @@ import {
   parsePaneFunctionArgs,
   type ParsedPaneFunctionArgs,
 } from "./options";
-import { applyListingArgument, findPaneFunction, resolvePaneFunction, UnknownPaneFunctionError, type ResolvedPaneFunction } from "./resolver";
+import { applyListingArgument, findPaneFunction, parsePaneFunctionArgsFor, resolvePaneFunction, UnknownPaneFunctionError, type ResolvedPaneFunction } from "./resolver";
 import { buildFunctionReport } from "./report";
 import { expandResolvedArgument } from "./headless";
-import { defaultScreenshotPath, renderDesktopShot, shotSizeWarnings, shotStatusIssues } from "./screenshot";
+import { defaultScreenshotPath, shotSizeWarnings } from "./screenshot-payload";
+import { renderDesktopShot } from "./screenshot-render";
+import { shotStatusIssues } from "./screenshot-assessment";
 import {
   buildPaneCatalogEntries,
 } from "./catalog";
@@ -37,8 +39,8 @@ import { isNotATickerMessage } from "../not-a-ticker";
 import { isCliFailure } from "../errors";
 import { isTickerLinkPeer } from "../../layout/ticker-navigation";
 import { knownGapMessage, commandPointer, commandPointerLeads, topicPointer } from "../known-gaps";
-import { selectReportTables } from "../report-tables";
-import { cliOutputWritten } from "../result";
+import { selectReportTables, type CliReportTables } from "../report-tables";
+import { cliOutputWritten, type CliErrorObject } from "../result";
 import type { CatalogCommandHit } from "../unknown-command";
 import { CLI_EXIT_CODES } from "../exit-codes";
 import { shotOptionRefusal } from "./shot-options";
@@ -67,7 +69,7 @@ async function withPaneRuntime<T>(
     const context: MarketContext = ctx.cliOptions.refresh ? { ...market, refresh: true } : market;
     const registry = await createPaneCatalog(context, ctx.plugins);
     try {
-      let parsed = await applyListingArgument(registry, context, parsePaneFunctionArgs(args, ctx.cliOptions), settings.command);
+      let parsed = await applyListingArgument(registry, context, parsePaneFunctionArgsFor(registry, 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));
@@ -100,8 +102,8 @@ function commandWord(argument: string): string {
 }
 
 /**
- * What to run when a command name is a function's code (`gloomberb OVDV KO`,
- * `gloomberb help OVDV`): `fn` with the reader's own arguments, or the
+ * What to run when a command name is a function's code (`gloom OVDV KO`,
+ * `gloom help OVDV`): `fn` with the reader's own arguments, or the
  * function's argument hint when they gave none. Null when the word is no
  * function code or the catalog cannot be read, and the command stays unknown.
  */
@@ -123,7 +125,7 @@ export async function functionCodeCommand(
     });
     if (!found) return null;
     const code = word.replace(/^\$/, "").toUpperCase();
-    return { code, command: ["gloomberb fn", code, args.length > 0 ? args.map(commandWord).join(" ") : found.argument].filter(Boolean).join(" ") };
+    return { code, command: ["gloom fn", code, args.length > 0 ? args.map(commandWord).join(" ") : found.argument].filter(Boolean).join(" ") };
   } catch (error) {
     logFailure("cli.pane-functions-index", "Resolve function code command failed")(error);
     return null;
@@ -131,7 +133,7 @@ export async function functionCodeCommand(
 }
 
 /**
- * The one function code a command name is a slip from (`gloomberb RCDF PLTR`
+ * The one function code a command name is a slip from (`gloom RCDF PLTR`
  * for RDCF), with the command that runs it on the reader's arguments, read
  * as a command word is (nearFunctionCodes), so a ticker is not taken for one.
  * Null when no code, or more than one, is that close, or the catalog cannot
@@ -155,7 +157,7 @@ export async function nearFunctionCodeCommand(
     });
     if (near.length !== 1) return null;
     const { code, label } = near[0]!;
-    return { code, label, command: ["gloomberb fn", code, ...args.map(commandWord)].join(" ") };
+    return { code, label, command: ["gloom fn", code, ...args.map(commandWord)].join(" ") };
   } catch (error) {
     logFailure("cli.pane-functions-index", "Find nearby function code command failed")(error);
     return null;
@@ -204,6 +206,63 @@ function foundNothing(data: { rowCount: number; unavailableSymbols: readonly str
   return data.rowCount === 0 || data.unavailableSymbols.length >= data.rowCount;
 }
 
+/** A listing key as asked or reported (`BHP:XASX`, `fred:DGS10`, `SPY`), in one case. */
+const listingKey = (symbol: string) => symbol.trim().toUpperCase();
+const bareKey = (key: string) => key.split(":")[0]!;
+
+/**
+ * The listings asked that a report has no data for. A report names one by its
+ * full key; one that names it by the bare symbol (`SAN` for `SAN:EPA`), or by
+ * the listing a bare symbol resolved to (`SXR8:XETRA` for `SXR8`), stands for
+ * the one listing asked that way, never for a listing asked by its own key:
+ * with `BHP:XASX` and `BHP` asked, `BHP:XASX` unavailable leaves `BHP`.
+ */
+function missingListings(asked: readonly string[], unavailable: readonly string[]): Set<string> {
+  const keys = asked.map(listingKey);
+  const exact = new Set(keys);
+  const missing = new Set<string>();
+  for (const entry of unavailable.map(listingKey)) {
+    if (exact.has(entry)) {
+      missing.add(entry);
+      continue;
+    }
+    const loose = keys.filter((key) => bareKey(key) === bareKey(entry) && key.includes(":") !== entry.includes(":"));
+    if (loose.length === 1) missing.add(loose[0]!);
+  }
+  return missing;
+}
+
+/** Whether a table holds a value past its first column (a row's label or date) and its reasons: a figure, a time, any text. */
+function tablesHoldValues(tables: CliReportTables): boolean {
+  return tables.tables.some((table) => {
+    const skipped = new Set(table.columns.flatMap((header, index) => index === 0 || header === "status" || header === "value_status" ? [index] : []));
+    return table.rows.some((row) => row.some((cell, index) => !skipped.has(index) && cell !== "" && cell != null));
+  });
+}
+
+/**
+ * Why `fn` fails a report it printed, or null when the report has data. It
+ * fails when it is empty (a pane behind a wall reads nothing), when it has no
+ * data for any listing asked and its tables hold no value either, or when it
+ * is a list (`failsWithoutData`) with no name that has any. A report with data
+ * for some of what was asked, warnings or errors beside it, is a result: a
+ * loss-maker's P/E band without a P/E, or IV history with only realized
+ * volatility, exits 0.
+ */
+export function reportFailure(
+  data: { empty: boolean; rowCount: number; symbols: readonly string[]; unavailableSymbols: readonly string[]; errors?: readonly string[]; reason?: unknown },
+  asked: string,
+  { failsWithoutData = false, tables }: { failsWithoutData?: boolean; tables?: CliReportTables } = {},
+): CliErrorObject | null {
+  const missing = missingListings(data.symbols, data.unavailableSymbols);
+  const noListing = data.symbols.length > 0 && data.symbols.every((symbol) => missing.has(listingKey(symbol)));
+  const noValues = tables ? !tablesHoldValues(tables) : false;
+  if (!data.empty && !(noListing && noValues) && !(failsWithoutData && foundNothing(data))) return null;
+  const reasons = [...data.errors ?? [], ...typeof data.reason === "string" ? [data.reason] : []];
+  const unavailable = data.unavailableSymbols.length > 0 ? `no data for ${data.unavailableSymbols.join(", ")}` : "no data";
+  return { code: "no_data", message: `${asked}: ${reasons.length > 0 ? reasons.join("; ") : unavailable}.`.replace(/\.\.$/, ".") };
+}
+
 export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
   await runPaneCliCommand(ctx, async () => {
     await withPaneRuntime(ctx, args, async ({ parsed, context, registry, resolved }) => {
@@ -215,7 +274,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       )) {
         throw new Error(
           `${resolved.token} is not a verified bot-safe report capability. `
-          + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
+          + `Use "gloom catalog ${resolved.token}" to inspect readiness.`,
         );
       }
       const tabular = ctx.cliOptions.format === "csv" || ctx.cliOptions.format === "ndjson";
@@ -237,7 +296,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       const fate = listing && quoteAnswer && isTickerLinkPeer(resolved.instance, registry.panes)
         ? listingFateLoader(listing, context, quoteAnswer().then((answer) => answer.quote))
         : null;
-      const moved = { command: "fn", retry: (key: string) => `gloomberb fn ${resolved.token} ${key}` };
+      const moved = { command: "fn", retry: (key: string) => `gloom fn ${resolved.token} ${key}` };
       // A report that fails or comes back empty for an exchange the symbol is not listed on says so.
       const report = await refuseMovedListing(fate, moved, () => withPersistedCloudSession(
         context,
@@ -250,7 +309,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
         ),
       ));
       // A company's name typed where its ticker goes (`fn RDCF Palantir`) found nothing: the answer is `quote`'s,
-      // "Not a ticker: PALANTIR. Try `gloomberb search Palantir`.", not an empty report.
+      // "Not a ticker: PALANTIR. Try `gloom search Palantir`.", not an empty report.
       if (quoteAnswer && (report.data.empty || report.data.unavailableSymbols.length > 0)) {
         const { quote, error } = await quoteAnswer();
         const message = error instanceof Error ? error.message : null;
@@ -277,13 +336,15 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
         ? { ...report.data, glossary: glossary.map(({ term, short, definition }) => ({ term, ...(short ? { short } : {}), definition })) }
         : report.data;
       const warnings = [...parsed.listingNotes ?? [], ...await choice ?? [], ...report.data.warnings ?? []];
+      // A report with no data is printed as it is, and fails: exit 1, and `ok: false` in JSON with the reason.
+      const failure = reportFailure(report.data, ["fn", resolved.token, parsed.arg.trim()].filter(Boolean).join(" "), {
+        failsWithoutData: resolved.headless?.failsWithoutData, tables: report.tables });
       // The report states its own freshness in its data and text; JSON cites it as `source` too.
-      ctx.printResult({ data, exportFreshness: report.data.freshness, ...(warnings.length > 0 ? { warnings } : {}) }, {
+      ctx.printResult({ data, exportFreshness: report.data.freshness, ...(warnings.length > 0 ? { warnings } : {}), ...(failure ? { failure } : {}) }, {
         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;
+      if (failure) process.exitCode = CLI_EXIT_CODES.error;
     }, { strictHeadlessOptions: true, tableSection: true });
   });
 }
@@ -308,8 +369,8 @@ export function emptySeriesExport(
     const ids = [...new Set(fred)];
     return {
       message: `${asked} has no data to export: ${ids.join(" and ")} ${ids.length === 1 ? "is a FRED series" : "are FRED series"}, not ${ids.length === 1 ? "a ticker" : "tickers"}.`,
-      details: `Chart it with the fred: prefix: gloomberb fn G ${ids.map((id) => `fred:${id}`).join(",")} ${formatFlag}`
-        + `${ids.length === 1 ? ` (or gloomberb fred ${ids[0]} ${formatFlag})` : ""}.`,
+      details: `Chart it with the fred: prefix: gloom fn G ${ids.map((id) => `fred:${id}`).join(",")} ${formatFlag}`
+        + `${ids.length === 1 ? ` (or gloom fred ${ids[0]} ${formatFlag})` : ""}.`,
     };
   }
   const missing = data.unavailableSymbols.length > 0 ? ` for ${data.unavailableSymbols.join(", ")}` : "";
@@ -318,7 +379,7 @@ export function emptySeriesExport(
     message: `${asked} has no data to export${missing}.`,
     details: [
       ...reasons,
-      `Check the symbol with gloomberb search, or run gloomberb ${asked} without ${formatFlag} to see the report.`,
+      `Check the symbol with gloom search, or run gloom ${asked} without ${formatFlag} to see the report.`,
     ].join("\n"),
   };
 }
@@ -346,7 +407,7 @@ async function capturePaneScreenshot(args: string[], ctx: CliCommandContext, onS
       )) {
         throw new Error(
           `${resolved.token} is not a verified bot-safe screenshot capability. `
-          + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
+          + `Use "gloom catalog ${resolved.token}" to inspect readiness.`,
         );
       }
       // An option the pane cannot draw fails here, before a capture of its default is saved as if it were the view asked for.
@@ -410,7 +471,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}".`, knownGapMessage(term) ?? "gloomberb catalog glossary lists every term.");
+    ctx.fail(`No glossary entry for "${term}".`, knownGapMessage(term) ?? "gloom catalog glossary lists every term.");
   }
   ctx.printResult({ data: entries.map(glossaryRecord) }, { text: () => renderGlossaryEntries(entries).join("\n") });
 }

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

@@ -106,7 +106,17 @@ export function parseArgumentsOption(value: string): Record<string, string> {
   return pairs;
 }
 
-export function parsePaneFunctionArgs(args: string[], globalOptions: { limit?: number; tail?: number } = {}): ParsedPaneFunctionArgs {
+/** How many words one value of an option takes, by its key as parsed (`fxShift`); one when it is not a pair. */
+export type OptionValueWords = (key: string) => number;
+
+/** Words in the last value of a list (`TRY -20, EUR 5` ends with two); a decimal comma (`TRY -2,5`) separates nothing. */
+const lastValueWords = (value: string) => value.split(/(?<!\d),|,(?!\d)/).at(-1)!.trim().split(/\s+/).filter(Boolean).length;
+
+export function parsePaneFunctionArgs(
+  args: string[],
+  globalOptions: { limit?: number; tail?: number } = {},
+  valueWords?: OptionValueWords,
+): ParsedPaneFunctionArgs {
   const positionals: string[] = [];
   const options: Record<string, string | true> = {};
   let outputPath: string | null = null;
@@ -153,8 +163,18 @@ export function parsePaneFunctionArgs(args: string[], globalOptions: { limit?: n
     }
     const next = args[index + 1];
     const nextValue = inlineValue === undefined && next && !next.startsWith("--") ? args[++index] : true;
-    const value: string | true = inlineValue ?? nextValue ?? true;
+    let value: string | true = inlineValue ?? nextValue ?? true;
     const normalizedKey = normalizeOptionKey(key);
+    // A value that is a pair (`--fx-shift TRY -20`) takes the words after it, and a list of them the words after a comma.
+    const words = value === true ? 1 : valueWords?.(normalizedKey) ?? 1;
+    if (words > 1 && value !== true) {
+      while (index + 1 < args.length && !args[index + 1]!.startsWith("--")
+        && (lastValueWords(value) < words || value.trimEnd().endsWith(","))) {
+        value = `${value} ${args[++index]!}`;
+      }
+      const earlier = options[normalizedKey];
+      if (typeof earlier === "string") value = `${earlier}, ${value}`;
+    }
     if (normalizedKey === "requireBotSafe" || normalizedKey === "botSafe") {
       requireBotSafe = value === true || String(value).toLowerCase() === "true";
     } else if (normalizedKey === "output" || normalizedKey === "out" || normalizedKey === "o") {

package/src/cli/pane-functions/report-notices.ts

@@ -66,24 +66,29 @@ function publishedSources(value: unknown): NonNullable<HeadlessPaneFreshness["so
   return sources.length ? sources : null;
 }
 
+function isStringList(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
 /**
  * How current a rendered pane says its data is, from the `report-freshness`
  * node it publishes: `{ asOf?, status?, delayMinutes?, source?, sources?,
- * maxAgeMinutes?, oldestAge?, note?, basis?, asOfLabel? }`; `basis` names what a pane
+ * maxAgeMinutes?, oldestAge?, ageOnly?, note?, noteVariants?, basis?, asOfLabel?, datesEachVenue? }`; `basis` names what a pane
  * that is not a feed lists, when one pane lists different things (NI's
  * stories, and its LTR code's letters). A capture keeps no footer status and
  * few cells carry a time, so a pane that knows its feed (OMON's chain) dates
  * the report here, as the plain command over the same data does, and a pane
- * over several venues (PERP) dates each one as its report does. A pane whose
+ * over several venues (PERP) dates each one as its report does, as does one
+ * whose quotes trade on several markets (RV's `datesEachVenue`). A pane whose
  * figures come from several dated quotes (FXC's pair rates) publishes them
  * instead, see `renderedReportObservations`.
  */
 export function renderedReportFreshness(
   semanticUi: readonly RemoteUiNodeSnapshot[],
-): Pick<HeadlessPaneFreshness, "asOf" | "status" | "delayMinutes" | "source" | "sources" | "maxAgeMinutes" | "oldestAge" | "note" | "basis" | "asOfLabel"> {
+): Pick<HeadlessPaneFreshness, "asOf" | "status" | "delayMinutes" | "source" | "sources" | "maxAgeMinutes" | "oldestAge" | "ageOnly" | "note" | "noteVariants" | "basis" | "asOfLabel" | "datesEachVenue"> {
   const metadata = semanticUi.find((node) => node.role === "report-freshness")?.metadata;
   if (!metadata) return {};
-  const { asOf, status, delayMinutes, source, maxAgeMinutes, oldestAge, note, basis, asOfLabel } = metadata as Record<string, unknown>;
+  const { asOf, status, delayMinutes, source, maxAgeMinutes, oldestAge, ageOnly, note, noteVariants, basis, asOfLabel, datesEachVenue } = metadata as Record<string, unknown>;
   const sources = publishedSources(metadata.sources);
   return {
     ...(typeof asOf === "string" || isFiniteNumber(asOf) ? { asOf } : {}),
@@ -93,9 +98,12 @@ export function renderedReportFreshness(
     ...(sources ? { sources } : {}),
     ...(isFiniteNumber(maxAgeMinutes) && maxAgeMinutes > 0 ? { maxAgeMinutes } : {}),
     ...(oldestAge === true ? { oldestAge } : {}),
+    ...(ageOnly === true ? { ageOnly } : {}),
     ...(typeof note === "string" && note.trim() ? { note } : {}),
+    ...(isStringList(noteVariants) && noteVariants.length > 0 ? { noteVariants } : {}),
     ...(typeof basis === "string" && basis.trim() ? { basis } : {}),
     ...(typeof asOfLabel === "string" && asOfLabel.trim() ? { asOfLabel } : {}),
+    ...(datesEachVenue === true ? { datesEachVenue } : {}),
   };
 }
 

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

@@ -51,10 +51,10 @@ export function resolvePaneFunctionReportSource(
   return resolved.capability.reportReadiness === "live-dom" ? "dom" : null;
 }
 
-/** `gloomberb shot CAT santander`, the argument quoted when it has spaces. */
+/** `gloom shot CAT santander`, the argument quoted when it has spaces. */
 function shotCommand(token: string, rawArg: string): string {
   const arg = rawArg.trim();
-  return ["gloomberb shot", token, arg && /\s/.test(arg) ? JSON.stringify(arg) : arg].filter(Boolean).join(" ");
+  return ["gloom shot", token, arg && /\s/.test(arg) ? JSON.stringify(arg) : arg].filter(Boolean).join(" ");
 }
 
 export async function buildFunctionReport(
@@ -67,7 +67,7 @@ export async function buildFunctionReport(
   if (!source) {
     // HELP is what a newcomer tries first: send them to the command guide and the function list.
     if (resolved.pane.id === "help") {
-      throw new Error("HELP is an in-app pane, so it has no report. For the commands run `gloomberb help`; for the functions run `gloomberb catalog`.");
+      throw new Error("HELP is an in-app pane, so it has no report. For the commands run `gloom help`; for the functions run `gloom catalog`.");
     }
     // A pane `shot` can draw is still one command away.
     const screenshot = resolved.capability.screenshotReadiness;
@@ -88,10 +88,10 @@ export async function buildFunctionReport(
   }
   if (source === "dom") {
     const view = domReportView(report.data);
-    report.text = appendDomReportFooter(report.text, elapsedMs, view, report.data.freshness);
+    report.text = appendDomReportFooter(report.text, view, report.data.freshness);
     report.tables = {
       ...report.tables,
-      footer: [...report.tables.footer, `note: ${domReportNote(elapsedMs, view)}`],
+      footer: [...report.tables.footer, `note: ${domReportNote(view)}`],
     };
   }
   return report;

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

@@ -23,7 +23,9 @@ import type { MarketContext } from "../types";
 import {
   buildPaneFunctionLookup,
   buildTemplateContext,
+  findFunctionCode,
   nearFunctionCodes,
+  suggestedFunctionCodes,
   suggestPaneFunctions,
   type NearFunctionCode,
   type PaneFunctionCatalog,
@@ -34,15 +36,20 @@ import {
   cleanTickerInput,
   normalizeLookupToken,
   optionSettings,
+  parsePaneFunctionArgs,
   type ParsedPaneFunctionArgs,
 } from "./options";
+import { argumentSymbols, validateSymbolCount } from "./headless";
 import {
   capabilityHasOption,
   capabilityPaneSettings,
+  findCapabilityOption,
   getHeadlessPaneDefinition,
   getPaneFunctionCapability,
   noArgumentMessage,
   normalizeCapabilityOptions,
+  paneFunctionArgument,
+  takesNoArgument,
   type NormalizedPaneFunctionOptions,
   type PaneFunctionCapability,
 } from "./capabilities";
@@ -65,9 +72,10 @@ export interface ResolvedPaneFunction {
 }
 
 async function buildPaneInstance(
-  resolved: Pick<ResolvedPaneFunction, "pane" | "template" | "headless" | "createOptions" | "optionSettings" | "capability" | "options">,
+  resolved: Pick<ResolvedPaneFunction, "token" | "pane" | "template" | "headless" | "createOptions" | "optionSettings" | "capability" | "options">,
   context: MarketContext,
   target: string,
+  command: "fn" | "shot",
 ): Promise<PaneInstanceConfig> {
   // Free text is a phrase, not a symbol. Treating it as a ticker makes the
   // pane look for a provider for values such as "HIGH GROWTH SOFTWARE".
@@ -88,7 +96,11 @@ async function buildPaneInstance(
       return { ...spec.settings, ...resolved.optionSettings };
     }
     const chartSpec = parseChartSpec(spec.settings?.chartSpec);
-    if (!chartSpec) throw new Error("The chart template did not produce a valid chart specification.");
+    if (!chartSpec) {
+      // A chart of too few tickers (CMP of one) has none to draw: say how many it takes.
+      if (resolved.headless) validateSymbolCount(resolved.headless, resolved.token, argumentSymbols(target), command);
+      throw new Error("The chart template did not produce a valid chart specification.");
+    }
     return {
       ...spec.settings,
       chartSpec: applyChartComposerCapabilityOptions(
@@ -116,6 +128,24 @@ export function findPaneFunction(registry: PaneFunctionCatalog, target: string):
   return { template, pane: template ? registry.panes.get(template.paneId) : entry as PaneDef };
 }
 
+/**
+ * `fn` and `shot` arguments read with the function's own options: one whose
+ * value is a pair (MARS's `--fx-shift TRY -20`) takes the words after its
+ * flag, which a function that has none would read as its argument.
+ */
+export function parsePaneFunctionArgsFor(
+  registry: PaneFunctionCatalog,
+  args: string[],
+  globalOptions: { limit?: number; tail?: number } = {},
+): ParsedPaneFunctionArgs {
+  const parsed = parsePaneFunctionArgs(args, globalOptions);
+  const found = parsed.target ? findPaneFunction(registry, parsed.target) : null;
+  if (!found?.pane) return parsed;
+  const capability = getPaneFunctionCapability(found.template, found.pane);
+  if (!capability.options.some((option) => (option.valueWords ?? 1) > 1)) return parsed;
+  return parsePaneFunctionArgs(args, globalOptions, (key) => findCapabilityOption(capability, key)?.valueWords ?? 1);
+}
+
 /**
  * `fn ANR SAN --exchange EPA` is `fn ANR SAN:EPA`: a function that takes
  * tickers gets each listing as `quote` reads it (`resolveCliListing`), so
@@ -145,14 +175,24 @@ export async function applyListingArgument(
   }
   const exchange = typeof args.options.exchange === "string" ? args.options.exchange : undefined;
   const { exchange: _exchange, ...options } = args.options;
-  // A list entry with spaces is a company's name search finds, or the symbols it holds.
-  const typed = takesOneTicker ? [args.arg] : await readNameEntries(splitSymbolArgs([args.arg]), context.dataProvider);
+  // A list entry with spaces, or an argument of words, is a company's name search finds, or the symbols it holds.
+  const typed = takesOneTicker ? [args.arg] : await readNameEntries(splitSymbolArgs([args.arg], { phrases: true }), context.dataProvider);
   if (typed.length === 0) return args;
   // RY.TO is the listing its quote names, RY:TSX, as `quote` reads it: a function's data is read by venue.
   let listings = await Promise.all(typed.map((raw) => resolveCliListing(raw, exchange, context, { ownExchangeWins: typed.length > 1, venueSuffix: true })));
   // 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 token = found.template?.shortcut?.prefix ?? args.target.toUpperCase();
+  // Words search finds no company for, and that are not symbols either, name nothing a function can read: tickers do.
+  const unnamed = takesList ? listings.filter((listing) => /\s/.test(listing.symbol)) : [];
+  if (unnamed.length > 0) {
+    const names = unnamed.map((listing) => typed[listings.indexOf(listing)]!.trim());
+    const answer = `No company found for ${names.map((name) => `"${name}"`).join(", ")}; type tickers`;
+    const details = `Such as gloom ${command} ${token} GME,AMC. Find a company's ticker with gloom search "${names[0]!.replace(/"/g, "")}".`;
+    listings = listings.filter((listing) => !unnamed.includes(listing));
+    if (listings.length === 0) throw new ListingArgError(`${answer}.`, details);
+    notes.push(`${answer}, such as GME,AMC.`);
+  }
   // A function with company data answers an index or an ETF with what it is and where its data is, before
   // any request: its source would only say "Unknown ticker" or come back empty. A list leaves it out.
   const covered = found.pane.instruments;
@@ -177,7 +217,7 @@ export async function applyListingArgument(
   const abroad = usOnly ? listings.filter((listing) => listingAbroadVenue(listing.key) != null) : [];
   if (usOnly && abroad.length > 0) {
     const answers = await Promise.all(abroad.map(async (listing) => {
-      const answer = await usListingsOnlyMessage(usOnly, listing, context, (key) => `gloomberb ${command} ${token} ${key}`);
+      const answer = await usListingsOnlyMessage(usOnly, listing, context, (key) => `gloom ${command} ${token} ${key}`);
       const hint = headless?.usListingsOnlyHint?.(listing.key);
       return hint ? { ...answer, details: `${answer.details}\n${hint}` } : answer;
     }));
@@ -243,18 +283,24 @@ async function unknownPaneFunctionError(
   // NIM is one slip from NI, but a bank figure is in `fundamentals`, not in a function's statement lines.
   const bank = bankFigurePointer(name, arg);
   if (bank) return new UnknownPaneFunctionError(name, bank.details, null, bank.message);
-  const near = nearFunctionCodes(registry, name);
+  // A word that asks for a function's data (IVOL for HIVG and OVDV) names them as a slip from a code names it.
+  const suggested = suggestedFunctionCodes(registry, name);
+  const near = [...suggested, ...nearFunctionCodes(registry, name).filter(({ code }) => !suggested.some((entry) => entry.code === code))];
   // A catalog that cannot be read still leaves the pointer to it.
   const closest = (await suggestPaneFunctions(registry, context, name).catch(logFailure("cli.pane-functions-resolver", "Find pane function suggestions failed", [])))
     .filter((entry) => !near.some(({ code }) => code === entry.token));
   const tokenWidth = Math.max(0, ...closest.map((entry) => entry.token.length));
   const word = /^[\w.:-]+$/.test(name) ? name : JSON.stringify(name);
   const argument = arg.trim() ? ` ${/^[\w.:,=%+@/$^-]+$/.test(arg.trim()) ? arg.trim() : JSON.stringify(arg.trim())}` : "";
+  // One code is run on the argument; the functions a word asks for are each.
+  const runs = suggested.length > 0 ? suggested : near.length === 1 ? near : [];
   return new UnknownPaneFunctionError(name, [
-    ...near.length === 1 ? [`Run: gloomberb ${command} ${near[0]!.code}${argument}`] : [],
+    // A function a word asks for, typed with no argument, shows the one it takes (`<ticker>`).
+    ...runs.map(({ code }, index) => [index === 0 ? "Run:" : "    ", "gloom", command, code,
+      argument.trim() || (suggested.length > 0 ? findFunctionCode(registry, code)?.argument : "")].filter(Boolean).join(" ")),
     ...closest.length > 0
-      ? ["Closest matches:", ...closest.map((entry) => `  ${entry.token.padEnd(tokenWidth)}  ${entry.label}`), `Search the catalog: gloomberb catalog ${word}`]
-      : near.length > 0 ? [] : [`No function code is close to ${word}. List every function: gloomberb catalog`],
+      ? ["Closest matches:", ...closest.map((entry) => `  ${entry.token.padEnd(tokenWidth)}  ${entry.label}`), `Search the catalog: gloom catalog ${word}`]
+      : near.length > 0 ? [] : [`No function code is close to ${word}. List every function: gloom catalog`],
   ].join("\n"), near.length > 0 ? nearCodesText(near) : null);
 }
 
@@ -266,7 +312,7 @@ export async function resolvePaneFunction(
 ): Promise<ResolvedPaneFunction> {
   let args = parsedArgs;
   if (!args.target) {
-    throw new Error("Usage: gloomberb fn <function-or-pane> [argument] [--key value]");
+    throw new Error("Usage: gloom fn <function-or-pane> [argument] [--key value]");
   }
 
   const found = findPaneFunction(registry, args.target);
@@ -288,16 +334,21 @@ export async function resolvePaneFunction(
   // What the user types for the function, which every error about it names.
   const token = template?.shortcut?.prefix ?? template?.id ?? pane.id;
   // A word after a function that takes none is most often one of its option values (`fn JODI gas`).
-  if (headless?.argument.kind === "none" && args.arg?.trim()) {
+  // Every function the catalog lists with no argument refuses one, a rendered view (HALT) as a report (CBR).
+  // The catalog lists templates and the panes no template opens (HELP); a pane opened by its id stands for its templates.
+  const listed = template !== undefined || ![...registry.paneTemplates.values()].some((entry) => entry.paneId === pane.id);
+  const refusesArgument = listed ? takesNoArgument(paneFunctionArgument(template, pane)) : headless?.argument.kind === "none";
+  if (refusesArgument && args.arg?.trim()) {
     throw new Error(noArgumentMessage(capability.options, token, args.arg, resolutionSettings.command ?? "fn"));
   }
   const normalizedOptions = normalizeCapabilityOptions(capability, args.options, {
-    strict: args.requireBotSafe || (!!headless && resolutionSettings.strictHeadlessOptions === true),
+    strict: args.requireBotSafe || capability.strictOptions === true || (!!headless && resolutionSettings.strictHeadlessOptions === true),
     code: token,
     argument: args.arg || null,
   });
   const settings = {
-    ...optionSettings(args.options),
+    // A view that takes only its declared options gets only their settings.
+    ...capability.strictOptions ? {} : optionSettings(args.options),
     ...capabilityPaneSettings(capability, normalizedOptions),
   };
   if (args.requireBotSafe) {
@@ -318,7 +369,7 @@ export async function resolvePaneFunction(
     options: normalizedOptions,
     ...(tableSection !== undefined ? { tableSection } : {}),
   };
-  resolved.instance = await buildPaneInstance(resolved, context, args.arg);
+  resolved.instance = await buildPaneInstance(resolved, context, args.arg, resolutionSettings.command ?? "fn");
   return resolved;
 }