@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/telemetry/stall-reports.ts

@@ -0,0 +1,214 @@
+import { logFailure } from "../utils/log-failure";
+import type { StallEvent } from "../utils/main-thread-stall";
+import { VERSION } from "../version";
+import { reportCrash } from "./crash-reports";
+
+/**
+ * Freezes, made visible outside the app's own Debug Log.
+ *
+ * The stall monitor (utils/main-thread-stall.ts) notices when a process could
+ * not answer the user for a while and names the last measured section, and
+ * hands the stall to its sink. The terminal app and the desktop app's Bun
+ * process record their own stalls here; the desktop window sends the stalls
+ * it had in front of the user (stall-reports-dom.ts) to the Bun process,
+ * which records them too. Where a host is installed, each
+ * stall:
+ *
+ * - goes to a plain-text stall log in the profile folder, one line each, so a
+ *   user or support can read what froze and when;
+ * - from a second up, counts toward a report sent through the crash reporter
+ *   (and so behind the same off switch), the way update failures are: the
+ *   duration bucket, the section's fixed name, the process, the longest
+ *   stall and how many there were. No free text: a section name keeps only
+ *   its fixed leading part, so a ticker in a queue key never leaves.
+ *
+ * One report per process, bucket, section and app version a day; stalls of
+ * the same kind after that are counted and carried in the next report.
+ */
+
+/** Which process stalled. */
+export type StallProcess = "window" | "app" | "terminal";
+
+/** What error tracking gets: fixed values only. */
+export interface StallReport {
+  process: StallProcess;
+  bucket: StallBucket;
+  section: string;
+  appVersion: string;
+  platform: "macos" | "windows" | "linux" | "other";
+  arch: "arm64" | "x64" | "other";
+  /** Stalls of this kind since the last report, this one included. */
+  count: number;
+  /** The longest of them, rounded to 100 ms. */
+  longestMs: number;
+}
+
+type StallBucket = "1-2s" | "2-5s" | "5-15s" | "15s+";
+
+/** What the host keeps on disk between launches. */
+export interface StallReportState {
+  /** When each kind was last reported, in ms. */
+  sent: Record<string, number>;
+  /** Stalls counted since each kind was last reported. */
+  pending: Record<string, { count: number; longestMs: number }>;
+}
+
+export interface StallReporterHost {
+  /** The running version; defaults to this build's. */
+  appVersion?: string;
+  platform: string;
+  arch: string;
+  /** Appends one line to the stall log. */
+  appendLog(line: string): void;
+  load(): StallReportState;
+  save(state: StallReportState): void;
+  now?(): number;
+  /** Defaults to the crash reporter. */
+  send?(report: StallReport): void;
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** Shorter freezes go to the log only. */
+const STALL_REPORT_MIN_MS = 1_000;
+const SECTION_PATTERN = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*/;
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]{1,60})?$/;
+/** Kinds with counts waiting for their next report; the oldest go first past this. */
+const MAX_KINDS_KEPT = 200;
+
+let host: StallReporterHost | null = null;
+
+/** The fixed part of a section name: lower-case dotted words, cut where anything else starts. */
+function stallSectionName(name: string | undefined): string {
+  if (!name) return "unmeasured";
+  const match = SECTION_PATTERN.exec(name);
+  const section = match?.[0].replace(/\.$/, "");
+  return section && section.length <= 80 ? section : "unmeasured";
+}
+
+function stallBucket(blockedMs: number): StallBucket {
+  if (blockedMs < 2_000) return "1-2s";
+  if (blockedMs < 5_000) return "2-5s";
+  if (blockedMs < 15_000) return "5-15s";
+  return "15s+";
+}
+
+/** A stall another process sent over, kept only when it has the right shape. */
+export function parseStallEvent(value: unknown): StallEvent | null {
+  if (!value || typeof value !== "object") return null;
+  const { blockedMs, lastMeasured, lastMeasuredEndedMsAgo } = value as Record<string, unknown>;
+  if (typeof blockedMs !== "number" || !Number.isFinite(blockedMs) || blockedMs <= 0) return null;
+  return {
+    blockedMs,
+    ...(typeof lastMeasured === "string" && lastMeasured.length <= 200 ? { lastMeasured } : {}),
+    ...(typeof lastMeasuredEndedMsAgo === "number" && Number.isFinite(lastMeasuredEndedMsAgo) ? { lastMeasuredEndedMsAgo } : {}),
+  };
+}
+
+function formatSeconds(ms: number): string {
+  return `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)} s`;
+}
+
+/** One line of the stall log: when, which process, how long, and what ran last. */
+function formatStallLogLine(process: StallProcess, event: StallEvent, at: number): string {
+  const time = new Date(at).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const last = event.lastMeasured
+    ? `last measured: ${event.lastMeasured}${event.lastMeasuredEndedMsAgo === undefined ? "" : `, ended ${Math.round(event.lastMeasuredEndedMsAgo)} ms before`}`
+    : "nothing measured before it";
+  return `${time}  ${process.padEnd(8)}  froze ${formatSeconds(event.blockedMs).padStart(6)}  ${last}`;
+}
+
+function reportPlatform(platform: string): StallReport["platform"] {
+  if (platform === "darwin") return "macos";
+  if (platform === "win32") return "windows";
+  if (platform === "linux") return "linux";
+  return "other";
+}
+
+function reportArch(arch: string): StallReport["arch"] {
+  return arch === "arm64" || arch === "x64" ? arch : "other";
+}
+
+function sendThroughCrashReporter(report: StallReport): void {
+  const details = [
+    `process=${report.process}`,
+    `count=${report.count}`,
+    `longest=${report.longestMs}ms`,
+    `platform=${report.platform}-${report.arch}`,
+  ].join(" ");
+  // A plain object, not an Error: it has no stack, so no file path goes along.
+  // The message is the bucket and section, so error tracking keeps one issue per kind.
+  reportCrash(
+    { name: "MainThreadStall", message: `${report.bucket} after ${report.section}` },
+    { kind: "plugin", plugin: "stall-monitor", pane: details },
+  );
+}
+
+function loadState(current: StallReporterHost): StallReportState {
+  try {
+    const state = current.load();
+    return { sent: { ...state.sent }, pending: { ...state.pending } };
+  } catch (error) {
+    logFailure("telemetry-stalls", "Could not read stall report state")(error);
+    return { sent: {}, pending: {} };
+  }
+}
+
+function prune(state: StallReportState, now: number): void {
+  for (const [key, at] of Object.entries(state.sent)) {
+    if (!(now - at < DAY_MS) || at > now) delete state.sent[key];
+  }
+  const kinds = Object.keys(state.pending);
+  for (const key of kinds.slice(0, Math.max(0, kinds.length - MAX_KINDS_KEPT))) delete state.pending[key];
+}
+
+/** Records one stall of `process`. Does nothing where no host is installed; never throws. */
+export function recordStall(process: StallProcess, event: StallEvent): void {
+  const current = host;
+  if (!current || !(event.blockedMs > 0)) return;
+  try {
+    const now = current.now?.() ?? Date.now();
+    current.appendLog(formatStallLogLine(process, event, now));
+    if (event.blockedMs < STALL_REPORT_MIN_MS) return;
+    const appVersion = (current.appVersion ?? VERSION).trim().replace(/^v/, "");
+    const section = stallSectionName(event.lastMeasured);
+    const bucket = stallBucket(event.blockedMs);
+    const version = VERSION_PATTERN.test(appVersion) ? appVersion : "unknown";
+    const key = `${process}|${bucket}|${section}|${version}`;
+    const state = loadState(current);
+    prune(state, now);
+    const pending = state.pending[key] ?? { count: 0, longestMs: 0 };
+    pending.count += 1;
+    pending.longestMs = Math.max(pending.longestMs, Math.round(event.blockedMs / 100) * 100);
+    if (state.sent[key] !== undefined) {
+      state.pending[key] = pending;
+    } else {
+      delete state.pending[key];
+      state.sent[key] = now;
+      (current.send ?? sendThroughCrashReporter)({
+        process,
+        bucket,
+        section,
+        appVersion: version,
+        platform: reportPlatform(current.platform),
+        arch: reportArch(current.arch),
+        count: pending.count,
+        longestMs: pending.longestMs,
+      });
+    }
+    current.save(state);
+  } catch (error) {
+    logFailure("telemetry-stalls", "Could not record a stall")(error);
+  }
+}
+
+export function installStallReporter(next: StallReporterHost): () => void {
+  host = next;
+  return () => {
+    if (host === next) host = null;
+  };
+}
+
+/** Test seam. */
+export function resetStallReporterForTests(): void {
+  host = null;
+}

