gloomberb 0.16.0 → 0.16.2

package/src/market-data/market/status.ts

@@ -1,5 +1,7 @@
 import type { MarketState, Quote } from "../../types/financials";
 import { blendHex, colors, priceColor, type ThemeColors } from "../../theme/colors";
+import { isFiniteNumber } from "../../utils/guards";
+import { quoteTradingDay } from "../quotes/day-range";
 
 const CLOSED_CHANGE_MUTING_RATIO = 0.55;
 const US_SESSION_TIME = new Intl.DateTimeFormat("en-US", {
@@ -20,6 +22,12 @@ export interface ActiveQuoteDisplay {
   changePercent?: number;
 }
 
+export type ExtendedSession = "PRE" | "POST";
+
+export interface ExtendedSessionDisplay extends ActiveQuoteDisplay {
+  session: ExtendedSession;
+}
+
 export function marketStateLabel(state: MarketState): string {
   switch (state) {
     case "PRE": return "PRE-MKT";
@@ -124,6 +132,11 @@ export function exchangeShortName(exchangeName?: string, fullExchangeName?: stri
   return map[name] || name;
 }
 
+/**
+ * The live print against the daily reference, extended hours included: what
+ * a position is worth now and its day P&L. A headline that shows an
+ * extended-hours line beside it uses getRegularSessionDisplay instead.
+ */
 export function getActiveQuoteDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
   if (!quote) return null;
   if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice != null) {
@@ -141,3 +154,141 @@ export function getActiveQuoteDisplay(quote: Quote | null | undefined): ActiveQu
   }
   return { price: quote.price, change: quote.change, changePercent: quote.changePercent };
 }
+
+function isPositive(value: number | undefined): value is number {
+  return isFiniteNumber(value) && value > 0;
+}
+
+interface CompletedRegularSession {
+  close: number;
+  /** The close's move from the session before it, when the quote reports it with the close. */
+  reported: { change: number; changePercent: number } | null;
+}
+
+function reportedRegularMove(quote: Quote, close: number): CompletedRegularSession["reported"] {
+  const change = quote.regularChange;
+  if (!isFiniteNumber(change)) return null;
+  const reference = close - change;
+  const changePercent = isFiniteNumber(quote.regularChangePercent)
+    ? quote.regularChangePercent
+    : isPositive(reference) ? (change / reference) * 100 : null;
+  return changePercent == null ? null : { change, changePercent };
+}
+
+/**
+ * The regular session the quote's day follows, once it is over: after hours,
+ * overnight, and through a weekend or holiday until the next pre-market, and
+ * in the pre-market when the quote reports the last session's close and move,
+ * which its own previous close can no longer give once the day has rolled.
+ * Only a US listing with extended trading reports one. Without a reported
+ * close, an after-hours print less its move from the close gives it. Null in
+ * the regular session.
+ */
+function completedRegularSession(quote: Quote): CompletedRegularSession | null {
+  const state = quote.marketState;
+  if (state == null || state === "REGULAR") return null;
+  const close = quote.regularClose;
+  if (isPositive(close)) {
+    const closeDate = quote.regularCloseSessionDate;
+    const reported = reportedRegularMove(quote, close);
+    if (state === "PRE") {
+      // The quote's own day is today; the close must be an earlier one, with its move.
+      const today = quoteTradingDay(quote);
+      return reported && closeDate && today && closeDate < today ? { close, reported } : null;
+    }
+    if (closeDate ? closeDate === quoteTradingDay(quote) : state === "POST") return { close, reported };
+  }
+  if (state === "POST" && isFiniteNumber(quote.postMarketPrice) && isFiniteNumber(quote.postMarketChange)) {
+    const derived = quote.postMarketPrice - quote.postMarketChange;
+    if (derived > 0) return { close: derived, reported: null };
+  }
+  return null;
+}
+
+function completedRegularClose(quote: Quote): number | null {
+  return completedRegularSession(quote)?.close ?? null;
+}
+
+/**
+ * The day's headline: the regular session, which stops at its close. Once it
+ * is over, and in the pre-market while the quote carries the last session's
+ * close and move, the price is that close and the move is its own, so
+ * extended trading never moves it; the extended print is
+ * getExtendedSessionDisplay. A close without its reported move is measured
+ * against the previous close. In the pre-market without that close and move
+ * the headline is the live price against the previous close, as the
+ * pre-market line is.
+ */
+export function getRegularSessionDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
+  if (!quote) return null;
+  const session = completedRegularSession(quote);
+  if (session == null) return { price: quote.price, change: quote.change, changePercent: quote.changePercent };
+  const { close, reported } = session;
+  if (reported) return { price: close, ...reported };
+  const reference = isPositive(quote.previousClose)
+    ? quote.previousClose
+    : isFiniteNumber(quote.change) && isPositive(quote.price - quote.change) ? quote.price - quote.change : null;
+  if (reference == null) return { price: close };
+  const change = close - reference;
+  return { price: close, change, changePercent: (change / reference) * 100 };
+}
+
+/**
+ * getRegularSessionDisplay once the regular session is over (and in the
+ * pre-market, while the quote carries the last session's close and move), null
+ * while it is open. A table row headlines this when it has a column for the
+ * extended move: the close and its move stay put, and the extended column is
+ * the only figure that follows the extended print.
+ */
+export function getCompletedRegularSessionDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
+  return quote && completedRegularClose(quote) != null ? getRegularSessionDisplay(quote) : null;
+}
+
+/**
+ * The pre-market or after-hours print, measured from the regular close before
+ * it, while the quote has one: the pre-market until the open, the after-hours
+ * session from the close, and its last print until the next pre-market. Null
+ * when there is no extended print to show.
+ */
+export function getExtendedSessionDisplay(quote: Quote | null | undefined): ExtendedSessionDisplay | null {
+  if (!quote) return null;
+  const state = quote.marketState;
+  if (state === "PRE" || state === "PREPRE") {
+    if (isFiniteNumber(quote.preMarketPrice)) {
+      // Against the close the headline shows, so the two cannot disagree about it.
+      const close = state === "PRE" && quote.preMarketPrice > 0 ? completedRegularClose(quote) : null;
+      if (close != null) {
+        const change = quote.preMarketPrice - close;
+        return { session: "PRE", price: quote.preMarketPrice, change, changePercent: (change / close) * 100 };
+      }
+      return { session: "PRE", price: quote.preMarketPrice, change: quote.preMarketChange, changePercent: quote.preMarketChangePercent };
+    }
+    if (state === "PRE") return null;
+  }
+  const close = completedRegularClose(quote);
+  if (close == null) {
+    return state === "POST" && isFiniteNumber(quote.postMarketPrice)
+      ? { session: "POST", price: quote.postMarketPrice, change: quote.postMarketChange, changePercent: quote.postMarketChangePercent }
+      : null;
+  }
+  const price = state === "POST" ? quote.postMarketPrice ?? quote.price : quote.price;
+  // Once the session is over, a last print at the close means nothing traded after it.
+  if (!isPositive(price) || (state !== "POST" && price === close)) return null;
+  const change = price - close;
+  return { session: "POST", price, change, changePercent: (change / close) * 100 };
+}
+
+/** The extended display only while its session is open: the pre-market or the after-hours session. */
+function getOpenExtendedSessionDisplay(quote: Quote | null | undefined): ExtendedSessionDisplay | null {
+  return quote?.marketState === "PRE" || quote?.marketState === "POST" ? getExtendedSessionDisplay(quote) : null;
+}
+
+/**
+ * The move a board of tiles colors by: the open pre-market or after-hours
+ * session's, from the regular close, otherwise the day's regular session.
+ */
+export function getSessionMoveDisplay(
+  quote: Quote | null | undefined,
+): (ActiveQuoteDisplay & { session?: ExtendedSession }) | null {
+  return getOpenExtendedSessionDisplay(quote) ?? getRegularSessionDisplay(quote);
+}

