gloomberb 0.19.0 → 0.19.2

package/src/tickers/company-name-listing.ts

@@ -1,10 +1,11 @@
 import { logFailure } from "../utils/log-failure";
 import type { DataProvider } from "../types/data-provider";
+import type { Quote } from "../types/financials";
 import type { InstrumentSearchResult } from "../types/instrument";
 import { canonicalExchange, isUsListingExchange, parsePublicTickerKey } from "../utils/exchanges";
-import { companyNameMatch, sameCompany, shortCompanyName } from "./company-name";
+import { companyLines, companyNameExtraWords, companyNameMatch, namedByService, runTogether, shortCompanyName } from "./company-name";
 import { LISTING_SEARCH_LIMIT } from "./search";
-import { lineDistance } from "./search/home-listing";
+import { lineDistance, primaryCompanyLine } from "./search/home-listing";
 import { classifyInstrumentKind, isCryptoInstrumentType } from "./search/ranking";
 import { isProviderBusy, type ProviderBusyError } from "../sources/provider-errors";
 import { readTerminalListingCode, type TerminalListing, type TerminalListingCode } from "./terminal-codes";
@@ -12,18 +13,36 @@ import { hasNonLatinLetters } from "../utils/typed-text";
 
 export interface CompanyNameListing {
   symbol: string;
-  /** Canonical code of its exchange. */
+  /** Canonical code of its exchange; empty for a US symbol read bare (a line its company `moved` to). */
   exchange: string;
   /** The listing's name as search gives it. */
   name: string;
+  /** The service marked the listing with the name as typed (`searchAliases`): the company it means by it. */
+  named?: true;
   /**
    * When the listing is a fund or an index carrying the name ("JP Morgan" read
    * as ^JTEK, JP MORGAN ETF TRUS), the company's common stock the name says
    * run together (JPM, JPMorgan Chase & Co.), which the reader is asked about.
    */
   meant?: Omit<CompanyNameListing, "meant">;
+  /**
+   * When the company's US line, which search still lists, moved to another
+   * symbol and this is the line it trades as now (GETY became GETYQ): the
+   * change in one line, "GETY became GETYQ on 2026-10-22".
+   */
+  moved?: string;
 }
 
+/**
+ * Where a listing's company trades now when it moved off the symbol (GETY
+ * became GETYQ on 2026-10-22), from the line's quote (null when it has none)
+ * and the name search gives it: the symbol it took, and the change in one
+ * line. Null when it did not move, or that cannot be told.
+ */
+export type MovedLineLookup = (
+  listing: { symbol: string; exchange: string; quote: Quote | null; name: string | null },
+) => Promise<{ symbol: string; note: string } | null>;
+
 /** Share lines that are not the company's common stock, though search may type them as such. */
 const NOT_COMMON = /preferred|warrant|right|unit|note|bond|debenture/i;
 const RECEIPT = /depositary|^(?:ADR|ADS|GDR|CDR|BDR)$/i;
