@gloom-sh/terminal 0.18.5 → 0.19.0

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

@@ -0,0 +1,75 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { StallReportState, StallReporterHost } from "./stall-reports";
+
+/** Next to config.json: one line per stall, newest last. */
+const STALL_LOG_FILE = "stall-log.txt";
+/** Next to config.json: when each kind of stall was last reported, and the counts since. */
+const STATE_FILE = "stall-reports.json";
+/** Past this the log keeps its newer half. */
+const LOG_MAX_BYTES = 256 * 1024;
+
+function readCounts(value: unknown): StallReportState["pending"] {
+  const pending: StallReportState["pending"] = {};
+  if (!value || typeof value !== "object") return pending;
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    const { count, longestMs } = (entry ?? {}) as Record<string, unknown>;
+    if (typeof count === "number" && Number.isFinite(count) && typeof longestMs === "number" && Number.isFinite(longestMs)) {
+      pending[key] = { count, longestMs };
+    }
+  }
+  return pending;
+}
+
+/** The saved state, keeping only entries of the right shape. */
+function parseStallReportState(text: string): StallReportState {
+  const parsed: unknown = JSON.parse(text);
+  const record = parsed && typeof parsed === "object" ? parsed as Record<string, unknown> : {};
+  const sent: Record<string, number> = {};
+  if (record.sent && typeof record.sent === "object") {
+    for (const [key, at] of Object.entries(record.sent as Record<string, unknown>)) {
+      if (typeof at === "number" && Number.isFinite(at)) sent[key] = at;
+    }
+  }
+  return { sent, pending: readCounts(record.pending) };
+}
+
+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");
+}
+
+/** The stall reporter for a Bun process (the terminal app, the desktop app's main process). */
+export function createNodeStallReporterHost(options: {
+  /** The profile's data folder, or null before the config is loaded. */
+  getDataDir(): string | null;
+}): StallReporterHost {
+  const pathFor = (file: string) => {
+    const dir = options.getDataDir();
+    return dir ? join(dir, file) : null;
+  };
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    appendLog: (line) => {
+      const path = pathFor(STALL_LOG_FILE);
+      if (!path) return;
+      mkdirSync(join(path, ".."), { recursive: true });
+      appendFileSync(path, `${line}\n`, "utf-8");
+      trimLog(path);
+    },
+    load: () => {
+      const path = pathFor(STATE_FILE);
+      if (!path || !existsSync(path)) return { sent: {}, pending: {} };
+      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");
+    },
+  };
+}

package/src/telemetry/stall-reports.ts

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

package/src/test-support/preload.ts

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

package/src/theme/themes.ts

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

package/src/tickers/company-name.ts

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

package/src/tickers/listing-venues.ts

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

package/src/tickers/terminal-codes.ts

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

package/src/time-series/alignment.ts

@@ -46,7 +46,7 @@ function isStrictlyOrdered(points: readonly TimeSeriesPoint[]): boolean {
 }
 
 /** Callers only read the result, so ordered input (every market series) is returned as is. */
-function sortedUniquePoints(points: readonly TimeSeriesPoint[]): readonly TimeSeriesPoint[] {
+export function sortedUniquePoints(points: readonly TimeSeriesPoint[]): readonly TimeSeriesPoint[] {
   // Live charts re-resolve on every quote; skip the keyed sort when nothing needs it.
   if (isStrictlyOrdered(points)) return points;
   const byObservation = new Map<string, TimeSeriesPoint>();

package/src/time-series/economic.ts

@@ -1,6 +1,6 @@
 import type { TimeSeriesPoint } from "./types";
 import type { CloudFredSeriesInfoPayload, CloudFredSeriesPayload } from "../api-client";
-import { ICE_CREDIT_SERIES_IDS } from "./ice-credit";
+import { ICE_CREDIT_SERIES_IDS, ICE_HISTORY_LIMIT_NOTICE } from "./ice-credit";
 
 function sourceDate(value: string | undefined): number | null {
   if (!value || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
@@ -8,6 +8,21 @@ function sourceDate(value: string | undefined): number | null {
   return Number.isFinite(time) && new Date(time).toISOString().slice(0, 10) === value ? time : null;
 }
 
+const THREE_YEAR_RETENTION = /Starting in April 2026, this series will only include 3 years of observations\./;
+
+/**
+ * The publisher's cap on how far back an ICE credit series goes, from the
+ * series' own notes, so it lapses if FRED lifts it. Null for any other series.
+ */
+export function fredHistoryLimitNotice(
+  seriesId: string,
+  info: Pick<CloudFredSeriesInfoPayload, "id" | "notes"> | null | undefined,
+): string | null {
+  const id = seriesId.trim().toUpperCase();
+  if (!ICE_CREDIT_SERIES_IDS.has(id) || info?.id.trim().toUpperCase() !== id) return null;
+  return THREE_YEAR_RETENTION.test(info.notes) ? ICE_HISTORY_LIMIT_NOTICE : null;
+}
+
 /** Source coverage is separate from query limits and calculation buffers. */
 export function fredCreditCoverageNotice(
   seriesId: string,
@@ -21,9 +36,8 @@ export function fredCreditCoverageNotice(
   const end = sourceDate(info.observationEnd);
   if (start === null || end === null || start > end) return null;
   if (visibleStart !== null && visibleStart >= start) return null;
-  const retention = /Starting in April 2026, this series will only include 3 years of observations\./.test(info.notes)
-    ? " FRED limits this ICE series to 3 years."
-    : "";
+  const limit = fredHistoryLimitNotice(id, info);
+  const retention = limit ? ` ${limit}` : "";
   // Series metadata and observations can refresh independently. An observation
   // outside the declared span disproves that span; the query's first/last row
   // cannot establish replacement source coverage either.

package/src/time-series/field-catalog.ts

@@ -32,7 +32,7 @@ const FIELDS = [
     unit: "currency",
     unitGroup: "price",
     nativeFrequency: "daily",
-    styles: ["candles", "ohlc", "hlc", "line", "area"],
+    styles: ["candles", "hollow", "heikin-ashi", "ohlc", "hlc", "line", "area"],
     defaultStyle: "candles",
     transforms: MARKET_TRANSFORMS,
     defaultInterpolation: "none",