gloomberb 0.18.1 → 0.18.3

package/src/telemetry/update-failures.ts

@@ -0,0 +1,307 @@
+import type { UpdateFailureReport } from "../api-client";
+import type { UpdateChannel } from "../types/config";
+import type { UpdateFailure } from "../updater/failure";
+import { logFailure } from "../utils/log-failure";
+import { compareSemver } from "../utils/semver";
+import { VERSION } from "../version";
+import { reportCrash, type CrashReportContext } from "./crash-reports";
+
+/**
+ * Failed update steps, sent to error tracking through the crash reporter (and
+ * so behind the same off switch). A report is the step, a fixed code, the
+ * versions, the channel, the platform and how the app was installed: never the
+ * error's text, which can hold a path, a user name or a signed URL.
+ *
+ * The process that runs the update reports it: the terminal app, and the
+ * desktop app's Bun process. The desktop view and the web install no host, so
+ * the same failure is never sent twice. One report per step, code and app
+ * version a day is enough to see a stuck updater; the hourly check that keeps
+ * failing offline adds nothing after the first.
+ *
+ * The desktop host also keeps what an install was about to do, so the next
+ * launch can tell an install that never took, or an update downloaded and
+ * then quit without, from one that worked (`reviewLastUpdateAttempt`).
+ */
+
+/**
+ * Where the running app sits. macOS installs replace the app bundle in place,
+ * which only works from a folder the user can write: not from a disk image,
+ * and not from the read-only copy App Translocation runs a quarantined app from.
+ */
+export type UpdateInstallKind =
+  | "desktop-applications"
+  | "desktop-translocated"
+  | "desktop-volume"
+  | "desktop-elsewhere"
+  /** Windows and Linux: the app folder the installer created. */
+  | "desktop-app-data"
+  | "terminal-binary"
+  | "terminal-managed"
+  | "terminal-package-manager"
+  | "terminal-source"
+  | "unknown";
+
+/** One update the app downloaded or started installing, and when. */
+export interface UpdateAttempt {
+  from: string;
+  to: string;
+  channel: UpdateChannel;
+  at: number;
+}
+
+/** What the host keeps on disk between launches. */
+export interface UpdateReportState {
+  /** When each step, code and app version was last reported, in ms. */
+  sent: Record<string, number>;
+  /** A downloaded update waiting for the user's Restart. */
+  staged?: UpdateAttempt;
+  /** An install the user started; the next launch says whether it took. */
+  applying?: UpdateAttempt;
+}
+
+export interface UpdateFailureReporterHost {
+  installKind: UpdateInstallKind;
+  /** The running version; defaults to this build's. */
+  appVersion?: string;
+  /** `process.platform` and `process.arch`. */
+  platform: string;
+  arch: string;
+  load(): UpdateReportState;
+  save(state: UpdateReportState): void;
+  now?(): number;
+  /** Defaults to the crash reporter. */
+  send?(report: UpdateFailureReport): void;
+}
+
+export interface UpdateFailureContext {
+  /** The version the update was going to, when one was known. */
+  targetVersion?: string | null;
+  channel?: UpdateChannel | null;
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** Older attempts say nothing about this launch: the user installed by hand, or reinstalled. */
+const ATTEMPT_MAX_AGE_MS = 30 * DAY_MS;
+/**
+ * The install quits the app and opens the new one as soon as it is gone. A new
+ * version first seen this long after is one the user opened again by hand.
+ */
+const RELAUNCH_GRACE_MS = 10 * 60 * 1000;
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]{1,60})?$/;
+
+let host: UpdateFailureReporterHost | null = null;
+
+function cleanVersion(value: string | null | undefined): string | undefined {
+  const version = value?.trim().replace(/^v/, "");
+  return version && VERSION_PATTERN.test(version) ? version : undefined;
+}
+
+function reportPlatform(platform: string): UpdateFailureReport["platform"] {
+  if (platform === "darwin") return "macos";
+  if (platform === "win32") return "windows";
+  if (platform === "linux") return "linux";
+  return "other";
+}
+
+function reportArch(arch: string): UpdateFailureReport["arch"] {
+  return arch === "arm64" || arch === "x64" ? arch : "other";
+}
+
+/**
+ * The report, from fixed values only: anything that is not a version, a
+ * known channel, platform or install kind is left out or named `other`.
+ */
+function buildUpdateFailureReport(
+  failure: UpdateFailure,
+  fields: UpdateFailureContext & {
+    appVersion: string;
+    platform: string;
+    arch: string;
+    installKind: UpdateInstallKind;
+  },
+): UpdateFailureReport {
+  const targetVersion = cleanVersion(fields.targetVersion);
+  return {
+    phase: failure.phase,
+    code: failure.code,
+    appVersion: cleanVersion(fields.appVersion) ?? "unknown",
+    ...(targetVersion ? { targetVersion } : {}),
+    channel: fields.channel === "nightly" ? "nightly" : "stable",
+    platform: reportPlatform(fields.platform),
+    arch: reportArch(fields.arch),
+    installKind: fields.installKind,
+  };
+}
+
+/**
+ * The report as the crash reporter sends it. Today's server keeps the error's
+ * type, message, plugin and pane: the message is the step and code, so error
+ * tracking groups one issue per failure, and the pane holds the rest as
+ * `key=value` pairs. The `update` field carries the same values for a server
+ * that reads it.
+ */
+function updateFailureCrashReport(report: UpdateFailureReport): {
+  error: { name: string; message: string };
+  context: CrashReportContext;
+} {
+  const details = [
+    `to=${report.targetVersion ?? "none"}`,
+    `channel=${report.channel}`,
+    `platform=${report.platform}-${report.arch}`,
+    `install=${report.installKind}`,
+  ].join(" ");
+  return {
+    // A plain object, not an Error: it has no stack, so no file path goes along.
+    error: { name: "UpdateFailed", message: `${report.phase}: ${report.code}` },
+    context: { kind: "plugin", plugin: "updater", pane: details, update: report },
+  };
+}
+
+function sendThroughCrashReporter(report: UpdateFailureReport): void {
+  const { error, context } = updateFailureCrashReport(report);
+  reportCrash(error, context);
+}
+
+/**
+ * Takes the day's slot for `key`, or says it is used: one report per step,
+ * code and version a day. Drops what is older than a day while at it.
+ */
+function takeReportSlot(state: UpdateReportState, key: string, now: number): boolean {
+  for (const [entry, at] of Object.entries(state.sent)) {
+    if (!(now - at < DAY_MS) || at > now) delete state.sent[entry];
+  }
+  if (state.sent[key] !== undefined) return false;
+  state.sent[key] = now;
+  return true;
+}
+
+function loadState(current: UpdateFailureReporterHost): UpdateReportState {
+  try {
+    const state = current.load();
+    return { ...state, sent: { ...state.sent } };
+  } catch (error) {
+    logFailure("telemetry-update-failures", "Could not read update report state")(error);
+    return { sent: {} };
+  }
+}
+
+function saveState(current: UpdateFailureReporterHost, state: UpdateReportState): void {
+  try {
+    current.save(state);
+  } catch (error) {
+    logFailure("telemetry-update-failures", "Could not save update report state")(error);
+  }
+}
+
+function sendIfDue(
+  current: UpdateFailureReporterHost,
+  state: UpdateReportState,
+  failure: UpdateFailure,
+  context: UpdateFailureContext,
+  now: number,
+): void {
+  const report = buildUpdateFailureReport(failure, {
+    ...context,
+    appVersion: current.appVersion ?? VERSION,
+    platform: current.platform,
+    arch: current.arch,
+    installKind: current.installKind,
+  });
+  if (!takeReportSlot(state, `${report.phase}|${report.code}|${report.appVersion}`, now)) return;
+  (current.send ?? sendThroughCrashReporter)(report);
+}
+
+export function installUpdateFailureReporter(next: UpdateFailureReporterHost): () => void {
+  host = next;
+  return () => {
+    if (host === next) host = null;
+  };
+}
+
+/** Reports one failed step. Never throws; does nothing where no host is installed. */
+export function reportUpdateFailure(failure: UpdateFailure, context: UpdateFailureContext = {}): void {
+  const current = host;
+  if (!current) return;
+  try {
+    const now = current.now?.() ?? Date.now();
+    const state = loadState(current);
+    // An install that failed in this run is reported here, not again at the next launch.
+    if (failure.phase === "apply" || failure.phase === "relaunch") delete state.applying;
+    sendIfDue(current, state, failure, context, now);
+    saveState(current, state);
+  } catch (error) {
+    logFailure("telemetry-update-failures", "Could not report update failure")(error);
+  }
+}
+
+function recordAttempt(field: "staged" | "applying", to: string, channel: UpdateChannel): void {
+  const current = host;
+  if (!current) return;
+  const state = loadState(current);
+  const attempt: UpdateAttempt = { from: current.appVersion ?? VERSION, to, channel, at: current.now?.() ?? Date.now() };
+  if (field === "applying") delete state.staged;
+  state[field] = attempt;
+  saveState(current, state);
+}
+
+/** A downloaded update is waiting for the user's Restart. */
+export function noteUpdateStaged(to: string, channel: UpdateChannel): void {
+  recordAttempt("staged", to, channel);
+}
+
+/** The user pressed Restart: the next launch should be `to`. */
+export function noteUpdateApplying(to: string, channel: UpdateChannel): void {
+  recordAttempt("applying", to, channel);
+}
+
+/** The waiting update was taken back (a channel switch); quitting without it is no longer news. */
+export function forgetStagedUpdate(): void {
+  const current = host;
+  if (!current) return;
+  const state = loadState(current);
+  if (!state.staged) return;
+  delete state.staged;
+  saveState(current, state);
+}
+
+/**
+ * Run once at launch: what came of the last update this app started.
+ *
+ * - Restarted into the new version: nothing to report, unless the new version
+ *   only came up long after, which is the app failing to reopen itself.
+ * - Still the old version after an install: it never took.
+ * - Still the old version with a download waiting: the app was quit without
+ *   restarting into it, which the stuck installs may come down to.
+ */
+export function reviewLastUpdateAttempt(): void {
+  const current = host;
+  if (!current) return;
+  const currentVersion = current.appVersion ?? VERSION;
+  try {
+    const state = loadState(current);
+    const { applying, staged } = state;
+    if (!applying && !staged) return;
+    delete state.applying;
+    delete state.staged;
+    const now = current.now?.() ?? Date.now();
+    const fresh = (attempt: UpdateAttempt | undefined) => !!attempt && now - attempt.at < ATTEMPT_MAX_AGE_MS && attempt.at <= now;
+    if (applying && fresh(applying)) {
+      const context = { targetVersion: applying.to, channel: applying.channel };
+      if (applying.from === currentVersion) {
+        sendIfDue(current, state, { phase: "apply", code: "not_applied" }, context, now);
+      } else if ((compareSemver(currentVersion, applying.to) ?? -1) >= 0 && now - applying.at > RELAUNCH_GRACE_MS) {
+        sendIfDue(current, state, { phase: "relaunch", code: "relaunch_missed" }, context, now);
+      }
+    } else if (staged && fresh(staged) && staged.from === currentVersion) {
+      sendIfDue(current, state, { phase: "apply", code: "not_restarted" }, { targetVersion: staged.to, channel: staged.channel }, now);
+    }
+    saveState(current, state);
+  } catch (error) {
+    logFailure("telemetry-update-failures", "Could not review the last update")(error);
+  }
+}
+
+/** Test seam. */
+export function resetUpdateFailureReporterForTests(): void {
+  host = null;
+}

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

