gloomberb 0.16.4 → 0.16.5

package/src/utils/exchanges.ts

@@ -20,12 +20,16 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   ARCA: "ARCA",
   ARCX: "ARCA",
   BATS: "BATS",
-  // Cboe's US equities listing venue (BZX); quotes label it "CBOE US".
+  // Cboe's US equities listing venue (BZX); quotes label it "CBOE US" or BTS.
   "CBOE US": "BATS",
+  BTS: "BATS",
   TYO: "JPX",
+  // Toronto, as brokers and quote sites spell it; typed after a symbol it can
+  // also be Tokyo (SHARED_EXCHANGE_CODES).
   TSE: "TSX",
   TSEJ: "JPX",
   JPX: "JPX",
+  XTKS: "JPX",
   HKG: "HKEX",
   HKEX: "HKEX",
   SEHK: "HKEX",
@@ -40,6 +44,7 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   TSXV: "TSXV",
   XTSX: "TSXV",
   VAN: "TSXV",
+  CVE: "TSXV",
   CN: "CSE",
   CNSX: "CSE",
   XCNQ: "CSE",
@@ -48,6 +53,7 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   XASX: "ASX",
   NZX: "NZX",
   XNZE: "NZX",
+  NZE: "NZX",
   SIX: "SWX",
   SWX: "SWX",
   EBS: "SWX",
@@ -60,6 +66,7 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   GER: "XETRA",
   FSE: "FWB2",
   FSX: "FWB2",
+  FRA: "FWB2",
   XFRA: "FWB2",
   FWB: "FWB2",
   FWB2: "FWB2",
@@ -112,14 +119,19 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   SSE: "SSE",
   XSHG: "SSE",
   SHH: "SSE",
+  SHA: "SSE",
   SZSE: "SZSE",
   XSHE: "SZSE",
   SHE: "SZSE",
+  SHZ: "SZSE",
+  // KOSPI; typed after a symbol it can also be KOSDAQ, which the Korea Exchange runs too.
   KRX: "KRX",
   XKRX: "KRX",
   KOSPI: "KRX",
+  KSC: "KRX",
   KOSDAQ: "KOSDAQ",
   XKOS: "KOSDAQ",
+  KOE: "KOSDAQ",
   SGX: "SGX",
   XSES: "SGX",
   BMV: "BMV",
@@ -127,6 +139,7 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   B3: "B3",
   BVMF: "B3",
   B3SA: "B3",
+  SAO: "B3",
   BUE: "BYMA",
   BCBA: "BYMA",
   JSE: "JSE",
@@ -138,9 +151,52 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   QE: "QE",
   QSE: "QE",
   DSMD: "QE",
+  // Bahrain Bourse, which Gloom Cloud names BHB.
+  BHB: "BHB",
+  XBAH: "BHB",
+  BAHRAIN: "BHB",
+  "BAHRAIN BOURSE": "BHB",
   DFM: "DFM",
   XDFM: "DFM",
+  // The Muscat Stock Exchange, which Gloom Cloud names MSX.
+  MSX: "MSX",
+  XMUS: "MSX",
+  MSM: "MSX",
+  MUSCAT: "MSX",
+  OMAN: "MSX",
+  // Boursa Kuwait, which Gloom Cloud names KUWAIT.
+  KUWAIT: "KUWAIT",
+  XKUW: "KUWAIT",
+  BOURSA: "KUWAIT",
+  "BOURSA KUWAIT": "KUWAIT",
+  // The Egyptian Exchange, which Gloom Cloud names EGX.
+  EGX: "EGX",
+  CAI: "EGX",
+  XCAI: "EGX",
+  EGYPT: "EGX",
+  CAIRO: "EGX",
   CCC: "CCC",