package/src/test-support/preload.ts

@@ -0,0 +1,14 @@
+import { beforeEach } from "bun:test";
+import { resetCrashReporterForTests } from "../telemetry/crash-reports";
+
+/**
+ * `bun test` runs every file in one process, so module state outlives the file
+ * that set it. A crash report queued while no reporter is installed, such as a
+ * plugin that fails to register in an app runtime test, would wait in the
+ * queue and go out with the next reporter another file installs, and its key
+ * would keep a later identical report from being queued at all. Every test
+ * starts with no reporter, an empty queue and nothing seen.
+ */
+beforeEach(() => {
+  resetCrashReporterForTests();
+});

package/src/theme/themes.ts

@@ -745,6 +745,16 @@ const THEME_TRAITS: Readonly<Record<string, readonly ThemeTrait[]>> = {
   "high-contrast": ["high-contrast", "colorblind-safe"],
 };
 
+/**
+ * Whether a theme's gains and losses are told apart by something other than
+ * the red and green everyone reads: a color-blind safe theme's blue and
+ * vermillion, which a chart keys (`▲▼` beside a candle series) so a reader
+ * knows which is which.
+ */
+export function themeKeysDirection(id: string): boolean {
+  return (THEME_TRAITS[id] ?? []).includes("colorblind-safe");
+}
+
 export interface ThemeSummary {
   id: string;
   name: string;

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

@@ -1,5 +1,6 @@
 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";
@@ -12,7 +13,7 @@ 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;
@@ -22,8 +23,24 @@ export interface CompanyNameListing {
    * 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;
@@ -70,7 +87,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;
@@ -110,8 +127,12 @@ export async function findListingOfCompanyName(
   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 };
+  const quoted = options.quoted ? await firstQuoted(dataProvider, lines, options.movedLine) : { line: first, 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 };
   const meant = best.stock && options.meant ? await stockNamedRunTogether(dataProvider, name, results) : null;
   return meant ? { ...found, meant } : found;
 }
@@ -127,22 +148,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,11 +191,11 @@ 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. */

package/src/tickers/company-name.ts

@@ -99,12 +99,53 @@ export function companyNameMatch(typed: string, name: string | null | undefined)
   return { extra: words.size - matched.size, abbreviated };
 }
 
