gloomberb 0.16.3 → 0.16.5

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

@@ -9,6 +9,11 @@ import { quoteFutureToleranceMs } from "../quotes/clock";
 import { zonedDateKey, zonedDateTimeParts, zonedWallClockToUtcMs } from "../../utils/zoned-date-time";
 
 const ALWAYS_OPEN_EXCHANGES = new Set(["CCC"]);
+
+/** Spot crypto venues have no equity open or close. */
+export function isAlwaysOpenExchange(exchange: string | undefined): boolean {
+  return ALWAYS_OPEN_EXCHANGES.has(canonicalExchange(exchange));
+}
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 const OVERNIGHT_CLOSE_MAX_AGE_MS = 20 * 60 * 60 * 1000;
 const ALWAYS_OPEN_MAX_AGE_MS = 2 * 60 * 60 * 1000;
@@ -61,6 +66,15 @@ const REGULAR_OPEN_MINUTES: Record<string, number> = {
   B3: 10 * 60,
   BYMA: 11 * 60,
   JSE: 9 * 60,
+  // The opening auction ends at 10:00 and the feed stamps its first bar 09:59.
+  TASE: 9 * 60 + 59,
+  TADAWUL: 10 * 60,
+  QE: 9 * 60 + 30,
+  BHB: 9 * 60 + 30,
+  DFM: 10 * 60,
+  MSX: 10 * 60,
+  KUWAIT: 9 * 60,
+  EGX: 10 * 60,
 };
 // Local regular close with the closing auction, rounded up. A close taken too
 // early would let a copy fetched during the auction pass as final.
