@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/utils/main-thread-stall.ts

@@ -9,13 +9,43 @@ const SAMPLE_INTERVAL_MS = 250;
  */
 const STALL_THRESHOLD_MS = 400;
 
+export interface StallEvent {
+  blockedMs: number;
+  /** The last measured section before the stall (perf-marks), if any. */
+  lastMeasured?: string;
+  /** How long before the stall was noticed that section ended. */
+  lastMeasuredEndedMsAgo?: number;
+}
+
+let stallSink: ((event: StallEvent) => void) | null = null;
+
+/**
+ * Where this process's stalls go besides the Debug Log: the stall log and its
+ * report (telemetry/stall-reports.ts), or, in the desktop window, the Bun
+ * process that keeps them.
+ */
+export function setStallSink(next: ((event: StallEvent) => void) | null): () => void {
+  stallSink = next;
+  return () => {
+    if (stallSink === next) stallSink = null;
+  };
+}
+
+function noteStall(event: StallEvent): void {
+  try {
+    stallSink?.(event);
+  } catch {
+    // Intentional ignore: reporting a freeze must never become one.
+  }
+}
+
 export interface MainThreadStallMonitorOptions {
   intervalMs?: number;
   thresholdMs?: number;
   now?: () => number;
   schedule?: (callback: () => void, delayMs: number) => unknown;
   cancel?: (handle: unknown) => void;
-  report?: (blockedMs: number, context: Record<string, unknown>) => void;
+  report?: (blockedMs: number, context: Omit<StallEvent, "blockedMs">) => void;
 }
 
 function defaultNow(): number {
@@ -41,7 +71,10 @@ export function startMainThreadStallMonitor(
   const schedule = options.schedule ?? ((callback, delayMs) => setInterval(callback, delayMs));
   const cancel = options.cancel ?? ((handle) => clearInterval(handle as ReturnType<typeof setInterval>));
   const report = options.report
-    ?? ((blockedMs, context) => recordPerfSample("runtime.stall", blockedMs, context));
+    ?? ((blockedMs, context) => {
+      recordPerfSample("runtime.stall", blockedMs, context);
+      noteStall({ blockedMs, ...context });
+    });
 
   let previous = now();
   const handle = schedule(() => {

package/src/utils/market-capitalization.ts

@@ -20,11 +20,34 @@ function explicitCurrency(currency: string | undefined): currency is string {
   return currency != null && /^[A-Z]{3}$/.test(currency);
 }
 
-/** A lightweight quote can omit capitalization without invalidating the snapshot. */
+/** What every view says for a cap Gloom Cloud withheld, in the words its screener uses. */
+const WITHHELD_MARKET_CAP: Record<NonNullable<Fundamentals["marketCapUnavailable"]>, { gap: string; note: string }> = {
+  "receipt-priced-as-ordinary": {
+    gap: "receipt, no ratio",
+    note: "No market cap: a depositary receipt with no known ratio, whose source's cap is the receipt price x the company's ordinary shares.",
+  },
+};
+
+/**
+ * Why a listing has no market cap when Gloom Cloud withheld it: `gap` for a cell, `note` for a line under a
+ * report. Null when the cap was not withheld.
+ */
+export function withheldMarketCap(fundamentals: Pick<Fundamentals, "unavailableFields" | "marketCapUnavailable"> | undefined):
+  { gap: string; note: string } | null {
+  if (!fundamentals?.unavailableFields?.includes("marketCap")) return null;
+  const reason = fundamentals.marketCapUnavailable ? WITHHELD_MARKET_CAP[fundamentals.marketCapUnavailable] : undefined;
+  return reason ?? { gap: "withheld", note: "No market cap: Gloom Cloud withheld it." };
+}
+
+/**
+ * A lightweight quote can omit capitalization without invalidating the snapshot. A cap Gloom Cloud withheld
+ * (withheldMarketCap) is none, the quote's included.
+ */
 export function selectMarketCapitalization(
   quote: Quote | undefined,
   fundamentals: Fundamentals | undefined,
 ): MarketCapitalization | null {
+  if (withheldMarketCap(fundamentals)) return null;
   if (usableValue(quote?.marketCap) && explicitCurrency(quote?.currency)) {
     return { value: quote.marketCap, currency: quote.currency,
       provenance: { kind: "quote", source: quote.providerId } };

package/src/utils/price-history.ts

@@ -2,7 +2,7 @@ import type { PricePoint, TickerFinancials } from "../types/financials";
 import { canonicalExchange } from "./exchanges";
 import { isRoundTheClockCoin } from "./crypto-pair";
 import { isCurrencyPairListing, isFxMarketOpen, latestFxWeekClose, latestFxWeekOpen } from "./fx-market-hours";
-import { hasPublishedSessionCalendar, historySourceWeekendDays, latestRegularSessionClose, latestRegularSessionOpen, sessionCalendarTimeZone } from "../market-data/market/freshness";
+import { hasPublishedSessionCalendar, historySourceWeekendDays, isMiddayBreakPrint, latestRegularSessionClose, latestRegularSessionOpen, sessionCalendarTimeZone } from "../market-data/market/freshness";
 import { zonedDateTimeParts } from "./zoned-date-time";
 import { regularHistorySessionStaleness } from "../market-data/history-session";
 import type { HistorySession } from "../types/price-history";
@@ -234,6 +234,12 @@ export function isPriceHistoryStaleForCurrentWindow(
   const age = now - latestTime;
   const allowedLag = allowedBarLagMs(intervalMs);
   if (age <= allowedLag) return false;
+  // A venue paused at midday (SSE/SZSE/BSE, TKO, ...) holds the morning's last
+  // bar current through the break, as the quote freshness rule does. A bar is
+  // labelled by its start, so an hourly bar ending at the break is judged by
+  // when it ends.
+  const latestBarEnd = intervalMs != null ? Math.min(latestTime + intervalMs, now) : latestTime;
+  if (isMiddayBreakPrint(latestBarEnd, options.exchange, now, 0)) return false;
   const sessions = listingSessionsAt(now, options);
   if (!sessions) return age > UNSCHEDULED_HISTORY_MAX_AGE_MS;
   const fetchedAt = options.fetchedAt ?? Number.NEGATIVE_INFINITY;

package/src/utils/shell-word.ts

@@ -0,0 +1,8 @@
+/**
+ * One word of a command line as a shell reads it back: as written when it
+ * holds nothing a shell treats specially (`NVDA`, `SAN:EPA`, `BRK.B`), else
+ * in single quotes (`'Altria Group'`, `'$nvda'`, `'AT&T'`).
+ */
+export function shellWord(word: string): string {
+  return /^[\p{L}\p{N}._:@%+,/][\p{L}\p{N}._:@%+,/=-]*$/u.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
+}

package/src/utils/trailing-dividend.ts

@@ -51,7 +51,9 @@ export function inferCadence(payments: readonly Pick<CashDistribution, "exDate">
 }
 
 /**
- * Trailing twelve-month cash as known at `asOf`, one payment per regular period.
+ * The payments trailing twelve-month cash is made of as known at `asOf`, one
+ * per regular period, and how many a year the issuer's cadence pays (null
+ * without a regular cadence).
  *
  * A fixed one-year ex-date window counts a fifth quarterly (or thirteenth
  * monthly) payment when this year's ex-date is a few days earlier than last
@@ -61,13 +63,13 @@ export function inferCadence(payments: readonly Pick<CashDistribution, "exDate">
  * the window holds fewer than one year of payments. Irregular cash uses the
  * plain window, so special distributions are neither dropped nor extended.
  */
-export function trailingCashAt<Payment extends CashDistribution>(payments: readonly Payment[], asOf: Date): number {
+function trailingPayments<Payment extends CashDistribution>(payments: readonly Payment[], asOf: Date): { counted: Payment[]; perYear: number | null; cadence: DistributionCadence | null } {
   const known = payments.filter((payment) => payment.exDate <= asOf && Number.isFinite(payment.amount) && payment.amount > 0)
     .sort((a, b) => a.exDate.getTime() - b.exDate.getTime());
   const cutoff = calendarMonthsBefore(asOf, 12);
   const cadence = inferCadence(known, asOf);
   const regular = cadence ? REGULAR_CADENCE[cadence] : undefined;
-  if (!regular) return known.filter((payment) => payment.exDate > cutoff).reduce((sum, payment) => sum + payment.amount, 0);
+  if (!regular) return { counted: known.filter((payment) => payment.exDate > cutoff), perYear: null, cadence };
 
   const halfPeriod = regular.halfPeriodDays * DAY;
   const graceCutoff = new Date(cutoff.getTime() - Math.min(regular.halfPeriodDays, MAX_LATE_GRACE_DAYS) * DAY);
@@ -94,7 +96,54 @@ export function trailingCashAt<Payment extends CashDistribution>(payments: reado
   const late = candidates.filter((payment) => payment.exDate <= cutoff && payment.exDate > graceCutoff && !superseded.has(payment))
     .reverse()
     .slice(0, Math.max(0, regular.perYear - counted.length));
-  return [...counted, ...late].reduce((sum, payment) => sum + payment.amount, 0);
+  return { counted: [...counted, ...late], perYear: regular.perYear, cadence };
+}
+
+/** Trailing twelve-month cash as known at `asOf` (trailingPayments). */
+export function trailingCashAt<Payment extends CashDistribution>(payments: readonly Payment[], asOf: Date): number {
+  return trailingPayments(payments, asOf).counted.reduce((sum, payment) => sum + payment.amount, 0);
+}
+
+/** How many payments trailing cash counts against how many a year the issuer's cadence pays. */
+export interface TrailingPayments {
+  counted: number;
+  expected: number;
+  cadence: DistributionCadence;
+}
+
+/**
+ * The payments a regular payer's trailing cash counts when it is fewer than
+ * its cadence pays in a year: a hole in the history (ECC's monthly July to
+ * September 2026 distributions), a missed or late payment, or a fund under a
+ * year old. Null for a full year, an irregular payer and an issuer with no
+ * cadence, whose trailing cash is the plain window.
+ */
+export function trailingPaymentShortfall(payments: readonly CashDistribution[], asOf: Date): TrailingPayments | null {
+  const { counted, perYear, cadence } = trailingPayments(payments, asOf);
+  return perYear != null && cadence && counted.length < perYear ? { counted: counted.length, expected: perYear, cadence } : null;
+}
+
+/** Over this ratio between a regular payer's largest and smallest payment of a year, no one payment stands for the year. */
+const UNEVEN_PAYMENT_RATIO = 1.5;
+
+/**
+ * A regular payer's payments of the trailing year when they differ widely:
+ * exactly as many as its cadence pays, the largest more than 1.5 times the
+ * smallest (HSBC's final beside its interims, AstraZeneca's interim beside its
+ * final). Their total is the year's cash, where the latest one annualized is
+ * not (HSBA's interim read as 2.17% a year beside the 4.08% it paid). Null for
+ * an even year, one with a hole or an extra payment, an annual payer and an
+ * irregular one. `latest` is the newest payment's ex-date.
+ */
+export function unevenRegularPayments(payments: readonly CashDistribution[], asOf: Date): { total: number; latest: Date } | null {
+  const { counted, perYear } = trailingPayments(payments, asOf);
+  if (perYear == null || perYear < 2 || counted.length !== perYear) return null;
+  const amounts = counted.map((payment) => payment.amount);
+  if (Math.max(...amounts) <= UNEVEN_PAYMENT_RATIO * Math.min(...amounts)) return null;
+  return {
+    total: atSourcePrecision(amounts.reduce((sum, amount) => sum + amount, 0)),
+    latest: new Date(Math.max(...counted.map((payment) => payment.exDate.getTime()))),
+  };
 }
 
 /** A history row as a paid distribution; null when its date is not a calendar day or its amount is no cash. */

package/src/plugins/builtin/clinical-trials/ticker-sponsor.ts

@@ -1,17 +0,0 @@
-import type { DataProvider } from "../../../types/data-provider";
-import { shortCompanyName } from "../../../tickers/company-name";
-import { classifyInstrumentKind } from "../../../tickers/search/ranking";
-
-/**
- * The company a ticker is, by the name a registry files its studies under:
- * VKTX is "Viking Therapeutics". Read from the listing's quote, which names
- * it; a fund or a contract is no sponsor. Null when no share trades under it.
- */
-export async function tickerSponsorName(dataProvider: Pick<DataProvider, "getQuote"> | null, ticker: string): Promise<string | null> {
-  const symbol = ticker.trim().toUpperCase();
-  if (!dataProvider || !symbol) return null;
-  const quote = await dataProvider.getQuote(symbol).catch(() => null);
-  const name = quote?.name?.trim();
-  const kind = classifyInstrumentKind(quote?.instrumentType);
-  return name && kind !== "fund" && kind !== "derivative" ? shortCompanyName(name) : null;
-}