-/** Items grouped by the company their names are, in the order each company first appears. Unnamed items are left out. */
-export function groupByCompany<T>(items: readonly T[], nameOf: (item: T) => string | null | undefined): T[][] {
+// Words one fund's venues name it with or without: "iShares MSCI Japan Index Fund" in New York is "iShares MSCI Japan ETF" in Mexico.
+const FUND_NOISE = new Set(["etf", "etfs", "fund", "funds", "index", "trust", "ucits"]);
+
+function instrumentWords(name: string | null | undefined): Set<string> {
+  return new Set([...companyWords(name)].filter((word) => !FUND_NOISE.has(word)));
+}
+
+/**
+ * Whether two venues' names can be one instrument's: one company's
+ * (`sameCompany`), or one fund's however a venue words it, with or without
+ * "ETF", "Index Fund" or "Trust" ("Technology Select Sector SPDR Fund" in
+ * Buenos Aires is State Street's ETF in New York). Two names that are not are
+ * another company's or another fund's ("W.A.G Payment Solutions" is not the
+ * iShares fund, nor "UBS MSCI India" iShares' India fund). An empty name
+ * matches none.
+ */
+export function sameListedName(left: string | null | undefined, right: string | null | undefined): boolean {
+  if (sameCompany(left, right)) return true;
+  const a = instrumentWords(left);
+  const b = instrumentWords(right);
+  if (a.size === 0 || b.size === 0) return false;
+  const [fewer, more] = a.size <= b.size ? [a, b] : [b, a];
+  return [...fewer].every((word) => more.has(word));
+}
+
+/**
+ * Whether a venue names its line a depositary receipt ("Toyota Motor
+ * Corporation CEDEAR", "SS SPDR S&P 500 ETF Trust - CEDEAR"): a receipt of a
+ * line elsewhere, whose short form of that line's name says little of whose it is.
+ */
+export function namesDepositaryReceipt(name: string | null | undefined): boolean {
+  return /\b(?:cedears?|adrs?|ads|cdrs?|cdis?|depositary)\b/i.test(name ?? "");
+}
+
+/**
+ * Items grouped by the company their names are (`same`, `sameCompany` unless
+ * given), in the order each company first appears. Unnamed items are left out.
+ */
+export function groupByCompany<T>(
+  items: readonly T[],
+  nameOf: (item: T) => string | null | undefined,
+  same: (left: string | null | undefined, right: string | null | undefined) => boolean = sameCompany,
+): T[][] {
   const groups: T[][] = [];
   for (const item of items) {
     if (companyWords(nameOf(item)).size === 0) continue;
-    const group = groups.find((members) => members.some((member) => sameCompany(nameOf(member), nameOf(item))));
+    const group = groups.find((members) => members.some((member) => same(nameOf(member), nameOf(item))));
     if (group) group.push(item);
     else groups.push([item]);
   }
@@ -174,10 +215,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;

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/listing-venues.ts

@@ -28,6 +28,17 @@ export interface ListingVenue {
   /** Canonical code. */
   exchange: string;
   name: string;
+  /**
+   * The listing's own symbol there, when search lists it under another
+   * spelling than the one asked for: BP for `BP.` (London's code for it).
+   */
+  symbol?: string;
+}
+
+/** The venue's own symbol, when it is not `asked` (ignoring case). */
+function ownSymbol(listed: string | undefined, asked: string): { symbol: string } | Record<string, never> {
+  const symbol = listed?.trim().toUpperCase();
+  return symbol && symbol !== asked.trim().toUpperCase() ? { symbol } : {};
 }
 
 /**
@@ -50,14 +61,15 @@ export async function listingVenues(symbol: string, { store, dataProvider }: Lis
       : {
         exchange: resolved.result.exchange === "SMART" ? resolved.result.primaryExchange ?? "" : resolved.result.exchange || resolved.result.primaryExchange || "",
         name: resolved.result.name,
+        ...ownSymbol(parsePublicTickerKey(resolved.result.symbol).symbol, symbol),
       };
-    venues = only?.exchange ? [{ exchange: canonicalExchange(only.exchange), name: only.name }] : [];
+    venues = only?.exchange ? [{ ...only, exchange: canonicalExchange(only.exchange) }] : [];
   } catch (error) {
     // One listing settles the picker; several are its choices.
     if (!(error instanceof AmbiguousTickerError) || error instanceof AmbiguousContractError) return [];
     venues = error.listings.flatMap((listing) => {
-      const exchange = parsePublicTickerKey(listing).exchange;
-      return exchange ? [{ exchange, name: error.listingNames[listing] ?? "" }] : [];
+      const key = parsePublicTickerKey(listing);
+      return key.exchange ? [{ exchange: key.exchange, name: error.listingNames[listing] ?? "", ...ownSymbol(key.symbol, symbol) }] : [];
     });
   }
   return venues.filter((venue, index) => venues.findIndex((other) => other.exchange === venue.exchange) === index);

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";
@@ -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.

package/src/tickers/terminal-codes.ts

@@ -412,6 +412,25 @@ export interface NearMissListing {
   symbol: string;
 }
 
+/**
+ * `BP.`, `RR.`: London's code for a company with a two-letter symbol, which
+ * the exchange writes with a dot to make three. No other venue writes a
+ * trailing dot, though one can trail a US ticker by slip (`GE.`).
+ */
+const LONDON_DOTTED = /^([A-Z]{2})\.$/;
+
+/**
+ * A two-letter symbol written with London's trailing dot (`BP.`): what was
+ * typed and the symbol (BP). Whether it is London's line (BP:LSE) or a US
+ * ticker with a stray dot (`GE.`) is for where London lists it to say
+ * (`resolveCliListing`). Null for anything else.
+ */
+export function readLondonDottedSymbol(raw: string): NearMissListing | null {
+  const typed = raw.trim();
+  const london = LONDON_DOTTED.exec(typed.toUpperCase());
+  return london ? { typed, symbol: london[1]! } : null;
+}
+
 /** `BRK/B`: a US share class after a slash, as a broker writes it. One letter before the slash is a ratio or an abbreviation (P/E, N/A). */
 const SLASH_CLASS = /^([A-Z]{2,5})\/([A-Z])$/;
 /** `700.HK`: a Hong Kong code without its leading zeros. */