gloomberb 0.16.3 → 0.16.4

package/src/layout/pane-manager/hidden-panes.ts

@@ -0,0 +1,160 @@
+import type { DockLayoutNode, DockSplitNode, LayoutConfig, PaneInstanceConfig } from "../../types/config";
+import { collectDockLeafRefs, getDockedInstanceIds, getNodeAtPath, replaceNodeAtPath } from "./dock-tree";
+
+/**
+ * A hidden part of the saved dock tree: the largest subtree with no pane on
+ * screen, and where it sat beside the panes that are.
+ */
+interface HiddenDockBranch {
+  node: DockLayoutNode;
+  axis: DockSplitNode["axis"];
+  ratio: number;
+  /** Which child of its split it was. */
+  side: 0 | 1;
+  /** The shown panes on the other side of that split. */
+  besideIds: ReadonlySet<string>;
+  depth: number;
+}
+
+function isAllHidden(node: DockLayoutNode, hidden: ReadonlySet<string>): boolean {
+  return getDockedInstanceIds(node).every((instanceId) => hidden.has(instanceId));
+}
+
+function collectHiddenBranches(
+  node: DockLayoutNode,
+  hidden: ReadonlySet<string>,
+  depth: number,
+  out: HiddenDockBranch[],
+): void {
+  if (node.kind !== "split") return;
+  const children = [node.first, node.second] as const;
+  children.forEach((child, index) => {
+    const side = index as 0 | 1;
+    if (!isAllHidden(child, hidden)) {
+      collectHiddenBranches(child, hidden, depth + 1, out);
+      return;
+    }
+    const sibling = children[1 - side]!;
+    out.push({
+      node: child,
+      axis: node.axis,
+      ratio: node.ratio,
+      side,
+      besideIds: new Set(getDockedInstanceIds(sibling).filter((instanceId) => !hidden.has(instanceId))),
+      depth,
+    });
+  });
+}
+
+function commonPathPrefix(paths: ReadonlyArray<ReadonlyArray<0 | 1>>): Array<0 | 1> {
+  const [first, ...rest] = paths;
+  if (!first) return [];
+  let length = first.length;
+  for (const path of rest) {
+    let index = 0;
+    while (index < length && index < path.length && path[index] === first[index]) index += 1;
+    length = index;
+  }
+  return first.slice(0, length);
+}
+
+/**
+ * Puts a hidden branch back beside the smallest subtree that holds the panes
+ * it sat beside, or beside everything when those are gone. Branches put back
+ * first sat deeper, so the target grows over them to keep the old nesting.
+ */
+function reattachBranch(
+  root: DockLayoutNode | null,
+  branch: HiddenDockBranch,
+  hidden: ReadonlySet<string>,
+): DockLayoutNode {
+  if (!root) return branch.node;
+  const beside = collectDockLeafRefs(root).filter((leaf) => branch.besideIds.has(leaf.instanceId));
+  let path = beside.length > 0 ? commonPathPrefix(beside.map((leaf) => leaf.path)) : [];
+  while (path.length > 0) {
+    const parent = getNodeAtPath(root, path.slice(0, -1));
+    if (parent?.kind !== "split") break;
+    const sibling = path[path.length - 1] === 0 ? parent.second : parent.first;
+    if (!isAllHidden(sibling, hidden)) break;
+    path = path.slice(0, -1);
+  }
+  const target = getNodeAtPath(root, path) ?? root;
+  const split: DockSplitNode = {
+    kind: "split",
+    axis: branch.axis,
+    ratio: branch.ratio,
+    first: branch.side === 0 ? branch.node : target,
+    second: branch.side === 0 ? target : branch.node,
+  };
+  return replaceNodeAtPath(root, path, split);
+}
+
+function restoreHiddenDockTree(
+  saved: DockLayoutNode | null,
+  edited: DockLayoutNode | null,
+  hidden: ReadonlySet<string>,
+): DockLayoutNode | null {
+  if (!saved || !getDockedInstanceIds(saved).some((instanceId) => hidden.has(instanceId))) return edited;
+  if (isAllHidden(saved, hidden)) {
+    return edited ? { kind: "split", axis: "horizontal", ratio: 0.5, first: saved, second: edited } : saved;
+  }
+  const branches: HiddenDockBranch[] = [];
+  collectHiddenBranches(saved, hidden, 0, branches);
+  branches.sort((a, b) => b.depth - a.depth);
+  let root = edited;
+  for (const branch of branches) root = reattachBranch(root, branch, hidden);
+  return root;
+}
+
+/**
+ * The edited list with each hidden entry back after the entry it followed in
+ * the saved one, so the order of what is on screen stays the edit's.
+ */
+function restoreHiddenEntries<T extends { instanceId: string }>(
+  saved: readonly T[],
+  edited: readonly T[],
+  hidden: ReadonlySet<string>,
+): T[] {
+  if (!saved.some((entry) => hidden.has(entry.instanceId))) return [...edited];
+  const result = [...edited];
+  let previousId: string | null = null;
+  for (const entry of saved) {
+    if (hidden.has(entry.instanceId)) {
+      const index = previousId === null ? -1 : result.findIndex((candidate) => candidate.instanceId === previousId);
+      result.splice(index + 1, 0, entry);
+      previousId = entry.instanceId;
+    } else if (result.some((candidate) => candidate.instanceId === entry.instanceId)) {
+      previousId = entry.instanceId;
+    }
+  }
+  return result;
+}
+
+/**
+ * Panes whose plugin is off, or whose pane type nothing registered, stay in
+ * the saved layout while the shell leaves them off screen. The shell edits
+ * the layout it shows, so before an edit is saved this puts every hidden pane
+ * back from `saved`: its instance and state, its floating or popped-out frame,
+ * and its docked branch beside the panes it sat next to. A hidden pane the
+ * edit itself kept is left as the edit has it.
+ *
+ * With nothing edited, `restoreHiddenPanes(saved, shown)` is `saved` again.
+ */
+export function restoreHiddenPanes(
+  saved: LayoutConfig,
+  edited: LayoutConfig,
+  isHidden: (instance: PaneInstanceConfig) => boolean,
+): LayoutConfig {
+  const editedIds = new Set(edited.instances.map((instance) => instance.instanceId));
+  const hidden = new Set(saved.instances
+    .filter((instance) => !editedIds.has(instance.instanceId) && isHidden(instance))
+    .map((instance) => instance.instanceId));
+  if (hidden.size === 0) return edited;
+  return {
+    ...edited,
+    dockRoot: restoreHiddenDockTree(saved.dockRoot, edited.dockRoot, hidden),
+    instances: restoreHiddenEntries(saved.instances, edited.instances, hidden),
+    floating: restoreHiddenEntries(saved.floating, edited.floating, hidden),
+    detached: restoreHiddenEntries(saved.detached ?? [], edited.detached ?? [], hidden),
+  };
+}