+  // Futures venues, by the code search gives each (GC=F on CMX). Quotes spell
+  // the venue out (COMEX, NY MERCANTILE); both spellings are one venue, or the
+  // quote for GC=F:CMX reads as another venue's and is dropped.
+  CME: "CME",
+  CBT: "CBT",
+  CBOT: "CBT",
+  NYM: "NYM",
+  NYMEX: "NYM",
+  "NY MERCANTILE": "NYM",
+  CMX: "CMX",
+  COMEX: "CMX",
+  NYB: "NYB",
+  NYBOT: "NYB",
+  "ICE FUTURES": "NYB",
+  CFE: "CFE",
+  "CBOE FUTURES": "CFE",
+  // The currency venue: EURUSD:CCY and EURUSD:FX are the pair EURUSD=X. Pairs
+  // saved from an older search answer are on PHYSICAL CURRENCY.
+  CCY: "CCY",
+  FX: "CCY",
+  "PHYSICAL CURRENCY": "CCY",
 };
 
 const PUBLIC_EXCHANGE_ALIASES: Record<string, string> = {
@@ -231,7 +287,11 @@ export const EXCHANGE_TIME_ZONES: Record<string, string> = {
   TASE: "Asia/Jerusalem",
   TADAWUL: "Asia/Riyadh",
   QE: "Asia/Qatar",
+  BHB: "Asia/Bahrain",
   DFM: "Asia/Dubai",
+  MSX: "Asia/Muscat",
+  KUWAIT: "Asia/Kuwait",
+  EGX: "Africa/Cairo",
   CCC: "UTC",
 };
 
@@ -287,7 +347,16 @@ const EXCHANGE_NAMES: Record<string, string> = {
   TASE: "Tel Aviv Stock Exchange",
   TADAWUL: "Saudi Exchange",
   QE: "Qatar Stock Exchange",
+  BHB: "Bahrain Bourse",
   DFM: "Dubai Financial Market",
+  MSX: "Muscat Stock Exchange",
+  KUWAIT: "Boursa Kuwait",
+  EGX: "Egyptian Exchange",
+  CBT: "CBOT",
+  NYM: "NYMEX",
+  CMX: "COMEX",
+  NYB: "ICE Futures U.S.",
+  CFE: "Cboe Futures Exchange",
 };
 
 const KNOWN_EXCHANGE_CODES: ReadonlySet<string> = new Set([
@@ -323,6 +392,43 @@ export function canonicalExchange(value?: string): string {
   return CANONICAL_EXCHANGE_ALIASES[normalized] ?? normalized;
 }
 
+/**
+ * Codes people type for more than one venue, the venue `canonicalExchange`
+ * reads them as first. TSE is the Tokyo Stock Exchange's own short name, and
+ * the code brokers and quote sites give Toronto; KRX is the Korea Exchange,
+ * which runs both KOSPI and KOSDAQ; EURONEXT runs Paris, Amsterdam, Brussels,
+ * Lisbon, Oslo and Milan. Data that arrives with one (a broker's contract)
+ * keeps the first venue; a listing typed with one is the venue its symbol
+ * trades on.
+ */
+const SHARED_EXCHANGE_CODES: Record<string, readonly string[]> = {
+  TSE: ["TSX", "JPX"],
+  KRX: ["KRX", "KOSDAQ"],
+  EURONEXT: ["AMS", "EPA", "BRU", "LIS", "OSL", "BIT"],
+};
+
+/** Whether a typed exchange code names more than one venue (TSE: Tokyo or Toronto). */
+export function isSharedExchangeCode(value?: string): boolean {
+  return normalizeExchange(value) in SHARED_EXCHANGE_CODES;
+}
+
+/**
+ * Every venue a typed exchange code can name, as canonical codes: TSE is
+ * TSX or JPX, PAR is EPA. Empty for no code.
+ */
+export function exchangeCodeVenues(value?: string): string[] {
+  const normalized = normalizeExchange(value);
+  if (!normalized) return [];
+  return [...(SHARED_EXCHANGE_CODES[normalized] ?? [canonicalExchange(normalized)])];
+}
+
+/** The exchange code after a listing key's colon, as typed: TSE for 7203:TSE; "" when there is none. */
+export function typedExchangeCode(key: string): string {
+  const normalized = normalizeSymbol(key);
+  const separator = normalized.lastIndexOf(":");
+  return separator > 0 ? normalized.slice(separator + 1) : "";
+}
+
 /**
  * The US primary listing venues, as canonical exchanges. All of them trade the
  * US regular and extended-hours sessions.

package/src/utils/format.ts

@@ -1,7 +1,16 @@
 const currencyFormatters = new Map<string, Intl.NumberFormat>();
 const numberFormatters = new Map<number, Intl.NumberFormat>();
 
-function getCurrencyFormatter(currency: string, maximumFractionDigits = 2): Intl.NumberFormat {
+/** Currencies whose minor unit is a thousandth (ISO 4217 exponent 3): an Omani share is OMR 1.366, not OMR 1.37.
+ * IQD is left out on purpose: it has the exponent in ISO 4217 but trades in whole units. */
+const THREE_DECIMAL_CURRENCIES = new Set(["BHD", "JOD", "KWD", "LYD", "OMR", "TND"]);
+
+/** Decimals a price or amount in this currency is shown to: 3 for the thousandth currencies, 2 for everything else. */
+export function currencyPriceDigits(currency: string | undefined): 2 | 3 {
+  return currency != null && THREE_DECIMAL_CURRENCIES.has(currency.trim().toUpperCase()) ? 3 : 2;
+}
+
+function getCurrencyFormatter(currency: string, maximumFractionDigits: number = currencyPriceDigits(currency)): Intl.NumberFormat {
   const key = `${currency}:${maximumFractionDigits}`;
   let formatter = currencyFormatters.get(key);
   if (!formatter) {
@@ -9,7 +18,7 @@ function getCurrencyFormatter(currency: string, maximumFractionDigits = 2): Intl
       style: "currency",
       currency,
       // Whole units (0) drop the cents rather than throw.
-      minimumFractionDigits: Math.min(2, maximumFractionDigits),
+      minimumFractionDigits: Math.min(currencyPriceDigits(currency), maximumFractionDigits),
       maximumFractionDigits,
     });
     currencyFormatters.set(key, formatter);
@@ -30,7 +39,11 @@ function getNumberFormatter(decimals: number): Intl.NumberFormat {
 }
 
 /** Format a number as currency (e.g., $1,234.56) */
-export function formatCurrency(value: number | undefined, currency = "USD", maximumFractionDigits = 2): string {
+export function formatCurrency(
+  value: number | undefined,
+  currency = "USD",
+  maximumFractionDigits: number = currencyPriceDigits(currency),
+): string {
   if (value == null || !Number.isFinite(value)) return "—";
   return getCurrencyFormatter(currency, maximumFractionDigits).format(value);
 }

package/src/utils/fundamentals.ts

@@ -1,4 +1,5 @@
 import type { Fundamentals, TickerFinancials } from "../types/financials";
+import { resolveCurrencyUnit } from "./currency-units";
 
 export const RETRACTABLE_VALUATION_FIELDS = ["enterpriseValue", "enterpriseToRevenue"] as const;
 
@@ -29,3 +30,68 @@ export function fundamentalsCurrency(
 ): string | undefined {
   return financials?.fundamentals?.financialCurrency?.trim() || financials?.financialCurrency?.trim() || undefined;
 }
+
+/**
+ * The currency of the trailing EPS: the one stated for it when it differs from the block's amounts (an EPS converted
+ * to the listing's currency beside revenue left in the reporting one), else the block's.
+ */
+export function fundamentalsEpsCurrency(
+  financials: Pick<TickerFinancials, "fundamentals" | "financialCurrency"> | null | undefined,
+): string | undefined {
+  return financials?.fundamentals?.epsCurrency?.trim() || fundamentalsCurrency(financials);
+}
+
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * "TTM converted from EUR (1 EUR = 1.1257 USD, 2026-10-09); EPS at report-date rates.": what a converted trailing
+ * block was converted from, at which rate and when. Undefined for a block in the currency the company reports in.
+ */
+export function ttmConversionNote(fundamentals: Pick<Fundamentals, "financialCurrency" | "ttmConversion"> | undefined): string | undefined {
+  const conversion = fundamentals?.ttmConversion;
+  const from = conversion?.from?.trim();
+  const to = fundamentals?.financialCurrency?.trim();
+  if (!conversion || !from || !to || from === to) return undefined;
+  const rate = typeof conversion.rate === "number" && Number.isFinite(conversion.rate) && conversion.rate > 0
+    ? `1 ${from} = ${Number(conversion.rate.toPrecision(5))} ${to}`
+    : undefined;
+  const asOf = conversion.asOf && ISO_DAY.test(conversion.asOf) ? conversion.asOf : undefined;
+  const basis = [rate, asOf].filter(Boolean).join(", ");
+  const eps = conversion.eps === "report_date" ? "; EPS at report-date rates" : "";
+  return `TTM converted from ${from}${basis ? ` (${basis})` : ""}${eps}.`;
+}
+
+/**
+ * "EPS (TTM) in USD, converted from CLP at report-date rates.": an EPS in another currency than the trailing amounts
+ * beside it. Undefined when they share one.
+ */
+export function epsConversionNote(fundamentals: Pick<Fundamentals, "financialCurrency" | "epsCurrency"> | undefined): string | undefined {
+  const eps = fundamentals?.epsCurrency?.trim();
+  const amounts = fundamentals?.financialCurrency?.trim();
+  return eps && amounts && eps !== amounts ? `EPS (TTM) in ${eps}, converted from ${amounts} at report-date rates.` : undefined;
+}
+
+type PriceEarningsBasis = Pick<Fundamentals, "financialCurrency" | "ttmConversion" | "epsCurrency" | "trailingPEConversion">;
+
+/** The trailing EPS in the price's currency: converted at the rate the served P/E used when it says so. */
+export function priceEarningsEps(fundamentals: Pick<Fundamentals, "eps" | "trailingPEConversion"> | undefined): number | undefined {
+  const eps = fundamentals?.eps;
+  const rate = fundamentals?.trailingPEConversion?.rate;
+  return typeof eps === "number" && typeof rate === "number" && Number.isFinite(rate) && rate > 0 ? eps * rate : eps;
+}
+
+/**
+ * The trailing P/E's footnote: the rate its EPS was converted at when that EPS is in another currency than the
+ * price, or that it divides a spot price by EPS converted at report-date rates.
+ */
+export function convertedPriceEarningsNote(fundamentals: PriceEarningsBasis | undefined, quoteCurrency?: string): string | undefined {
+  const conversion = fundamentals?.trailingPEConversion;
+  const from = conversion?.from?.trim();
+  const to = resolveCurrencyUnit(quoteCurrency).currency;
+  if (from && to && from !== to && typeof conversion?.rate === "number" && Number.isFinite(conversion.rate) && conversion.rate > 0) {
+    return `P/E (TTM): price over EPS converted at 1 ${from} = ${Number(conversion.rate.toPrecision(5))} ${to}.`;
+  }
+  return (ttmConversionNote(fundamentals) && fundamentals?.ttmConversion?.eps === "report_date") || epsConversionNote(fundamentals)
+    ? "P/E (TTM): spot price over EPS at report-date rates."
+    : undefined;
+}

package/src/utils/futures-generic.ts

@@ -7,7 +7,7 @@
  * ratio-adjusts, A difference-adjusts, neither leaves prices as traded.
  */
 
-import { parsePublicTickerKey } from "./exchanges";
+import { canonicalExchange, parsePublicTickerKey } from "./exchanges";
 
 export type FuturesGenericRoll =
   | { rule: "open-interest" }
@@ -36,11 +36,6 @@ const ROOT_VENUES: Readonly<Record<string, string>> = Object.fromEntries(([
   ["CFE", ["VX"]],
 ] as const).flatMap(([venue, roots]) => roots.map((root) => [root, venue])));
 
-/** Other names quotes give each venue, which a listing may carry as its exchange. */
-const VENUE_NAMES: Readonly<Record<string, readonly string[]>> = {
-  NYM: ["NYMEX", "NY MERCANTILE"], CBT: ["CBOT"], CMX: ["COMEX"], NYB: ["ICE FUTURES", "NYBOT"], CFE: ["CBOE FUTURES"],
-};
-
 /** Bloomberg's codes where they differ from the exchange's. */
 const ALIASES: Readonly<Record<string, string>> = {
   TY: "ZN", US: "ZB", FV: "ZF", TU: "ZT", WN: "UB", DM: "YM", FF: "ZQ", SFR: "SR3",
@@ -83,9 +78,9 @@ export function futuresGenericListing(symbol: string, exchange?: string | null):
   const key = parsePublicTickerKey(symbol);
   const generic = parseFuturesGeneric(key.symbol);
   if (!generic) return null;
-  const venue = (key.exchange || exchange || "").trim().toUpperCase();
-  const own = ROOT_VENUES[generic.root]!;
-  return !venue || venue === own || VENUE_NAMES[own]?.includes(venue) ? generic : null;
+  // The alias table names each venue by its code, however a quote spells it (NYMEX is NYM).
+  const venue = key.exchange || canonicalExchange(exchange ?? "");
+  return !venue || venue === ROOT_VENUES[generic.root] ? generic : null;
 }
 
 const FUTURES_VENUES = new Set(Object.values(ROOT_VENUES));
@@ -98,9 +93,8 @@ const FUTURES_VENUES = new Set(Object.values(ROOT_VENUES));
  */
 export function futuresListingVenue(symbol: string, exchange?: string | null): { venue: string; root: string | null } | null {
   const ticker = symbol.trim().toUpperCase();
-  const named = (exchange ?? "").trim().toUpperCase();
-  const venue = FUTURES_VENUES.has(named) ? named
-    : Object.entries(VENUE_NAMES).find(([, names]) => names.includes(named))?.[0] ?? null;
+  const named = canonicalExchange(exchange ?? "");
+  const venue = FUTURES_VENUES.has(named) ? named : null;
   const coded = /^([A-Z0-9]{1,4}?)(?:=F|[FGHJKMNQUVXZ]\d{2}(?:\.[A-Z]+)?)$/.exec(ticker)?.[1]
     ?? /^([A-Z]{2})-Y\.[A-Z]+$/.exec(ticker)?.[1];
   const root = futuresGenericListing(ticker, venue ?? named)?.root ?? (coded ? ALIASES[coded] ?? coded : null);

package/src/utils/fx-market-hours.ts

@@ -29,20 +29,30 @@ export function isFxMarketOpen(time: number): boolean {
   return true;
 }
 
-/** The latest close of the FX week, Friday 17:00 New York, at or before `time`. */
-export function latestFxWeekClose(time: number): number | null {
+/** The latest 17:00 New York on `weekday` (0 is Sunday) at or before `time`. */
+function latestNewYorkFivePm(time: number, weekday: number): number | null {
   if (!Number.isFinite(time)) return null;
   const { year, month, day } = zonedDateTimeParts(time, NEW_YORK);
   const today = Date.UTC(year, month - 1, day);
   for (let offset = 0; offset <= 7; offset += 1) {
     const date = new Date(today - offset * DAY_MS);
-    if (date.getUTCDay() !== 5) continue;
-    const close = zonedWallClockToUtcMs(NEW_YORK, date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), 17, 0, 0);
-    if (close <= time) return close;
+    if (date.getUTCDay() !== weekday) continue;
+    const at = zonedWallClockToUtcMs(NEW_YORK, date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), 17, 0, 0);
+    if (at <= time) return at;
   }
   return null;
 }
 
+/** The latest close of the FX week, Friday 17:00 New York, at or before `time`. */
+export function latestFxWeekClose(time: number): number | null {
+  return latestNewYorkFivePm(time, 5);
+}
+
+/** The latest open of the FX week, Sunday 17:00 New York, at or before `time`. */
+export function latestFxWeekOpen(time: number): number | null {
+  return latestNewYorkFivePm(time, 0);
+}
+
 /**
  * When the closure the market is in began (Friday 17:00 New York time); null
  * while it trades. That is `latestFxWeekClose` for every moment the week is

package/src/utils/price-history.ts

@@ -1,15 +1,21 @@
 import type { PricePoint, TickerFinancials } from "../types/financials";
-import { canonicalExchange, resolveExchangeTimeZone } from "./exchanges";
+import { canonicalExchange } from "./exchanges";
 import { isRoundTheClockCoin } from "./crypto-pair";
-import { isCurrencyPairListing, latestFxWeekClose } from "./fx-market-hours";
-import { hasPublishedSessionCalendar, isRegularSessionTime, isTimestampStaleForExchangeSession, latestRegularSessionClose, latestRegularSessionOpen, sessionCalendarTimeZone } from "../market-data/market/freshness";
+import { isCurrencyPairListing, isFxMarketOpen, latestFxWeekClose, latestFxWeekOpen } from "./fx-market-hours";
+import { hasPublishedSessionCalendar, historySourceWeekendDays, latestRegularSessionClose, latestRegularSessionOpen, sessionCalendarTimeZone } from "../market-data/market/freshness";
 import { zonedDateTimeParts } from "./zoned-date-time";
 import { regularHistorySessionStaleness } from "../market-data/history-session";
 import type { HistorySession } from "../types/price-history";
 import { BAR_INTERVAL_UNIT_MS, parseBarInterval } from "../time-series/resolution";
 
-const MAX_CURRENT_INTRADAY_HISTORY_LAG_MS = 18 * 60 * 60 * 1000;
+// A venue without session hours here (OTC Markets, Cboe Canada) has no
+// session to hold: its copy is current while the latest bar is this recent.
+const UNSCHEDULED_HISTORY_MAX_AGE_MS = 18 * 60 * 60 * 1000;
 const MAX_SAME_SESSION_HISTORY_LAG_MS = 30 * 60 * 1000;
+// Sources finish the closing auction and late prints some minutes after the
+// bell, past the delayed feed's lag. A copy fetched later can still carry an
+// unfinished bar when its source had not settled it; only the source can tell.
+const SESSION_BAR_SETTLE_MS = 30 * 60 * 1000;
 const DELAYED_HISTORY_ALLOWANCE_MS = 15 * 60 * 1000;
 const DAY_MS = 24 * 60 * 60 * 1000;
 // A series that never closes must reach the present without a break: no hole
@@ -22,12 +28,19 @@ interface PriceHistoryFreshnessOptions {
   exchange?: string;
   /**
    * The listing's symbol. A coin quoted in dollars (BTC-USD) trades around the
-   * clock whether or not the exchange says CCC; without the symbol a bare
-   * pair is read as a US listing and judged on the NYSE session.
+   * clock whether or not the exchange says CCC, and a currency pair (EURUSD=X)
+   * on the FX week; without the symbol a bare pair is read as a US listing and
+   * judged on the NYSE session.
    */
   symbol?: string;
   intervalMs?: number | null;
   session?: HistorySession;
+  /**
+   * When the copy was fetched. A copy fetched once its session had settled
+   * holds that session however early its last bar: a thin listing need not
+   * trade late. Without it, the bars must reach the close.
+   */
+  fetchedAt?: number;
 }
 
 /**
@@ -217,38 +230,84 @@ export function isPriceHistoryStaleForCurrentWindow(
   const age = now - latestTime;
   const allowedLag = allowedBarLagMs(intervalMs);
   if (age <= allowedLag) return false;
-  const exchange = options.exchange || "NASDAQ";
-  // Bars that reach the close of the venue's latest session stay current
-  // once it has closed, so a closed market keeps its last session until the
-  // next one opens. A copy taken earlier in that session is still behind.
-  // Asked before the quote rule below, which reads any US bar dated before
-  // today as behind from 04:00 ET: right for a last price, wrong for bars
-  // waiting for the next session's first one.
-  const regularSession = isRegularSessionTime(exchange, now);
-  if (regularSession !== null) {
-    const open = latestRegularSessionOpen(exchange, now);
-    const close = latestRegularSessionClose(exchange, now)?.close;
-    if (open !== null && close !== undefined && latestTime >= close - allowedLag) {
-      if (!regularSession && close > open && latestTime >= open) return false;
-      // After the next open they answer until its first delayed bar is due.
-      if (regularSession && close < open && latestTime < open && now - open <= allowedLag) return false;
-    }
-  }
-  if (
-    resolveExchangeTimeZone(exchange)
-    && isTimestampStaleForExchangeSession(latestTime, exchange, now)
-  ) {
-    return true;
+  const sessions = listingSessionsAt(now, options);
+  if (!sessions) return age > UNSCHEDULED_HISTORY_MAX_AGE_MS;
+  const fetchedAt = options.fetchedAt ?? Number.NEGATIVE_INFINITY;
+  if (holdsLatestSession(latestTime, now, sessions, allowedLag, fetchedAt)) return false;
+  // A venue whose chart source files another week (DFM's Sunday to Thursday)
+  // may end on the last session that week has: current under either week.
+  // Bars of a day that week lacks (a DFM Friday) answer to the venue's own.
+  const exchange = listingSessionExchange(options.exchange);
+  const sourceWeekendDays = historySourceWeekendDays(exchange);
+  const timeZone = sessionCalendarTimeZone(exchange);
+  const latestWeekday = timeZone ? zonedWeekday(latestTime, timeZone) : null;
+  if (!sourceWeekendDays || latestWeekday == null || sourceWeekendDays.includes(latestWeekday)) return true;
+  const sourceSessions = listingSessionsAt(now, options, sourceWeekendDays);
+  return !sourceSessions || !holdsLatestSession(latestTime, now, sourceSessions, allowedLag, fetchedAt);
+}
+
+/** Bare symbols resolve to their US listing at the sources. */
+function listingSessionExchange(exchange: string | undefined): string {
+  return canonicalExchange(exchange) || "NYSE";
+}
+
+interface ListingSessions {
+  /** The open of the session trading at the time asked, if one is. */
+  liveOpen: number | null;
+  /** The latest session closed at or before that time. */
+  last: { open: number; close: number } | null;
+}
+
+/**
+ * The sessions a listing's bars are read against at `time`, from the venue's
+ * session tables; `weekendDays` replaces its days off. A currency pair's
+ * session is the FX week, Sunday to Friday 17:00 New York, whatever venue it
+ * is quoted on. Null for a venue without session hours.
+ */
+function listingSessionsAt(
+  time: number,
+  options: Pick<PriceHistoryFreshnessOptions, "exchange" | "symbol">,
+  weekendDays?: readonly number[],
+): ListingSessions | null {
+  if (isCurrencyPairListing(options.symbol, options.exchange)) {
+    const close = latestFxWeekClose(time);
+    const open = close === null ? null : latestFxWeekOpen(close);
+    return { liveOpen: isFxMarketOpen(time) ? latestFxWeekOpen(time) : null,
+      last: close !== null && open !== null ? { open, close } : null };
   }
-  const hasExchangeSession = Boolean(resolveExchangeTimeZone(exchange));
-  if (age <= MAX_CURRENT_INTRADAY_HISTORY_LAG_MS) return hasExchangeSession;
-  return !hasExchangeSession;
+  const exchange = listingSessionExchange(options.exchange);
+  const open = latestRegularSessionOpen(exchange, time, weekendDays);
+  if (open === null) return null;
+  const latest = latestRegularSessionClose(exchange, time, weekendDays);
+  const last = latest
+    ? { open: latestRegularSessionOpen(exchange, latest.close, weekendDays) ?? latest.close, close: latest.close }
+    : null;
+  return { liveOpen: !last || last.close < open ? open : null, last };
+}
+
+/**
+ * Whether bars ending at `latestTime`, older than one bar's lag, hold the
+ * listing's latest session. Between sessions that is the whole of the last
+ * one. While one trades, bars older than the lag are behind it, and the whole
+ * of the one before answers only until this one's first delayed bar is due.
+ * A session is held whole by bars from its open that reach its close less
+ * that lag, or by a copy fetched once it had settled. Weeknights, weekends
+ * and holidays read alike: the session tables say which session is the last.
+ */
+function holdsLatestSession(
+  latestTime: number, now: number, sessions: ListingSessions, allowedLag: number, fetchedAt: number,
+): boolean {
+  const { liveOpen, last } = sessions;
+  if (liveOpen !== null && (latestTime >= liveOpen || now - liveOpen > allowedLag)) return false;
+  return !!last && latestTime >= last.open
+    && (latestTime >= last.close - allowedLag || fetchedAt >= last.close + SESSION_BAR_SETTLE_MS);
+}
+
+function zonedWeekday(time: number, timeZone: string): number {
+  const { year, month, day } = zonedDateTimeParts(time, timeZone);
+  return new Date(Date.UTC(year, month - 1, day)).getUTCDay();
 }
 
-// Sources finish the closing auction and late prints some minutes after the
-// bell, past the delayed feed's lag. A copy fetched later can still carry an
-// unfinished bar when its source had not settled it; only the source can tell.
-const SESSION_BAR_SETTLE_MS = 30 * 60 * 1000;
 const CRYPTO_BAR_MAX_AGE_MS = 60 * 60 * 1000;
 // A copy missing a settled session is asked again at most this often, and less
 // often as that close recedes, so a halted, delisted or late listing costs a
@@ -323,18 +382,16 @@ function isBarBeforeSession(latestTime: number, session: string, intervalMs: num
  * next has begun, a copy whose last bar stops short of the close by more than
  * a current copy's bars may lag is refetched. A copy fetched after the
  * session settled holds all of it, however early its last bar: a thin listing
- * need not trade late. A currency pair's session is the FX week, which closes
- * Friday 17:00 New York. Coins never close, and within the FX week neither do
- * pairs: isPriceHistoryStaleForCurrentWindow holds those copies to the present.
+ * need not trade late. The sessions are those isPriceHistoryStaleForCurrentWindow
+ * reads (listingSessionsAt): a currency pair's is the FX week. Coins never
+ * close, and within the FX week neither do pairs:
+ * isPriceHistoryStaleForCurrentWindow holds those copies to the present.
  */
 function intradayHistoryFetchState(
   points: PricePoint[], fetchedAt: number, now: number, intervalMs: number, options: CalendarHistoryFetchOptions,
 ): CalendarHistoryFetchState {
   if (isRoundTheClockCoin(options.symbol, options.exchange)) return "current";
-  const settledBy = now - SESSION_BAR_SETTLE_MS;
-  // Bare symbols resolve to their US listing at the sources.
-  const close = isCurrencyPairListing(options.symbol, options.exchange) ? latestFxWeekClose(settledBy)
-    : latestRegularSessionClose(canonicalExchange(options.exchange) || "NYSE", settledBy)?.close ?? null;
+  const close = listingSessionsAt(now - SESSION_BAR_SETTLE_MS, options)?.last?.close ?? null;
   if (close === null || fetchedAt >= close + SESSION_BAR_SETTLE_MS) return "current";
   const latest = points.findLast(hasFiniteClose);
   const latestTime = latest ? getPricePointTimestamp(latest) : Number.NaN;

package/src/utils/sec-eps-basis.ts

@@ -98,7 +98,8 @@ function splitEvents(proofs: Proof[]): SplitEvent[] {
 /**
  * Share bases belong to source accessions, not filing dates. A split edge needs
  * an explicit SEC split fact and unchanged same-period income with inverse EPS
- * restatement. Repeated EPS AND diluted shares connect otherwise equal bases;
+ * restatement. Repeated EPS AND diluted shares (at the coarser filing's
+ * rounding) connect otherwise equal bases;
  * where a filing tags no diluted shares, repeated EPS AND income do, if no
  * disclosed split could leave that EPS unchanged at cent rounding.
  * No price jump, ticker exception, or chronological assumption establishes one.
@@ -131,23 +132,30 @@ export function createSecEpsBasisResolver(payload: unknown): (fact: Fact) => { v
     graph.set(after, [...graph.get(after) ?? [], { node: before, factor: ratio, evidence }]);
     graph.set(before, [...graph.get(before) ?? [], { node: after, factor: 1 / ratio, evidence }]);
   };
-  const identical = new Map<string, Row>();
   const periods = new Map<string, Row[]>();
   for (const row of eps.values()) {
     const period = `${row.start}:${row.end}`;
     periods.set(period, [...periods.get(period) ?? [], row]);
-    const denominator = shares.get(key(row))?.val;
-    if (!row.val || !denominator || denominator <= 0) continue;
-    const identity = `${period}:${row.val}:${denominator}`;
-    const prior = identical.get(identity);
-    if (prior && prior.accn !== row.accn) connect(prior.accn, row.accn, 1);
-    else identical.set(identity, row);
   }
+  const ratios = [...new Set(splits.map((split) => split.val!))];
+  // A filing rounds its share counts to one unit, the largest power of ten
+  // dividing every diluted count it reports (Tesla gave thousands until 2019
+  // and millions after). Two counts are one basis when the finer one, rounded
+  // to the coarser filing's unit, gives the coarser one, and every disclosed
+  // split would move a count by more than that unit. Counts at exact share
+  // precision must be equal.
+  const unit = new Map<string, number>();
+  for (const row of entries(payload, "WeightedAverageNumberOfDilutedSharesOutstanding", "shares")) {
+    let power = 1;
+    while (row.val! > 0 && row.val! % (power * 10) === 0) power *= 10;
+    unit.set(row.accn!, Math.min(unit.get(row.accn!) ?? power, power));
+  }
+  const sameShares = (a: number, b: number, coarser: number) => a === b || coarser > 1 && Math.abs(a - b) * 2 <= coarser
+    && ratios.every((ratio) => Math.abs(a - a / ratio) > coarser && Math.abs(a - a * ratio) > coarser);
   // Not every filer tags diluted shares (Alphabet before 2024). Where a filing
   // tags none for the period, a repeated EPS and net income connect instead,
   // when no disclosed split ratio could leave that EPS unchanged at cent
   // rounding. Diluted shares that differ still keep the bases apart.
-  const ratios = [...new Set(splits.map((split) => split.val!))];
   const telling = (value: number) => ratios.every((ratio) => Math.abs(value - value / ratio) > .005 + .005 / ratio
     && Math.abs(value - value * ratio) > .005 + .005 * ratio);
   const tagged = new Set(entries(payload, "WeightedAverageNumberOfDilutedSharesOutstanding", "shares").map(key));
@@ -155,8 +163,13 @@ export function createSecEpsBasisResolver(payload: unknown): (fact: Fact) => { v
     for (let i = 0; i < rows.length; i++) {
       for (let j = i + 1; j < rows.length; j++) {
         const [a, b] = [rows[i]!, rows[j]!];
-        if (a.accn === b.accn || a.val !== b.val || !a.val || !telling(a.val)) continue;
-        if (tagged.has(key(a)) && tagged.has(key(b))) continue;
+        if (a.accn === b.accn || a.val !== b.val || !a.val) continue;
+        const [sharesA, sharesB] = [shares.get(key(a))?.val, shares.get(key(b))?.val];
+        if (sharesA && sharesB && sharesA > 0 && sharesB > 0) {
+          if (sameShares(sharesA, sharesB, Math.max(unit.get(a.accn) ?? 1, unit.get(b.accn) ?? 1))) connect(a.accn, b.accn, 1);
+          continue;
+        }
+        if (!telling(a.val) || tagged.has(key(a)) && tagged.has(key(b))) continue;
         const repeated = income.get(key(a))?.val;
         if (repeated !== undefined && repeated !== 0 && repeated === income.get(key(b))?.val) connect(a.accn, b.accn, 1);
       }