@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/telemetry/stall-reports-node.ts

@@ -1,5 +1,6 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { existsSync, readFileSync, statSync } from "fs";
 import { join } from "path";
+import { makePrivateDirSync, writePrivateFileSync } from "../utils/private-files";
 import type { StallReportState, StallReporterHost } from "./stall-reports";
 
 /** Next to config.json: one line per stall, newest last. */
@@ -31,17 +32,32 @@ function parseStallReportState(text: string): StallReportState {
       if (typeof at === "number" && Number.isFinite(at)) sent[key] = at;
     }
   }
-  return { sent, pending: readCounts(record.pending) };
+  return { sent, pending: readCounts(record.pending), recent: readTimes(record.recent) };
+}
+
+function readTimes(value: unknown): NonNullable<StallReportState["recent"]> {
+  const recent: NonNullable<StallReportState["recent"]> = {};
+  if (!value || typeof value !== "object") return recent;
+  for (const [process, times] of Object.entries(value as Record<string, unknown>)) {
+    if (!Array.isArray(times)) continue;
+    const kept = times.filter((at): at is number => typeof at === "number" && Number.isFinite(at));
+    if (kept.length > 0) recent[process] = kept;
+  }
+  return recent;
 }
 
 function trimLog(path: string): void {
   if (statSync(path).size <= LOG_MAX_BYTES) return;
   const text = readFileSync(path, "utf-8");
   const keep = text.slice(text.length - LOG_MAX_BYTES / 2);
-  writeFileSync(path, keep.slice(keep.indexOf("\n") + 1), "utf-8");
+  writePrivateFileSync(path, keep.slice(keep.indexOf("\n") + 1));
 }
 
