@gloom-sh/terminal 0.19.0 → 0.19.2

package/src/tickers/ticker-changes.ts

@@ -3,7 +3,7 @@ import type { Quote } from "../types/financials";
 import type { FormerIssuerRecord, TickerChangeHop, TickerChanges } from "../types/ticker-changes";
 import { isCryptoPairSymbol } from "../utils/crypto-pair";
 import { canonicalExchange, isUsListingExchange } from "../utils/exchanges";
-import { sameCompany, shortCompanyName } from "./company-name";
+import { companyNameCase, sameCompany, shortCompanyName } from "./company-name";
 
 /**
  * A symbol that changed (FB became META), as data for `--json`. `moved`: the
@@ -209,7 +209,7 @@ export function movedAwayChange(change: TickerChange | null | undefined): MovedT
  * look. A quote that stopped before the change, or that names the issuer that
  * left, is that issuer's old line rather than a new listing.
  *
- * "FB now lists ProShares S&P 500 Dynamic Daily Buffer ETF; Meta Platforms trades as META (changed 2022-06-09)"
+ * "FB now lists ProShares S&P 500 Dynamic Daily Buffer ETF; FB was Meta Platforms before, now META (changed 2022-06-09)"
  * "HFC became DINO on 2022-03-15"
  * "METV was META until 2022-01-31" (data only: `tickerChangeLine` prints none)
  */