package/src/market-data/published-apac-sessions.ts

@@ -0,0 +1,66 @@
+// Published full-day closures (weekend dates omitted) for Asia-Pacific venues,
+// not a holiday-rule engine. A year a venue has not published is unknown, not
+// open: every weekday of it reads as a session. Half-day sessions (HKEX and
+// SGX eves, ASX's 14:10 closes) are not modelled. Checked 2026-10-09:
+// KRX, also KOSDAQ: http://open.krx.co.kr/contents/MKD/01/0110/01100305/MKD01100305.jsp
+// TWSE, whose closures TPEx shares: https://www.twse.com.tw/en/trading/holiday.html
+//   (2027 not yet published; 12 and 13 Feb 2026 are clearing-only days without trading)
+// HKEX: https://www.hkex.com.hk/-/media/HKEX-Market/Services/Circulars-and-Notices/Participant-and-Members-Circulars/SEHK/2025/ce_SEHK_CT_075_2025.pdf
+//   and https://www.hkex.com.hk/-/media/HKEX-Market/Services/Circulars-and-Notices/Participant-and-Members-Circulars/SEHK/2026/ce_SEHK_CT_077_2026.pdf
+// SGX closes on Singapore's gazetted public holidays, one on a Sunday moving to the Monday:
+//   https://www.sgx.com/stock-exchange/trading and https://www.mom.gov.sg/employment-practices/public-holidays
+// ASX: https://www.asx.com.au/markets/market-resources/trading-hours-calendar/cash-market-trading-hours/trading-calendar
+const KRX_CLOSURES: Record<number, readonly string[]> = {
+  2026: [
+    "01-01", "02-16", "02-17", "02-18", "03-02", "05-01", "05-05", "05-25", "06-03",
+    "07-17", "08-17", "09-24", "09-25", "10-05", "10-09", "12-25", "12-31",
+  ],
+  2027: [
+    "01-01", "02-08", "02-09", "03-01", "05-03", "05-05", "05-13", "07-19", "08-16",
+    "09-14", "09-15", "09-16", "10-04", "10-11", "12-27", "12-31",
+  ],
+};
+
+const TWSE_CLOSURES: Record<number, readonly string[]> = {
+  2026: [
+    "01-01", "02-12", "02-13", "02-16", "02-17", "02-18", "02-19", "02-20", "02-27",
+    "04-03", "04-06", "05-01", "06-19", "09-25", "09-28", "10-09", "10-26", "12-25",
+  ],
+};
+
+/** Closures by canonical venue code. */
+export const PUBLISHED_APAC_CLOSURES: Readonly<Record<string, Record<number, readonly string[]>>> = {
+  KRX: KRX_CLOSURES,
+  KOSDAQ: KRX_CLOSURES,
+  TWSE: TWSE_CLOSURES,
+  TPEX: TWSE_CLOSURES,
+  HKEX: {
+    2026: [
+      "01-01", "02-17", "02-18", "02-19", "04-03", "04-06", "04-07", "05-01", "05-25",
+      "06-19", "07-01", "10-01", "10-19", "12-25",
+    ],
+    2027: [
+      "01-01", "02-08", "02-09", "03-26", "03-29", "04-05", "05-13", "06-09", "07-01",
+      "09-16", "10-01", "10-08", "12-27",
+    ],
+  },
+  SGX: {
+    2026: ["01-01", "02-17", "02-18", "04-03", "05-01", "05-27", "06-01", "08-10", "11-09", "12-25"],
+    2027: ["01-01", "02-08", "03-10", "03-26", "05-17", "05-20", "08-09", "10-28"],
+  },
+  ASX: {
+    2026: ["01-01", "01-26", "04-03", "04-06", "06-08", "12-25", "12-28"],
+    2027: ["01-01", "01-26", "03-26", "03-29", "06-14", "12-27", "12-28"],
+  },
+};
+
+/** True only for a published full-day closure; unpublished years are unknown, not open. */
+export function isPublishedApacClosure(exchange: string, date: string): boolean {
+  if (!Object.hasOwn(PUBLISHED_APAC_CLOSURES, exchange)) return false;
+  return PUBLISHED_APAC_CLOSURES[exchange]![Number(date.slice(0, 4))]?.includes(date.slice(5)) ?? false;
+}
+
+/** True when the venue's closures of that year are published. */
+export function hasPublishedApacCalendar(exchange: string, year: number): boolean {
+  return Object.hasOwn(PUBLISHED_APAC_CLOSURES, exchange) && PUBLISHED_APAC_CLOSURES[exchange]![year] !== undefined;
+}