package/src/layout/pane-manager/index.ts

@@ -49,6 +49,7 @@ export {
   swapPanes,
 } from "./docking";
 
+export { restoreHiddenPanes } from "./hidden-panes";
 export {
   removeFloatingPanes,
   removePane,

package/src/market-data/coordinator/entries.ts

@@ -140,7 +140,7 @@ export function readyQuoteEntry(
   quote: Quote,
   source: string,
   attempts: ProviderAttempt[],
-  options: { keepNewerHeldQuote?: boolean } = {},
+  options: { keepNewerHeldQuote?: boolean; acceptLastKnown?: boolean } = {},
 ): QueryEntry<Quote> {
   const held = options.keepNewerHeldQuote ? heldQuoteSupersedes(current, quote) : null;
   if (held) {
@@ -148,6 +148,12 @@ export function readyQuoteEntry(
   }
   if (isQuoteStaleForCurrentSession(quote)) {
     const keepFreshQuote = hasFreshQuoteForCurrentSession([current.data, current.lastGoodData]);
+    // A request answers with a stale quote only when no source has a current
+    // one (`acceptLastKnown`). With nothing current held, that last known
+    // price, flagged stale, beats no price. Stream ticks never bring one in.
+    if (options.acceptLastKnown && !keepFreshQuote) {
+      return readyEntry(current, { ...quote, stale: true }, source, attempts, { keepLastGoodOnEmpty: true });
+    }
     return readyEntry(current, null, current.source ?? source, attempts, { keepLastGoodOnEmpty: keepFreshQuote });
   }
   return readyEntry(current, quote, source, attempts, { keepLastGoodOnEmpty: true });

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

@@ -111,7 +111,7 @@ export async function loadQuoteEntry({
       const resolvedQuote = resolveQuote?.(instrument, quote) ?? quote;
       const source = resolvedQuote.providerId ?? dataProvider.id;
       const attempts = [createAttempt(source, startedAt, "success")];
-      return quoteStore.update(key, (current) => readyQuoteEntry(current, resolvedQuote, source, attempts, { keepNewerHeldQuote: true }));
+      return quoteStore.update(key, (current) => readyQuoteEntry(current, resolvedQuote, source, attempts, { keepNewerHeldQuote: true, acceptLastKnown: true }));
     } catch (error) {
       return storeQuoteFailure(quoteStore, key, dataProvider.id, startedAt, error);
     }
@@ -182,7 +182,7 @@ export async function loadQuoteBatchEntries({
       const quote = resolveQuote?.(instrument, item.quote) ?? item.quote;
       const source = quote.providerId ?? dataProvider.id;
       const attempts = [createAttempt(source, Date.now(), "success")];
-      results.set(key, quoteStore.update(key, (current) => readyQuoteEntry(current, quote, source, attempts, { keepNewerHeldQuote: true })));
+      results.set(key, quoteStore.update(key, (current) => readyQuoteEntry(current, quote, source, attempts, { keepNewerHeldQuote: true, acceptLastKnown: true })));
     });
   }
 

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,11 @@ 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,
+  DFM: 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 +84,37 @@ 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,
+  // 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,
+};
+// Venues whose week is not Monday to Friday, as their days off (0 is Sunday).
+// Tadawul and Qatar 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],
+  QE: [5, 6],
+};
+const DEFAULT_WEEKEND_DAYS: readonly number[] = [0, 6];
+// 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,12 +229,17 @@ function isPublishedClosure(exchange: string, date: string): boolean {
   return getPublishedUsEquityCalendarDay(exchange, date) === "closed";
 }
 
