@gloom-sh/terminal 0.19.0 → 0.19.1

package/src/sources/gloomberb-cloud/index.ts

@@ -1,4 +1,5 @@
 import { logFailure } from "../../utils/log-failure";
+import { readCompanyFrom } from "../../types/company-from";
 import { exchangeRateMetadata } from "../../utils/exchange-rate-snapshot";
 import type { ExchangeRateSnapshot } from "../../types/exchange-rate";
 import type { TimeRange } from "../../time-series/range";
@@ -42,7 +43,7 @@ import {
 import type { NewsArticle, NewsQuery } from "../../types/news-source";
 import { normalizeNewsFeed } from "../../news/news-model";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
-import { isRoundTheClockCoin } from "../../utils/crypto-pair";
+import { exchangeLineCoinListing, isRoundTheClockCoin, withExchangeLinesAsCoinListings } from "../../utils/crypto-pair";
 import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss, ProviderBusyError, providerMissReason, StaleHistoryError } from "../provider-errors";
@@ -315,14 +316,35 @@ function cloudResponseTargetKey(key: string, requested: Set<string>): string | u
 
 /**
  * The listing as Gloom Cloud knows it. A Hong Kong code goes out with its four
- * digits: Cloud has no 700 or 5 on HKEX, only 0700 and 0005.
+ * digits: Cloud has no 700 or 5 on HKEX, only 0700 and 0005. A crypto
+ * exchange's line of a coin pair (BTC/GBP on COINBASE PRO), which no source
+ * quotes, goes out as the crypto venue's listing of the pair, BTC-GBP on CCC.
  */
 function cloudInstrumentTarget(symbol: string, exchange?: string) {
   rejectPredictionMarket(symbol, exchange);
   const target = publicListingTarget(symbol, exchange);
+  const coin = exchangeLineCoinListing(target.symbol, target.exchange);
+  if (coin) return { symbol: coin.symbol, exchange: coin.exchange };
   return target.exchange ? { ...target, symbol: hongKongListingCode(target.symbol, target.exchange) } : target;
 }
 