package/src/market-data/quotes/contributions.ts

@@ -152,6 +152,12 @@ export function mergeQuoteContribution(
   }
   if (!current) return next;
 
+  // NAV responses are complete dated observations. Never carry an earlier
+  // date or intraday session fields into one, or its marker into a later tick.
+  if (current.priceObservation != null || next.priceObservation != null) {
+    return { ...next, name: next.name ?? current.name };
+  }
+
   const priorBasis = resolvePriceBasis(current.priceBasis, current.instrumentType);
   const samePriceBasis = priorBasis !== null && priorBasis === resolvePriceBasis(next.priceBasis, next.instrumentType || current.instrumentType);
   const merged: QuoteContribution = {
@@ -171,6 +177,8 @@ export function mergeQuoteContribution(
     priceBasis: next.priceBasis,
     regularClose: next.regularClose,
     regularCloseSessionDate: next.regularClose != null ? next.regularCloseSessionDate : undefined,
+    regularChange: next.regularClose != null ? next.regularChange : undefined,
+    regularChangePercent: next.regularClose != null ? next.regularChangePercent : undefined,
   };
 
   if (isOtherTradingDay(current, next)) {

package/src/market-data/quotes/freshness.ts

@@ -1,5 +1,7 @@
 import type { Quote } from "../../types/financials";
 import { isUsListingExchange } from "../../utils/exchanges";
+import { zonedDateKey } from "../../utils/zoned-date-time";
+import { getPublishedUsEquitySession } from "../published-us-sessions";
 import { quoteFutureToleranceMs } from "./clock";
 import {
   activeUsExtendedHoursSession,
@@ -7,6 +9,9 @@ import {
   isUsPriorSessionPremarketQuote,
 } from "../market/freshness";
 
+// Give the next regular session's NAV time to publish after its actual close.
+const NAV_PUBLICATION_ALLOWANCE_MS = 12 * 60 * 60_000;
+
 /**
  * Receipt time cannot establish when the source observed a quoted price. A
  * stamp slightly ahead of local time is clock skew, not a bad observation.
@@ -18,6 +23,36 @@ export function hasValidQuoteObservationTime(quote: Pick<Quote, "lastUpdated">,
     && Number.isFinite(new Date(timestamp).getTime()) && Number.isFinite(new Date(now).getTime());
 }
 
+/** The source date of a validated daily fund observation, including an old NAV. */
+export function dailyNavDate(quote: Quote, now = Date.now()): string | null {
+  if (quote.priceObservation !== "nav" || quote.instrumentType !== "MUTUALFUND"
+    || (quote.priceBasis !== undefined && quote.priceBasis !== "per-unit")
+    || !Number.isFinite(quote.price) || quote.price <= 0
+    || !hasValidQuoteObservationTime(quote, now) || quote.lastUpdated > now) return null;
+  const exchange = quote.listingExchangeName || quote.exchangeName;
+  const date = quote.changeSessionDate;
+  if (typeof exchange !== "string" || typeof date !== "string"
+    || getPublishedUsEquitySession(exchange, date)?.kind !== "session"
+    || zonedDateKey(quote.lastUpdated, "America/New_York") !== date) return null;
+  return date;
+}
+
+function isDailyNavStale(quote: Quote, now: number): boolean {
+  const date = dailyNavDate(quote, now);
+  if (!date) return true;
+  const exchange = quote.listingExchangeName || quote.exchangeName;
+  const today = zonedDateKey(now, "America/New_York");
+  if (!today || !getPublishedUsEquitySession(exchange!, today) || date > today) return true;
+  const sourceDay = Date.parse(`${date}T00:00:00Z`);
+  for (let ahead = 1; ahead <= 10; ahead++) {
+    const nextDate = new Date(sourceDay + ahead * 24 * 60 * 60_000).toISOString().slice(0, 10);
+    const next = getPublishedUsEquitySession(exchange!, nextDate);
+    if (!next) return true;
+    if (next.kind === "session") return now >= next.close + NAV_PUBLICATION_ALLOWANCE_MS;
+  }
+  return true;
+}
+
 export function isExtendedHoursExchange(quote: Quote): boolean {
   return isUsListingExchange(quote.listingExchangeName || quote.exchangeName);
 }
@@ -38,6 +73,7 @@ export function isQuoteStaleForCurrentSession(quote: Quote | null | undefined, n
   if (!quote) return false;
   if (quote.stale === true) return true;
   if (!hasValidQuoteObservationTime(quote, now)) return true;
+  if (quote.priceObservation != null) return isDailyNavStale(quote, now);
   if (isQuoteMissingActiveSessionPrice(quote, now)) return true;
 
   // A tolerated future stamp belongs to the session in progress, not the next one.

package/src/market-data/quotes/resolution.ts

@@ -12,7 +12,7 @@ import { mergeQuoteMetadata, quoteMetadataFromQuote } from "./metadata";
 import { resolvePriceBasis } from "../market/price-basis";
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
 import { debugLog } from "../../utils/debug-log";
-import { hasValidQuoteObservationTime, isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "./freshness";
+import { dailyNavDate, hasValidQuoteObservationTime, isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "./freshness";
 import { activeUsExtendedHoursSession, isTimestampStaleForExchangeSession } from "../market/freshness";
 import {
   finalizeSessionFields,
@@ -243,7 +243,10 @@ function buildAcceptedPriceCandidates(contributions: QuoteContribution[], now: n
 } {
   const ranks = new Map(contributions.map((quote) => [quote, priceRank(quote, now)] as const));
   const sorted = [...contributions]
-    .filter((quote) => Number.isFinite(quote.price))
+    // Even a stale research snapshot must have its own NAV evidence. Canonical
+    // fallbacks cannot supply a missing observation time or security type.
+    .filter((quote) => Number.isFinite(quote.price)
+      && (quote.priceObservation == null || dailyNavDate(quote, now) !== null))
     .sort((left, right) => {
       const rankDelta = ranks.get(left)! - ranks.get(right)!;
       if (rankDelta !== 0) return rankDelta;
@@ -281,7 +284,7 @@ function buildAcceptedPriceCandidates(contributions: QuoteContribution[], now: n
 }
 
 export function isQuoteContributionStaleForCurrentSession(contribution: Quote, now = Date.now()): boolean {
-  if (contribution.marketState != null) return isQuoteStaleForCurrentSession(contribution, now);
+  if (contribution.priceObservation != null || contribution.marketState != null) return isQuoteStaleForCurrentSession(contribution, now);
   // A price-only source can be combined with independent session metadata.
   // Its observation must still belong to the current active session.
   if (contribution.stale === true || !hasValidQuoteObservationTime(contribution, now)) return true;
@@ -387,8 +390,8 @@ export function resolveCanonicalQuote(
   const { accepted: acceptedPriceCandidates, rejectedProviders } = buildAcceptedPriceCandidates(effectiveQuoteCandidates, now);
   if (acceptedPriceCandidates.length === 0) return {};
 
-  const sessionCandidates = buildSessionCandidates(effectiveQuoteCandidates);
-  const listingCandidates = buildListingCandidates(contributions);
+  let sessionCandidates = buildSessionCandidates(effectiveQuoteCandidates);
+  let listingCandidates = buildListingCandidates(contributions);
   const routingCandidates = buildRoutingCandidates(contributions);
   const descriptiveCandidates = buildDescriptiveCandidates(contributions);
 
@@ -401,9 +404,18 @@ export function resolveCanonicalQuote(
   // The selected response owns the price convention; metadata enrichment must
   // not declare units for another provider's price or supply incompatible anchors.
   assignField(resolved, provenance, "priceBasis", priceProvider);
+  assignField(resolved, provenance, "priceObservation", priceProvider);
+  const isNav = priceProvider?.priceObservation === "nav";
+  if (isNav) {
+    sessionCandidates = priceProvider ? [priceProvider] : [];
+    listingCandidates = sessionCandidates;
+  } else {
+    sessionCandidates = sessionCandidates.filter((quote) => quote.priceObservation == null);
+  }
   const selectedBasis = resolvePriceBasis(priceProvider?.priceBasis, priceProvider?.instrumentType);
   const compatiblePrice = (candidate: QuoteContribution) => candidate === priceProvider
-    || selectedBasis !== null && resolvePriceBasis(candidate.priceBasis, candidate.instrumentType) === selectedBasis;
+    || !isNav && candidate.priceObservation == null
+      && selectedBasis !== null && resolvePriceBasis(candidate.priceBasis, candidate.instrumentType) === selectedBasis;
   const compatiblePriceCandidates = acceptedPriceCandidates.filter(compatiblePrice);
   for (const field of PRICE_FIELD_KEYS) {
     if (field === "price") continue;
@@ -459,13 +471,14 @@ export function resolveCanonicalQuote(
 
   let descriptiveProvider: QuoteContribution | undefined;
   for (const field of DESCRIPTIVE_FIELD_KEYS) {
-    const provider = pickField(resolved, provenance, field, field === "high52w" || field === "low52w" ? descriptiveCandidates.filter(compatiblePrice) : descriptiveCandidates);
+    const ownsPriceField = field === "high52w" || field === "low52w" || isNav && (field === "volume" || field === "marketCap");
+    const provider = pickField(resolved, provenance, field, ownsPriceField ? descriptiveCandidates.filter(compatiblePrice) : descriptiveCandidates);
     descriptiveProvider ??= provider;
   }
   provenance.descriptive = toProvenance(descriptiveProvider);
   // Descriptive enrichment cannot turn an unknown-unit bond observation into
   // an ordinary share price by replacing its source-reported security type.
-  if (priceProvider?.instrumentType?.trim().toUpperCase() === "BOND") {
+  if (isNav || priceProvider?.instrumentType?.trim().toUpperCase() === "BOND") {
     assignField(resolved, provenance, "instrumentType", priceProvider);
   }
 
@@ -474,6 +487,7 @@ export function resolveCanonicalQuote(
     providerId: priceProvider?.providerId ?? contributions[0]!.providerId,
     price: Number(resolved.price ?? priceProvider?.price ?? 0),
     priceBasis: priceProvider?.priceBasis,
+    priceObservation: priceProvider?.priceObservation,
     // The price's own source unit, like its basis; another provider's divisor does not apply.
     ...(typeof priceProvider?.providerPriceDivisor === "number" ? { providerPriceDivisor: priceProvider.providerPriceDivisor } : {}),
     currency: String(resolved.currency ?? priceProvider?.currency ?? contributions[0]!.currency ?? ""),
@@ -482,6 +496,8 @@ export function resolveCanonicalQuote(
     previousClose: resolved.previousClose as Quote["previousClose"],
     regularClose: priceProvider?.regularClose,
     regularCloseSessionDate: priceProvider?.regularClose != null ? priceProvider.regularCloseSessionDate : undefined,
+    regularChange: priceProvider?.regularClose != null ? priceProvider.regularChange : undefined,
+    regularChangePercent: priceProvider?.regularClose != null ? priceProvider.regularChangePercent : undefined,
     changeSessionDate: resolved.changeSessionDate as Quote["changeSessionDate"],
     high52w: resolved.high52w as Quote["high52w"],
     low52w: resolved.low52w as Quote["low52w"],

package/src/market-data/quotes/screener-live-quotes.ts

@@ -5,6 +5,7 @@ import { buildQuoteKey, resolveEntryData } from "../selectors";
 import type { QueryEntry } from "../result-types";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
 import { isFiniteNumber } from "../../utils/guards";
+import { getCompletedRegularSessionDisplay, getSessionMoveDisplay, type ExtendedSession } from "../market/status";
 
 const STREAM_FRESHNESS_MS = 2 * 60_000;
 const STREAM_CONNECTING_GRACE_MS = 15_000;
@@ -20,6 +21,24 @@ export interface ScreenerQuoteRow {
   exchange: string;
   lastUpdated?: number;
   previousClose?: number;
+  /** Set when the price and move are an open pre-market or after-hours session's (see `extendedSessions`). */
+  extendedSession?: ExtendedSession;
+  /** Set when the price and move are the last completed regular session's close and its move; the move, in percent. */
+  regularChangePercent?: number | null;
+}
+
+export interface ScreenerQuoteOverlayOptions {
+  /**
+   * While a pre-market or after-hours session is open, show its price and its
+   * move from the regular close, marked with `extendedSession`; otherwise the
+   * regular session's, which stops at the close. Without it a row shows the
+   * live price against the previous close. A row that is a completed regular
+   * session's close and move (`regularChangePercent`) keeps them outside the
+   * regular session when its quote has neither an open extended print nor
+   * that session's close of its own, so its price and move never come from
+   * two different days.
+   */
+  extendedSessions?: boolean;
 }
 
 export interface ScreenerQuoteFreshness {
@@ -64,12 +83,14 @@ function overlayCurrency(row: ScreenerQuoteRow, quote: Quote): string {
  * entries map, but most rows' quotes did not move; returning the same row
  * object for those lets memoized table rows skip the render.
  */
-const overlayCache = new WeakMap<object, { quote: Quote; row: ScreenerQuoteRow }>();
+const overlayCache = new WeakMap<object, { quote: Quote; extended: boolean; row: ScreenerQuoteRow }>();
 
 export function overlayScreenerQuoteEntries<T extends ScreenerQuoteRow>(
   rows: readonly T[],
   entries: ReadonlyMap<string, QueryEntry<Quote>>,
+  options: ScreenerQuoteOverlayOptions = {},
 ): T[] {
+  const extended = options.extendedSessions === true;
   return rows.map((row) => {
     const quote = resolveEntryData(entries.get(quoteKey(row)));
     if (!quote || !isFiniteNumber(quote.price)) return row;
@@ -81,9 +102,9 @@ export function overlayScreenerQuoteEntries<T extends ScreenerQuoteRow>(
       return row;
     }
     const cached = overlayCache.get(row);
-    if (cached?.quote === quote) return cached.row as T;
-    const overlaid = overlayQuote(row, quote);
-    overlayCache.set(row, { quote, row: overlaid });
+    if (cached?.quote === quote && cached.extended === extended) return cached.row as T;
+    const overlaid = extended ? overlaySessionQuote(row, quote) : overlayQuote(row, quote);
+    overlayCache.set(row, { quote, extended, row: overlaid });
     return overlaid;
   });
 }
@@ -101,6 +122,30 @@ function overlayQuote<T extends ScreenerQuoteRow>(row: T, quote: Quote): T {
     currency: overlayCurrency(row, quote),
     previousClose: isFiniteNumber(quote.previousClose) ? quote.previousClose : undefined,
     lastUpdated: quote.lastUpdated,
+    // The streamed price and move are no longer the snapshot's completed session.
+    ...(row.regularChangePercent !== undefined ? { regularChangePercent: null } : {}),
+  };
+}
+
+function overlaySessionQuote<T extends ScreenerQuoteRow>(row: T, quote: Quote): T {
+  const overlaid = overlayQuote(row, quote);
+  const display = getSessionMoveDisplay(quote);
+  if (!display || !isFiniteNumber(display.price)) return overlaid;
+  if (
+    !display.session
+    && row.regularChangePercent != null
+    && quote.marketState != null
+    && quote.marketState !== "REGULAR"
+    && !getCompletedRegularSessionDisplay(quote)
+  ) {
+    return { ...overlaid, price: row.price, change: row.change, changePercent: row.changePercent, regularChangePercent: row.regularChangePercent };
+  }
+  return {
+    ...overlaid,
+    price: display.price,
+    change: isFiniteNumber(display.change) ? display.change : null,
+    changePercent: isFiniteNumber(display.changePercent) ? display.changePercent : null,
+    extendedSession: display.session,
   };
 }
 

package/src/market-data/quotes/time.ts

@@ -1,4 +1,20 @@
 import type { Quote } from "../../types/financials";
+import { getLanguage, tf } from "../../i18n";
+import { dailyNavDate } from "./freshness";
+
+/** The published NAV session date, independent of local time and receipt time. */
+export function formatQuoteNavAsOf(quote: Quote | null | undefined, now = Date.now()): string | null {
+  const date = quote && dailyNavDate(quote, now);
+  if (!date) return null;
+  const sourceDate = new Date(`${date}T00:00:00Z`);
+  const dateText = new Intl.DateTimeFormat(getLanguage(), {
+    timeZone: "UTC",
+    month: "short",
+    day: "numeric",
+    ...(sourceDate.getUTCFullYear() !== new Date(now).getUTCFullYear() ? { year: "numeric" as const } : {}),
+  }).format(sourceDate);
+  return tf("NAV · as of {date}", { date: dateText });
+}
 
 function clampQuoteTimestamp(lastUpdated: number | undefined, now = Date.now()): number | null {
   if (typeof lastUpdated !== "number" || !Number.isFinite(lastUpdated) || lastUpdated <= 0) {

package/src/plugins/builtin/account-management/pane.tsx

@@ -22,11 +22,13 @@ import {
   ScrollBox,
   Textarea,
   TextAttributes,
+  useUiCapabilities,
   type ScrollBoxRenderable,
   type TextareaRenderable,
 } from "../../../ui";
 import { useDialog, type AlertContext } from "../../../ui/dialog";
 import type { SelectControl } from "../../../components/ui/select-button";
+import { FRAMED_TEXTAREA_DESKTOP_STYLE } from "../../../components/ui/fields";
 import { apiClient, type AccountProfile, type CloudPricing } from "../../../api-client";
 import { chatController } from "../chat/controller";
 import { SignInWall } from "../cloud/auth-actions";
@@ -220,6 +222,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
     setActiveField(ACCOUNT_TAB_FIELD_ORDER[tab][0] ?? "username");
   }), []);
   const syncStatus = useCloudSyncStatus();
+  const { nativePaneChrome } = useUiCapabilities();
   const bioRef = useRef<TextareaRenderable | null>(null);
   const portfolioSelectRef = useRef<SelectControl | null>(null);
   const refreshedSyncRevisionRef = useRef<number | null>(null);
@@ -821,6 +824,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
                     backgroundColor={colors.panel}
                     flexGrow={1}
                     wrapText
+                    {...(nativePaneChrome ? { style: FRAMED_TEXTAREA_DESKTOP_STYLE } : {})}
                     onInput={(value: string) => setDraftValue("bio", value)}
                   />
                 </Box>

package/src/plugins/builtin/alerts/cli.ts

@@ -1,7 +1,8 @@
 import { withConfigData } from "../../../cli/scoped-context";
 import { CLI_COMMAND_GROUPS } from "../../../cli/help";
 import { dryRunNote } from "../../../cli/helpers";
-import { requireArg } from "../../../cli/commands/command-utils";
+import { requireArg, takeOption } from "../../../cli/commands/command-utils";
+import { EXCHANGE_OPTION, requireListingArg } from "../../../cli/listing-arg";
 import { saveConfig } from "../../../data/config/store";
 import type { CliCommandDef } from "../../../types/plugin";
 import { cliStyles } from "../../../utils/cli-output";
@@ -18,10 +19,14 @@ export const alertsCliCommand: CliCommandDef = {
   help: {
     group: CLI_COMMAND_GROUPS.portfolios,
     usage: ["alerts list", "alerts add <symbol> <above|below|crosses> <price>", "alerts delete <id>", "alerts rearm <id>"],
-    examples: ["alerts", "alerts add AAPL above 250", "alerts add BTC-USD below 60000"],
+    options: [EXCHANGE_OPTION],
+    examples: ["alerts", "alerts add AAPL above 250", "alerts add SAN:EPA below 70", "alerts add BTC-USD below 60000"],
   },
-  execute: async (args, ctx) => {
+  execute: async (rawArgs, ctx) => {
+    const args = [...rawArgs];
+    const exchange = takeOption(args, "--exchange");
     const action = args[0] ?? "list";
+    const listing = action === "add" && args[1] ? await requireListingArg(args[1], exchange, ctx) : null;
     await withConfigData(ctx, async (config) => {
       const raw = config.config.pluginConfig[ALERTS_PLUGIN_ID]?.[ALERTS_KEY];
       const alerts = deserializeAlerts(typeof raw === "string" ? raw : "[]");
@@ -56,12 +61,12 @@ export const alertsCliCommand: CliCommandDef = {
         return;
       }
       if (action === "add") {
-        const symbol = requireArg(args[1]?.toUpperCase(), "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>", ctx);
+        const symbol = requireArg(listing?.key, "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>", ctx);
         const condition = requireArg(args[2], "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>", ctx) as AlertCondition;
         if (!["above", "below", "crosses"].includes(condition)) ctx.fail("Condition must be above, below, or crosses.");
         const price = Number(requireArg(args[3], "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>", ctx));
         if (!Number.isFinite(price)) ctx.fail("Alert price must be a finite number.");
-        const alert = createAlert(symbol, condition, price);
+        const alert = createAlert(symbol, condition, price, listing?.exchange);
         await saveAlerts([...alerts, alert]);
         ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert } }, {
           text: (data) => `Added alert ${data.alert.id}: ${symbol} ${condition} ${price}.${dryRunNote(data.dryRun)}`,

package/src/plugins/builtin/alerts/index.tsx

@@ -282,6 +282,7 @@ export const alertsPlugin: GloomPlugin = {
 
     ctx.registerPane({
       id: "alerts",
+      reportFreshness: { source: "Your alerts", status: "not-a-feed", basis: "your alert rules" },
       name: "Alerts",
       icon: "A",
       component: AlertsPane,

package/src/plugins/builtin/analytics/metrics.ts

@@ -33,13 +33,18 @@ export function syntheticPositionUnsupportedReason(ticker: TickerRecord, quoteCu
   if (positions.some((position) => position.side === "short" || position.shares < 0)) {
     return "Short positions: signed exposure history required";
   }
+  const category = (ticker.metadata.assetCategory ?? "").toUpperCase();
+  // Crypto trades every day at another close, so its daily returns do not pair with the equity factor proxies.
+  if (category.startsWith("CRYPTO") || /-[A-Z]{3,4}$/.test(ticker.metadata.ticker)) {
+    return "Crypto is not covered by the equity basket";
+  }
   // "Common Stock" is the category provider search hands a ticker added from
   // the command bar, so a plain equity must not read as unsupported.
   const equityCategories = new Set(["", "STK", "STOCK", "COMMON STOCK", "EQUITY", "ETF", "ETN", "FUND", "ADR", "REIT"]);
-  if (!equityCategories.has((ticker.metadata.assetCategory ?? "").toUpperCase())
+  if (!equityCategories.has(category)
     || positions.some((position) => position.multiplier != null && position.multiplier !== 1)
-    || /=[A-Z]+$|-[A-Z]{3,4}$|\d{6}[CP]\d{8}$/.test(ticker.metadata.ticker)) {
-    return "Unsupported asset: equity basket estimate only";
+    || /=[A-Z]+$|\d{6}[CP]\d{8}$/.test(ticker.metadata.ticker)) {
+    return "Asset type is not covered by the equity basket";
   }
   if (quoteCurrency !== "USD") return "Foreign holdings: historical FX returns required";
   return null;