-/** The stall reporter for a Bun process (the terminal app, the desktop app's main process). */
+/**
+ * The stall reporter for a Bun process (the terminal app, the desktop app's
+ * main process). Its log and state are readable by the user alone: the log
+ * says what the user was doing when the app froze.
+ */
 export function createNodeStallReporterHost(options: {
   /** The profile's data folder, or null before the config is loaded. */
   getDataDir(): string | null;
@@ -56,20 +72,20 @@ export function createNodeStallReporterHost(options: {
     appendLog: (line) => {
       const path = pathFor(STALL_LOG_FILE);
       if (!path) return;
-      mkdirSync(join(path, ".."), { recursive: true });
-      appendFileSync(path, `${line}\n`, "utf-8");
+      makePrivateDirSync(join(path, ".."));
+      writePrivateFileSync(path, `${line}\n`, { append: true });
       trimLog(path);
     },
     load: () => {
       const path = pathFor(STATE_FILE);
-      if (!path || !existsSync(path)) return { sent: {}, pending: {} };
+      if (!path || !existsSync(path)) return { sent: {}, pending: {}, recent: {} };
       return parseStallReportState(readFileSync(path, "utf-8"));
     },
     save: (state) => {
       const path = pathFor(STATE_FILE);
       if (!path) return;
-      mkdirSync(join(path, ".."), { recursive: true });
-      writeFileSync(path, JSON.stringify(state), "utf-8");
+      makePrivateDirSync(join(path, ".."));
+      writePrivateFileSync(path, JSON.stringify(state));
     },
   };
 }

package/src/telemetry/stall-reports.ts

@@ -22,8 +22,22 @@ import { reportCrash } from "./crash-reports";
  *   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.
  *
+ * A report also says when in the process's life the stall came (still
+ * starting or up, and an uptime bucket), how long before it the named section
+ * ended (or that it ended inside it, which makes it the likely cause), and,
+ * for the desktop app's own process, whether the app was in front and had a
+ * window on screen: a hidden app's slowed timers read like a freeze. A stall
+ * after a SQLite statement names the statement (a fixed name), its tries and
+ * whether it waited on another program's lock. Where the platform's clocks
+ * can be read, it says how much of the stall the thread spent on the CPU
+ * and how busy the process's other threads were, which tells script or a
+ * collection (busy) from a wait on the disk, a lock or another thread
+ * (idle); the time the computer slept never counts as a stall (see
+ * utils/main-thread-stall.ts). All of it is buckets and flags.
+ *
  * 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.
+ * the same kind after that are counted and carried in the next report, and
+ * every report says how many stalls the process had in the last day.
  */
 
 /** Which process stalled. */
@@ -41,9 +55,38 @@ export interface StallReport {
   count: number;
   /** The longest of them, rounded to 100 ms. */
   longestMs: number;
+  /** This process's stalls of a second or more in the last 24 hours, this one included. */
+  day: number;
+  /** Whether the process had finished starting. */
+  phase: "startup" | "steady" | "unknown";
+  uptime: UptimeBucket | "unknown";
+  /** How long before the stall began the section ended; "in" when it ended inside it. */
+  gap: GapBucket;
+  /** The desktop app's own process: whether the app was in front (null: not known yet). */
+  active?: boolean | null;
+  /** The desktop app's own process: whether a window was open and not minimized. */
+  visible?: boolean | null;
+  /** After a SQLite statement: how many tries it took. */
+  attempts?: number;
+  /** After a SQLite statement: whether it waited on another connection's lock. */
+  lockWait?: boolean;
+  /** Where the platform says: the share of the stall the thread was on the CPU, in percent, by tens. */
+  cpuPercent?: number;
+  /** Where the platform says: the CPU the process's other threads used meanwhile, in percent of one core, by tens. */
+  otherCpuPercent?: number;
 }
 
 type StallBucket = "1-2s" | "2-5s" | "5-15s" | "15s+";
+type UptimeBucket = "<30s" | "30s-2m" | "2-10m" | "10-60m" | "1-6h" | "6-24h" | "1d+";
+type GapBucket = "none" | "in" | "<1s" | "1-10s" | "10-60s" | "1-10m" | "10m+";
+
+/** What the desktop app's Bun process can tell about whether anyone was looking. */
+export interface StallAttention {
+  /** One of the app's windows had the keyboard; null before the first focus change. */
+  active: boolean | null;
+  /** One of the app's windows was open and not minimized; null when it could not be read. */
+  visible: boolean | null;
+}
 
 /** What the host keeps on disk between launches. */
 export interface StallReportState {
@@ -51,6 +94,8 @@ export interface StallReportState {
   sent: Record<string, number>;
   /** Stalls counted since each kind was last reported. */
   pending: Record<string, { count: number; longestMs: number }>;
+  /** When each process's stalls of a second or more in the last day happened, oldest first. */
+  recent?: Record<string, number[]>;
 }
 
 export interface StallReporterHost {
@@ -74,8 +119,15 @@ 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;
+/** Stall times kept per process for the day count. */
+const MAX_RECENT_KEPT = 500;
+/** What error tracking keeps of the details line; fields that do not fit are left out. */
+const MAX_DETAILS_LENGTH = 120;
+/** Other threads' CPU past this many percent of a core reads as this. */
+const MAX_OTHER_CPU_PERCENT = 990;
 
 let host: StallReporterHost | null = null;
+let attentionProbe: (() => StallAttention) | null = null;
 
 /** The fixed part of a section name: lower-case dotted words, cut where anything else starts. */
 function stallSectionName(name: string | undefined): string {
@@ -85,6 +137,15 @@ function stallSectionName(name: string | undefined): string {
   return section && section.length <= 80 ? section : "unmeasured";
 }
 
+/** The section a report names; a SQLite statement's adds the statement's fixed name. */
+function reportSection(event: StallEvent): string {
+  const section = stallSectionName(event.lastMeasured);
+  if (section !== "sqlite.blocked" || !event.sqlite) return section;
+  const operation = event.sqlite.operation.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  const named = `${section}.${operation}`.replace(/-+$/, "");
+  return SECTION_PATTERN.exec(named)?.[0] === named ? named : section;
+}
+
 function stallBucket(blockedMs: number): StallBucket {
   if (blockedMs < 2_000) return "1-2s";
   if (blockedMs < 5_000) return "2-5s";
@@ -92,15 +153,50 @@ function stallBucket(blockedMs: number): StallBucket {
   return "15s+";
 }
 
+function uptimeBucket(uptimeMs: number | undefined): UptimeBucket | "unknown" {
+  if (uptimeMs === undefined) return "unknown";
+  const minutes = uptimeMs / 60_000;
+  if (minutes < 0.5) return "<30s";
+  if (minutes < 2) return "30s-2m";
+  if (minutes < 10) return "2-10m";
+  if (minutes < 60) return "10-60m";
+  if (minutes < 360) return "1-6h";
+  if (minutes < 1_440) return "6-24h";
+  return "1d+";
+}
+
+/**
+ * How long before the stall began the last measured section ended. A
+ * section that ended inside the stall ran during it ("in"): the likely
+ * cause. Anything after that is time nothing measured ran in.
+ */
+function gapBucket(event: StallEvent): GapBucket {
+  if (!event.lastMeasured || event.lastMeasuredEndedMsAgo === undefined) return "none";
+  const gapMs = event.lastMeasuredEndedMsAgo - event.blockedMs;
+  if (gapMs <= 0) return "in";
+  if (gapMs < 1_000) return "<1s";
+  if (gapMs < 10_000) return "1-10s";
+  if (gapMs < 60_000) return "10-60s";
+  if (gapMs < 600_000) return "1-10m";
+  return "10m+";
+}
+
 /** 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>;
+  const { blockedMs, lastMeasured, lastMeasuredEndedMsAgo, sqlite, uptimeMs, phase } = value as Record<string, unknown>;
   if (typeof blockedMs !== "number" || !Number.isFinite(blockedMs) || blockedMs <= 0) return null;
+  const detail = sqlite && typeof sqlite === "object" ? sqlite as Record<string, unknown> : null;
   return {
     blockedMs,
     ...(typeof lastMeasured === "string" && lastMeasured.length <= 200 ? { lastMeasured } : {}),
     ...(typeof lastMeasuredEndedMsAgo === "number" && Number.isFinite(lastMeasuredEndedMsAgo) ? { lastMeasuredEndedMsAgo } : {}),
+    ...(detail && typeof detail.operation === "string" && detail.operation.length <= 80
+      && typeof detail.attempts === "number" && Number.isFinite(detail.attempts)
+      ? { sqlite: { operation: detail.operation, attempts: detail.attempts, lockWait: detail.lockWait === true } }
+      : {}),
+    ...(typeof uptimeMs === "number" && Number.isFinite(uptimeMs) && uptimeMs >= 0 ? { uptimeMs } : {}),
+    ...(phase === "startup" || phase === "steady" ? { phase } : {}),
   };
 }
 
@@ -108,13 +204,57 @@ 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 {
+function flag(value: boolean | null | undefined): string {
+  return value == null ? "?" : value ? "1" : "0";
+}
+
+/** A share or a core count in percent, by tens. */
+function tens(value: number | undefined, max: number): number | undefined {
+  if (value === undefined || !Number.isFinite(value)) return undefined;
+  return Math.min(max, Math.max(0, Math.round(value * 10) * 10));
+}
+
+/** The context a report carries, also written at the end of the log line. */
+interface StallContext {
+  phase: StallReport["phase"];
+  uptime: StallReport["uptime"];
+  gap: GapBucket;
+  attention: StallAttention | null;
+  cpuPercent?: number;
+  otherCpuPercent?: number;
+}
+
+function stallContext(event: StallEvent, attention: StallAttention | null): StallContext {
+  const cpuPercent = tens(event.threadCpu, 100);
+  const otherCpuPercent = tens(event.otherCpu, MAX_OTHER_CPU_PERCENT);
+  return {
+    phase: event.phase ?? "unknown",
+    uptime: uptimeBucket(event.uptimeMs),
+    gap: gapBucket(event),
+    attention,
+    ...(cpuPercent === undefined ? {} : { cpuPercent }),
+    ...(otherCpuPercent === undefined ? {} : { otherCpuPercent }),
+  };
+}
+
+/** One line of the stall log: when, which process, how long, what ran last, and when in the process's life. */
+function formatStallLogLine(process: StallProcess, event: StallEvent, context: StallContext, 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}`;
+  const sqlite = event.sqlite
+    ? ` (${event.sqlite.operation}, ${event.sqlite.attempts} ${event.sqlite.attempts === 1 ? "try" : "tries"}${event.sqlite.lockWait ? ", waited on a lock" : ""})`
+    : "";
+  const facts = [
+    `phase=${context.phase}`,
+    `up=${context.uptime}`,
+    `gap=${context.gap}`,
+    ...(context.attention ? [`fg=${flag(context.attention.active)}`, `vis=${flag(context.attention.visible)}`] : []),
+    ...(context.cpuPercent === undefined ? [] : [`cpu=${context.cpuPercent}`]),
+    ...(context.otherCpuPercent === undefined ? [] : [`oth=${context.otherCpuPercent}`]),
+  ].join(" ");
+  return `${time}  ${process.padEnd(8)}  froze ${formatSeconds(event.blockedMs).padStart(6)}  ${last}${sqlite}  [${facts}]`;
 }
 
 function reportPlatform(platform: string): StallReport["platform"] {
@@ -128,13 +268,38 @@ function reportArch(arch: string): StallReport["arch"] {
   return arch === "arm64" || arch === "x64" ? arch : "other";
 }
 
-function sendThroughCrashReporter(report: StallReport): void {
-  const details = [
+/**
+ * The details line error tracking keeps, most telling first. The platform
+ * comes last: error tracking has the system and its architecture already.
+ * One that would not fit is left out.
+ */
+export function formatStallReportDetails(report: StallReport): string {
+  const fields = [
     `process=${report.process}`,
     `count=${report.count}`,
     `longest=${report.longestMs}ms`,
+    `phase=${report.phase}`,
+    `up=${report.uptime}`,
+    `gap=${report.gap}`,
+    ...(report.active === undefined ? [] : [`fg=${flag(report.active)}`]),
+    ...(report.visible === undefined ? [] : [`vis=${flag(report.visible)}`]),
+    ...(report.cpuPercent === undefined ? [] : [`cpu=${report.cpuPercent}`]),
+    ...(report.otherCpuPercent === undefined ? [] : [`oth=${report.otherCpuPercent}`]),
+    ...(report.lockWait === undefined ? [] : [`lock=${flag(report.lockWait)}`]),
+    ...(report.attempts === undefined ? [] : [`try=${report.attempts}`]),
+    `day=${report.day}`,
     `platform=${report.platform}-${report.arch}`,
-  ].join(" ");
+  ];
+  let details = "";
+  for (const field of fields) {
+    const next = details ? `${details} ${field}` : field;
+    if (next.length <= MAX_DETAILS_LENGTH) details = next;
+  }
+  return details;
+}
+
+function sendThroughCrashReporter(report: StallReport): void {
+  const details = formatStallReportDetails(report);
   // 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(
@@ -146,10 +311,10 @@ function sendThroughCrashReporter(report: StallReport): void {
 function loadState(current: StallReporterHost): StallReportState {
   try {
     const state = current.load();
-    return { sent: { ...state.sent }, pending: { ...state.pending } };
+    return { sent: { ...state.sent }, pending: { ...state.pending }, recent: { ...state.recent } };
   } catch (error) {
     logFailure("telemetry-stalls", "Could not read stall report state")(error);
-    return { sent: {}, pending: {} };
+    return { sent: {}, pending: {}, recent: {} };
   }
 }
 
@@ -159,6 +324,22 @@ function prune(state: StallReportState, now: number): void {
   }
   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];
+  for (const [process, times] of Object.entries(state.recent ?? {})) {
+    const kept = times.filter((at) => now - at < DAY_MS && at <= now);
+    if (kept.length > 0) state.recent![process] = kept;
+    else delete state.recent![process];
+  }
+}
+
+/** Never throws: a probe that fails reads as not known. */
+function readAttention(): StallAttention | null {
+  if (!attentionProbe) return null;
+  try {
+    return attentionProbe();
+  } catch {
+    // Intentional ignore: a window that cannot be read leaves the report saying it is not known.
+    return { active: null, visible: null };
+  }
 }
 
 /** Records one stall of `process`. Does nothing where no host is installed; never throws. */
@@ -167,15 +348,20 @@ export function recordStall(process: StallProcess, event: StallEvent): void {
   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 reportable = event.blockedMs >= STALL_REPORT_MIN_MS;
+    // Asked only of a stall that will be reported: the probe reads the windows.
+    const context = stallContext(event, reportable && process === "app" ? readAttention() : null);
+    current.appendLog(formatStallLogLine(process, event, context, now));
+    if (!reportable) return;
     const appVersion = (current.appVersion ?? VERSION).trim().replace(/^v/, "");
-    const section = stallSectionName(event.lastMeasured);
+    const section = reportSection(event);
     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 recent = [...(state.recent?.[process] ?? []), now].slice(-MAX_RECENT_KEPT);
+    state.recent = { ...state.recent, [process]: recent };
     const pending = state.pending[key] ?? { count: 0, longestMs: 0 };
     pending.count += 1;
     pending.longestMs = Math.max(pending.longestMs, Math.round(event.blockedMs / 100) * 100);
@@ -193,6 +379,16 @@ export function recordStall(process: StallProcess, event: StallEvent): void {
         arch: reportArch(current.arch),
         count: pending.count,
         longestMs: pending.longestMs,
+        day: recent.length,
+        phase: context.phase,
+        uptime: context.uptime,
+        gap: context.gap,
+        ...(context.attention ? { active: context.attention.active, visible: context.attention.visible } : {}),
+        ...(context.cpuPercent === undefined ? {} : { cpuPercent: context.cpuPercent }),
+        ...(context.otherCpuPercent === undefined ? {} : { otherCpuPercent: context.otherCpuPercent }),
+        ...(event.sqlite && section.startsWith("sqlite.blocked")
+          ? { attempts: Math.max(1, Math.min(99, Math.round(event.sqlite.attempts))), lockWait: event.sqlite.lockWait }
+          : {}),
       });
     }
     current.save(state);
@@ -208,7 +404,16 @@ export function installStallReporter(next: StallReporterHost): () => void {
   };
 }
 
+/** How the desktop app's Bun process tells whether anyone was looking when it froze (bun/window/attention.ts). */
+export function setStallAttentionProbe(next: (() => StallAttention) | null): () => void {
+  attentionProbe = next;
+  return () => {
+    if (attentionProbe === next) attentionProbe = null;
+  };
+}
+
 /** Test seam. */
 export function resetStallReporterForTests(): void {
   host = null;
+  attentionProbe = null;
 }

package/src/test-support/outage.ts

@@ -0,0 +1,8 @@
+/**
+ * A request that never reached its server, with `message`: the failure a
+ * saved copy answers for (`isTransientFailure`), unlike a plain `Error`, which
+ * reads as a reply that failed validation.
+ */
+export function outage(message = "Unable to connect. Is the computer able to access the url?"): Error {
+  return Object.assign(new Error(message), { code: "ConnectionRefused" });
+}

package/src/test-support/preload.ts

@@ -1,5 +1,6 @@
 import { beforeEach } from "bun:test";
 import { resetCrashReporterForTests } from "../telemetry/crash-reports";
+import { setCliAsciiLocaleOverride, setCliColorEnabledOverride, setCliPlainOverride, setCliWidthOverride } from "../utils/cli-output";
 
 /**
  * `bun test` runs every file in one process, so module state outlives the file
@@ -8,7 +9,15 @@ import { resetCrashReporterForTests } from "../telemetry/crash-reports";
  * 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.
+ *
+ * Commands also keep output overrides for the process: a parity test that
+ * runs --plain would otherwise make a later serializer test keep empty
+ * columns. Start each test with the default output modes and terminal width.
  */
 beforeEach(() => {
   resetCrashReporterForTests();
+  setCliAsciiLocaleOverride(null);
+  setCliColorEnabledOverride(null);
+  setCliPlainOverride(null);
+  setCliWidthOverride(null);
 });

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

@@ -3,9 +3,9 @@ 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";
@@ -17,6 +17,8 @@ export interface CompanyNameListing {
   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
@@ -67,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
@@ -95,44 +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 quoted = options.quoted ? await firstQuoted(dataProvider, lines, options.movedLine) : { line: first, moved: null };
+  // 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 };
+    : {
+      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;
 }
@@ -199,6 +222,11 @@ async function firstQuoted<T extends RankedListing>(
 }
 
 /** 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();
 }
@@ -211,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 => {
@@ -228,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