+/** Whether `weekday` (0 is Sunday) is in the venue's trading week. */
+function isTradingWeekday(exchange: string, weekday: number): boolean {
+  return !(WEEKEND_DAYS[exchange] ?? DEFAULT_WEEKEND_DAYS).includes(weekday);
+}
+
 function isLocalTradingDay(exchange: string, date: string): boolean {
   const weekday = localWeekday(date);
-  return weekday != null && weekday !== 0 && weekday !== 6 && !isPublishedClosure(exchange, date);
+  return weekday != null && isTradingWeekday(exchange, weekday) && !isPublishedClosure(exchange, date);
 }
 
-/** Weekdays in (earlier, later], less published closures for venues with a calendar. */
+/** 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): number {
   const earlierDay = isoLocalDateToUtcDay(earlierDate);
   const laterDay = isoLocalDateToUtcDay(laterDate);
@@ -212,6 +257,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,9 +272,9 @@ 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,
@@ -241,7 +292,7 @@ export function latestRegularSessionClose(
     if (published) {
       if (published.kind === "session") close = published.close;
     } else if (isLocalTradingDay(canonical, date)) {
-      const minutes = REGULAR_CLOSE_MINUTES[canonical] ?? 24 * 60;
+      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,8 +318,8 @@ 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 {
   const canonical = canonicalExchange(exchange);
@@ -294,6 +345,40 @@ 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.
@@ -309,7 +394,7 @@ export function isRegularSessionTime(exchange: string | undefined, time: number)
 /**
  * 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 and ASX. Elsewhere a local holiday reads as a trading day.
  */
 export function hasPublishedSessionCalendar(exchange: string | undefined, date: string): boolean {
   const canonical = canonicalExchange(exchange);
@@ -345,7 +430,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 +528,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(

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

@@ -24,6 +24,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;
 }
@@ -278,11 +281,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.

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/quotes/contributions.ts

@@ -1,11 +1,14 @@
 import { resolvePriceBasis } from "../market/price-basis";
+import { isAlwaysOpenExchange } from "../market/freshness";
 import type {
+  MarketState,
   Quote,
   QuoteContribution,
   QuoteContributionMap,
   SessionConfidence,
   TickerFinancials,
 } from "../../types/financials";
+import { classifyInstrumentType } from "../../tickers/instrument-kind";
 import { quoteTradingDay, reconcileQuoteDayRange } from "./day-range";
 
 const RETAINED_DESCRIPTIVE_FIELDS = ["high52w", "low52w", "marketCap", "name", "instrumentType"] as const;
@@ -48,6 +51,17 @@ function inferSessionConfidence(
   return "unknown";
 }
 
+/**
+ * A CCC coin trades through the equity close. The live tape often leaves the
+ * session off, and a copied equity close would paint the coin shut.
+ */
+function alwaysOpenSession(quote: Pick<Quote, "listingExchangeName" | "exchangeName" | "instrumentType" | "marketState">): { marketState: MarketState; sessionConfidence: SessionConfidence } | null {
+  const open = isAlwaysOpenExchange(quote.listingExchangeName ?? quote.exchangeName)
+    || classifyInstrumentType(quote.instrumentType) === "crypto";
+  if (!open || quote.marketState === "REGULAR") return null;
+  return { marketState: "REGULAR", sessionConfidence: "derived" };
+}
+
 function normalizeListingExchange(
   quote: Quote | QuoteContribution,
   providerId: string,
@@ -128,6 +142,8 @@ export function normalizeQuoteContribution(
   const { listingExchangeName, listingExchangeFullName } = normalizeListingExchange(quote, providerId);
   const routingExchangeName = quote.routingExchangeName;
   const routingExchangeFullName = quote.routingExchangeFullName ?? routingExchangeName;
+  const exchangeName = listingExchangeName ?? quote.exchangeName;
+  const session = alwaysOpenSession({ ...quote, listingExchangeName, exchangeName });
 
   return finalizeSessionFields(reconcileQuoteDayRange({
     ...quote,
@@ -136,9 +152,10 @@ export function normalizeQuoteContribution(
     listingExchangeFullName,
     routingExchangeName,
     routingExchangeFullName,
-    exchangeName: listingExchangeName ?? quote.exchangeName,
+    exchangeName,
     fullExchangeName: listingExchangeFullName ?? quote.fullExchangeName,
-    sessionConfidence: inferSessionConfidence(quote, providerId),
+    ...session,
+    sessionConfidence: session?.sessionConfidence ?? inferSessionConfidence(quote, providerId),
   }));
 }
 

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

@@ -38,6 +38,18 @@ function metadataExchange(value?: string): string {
   return exchange === "NY MERCANTILE" ? "NYMEX" : exchange;
 }
 
+/**
+ * The pair an FX symbol names, base then quote: EURUSD for EUR/USD and
+ * EURUSD=X, USDJPY for USD/JPY, USDJPY=X and JPY=X, the dollar pair's short
+ * spelling.
+ */
+function currencyPairCode(symbol: string): string | null {
+  const pair = /^([A-Z]{3})\/([A-Z]{3})$/.exec(symbol) ?? /^([A-Z]{3})([A-Z]{3})=X$/.exec(symbol);
+  if (pair) return `${pair[1]}${pair[2]}`;
+  const dollarPair = /^([A-Z]{3})=X$/.exec(symbol);
+  return dollarPair ? `USD${dollarPair[1]}` : null;
+}
+
 /** Qualified listings must agree; provider suffix spellings use the existing exact-listing normalizer. */
 export function quoteMetadataMatchesTarget(metadata: QuoteMetadata, symbol: string, exchange?: string): boolean {
   const target = parsePublicTickerKey(symbol);
@@ -48,6 +60,10 @@ export function quoteMetadataMatchesTarget(metadata: QuoteMetadata, symbol: stri
   if (symbolExchange && actualExchange && symbolExchange !== actualExchange) return false;
   if (requestedExchange && actualExchange !== requestedExchange) return false;
   if (target.symbol === actual.symbol) return true;
+  // Gloom Cloud answers a currency pair in one spelling however it was asked
+  // for: EUR/USD comes back as EURUSD=X on its currency venue.
+  const pair = actualExchange === "CCY" ? currencyPairCode(actual.symbol) : null;
+  if (pair && pair === currencyPairCode(target.symbol)) return true;
   const listing = requestedExchange || actualExchange;
   if (!listing) return false;
   const candidates = getListingSymbolsToTry(target.symbol, listing, { exactExchange: true });