gloomberb 0.18.2 → 0.18.4

package/src/cli/listing-arg.ts

@@ -34,15 +34,29 @@ import {
 import { withMarketData } from "./scoped-context";
 import { failWithFields } from "./errors";
 import { stripStrayEdges } from "./symbol-args";
-import { isNoProviderMessage } from "../sources/provider-errors";
-import { dashedCoinPair } from "../utils/crypto-pair";
+import { isNoProviderMessage, isProviderBusy } from "../sources/provider-errors";
+import { dashedCoinPair, MAJOR_COIN_NAMES } from "../utils/crypto-pair";
+import { boardCoinFor, primeBoardCoins } from "./board-coins";
+import { knownGapMessage } from "./known-gaps";
 import { currencyPairSpelling } from "../utils/currency-pair";
 import { bareFuturesCode, futuresContractByCode } from "../market-data/futures-board";
 import { classifyInstrumentType, kindFromListingSyntax } from "../tickers/instrument-kind";
 import type { InstrumentOfKind } from "../tickers/instrument-coverage";
 import { brokerIndexCode, brokerIndexReadAs } from "./index-roots";
-import { readTerminalListingCode, terminalCodeReadAs } from "../tickers/terminal-codes";
+import {
+  bloombergCodeOf,
+  bloombergMarketHint,
+  endsInLegalForm,
+  isSearchOnlyVenue,
+  readNearMissListing,
+  readTerminalListingCode,
+  terminalCodeReadAs,
+  unknownBloombergMarket,
+  type TerminalListingCode,
+} from "../tickers/terminal-codes";
 import { listingAbroadVenue } from "../utils/sec";
+import { listingSuffixCandidate, listingSuffixVenue, tickerHasListingSuffix } from "../sources/listing-symbols";
+import { notTheCoinNote } from "./commands/crypto-hints";
 
 /** The `--exchange` option of every command that takes a ticker. */
 export const EXCHANGE_OPTION = {
@@ -83,6 +97,19 @@ export interface ListingArg {
   sharedCode?: string;
   /** What a shared code was read as, when not its first venue: "Read 7203:TSE as 7203:JPX: ...". */
   readAs?: string;
+  /**
+   * The company's common stock a name read as a fund or an index means
+   * (`CompanyNameListing.meant`): JPM for "JP Morgan" read as ^JTEK:NIM.
+   * `readAs` asks about it, and a command the listing fails asks too.
+   */
+  meant?: { symbol: string; name: string };
+}
+
+/** "Did you mean JPM (JPMorgan Chase & Co.)?", for a name read as a fund or an index; empty for any other listing. */
+export function meantQuestion(listing: Pick<ListingArg, "meant">): string {
+  const meant = listing.meant;
+  if (!meant) return "";
+  return `Did you mean ${meant.name && meant.name.toUpperCase() !== meant.symbol ? `${meant.symbol} (${meant.name})` : meant.symbol}?`;
 }
 
 /**
@@ -101,19 +128,32 @@ export interface ListingArg {
 export function parseListingArg(
   rawArg: string,
   exchangeOption?: string | null,
-  { ownExchangeWins = false, terminalCodes = true }: {
+  { ownExchangeWins = false, terminalCode, listingSuffix = false }: {
     ownExchangeWins?: boolean;
-    /** False for words that read as a Bloomberg code but are a name (`readTerminalCodeArg`). */
-    terminalCodes?: boolean;
+    /**
+     * The terminal code `readTerminalCodeArg` read the text as, or null for
+     * words that read as a Bloomberg code but are a name. Read here when not given.
+     */
+    terminalCode?: TerminalListingCode | null;
+    /**
+     * Read a vendor's venue suffix as the venue it names (GARAN.IS as
+     * GARAN:BIST, `listingSuffixVenue`), so what is saved, found or removed is
+     * the listing's one row. Commands that store a listing ask for it.
+     */
+    listingSuffix?: boolean;
   } = {},
 ): ListingArg {
   // A pasted ticker can bring the separator or quote marks that sat beside it (`UPST;`); search would ask for them.
   const stripped = stripStrayEdges(rawArg);
   const raw = stripped.text || rawArg;
-  // A terminal's code for a US listing (WFC.N, "JPM US Equity") is that listing (WFC:NYSE, JPM).
-  const terminal = terminalCodes ? readTerminalListingCode(raw) : null;
-  const listing = parseCleanListingArg(terminal?.key ?? raw, exchangeOption, { ownExchangeWins });
-  const notes = [...stripped.text ? stripped.notes : [], ...terminal ? [terminalCodeReadAs(terminal)] : []];
+  // A terminal's code (WFC.N, "VOD LN", "JPM US Equity") is that listing (WFC:NYSE, VOD:LSE, JPM), and a symbol
+  // written nearly as one is (700.HK, 6758.JP, BRK/B) its working form (0700.HK, 6758.T, BRK-B).
+  const terminal = terminalCode === undefined ? readTerminalListingCode(raw) : terminalCode;
+  const nearMiss = terminal ? null : readNearMissListing(raw);
+  const reading = terminal ?? (nearMiss ? { typed: nearMiss.typed, key: nearMiss.symbol } : null);
+  const parsed = parseCleanListingArg(reading?.key ?? raw, exchangeOption, { ownExchangeWins });
+  const listing = listingSuffix ? readListingSuffix(parsed) ?? parsed : parsed;
+  const notes = [...stripped.text ? stripped.notes : [], ...reading ? [terminalCodeReadAs(reading)] : []];
   return notes.length > 0 ? { ...listing, readAs: notes.join(" ") } : listing;
 }
 
