gloomberb 0.19.1 → 0.19.2

package/src/telemetry/stall-reports.ts

@@ -22,8 +22,18 @@ 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. 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 +51,34 @@ 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;
 }
 
 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 +86,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 +111,13 @@ 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;
 
 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 +127,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 +143,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 +194,43 @@ 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";
+}
+
+/** 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;
+}
+
+function stallContext(event: StallEvent, attention: StallAttention | null): StallContext {
+  return {
+    phase: event.phase ?? "unknown",
+    uptime: uptimeBucket(event.uptimeMs),
+    gap: gapBucket(event),
+    attention,
+  };
+}
+
+/** 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)}`] : []),
+  ].join(" ");
+  return `${time}  ${process.padEnd(8)}  froze ${formatSeconds(event.blockedMs).padStart(6)}  ${last}${sqlite}  [${facts}]`;
 }
 
 function reportPlatform(platform: string): StallReport["platform"] {
@@ -128,13 +244,35 @@ 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 original
+ * four fields, then the new ones. 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`,
     `platform=${report.platform}-${report.arch}`,
-  ].join(" ");
+    `phase=${report.phase}`,
+    `up=${report.uptime}`,
+    `gap=${report.gap}`,
+    ...(report.active === undefined ? [] : [`fg=${flag(report.active)}`]),
+    ...(report.visible === undefined ? [] : [`vis=${flag(report.visible)}`]),
+    ...(report.lockWait === undefined ? [] : [`lock=${flag(report.lockWait)}`]),
+    ...(report.attempts === undefined ? [] : [`try=${report.attempts}`]),
+    `day=${report.day}`,
+  ];
+  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 +284,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 +297,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 +321,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 +352,14 @@ 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 } : {}),
+        ...(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 +375,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/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

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
@@ -234,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);
+}