gloomberb 0.18.4 → 0.19.0

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]);
   }
@@ -129,3 +170,62 @@ export function shortListingTitle(listing: { symbol: string; exchange: string; n
   const name = listing.name?.trim() ? shortCompanyName(listing.name) : listing.symbol;
   return listing.exchange ? `${name} (${listing.exchange})` : name;
 }
+
+/** Legal forms a list abbreviates, and short words that are words where short capitals would read as initials. */
+const NAME_WORDS: Readonly<Record<string, string>> = {
+  INC: "Inc", CORP: "Corp", CO: "Co", LTD: "Ltd", HLDG: "Hldg", HLDGS: "Hldgs", INTL: "Intl", GRP: "Grp", ST: "St",
+  OLD: "Old", NEW: "New", AIR: "Air", OIL: "Oil", GAS: "Gas", FOX: "Fox", ONE: "One", TWO: "Two", NON: "Non", NET: "Net",
+  PET: "Pet", BIO: "Bio", SUN: "Sun", SIX: "Six", RED: "Red", BOX: "Box", GAP: "Gap", ELI: "Eli", DOW: "Dow", LAB: "Lab",
+  MID: "Mid", SON: "Son", GEN: "Gen", HUB: "Hub", OWL: "Owl", REX: "Rex", LA: "La", LAM: "Lam", JOE: "Joe", CAL: "Cal",
+  MET: "Met", GRO: "Gro", BUY: "Buy", COM: "Com", SHS: "Shs",
+};
+/** Words a name keeps in lower case unless it opens with one. */
+const NAME_MINOR_WORDS = new Set(["AND", "OF", "THE", "FOR", "DE", "DEL"]);
+/** Spellings that title case gets wrong, for the largest names; any other name reads in plain title case. */
+const NAME_BRANDS: Readonly<Record<string, string>> = {
+  NVIDIA: "NVIDIA", JPMORGAN: "JPMorgan", UNITEDHEALTH: "UnitedHealth", ABBVIE: "AbbVie", EXXONMOBIL: "ExxonMobil",
+  PEPSICO: "PepsiCo", BLACKROCK: "BlackRock", SERVICENOW: "ServiceNow", CROWDSTRIKE: "CrowdStrike", FEDEX: "FedEx",
+  PAYPAL: "PayPal", EBAY: "eBay", DOORDASH: "DoorDash", DRAFTKINGS: "DraftKings", MONGODB: "MongoDB", HUBSPOT: "HubSpot",
+  GODADDY: "GoDaddy", CARMAX: "CarMax", MARKETAXESS: "MarketAxess", AUTOZONE: "AutoZone", AUTONATION: "AutoNation",
+  COSTAR: "CoStar", IDACORP: "IDACORP", AECOM: "AECOM", CBRE: "CBRE", MSCI: "MSCI",
+};
+/** Longer than three letters, yet still capitals: a legal form, a share structure or an index. */
+const NAME_INITIALISMS = new Set(["REIT", "USA", "ADR", "ADS", "VIII"]);
+const NAME_DOMAINS = new Set(["COM", "NET", "ORG", "IO", "AI"]);
+
+/** One run of letters in a name written in capitals. */
+function nameWord(word: string, opening: boolean, domain: boolean): string {
+  if (!/\p{L}/u.test(word)) return word;
+  if (domain && NAME_DOMAINS.has(word)) return word.toLowerCase();
+  const brand = NAME_BRANDS[word];
+  if (brand) return brand;
+  if (NAME_MINOR_WORDS.has(word)) return opening ? `${word.charAt(0)}${word.slice(1).toLowerCase()}` : word.toLowerCase();
+  const plain = NAME_WORDS[word];
+  if (plain) return plain;
+  // Initials and tickers read as capitals: up to three letters with no word of their own, or no vowel at all.
+  if (word.length <= 3 || NAME_INITIALISMS.has(word) || !/[AEIOUY]/.test(word)) return word;
+  if (/^MC[A-Z]{3}/.test(word)) return `Mc${word.charAt(2)}${word.slice(3).toLowerCase()}`;
+  return `${word.charAt(0)}${word.slice(1).toLowerCase()}`;
+}
+
+/**
+ * A company name a source writes in capitals (an ETF's holdings file: "APPLE INC", "MERCK & CO INC") as it is
+ * normally written: "Apple Inc", "Merck & Co Inc". Legal forms and short words take their usual case, initials
+ * inside a name stay capitals ("GE Aerospace", "AT&T", "L3Harris"). A name with any lower case letter is written
+ * 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;
+  let words = 0;
+  return name.replace(/\S+/g, (token) => {
+    const opening = words++ === 0;
+    // 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;
+      const before = parts[index - 1];
+      if (part === "S" && before && /['\u2019]$/.test(before)) return "s";
+      // Digits split a word too: Five9, L3Harris. A run of one or two letters beside a number is an initial.
+      return part.split(/(\d+)/).map((run, at) => at % 2 === 1 ? run : nameWord(run, opening && index === 0 && at === 0, before === ".")).join("");
+    }).join("");
+  });
+}

package/src/tickers/listing-venues.ts

@@ -12,6 +12,7 @@ import {
   typedExchangeCode,
 } from "../utils/exchanges";
 import { currencyPairSpelling } from "../utils/currency-pair";
+import { savedAbroadForBareSymbol } from "./search/bare-symbol";
 
 export interface ListingStore {
   loadTicker(symbol: string): Promise<TickerRecord | null>;
@@ -27,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 } : {};
 }
 
 /**
@@ -49,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);
@@ -119,6 +132,28 @@ export async function readAmbiguousCurrencyPair(typed: string, { store, dataProv
   }
 }
 
+/**
+ * The saved row a bare symbol stands for, read as the command bar reads it
+ * (`savedAbroadForBareSymbol`): a row abroad saved under the bare key (SHEL on
+ * LSE, saved from SHEL.L) gives way to the symbol's US listing, the row of it
+ * saved under another key, or null when that listing is not saved yet. The
+ * row abroad stands when the symbol lists on no US exchange, or search could
+ * not say.
+ */
+export async function savedRowOfBareSymbol(symbol: string, saved: TickerRecord | null, { store, dataProvider }: ListingDeps): Promise<TickerRecord | null> {
+  if (!saved || !savedAbroadForBareSymbol(symbol, saved)) return saved;
+  try {
+    const tickers = new Map((await store.loadAllTickers()).map((ticker) => [ticker.metadata.ticker.toUpperCase(), ticker] as const));
+    const resolved = await resolveTickerSearch({ query: symbol, activeTicker: null, tickers, dataProvider });
+    return resolved?.kind === "local" ? resolved.ticker : resolved ? null : saved;
+  } catch (error) {
+    // US listings no quote settles between: the lookup asks which, as with nothing saved.
+    if (error instanceof AmbiguousTickerError && !(error instanceof AmbiguousContractError)) return null;
+    logFailure("tickers-listing-venues", "Could not resolve bare symbol")(error);
+    return saved;
+  }
+}
+
 /** What a typed code that names several venues (7203:TSE) was read as. */
 export type SharedCodeReading =
   /** The one of the code's venues the symbol trades on. */

package/src/tickers/search/bare-symbol.ts

@@ -0,0 +1,36 @@
+import type { TickerRecord } from "../../types/ticker";
+import { tickerHasListingSuffix } from "../../sources/listing-symbols";
+import { canonicalExchange, isUsListingExchange, parsePublicTickerKey } from "../../utils/exchanges";
+import { listingAbroadVenue } from "../../utils/sec";
+import { tickerChangeSymbol } from "../ticker-changes";
+
+/**
+ * One rule for a bare symbol, whatever the profile saved before: a US-shaped
+ * symbol (SHEL, not SHEL.L, SHEL:LSE or 7203) is its US listing whenever it
+ * has one. A saved listing abroad (SHEL on LSE, saved from SHEL.L under the
+ * bare key) answers for it only when the symbol lists on no US exchange
+ * (GARAN, on BIST alone).
+ */
+function isBareUsShapedSymbol(symbol: string): boolean {
+  return !symbol.includes(":") && !!tickerChangeSymbol(symbol) && !tickerHasListingSuffix(symbol);
+}
+
+/** Whether a saved row is a listing abroad that a bare US-shaped symbol settles on only when it has no US listing. */
+export function savedAbroadForBareSymbol(symbol: string, ticker: TickerRecord): boolean {
+  if (!isBareUsShapedSymbol(symbol)) return false;
+  const venue = savedVenue(ticker);
+  return !!venue && !!listingAbroadVenue(`${symbol}:${venue}`);
+}
+
+function savedVenue(ticker: TickerRecord): string {
+  return canonicalExchange(ticker.metadata.exchange || parsePublicTickerKey(ticker.metadata.ticker).exchange);
+}
+
+/** The saved row of a bare symbol's US listing, under any key (SHEL:NYSE beside SHEL on LSE); null when none is saved. */
+export function savedUsListingOf(symbol: string, tickers: Iterable<TickerRecord>): TickerRecord | null {
+  for (const ticker of tickers) {
+    if (parsePublicTickerKey(ticker.metadata.ticker).symbol !== symbol) continue;
+    if (isUsListingExchange(savedVenue(ticker))) return ticker;
+  }
+  return null;
+}

package/src/tickers/search/index.ts

@@ -39,8 +39,10 @@ import { isProviderBusy, ProviderBusyError, SEARCH_BUSY_MESSAGE } from "../../so
 import { settleWithin } from "../../utils/async-deadline";
 import { companyNameExtraWords } from "../company-name";
 import { withHomeListingLead } from "./home-listing";
+import { savedAbroadForBareSymbol, savedUsListingOf } from "./bare-symbol";
 import { delistingLabel } from "../../market-data/quotes/delisting";
 import { hasNonLatinLetters } from "../../utils/typed-text";
+import { isNetworkFailure } from "../../utils/network-failure";
 export type {
   ResolvedTickerSearch,
   TickerSearchCandidate,
@@ -224,6 +226,7 @@ function createProviderTickerSearchCandidates(
       instrumentClass: classifyInstrumentKind(result.brokerContract?.secType || result.type),
       instrumentType: result.brokerContract?.secType || result.type,
       searchAliases: buildSearchResultAliases(result),
+      ...(searchResultNames(result) ? { nameAliases: searchResultNames(result) } : {}),
       ...(searchResultKeywords(result) ? { searchKeywords: searchResultKeywords(result) } : {}),
       result,
     }];
@@ -260,7 +263,7 @@ export async function searchTickerCandidates({
     // A search that hides contracts still shows them when asked: "AAPL OPT".
     includeOptionContracts: includeOptionContracts || parseAssetClassQuery(query)?.code === "OPT",
   });
-  const { results, busy } = await searchProviderResults(
+  const { results, busy, unreachable } = await searchProviderResults(
     dataProvider,
     query,
     searchContext,
@@ -268,7 +271,9 @@ export async function searchTickerCandidates({
     true,
   );
   const candidates = assemble(results);
-  // Saved tickers or another source's rows still answer. Nothing at all, because a source was busy, is no answer.
+  // Saved tickers or another source's rows still answer. Nothing at all, because the data service
+  // could not be reached or a source was busy, is no answer: not a name nothing lists.
+  if (unreachable && candidates.length === 0) throw unreachable;
   if (busy && candidates.length === 0) throw new ProviderBusyError(SEARCH_BUSY_MESSAGE);
   return candidates;
 }
@@ -465,15 +470,27 @@ async function resolveTickerSymbol(
     if (contracts.size > 1) throw new AmbiguousContractError(symbol,
       [...contracts.values()].map((contract) => tickerInstrumentLabel(local.metadata.ticker, contract)));
   }
+  // A bare symbol is its US listing whenever it has one (`savedAbroadForBareSymbol`): a row abroad saved under it
+  // (SHEL on LSE, from SHEL.L) gives way to the US row saved beside it, else to search's US listing.
+  const abroad = !pickerQuery && !!local && savedAbroadForBareSymbol(symbol, local);
+  const savedUs = abroad ? savedUsListingOf(symbol, tickers.values()) : null;
+  if (savedUs) return { kind: "local", symbol: savedUs.metadata.ticker, ticker: savedUs };
   // A saved symbol keeps its company. The colon still offers the others.
-  const saved: ResolvedTickerSearch | null = local ? { kind: "local", symbol: local.metadata.ticker, ticker: local } : null;
-  if (saved && !pickerQuery) return saved;
+  let saved: ResolvedTickerSearch | null = local ? { kind: "local", symbol: local.metadata.ticker, ticker: local } : null;
+  if (saved && !pickerQuery && !abroad) return saved;
 
   const { results, busy } = await searchProviderResults(dataProvider, symbol, searchContext);
   const providerItems = createProviderTickerSearchCandidates(results, tickers);
   const literalMatches = providerItems.filter((item) => normalizeTickerSymbol(item.symbol) === symbol);
-  const matches = literalMatches.length ? literalMatches
+  let matches = literalMatches.length ? literalMatches
     : providerItems.filter((item) => findExactTickerSearchMatch([item], symbol));
+  if (abroad) {
+    const us = matches.filter((item) => isUsListingExchange(listingExchange(item.result!)));
+    // No US listing: the row abroad is the symbol's.
+    if (us.length === 0) return saved;
+    matches = us;
+    saved = null;
+  }
   let exactMatch = matches[0];
   if (!exactMatch?.result) {
     // Nothing matched while a source was too busy to answer: that is no answer, not a miss.
@@ -599,6 +616,8 @@ interface ProviderSearch {
   results: InstrumentSearchResult[];
   /** A spelling went unanswered because a source was busy, so an empty list may not mean nothing matches. */
   busy: boolean;
+  /** Why a spelling went unanswered when the data service could not be reached (offline, a hung connection). */
+  unreachable: unknown;
 }
 
 async function searchProviderResults(
@@ -651,6 +670,7 @@ async function searchProviderResults(
     for (const [key, result] of named) byKey.set(key, result);
   };
   let busy = false;
+  let unreachable: unknown = null;
   await Promise.all(searchQueries.map(async (searchQuery, index) => {
     try {
       const results = await dataProvider.search(searchQuery, {
@@ -669,7 +689,8 @@ async function searchProviderResults(
       answers[index] = results;
       merge();
     } catch (error) {
-      if (isProviderBusy(error)) busy = true;
+      if (isNetworkFailure(error)) unreachable ??= error;
+      else if (isProviderBusy(error)) busy = true;
       else logFailure("tickers-search", "Could not search ticker spelling")(error);
     }
   }));
@@ -736,7 +757,7 @@ async function searchProviderResults(
 
   // Listings are named in Latin letters, and a source can fail on a name typed in another script (任天堂)
   // every time it is asked: nothing found for it is no answer to wait for and ask again.
-  return { results: [...byKey.values()], busy: busy && !hasNonLatinLetters(query) };
+  return { results: [...byKey.values()], busy: busy && !hasNonLatinLetters(query), unreachable };
 }
 
 /** Two search texts the server answers alike: its search ignores case and runs of spaces. */
@@ -846,6 +867,14 @@ function getProviderHintScore(result: InstrumentSearchResult, preferredExchange?
   return getProviderHintRichness(result) + (matchesPreferredExchange ? 10_000 : 0);
 }
 
+/** The names the service sent the row for, without the symbol spellings; older servers send none. */
+function searchResultNames(result: InstrumentSearchResult): string[] | undefined {
+  const names = Array.isArray(result.searchAliases)
+    ? result.searchAliases.filter((alias): alias is string => typeof alias === "string" && !!alias.trim())
+    : [];
+  return names.length > 0 ? names : undefined;
+}
+
 /** Older servers send none; anything malformed is ignored. */
 function searchResultKeywords(result: InstrumentSearchResult): string[] | undefined {
   const keywords = Array.isArray(result.searchKeywords)

package/src/tickers/search/ranking.ts

@@ -254,7 +254,16 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
       const explicitIntentScore = scoreAssetPreference(intent, item.instrumentClass)
         + scoreExchangePreference(intent, item);
       const priorityScore = explicitIntentScore + scoreListingPriority(item);
-      const companyMatchRank = scoreCompanyNameMatch(intent, companyNameKey);
+      // A company the service found by a name it does not bear in this row (the one it had before it was renamed,
+      // a trade name) is that company by the name as much as its listing's own name says so. An index answers to
+      // its codes, never as a company.
+      const companyAliases = item.instrumentClass === "equity" && !(item.symbol || item.label).startsWith("^")
+        ? item.nameAliases ?? []
+        : [];
+      const companyMatchRank = Math.max(
+        scoreCompanyNameMatch(intent, companyNameKey),
+        ...companyAliases.map((alias) => scoreCompanyNameMatch(intent, normalizeCompanyName(alias))),
+      );
       return {
         item,
         index,

package/src/tickers/search/types.ts

@@ -22,6 +22,11 @@ export interface TickerSearchRankableItem {
   providerRank?: number;
   popularity?: number;
   searchAliases?: string[];
+  /**
+   * The names the service sent the row for (`InstrumentSearchResult.searchAliases`: a trade name, or the name a
+   * renamed company had), apart from the symbol spellings `searchAliases` also holds.
+   */
+  nameAliases?: string[];
   /** Themes the row answers to that its name does not say (`InstrumentSearchResult.searchKeywords`). */
   searchKeywords?: string[];
 }

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/base-series.ts

@@ -10,6 +10,7 @@ import { extractFredSeries } from "./economic";
 import { getTimeSeriesField, isMarketFieldId } from "./field-catalog";
 import {
   unreportedStatementPeriod,
+  dailyValuationFallbackPeriod,
   valuationCurrencyWarning,
   valuationPriceIssues,
 } from "./fundamentals";
@@ -20,7 +21,7 @@ import { compareChartQuoteRecency } from "./live-quotes";
 import { marketSeriesFrequency } from "./market";
 import { canonicalExchange, resolveExchangeTimeZone } from "../utils/exchanges";
 import { futuresGenericCaption, futuresGenericListing, futuresListingPriceBasis } from "../utils/futures-generic";
-import { contractPriceUnit } from "./price-units";
+import { contractPriceUnit, currencyPairPriceUnit } from "./price-units";
 import { INDEX_POINTS_UNIT, isIndexLevel } from "../market-data/market/index-level";
 import { isOhlcSeriesStyle } from "./spec";
 import { SERIES_COLORS } from "../theme/series-colors";
@@ -118,6 +119,7 @@ export function baseSecuritySeries(
   const field = getTimeSeriesField(spec.source.fieldId);
   if (!field) return null;
   const points = extractSecuritySeries(financials, spec.source);
+  const valuationFallback = dailyValuationFallbackPeriod(financials, spec.source);
   const unreportedPeriod = points.length === 0 ? unreportedStatementPeriod(financials, spec.source) : null;
   const symbol = instrumentLabel(spec.source);
   const statementCurrency = field.id.startsWith("fundamental.") && field.unit.startsWith("currency")
@@ -147,8 +149,13 @@ export function baseSecuritySeries(
   // A future's price in a currency counts what its contract terms say: heating
   // oil is USD / gallon and crude USD / barrel, which a bare USD does not tell apart.
   const statedUnit = !genericUnit && unitTemplate === "currency" ? contractPriceUnit(contractUnit, currency) : null;
+  // A currency pair's rate is the quote currency one unit of the base buys:
+  // EURUSD=X is USD / EUR, so Brent over it reads EUR / barrel.
+  const pairUnit = !genericUnit && unitTemplate === "currency" && field.unitGroup === "price" && isMarketFieldId(field.id)
+    ? currencyPairPriceUnit(spec.source.instrument.symbol, spec.source.instrument.exchange, currency) : null;
   const unit = field.id === "market.volume" ? volumeUnit ?? ""
-    : statedUnit ?? genericUnit ?? (unitTemplate.startsWith("currency") && currency ? unitTemplate.replace("currency", currency) : unitTemplate);
+    : statedUnit ?? genericUnit ?? pairUnit
+      ?? (unitTemplate.startsWith("currency") && currency ? unitTemplate.replace("currency", currency) : unitTemplate);
   const currencyUnitGroup = genericUnit ? `${field.unitGroup}:${genericUnit}`
     : unknownBondBasis && field.unitGroup === "price" ? "price:unknown"
     : field.unit.startsWith("currency") && currency
@@ -198,10 +205,11 @@ export function baseSecuritySeries(
       ? financials.quote?.instrumentType || quoteMetadata?.instrumentType : undefined,
     volumeUnit,
     ...(priceIssues.length ? { valuationPriceIssues: priceIssues } : {}),
-    warning: field.id === "market.volume" && !volumeUnit && points.length > 0
-      ? "Volume unit unknown." : statementCurrency?.warning ?? valuationCurrencyWarning(financials, spec.source),
+    warning: [valuationFallback ? "Release dates unavailable; showing reported periods." : undefined,
+      field.id === "market.volume" && !volumeUnit && points.length > 0
+        ? "Volume unit unknown." : statementCurrency?.warning ?? valuationCurrencyWarning(financials, spec.source)].filter(Boolean).join(" ") || undefined,
     nativeFrequency: marketField ? marketSeriesFrequency(spec.source, marketResolution)
-      : spec.source.period && spec.source.period !== "auto" ? spec.source.period : field.nativeFrequency,
+      : valuationFallback ?? (spec.source.period && spec.source.period !== "auto" ? spec.source.period : field.nativeFrequency),
     ...(unreportedPeriod ? { unreportedPeriod } : {}),
     ...(marketField ? { historyResolution: marketResolution } : {}),
     timestampMode: spec.source.timestampMode,

package/src/time-series/daily-valuation.ts

@@ -0,0 +1,62 @@
+import type { PricePoint } from "../types/financials";
+import type { TimeSeriesPoint } from "./types";
+import { valuationPriceAtOrBefore } from "./valuation-price";
+import { regularSessionCloseOn } from "../market-data/market/freshness";
+import { financialAvailabilityTime } from "../utils/financial-statements";
+
+export interface DailyValuationBasis {
+  /** ISO publication date or timestamp. A date without a time takes effect after that session. */
+  availableAt?: string;
+  /** An undated, unusable statement invalidates the old basis from its period end. */
+  observedAt: Date;
+  atPrice: (price: number) => number | null;
+  periodLabel?: string;
+}
+
+/** Reprice a stepped financial figure at each source daily close. */
+export function dailyValuationHistory(
+  history: readonly PricePoint[],
+  bases: readonly DailyValuationBasis[],
+  exchange?: string,
+): TimeSeriesPoint[] {
+  const byDate = new Map<number, PricePoint[]>();
+  for (const bar of history) {
+    const time = bar.date instanceof Date ? bar.date.getTime() : Date.parse(bar.date);
+    if (!Number.isFinite(time) || bar.partial) continue;
+    byDate.set(time, [...byDate.get(time) ?? [], bar]);
+  }
+  const effectiveTime = (basis: DailyValuationBasis) => basis.availableAt
+    ? financialAvailabilityTime(basis.availableAt)
+    : basis.observedAt.getTime();
+  const releases = [...bases].sort((a, b) => effectiveTime(a) - effectiveTime(b)
+    || a.observedAt.getTime() - b.observedAt.getTime());
+  let next = 0;
+  let active: DailyValuationBasis | undefined;
+  const points: TimeSeriesPoint[] = [];
+  for (const [time, bars] of [...byDate].sort(([a], [b]) => a - b)) {
+    // Daily bars name their session at midnight. A timed report belongs to
+    // that close only if it was already public, including on early closes.
+    const day = new Date(time).toISOString().slice(0, 10);
+    const closeTime = regularSessionCloseOn(exchange, day) ?? time;
+    while (next < releases.length && effectiveTime(releases[next]!) <= closeTime) {
+      const release = releases[next++]!;
+      if (!active || release.observedAt >= active.observedAt) active = release;
+    }
+    const date = new Date(time);
+    const price = valuationPriceAtOrBefore(bars, date.toISOString());
+    const value = active && price?.price != null ? active.atPrice(price.price) : null;
+    points.push({
+      date,
+      observedAt: date,
+      availableAt: active?.availableAt ? new Date(active.availableAt) : undefined,
+      value: value !== null && Number.isFinite(value) ? value : null,
+      periodLabel: active?.periodLabel,
+      provenance: {
+        quality: "derived",
+        ...(price?.integrity ? { priceHistoryIntegrity: price.integrity } : {}),
+        ...(price?.issue ? { valuationPriceIssues: [{ ...price.issue, affectedAt: date.toISOString() }] } : {}),
+      },
+    });
+  }
+  return points;
+}

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",
@@ -226,9 +226,7 @@ const FIELDS = [
     transforms: FUNDAMENTAL_TRANSFORMS,
   }),
   ...([
-    // Trailing twelve-month EPS over the regular session price (the live price in session, the close after it), as
-    // `valuation` measures it, never an extended print.
-    ["trailingPE", "Trailing P/E", "P/E", "P/E (TTM, regular session)"],
+    ["trailingPE", "Trailing P/E", "P/E"],
     ["forwardPE", "Forward P/E", "Forward P/E"],
     ["realizedNtmPE", "Realized NTM P/E", "Realized P/E"],
     ["pegRatio", "PEG Ratio", "PEG"],