@@ -74,7 +88,79 @@ const REGULAR_CLOSE_MINUTES: Record<string, number> = {
   JPX: 15 * 60 + 30, HKEX: 16 * 60 + 10, TWSE: 14 * 60 + 30, TPEX: 14 * 60 + 30,
   NSE: 16 * 60, BSE: 16 * 60, ASX: 16 * 60 + 15, SGX: 17 * 60 + 20, KRX: 16 * 60, KOSDAQ: 16 * 60,
   NZX: 17 * 60, SSE: 15 * 60 + 30, SZSE: 15 * 60 + 30,
-  BMV: 15 * 60 + 10, B3: 18 * 60 + 30, BYMA: 17 * 60 + 10, JSE: 17 * 60 + 15, TASE: 17 * 60 + 40,
+  BMV: 15 * 60 + 10, B3: 18 * 60 + 30, BYMA: 17 * 60 + 10, JSE: 17 * 60 + 15,
+  // Monday to Thursday: trading at last ends 17:30, after the closing auction.
+  // Not later: a complete 5-minute copy ends with its 17:09 bar, which must
+  // reach the close less the half hour a history copy may lag.
+  TASE: 17 * 60 + 30,
+  // Continuous trading to 15:00, the closing auction to 15:10 and trading at
+  // last to 15:20. A complete 5-minute copy ends with its 14:55 bar.
+  TADAWUL: 15 * 60 + 20,
+  // Continuous trading to 13:00, the closing auction to 13:10 and trading at
+  // last to 13:15. A complete 5-minute copy ends with its 13:05 or 13:10 bar.
+  QE: 13 * 60 + 15,
+  // Bahrain Bourse trades continuously to 13:00, with no closing auction.
+  BHB: 13 * 60,
+  // Continuous trading to 14:45, the closing auction to 14:55 and trading at
+  // the close to 15:00. A complete 5-minute copy ends with its 14:55 bar.
+  DFM: 15 * 60,
+  // The Muscat Stock Exchange since 1 Jun 2026: continuous trading to 14:45,
+  // the closing auction to 14:55 and trade at last to 15:00. A complete
+  // 5-minute copy ends with its 14:55 bar.
+  MSX: 15 * 60,
+  // Boursa Kuwait: continuous trading to 13:00, the closing auction to 13:10
+  // and trade at last to 13:15. Not later than the auction's end: a complete
+  // 5-minute copy ends with its 12:40 bar (the source still closes its
+  // period at 12:45), which must reach the close less the half hour a
+  // history copy may lag.
+  KUWAIT: 13 * 60 + 10,
+  // The Egyptian Exchange: continuous trading to 14:15, the closing auction
+  // to 14:25 and trading at the close to 14:30.
+  EGX: 14 * 60 + 25,
+};
+// Venues whose week is not Monday to Friday, as their days off (0 is Sunday).
+// Tadawul, Qatar, Boursa Kuwait and the Egyptian Exchange trade Sunday to
+// Thursday. Dubai's DFM has traded Monday to Friday since 2022, like the
+// venues not listed here.
+const WEEKEND_DAYS: Record<string, readonly number[]> = {
+  TADAWUL: [5, 6],
+  // Bahrain Bourse trades Sunday to Thursday.
+  BHB: [5, 6],
+  QE: [5, 6],
+  // The Muscat Stock Exchange trades Sunday to Thursday.
+  MSX: [5, 6],
+  KUWAIT: [5, 6],
+  EGX: [5, 6],
+};
+const DEFAULT_WEEKEND_DAYS: readonly number[] = [0, 6];
+// History only: venues whose chart source files their bars on another week,
+// as its days off. The chart source still files DFM Sunday to Thursday, the
+// week Dubai traded until 2022, and has no Friday bars, so DFM history ends
+// with Thursday's session from Friday until Monday's opens.
+const HISTORY_SOURCE_WEEKEND_DAYS: Record<string, readonly number[]> = {
+  DFM: [5, 6],
+};
+
+/**
+ * For history only, the days off of the sessions a venue's chart source has
+ * bars for, where its week differs from the venue's: the days both weeks
+ * trade (DFM Monday to Thursday, since Dubai does not trade the source's
+ * Sundays). Undefined for every other venue. Quotes and the calendar keep the
+ * venue's own week.
+ */
+export function historySourceWeekendDays(exchange: string | undefined): readonly number[] | undefined {
+  const canonical = canonicalExchange(exchange);
+  const source = HISTORY_SOURCE_WEEKEND_DAYS[canonical];
+  return source && [...new Set([...(WEEKEND_DAYS[canonical] ?? DEFAULT_WEEKEND_DAYS), ...source])];
+}
+// Venues whose regular session ends earlier on one weekday every week, as
+// local minutes by weekday (0 is Sunday); the other days close as above. TASE
+// has traded Monday to Friday since January 2026, and on Fridays trading at
+// last ends 13:50 (closing auction 13:44 to 13:45). A complete 5-minute copy
+// ends with its 13:29 bar. Holidays and the shortened days around Sukkot and
+// Pesach are not weekly and are not listed.
+const WEEKDAY_CLOSE_MINUTES: Record<string, Partial<Record<number, number>>> = {
+  TASE: { 5: 13 * 60 + 50 },
 };
 // Venues that pause at midday, as local minutes [start, end), with a zone for
 // those the session tables above do not cover. Jakarta pauses longer on Fridays.
@@ -189,20 +275,31 @@ function isPublishedClosure(exchange: string, date: string): boolean {
   return getPublishedUsEquityCalendarDay(exchange, date) === "closed";
 }
 