+/**
+ * Whether a quote names a listing other than the one asked for: asked for BHP
+ * on Cboe Australia, Gloom Cloud has answered with BHP on NYSE, in dollars. A
+ * price for another instrument is worse than none. A quote that names no
+ * listing is judged by its symbol alone, as the router judges it.
+ */
+function pricesOtherListing(quote: Quote, target: ReturnType<typeof cloudInstrumentTarget>): boolean {
+  const metadata = quoteMetadataFromQuote(quote);
+  const named = !!(metadata.listingExchangeName || parsePublicTickerKey(quote.symbol).exchange);
+  return !quoteMetadataMatchesTarget(metadata, named ? target.symbol : parsePublicTickerKey(target.symbol).symbol, named ? target.exchange : undefined);
+}
+
+function otherListingMiss(ticker: string, quote: Quote) {
+  const venue = quote.listingExchangeName || quote.exchangeName || parsePublicTickerKey(quote.symbol).exchange;
+  return createProviderMiss(`Cloud quoted ${quote.symbol}${venue ? ` on ${venue}` : ""} for ${ticker}`);
+}
+
 function cloudHistoryRecovery(
   context: MarketDataRequestContext | undefined,
   ticker: string, symbol: string, exchange: string, interval: string, start: Date, end: Date,
@@ -520,10 +542,12 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return withCloudFallback(
       async () => {
         const response = await apiClient.getCloudQuote(target.symbol, target.exchange);
-        const quote = retainRequestedQuoteSymbol(mapQuote(
+        const answered = mapQuote(
           unwrapRequiredCloudResponse(response, `Cloud quotes are unavailable for ${ticker}`),
           response.providerMeta,
-        ), ticker);
+        );
+        if (pricesOtherListing(answered, target)) throw otherListingMiss(ticker, answered);
+        const quote = retainRequestedQuoteSymbol(answered, ticker);
         // A stale answer is the last price the service has. It stays flagged, so
         // no freshness check passes it and only a request with no current quote
         // from any source falls back to it.
@@ -585,7 +609,11 @@ export class GloomberbCloudProvider implements AssetDataProvider {
           return { target, quote: null, error: createProviderMiss(`Cloud quotes are stale for ${target.symbol}`) };
         }
         if ((item.status === "success" || item.status === "partial") && item.data) {
-          const quote = retainRequestedQuoteSymbol(mapQuote(item.data), target.symbol);
+          const answered = mapQuote(item.data);
+          if (pricesOtherListing(answered, cloudInstrumentTarget(target.symbol, target.exchange))) {
+            return { target, quote: null, error: otherListingMiss(target.symbol, answered) };
+          }
+          const quote = retainRequestedQuoteSymbol(answered, target.symbol);
           return { target, quote: item.stale === true ? { ...quote, stale: true } : quote };
         }
         return {
@@ -617,8 +645,9 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     // Perpetual markets are listings too, asked for beside the others. They are optional: a failed lookup leaves the
     // other results, and a keystroke waits for them only briefly once the listings are in, unless the query names one.
     const pending = searchPerpetualMarkets(query).catch(logFailure("sources.gloomberb-cloud.index", "Searching perpetual markets failed", [] as InstrumentSearchResult[]));
+    // A crypto exchange's line of a coin pair, which no source quotes, is offered as the crypto venue's listing.
     const listings = await withCloudFallback(
-      () => apiClient.searchInstruments(query, context?.limit ?? 10),
+      async () => withExchangeLinesAsCoinListings(await apiClient.searchInstruments(query, context?.limit ?? 10)),
       "Cloud search is unavailable",
     ).catch((error: unknown) => {
       // Rate limited or overloaded: the search was not run, which is not a search that found nothing.
@@ -637,9 +666,12 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const name = venue ? context?.listingName?.trim() || await this.listingName(ticker, venue) || undefined : undefined;
     const filings = await withCloudFallback(async () => {
       const response = await apiClient.getCloudSecFilings({ ticker, exchange, name, limit: count, offset: 0 });
-      return response.filings.map(mapCloudSecFiling);
+      // A foreign line's filings read from its company's home line say whose, each of them.
+      const companyFrom = readCompanyFrom(response.companyFrom);
+      return response.filings.map((filing) => companyFrom ? { ...mapCloudSecFiling(filing), companyFrom } : mapCloudSecFiling(filing));
     }, `Cloud SEC filings are unavailable for ${ticker}`);
-    if (!venue || filings.length === 0) return filings;
+    // The service matched a line read from its company's home line to the company itself.
+    if (!venue || filings.length === 0 || filings[0]!.companyFrom) return filings;
     const symbol = parsePublicTickerKey(ticker).symbol;
     // Without the listing's company the filings cannot be told apart from another company's.
     if (!name) throw createProviderMiss(`SEC filings for ${symbol} could not be matched to its ${venue} listing`);
@@ -732,6 +764,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   async searchBatch(queries: string[], options: { limit?: number; signal?: AbortSignal } = {}): Promise<Map<string, InstrumentSearchResult[]> | null> {
     const answers = await cloudSearchBatch(queries, options);
     if (!answers) return null;
+    for (const [query, rows] of answers) answers.set(query, withExchangeLinesAsCoinListings(rows));
     // Perpetual markets lead each answer, as `search` gives them, so a symbol in a list resolves as it does alone:
     // one read of the board answers every query's search of it. A query that found no listing is searched again
     // on its own, which finds them then; a board that does not answer leaves them out, as a search does.
@@ -965,6 +998,7 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
             articles: cloudNewsReadArticles(read, query.ticker),
             nextCursor: read.nextCursor ?? null,
             access: read.access ?? null,
+            companyFrom: readCompanyFrom(read.companyFrom),
           };
         },
         async fetchNews(query: NewsQuery): Promise<NewsArticle[]> {

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

@@ -1,5 +1,6 @@
 import { logFailure } from "../utils/log-failure";
 import type { DataProvider } from "../types/data-provider";
+import type { Quote } from "../types/financials";
 import type { InstrumentSearchResult } from "../types/instrument";
 import { canonicalExchange, isUsListingExchange, parsePublicTickerKey } from "../utils/exchanges";
 import { companyNameMatch, sameCompany, shortCompanyName } from "./company-name";
@@ -12,7 +13,7 @@ import { hasNonLatinLetters } from "../utils/typed-text";
 
 export interface CompanyNameListing {
   symbol: string;
-  /** Canonical code of its exchange. */
+  /** Canonical code of its exchange; empty for a US symbol read bare (a line its company `moved` to). */
   exchange: string;
   /** The listing's name as search gives it. */
   name: string;
@@ -22,8 +23,24 @@ export interface CompanyNameListing {
    * run together (JPM, JPMorgan Chase & Co.), which the reader is asked about.
    */
   meant?: Omit<CompanyNameListing, "meant">;
+  /**
+   * When the company's US line, which search still lists, moved to another
+   * symbol and this is the line it trades as now (GETY became GETYQ): the
+   * change in one line, "GETY became GETYQ on 2026-10-22".
+   */
+  moved?: string;
 }
 
+/**
+ * Where a listing's company trades now when it moved off the symbol (GETY
+ * became GETYQ on 2026-10-22), from the line's quote (null when it has none)
+ * and the name search gives it: the symbol it took, and the change in one
+ * line. Null when it did not move, or that cannot be told.
+ */
+export type MovedLineLookup = (
+  listing: { symbol: string; exchange: string; quote: Quote | null; name: string | null },
+) => Promise<{ symbol: string; note: string } | null>;
+
 /** Share lines that are not the company's common stock, though search may type them as such. */
 const NOT_COMMON = /preferred|warrant|right|unit|note|bond|debenture/i;
 const RECEIPT = /depositary|^(?:ADR|ADS|GDR|CDR|BDR)$/i;
@@ -70,7 +87,7 @@ export function isCompanyNameInput(input: string): boolean {
 export async function findListingOfCompanyName(
   dataProvider: Pick<DataProvider, "search"> & Partial<Pick<DataProvider, "getQuote">>,
   typed: string,
-  options: { meant?: boolean; oneWord?: boolean; quoted?: boolean } = {},
+  options: { meant?: boolean; oneWord?: boolean; quoted?: boolean; movedLine?: MovedLineLookup } = {},
 ): Promise<CompanyNameListing | null> {
   const name = typed.trim();
   if (!name) return null;
@@ -110,8 +127,12 @@ export async function findListingOfCompanyName(
   const lines = ranked.filter((listing) => listing === first || (!listing.home && !otherHomes.has(plainName(listing.result.name))
     && sameCompany(first.result.name, listing.result.name)
     && listing.rank.slice(0, NAME_RANKS).every((value, index) => value === first.rank[index])));
-  const best = options.quoted ? await firstQuoted(dataProvider, lines) : first;
-  const found = { symbol: best.result.symbol.toUpperCase(), exchange: best.exchange, name: best.result.name };
+  const quoted = options.quoted ? await firstQuoted(dataProvider, lines, options.movedLine) : { line: first, moved: null };
+  const best = quoted.line;
+  const found: CompanyNameListing = quoted.moved
+    // The line it moved to is a US symbol, read bare as `quote` reads one (GETYQ, which trades over the counter).
+    ? { symbol: quoted.moved.symbol, exchange: "", name: best.result.name, moved: quoted.moved.note }
+    : { symbol: best.result.symbol.toUpperCase(), exchange: best.exchange, name: best.result.name };
   const meant = best.stock && options.meant ? await stockNamedRunTogether(dataProvider, name, results) : null;
   return meant ? { ...found, meant } : found;
 }
@@ -127,22 +148,41 @@ interface RankedListing {
   exchange: string;
 }
 
+/** A US exchange, or the US over-the-counter market a line moves to when it leaves one. */
+function isUsVenue(exchange: string): boolean {
+  return isUsListingExchange(exchange) || exchange.startsWith("OTC") || exchange === "PNK";
+}
+
 /**
  * The first of a company's lines, in their order, that has a quote: the first
  * itself, or when it has none, the first of the next few that does, asked
- * together. The first stands when none has a quote, when the source is too
- * busy to say, and when nothing here can ask for quotes.
+ * together. A first US line whose company moved to another symbol (GETY
+ * became GETYQ) is followed there before any other line, so a name never lands
+ * on a listing abroad that still quotes the old shares. The first stands when none has a quote,
+ * when the source is too busy to say, and when nothing here can ask for quotes.
  */
-async function firstQuoted<T extends RankedListing>(dataProvider: Partial<Pick<DataProvider, "getQuote">>, lines: readonly T[]): Promise<T> {
+async function firstQuoted<T extends RankedListing>(
+  dataProvider: Partial<Pick<DataProvider, "getQuote">>,
+  lines: readonly T[],
+  movedLine?: MovedLineLookup,
+): Promise<{ line: T; moved: { symbol: string; note: string } | null }> {
   const first = lines[0]!;
-  if (!dataProvider.getQuote) return first;
-  const quoted = ({ result, exchange }: RankedListing) => dataProvider.getQuote!(result.symbol.toUpperCase(), exchange).then(hasPrice);
+  const only = (line: T) => ({ line, moved: null });
+  if (!dataProvider.getQuote) return only(first);
+  const quoteOf = ({ result, exchange }: RankedListing) => dataProvider.getQuote!(result.symbol.toUpperCase(), exchange);
+  let quote: Quote | null = null;
   try {
-    if (await quoted(first)) return first;
+    quote = await quoteOf(first) ?? null;
   } catch (error) {
     // A busy source says nothing of the listing; any other failure is a listing with no quote.
-    if (isProviderBusy(error)) return first;
+    if (isProviderBusy(error)) return only(first);
+  }
+  if (movedLine && isUsVenue(first.exchange)) {
+    const symbol = first.result.symbol.toUpperCase();
+    const moved = await movedLine({ symbol, exchange: first.exchange, quote, name: first.result.name?.trim() || null });
+    if (moved && moved.symbol.toUpperCase() !== symbol) return { line: first, moved: { ...moved, symbol: moved.symbol.toUpperCase() } };
   }
+  if (hasPrice(quote)) return only(first);
   const keys = new Set([listingKey(first)]);
   const next: T[] = [];
   for (const line of lines) {
@@ -151,11 +191,11 @@ async function firstQuoted<T extends RankedListing>(dataProvider: Partial<Pick<D
     keys.add(listingKey(line));
     next.push(line);
   }
-  const priced = await Promise.all(next.map((line) => quoted(line).catch(() => {
+  const priced = await Promise.all(next.map((line) => quoteOf(line).then(hasPrice).catch(() => {
     // Intentional ignore: a line whose quote fails is a line with no quote.
     return false;
   })));
-  return next.find((_, index) => priced[index]) ?? first;
+  return only(next.find((_, index) => priced[index]) ?? first);
 }
 
 /** A name as two venues may spell it alike: "SIEMENS LTD" for Siemens Ltd. */

package/src/tickers/company-name.ts

@@ -215,10 +215,15 @@ function nameWord(word: string, opening: boolean, domain: boolean): string {
  * the way its source means it and comes back as it is.
  */
 export function companyNameCase(name: string): string {
-  if (!/\p{Lu}/u.test(name) || name !== name.toUpperCase()) return name;
+  // A brand that opens in lower case before capitals (aTYR, iROBOT) is still a name in capitals: aTyr, iRobot.
+  const brand = /^\p{Ll}(?=\p{Lu}{2})/u;
+  const capitals = name.split(/\s+/).map((word) => word.replace(brand, "")).join(" ");
+  if (!/\p{Lu}/u.test(name) || capitals !== capitals.toUpperCase()) return name;
   let words = 0;
   return name.replace(/\S+/g, (token) => {
     const opening = words++ === 0;
+    const lead = brand.exec(token)?.[0];
+    if (lead) return `${lead}${token.charAt(1)}${token.slice(2).toLowerCase()}`;
     // A separator inside a word (Coca-Cola, AT&T, Amazon.com, McDonald's) cuts it into words of its own.
     return token.split(/([-/.&,'\u2019]+)/).map((part, index, parts) => {
       if (index % 2 === 1) return part;

package/src/tickers/index-roots.ts

@@ -45,3 +45,10 @@ export function indexRootSuggestion(symbol: string): string | null {
   const root = indexRootFor(symbol);
   return root ? `Did you mean ${root.symbol} (${root.name})?` : null;
 }
+
+/** Cboe's Treasury yield indices: 13-week bill, 5-, 10- and 30-year notes. Each level is a yield in percent. */
+const YIELD_INDEX_SYMBOLS: ReadonlySet<string> = new Set(["^IRX", "^FVX", "^TNX", "^TYX"]);
+
+export function isYieldIndexSymbol(symbol: string): boolean {
+  return YIELD_INDEX_SYMBOLS.has(symbol.trim().toUpperCase());
+}

package/src/tickers/listing-fate.ts

@@ -182,7 +182,7 @@ export function describeListingFate(
  * ended long ago. Only such a line can be a company that moved away, so only
  * its change lookup is waited for.
  */
-function mayHaveMoved(quote: Quote | null, now = Date.now()): boolean {
+export function lineMayHaveMoved(quote: Quote | null, now = Date.now()): boolean {
   return !!quote && (isQuoteBeforeLatestSession(quote, now) || endedTradingDate(quote, now) != null);
 }
 
@@ -206,7 +206,7 @@ export async function loadListingFate(
     // A lookup started beside the command's request gets a short grace once that is ready, so a slow
     // one never holds a symbol that trades. A line that stopped is waited for: only its company can
     // have moved, and then the answer decides whether the command serves anything at all.
-    const changes = await lookup.settle(!options.changes || mayHaveMoved(quote) ? LATE_CHANGE_WAIT_MS : undefined);
+    const changes = await lookup.settle(!options.changes || lineMayHaveMoved(quote) ? LATE_CHANGE_WAIT_MS : undefined);
     return describeListingFate(listing, quote, changes);
   } catch (error) {
     logFailure("tickers-listing-fate", "Could not resolve listing fate")(error);

package/src/tickers/search/index.ts

@@ -7,6 +7,7 @@ import { getListingSymbol, listingSuffixConflictsWithExchange, tickerHasListingS
 import { parseOptionSymbol } from "../../utils/options";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
 import { currencyPairSpelling } from "../../utils/currency-pair";
+import { typedCoinPairListing } from "../../utils/crypto-pair";
 import { assetClassMarketSymbol, parseAssetClassQuery } from "./asset-classes";
 import { bareFuturesCode, futuresContractByCode } from "../../market-data/futures-board";
 import { searchContractKey, searchInstrumentKey } from "./identity";
@@ -387,9 +388,12 @@ export function resolveTickerSearch(options: ResolveTickerSearchOptions): Promis
   // JPY=X are EURUSD=X and USDJPY=X. USD-NGN and USDNGN, which a security could also be written as
   // (MNT-USD is a coin), are the pair only when nothing is listed under those letters.
   const pair = pickListing || future ? null : currencyPairSpelling(typed);
-  const symbol = future?.symbol ?? (pair && !pair.ambiguous ? pair.symbol : typed);
+  // A coin pair written as crypto exchanges write it (BTC/GBP, or BTC/GBP:KRAKEN) is the crypto venue's BTC-GBP,
+  // and what was typed when the venue has no such coin.
+  const coin = pickListing || future || pair || options.tickers.has(typed) ? null : typedCoinPairListing(typed);
+  const symbol = future?.symbol ?? coin?.symbol ?? (pair && !pair.ambiguous ? pair.symbol : typed);
   const literal = resolveTickerSymbol(symbol, options, pickListing ? requested : null);
-  const alternatives = pickListing ? [] : [...dottedVenueQueries(symbol), ...pair?.ambiguous ? [pair.symbol] : []];
+  const alternatives = pickListing ? [] : [...dottedVenueQueries(symbol), ...pair?.ambiguous ? [pair.symbol] : [], ...coin ? [typed] : []];
   // A listing suffix search does not carry (CEZ.PR) is read from its own quote, as `quote` reads it.
   const quoted = !pickListing && tickerHasListingSuffix(symbol) && !parsePublicTickerKey(symbol).exchange;
   // Most input has no venue code to retry: hand back the literal lookup

package/src/tickers/search/ranking.ts

@@ -4,6 +4,7 @@ import type {
 } from "./types";
 import { getListingSymbol, tickerHasListingSuffix } from "../../sources/listing-symbols";
 import { currencyPairCode } from "../../utils/currency-pair";
+import { typedCoinPairListing } from "../../utils/crypto-pair";
 import { canonicalExchange, exchangeCodeVenues, isUsListingExchange, parsePublicTickerKey, typedExchangeCode } from "../../utils/exchanges";
 import { assetClassKeeps, assetClassMarketSymbol, instrumentClassCode, parseAssetClassQuery } from "./asset-classes";
 import { futuresContractByCode } from "../../market-data/futures-board";
@@ -322,9 +323,12 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
       .map(({ item }) => getTickerSearchListingKey(item)),
   );
 
+  // BTC/GBP reads as a currency pair's spelling, and is the crypto venue's BTC-GBP.
+  const coinListing = typedCoinPairListing(query)?.symbol;
   const filtered = ranked.filter(({ item, textScore }) => {
     if (textScore <= 0) return false;
-    if (isExplicitMarketSymbol(query) && !isExplicitMarketSymbol(item.symbol || item.label)) return false;
+    if (isExplicitMarketSymbol(query) && !isExplicitMarketSymbol(item.symbol || item.label)
+      && parsePublicTickerKey(item.symbol || item.label).symbol !== coinListing) return false;
     if (item.kind !== "search") return true;
     return !matchedLocalListings.has(getTickerSearchListingKey(item));
   });

package/src/tickers/search/upsert.ts

@@ -11,6 +11,7 @@ import {
 import { canonicalExchange, parsePublicTickerKey, publicTickerKey } from "../../utils/exchanges";
 import { scopedBrokerContractIdentityKey } from "../../utils/instrument-identity";
 import { listingSuffixVenue } from "../../sources/listing-symbols";
+import { coinPairQuoteCurrency, exchangeLineCoinListing, isCoinRowType } from "../../utils/crypto-pair";
 
 /**
  * The key a result is saved under when its symbol is already saved for
@@ -36,6 +37,18 @@ export async function upsertTickerFromSearchResult(
   result: InstrumentSearchResult,
   options: { tickerSymbol?: string } = {},
 ): Promise<{ ticker: TickerRecord; created: boolean }> {
+  // A crypto exchange's line of a coin pair (BTC/GBP on COINBASE PRO), which no source quotes, is saved as the
+  // crypto venue's listing of the pair (BTC-GBP on CCC), in the currency the pair is quoted in.
+  const coin = result.brokerContract ? null
+    : exchangeLineCoinListing(getSearchResultSymbol(result), listingVenue(result), { coinRow: isCoinRowType(result.type) });
+  if (coin) {
+    result = { ...result, symbol: coin.symbol, exchange: coin.exchange, primaryExchange: undefined, currency: coin.currency };
+    if (options.tickerSymbol) options = { ...options, tickerSymbol: publicTickerKey(coin.symbol, coin.exchange) };
+  } else if (!result.currency && !result.brokerContract && canonicalExchange(listingVenue(result)) === "CCC") {
+    // The venue's own row of a pair (BTC-GBP) often comes without its currency, which the pair names.
+    const currency = coinPairQuoteCurrency(getSearchResultSymbol(result));
+    if (currency) result = { ...result, currency };
+  }
   let symbol = options.tickerSymbol ?? getSearchResultSymbol(result);
   // A vendor's suffixed symbol (GARAN.IS) is saved as the listing it is (GARAN on BIST), under the key
   // GARAN:BIST is saved under, so one listing is one row. A key the caller names is kept as given.

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/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 {
@@ -436,6 +459,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 +539,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 {

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;
   /**