@@ -50,7 +69,10 @@ export function isCompanyNameInput(input: string): boolean {
  * depositary receipt (SAP's NYSE line for "SAP SE"), so a receipt is the
  * listing only of a company listed by receipts alone (PDD); then the row the
  * service marks with the name, a US line, the shortest symbol (WHR before
- * WHR-A) and search's order. The row the service marks with the name as typed
+ * WHR-A) and search's order. The first then gives way to the line `search`
+ * calls the company's primary listing (`primaryCompanyLine`), though its name
+ * says more: "lufthansa" is LHA on XETRA, not LUFTHANSA on Budapest, a
+ * cross-listing with no search score. The row the service marks with the name as typed
  * (`searchAliases`: JPM for "JP Morgan", SIE for "SIEMENS AG", though its name
  * is Siemens Aktiengesellschaft) is named by it exactly. Contracts, preferred
  * shares and notes are never the listing. With `quoted`, a listing with no
@@ -70,7 +92,7 @@ export function isCompanyNameInput(input: string): boolean {
 export async function findListingOfCompanyName(
   dataProvider: Pick<DataProvider, "search"> & Partial<Pick<DataProvider, "getQuote">>,
   typed: string,
-  options: { meant?: boolean; oneWord?: boolean; quoted?: boolean } = {},
+  options: { meant?: boolean; oneWord?: boolean; quoted?: boolean; movedLine?: MovedLineLookup } = {},
 ): Promise<CompanyNameListing | null> {
   const name = typed.trim();
   if (!name) return null;
@@ -78,40 +100,62 @@ export async function findListingOfCompanyName(
   const answers = await Promise.all(queries.map((query) => searchListings(dataProvider, query)));
   const busy = answers.find(isProviderBusy);
   const results = answers.flatMap((answer) => Array.isArray(answer) ? answer : []);
-  const ranked = results.flatMap((result, order) => {
+  const listed = results.flatMap((result, order) => {
     const exchange = listedExchange(result);
     const type = listedType(result);
     const named = namedByService(name, result);
     const match = named ? { extra: 0, abbreviated: 0 } : companyNameMatch(name, result.name);
     if (!exchange || match == null || classifyInstrumentKind(type) === "derivative" || NOT_COMMON.test(type)
       || parsePublicTickerKey(result.symbol).exchange) return [];
-    if (options.oneWord && (match.abbreviated > 0 || isCryptoInstrumentType(type) || !(order === 0 || named || match.extra === 0))) return [];
+    // A word alone names a company by these lines only; the company's other lines are still its lines.
+    const namesCompany = !(options.oneWord && (match.abbreviated > 0 || isCryptoInstrumentType(type) || !(order === 0 || named || match.extra === 0)));
     // A receipt is a company's shares too, however search types it ("Depositary Receipt" or "American Depositary Receipt").
     const stock = classifyInstrumentKind(type) === "equity" || RECEIPT.test(type) ? 0 : 1;
     const home = result.homeListing === true;
     const line = home ? 0 : 1 + lineDistance(type, exchange, result.symbol);
     return [{
-      result, exchange, stock, home,
+      result, exchange, stock, home, namesCompany,
       rank: [match.extra, match.abbreviated, stock, line, named ? 0 : 1, isUsListingExchange(exchange) ? 0 : 1, result.symbol.length, order],
     }];
   }).sort((left, right) => {
     const at = left.rank.findIndex((value, index) => value !== right.rank[index]);
     return at < 0 ? 0 : left.rank[at]! - right.rank[at]!;
   });
-  const first = ranked[0];
+  const first = listed.find((listing) => listing.namesCompany);
   // Listings are named in Latin letters: a name in another script ("任天堂 ソニー") names none, answered or not.
   if (!first && busy && !hasNonLatinLetters(name)) throw busy;
   if (!first) return null;
-  // The first may give way to its company's other lines: as near the name and of its kind. Another line the
-  // service marks as a home is another company's (Siemens Ltd. on NSE, for "SIEMENS AG"), and so is a line
-  // named as that one is (Siemens Ltd. on BSE).
-  const otherHomes = new Set(ranked.filter((listing) => listing.home && listing !== first).map(({ result }) => plainName(result.name)));
-  otherHomes.delete(plainName(first.result.name));
-  const lines = ranked.filter((listing) => listing === first || (!listing.home && !otherHomes.has(plainName(listing.result.name))
-    && sameCompany(first.result.name, listing.result.name)
-    && listing.rank.slice(0, NAME_RANKS).every((value, index) => value === first.rank[index])));
-  const best = options.quoted ? await firstQuoted(dataProvider, lines) : first;
-  const found = { symbol: best.result.symbol.toUpperCase(), exchange: best.exchange, name: best.result.name };
+  // Another line the service marks as a home is another company's (Siemens Ltd. on NSE, for "SIEMENS AG"), and
+  // so is a line named as that one is (Siemens Ltd. on BSE).
+  const otherHomesThan = (lead: typeof first) => {
+    const homes = new Set(listed.filter((listing) => listing.home && listing !== lead).map(({ result }) => plainName(result.name)));
+    homes.delete(plainName(lead.result.name));
+    return homes;
+  };
+  // The listing `search` calls the company's primary leads, though its name says more than the one typed: the
+  // name typed opens what a search for it lists first (LHA on XETRA for "lufthansa", not LUFTHANSA on Budapest).
+  const named = namedByService(name, first.result);
+  const firstHomes = otherHomesThan(first);
+  // Never a line of another business its name is in (`companyLines`): Siemens Energy AG is not Siemens AG's.
+  const lead = first.home ? first : primaryCompanyLine(first, companyLines(first, listed, lineFacts).filter((listing) => listing === first
+    || (!listing.home && !firstHomes.has(plainName(listing.result.name)) && listing.stock === first.stock
+    && (!named || companyNameExtraWords(listing.result.name, first.result.name) != null))),
+  ({ result, exchange }) => ({ distance: lineDistance(listedType(result), exchange, result.symbol), score: result.popularity ?? null }),
+  { named });
+  // The lead may give way to its company's other lines: as near the name and of its kind.
+  const otherHomes = otherHomesThan(lead);
+  const lines = [lead, ...companyLines(lead, listed, lineFacts).filter((listing) => listing !== lead && !listing.home
+    && !otherHomes.has(plainName(listing.result.name))
+    && listing.rank.slice(0, NAME_RANKS).every((value, index) => value === lead.rank[index]))];
+  const quoted = options.quoted ? await firstQuoted(dataProvider, lines, options.movedLine) : { line: lead, moved: null };
+  const best = quoted.line;
+  const found: CompanyNameListing = quoted.moved
+    // The line it moved to is a US symbol, read bare as `quote` reads one (GETYQ, which trades over the counter).
+    ? { symbol: quoted.moved.symbol, exchange: "", name: best.result.name, moved: quoted.moved.note }
+    : {
+      symbol: best.result.symbol.toUpperCase(), exchange: best.exchange, name: best.result.name,
+      ...namedByService(name, best.result) ? { named: true as const } : {},
+    };
   const meant = best.stock && options.meant ? await stockNamedRunTogether(dataProvider, name, results) : null;
   return meant ? { ...found, meant } : found;
 }
@@ -127,22 +171,41 @@ interface RankedListing {
   exchange: string;
 }
 
+/** A US exchange, or the US over-the-counter market a line moves to when it leaves one. */
+function isUsVenue(exchange: string): boolean {
+  return isUsListingExchange(exchange) || exchange.startsWith("OTC") || exchange === "PNK";
+}
+
 /**
  * The first of a company's lines, in their order, that has a quote: the first
  * itself, or when it has none, the first of the next few that does, asked
- * together. The first stands when none has a quote, when the source is too
- * busy to say, and when nothing here can ask for quotes.
+ * together. A first US line whose company moved to another symbol (GETY
+ * became GETYQ) is followed there before any other line, so a name never lands
+ * on a listing abroad that still quotes the old shares. The first stands when none has a quote,
+ * when the source is too busy to say, and when nothing here can ask for quotes.
  */
-async function firstQuoted<T extends RankedListing>(dataProvider: Partial<Pick<DataProvider, "getQuote">>, lines: readonly T[]): Promise<T> {
+async function firstQuoted<T extends RankedListing>(
+  dataProvider: Partial<Pick<DataProvider, "getQuote">>,
+  lines: readonly T[],
+  movedLine?: MovedLineLookup,
+): Promise<{ line: T; moved: { symbol: string; note: string } | null }> {
   const first = lines[0]!;
-  if (!dataProvider.getQuote) return first;
-  const quoted = ({ result, exchange }: RankedListing) => dataProvider.getQuote!(result.symbol.toUpperCase(), exchange).then(hasPrice);
+  const only = (line: T) => ({ line, moved: null });
+  if (!dataProvider.getQuote) return only(first);
+  const quoteOf = ({ result, exchange }: RankedListing) => dataProvider.getQuote!(result.symbol.toUpperCase(), exchange);
+  let quote: Quote | null = null;
   try {
-    if (await quoted(first)) return first;
+    quote = await quoteOf(first) ?? null;
   } catch (error) {
     // A busy source says nothing of the listing; any other failure is a listing with no quote.
-    if (isProviderBusy(error)) return first;
+    if (isProviderBusy(error)) return only(first);
+  }
+  if (movedLine && isUsVenue(first.exchange)) {
+    const symbol = first.result.symbol.toUpperCase();
+    const moved = await movedLine({ symbol, exchange: first.exchange, quote, name: first.result.name?.trim() || null });
+    if (moved && moved.symbol.toUpperCase() !== symbol) return { line: first, moved: { ...moved, symbol: moved.symbol.toUpperCase() } };
   }
+  if (hasPrice(quote)) return only(first);
   const keys = new Set([listingKey(first)]);
   const next: T[] = [];
   for (const line of lines) {
@@ -151,14 +214,19 @@ async function firstQuoted<T extends RankedListing>(dataProvider: Partial<Pick<D
     keys.add(listingKey(line));
     next.push(line);
   }
-  const priced = await Promise.all(next.map((line) => quoted(line).catch(() => {
+  const priced = await Promise.all(next.map((line) => quoteOf(line).then(hasPrice).catch(() => {
     // Intentional ignore: a line whose quote fails is a line with no quote.
     return false;
   })));
-  return next.find((_, index) => priced[index]) ?? first;
+  return only(next.find((_, index) => priced[index]) ?? first);
 }
 
 /** A name as two venues may spell it alike: "SIEMENS LTD" for Siemens Ltd. */
+/** A listing as `companyLines` weighs it. */
+function lineFacts({ result, exchange, home }: { result: InstrumentSearchResult; exchange: string; home: boolean }) {
+  return { name: result.name, exchange, receipt: RECEIPT.test(listedType(result)), home };
+}
+
 function plainName(name: string | null | undefined): string {
   return (name ?? "").normalize("NFKD").replace(/\p{M}/gu, "").toUpperCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
 }
@@ -171,6 +239,20 @@ function hasPrice(quote: { price?: number } | null | undefined): boolean {
   return !!quote && Number.isFinite(quote.price) && quote.price !== 0;
 }
 
+/**
+ * Whether search marks a listing under another symbol with the word as typed
+ * (`searchAliases`): "siemens" marks SIE on XETRA, whose symbol is not the
+ * word. One search, the one `findListingOfCompanyName` asks first, so asking
+ * this before it costs nothing more.
+ */
+export async function marksAnotherListing(dataProvider: Partial<Pick<DataProvider, "search">>, word: string): Promise<boolean> {
+  // A source that cannot search marks nothing.
+  if (typeof dataProvider.search !== "function") return false;
+  const answer = await searchListings(dataProvider as Pick<DataProvider, "search">, word.trim());
+  return Array.isArray(answer) && answer.some((result) =>
+    result.symbol.toUpperCase() !== word.trim().toUpperCase() && namedByService(word, result));
+}
+
 function searchListings(dataProvider: Pick<DataProvider, "search">, query: string): Promise<InstrumentSearchResult[] | ProviderBusyError> {
   return dataProvider.search(query, { limit: LISTING_SEARCH_LIMIT })
     .catch((error: unknown): InstrumentSearchResult[] | ProviderBusyError => {
@@ -188,18 +270,6 @@ function listedType(result: InstrumentSearchResult): string {
   return result.brokerContract?.secType || result.type || "";
 }
 
-/** Letters and digits only, in capitals: "JP Morgan" and "JPMorgan" are JPMORGAN. */
-function runTogether(text: string): string {
-  return text.normalize("NFKD").replace(/\p{M}/gu, "").toUpperCase().replace(/[^\p{L}\p{N}]/gu, "");
-}
-
-/** Whether the service marked the row with the name as typed: the company it means by it. */
-export function namedByService(typed: string, result: InstrumentSearchResult): boolean {
-  const wanted = runTogether(typed);
-  return !!wanted && Array.isArray(result.searchAliases)
-    && result.searchAliases.some((alias) => typeof alias === "string" && runTogether(alias) === wanted);
-}
-
 /**
  * The company's common stock on a US exchange whose name starts with the
  * typed words run together ("JPMorgan Chase & Co." for "JP Morgan"), first in

package/src/tickers/company-name.ts

@@ -1,3 +1,5 @@
+import type { InstrumentSearchResult } from "../types/instrument";
+
 /**
  * Company names as venues spell them, compared and shortened for sentences.
  * One company's listings carry its name with different legal forms and share
@@ -9,7 +11,7 @@
 const NAME_NOISE = new Set([
   "co", "company", "corp", "corporation", "inc", "incorporated", "ltd", "limited", "llc", "lp", "plc", "sa", "ag", "nv", "se",
   "spa", "ab", "as", "asa", "oyj", "bv", "gmbh", "kgaa", "bhd", "berhad", "pcl", "the", "adr", "ads", "cedear", "cedears",
-  "sponsored", "unsponsored", "cdr", "cdi",
+  "sponsored", "unsponsored", "cdr", "cdi", "aktiengesellschaft", "aktiebolag",
 ]);
 // Words a venue adds to the share it lists ("Microsoft Corporation Common Stock"), never part of whose it is.
 const SHARE_NOISE = new Set(["common", "ordinary", "stock", "shares"]);
@@ -43,6 +45,56 @@ export function sameCompany(left: string | null | undefined, right: string | nul
   return [...fewer].every((word) => more.has(word));
 }
 
+// Words that tell one class of a company's shares from another ("Berkshire Hathaway Inc. Class B"), never its business.
+const SHARE_CLASS_WORD = /^(?:class|series|[a-z]|\d+)$/;
+
+/** Whether two names differ only in how they name a class of shares, so they are one company's whatever the venue. */
+function sameBusinessWords(left: Set<string>, right: Set<string>): boolean {
+  const differ = [...left].filter((word) => !right.has(word)).concat([...right].filter((word) => !left.has(word)));
+  return differ.every((word) => SHARE_CLASS_WORD.test(word));
+}
+
+/** A company line as `companyLines` weighs it. */
+export interface CompanyLineFacts {
+  name: string | null | undefined;
+  /** The line's canonical venue. */
+  exchange: string;
+  /** A depositary receipt, whose name says whose shares it holds rather than whose it is. */
+  receipt: boolean;
+  /** The service marks it as its company's home line (`homeListing`). */
+  home: boolean;
+}
+
+/**
+ * The lines among `lines` that are `lead`'s company's own (`sameCompany`),
+ * less those under a name that adds words for another business, though one
+ * name's words are all in the other's: Siemens Energy AG and Siemens
+ * Healthineers AG are not Siemens AG, nor Sony Financial Group Sony Group. A
+ * name is another business's where a venue lists a line under it beside a
+ * line under the lead's own name (both on XETRA, both in Tokyo), or where it
+ * and a line under the lead's name are each marked as a home line, since a
+ * company has one (Siemens Ltd. on NSE beside Siemens AG on XETRA). Receipts
+ * are named for the shares they hold, so they never tell two businesses
+ * apart, and nor do words that name a class of shares (Class B). A name with
+ * more words on no shared venue stays the company's (Deutsche Lufthansa AG on
+ * XETRA for LUFTHANSA on Budapest). `lead` is always one of them.
+ */
+export function companyLines<T>(lead: T, lines: readonly T[], facts: (line: T) => CompanyLineFacts): T[] {
+  const own = facts(lead);
+  const ownWords = companyWords(own.name);
+  const ownName = (line: CompanyLineFacts) => sameBusinessWords(companyWords(line.name), ownWords);
+  const candidates = lines.filter((line) => line === lead || sameCompany(own.name, facts(line).name));
+  const read = candidates.map((line) => ({ line, facts: facts(line), words: companyWords(facts(line).name) }));
+  const ownShares = read.filter((entry) => !entry.facts.receipt && ownName(entry.facts));
+  const ownVenues = new Set(ownShares.map((entry) => entry.facts.exchange).filter(Boolean));
+  const ownHome = ownShares.some((entry) => entry.facts.home);
+  // A name another business goes by, once one of its share lines gives it away: all its lines are that business's.
+  const others = read.filter((entry) => !entry.facts.receipt && !ownName(entry.facts)
+    && ((!!entry.facts.exchange && ownVenues.has(entry.facts.exchange)) || (entry.facts.home && ownHome)));
+  const otherBusiness = (words: Set<string>) => others.some((other) => sameBusinessWords(other.words, words));
+  return read.filter((entry) => entry.line === lead || ownName(entry.facts) || !otherBusiness(entry.words)).map((entry) => entry.line);
+}
+
 /**
  * How many words a listing's name has beyond a company name typed for it,
  * which it must have every word of: 0 for the same name however each spells
@@ -215,10 +267,15 @@ function nameWord(word: string, opening: boolean, domain: boolean): string {
  * the way its source means it and comes back as it is.
  */
 export function companyNameCase(name: string): string {
-  if (!/\p{Lu}/u.test(name) || name !== name.toUpperCase()) return name;
+  // A brand that opens in lower case before capitals (aTYR, iROBOT) is still a name in capitals: aTyr, iRobot.
+  const brand = /^\p{Ll}(?=\p{Lu}{2})/u;
+  const capitals = name.split(/\s+/).map((word) => word.replace(brand, "")).join(" ");
+  if (!/\p{Lu}/u.test(name) || capitals !== capitals.toUpperCase()) return name;
   let words = 0;
   return name.replace(/\S+/g, (token) => {
     const opening = words++ === 0;
+    const lead = brand.exec(token)?.[0];
+    if (lead) return `${lead}${token.charAt(1)}${token.slice(2).toLowerCase()}`;
     // A separator inside a word (Coca-Cola, AT&T, Amazon.com, McDonald's) cuts it into words of its own.
     return token.split(/([-/.&,'\u2019]+)/).map((part, index, parts) => {
       if (index % 2 === 1) return part;
@@ -229,3 +286,15 @@ export function companyNameCase(name: string): string {
     }).join("");
   });
 }
+
+/** Letters and digits only, in capitals: "JP Morgan" and "JPMorgan" are JPMORGAN. */
+export function runTogether(text: string): string {
+  return text.normalize("NFKD").replace(/\p{M}/gu, "").toUpperCase().replace(/[^\p{L}\p{N}]/gu, "");
+}
+
+/** Whether the service marked the row with the name as typed: the company it means by it. */
+export function namedByService(typed: string, result: Pick<InstrumentSearchResult, "searchAliases">): boolean {
+  const wanted = runTogether(typed);
+  return !!wanted && Array.isArray(result.searchAliases)
+    && result.searchAliases.some((alias) => typeof alias === "string" && runTogether(alias) === wanted);
+}

package/src/tickers/index-roots.ts

@@ -45,3 +45,10 @@ export function indexRootSuggestion(symbol: string): string | null {
   const root = indexRootFor(symbol);
   return root ? `Did you mean ${root.symbol} (${root.name})?` : null;
 }
+
+/** Cboe's Treasury yield indices: 13-week bill, 5-, 10- and 30-year notes. Each level is a yield in percent. */
+const YIELD_INDEX_SYMBOLS: ReadonlySet<string> = new Set(["^IRX", "^FVX", "^TNX", "^TYX"]);
+
+export function isYieldIndexSymbol(symbol: string): boolean {
+  return YIELD_INDEX_SYMBOLS.has(symbol.trim().toUpperCase());
+}

package/src/tickers/listing-fate.ts

@@ -182,7 +182,7 @@ export function describeListingFate(
  * ended long ago. Only such a line can be a company that moved away, so only
  * its change lookup is waited for.
  */
-function mayHaveMoved(quote: Quote | null, now = Date.now()): boolean {
+export function lineMayHaveMoved(quote: Quote | null, now = Date.now()): boolean {
   return !!quote && (isQuoteBeforeLatestSession(quote, now) || endedTradingDate(quote, now) != null);
 }
 
@@ -206,7 +206,7 @@ export async function loadListingFate(
     // A lookup started beside the command's request gets a short grace once that is ready, so a slow
     // one never holds a symbol that trades. A line that stopped is waited for: only its company can
     // have moved, and then the answer decides whether the command serves anything at all.
-    const changes = await lookup.settle(!options.changes || mayHaveMoved(quote) ? LATE_CHANGE_WAIT_MS : undefined);
+    const changes = await lookup.settle(!options.changes || lineMayHaveMoved(quote) ? LATE_CHANGE_WAIT_MS : undefined);
     return describeListingFate(listing, quote, changes);
   } catch (error) {
     logFailure("tickers-listing-fate", "Could not resolve listing fate")(error);

package/src/tickers/search/home-listing.ts

@@ -1,5 +1,5 @@
-import { canonicalExchange } from "../../utils/exchanges";
-import { companyNameExtraWords, sameCompany } from "../company-name";
+import { canonicalExchange, isUsListingExchange } from "../../utils/exchanges";
+import { companyLines, companyNameExtraWords, namedByService, type CompanyLineFacts } from "../company-name";
 import { answersOnlyByKeyword, isQualifiedTickerQuery } from "./ranking";
 import type { TickerSearchCandidate } from "./types";
 
@@ -29,6 +29,69 @@ export function lineDistance(type: string, exchange: string, symbol: string): 0
   return SECONDARY_VENUES.has(exchange) || /\d/.test(symbol) && /[A-Za-z]/.test(symbol) ? 1 : 0;
 }
 
+/** How the primary-listing choice weighs one of a company's lines. */
+export interface WeighedCompanyLine {
+  /** `listingDistance`: 0 its own line, 1 a line quoting shares listed elsewhere, 2 a receipt. */
+  distance: number;
+  /** The search score the service gives the listings people look up most; null when it gives none. */
+  score: number | null;
+}
+
+/**
+ * The line a company's search lists as its primary listing instead of `lead`,
+ * the line search put first, often the one-off cross-listing whose short name
+ * matched the query (LUFTHANSA on Budapest): its lines go by how far each is
+ * from being its own line, then by the search score. The lead gives way only
+ * to a closer line, or to one searched at least twice as often, or any scored
+ * line when it has no score. With `named` (the service marked the lead with
+ * the name as typed) no score outweighs the mark: only a closer line does.
+ * `lines` holds the lead. `search` and a company's name typed for a listing
+ * (`findListingOfCompanyName`) choose by this one rule, so both open the same
+ * listing.
+ */
+export function primaryCompanyLine<T>(
+  lead: T,
+  lines: readonly T[],
+  weigh: (line: T) => WeighedCompanyLine,
+  options: { named?: boolean } = {},
+): T {
+  const order = (line: T) => lines.indexOf(line);
+  const [home] = [...lines].sort((a, b) => weigh(a).distance - weigh(b).distance
+    || (weigh(b).score ?? -1) - (weigh(a).score ?? -1) || order(a) - order(b));
+  if (!home || home === lead) return lead;
+  const [best, first] = [weigh(home), weigh(lead)];
+  const closer = best.distance < first.distance;
+  const moreSearched = !options.named && best.distance === first.distance && best.score != null
+    && (first.score == null || best.score >= first.score * 2);
+  return closer || moreSearched ? home : lead;
+}
+
+/** A row as `companyLines` weighs it. */
+function lineFacts(candidate: TickerSearchCandidate): CompanyLineFacts {
+  return {
+    name: candidateName(candidate),
+    exchange: candidateExchange(candidate),
+    receipt: listingDistance(candidate) === 2,
+    home: candidate.result?.homeListing === true,
+  };
+}
+
+/** The rows of `lead`'s company among `items` (`companyLines`): never a line of another business its name is in (Siemens Energy for Siemens). */
+function companyRows<T extends TickerSearchCandidate>(lead: T, items: readonly T[]): T[] {
+  return companyLines(lead, items.filter((item) => item === lead || isListedEquity(item)), lineFacts);
+}
+
+/** `primaryCompanyLine` among `items` of `start`'s company, for the command bar's rows. */
+function primaryLineOf<T extends TickerSearchCandidate>(start: T, items: readonly T[], query: string): T {
+  const name = candidateName(start);
+  const named = !!start.result && namedByService(query, start.result);
+  const lines = companyRows(start, items).filter((item) => item === start
+    || !named || companyNameExtraWords(candidateName(item), name) != null);
+  return primaryCompanyLine(start, lines, (item) => ({
+    distance: listingDistance(item), score: item.result?.popularity ?? item.popularity ?? null,
+  }), { named });
+}
+
 function candidateName(candidate: TickerSearchCandidate): string {
   return candidate.result?.name || candidate.detail.split(" | ")[0] || "";
 }
@@ -51,24 +114,46 @@ function isListedEquity(candidate: TickerSearchCandidate): boolean {
  * service marks as the company's home (`homeListing`) takes the lead from
  * the company's first row. Without that mark, a receipt in the lead gives
  * way to the company's own shares on an exchange (`listingDistance` 0, not
- * an OTC or regional line), the name nearest the receipt's first. A query that names a venue (LVMH:TSX,
- * 7203.T) asked for that line, and a saved row keeps the lead.
+ * an OTC or regional line), the name nearest the receipt's first. Then the
+ * line `search` calls the company's primary listing (`primaryCompanyLine`)
+ * takes the lead, so a name opens what `search` lists first: LHA on XETRA
+ * for "lufthansa", not LUFTHANSA on Budapest. A company's lines are never
+ * another business's its name is in (`companyLines`: Siemens Energy AG for
+ * Siemens AG). The row the service marks with the word as typed is the
+ * company the word means, ahead of a line abroad whose symbol is the word:
+ * "siemens" is SIE on XETRA, not SIEMENS on NSE (Siemens Ltd.); a US line
+ * keeps its ticker. A query that names a venue (LVMH:TSX, 7203.T) asked for
+ * that line, and a saved row keeps the lead.
  */
 export function withHomeListingLead<T extends TickerSearchCandidate>(items: T[], query: string): T[] {
   if (isQualifiedTickerQuery(query)) return items;
   const lead = items.find((item) => item.instrumentClass !== "fund" && item.instrumentClass !== "derivative"
     && !answersOnlyByKeyword(item, query));
   if (!lead || !isListedEquity(lead)) return items;
+  const typedSymbol = lead.symbol.toUpperCase() === query.trim().toUpperCase();
+  const meant = typedSymbol && !isUsListingExchange(candidateExchange(lead)) && !(lead.result && namedByService(query, lead.result))
+    // A company's shares under another symbol: an index the code also names (SPX) or the word's own line elsewhere (SAP) is not it.
+    ? items.find((item) => item !== lead && isListedEquity(item) && item.instrumentClass === "equity" && !!item.result
+      && item.symbol.toUpperCase() !== lead.symbol.toUpperCase() && namedByService(query, item.result))
+    : undefined;
+  if (meant) return moveAhead(items, meant, lead);
   const name = candidateName(lead);
-  const lines = items.filter((item) => item !== lead && isListedEquity(item) && sameCompany(name, candidateName(item)));
+  const lines = companyRows(lead, items).filter((item) => item !== lead);
   const nearest = (candidates: T[]) => [...candidates].sort((a, b) => nameGap(name, candidateName(a)) - nameGap(name, candidateName(b))
     || items.indexOf(a) - items.indexOf(b))[0];
   const marked = lines.filter((item) => item.result?.homeListing === true);
+  const own = listingDistance(lead) === 2 ? nearest(lines.filter((item) => listingDistance(item) === 0)) : undefined;
   const home = lead.result?.homeListing === true ? undefined
     : marked.length ? nearest(marked)
-    : listingDistance(lead) === 2 ? nearest(lines.filter((item) => listingDistance(item) === 0))
-    : undefined;
-  if (!home) return items;
+    // A listing searched by its own symbol is that listing, as `search` keeps it.
+    : typedSymbol ? own
+    : primaryLineOf(own ?? lead, [lead, ...lines], query);
+  if (!home || home === lead) return items;
+  return moveAhead(items, home, lead);
+}
+
+/** `items` with `home` moved just ahead of `lead`. */
+function moveAhead<T>(items: readonly T[], home: T, lead: T): T[] {
   const rest = items.filter((item) => item !== home);
   const at = rest.indexOf(lead);
   return [...rest.slice(0, at), home, ...rest.slice(at)];

package/src/tickers/search/index.ts

@@ -7,6 +7,7 @@ import { getListingSymbol, listingSuffixConflictsWithExchange, tickerHasListingS
 import { parseOptionSymbol } from "../../utils/options";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
 import { currencyPairSpelling } from "../../utils/currency-pair";
+import { typedCoinPairListing } from "../../utils/crypto-pair";
 import { assetClassMarketSymbol, parseAssetClassQuery } from "./asset-classes";
 import { bareFuturesCode, futuresContractByCode } from "../../market-data/futures-board";
 import { searchContractKey, searchInstrumentKey } from "./identity";
@@ -53,7 +54,7 @@ export {
   rankTickerSearchItems,
 } from "./ranking";
 export { upsertTickerFromSearchResult } from "./upsert";
-export { candidateExchange, listingDistance } from "./home-listing";
+export { candidateExchange, listingDistance, primaryCompanyLine } from "./home-listing";
 
 const MAX_NAMED_LISTINGS = 6;
 
@@ -387,9 +388,12 @@ export function resolveTickerSearch(options: ResolveTickerSearchOptions): Promis
   // JPY=X are EURUSD=X and USDJPY=X. USD-NGN and USDNGN, which a security could also be written as
   // (MNT-USD is a coin), are the pair only when nothing is listed under those letters.
   const pair = pickListing || future ? null : currencyPairSpelling(typed);
-  const symbol = future?.symbol ?? (pair && !pair.ambiguous ? pair.symbol : typed);
+  // A coin pair written as crypto exchanges write it (BTC/GBP, or BTC/GBP:KRAKEN) is the crypto venue's BTC-GBP,
+  // and what was typed when the venue has no such coin.
+  const coin = pickListing || future || pair || options.tickers.has(typed) ? null : typedCoinPairListing(typed);
+  const symbol = future?.symbol ?? coin?.symbol ?? (pair && !pair.ambiguous ? pair.symbol : typed);
   const literal = resolveTickerSymbol(symbol, options, pickListing ? requested : null);
-  const alternatives = pickListing ? [] : [...dottedVenueQueries(symbol), ...pair?.ambiguous ? [pair.symbol] : []];
+  const alternatives = pickListing ? [] : [...dottedVenueQueries(symbol), ...pair?.ambiguous ? [pair.symbol] : [], ...coin ? [typed] : []];
   // A listing suffix search does not carry (CEZ.PR) is read from its own quote, as `quote` reads it.
   const quoted = !pickListing && tickerHasListingSuffix(symbol) && !parsePublicTickerKey(symbol).exchange;
   // Most input has no venue code to retry: hand back the literal lookup

package/src/tickers/search/ranking.ts

@@ -4,6 +4,7 @@ import type {
 } from "./types";
 import { getListingSymbol, tickerHasListingSuffix } from "../../sources/listing-symbols";
 import { currencyPairCode } from "../../utils/currency-pair";
+import { typedCoinPairListing } from "../../utils/crypto-pair";
 import { canonicalExchange, exchangeCodeVenues, isUsListingExchange, parsePublicTickerKey, typedExchangeCode } from "../../utils/exchanges";
 import { assetClassKeeps, assetClassMarketSymbol, instrumentClassCode, parseAssetClassQuery } from "./asset-classes";
 import { futuresContractByCode } from "../../market-data/futures-board";
@@ -322,9 +323,12 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
       .map(({ item }) => getTickerSearchListingKey(item)),
   );
 
+  // BTC/GBP reads as a currency pair's spelling, and is the crypto venue's BTC-GBP.
+  const coinListing = typedCoinPairListing(query)?.symbol;
   const filtered = ranked.filter(({ item, textScore }) => {
     if (textScore <= 0) return false;
-    if (isExplicitMarketSymbol(query) && !isExplicitMarketSymbol(item.symbol || item.label)) return false;
+    if (isExplicitMarketSymbol(query) && !isExplicitMarketSymbol(item.symbol || item.label)
+      && parsePublicTickerKey(item.symbol || item.label).symbol !== coinListing) return false;
     if (item.kind !== "search") return true;
     return !matchedLocalListings.has(getTickerSearchListingKey(item));
   });

package/src/tickers/search/upsert.ts

@@ -11,6 +11,7 @@ import {
 import { canonicalExchange, parsePublicTickerKey, publicTickerKey } from "../../utils/exchanges";
 import { scopedBrokerContractIdentityKey } from "../../utils/instrument-identity";
 import { listingSuffixVenue } from "../../sources/listing-symbols";
+import { coinPairQuoteCurrency, exchangeLineCoinListing, isCoinRowType } from "../../utils/crypto-pair";
 
 /**
  * The key a result is saved under when its symbol is already saved for
@@ -36,6 +37,18 @@ export async function upsertTickerFromSearchResult(
   result: InstrumentSearchResult,
   options: { tickerSymbol?: string } = {},
 ): Promise<{ ticker: TickerRecord; created: boolean }> {
+  // A crypto exchange's line of a coin pair (BTC/GBP on COINBASE PRO), which no source quotes, is saved as the
+  // crypto venue's listing of the pair (BTC-GBP on CCC), in the currency the pair is quoted in.
+  const coin = result.brokerContract ? null
+    : exchangeLineCoinListing(getSearchResultSymbol(result), listingVenue(result), { coinRow: isCoinRowType(result.type) });
+  if (coin) {
+    result = { ...result, symbol: coin.symbol, exchange: coin.exchange, primaryExchange: undefined, currency: coin.currency };
+    if (options.tickerSymbol) options = { ...options, tickerSymbol: publicTickerKey(coin.symbol, coin.exchange) };
+  } else if (!result.currency && !result.brokerContract && canonicalExchange(listingVenue(result)) === "CCC") {
+    // The venue's own row of a pair (BTC-GBP) often comes without its currency, which the pair names.
+    const currency = coinPairQuoteCurrency(getSearchResultSymbol(result));
+    if (currency) result = { ...result, currency };
+  }
   let symbol = options.tickerSymbol ?? getSearchResultSymbol(result);
   // A vendor's suffixed symbol (GARAN.IS) is saved as the listing it is (GARAN on BIST), under the key
   // GARAN:BIST is saved under, so one listing is one row. A key the caller names is kept as given.