@@ -225,8 +265,12 @@ async function checkListingExchange(listing: ListingArg, deps: ListingDeps): Pro
     throw new ListingArgError(`Choose an exchange for ${symbol}.${tradesOn(symbol, await listingVenues(symbol, deps))}`);
   }
   if (!listing.exchange || isKnownExchangeCode(listing.exchange)) return;
+  // A row saved on that venue says it is real (GARAN:BIST, which the exchange table lacks), with no request.
+  if (await loadSavedListing(deps.store, listing)) return;
   const venues = await listingVenues(listing.symbol, deps);
   if (venues.some((venue) => venue.exchange === listing.exchange)) return;
+  // Search busy, or missing the venue: the listing's own quote there settles it, as `quote` reads it.
+  if (await quotedOnVenue(listing, deps)) return;
   throw new ListingArgError(
     `Unknown exchange ${listing.exchange} for ${listing.symbol}.${tradesOn(listing.symbol, venues)}`,
     venues.length > 0 ? undefined : `No listings of ${listing.symbol} were found.`,
@@ -270,7 +314,7 @@ export interface ListingDataRequest {
   noun: string;
   /**
    * The retry for one listing, when the key does not go right after the
-   * command (`gloomberb watchlist add Growth SAN:EPA`); null names the listings alone.
+   * command (`gloom watchlist add Growth SAN:EPA`); null names the listings alone.
    */
   retry?: ((key: string) => string) | null;
   /**
@@ -338,7 +382,7 @@ export function listingChoiceNote(
     .filter((exchange) => exchange !== chosen.exchange);
   if (others.length === 0) return null;
   const more = others.length - MAX_OTHER_LISTINGS;
-  const also = `${others.slice(0, MAX_OTHER_LISTINGS).join(", ")}${more > 0 ? ` and ${more} more: gloomberb search ${symbol}` : ""}`;
+  const also = `${others.slice(0, MAX_OTHER_LISTINGS).join(", ")}${more > 0 ? ` and ${more} more: gloom search ${symbol}` : ""}`;
   return `${symbol} = ${name ? `${shortCompanyName(name)}, ` : ""}${chosen.exchange} (also ${also})`;
 }
 
@@ -388,7 +432,9 @@ export async function listingChoiceNotes(
 /**
  * `listingChoiceNotes` for a command with no quote of its own to read the
  * listing from (`fn`): it loads the listing's quote, and only for a bare
- * symbol, so a named or saved listing costs nothing.
+ * symbol, so a named or saved listing costs nothing. A bare coin ticker read
+ * as a fund (BTC, the Grayscale trust) ends with `quote`'s note naming the
+ * coin's pair.
  */
 export async function quotedListingChoiceNotes(
   listing: Pick<CliListing, "symbol" | "exchange" | "saved" | "request" | "readAs">,
@@ -396,7 +442,9 @@ export async function quotedListingChoiceNotes(
 ): Promise<string[]> {
   const venues = loadBareVenues(listing, deps);
   if (!venues) return listingReadNotes(listing);
-  return listingChoiceNotes(listing, deps, await loadListingQuote(deps.dataProvider, listing), venues);
+  const quote = await loadListingQuote(deps.dataProvider, listing);
+  const coin = notTheCoinNote(listing.symbol, quote);
+  return [...await listingChoiceNotes(listing, deps, quote, venues), ...coin ? [coin] : []];
 }
 
 /**
@@ -438,7 +486,7 @@ async function usListingOfCompany(
  * instead of a bare error or another company's numbers under the same
  * symbol: "Time and sales covers US listings only, and SAN:EPA is Sanofi on
  * Euronext Paris (EPA).", then the company's US listing with the command that
- * asks for it ("Sanofi's US listing: SNY (try: gloomberb fn TAS SNY)"), or that
+ * asks for it ("Sanofi's US listing: SNY (try: gloom fn TAS SNY)"), or that
  * none was found.
  */
 export async function usListingsOnlyMessage(
@@ -492,17 +540,17 @@ interface OtherListingsMessage {
 }
 
 /**
- * The command that asks again for another listing: `gloomberb history SAN:EPA
+ * The command that asks again for another listing: `gloom history SAN:EPA
  * --range 5Y` keeps the options. Null where the request names listings alone.
  */
 function retryCommand(request: Pick<ListingDataRequest, "command" | "retry">, key: string): string | null {
   if (request.retry !== undefined) return request.retry?.(key) ?? null;
   const [command, ...options] = request.command.split(" ");
-  return ["gloomberb", command, key, ...options].join(" ");
+  return ["gloom", command, key, ...options].join(" ");
 }
 
 /**
- * "GC=F Gold future (try: gloomberb quote GC=F)", under a bare futures board
+ * "GC=F Gold future (try: gloom quote GC=F)", under a bare futures board
  * code a security keeps (GC, NG) when that security has no data: the future is
  * the other thing the code names. Null for any other symbol.
  */
@@ -526,7 +574,7 @@ function describeOtherListings(
     const retry = retryCommand(request, key);
     return `${key}${venue.name ? ` ${venue.name}` : ""}${retry ? ` (try: ${retry})` : ""}`;
   });
-  if (others.length > MAX_OTHER_LISTINGS) lines.push(`and ${others.length - MAX_OTHER_LISTINGS} more: gloomberb search ${listing.symbol}`);
+  if (others.length > MAX_OTHER_LISTINGS) lines.push(`and ${others.length - MAX_OTHER_LISTINGS} more: gloom search ${listing.symbol}`);
   if (future) lines.push(future);
   const heading = choose ? "Listings" : "Other listings";
   return {
@@ -547,7 +595,7 @@ function describeOtherListings(
  * the symbol's other listings, each with the command that asks for it, such
  * as "SXR8 resolved to iShares Core S&P 500 UCITS ETF USD (Acc) (XETRA), which has
  * no history." and "SXR8:BUD iShares Core S&P 500 UCITS ETF USD (Acc) (try:
- * gloomberb history SXR8:BUD)". When several
+ * gloom history SXR8:BUD)". When several
  * companies list the code, it went to none of them: "Choose an exchange for
  * 2222." and every listing with its retry command, as `2222:` asks. Null when
  * the symbol named its exchange or has no other listing. It searches, so ask
@@ -692,14 +740,14 @@ export function chosenListingNote(symbol: string, exchange: string, others: read
   const aside = [
     without.length > 0 ? `no quote on ${without.join(", ")}` : "",
     others.length > 0
-      ? `other listings: ${others.slice(0, MAX_OTHER_LISTINGS).join(", ")}${more > 0 ? ` and ${more} more: gloomberb search ${symbol}` : ""}`
+      ? `other listings: ${others.slice(0, MAX_OTHER_LISTINGS).join(", ")}${more > 0 ? ` and ${more} more: gloom search ${symbol}` : ""}`
       : "",
   ].filter(Boolean).join("; ");
   return `${symbol} -> ${exchange}${aside ? ` (${aside})` : ""}`;
 }
 
 /**
- * "HFC became DINO on 2022-03-15: `gloomberb history DINO`": a symbol whose
+ * "HFC became DINO on 2022-03-15: `gloom history DINO`": a symbol whose
  * company moved, with the command that asks for it under its new symbol.
  */
 export function movedSymbolLine(change: MovedTickerChange, retry: string | null): string {
@@ -772,6 +820,46 @@ export function tradingBoardNote(
   return board && asked && board !== asked ? `Read ${listing.symbol}:${asked} on ${board}, where ${listing.symbol} trades.` : null;
 }
 
+/**
+ * Ends a command with what it says for a bare symbol no source serves: a
+ * company that moved is under its new symbol, else the listing the symbol went
+ * to and the others (`other`, from `otherListingsMessage`), else what became of
+ * it. Returns when there is nothing to say.
+ */
+async function failUnservedListing(
+  ctx: Pick<CliCommandContext, "fail">,
+  request: ListingDataRequest,
+  other: Promise<OtherListingsMessage | null>,
+): Promise<void> {
+  const [listings, fate] = await Promise.all([other, request.fate?.() ?? null]);
+  // Nothing served either way: a company that moved is under its new symbol, before any other listing.
+  const moved = movedAwayChange(fate?.change);
+  if (moved) failMovedSymbol(moved, request);
+  if (listings) ctx.fail(listings.message, [fate?.note, listings.details].filter(Boolean).join("\n"));
+  if (fate?.note) ctx.fail(`${fate.note}.`);
+}
+
+/**
+ * Refuses a bare symbol several companies list (FP is a newspaper group in
+ * Toronto and Fondul Proprietatea in Bucharest) with the message `quote`
+ * gives it, whatever the command's own request served: the data service answers
+ * a history for the bare symbol from one of the listings, which is a pick the
+ * user never made. Asked once the symbol's own quote (`loadListingQuoteAnswer`)
+ * failed with no provider, so a symbol with a quote, a named or saved listing,
+ * and a symbol one company lists go on as they were. It searches, so ask only then.
+ */
+export async function failUnchosenListing(
+  listing: BareListing,
+  deps: ListingDeps,
+  ctx: Pick<CliCommandContext, "fail">,
+  request: ListingDataRequest,
+  quoteError: unknown,
+): Promise<void> {
+  if (!isNoProviderError(quoteError)) return;
+  const venues = await bareListingVenues(listing, deps);
+  if (venues?.choose) await failUnservedListing(ctx, request, Promise.resolve(describeOtherListings(listing, venues, request)));
+}
+
 /**
  * A data request for the listings a command named. When it throws, or `isMiss`
  * calls what it returned empty, and a listing's exchange is one its symbol does
@@ -797,14 +885,7 @@ export async function loadForListing<T>(
     value = await load();
   } catch (error) {
     await checkVenues();
-    if (request && all.length === 1 && isNoProviderError(error)) {
-      const [other, fate] = await Promise.all([otherListingsMessage(all[0]!, deps, request), request.fate?.() ?? null]);
-      // Nothing served either way: a company that moved is under its new symbol, before any other listing.
-      const moved = movedAwayChange(fate?.change);
-      if (moved) failMovedSymbol(moved, request);
-      if (other) ctx.fail(other.message, [fate?.note, other.details].filter(Boolean).join("\n"));
-      if (fate?.note) ctx.fail(`${fate.note}.`);
-    }
+    if (request && all.length === 1 && isNoProviderError(error)) await failUnservedListing(ctx, request, otherListingsMessage(all[0]!, deps, request));
     throw error;
   }
   if (isMiss?.(value)) await checkVenues();
@@ -836,8 +917,85 @@ export async function loadSavedListing(store: ListingStore, listing: ListingArg)
   return null;
 }
 
+/**
+ * The listings a typed symbol may be saved as, most likely first. With a
+ * vendor's suffix, its venue's listing (GARAN.IS as GARAN:BIST, 7203.T as
+ * 7203:JPX), then the suffixed key as typed, for a row saved under it: a
+ * broker's, or MKC.V, a US share class the suffix only looks like. A
+ * one-letter suffix's venue is a guess that a row saved there confirms
+ * (`loadSavedListingOf`). One listing for anything else.
+ */
+export function savedListingCandidates(raw: string, exchangeOption?: string | null, options: { ownExchangeWins?: boolean } = {}): ListingArg[] {
+  const literal = parseListingArg(raw, exchangeOption, options);
+  const venue = literal.exchange ? null : listingSuffixCandidate(literal.symbol);
+  if (!venue) return [literal];
+  return [{ symbol: venue.symbol, exchange: venue.exchange, key: `${venue.symbol}:${venue.exchange}`, ...literal.readAs ? { readAs: literal.readAs } : {} }, literal];
+}
+
+/**
+ * The first of the listings that is saved, with its row; one `wanted` says is
+ * meant (held in the list a command changes) before any other. Null when none is.
+ */
+export async function loadSavedListingOf(
+  store: ListingStore,
+  listings: readonly ListingArg[],
+  wanted?: (ticker: TickerRecord) => boolean,
+): Promise<{ listing: ListingArg; ticker: TickerRecord } | null> {
+  const found: Array<{ listing: ListingArg; ticker: TickerRecord }> = [];
+  const add = (listing: ListingArg, ticker: TickerRecord | null | undefined) => {
+    if (ticker && !found.some((entry) => entry.ticker.metadata.ticker === ticker.metadata.ticker)) found.push({ listing, ticker });
+  };
+  for (const listing of listings) {
+    if (found.some((entry) => entry.listing.key === listing.key)) continue;
+    const ticker = await loadSavedListing(store, listing);
+    add(listing, ticker);
+    // A suffixed key as typed may be saved with a venue (7203.T:JPX, GARAN.IS:XNYS): any row of that symbol.
+    if (!ticker && !listing.exchange && tickerHasListingSuffix(listing.symbol)) {
+      for (const row of await store.loadAllTickers()) {
+        if (parsePublicTickerKey(row.metadata.ticker).symbol === listing.symbol) add(listing, row);
+      }
+    }
+  }
+  return (wanted && found.find((entry) => wanted(entry.ticker))) || found[0] || null;
+}
+
+/**
+ * The saved row a command that changes a list names, and the listing it was
+ * found as: one of `savedListingCandidates`, with no request when one is
+ * saved (a broker's GARAN.IS while GARAN:BIST has no row), else the typed
+ * listing as `requireListingArg` checks it, which fails the command when it
+ * is no listing. The row is null when that listing has none.
+ */
+export async function requireSavedListing(
+  raw: string,
+  exchangeOption: string | null | undefined,
+  ctx: Pick<CliCommandContext, "fail" | "initMarketData">,
+  store: ListingStore,
+  wanted?: (ticker: TickerRecord) => boolean,
+): Promise<{ listing: ListingArg; ticker: TickerRecord | null }> {
+  let candidates: ListingArg[] = [];
+  try {
+    candidates = savedListingCandidates(raw, exchangeOption);
+  } catch {
+    // Intentional ignore: requireListingArg below fails with what is wrong with the text.
+  }
+  const saved = await loadSavedListingOf(store, candidates, wanted);
+  if (saved) return saved;
+  const listing = await requireListingArg(raw, exchangeOption, ctx, { listingSuffix: true });
+  return { listing, ticker: (await loadSavedListingOf(store, [listing], wanted))?.ticker ?? null };
+}
+
+/** A row saved under a vendor's suffixed key (RY.TO) for the listing it was read as: on that venue, or on none it names. */
+async function loadSuffixedRow(store: ListingStore, key: string, exchange: string): Promise<TickerRecord | null> {
+  const ticker = await store.loadTicker(key);
+  const savedExchange = canonicalExchange(ticker?.metadata.exchange);
+  return ticker && (!savedExchange || savedExchange === exchange) ? ticker : null;
+}
+
 export interface CliListing extends ListingArg {
   saved: TickerRecord | null;
+  /** What was typed for it, as written (`Apple`), so a word no listing trades as can be read as a company's name. */
+  typed?: string;
   /**
    * What data requests take: a named listing goes by its key (SAN:EPA), never
    * the bare symbol's cache; a bare symbol goes on its saved venue, as the
@@ -889,22 +1047,47 @@ async function readVenueSuffix(listing: ListingArg, deps: Pick<ListingDeps, "dat
   return { symbol: match[1]!, exchange: venue, key, readAs: `Read ${listing.symbol} as ${key}.` };
 }
 
+/** 7203.T as 7203:JPX when a row of 7203 on JPX is saved: a suffix `readListingSuffix` leaves to be confirmed. Null otherwise. */
+async function savedSuffixVenue(listing: ListingArg, store: ListingStore): Promise<ListingArg | null> {
+  const venue = listing.exchange ? null : listingSuffixCandidate(listing.symbol);
+  if (!venue) return null;
+  const candidate = { symbol: venue.symbol, exchange: venue.exchange, key: `${venue.symbol}:${venue.exchange}` };
+  if (!await loadSavedListing(store, candidate)) return null;
+  return listing.readAs ? { ...candidate, readAs: listing.readAs } : candidate;
+}
+
+/** GARAN.IS as GARAN:BIST: a vendor's venue suffix read as the venue it names (`listingSuffixVenue`), with no request. */
+function readListingSuffix(listing: ListingArg): ListingArg | null {
+  const venue = listing.exchange ? null : listingSuffixVenue(listing.symbol);
+  return venue ? { symbol: venue.symbol, exchange: venue.exchange, key: `${venue.symbol}:${venue.exchange}` } : null;
+}
+
 export async function resolveCliListing(
   raw: string,
   exchangeOption: string | null | undefined,
   deps: ListingDeps,
   options: {
     ownExchangeWins?: boolean;
-    /** Read a venue suffix (RY.TO) as the listing its quote names (RY:TSX): `fn` and `shot`, whose functions read data by venue. */
+    /**
+     * Read a venue suffix (RY.TO) as the listing its quote names (RY:TSX).
+     * Only pane functions ask for it (`applyListingArgument`, which `fn` and
+     * `shot` run through), as their data is read by venue.
+     */
     venueSuffix?: boolean;
+    /** Read a venue suffix as the venue it names, with no request (`parseListingArg`). */
+    listingSuffix?: boolean;
   } = {},
 ): Promise<CliListing> {
   // "JPM US Equity" is Bloomberg's code for JPM; "Putnam US Equity", whose root is no US ticker, is a name.
   const typed = stripStrayEdges(raw).text || raw;
-  const terminal = await readTerminalCodeArg(deps.dataProvider, typed);
+  const read = await readTerminalCodeArg(deps.dataProvider, typed);
   // A company's name, an entry of a comma list (`WHR, Whirlpool Corporation`), is the listing search names for it.
-  const named = terminal ? null : await companyNameListingArg(raw, deps);
-  let parsed = named ?? parseListingArg(raw, exchangeOption, { ...options, terminalCodes: terminal != null });
+  // A name before a legal form ("SAP SE", "SIEMENS AG") is looked up first: SE is also SIX Swiss's market code.
+  const named = !read || endsInLegalForm(typed) ? await companyNameListingArg(raw, deps) : null;
+  const terminal = named ? null : read;
+  // "AAPL GP" is written as a code, with a market code no venue answers to and no company's name: one entry, never AAPL and GP.
+  if (!terminal && !named) await refuseUnknownMarketCode(typed, deps);
+  let parsed = named ?? parseListingArg(raw, exchangeOption, { ...options, terminalCode: terminal });
   if (!parsed.symbol) throw new ListingArgError("Ticker symbol is required.");
   // $VIX is Schwab's code for ^VIX, unless a security trades as VIX: $AAPL is a cashtag.
   const index = named || parsed.exchange ? null : await readDollarIndexCode(raw, deps);
@@ -912,29 +1095,76 @@ export async function resolveCliListing(
   // USD-NGN and USDNGN are the pair USDNGN=X unless a security is listed under those letters.
   const pair = parsed.exchange ? null : await readAmbiguousCurrencyPair(parsed.symbol, deps);
   if (pair) parsed = { symbol: pair, exchange: "", key: pair };
-  const suffixed = pair || named || !options.venueSuffix ? null : await readVenueSuffix(parsed, deps);
-  if (suffixed) parsed = parsed.readAs ? { ...suffixed, readAs: `${parsed.readAs} ${suffixed.readAs}` } : suffixed;
+  // A one-letter suffix (7203.T) is read as its venue only when a row saved there says so; the listing's quote may later.
+  const venueRow = options.listingSuffix && !pair && !named ? await savedSuffixVenue(parsed, deps.store) : null;
+  if (venueRow) parsed = venueRow;
+  const suffixed = pair || named || venueRow || !options.venueSuffix ? null : await readVenueSuffix(parsed, deps);
+  // The row may be saved under the suffixed key itself: a link or a layout's key is kept as it came.
+  const typedKey = suffixed ? parsed.symbol : null;
+  if (suffixed) {
+    const readAs = [parsed.readAs, suffixed.readAs].filter(Boolean).join(" ");
+    parsed = { ...suffixed, ...readAs ? { readAs } : {} };
+  }
   try {
-    await checkListingExchange(parsed, deps);
+    // A code's venue is one the app reads; where search alone knows it (`BBCA IJ`) or the codes differ (`DBS SP`), search says what trades there.
+    if (terminal?.market && parsed.exchange === terminal.exchange) await checkTerminalCodeVenue(parsed, terminal.market, deps);
+    else await checkListingExchange(parsed, deps);
   } catch (error) {
     const market = error instanceof ListingArgError ? await builderDexMarket(parsed, deps) : null;
     if (!market) throw error;
     parsed = market;
   }
   let listing = await settleSharedCode(parsed, deps);
-  const saved = await loadSavedListing(deps.store, listing);
+  const saved = await loadSavedListing(deps.store, listing) ?? (typedKey ? await loadSuffixedRow(deps.store, typedKey, listing.exchange) : null);
   // A code nothing could read stays the venue it is saved on.
   const savedExchange = canonicalExchange(saved?.metadata.exchange);
   if (listing.sharedCode && savedExchange) listing = { symbol: listing.symbol, exchange: savedExchange, key: `${listing.symbol}:${savedExchange}` };
   return {
     ...listing,
     saved,
+    typed: typed.trim(),
     request: listing.exchange
       ? { symbol: listing.key, exchange: listing.exchange }
       : { symbol: listing.symbol, exchange: saved?.metadata.exchange ?? "" },
   };
 }
 
+/**
+ * Fails a line written as a Bloomberg code whose market code no venue answers
+ * to (`AAPL GP`), suggesting the code of the symbol's own listing (`AAPL
+ * US`), where else it trades, and, when the words could be two symbols, how
+ * to write them as two. A real market no source quotes (`SM PM`) says so.
+ * Run once no company's name was found in the words. Returns for anything else.
+ */
+async function refuseUnknownMarketCode(typed: string, deps: ListingDeps): Promise<void> {
+  const unknown = unknownBloombergMarket(typed);
+  if (!unknown) return;
+  const twoSymbols = unknown.keyed ? null : `For two symbols, separate them with a comma: ${unknown.symbol}, ${unknown.market}.`;
+  // A real market no source quotes (PM): the symbol's listings elsewhere are as likely another company's (SM US is SM Energy).
+  if (unknown.unquoted) throw new ListingArgError(`${unknown.market} is the ${unknown.unquoted}, which has no quotes here.`, twoSymbols ?? undefined);
+  const venues = await listingVenues(unknown.symbol, deps).catch(logFailure("cli.listing-arg", "Read listing venues failed", []));
+  const codes = [...new Set(venues.flatMap((venue) => bloombergCodeOf(unknown.symbol, venue.exchange) ?? []))];
+  const also = codes.slice(1, 1 + MAX_OTHER_LISTINGS);
+  const details = [also.length > 0 ? `${unknown.symbol} also trades as ${also.join(", ")}.` : null, twoSymbols].filter(Boolean).join("\n");
+  throw new ListingArgError(`${unknown.market} is not a market code; did you mean ${codes[0] ?? unknown.symbol}?`, details || undefined);
+}
+
+/**
+ * A code's venue where the exchange table has no entry for it (`BBCA IJ` is
+ * JAKARTA) or Bloomberg's ticker is not the venue's code (`MAY MK`, Bursa's
+ * 1155): "MAY does not trade on BURSAMY", with where it does and what to
+ * type instead, rather than an unknown exchange. Returns for a venue the table
+ * knows, which the listing's own request checks, and when search lists the
+ * symbol there or cannot say.
+ */
+async function checkTerminalCodeVenue(listing: ListingArg, market: string, deps: ListingDeps): Promise<void> {
+  const hint = bloombergMarketHint(market);
+  if (!hint && !isSearchOnlyVenue(listing.exchange)) return;
+  const venues = await listingVenues(listing.symbol, deps).catch(logFailure("cli.listing-arg", "Read listing venues failed", []));
+  if (venues.length === 0 || venues.some((venue) => venue.exchange === listing.exchange)) return;
+  throw new ListingArgError(`${listing.symbol} does not trade on ${listing.exchange}.${tradesOn(listing.symbol, venues)}`, hint ?? undefined);
+}
+
 /**
  * The index a broker's code names, as a listing: VIX.X and $VIX.X at once,
  * $VIX when the sources answer that nothing trades as VIX. `$MOVE` stays
@@ -974,11 +1204,52 @@ function readDollarIndexCode(raw: string, deps: Pick<ListingDeps, "dataProvider"
  */
 async function companyNameListingArg(raw: string, deps: ListingDeps): Promise<ListingArg | null> {
   const typed = stripStrayEdges(raw).text || raw;
-  if (!isCompanyNameInput(typed)) return null;
-  const found = await findListingOfCompanyName(deps.dataProvider, typed);
+  return isCompanyNameInput(typed) ? readCompanyName(typed, deps) : null;
+}
+
+/** One word that can be a company's name: letters first, no venue, pair or index mark (`Apple`, `Petrobras`, `Coca-Cola`). */
+const ONE_WORD_NAME = /^\p{L}[\p{L}\p{N}&'’.-]*$/u;
+
+/**
+ * A company's name typed as one word (`Apple`) where a symbol goes, once the
+ * sources said no listing trades as it, read as the listing search names for
+ * it the way a name of several words is (`companyNameListingArg`): "Read
+ * "Apple" as AAPL:NASDAQ (Apple Inc.).". A real ticker never gets here, so it
+ * always wins over a name. A word many names share (`oil`) is a name only
+ * when search puts it first, the service marks it, or a listing's name is
+ * the word alone (`findListingOfCompanyName` with `oneWord`). A coin's name
+ * (`bitcoin`, or any the crypto board lists) and a subject the app knows of
+ * (`carbon`, `freight`) are never read as a company: they keep their own
+ * hint, the coin's pair (BTC-USD) or the search that says where it is. Null
+ * for anything else, and when search names no company or is too busy to say.
+ */
+export async function oneWordCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvider">): Promise<ListingArg | null> {
+  const word = typed.trim();
+  if (!ONE_WORD_NAME.test(word) || knownGapMessage(word) || isMajorCoinName(word)) return null;
+  const named = await readCompanyName(word, deps, { oneWord: true }).catch((error: unknown) => {
+    if (!isProviderBusy(error)) throw error;
+    // Intentional ignore: a busy search says nothing about the name, so the word keeps its own "Not a ticker".
+    return null;
+  });
+  if (!named) return null;
+  // The board is read only for a word that names a company, and once for the run (`primeBoardCoins`).
+  if (/^[A-Za-z0-9]+$/.test(word)) await primeBoardCoins([`Not a ticker: ${word.toUpperCase()}.`]);
+  return boardCoinFor(word) ? null : named;
+}
+
+function isMajorCoinName(word: string): boolean {
+  const wanted = word.toLowerCase();
+  return [...MAJOR_COIN_NAMES.values()].some((name) => name.toLowerCase() === wanted);
+}
+
+async function readCompanyName(typed: string, deps: Pick<ListingDeps, "dataProvider">, options: { oneWord?: boolean } = {}): Promise<ListingArg | null> {
+  const found = await findListingOfCompanyName(deps.dataProvider, typed, { meant: true, quoted: true, ...options });
   if (!found) return null;
   const key = `${found.symbol}:${found.exchange}`;
-  return { ...parseListingArg(key), readAs: `Read "${typed.trim()}" as ${key} (${found.name}).` };
+  // A fund or an index carrying the name asks about the company's stock: "Did you mean JPM (JPMorgan Chase & Co.)?".
+  const meant = found.meant ? { symbol: found.meant.symbol, name: found.meant.name } : null;
+  const question = meant ? ` ${meantQuestion({ meant })}` : "";
+  return { ...parseListingArg(key), readAs: `Read "${typed.trim()}" as ${key} (${found.name}).${question}`, ...meant ? { meant } : {} };
 }
 
 /** `resolveCliListing` for a command: a bad exchange fails the command with its message. */
@@ -987,7 +1258,7 @@ export async function requireCliListing(
   exchangeOption: string | null | undefined,
   deps: ListingDeps,
   ctx: Pick<CliCommandContext, "fail">,
-  options: { ownExchangeWins?: boolean } = {},
+  options: { ownExchangeWins?: boolean; venueSuffix?: boolean } = {},
 ): Promise<CliListing> {
   try {
     return await resolveCliListing(raw, exchangeOption, deps, options);
@@ -1005,9 +1276,10 @@ export async function requireListingArg(
   raw: string,
   exchangeOption: string | null | undefined,
   ctx: Pick<CliCommandContext, "fail" | "initMarketData">,
+  options: { listingSuffix?: boolean } = {},
 ): Promise<ListingArg> {
   try {
-    const listing = parseListingArg(raw, exchangeOption);
+    const listing = parseListingArg(raw, exchangeOption, options);
     if (listing.symbol.endsWith(":") || (listing.exchange && !isKnownExchangeCode(listing.exchange)) || listing.sharedCode) {
       return await withMarketData(ctx, async (market) => {
         await checkListingExchange(listing, market);