-function isLocalTradingDay(exchange: string, date: string): boolean {
+/** Whether `weekday` (0 is Sunday) is in the venue's trading week. */
+export function isTradingWeekday(exchange: string, weekday: number, weekendDays?: readonly number[]): boolean {
+  return !(weekendDays ?? WEEKEND_DAYS[exchange] ?? DEFAULT_WEEKEND_DAYS).includes(weekday);
+}
+
+/** `weekendDays` replaces the venue's days off (historySourceWeekendDays). */
+function isLocalTradingDay(exchange: string, date: string, weekendDays?: readonly number[]): boolean {
   const weekday = localWeekday(date);
-  return weekday != null && weekday !== 0 && weekday !== 6 && !isPublishedClosure(exchange, date);
+  return weekday != null && isTradingWeekday(exchange, weekday, weekendDays) && !isPublishedClosure(exchange, date);
 }
 
-/** Weekdays in (earlier, later], less published closures for venues with a calendar. */
-function localTradingDaysBetween(exchange: string, earlierDate: string, laterDate: string): number {
+/** Days of the venue's trading week in (earlier, later], less published closures for venues with a calendar. */
+function localTradingDaysBetween(
+  exchange: string,
+  earlierDate: string,
+  laterDate: string,
+  weekendDays?: readonly number[],
+): number {
   const earlierDay = isoLocalDateToUtcDay(earlierDate);
   const laterDay = isoLocalDateToUtcDay(laterDate);
   if (earlierDay == null || laterDay == null || laterDay <= earlierDay) return 0;
 
   let sessions = 0;
   for (let day = earlierDay + 1; day <= laterDay; day += 1) {
-    if (isLocalTradingDay(exchange, new Date(day * MS_PER_DAY).toISOString().slice(0, 10))) sessions += 1;
+    if (isLocalTradingDay(exchange, new Date(day * MS_PER_DAY).toISOString().slice(0, 10), weekendDays)) sessions += 1;
   }
   return sessions;
 }
@@ -212,6 +309,12 @@ function localWeekday(date: string): number | null {
   return day == null ? null : new Date(day * MS_PER_DAY).getUTCDay();
 }
 
+/** The local close of the venue's regular session on `date`, in minutes of the day. */
+function regularCloseMinutes(exchange: string, date: string): number | undefined {
+  const weekday = localWeekday(date);
+  return (weekday == null ? undefined : WEEKDAY_CLOSE_MINUTES[exchange]?.[weekday]) ?? REGULAR_CLOSE_MINUTES[exchange];
+}
+
 /** The zone a venue's session dates are read in, or null when unknown. */
 export function sessionCalendarTimeZone(exchange: string | undefined): string | null {
   const canonical = canonicalExchange(exchange);
@@ -221,13 +324,14 @@ export function sessionCalendarTimeZone(exchange: string | undefined): string |
 
 /**
  * The latest regular session that closed at or before `time`: the published
- * calendar for US venues, otherwise local weekdays less published closures. A
- * venue without a known close hour is taken to close at local midnight. Null
- * for round-the-clock and unknown venues.
+ * calendar for US venues, otherwise the days of the venue's trading week less
+ * published closures. A venue without a known close hour is taken to close at
+ * local midnight. Null for round-the-clock and unknown venues.
  */
 export function latestRegularSessionClose(
   exchange: string | undefined,
   time: number,
+  weekendDays?: readonly number[],
 ): { date: string; close: number; timeZone: string } | null {
   const canonical = canonicalExchange(exchange);
   const timeZone = sessionCalendarTimeZone(canonical);
@@ -240,8 +344,8 @@ export function latestRegularSessionClose(
     let close: number | null = null;
     if (published) {
       if (published.kind === "session") close = published.close;
-    } else if (isLocalTradingDay(canonical, date)) {
-      const minutes = REGULAR_CLOSE_MINUTES[canonical] ?? 24 * 60;
+    } else if (isLocalTradingDay(canonical, date, weekendDays)) {
+      const minutes = regularCloseMinutes(canonical, date) ?? 24 * 60;
       close = zonedWallClockToUtcMs(timeZone, Number(date.slice(0, 4)), Number(date.slice(5, 7)),
         Number(date.slice(8, 10)), Math.floor(minutes / 60), minutes % 60, 0);
     }
@@ -267,10 +371,14 @@ export function regularSessionCloseUtcMinute(exchange: string | undefined, time:
 /**
  * The open of the regular session `time` falls in, or of the latest one
  * before it: the published calendar for US venues, otherwise the venue's
- * local open on a weekday that is not a published closure. Null for
- * round-the-clock venues and venues without a known open hour.
+ * local open on a day of its trading week that is not a published closure.
+ * Null for round-the-clock venues and venues without a known open hour.
  */
-export function latestRegularSessionOpen(exchange: string | undefined, time: number): number | null {
+export function latestRegularSessionOpen(
+  exchange: string | undefined,
+  time: number,
+  weekendDays?: readonly number[],
+): number | null {
   const canonical = canonicalExchange(exchange);
   const timeZone = sessionCalendarTimeZone(canonical);
   if (!timeZone || ALWAYS_OPEN_EXCHANGES.has(canonical) || !Number.isFinite(time)) return null;
@@ -285,7 +393,7 @@ export function latestRegularSessionOpen(exchange: string | undefined, time: num
       if (published.kind === "session") open = published.open;
     } else if (minutes === undefined) {
       return null;
-    } else if (isLocalTradingDay(canonical, date)) {
+    } else if (isLocalTradingDay(canonical, date, weekendDays)) {
       open = zonedWallClockToUtcMs(timeZone, Number(date.slice(0, 4)), Number(date.slice(5, 7)),
         Number(date.slice(8, 10)), Math.floor(minutes / 60), minutes % 60, 0);
     }
@@ -294,22 +402,60 @@ export function latestRegularSessionOpen(exchange: string | undefined, time: num
   return null;
 }
 
+/**
+ * The open of the first regular session after `time`, with its local date and
+ * the venue's zone: the published calendar for US venues, otherwise the
+ * venue's local open on the next day of its trading week that is not a
+ * published closure. Null for round-the-clock venues and venues without a
+ * known open hour.
+ */
+export function nextRegularSessionOpen(
+  exchange: string | undefined,
+  time: number,
+): { date: string; open: number; timeZone: string } | null {
+  const canonical = canonicalExchange(exchange);
+  const timeZone = sessionCalendarTimeZone(canonical);
+  if (!timeZone || ALWAYS_OPEN_EXCHANGES.has(canonical) || !Number.isFinite(time)) return null;
+  const minutes = REGULAR_OPEN_MINUTES[canonical];
+  const { year, month, day } = zonedDateTimeParts(time, timeZone);
+  const today = Date.UTC(year, month - 1, day) / MS_PER_DAY;
+  for (let offset = 0; offset <= SESSION_LOOKBACK_DAYS; offset++) {
+    const date = new Date((today + offset) * MS_PER_DAY).toISOString().slice(0, 10);
+    const published = getPublishedUsEquitySession(canonical, date);
+    let open: number | null = null;
+    if (published) {
+      if (published.kind === "session") open = published.open;
+    } else if (minutes === undefined) {
+      return null;
+    } else if (isLocalTradingDay(canonical, date)) {
+      open = zonedWallClockToUtcMs(timeZone, Number(date.slice(0, 4)), Number(date.slice(5, 7)),
+        Number(date.slice(8, 10)), Math.floor(minutes / 60), minutes % 60, 0);
+    }
+    if (open != null && open > time) return { date, open, timeZone };
+  }
+  return null;
+}
+
 /**
  * Whether `time` is inside a regular session: at or after its open and
  * before its close. Null for venues without known hours.
  */
-export function isRegularSessionTime(exchange: string | undefined, time: number): boolean | null {
-  const open = latestRegularSessionOpen(exchange, time);
+export function isRegularSessionTime(
+  exchange: string | undefined,
+  time: number,
+  weekendDays?: readonly number[],
+): boolean | null {
+  const open = latestRegularSessionOpen(exchange, time, weekendDays);
   if (open === null) return null;
   // Before this session's close, the latest close is still the one before it opened.
-  const close = latestRegularSessionClose(exchange, time);
+  const close = latestRegularSessionClose(exchange, time, weekendDays);
   return !close || close.close < open;
 }
 
 /**
  * True when the venue's full-day closures for the year of `date` are
  * published: US venues, JPX, NSE, BSE, SSE, SZSE, KRX, KOSDAQ, TWSE, TPEX,
- * HKEX, SGX and ASX. Elsewhere a local holiday reads as a weekday.
+ * HKEX, SGX, ASX and EGX. Elsewhere a local holiday reads as a trading day.
  */
 export function hasPublishedSessionCalendar(exchange: string | undefined, date: string): boolean {
   const canonical = canonicalExchange(exchange);
@@ -345,7 +491,7 @@ export function isMiddayBreakPrint(
   if (!pause || !timeZone || !Number.isFinite(timestampMs) || !Number.isFinite(now) || timestampMs > now) return false;
   const { year, month, day } = zonedDateTimeParts(now, timeZone);
   const weekday = new Date(Date.UTC(year, month - 1, day)).getUTCDay();
-  if (weekday === 0 || weekday === 6) return false;
+  if (!isTradingWeekday(canonical, weekday)) return false;
   const [start, end] = weekday === 5 && pause.friday ? pause.friday : pause.weekdays;
   const at = (minutes: number) => zonedWallClockToUtcMs(timeZone, year, month, day, Math.floor(minutes / 60), minutes % 60, 0);
   const breakStart = at(start);
@@ -443,20 +589,35 @@ export function isUsRegularCloseQuoteInPostSession(
 }
 
 /**
- * Whether a US print belongs to the after-hours session in progress: today's,
- * from the regular close. An earlier day's after-hours print is not.
+ * Whether a US print belongs to the extended-hours session the source labels,
+ * or to the regular session it extends. POST, after today's regular close (a
+ * published early close included) and before 20:00: a print from today's
+ * regular session or its after-hours. PRE, before today's open: a print from
+ * the previous regular session or since, so its after-hours or this morning's
+ * pre-market. An earlier print is not, and neither is any print on a day
+ * without a session.
  */
-export function isUsPostSessionPrint(
+export function isUsExtendedHoursSessionPrint(
   timestampMs: number,
   exchange: string | undefined,
+  marketState: MarketState | undefined,
   now = Date.now(),
 ): boolean {
   const canonical = canonicalExchange(exchange);
-  if (!isUsListingExchange(canonical)) return false;
+  if ((marketState !== "PRE" && marketState !== "POST") || !isUsListingExchange(canonical)) return false;
   if (!Number.isFinite(timestampMs) || !Number.isFinite(now) || timestampMs > now + quoteFutureToleranceMs()) return false;
-  if (!Number.isFinite(new Date(now).getTime()) || usSessionState(now) !== "POST") return false;
-  const currentDate = exchangeLocalDate(canonical, now);
-  return !!currentDate && exchangeLocalDate(canonical, timestampMs) === currentDate && usSessionState(timestampMs) === "POST";
+  if (!Number.isFinite(new Date(now).getTime())) return false;
+  const today = exchangeLocalDate(canonical, now);
+  const close = latestRegularSessionClose(canonical, now);
+  if (!today || !close || !isLocalTradingDay(canonical, today)) return false;
+  const session = usSessionState(now);
+  const closedToday = close.date === today;
+  if (marketState === "POST" ? !closedToday || (session !== "REGULAR" && session !== "POST") : closedToday || session !== "PRE") {
+    return false;
+  }
+  // The open of the session that closed last: today's after the close, the previous one before the open.
+  const open = latestRegularSessionOpen(canonical, close.close);
+  return open != null && timestampMs >= open;
 }
 
 export function isTimestampStaleForExchangeSession(
@@ -464,9 +625,10 @@ export function isTimestampStaleForExchangeSession(
   exchange?: string,
   now = Date.now(),
   marketState?: MarketState,
+  weekendDays?: readonly number[],
 ): boolean {
   try {
-    return isTimestampStaleForExchangeSessionUnsafe(timestampMs, exchange, now, marketState);
+    return isTimestampStaleForExchangeSessionUnsafe(timestampMs, exchange, now, marketState, weekendDays);
   } catch {
     return true;
   }
@@ -477,6 +639,7 @@ function isTimestampStaleForExchangeSessionUnsafe(
   exchange?: string,
   now = Date.now(),
   marketState?: MarketState,
+  weekendDays?: readonly number[],
 ): boolean {
   const canonical = canonicalExchange(exchange);
   if (!canonical || !Number.isFinite(timestampMs) || !Number.isFinite(now)) return false;
@@ -498,13 +661,13 @@ function isTimestampStaleForExchangeSessionUnsafe(
     }
   }
 
-  const sessionsBehind = localTradingDaysBetween(canonical, timestampDate, currentDate);
+  const sessionsBehind = localTradingDaysBetween(canonical, timestampDate, currentDate, weekendDays);
   if (sessionsBehind > 1) return true;
   if (sessionsBehind === 1 && now - timestampMs > OVERNIGHT_CLOSE_MAX_AGE_MS) {
     // When today is the first session after a weekend or exchange holiday,
     // the last close stays current until the provider reports the new session.
     const calendarDaysBehind = isoLocalDateToUtcDay(currentDate)! - isoLocalDateToUtcDay(timestampDate)!;
-    return !(isLocalTradingDay(canonical, currentDate) && (calendarDaysBehind > 1 || localWeekday(currentDate) === 1));
+    return !(isLocalTradingDay(canonical, currentDate, weekendDays) && (calendarDaysBehind > 1 || localWeekday(currentDate) === 1));
   }
   return false;
 }

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

@@ -1,6 +1,7 @@
 import type { MarketState, Quote } from "../../types/financials";
 import { blendHex, colors, priceColor, type ThemeColors } from "../../theme/colors";
 import { isFiniteNumber } from "../../utils/guards";
+import { canonicalExchange, isKnownExchangeCode } from "../../utils/exchanges";
 import { quoteTradingDay } from "../quotes/day-range";
 
 const CLOSED_CHANGE_MUTING_RATIO = 0.55;
@@ -24,6 +25,9 @@ export interface ActiveQuoteDisplay {
 
 export type ExtendedSession = "PRE" | "POST";
 
+/** What reports call each extended session's line or column. */
+export const EXTENDED_SESSION_LABELS: Record<ExtendedSession, string> = { PRE: "Pre-Market", POST: "After Hours" };
+
 export interface ExtendedSessionDisplay extends ActiveQuoteDisplay {
   session: ExtendedSession;
 }
@@ -105,31 +109,14 @@ export function marketChangeColor(change: number | undefined, state?: MarketStat
   return blendHex(directionalColor, colors.textDim, CLOSED_CHANGE_MUTING_RATIO);
 }
 
-/** Short exchange display name */
+/**
+ * The venue's code as a listing key names it (EPA, JPX), from the app's one
+ * venue list, so the code a pane shows is the one to type after the symbol.
+ * A venue the list does not know keeps the name it came with.
+ */
 export function exchangeShortName(exchangeName?: string, fullExchangeName?: string): string {
-  if (!exchangeName && !fullExchangeName) return "";
   const name = exchangeName || fullExchangeName || "";
-  // Common market data exchange abbreviations
-  const map: Record<string, string> = {
-    NMS: "NASDAQ", NGM: "NASDAQ", NCM: "NASDAQ", NAS: "NASDAQ",
-    NYQ: "NYSE", NYS: "NYSE",
-    PCX: "ARCA", NYSEArca: "ARCA", "NYSE Arca": "ARCA", ASE: "AMEX",
-    HKG: "HKEX",
-    TYO: "TYO",
-    LSE: "LSE",
-    ASX: "ASX",
-    SGX: "SGX",
-    KSC: "KRX", KOE: "KOSDAQ",
-    TAI: "TWSE",
-    SHH: "SSE", SHZ: "SZSE",
-    PAR: "EURONEXT", AMS: "EURONEXT", BRU: "EURONEXT",
-    GER: "XETRA",
-    OSL: "OSE",
-    BOM: "BSE", NSI: "NSE",
-    SAO: "B3",
-    JPX: "TYO",
-  };
-  return map[name] || name;
+  return isKnownExchangeCode(name) ? canonicalExchange(name) : name;
 }
 
 /**
@@ -278,11 +265,48 @@ export function getExtendedSessionDisplay(quote: Quote | null | undefined): Exte
   return { session: "POST", price, change, changePercent: (change / close) * 100 };
 }
 
+/**
+ * A quote's headline and extended print as flat figures, for a report row or
+ * an export: price, change and changePercent are the regular session's
+ * (getRegularSessionDisplay), the extended fields the pre-market or
+ * after-hours print measured from its close (getExtendedSessionDisplay), all
+ * null when there is none.
+ */
+export function getQuoteSessionFields(quote: Quote | null | undefined) {
+  const headline = getRegularSessionDisplay(quote);
+  const extended = getExtendedSessionDisplay(quote);
+  return {
+    price: headline?.price ?? null,
+    change: headline?.change ?? null,
+    changePercent: headline?.changePercent ?? null,
+    extendedSession: extended?.session ?? null,
+    extendedPrice: extended?.price ?? null,
+    extendedChange: extended?.change ?? null,
+    extendedChangePercent: extended?.changePercent ?? null,
+  };
+}
+
 /** 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 regular session alone, for a board that never shows extended trading:
+ * the live quote while the session trades, then the completed session's close
+ * and its move (getCompletedRegularSessionDisplay). Null outside the session
+ * when the quote cannot say which close that is, rather than an extended
+ * print or a flat move standing in for one. A quote that does not say its
+ * session is read as the regular one, as getRegularSessionDisplay does.
+ */
+export function getRegularSessionMoveDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
+  if (!quote) return null;
+  if (quote.marketState == null || quote.marketState === "REGULAR") {
+    return { price: quote.price, change: quote.change, changePercent: quote.changePercent };
+  }
+  return getCompletedRegularSessionDisplay(quote);
+}
+
 /**
  * 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.
@@ -292,3 +316,15 @@ export function getSessionMoveDisplay(
 ): (ActiveQuoteDisplay & { session?: ExtendedSession }) | null {
   return getOpenExtendedSessionDisplay(quote) ?? getRegularSessionDisplay(quote);
 }
+
+/**
+ * getSessionMoveDisplay for a board that marks an extended move on each tile
+ * (the heat map): while a quote says nothing has traded in the open session
+ * yet (extendedSessionPrint false), its extended figures are the close
+ * carried forward, not a flat print, so the regular session stands.
+ */
+export function getTradedSessionMoveDisplay(
+  quote: Quote | null | undefined,
+): (ActiveQuoteDisplay & { session?: ExtendedSession }) | null {
+  return quote?.extendedSessionPrint === false ? getRegularSessionDisplay(quote) : getSessionMoveDisplay(quote);
+}

package/src/market-data/options-alternatives.ts

@@ -0,0 +1,69 @@
+import { parseFuturesGeneric } from "../utils/futures-generic";
+
+/** A US-listed fund whose options track an instrument that has none of its own. */
+export interface ListedOptionsAlternative {
+  symbol: string;
+  name: string;
+}
+
+/**
+ * Futures roots with no option chain here, and the listed fund whose options
+ * are the nearest stand-in. One table for every surface that says so.
+ */
+const FUTURES_ALTERNATIVES: Readonly<Record<string, ListedOptionsAlternative>> = {
+  GC: { symbol: "GLD", name: "SPDR Gold Shares" },
+  SI: { symbol: "SLV", name: "iShares Silver Trust" },
+  HG: { symbol: "CPER", name: "United States Copper Index Fund" },
+  PL: { symbol: "PPLT", name: "abrdn Physical Platinum Shares" },
+  PA: { symbol: "PALL", name: "abrdn Physical Palladium Shares" },
+  CL: { symbol: "USO", name: "United States Oil Fund" },
+  BZ: { symbol: "BNO", name: "United States Brent Oil Fund" },
+  NG: { symbol: "UNG", name: "United States Natural Gas Fund" },
+  LTH: { symbol: "LIT", name: "Global X Lithium & Battery Tech ETF" },
+  UX: { symbol: "URA", name: "Global X Uranium ETF" },
+  ZC: { symbol: "CORN", name: "Teucrium Corn Fund" },
+  ZW: { symbol: "WEAT", name: "Teucrium Wheat Fund" },
+  ZS: { symbol: "SOYB", name: "Teucrium Soybean Fund" },
+  ES: { symbol: "SPY", name: "SPDR S&P 500 ETF" },
+  NQ: { symbol: "QQQ", name: "Invesco QQQ Trust" },
+  YM: { symbol: "DIA", name: "SPDR Dow Jones Industrial Average ETF" },
+  RTY: { symbol: "IWM", name: "iShares Russell 2000 ETF" },
+  ZB: { symbol: "TLT", name: "iShares 20+ Year Treasury Bond ETF" },
+  ZN: { symbol: "IEF", name: "iShares 7-10 Year Treasury Bond ETF" },
+  "6E": { symbol: "FXE", name: "Invesco CurrencyShares Euro Trust" },
+  "6J": { symbol: "FXY", name: "Invesco CurrencyShares Japanese Yen Trust" },
+  BTC: { symbol: "IBIT", name: "iShares Bitcoin Trust" },
+  ETH: { symbol: "ETHA", name: "iShares Ethereum Trust" },
+};
+
+const MONTH_CODE_CONTRACT = /^([A-Z0-9]{1,3}?)[FGHJKMNQUVXZ]\d{1,4}$/;
+
+/** The futures root a symbol names: GC=F, GCZ26 and the generic GC1 all give GC. */
+function futuresRoot(symbol: string): string | null {
+  const ticker = symbol.trim().toUpperCase().replace(/[.:][A-Z]+$/, "");
+  if (ticker.endsWith("=F")) {
+    const body = ticker.slice(0, -2);
+    return FUTURES_ALTERNATIVES[body] ? body : MONTH_CODE_CONTRACT.exec(body)?.[1] ?? body;
+  }
+  const generic = parseFuturesGeneric(ticker);
+  if (generic) return generic.root;
+  const contract = MONTH_CODE_CONTRACT.exec(ticker)?.[1];
+  return contract && FUTURES_ALTERNATIVES[contract] ? contract : null;
+}
+
+/** The listed fund whose options stand in for an instrument with no chain, if there is one. */
+export function listedOptionsAlternative(symbol: string): ListedOptionsAlternative | null {
+  const root = futuresRoot(symbol);
+  return root ? FUTURES_ALTERNATIVES[root] ?? null : null;
+}
+
+/** Whether an options request failed because nothing lists options on the instrument. */
+export function isOptionsUnavailableError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  return /\boptions provider available for\b/i.test(message);
+}
+
+/** "Options are not available for GC=F.": the dead end itself, before any follow-up. */
+export function optionsUnavailableTitle(symbol: string): string {
+  return `Options are not available for ${symbol.trim().toUpperCase()}.`;
+}

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

@@ -1,15 +1,22 @@
-// Published full-day closures (weekend dates omitted) for Asia-Pacific venues,
+// Published full-day closures (weekend dates omitted) for Asia-Pacific venues and EGX,
 // 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)
+// BHB closes on the dates its own daily closes skip in 2026, which match the holidays it lists
+//   (some moved, as its list warns), and on National Day, 16 and 17 Dec. Its week is Sunday to Thursday.
 // 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
+// MSX closes on the holidays its site lists (msx.om exchange holidays, read 10 Oct 2026).
+//   Its week is Sunday to Thursday.
 // ASX: https://www.asx.com.au/markets/market-resources/trading-hours-calendar/cash-market-trading-hours/trading-calendar
+// EGX closes on Egypt's public holidays, often moved to the Thursday of their
+// week (Armed Forces Day, Tuesday 6 Oct 2026, to Thursday 8 Oct, by the
+// exchange's statement of 5 Oct). Its week is Sunday to Thursday.
 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",
@@ -34,6 +41,12 @@ export const PUBLISHED_APAC_CLOSURES: Readonly<Record<string, Record<number, rea
   KOSDAQ: KRX_CLOSURES,
   TWSE: TWSE_CLOSURES,
   TPEX: TWSE_CLOSURES,
+  BHB: {
+    2026: [
+      "01-01", "03-22", "03-23", "03-24", "05-03", "05-26", "05-27", "05-28", "05-31", "06-16", "06-25", "06-28",
+      "08-25", "12-16", "12-17",
+    ],
+  },
   HKEX: {
     2026: [
       "01-01", "02-17", "02-18", "02-19", "04-03", "04-06", "04-07", "05-01", "05-25",
@@ -48,10 +61,19 @@ export const PUBLISHED_APAC_CLOSURES: Readonly<Record<string, Record<number, rea
     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"],
   },
+  MSX: {
+    2026: ["01-15", "01-18", "03-19", "03-22", "03-23", "05-26", "05-27", "05-28", "06-18", "08-27", "11-25", "11-26"],
+  },
   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"],
   },
+  EGX: {
+    2026: [
+      "01-01", "01-07", "01-29", "03-19", "03-22", "03-23", "04-12", "04-13", "05-07",
+      "05-26", "05-27", "05-28", "05-31", "06-18", "07-02", "07-23", "08-27", "10-08",
+    ],
+  },
 };
 
 /** True only for a published full-day closure; unpublished years are unknown, not open. */