gloomberb 0.18.4 → 0.18.5

package/src/theme/colors.ts

@@ -291,6 +291,14 @@ export function priceColor(value: number, palette: ThemeColors = colors): string
   return palette.neutral;
 }
 
+/**
+ * `priceColor` for a figure as it is printed, to `digits` decimals: a move that
+ * rounds to zero (0.00%, never -0.00%) is neutral, not red or green.
+ */
+export function shownPriceColor(value: number, digits: number, palette: ThemeColors = colors): string {
+  return priceColor(Number(value.toFixed(digits)), palette);
+}
+
 const TONE_TINT = 0.18;
 
 /**

package/src/tickers/company-name.ts

@@ -129,3 +129,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>;
@@ -119,6 +120,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/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/field-catalog.ts

@@ -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"],

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

@@ -9,6 +9,7 @@ import type { ValuationCurrencyContext } from "./valuation-currency";
 import { currentValuationPrice, valuationPriceAtOrBefore } from "./valuation-price";
 import type { TimeSeriesPoint } from "./types";
 import { isFiniteNumber } from "../utils/guards";
+import { dailyValuationHistory, type DailyValuationBasis } from "./daily-valuation";
 
 /**
  * Forward multiples over time. No source serves the consensus as it stood on
@@ -236,6 +237,37 @@ export function forwardPeHistory(
   return points;
 }
 
+/** Daily closes over consensus that was actually observed by that date. */
+export function dailyForwardPeHistory(
+  financials: TickerFinancials,
+  currencies: ValuationCurrencyContext,
+  exchange?: string,
+): TimeSeriesPoint[] {
+  const history = financials.epsEstimates;
+  if (!history) return [];
+  // Pre-report estimates from future quarters are final-vintage figures,
+  // not the forecasts investors had on an earlier day. Only dated snapshots
+  // establish a historical daily forward denominator.
+  const bases: DailyValuationBasis[] = [...snapshotsByDay(history.snapshots)].map(([day, periods]) => {
+    const current = periods.get("current year");
+    const next = periods.get("next year");
+    const eps = blendedNextTwelveMonthsEps(day,
+      current ? { periodEnd: current.periodEnd, eps: current.epsAverage } : undefined,
+      next ? { eps: next.epsAverage } : undefined);
+    const date = new Date(day);
+    return {
+      availableAt: day,
+      observedAt: date,
+      periodLabel: `Consensus observed ${day}`,
+      atPrice: (price: number) => {
+        const comparable = currencies.priceInStatementUnits({ date: day, currency: history.currency ?? financials.financialCurrency }, price);
+        return comparable !== null && eps !== null ? comparable / eps : null;
+      },
+    };
+  });
+  return dailyValuationHistory(financials.priceHistory, bases, financials.quote?.listingExchangeName || financials.quote?.exchangeName || exchange);
+}
+
 /** Price at each report date over the EPS reported in the following four quarters. */
 export function realizedNtmPeHistory(
   financials: TickerFinancials,