@@ -224,7 +224,8 @@ export function describeTickerChange(
   if (moved) {
     const [first] = moved.hops;
     if (!first) return null;
-    const issuer = moved.name?.trim() ? shortCompanyName(moved.name) : null;
+    // A name filed in capitals ("aTYR PHARMA INC") reads as it is written: aTyr Pharma.
+    const issuer = moved.name?.trim() ? shortCompanyName(companyNameCase(moved.name.trim())) : null;
     const stillTheIssuer = !!current && (
       (current.lastTraded != null && current.lastTraded < day(first.date))
       || (!!current.name && !!moved.name && sameCompany(current.name, moved.name))
@@ -234,8 +235,11 @@ export function describeTickerChange(
     const when = moved.hops.length === 1
       ? `changed ${first.date}`
       : `changed to ${first.to} on ${first.date}${laterHops(moved.hops)}`;
+    // "LIFE now lists Ethos Technologies Inc.; LIFE was aTyr Pharma before, now ATYR (changed 2024-06-05)".
     const note = listed
-      ? `${symbol} now lists ${listed}; ${issuer ?? `the former ${symbol}`} trades as ${moved.symbol} (${when})`
+      ? issuer
+        ? `${symbol} now lists ${listed}; ${symbol} was ${issuer} before, now ${moved.symbol} (${when})`
+        : `${symbol} now lists ${listed}; the former ${symbol} trades as ${moved.symbol} (${when})`
       : `${symbol} became ${first.to} on ${first.date}${laterHops(moved.hops)}`;
     return { symbol, kind: "moved", note, changes: moved.hops, tradesAs: moved.symbol, issuer, listed };
   }

package/src/time-series/market.ts

@@ -1,5 +1,5 @@
 import type { PricePoint, TickerFinancials } from "../types/financials";
-import { pricePointIntegrity, pricePointValues, priceHistoryIntegrityNotice, mergePriceHistoryIntegrity, type PriceHistoryIntegrity } from "../utils/price-history-integrity";
+import { pricePointIntegrity, pricePointValues, pricePointWicks, priceHistoryIntegrityNotice, mergePriceHistoryIntegrity, type PriceHistoryIntegrity } from "../utils/price-history-integrity";
 import { canonicalTimeSeriesFieldId, isFundamentalFieldId, isMarketFieldId } from "./field-catalog";
 import { extractFundamentalSeries } from "./fundamentals";
 import type { ChartSeriesPriceHistoryIntegrity, ResolvedSeries, SecuritySeriesSource, SeriesPeriod, TimeSeriesPoint } from "./types";
@@ -73,8 +73,10 @@ function aggregatePriceHistory(
   for (const point of sorted) {
     const key = periodKey(point.date, period);
     const open = isFiniteNumber(point.open) ? point.open : point.close;
-    const high = isFiniteNumber(point.high) ? point.high : point.close;
-    const low = isFiniteNumber(point.low) ? point.low : point.close;
+    // A wick too far from its bar's body to have traded does not set the week's or month's range.
+    const wicks = pricePointWicks(point);
+    const high = isFiniteNumber(wicks.high) ? wicks.high : isFiniteNumber(point.high) ? Math.max(open, point.close) : point.close;
+    const low = isFiniteNumber(wicks.low) ? wicks.low : isFiniteNumber(point.low) ? Math.min(open, point.close) : point.close;
     const current = buckets.get(key);
     if (!current) {
       buckets.set(key, {

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

@@ -63,7 +63,24 @@ export function observationDate(time: number, series: Pick<ResolvedSeries, "time
   return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
 }
 
-/** Date-only research windows select local sessions; runtime timestamps remain exact. */
+/**
+ * The day the weekly or monthly bar holding `date` is dated by: its week's
+ * Monday or its month's 1st, as `history --from` keeps the week or month its
+ * first date falls in. A daily bar is its own day.
+ */
+function windowBarStart(date: string, resolution: "1d" | "1wk" | "1mo"): string {
+  if (resolution === "1mo") return `${date.slice(0, 7)}-01`;
+  if (resolution === "1d") return date;
+  const day = Date.parse(`${date}T00:00:00Z`);
+  return new Date(day - ((new Date(day).getUTCDay() + 6) % 7) * 86_400_000).toISOString().slice(0, 10);
+}
+
+/**
+ * Date-only research windows select local sessions; runtime timestamps remain
+ * exact. Weekly and monthly bars keep the bar the window starts in: a window
+ * from 2019-12-31 in monthly bars starts with December 2019's, whose close is
+ * that day's, so a comparison is measured from it.
+ */
 export function priceObservationWindowFilter(
   series: ResolvedSeries,
   bounds: { start: number | null; end: number | null },
@@ -74,11 +91,12 @@ export function priceObservationWindowFilter(
   const calendarWindow = calendarBars && dateWindow
     && /^\d{4}-\d{2}-\d{2}$/.test(dateWindow.start)
     && /^\d{4}-\d{2}-\d{2}$/.test(dateWindow.end) ? dateWindow : null;
+  const start = calendarWindow ? windowBarStart(calendarWindow.start, resolution as "1d" | "1wk" | "1mo") : null;
   return (time) => {
     if (!Number.isFinite(time)) return false;
     const key = calendarWindow ? observationDate(time, series) : null;
     return key !== null
-      ? key >= calendarWindow!.start && key <= calendarWindow!.end
+      ? key >= start! && key <= calendarWindow!.end
       : (bounds.start === null || time >= bounds.start) && (bounds.end === null || time <= bounds.end);
   };
 }

package/src/time-series/resolve.ts

@@ -1,4 +1,5 @@
 import { logFailure } from "../utils/log-failure";
+import { servedFromSavedCopy } from "../data/saved-copies";
 import { hasValidQuoteObservationTime } from "../market-data/quotes/freshness";
 import { delistingLabel } from "../market-data/quotes/delisting";
 import { financialPeriodCoverage, financialPeriodCoverageWarnings, limitSeriesObservations } from "./financial-period-coverage";
@@ -827,7 +828,7 @@ async function resolveChartSpecPass(
           cache.capabilitySeriesByRequest.set(key, pending);
           cache.revision += 1;
         }
-        return baseCapabilitySeries(seriesSpec, await pending, index);
+        return asSavedCopy(baseCapabilitySeries(seriesSpec, await pending, index));
       }
       if (seriesSpec.source.kind === "economic") {
         const request: FredSeriesRequest = {
@@ -845,6 +846,8 @@ async function resolveChartSpecPass(
           priorityWarnings.push(`${result.label}: ${coverageNotice}`);
           coverageNotices.push(`${result.label}: ${coverageNotice}`);
         }
+        // A saved copy that answered for a failed refresh is dated in the footer, as every pane's is.
+        if (result && fred.source === "stale-fallback") return asSavedCopy({ ...result, savedAt: fred.fetchedAt });
         const freshnessWarning = staleFredWarning(fred);
         if (result && freshnessWarning) priorityWarnings.push(`${result.label}: ${freshnessWarning}`);
         return result;
@@ -1180,6 +1183,7 @@ async function resolveChartSpecPass(
     loading: false,
     errors,
     warnings: [...new Set([...priorityWarnings, ...warnings])],
+    ...savedCopyOf(rawSeries.filter((entry) => visibleSeriesIds.has(entry.id))),
     ...(coverageNotices.length ? { coverageNotices: [...new Set(coverageNotices)] } : {}),
     ...(returnBasisNotice ? { returnBasisNotice } : {}),
     ...(delistings.size ? { delistings: [...delistings.values()] } : {}),
@@ -1188,3 +1192,18 @@ async function resolveChartSpecPass(
     ...(builtBarSize && rawSeries.some((entry) => entry.barSize === builtBarSize) ? { barSize: builtBarSize } : {}),
   };
 }
+
+/**
+ * A series drawn from a copy a failed refresh left answering (`savedAt`),
+ * marked as one, so a command charting it ends with "couldn't refresh; saved
+ * copy from …" as the app's footer says.
+ */
+function asSavedCopy(series: ResolvedSeries): ResolvedSeries {
+  return series.savedAt != null ? servedFromSavedCopy(series, series.savedAt) : series;
+}
+
+/** The oldest saved copy among `series` that answered for a failed refresh, which the chart's footer dates. */
+function savedCopyOf(series: readonly ResolvedSeries[]): { savedAt?: number } {
+  const saved = series.flatMap((entry) => entry.savedAt != null && Number.isFinite(entry.savedAt) ? [entry.savedAt] : []);
+  return saved.length ? { savedAt: Math.min(...saved) } : {};
+}

package/src/time-series/types.ts

@@ -265,6 +265,8 @@ export interface ResolvedSeries {
   /** Rejected valuation price inputs, retained independently of usable observations. */
   valuationPriceIssues?: import("./valuation-price").ValuationPriceIssue[];
   warning?: string;
+  /** When the copy the points came from was saved (ms), when its refresh failed and that copy answered. */
+  savedAt?: number;
   /** Listed in the legend so it can be restored, but not drawn. */
   hidden?: boolean;
   /**
@@ -324,6 +326,11 @@ export interface ChartResolutionResult {
   loading: boolean;
   errors: string[];
   warnings: string[];
+  /**
+   * The oldest saved copy a shown series answered from after its refresh
+   * failed (ms), which the chart's footer dates: "saved copy from …".
+   */
+  savedAt?: number;
   /**
    * Where a series' source starts after the range asked for, and why (a
    * publisher's cap on history), as `warnings` also carries it, so a report

package/src/types/company-from.ts

@@ -0,0 +1,40 @@
+/**
+ * The listing a pane's company data comes from when it is not the listing on
+ * screen: a receipt or a foreign line (SKHY, HY9H in Frankfurt) reads its
+ * company's home line (000660 on KRX) for news, filings, holders, hiring and
+ * the other company panes. Gloom Cloud names it on those answers.
+ */
+export interface CompanyFrom {
+  symbol: string;
+  /** The venue's code (KRX, FWB2, NASDAQ). */
+  exchange: string;
+  /** The company's name. */
+  name?: string;
+}
+
+const US_VENUES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "BATS", "CBOE", "IEX"]);
+
+/** The listing as the note names it: `000660 KRX`, or `SKHY` on a US venue. */
+export function companyFromLabel(from: CompanyFrom): string {
+  const exchange = from.exchange.trim().toUpperCase();
+  return exchange && !US_VENUES.has(exchange) ? `${from.symbol} ${exchange}` : from.symbol;
+}
+
+/** The note's listing from an answer's field, or null when the answer names none or something malformed. */
+export function readCompanyFrom(value: unknown): CompanyFrom | null {
+  if (!value || typeof value !== "object") return null;
+  const { symbol, exchange, name } = value as Record<string, unknown>;
+  if (typeof symbol !== "string" || !symbol.trim() || typeof exchange !== "string") return null;
+  return { symbol: symbol.trim(), exchange: exchange.trim(), ...(typeof name === "string" && name.trim() ? { name: name.trim() } : {}) };
+}
+
+/**
+ * What a report says under company data read from another listing, as the
+ * pane's footer does: "Company data from 000660 KRX (SK hynix)." Empty when
+ * the data is the listing's own, so a report's notes spread it as they are.
+ */
+export function companyDataNotes(from: CompanyFrom | null | undefined): string[] {
+  if (!from) return [];
+  const listing = companyFromLabel(from);
+  return [`Company data from ${listing}${from.name && from.name !== from.symbol ? ` (${from.name})` : ""}.`];
+}

package/src/types/data-provider.ts

@@ -1,3 +1,4 @@
+import type { CompanyFrom } from "./company-from";
 import type { ExchangeRateSnapshot } from "./exchange-rate";
 import type {
   AnalystResearchData,
@@ -61,6 +62,12 @@ export interface SecFilingItem {
    * series list reaches).
    */
   fundSeries?: boolean;
+  /**
+   * The company's home line the filing was read from, when the listing asked
+   * is a receipt or a foreign line with no filer of its own (HY9H in
+   * Frankfurt reads SK hynix's). Absent on the listing's own filings.
+   */
+  companyFrom?: CompanyFrom;
 }
 
 export interface SecFilingDocument {

package/src/types/financials.ts

@@ -1,3 +1,4 @@
+import type { CompanyFrom } from "./company-from";
 import type { PerpBoardRow } from "../api-client/perps";
 import type { PriceBasis } from "./instrument";
 
@@ -87,6 +88,26 @@ export interface DepositaryPair {
   ordinary: string[];
 }
 
+/**
+ * A Buenos Aires CEDEAR's ratio from BYMA's published list, as Gloom Cloud
+ * serves it: 20 AAPL:BYMA are 1 Apple share. Its market cap is the company's,
+ * in the currency of the listing it stands for.
+ */
+export interface CedearRatio {
+  /** The CEDEAR's listing: AAPL:BYMA. */
+  listing: string;
+  /** CEDEARs that make `shares` of the company's shares: 20 for Apple. */
+  receipts: number;
+  /** The company's shares `receipts` CEDEARs stand for: 1 for Apple, 8 for BABA's 9 (one receipt of 8 shares). */
+  shares: number;
+  /** The company as the list names it: "Apple Inc.". */
+  company: string;
+  /** The listing it stands for, as a ticker: AAPL, VALE3.SA. */
+  underlying: string;
+  /** The date of BYMA's list. */
+  listedAt: string;
+}
+
 /** How a depositary receipt relates to the ordinary shares, as Gloom Cloud states it. */
 interface DepositaryReceiptFacts {
   /** Whether the listing is a depositary receipt; absent when unknown. */
@@ -95,6 +116,8 @@ interface DepositaryReceiptFacts {
   adrRatio?: number;
   /** The receipt and its home lines, on the receipt's records and each home line's. */
   depositaryPair?: DepositaryPair;
+  /** A Buenos Aires CEDEAR's ratio, on its records. */
+  cedearRatio?: CedearRatio;
 }
 
 export interface Quote extends DepositaryReceiptFacts {
@@ -245,7 +268,8 @@ export interface TtmConversion {
 }
 
 /**
- * How a served enterprise value ties to market cap + total debt - cash from the latest balance sheet served beside it.
+ * How a served enterprise value ties to market cap + total debt (+ leases, `leases`) - cash from the latest balance sheet
+ * served beside it.
  * `matches` within 5%; `differs` beyond it (or beyond 2% on the other side of the market cap from net debt), within
  * 0.7x to 1.5x, shown labelled as the provider's; `withdrawn` outside that band, with no EV or EV/revenue; `unchecked`
  * without a recent balance sheet carrying both lines. `computed`: an insurer's or a holding company's EV, which is
@@ -261,15 +285,24 @@ export interface EnterpriseValueCheck {
   /** The market cap the EV is measured on; absent only on a not-meaningful source EV served without one. */
   marketCap?: number;
   totalDebt?: number;
+  /** The balance sheet's lease liabilities the bridge adds to total debt, as FA's net debt does (utils/lease-liabilities); absent when none were added. */
+  leases?: number;
   cash?: number;
   /** YYYY-MM-DD of the balance sheet the debt and cash come from. */
   balanceSheetDate?: string;
-  /** marketCap + totalDebt - cash. */
+  /** marketCap + totalDebt + leases - cash. */
   computed?: number;
   /** `cash` is cash and equivalents alone: an insurer's or a holding company's investments stay in its EV. */
   investmentsKept?: true;
-  /** Why the EV is not meaningful (`not-meaningful`). */
+  /** Why the EV is not meaningful (`not-meaningful`), or why a withdrawn EV no balance sheet checked is withdrawn. */
   reason?: string;
+  /** A balance sheet in another currency than the market cap: its currency and the rate at its date
+   * (`currency` per unit of `from`) that `totalDebt`, `leases` and `cash` were converted at. */
+  fx?: { from: string; rate: number };
+  /** The provider converted its EV from the statements' currency. */
+  convertedFrom?: string;
+  /** Withdrawn because the provider applied that conversion twice: its EV over `computed` is the conversion rate. */
+  convertedTwice?: true;
 }
 
 /** How a trailing P/E converts the EPS it divides by, when that EPS is in another currency than the price. */
@@ -436,6 +469,8 @@ export interface HolderData extends DepositaryReceiptFacts {
   asOf?: string;
   summary?: HolderSummary;
   holders: HolderRecord[];
+  /** The company's home line the data is read from, when not the listing asked (a receipt, a foreign line). */
+  companyFrom?: CompanyFrom;
 }
 
 interface AnalystPriceTarget {
@@ -514,6 +549,8 @@ export interface DeclaredDividendAction {
   declarationDate?: string;
   recordDate?: string;
   payDate?: string;
+  /** A one-off beside the regular payments (AIOK's $3.50), as the server marks it. */
+  special?: true;
 }
 
 export interface SplitAction {
@@ -757,6 +794,11 @@ export interface FinancialStatement {
   date: string;
   /** Source of the fiscal period date; does not establish metric publication dates. */
   dateSource?: "sec" | "provider";
+  /**
+   * The accounting standard the issuer reports in, from the taxonomy of its latest annual report to the SEC (10-K,
+   * 20-F or 40-F): BABA's 20-F is US GAAP, NVO's IFRS. Absent for a company that files none with the SEC.
+   */
+  accountingStandard?: "us-gaap" | "ifrs";
   /** Original vendor period date when independent filing evidence changes it. */
   providerDate?: string;
   /** Filing evidence for the period identity only, not availability of every field. */

package/src/types/headless.ts

@@ -403,6 +403,12 @@ export interface HeadlessPaneFreshness {
    * `newest story` dates a news list `newest story Tue 29 Sep 2026 20:17 UTC`.
    */
   asOfLabel?: string;
+  /**
+   * Say when the rows were retrieved too, after the newest one's date: a list
+   * dated by its newest filing was not read then (`newest filing Tue 27 Oct
+   * 2026 · retrieved Wed 28 Oct 2026 19:07 UTC`).
+   */
+  retrievedToo?: boolean;
   /** What the figures are, said after the status: `funding = current estimate, pays 08:00 UTC`. */
   note?: string;
   /**

package/src/ui/host.tsx

@@ -709,7 +709,12 @@ export interface SaveTextFileRequest {
 
 export interface RendererHost {
   requestExit(): void;
-  startWindowDrag?(): Promise<void> | void;
+  /**
+   * From a press on a title bar. `press.detail` counts the clicks: where the
+   * system's title bars maximize on a double-click, the second press does that
+   * instead of moving the window.
+   */
+  startWindowDrag?(press?: { detail?: number }): Promise<void> | void;
   controlWindow?(action: "minimize" | "toggle-maximize" | "close"): Promise<void> | void;
   /**
    * Opens a link in the person's browser. Resolves false when no browser could

package/src/utils/crypto-pair.ts

@@ -1,4 +1,4 @@
-import { canonicalExchange, parsePublicTickerKey } from "./exchanges";
+import { canonicalExchange, EXCHANGE_TIME_ZONES, isKnownExchangeCode, parsePublicTickerKey } from "./exchanges";
 
 // The fiat codes a pair against USD is read as FX for, never as a coin. The
 // list Cloud reads: it serves these pairs by the same rule, so a copy judged
@@ -9,8 +9,8 @@ const FIAT_CURRENCY_CODES = new Set([
 ]);
 
 const USD_COIN_PAIR = /^([A-Z0-9]+)[-/]USD$/;
-// The other currencies and coins the crypto venue quotes a coin in (BTC-EUR, ETH-BTC).
-const QUOTED_COIN_PAIR = /^([A-Z0-9]+)[-/](?:USDT|USDC|EUR|GBP|BTC|ETH)$/;
+// The other currencies and coins the crypto venue quotes a coin in (BTC-EUR, BTC-JPY, ETH-BTC).
+const QUOTED_COIN_PAIR = /^([A-Z0-9]+)[-/](?:USDT|USDC|EUR|GBP|JPY|KRW|CAD|INR|CNY|AUD|BTC|ETH)$/;
 
 /** A coin quoted in dollars (BTC-USD, ETH/USD). EUR-USD is spot FX, not a coin. */
 function isUsdCoinPair(symbol: string): boolean {
@@ -35,10 +35,18 @@ export function isRoundTheClockCoin(symbol?: string, exchange?: string): boolean
   const parsed = symbol ? parsePublicTickerKey(symbol) : null;
   const venue = canonicalExchange(parsed?.exchange ?? exchange) || canonicalExchange(exchange);
   if (venue === "CCC" || canonicalExchange(exchange) === "CCC") return true;
+  if (parsed && exchangeLineCoinListing(parsed.symbol, venue)) return true;
   return !!parsed && (isUsdCoinPair(parsed.symbol) || (!venue && isQuotedCoinPair(parsed.symbol)));
 }
 
-const SLASH_COIN_PAIR = /^([A-Z0-9]{1,15})\/(USD|EUR|GBP|USDT|USDC|BTC)$/;
+const SLASH_COIN_PAIR = /^([A-Z0-9]{1,15})\/(USD|EUR|GBP|JPY|KRW|CAD|INR|CNY|AUD|USDT|USDC|BTC|ETH)$/;
+
+/**
+ * What the crypto venue (CCC) quotes a coin in: BTC-GBP, BTC-KRW, LINK-ETH.
+ * It has no coin in a stablecoin (BTC-USDT) or in most other currencies
+ * (BTC-TRY, BTC-BRL).
+ */
+const VENUE_QUOTE_LEGS: ReadonlySet<string> = new Set(["USD", "EUR", "GBP", "JPY", "KRW", "CAD", "INR", "CNY", "AUD", "BTC", "ETH"]);
 
 let isoCurrencyCodes: ReadonlySet<string> | null = null;
 
@@ -58,9 +66,114 @@ export function dashedCoinPair(symbol: string): string | null {
   return `${match[1]}-${match[2]}`;
 }
 
+/**
+ * The crypto exchanges whose own lines of a coin pair search lists in a currency the crypto venue quotes coins in,
+ * and the venue itself. A slash pair saved on any other venue, or on none, is not read as a coin: on the commodity
+ * or currency venue it is spot crude, gold by the gram or a currency (WTI/USD, GAU/USD, RUB/USD).
+ */
+const COIN_EXCHANGES: ReadonlySet<string> = new Set([
+  "CCC", "BIGONE", "BINANCE", "BITBANK", "BITBNS", "BITFINEX", "BITFLYER", "BITHUMB", "BITMART", "BITRUE", "BITSTAMP",
+  "BTC MARKETS", "BYBIT", "CEX.IO", "COINBASE PRO", "COINONE", "CRYPTO.COM EXCHANGE", "FREIEXCHANGE", "GATE.IO", "HITBTC",
+  "HUOBI", "INDEPENDENT RESERVE", "KRAKEN", "KUCOIN", "LATOKEN", "MEXC", "MXC", "OKEX", "OKX", "POLONIEX", "SYNTHETIC",
+  "UNISWAP", "UPBIT", "WAZIRX", "XT.COM", "YOBIT", "ZAIF",
+]);
+
+/** Venues whose slash pairs are commodities or currencies, never coins, whatever a row's type says. */
+const NOT_COIN_VENUES: ReadonlySet<string> = new Set(["COMMODITY", "CCY", "FX", "FOREX", "CURRENCY", "PHYSICAL CURRENCY"]);
+
+/**
+ * Spot commodities written as a pair: gold, silver, platinum and palladium, gold and silver by the gram (GAU,
+ * XAGG), WTI, Brent (XBR) and Urals crude, and copper (HG1). Never a coin, though tokens share the letters
+ * (GAU-USD is Gamer Arena).
+ */
+const SPOT_COMMODITY_BASES: ReadonlySet<string> = new Set(["XAU", "GAU", "XAG", "XAGG", "XPT", "XPD", "WTI", "XBR", "URALS", "HG1"]);
+
+/** A spot commodity's pair (WTI/USD, GAU/USD) or a pair on the commodity or currency venue, which no coin is. */
+export function isSpotCommodityOrCurrencyPair(symbol: string, exchange?: string): boolean {
+  const parsed = parsePublicTickerKey(symbol.trim().toUpperCase());
+  const named = (parsed.exchange ?? exchange ?? "").trim().toUpperCase();
+  const base = /^([A-Z0-9]{1,15})\//.exec(parsed.symbol)?.[1];
+  return !!base && (SPOT_COMMODITY_BASES.has(base) || NOT_COIN_VENUES.has(named) || NOT_COIN_VENUES.has(canonicalExchange(named)));
+}
+
+/** The crypto venue's listing of a coin pair written with a slash (BTC/GBP); null for a currency, a spot commodity or another leg. */
+function slashCoinPairListing(symbol: string): { symbol: string; exchange: "CCC"; currency: string } | null {
+  const match = SLASH_COIN_PAIR.exec(symbol.trim().toUpperCase());
+  if (!match) return null;
+  const [, base, quote] = match as unknown as [string, string, string];
+  if (isIsoCurrencyCode(base) || SPOT_COMMODITY_BASES.has(base) || !VENUE_QUOTE_LEGS.has(quote)) return null;
+  return { symbol: `${base}-${quote}`, exchange: "CCC", currency: quote };
+}
+
+/**
+ * A crypto exchange's own line of a coin pair (BTC/GBP on COINBASE PRO, LINK/EUR on KRAKEN, DOGE/BTC on BINANCE)
+ * as the crypto venue's listing of it, in the currency it is quoted in: BTC-GBP on CCC, in pounds. Search offers
+ * those lines, and no source quotes them.
+ *
+ * Only a pair on a crypto exchange (COIN_EXCHANGES) is one, or a search row whose type says it is a coin
+ * (`coinRow`) on a venue that is no stock, commodity or currency venue. Null for a currency pair (EUR/USD,
+ * RUB/USD), a spot commodity (XAU/USD, WTI/USD), a pair the venue quotes in no such currency (BTC/USDT), a pair
+ * with no venue, and a slash on a stock exchange, which is a share class (BRK/B).
+ */
+export function exchangeLineCoinListing(
+  symbol: string,
+  exchange?: string,
+  { coinRow = false }: { coinRow?: boolean } = {},
+): { symbol: string; exchange: "CCC"; currency: string } | null {
+  const parsed = parsePublicTickerKey(symbol);
+  const listing = slashCoinPairListing(parsed.symbol);
+  if (!listing) return null;
+  const named = (parsed.exchange ?? exchange ?? "").trim().toUpperCase();
+  const venue = canonicalExchange(named);
+  if (COIN_EXCHANGES.has(named) || COIN_EXCHANGES.has(venue)) return listing;
+  if (!coinRow || !venue || NOT_COIN_VENUES.has(named) || NOT_COIN_VENUES.has(venue)) return null;
+  // The crypto venues trade around the clock; a venue the app knows that does not is a stock exchange.
+  return isKnownExchangeCode(venue) && EXCHANGE_TIME_ZONES[venue] !== "UTC" ? null : listing;
+}
+
+/**
+ * A coin pair typed with a slash (btc/gbp) as the crypto venue's listing of it, BTC-GBP on CCC; with a venue
+ * (BTC/GBP:KRAKEN), as that exchange's line reads (exchangeLineCoinListing). Null for a currency pair, a spot
+ * commodity (wti/usd) and a pair the venue quotes in no such currency.
+ */
+export function typedCoinPairListing(query: string): { symbol: string; exchange: "CCC"; currency: string } | null {
+  const parsed = parsePublicTickerKey(query.trim().toUpperCase());
+  return parsed.exchange ? exchangeLineCoinListing(parsed.symbol, parsed.exchange) : slashCoinPairListing(parsed.symbol);
+}
+
+/**
+ * Search rows with each crypto exchange's line of a coin pair (ETH/EUR on KRAKEN, COINBASE PRO, BITSTAMP and
+ * BINANCE) as the crypto venue's one listing of it, ETH-EUR on CCC in euros, where the first line stood. A pair
+ * already offered on the venue is not offered twice. Newer servers send the listing themselves.
+ */
+export function withExchangeLinesAsCoinListings<T extends { symbol: string; exchange: string; type: string; currency?: string; brokerContract?: unknown }>(rows: T[]): T[] {
+  const offered = new Set(rows.filter((row) => canonicalExchange(row.exchange) === "CCC").map((row) => row.symbol.trim().toUpperCase()));
+  let changed = false;
+  const mapped = rows.flatMap((row) => {
+    const coin = !row.brokerContract && isCoinRowType(row.type) ? exchangeLineCoinListing(row.symbol, row.exchange, { coinRow: true }) : null;
+    if (!coin) return [row];
+    changed = true;
+    if (offered.has(coin.symbol)) return [];
+    offered.add(coin.symbol);
+    return [{ ...row, symbol: coin.symbol, exchange: coin.exchange, currency: row.currency || coin.currency }];
+  });
+  return changed ? mapped : rows;
+}
+
+/** Whether a search row's type says it is a coin (CRYPTOCURRENCY, Digital Currency). */
+export function isCoinRowType(type: string | undefined): boolean {
+  return /CRYPTO|DIGITAL|COIN/i.test(type ?? "");
+}
+
+/** The currency or coin a pair on the crypto venue is quoted in: GBP for BTC-GBP; null for anything else. */
+export function coinPairQuoteCurrency(symbol: string): string | null {
+  const match = /^([A-Z0-9]{1,15})-([A-Z]{3})$/.exec(parsePublicTickerKey(symbol).symbol);
+  return match && !isIsoCurrencyCode(match[1]!) && VENUE_QUOTE_LEGS.has(match[2]!) ? match[2]! : null;
+}
+
 // A base-quote pair such as BTC-USD or SOL-EUR. Equities with a share-class dash (BRK-B) and
 // currency pairs (EURUSD=X) do not match.
-const CRYPTO_PAIR = /^[A-Z0-9]{1,15}-(?:USD|EUR|GBP|USDT|USDC|BTC)$/;
+const CRYPTO_PAIR = /^[A-Z0-9]{1,15}-(?:USD|EUR|GBP|JPY|KRW|CAD|INR|CNY|AUD|USDT|USDC|BTC|ETH)$/;
 
 /**
  * Wider than isUsdCoinPair, for the hint under a pair that will not load: it
@@ -135,9 +248,10 @@ export const TOP_COIN_NAMES: ReadonlyMap<string, string> = new Map([
   ["RENDER", "render"],
 ]);
 
-const COIN_PAIR = /^([A-Z0-9]{1,15})[-/](?:USD|EUR|GBP|USDT|USDC|BTC)$/;
+const COIN_PAIR = /^([A-Z0-9]{1,15})[-/](?:USD|EUR|GBP|JPY|KRW|CAD|INR|CNY|AUD|USDT|USDC|BTC|ETH)$/;
 // What a pair's listing name adds after the coin's: its quote currency, an id in brackets.
-const PAIR_NAME_SUFFIX = /(?:\s*\([^)]*\))+$|\s+(?:USD|EUR|GBP|USDT|USDC|BTC|US Dollars?)$/i;
+// Not ETH, which ends coins' own names (Lido Staked ETH).
+const PAIR_NAME_SUFFIX = /(?:\s*\([^)]*\))+$|\s+(?:USD|EUR|GBP|JPY|KRW|CAD|INR|CNY|AUD|USDT|USDC|BTC|US Dollars?)$/i;
 
 /**
  * The coin a crypto pair trades, as stories name it: "bitcoin" for BTC-USD

package/src/utils/declared-dividends.ts

@@ -34,6 +34,6 @@ export function declaredDividends(
     const at = Date.parse(`${exDate}T00:00:00Z`);
     if (paid.some((time) => Math.abs(time - at) <= SAME_DISTRIBUTION_DAYS * DAY_MS)) return [];
     return [{ exDate, amount: row.amount, ...declarationDate ? { declarationDate } : {},
-      ...recordDate ? { recordDate } : {}, ...payDate ? { payDate } : {} }];
+      ...recordDate ? { recordDate } : {}, ...payDate ? { payDate } : {}, ...row.special === true ? { special: true as const } : {} }];
   }).sort((left, right) => left.exDate.localeCompare(right.exDate));
 }