@@ -2,7 +2,7 @@ import { logFailure } from "../utils/log-failure";
 import type { DataProvider } from "../types/data-provider";
 import type { InstrumentSearchResult } from "../types/instrument";
 import { canonicalExchange, isUsListingExchange, parsePublicTickerKey } from "../utils/exchanges";
-import { companyNameExtraWords, shortCompanyName } from "./company-name";
+import { companyNameMatch, shortCompanyName } from "./company-name";
 import { LISTING_SEARCH_LIMIT } from "./search";
 import { classifyInstrumentKind } from "./search/ranking";
 import { isProviderBusy, type ProviderBusyError } from "../sources/provider-errors";
@@ -28,10 +28,12 @@ export function isCompanyNameInput(input: string): boolean {
 /**
  * The listing a company's name stands for when it is typed where a symbol
  * goes, as an entry of a comma list ("Whirlpool Corporation" is WHR on
- * NYSE). Of search's listings whose names have every word of it (the name is
- * also searched without its legal form, which can find more), the company
+ * NYSE). Of search's listings whose names have every word of it, or a word
+ * it shortens ("philip morris intl" is Philip Morris International; the name
+ * is also searched without its legal form, which can find more), the company
  * whose name says no more than the one typed goes first, so a subsidiary that
- * shares the word (Whirlpool of India) does not; then its line on a US
+ * shares the word (Whirlpool of India) does not, and of those a name matched
+ * word for word before one a short form matched; then its line on a US
  * exchange, then a plain line before a depositary receipt, the shortest
  * symbol (WHR before WHR-A) and search's order. Contracts, preferred shares
  * and notes are never the listing. Null when none matches; when none does
@@ -55,10 +57,10 @@ export async function findListingOfCompanyName(
   const ranked = results.flatMap((result, order) => {
     const exchange = canonicalExchange(result.exchange === "SMART" ? result.primaryExchange : result.exchange || result.primaryExchange);
     const type = result.brokerContract?.secType || result.type || "";
-    const extra = companyNameExtraWords(name, result.name);
-    if (!exchange || extra == null || classifyInstrumentKind(type) === "derivative" || NOT_COMMON.test(type)
+    const match = companyNameMatch(name, result.name);
+    if (!exchange || match == null || classifyInstrumentKind(type) === "derivative" || NOT_COMMON.test(type)
       || parsePublicTickerKey(result.symbol).exchange) return [];
-    return [{ result, exchange, rank: [extra, isUsListingExchange(exchange) ? 0 : 1, RECEIPT.test(type) ? 1 : 0, result.symbol.length, order] }];
+    return [{ result, exchange, rank: [match.extra, match.abbreviated, isUsListingExchange(exchange) ? 0 : 1, RECEIPT.test(type) ? 1 : 0, 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]!;

package/src/tickers/company-name.ts

@@ -56,6 +56,49 @@ export function companyNameExtraWords(typed: string, name: string | null | undef
   return words.size - wanted.size;
 }
 
+/**
+ * Whether a typed word is a short form of a name's word, as a list writes
+ * one: its first letter and the rest in order, at least three letters
+ * (`intl` for international, `hldgs` for holdings, `grp` for group).
+ */
+function abbreviates(short: string, word: string): boolean {
+  if (short.length < 3 || short.length >= word.length || short[0] !== word[0] || !/^\p{L}+$/u.test(short)) return false;
+  let at = 0;
+  for (const char of word) {
+    if (char === short[at]) at += 1;
+    if (at === short.length) return true;
+  }
+  return false;
+}
+
+/**
+ * `companyNameExtraWords` for a name typed with short forms, as a list or a
+ * spreadsheet writes it ("philip morris intl" for Philip Morris
+ * International Inc.): each typed word is one of the name's, or a short form
+ * of another of its words (`abbreviates`). `extra` counts the name's words
+ * left unmatched, `abbreviated` the typed words read as short forms, so an
+ * exact name ranks before one only a short form reaches. Null when a typed
+ * word is in the name neither way, or nothing was typed.
+ */
+export function companyNameMatch(typed: string, name: string | null | undefined): { extra: number; abbreviated: number } | null {
+  const wanted = companyWords(typed);
+  const words = companyWords(name);
+  if (wanted.size === 0) return null;
+  const matched = new Set<string>();
+  let abbreviated = 0;
+  for (const word of wanted) {
+    if (words.has(word)) {
+      matched.add(word);
+      continue;
+    }
+    const long = [...words].find((candidate) => !matched.has(candidate) && !wanted.has(candidate) && abbreviates(word, candidate));
+    if (!long) return null;
+    matched.add(long);
+    abbreviated += 1;
+  }
+  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[][] {
   const groups: T[][] = [];

package/src/tickers/listing-fate.ts

@@ -19,6 +19,7 @@ import { isQuoteBeforeLatestSession, isQuoteStaleForCurrentSession } from "../ma
 import { formatMarketPriceWithCurrency, quoteFormatOptions } from "../market-data/market/format";
 import { canonicalExchange, isUsListingExchange, parsePublicTickerKey, resolveExchangeTimeZone } from "../utils/exchanges";
 import { zonedDateKey } from "../utils/zoned-date-time";
+import { delistingLabel } from "../market-data/quotes/delisting";
 
 /*
  * What became of a symbol, read the way `quote` reads it: the listing's own
@@ -33,8 +34,10 @@ const ENDED_AFTER_MS = 183 * 24 * 60 * 60_000;
 /**
  * The exchange-local date a listing last traded, when its quote is stale and
  * that was over half a year ago (TWTR's 2022-10-27); null for anything newer.
+ * A quote that says its listing no longer trades gives its last session.
  */
 function endedTradingDate(quote: Quote, now = Date.now()): string | null {
+  if (quote.delisting) return quote.delisting.lastTradeDate;
   const last = Math.max(...[quote.lastTradeTime, quote.lastUpdated].filter((time): time is number => Number.isFinite(time)));
   if (!(last > 0) || now - last < ENDED_AFTER_MS || !isQuoteStaleForCurrentSession(quote, now)) return null;
   return quoteDateKey(quote, last);
@@ -60,12 +63,18 @@ export function tradingListing(quote: Quote | null | undefined, now = Date.now()
   return quote && !endedTradingDate(quote, now) ? quotedListing(quote) : null;
 }
 
-/** "TWTR: no longer trading since 2022-10-27 (last price $53.86)", for a quote that stopped long ago. */
+/**
+ * "TWTR: no longer trading since 2022-10-27 (last price $53.86)", for a quote
+ * that stopped long ago; "TWTR: Delisted Oct 27, 2022 (last price $53.86)"
+ * when the quote says the listing no longer trades.
+ */
 export function noLongerTradingNote(label: string, quote: Quote, now = Date.now()): string | null {
   const date = endedTradingDate(quote, now);
   if (!date) return null;
   const price = formatMarketPriceWithCurrency(quote.price, quote.currency, quoteFormatOptions(quote));
-  return `${label}: no longer trading since ${date} (last price ${price})`;
+  return quote.delisting
+    ? `${label}: ${delistingLabel(quote.delisting)} (last price ${price})`
+    : `${label}: no longer trading since ${date} (last price ${price})`;
 }
 
 /**
@@ -81,11 +90,17 @@ export interface ListingFate {
   /**
    * The line a command with nothing to serve for the symbol says: `quote`'s
    * change line when its company left it ("FB now lists ...; Meta Platforms
-   * trades as META (changed 2022-06-09)"), else, for a listing that stopped,
-   * "TWTR stopped trading 2022-10-27; no history or options served". Null
-   * for a symbol that trades as it always has.
+   * trades as META (changed 2022-06-09)"), else, for a listing the service
+   * says no longer trades, "TWTR: Delisted Oct 27, 2022", and for another
+   * that stopped, "XYZ stopped trading 2022-10-27; no history or options
+   * served". Null for a symbol that trades as it always has.
    */
   note: string | null;
+  /**
+   * "TWTR: Delisted Oct 27, 2022" when the listing's quote says it no longer
+   * trades: its history is served, ending on that session, and says so.
+   */
+  delisted?: string;
   /**
    * The change when the symbol's company trades under another symbol now
    * and its own quote shows nothing new listed under it (`movedAwayChange`):
@@ -156,9 +171,10 @@ export function describeListingFate(
   const abroad = !!quote && !!bareListingNote({ symbol, request: { exchange: listing.exchange ?? "" } }, quote);
   const current = tradingListing(quote, now);
   const change = abroad ? null : describeTickerChange(symbol, changes, current);
-  const note = tickerChangeLine(change) ?? (endedOn ? `${symbol} stopped trading ${endedOn}; no history or options served` : null);
+  const delisted = quote?.delisting && !abroad ? `${symbol}: ${delistingLabel(quote.delisting)}` : undefined;
+  const note = tickerChangeLine(change) ?? delisted ?? (endedOn ? `${symbol} stopped trading ${endedOn}; no history or options served` : null);
   const formerIssuer = abroad ? null : describeFormerIssuer(symbol, changes, current);
-  return { endedOn, change, note, moved: quote ? movedAwayChange(change) : null, formerIssuer };
+  return { endedOn, change, note, moved: quote ? movedAwayChange(change) : null, formerIssuer, ...(delisted ? { delisted } : {}) };
 }
 
 /**
@@ -200,7 +216,8 @@ export async function loadListingFate(
 
 /**
  * The lines a command says about a symbol's fate beside what it served. With
- * nothing served, `fate.note`. With data, `quote`'s change line when the
+ * nothing served, `fate.note`. With data, `fate.delisted` for a listing that
+ * no longer trades ("TWTR: Delisted Oct 27, 2022"), `quote`'s change line when the
  * symbol's company left it (FB's bars are the fund listed there now), and, for
  * bars from before the symbol's holder took it (META's from 2021), that they
  * are from its old symbol: "Includes FB-era bars: META was FB until 2022-06-09".
@@ -211,11 +228,43 @@ export function listingFateNotes(fate: ListingFate, served: { served: boolean; f
   const first = served.firstDate?.slice(0, 10);
   const earlier = change?.kind === "formerly" && first ? change.changes.filter((hop) => first < hop.date).map((hop) => hop.from) : [];
   return [
+    // What it served ends on the listing's last session, and says so.
+    fate.delisted ?? null,
     tickerChangeLine(change),
     earlier.length > 0 ? `Includes ${earlier.join("- and ")}-era bars: ${change!.note}` : null,
   ].filter((line): line is string => !!line);
 }
 
+/**
+ * A report's notes and errors beside what became of its symbol, worded as
+ * `quote`, `history` and `options` word it: with nothing served, the fate is
+ * why ("TWTR: Delisted Oct 27, 2022", "FB now lists ...; Meta Platforms
+ * trades as META") and stands in for the errors the empty load raised ("Not
+ * a ticker", "No options provider"); with data, `listingFateNotes` beside
+ * the errors. A symbol whose company moved, with nothing listed under it now,
+ * has nothing of its own to serve and throws `MovedSymbolError`.
+ */
+export function listingFateReport(
+  fate: ListingFate,
+  served: { served: boolean; firstDate?: string | null },
+  errors: readonly string[],
+): { notes: string[]; errors: string[] } {
+  if (fate.moved) throw new MovedSymbolError(fate.moved);
+  const notes = listingFateNotes(fate, served);
+  return { notes, errors: !served.served && notes.length > 0 ? [] : [...errors] };
+}
+
+/**
+ * A report that served nothing for its symbol (`listingFateReport`): what
+ * became of the symbol is the one reason it is empty, said once in place of
+ * every table's "No data." and of the load's errors; the errors alone when
+ * nothing became of it.
+ */
+export function listingFateEmpty(fate: ListingFate, errors: readonly string[]): { empty?: string; errors: string[] } {
+  const report = listingFateReport(fate, { served: false }, errors);
+  return report.notes.length ? { empty: report.notes.join(" "), errors: report.errors } : { errors: report.errors };
+}
+
 /**
  * What a report or loader with nothing of its own to serve for a symbol
  * throws when the symbol's company moved (`ListingFate.moved`): its message

package/src/tickers/search/index.ts

@@ -38,6 +38,7 @@ import { readTerminalListingCode } from "../terminal-codes";
 import { isProviderBusy, ProviderBusyError, SEARCH_BUSY_MESSAGE } from "../../sources/provider-errors";
 import { settleWithin } from "../../utils/async-deadline";
 import { companyNameExtraWords } from "../company-name";
+import { delistingLabel } from "../../market-data/quotes/delisting";
 export type {
   ResolvedTickerSearch,
   TickerSearchCandidate,
@@ -58,6 +59,17 @@ const MAX_NAMED_LISTINGS = 6;
  */
 export const LISTING_SEARCH_LIMIT = 30;
 
+/**
+ * A listing's name as a choice between listings gives it: a listing that no
+ * longer trades says so and when ("First Republic Bank · Last traded Apr 28,
+ * 2023"), and drops a name that only repeats its symbol.
+ */
+function listingChoiceName(result: InstrumentSearchResult): string {
+  if (!result.delisting) return result.name;
+  const name = result.name && normalizeTickerSymbol(result.name) !== normalizeTickerSymbol(result.symbol) ? result.name : "";
+  return [name, delistingLabel(result.delisting)].filter(Boolean).join(" · ");
+}
+
 export class AmbiguousTickerError extends Error {
   constructor(readonly query: string, readonly listings: readonly string[], readonly listingNames: Readonly<Record<string, string>> = {}) {
     // Every listing is a choice: a list cut short could leave out the one meant.
@@ -467,7 +479,7 @@ async function resolveTickerSymbol(
   }
   const listings = new Set(matches.map((item) => publicTickerKey(item.symbol, listingExchange(item.result!))));
   const ambiguity = (query: string) => new AmbiguousTickerError(query, [...listings], Object.fromEntries(matches.map((item) => [
-    publicTickerKey(item.symbol, listingExchange(item.result!)), item.result!.name,
+    publicTickerKey(item.symbol, listingExchange(item.result!)), listingChoiceName(item.result!),
   ])));
   if (pickerQuery && listings.size > 1) throw ambiguity(pickerQuery);
   // A code that names several venues (TSE) the symbol trades on more than one of is a choice.
@@ -485,7 +497,12 @@ async function resolveTickerSymbol(
       });
       const exchange = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
       const currency = resolveCurrencyUnit(quote.currency).currency;
-      if (exchange && currency && Number.isFinite(quote.price) && quote.price !== 0
+      const ended = quote.delisting;
+      if (ended) {
+        // The symbol's own quote is a US listing that no longer trades (a bare FRC, whose
+        // venue is not on record): it is the run search offers with the same last session.
+        verified = matches.filter((item) => item.result?.delisting?.lastTradeDate === ended.lastTradeDate);
+      } else if (exchange && currency && Number.isFinite(quote.price) && quote.price !== 0
         && Number.isFinite(quote.lastUpdated) && quote.lastUpdated > 0) {
         const sameSecurity = matches.filter((item) => {
           const result = item.result!;
@@ -663,7 +680,11 @@ async function searchProviderResults(
 
   // A sector word ("defense", which the server answers with rows tagged with it) lists its small companies by
   // name; the server orders "defense ETF" by size, which a name search does not. Those funds lead the list.
-  const theme = withThemeFunds && !assetClass ? themeQueryWord([...byKey.values()], query) : null;
+  // So do they when the funds are asked for by name: "defense etf" searches "defense", whose answer holds
+  // only the few funds tagged with it (not ITA), and "gold miners etf" a phrase no symbol is.
+  const fundsAsked = assetClass?.code === "ETF" || assetClass?.code === "FUND";
+  const theme = withThemeFunds && (!assetClass || fundsAsked)
+    && (themeQueryWord([...byKey.values()], query) || (fundsAsked && /\s/.test(query.trim())));
   if (theme) {
     try {
       const { onPartial: _ignored, ...context } = searchContext ?? {};

package/src/time-series/price-comparison.ts

@@ -123,6 +123,41 @@ export function resolvePriceComparison(
   };
 }
 
+/**
+ * The bars a compared leg pans and zooms over: inside the view only its shared
+ * dates, as the chart shows them, and every loaded bar past either edge of the
+ * view. Clipping the whole buffer to the view left a pan or a zoom out nothing
+ * to move into until the next fetch, and none at all toward newer bars.
+ */
+export function comparedBufferPoints(
+  points: readonly TimeSeriesPoint[],
+  shared: { start: number | null; end: number | null },
+  view: { start: number | null; end: number | null },
+): TimeSeriesPoint[] {
+  const { start, end } = shared;
+  if (start === null || end === null) return [];
+  const before = view.start === null ? Number.NEGATIVE_INFINITY : Math.min(start, view.start);
+  const after = view.end === null ? Number.POSITIVE_INFINITY : Math.max(end, view.end);
+  return points.filter((point) => {
+    const time = point.date.getTime();
+    return time < before || time > after || (time >= start && time <= end);
+  });
+}
+
+/** A compared leg's pan buffer around `view`; see comparedBufferPoints. */
+export function bufferPriceComparison(
+  series: ResolvedSeries,
+  comparison: PriceComparison | null,
+  view: { start: number | null; end: number | null },
+): ResolvedSeries {
+  if (!comparison?.seriesIds.includes(series.id)) return series;
+  return {
+    ...series,
+    latestChangePercent: undefined,
+    points: comparedBufferPoints(series.points, priceComparisonBoundsForSeries(series, comparison)!, view),
+  };
+}
+
 /** Clip only compared legs; raw observations and study inputs stay available in the source cache. */
 export function clipPriceComparison(series: ResolvedSeries, comparison: PriceComparison | null): ResolvedSeries {
   if (!comparison?.seriesIds.includes(series.id)) return series;