gloomberb 0.18.4 → 0.18.5

package/src/cli/commands/ticker.ts

@@ -1494,7 +1494,8 @@ export async function ticker(symbol: string, dependencies: TickerCommandDependen
 
     let financials: TickerFinancials | null = null;
     try {
-      financials = await dataProvider.getTickerFinancials(requestSymbol, exchange);
+      // The Change line says what the move is from.
+      financials = await dataProvider.getTickerFinancials(requestSymbol, exchange, { datesChangeBasis: true });
     } catch (error) {
       // A known exchange the symbol is not listed on: say where it is.
       await failIfNotTraded(listing, { store, dataProvider }, { fail: failCommand });

package/src/cli/errors.ts

@@ -9,9 +9,9 @@ import { DATA_SERVICE_UNREACHABLE_MESSAGE, isNetworkFailure } from "../utils/net
 
 const USAGE_PREFIX = "Usage: ";
 /** The code of every error a command fails with: bad input, nothing found, an option it does not take. */
-const CLI_ERROR_CODE = "cli_error";
+export const CLI_ERROR_CODE = "cli_error";
 /** The code of a command whose requests never reached the data service. */
-const SERVICE_UNREACHABLE_CODE = "service_unreachable";
+export const SERVICE_UNREACHABLE_CODE = "service_unreachable";
 
 /** What to check when nothing answered: the connection, and the proxy when one is set. */
 function unreachableHint(): string {

package/src/cli/export-source.ts

@@ -3,7 +3,8 @@
  * writes CSV or JSON, so an export can go in an audit file as it is: CSV ends
  * with `#` lines and JSON carries a `source` object with the same fields.
  * CSV and NDJSON rows also end with five fixed columns naming what each row
- * is (`EXPORT_IDENTITY_COLUMNS`), less any the table already has by name.
+ * is (`EXPORT_IDENTITY_COLUMNS`), less any the table already has by name; a
+ * dated export adds `period`, `released` and `retrieved` after them.
  */
 import { formatFreshnessLine, type ReportFreshness } from "./pane-functions/freshness";
 import { parseReportTime } from "../utils/utc-time";
@@ -54,6 +55,14 @@ export function exportSource(freshness: ReportFreshness): ExportSource {
  */
 export const EXPORT_IDENTITY_COLUMNS = ["symbol_or_series", "currency_or_unit", "interval", "source", "as_of"] as const;
 
+/**
+ * The columns a dated export (`econ`, `fred`, `fn ECST`) ends with after the
+ * five: the period a figure covers, when it was released, and when this export
+ * retrieved it. `as_of` is then the release, and these three say the rest, so a
+ * row never has to be read against the closing lines to be dated.
+ */
+export const EXPORT_DATING_COLUMNS = ["period", "released", "retrieved"] as const;
+
 /** What a command knows about the rows it exports; source and as-of come from its freshness. */
 export interface ExportIdentity {
   /** The symbol or series ID asked for: `USDZAR=X`, `SAN:EPA`, `DEXSFUS`. */
@@ -68,6 +77,10 @@ export interface ExportIdentity {
    * blank; absent, it is the closing lines' observation date.
    */
   asOf?: string | null;
+  /** In a dated export: the period the figure covers, as its publisher names it (`Sep 2026`, `2026-09-01`). */
+  period?: string | null;
+  /** In a dated export: when the figure was released, an ISO date or instant; null when the data does not say. */
+  released?: string | null;
 }
 
 /** A row's own as-of in the closing lines' form: a date stays a date, an instant is ISO in UTC. */
@@ -94,6 +107,21 @@ export function exportIdentityCells(freshness: ReportFreshness, identity: Export
   ];
 }
 
+/**
+ * The cells of `EXPORT_DATING_COLUMNS` for a row: its period and release as
+ * the data states them, blank when it does not, and the time this export
+ * retrieved the data.
+ */
+export function exportDatingCells(freshness: ReportFreshness, identity: ExportIdentity = {}): string[] {
+  return [identity.period?.trim() ?? "", rowAsOf(identity.released ?? null), exportSource(freshness).retrievalTime];
+}
+
+/** The three dating fields of an NDJSON row, null where blank. */
+export function exportDatingFields(freshness: ReportFreshness, identity: ExportIdentity = {}): Record<string, string | null> {
+  const cells = exportDatingCells(freshness, identity);
+  return Object.fromEntries(EXPORT_DATING_COLUMNS.map((column, index) => [column, cells[index] || null]));
+}
+
 /** The same five as fields of an NDJSON row, null where blank. */
 export function exportIdentityFields(freshness: ReportFreshness, identity: ExportIdentity = {}): Record<string, string | null> {
   const cells = exportIdentityCells(freshness, identity);

package/src/cli/glossary.ts

@@ -778,6 +778,42 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
     definition: "Cboe's index of the 30-day volatility that VIX options price: the VIX of the VIX. A high reading means traders are paying up "
       + "to protect against sudden jumps in VIX itself.",
   },
+  // Options positioning (OPX, GEX) and the volatility surface (OVDV).
+  {
+    term: "Max pain", aliases: ["max-pain", "maximum pain", "max pain strike", "pain strike"], functions: ["OPX", "GEX"],
+    definition: "The settlement price at which one expiry's options would pay their holders the least, summed over every call's and put's open interest: "
+      + "the strike where Payout $ is lowest. It says where option holders collect least at expiry, not where the price will go. "
+      + "Deribit's BTC and ETH options settle at 08:00 UTC on the day named, against its index averaged over the 30 minutes before.",
+  },
+  {
+    term: "Payout $", aliases: ["payout", "expiry payout", "option payout", "payout at expiry"], functions: ["OPX", "GEX"], shown: ["Payout $"],
+    definition: "What an expiry's options would pay their holders, in dollars, if the underlying settled at that strike: each call's open interest times "
+      + "how far the strike is above the call's, plus each put's times how far it is below, times the contract size (100 shares for a US listing, "
+      + "1 BTC or 1 ETH on Deribit). Max pain is the strike where it is lowest.",
+  },
+  {
+    term: "Call wall", aliases: ["put wall", "walls", "gamma wall", "gamma walls"], functions: ["OPX", "GEX"], shown: ["Call wall", "Put wall"],
+    definition: "The strike with the most dealer gamma from calls (call wall) or from puts (put wall), across every expiry or within one. "
+      + "Hedging flows are largest there, so it is often read as resistance above spot and support below it.",
+  },
+  {
+    term: "Risk reversal", short: "RR", aliases: ["25d risk reversal", "25-delta risk reversal", "25 delta risk reversal", "rr25", "risk reversals"],
+    functions: ["OVDV"], shown: ["RR"],
+    definition: "The 25-delta call's implied volatility minus the 25-delta put's, in vol points, for one expiry. Negative means puts cost more than calls "
+      + "as far from the forward (downside protection is bid), positive that upside calls are. OVDV signs it call minus put.",
+  },
+  {
+    term: "Butterfly", short: "BF", aliases: ["25d butterfly", "25-delta butterfly", "25 delta butterfly", "bf25", "smile curvature", "fly"],
+    functions: ["OVDV"], shown: ["BF"],
+    definition: "The average of the 25-delta call and put implied volatilities minus the implied volatility at the forward, in vol points, for one expiry: "
+      + "how much the wings cost over the middle of the smile. A higher butterfly prices larger moves in either direction.",
+  },
+  {
+    term: "DVOL", aliases: ["deribit volatility index", "bitcoin volatility index", "ether volatility index", "btc dvol", "eth dvol", "crypto vix"],
+    functions: ["OVDV", "G"], shown: ["DVOL"],
+    definition: "Deribit's volatility index for BTC or ETH: the 30-day implied volatility its options price, in vol points, computed from the whole "
+      + "strip of strikes as VIX is. OVDV shows it beside the coin's surface; chart it as CAP:volatility:dvol-btc or CAP:volatility:dvol-eth.",
+  },
   // The economic calendar (ECO).
   {
     term: "Actual", aliases: ["actual release", "actual value"], functions: ["ECO"], shown: ["ACTUAL", "Actual"],
@@ -795,6 +831,19 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
     term: "Impact", short: "IMP", aliases: ["importance", "event impact", "high impact"], functions: ["ECO"],
     definition: "How much a release usually moves markets: HIGH for the big ones (CPI, jobs, rate decisions), MED and LOW for speeches and smaller data.",
   },
+  {
+    term: "Purchasing managers' index", short: "PMI", aliases: ["pmis", "purchasing managers", "purchasing managers index", "ism", "ism pmi",
+      "flash pmi", "caixin pmi", "ratingdog pmi"], functions: ["ECO"],
+    definition: "A monthly survey of companies' purchasing managers on orders, output, jobs and prices: 50 is no change from the month before, "
+      + "above it growth, below it contraction. A flash PMI is the month's early read, the final a week or so later. ECO lists each as a release: "
+      + "ISM for the US, S&P Global's elsewhere, NBS and RatingDog (formerly Caixin) for China, most at medium or low impact.",
+  },
+  // Economic statistics (ECST).
+  {
+    term: "Nowcast", aliases: ["nowcasts", "nowcasting", "gdpnow", "gdp nowcast"], functions: ["ECST", "ECO"], shown: ["GDPNow"],
+    definition: "An estimate of this quarter's GDP growth from the data already out, revised as each release lands until the official figure. "
+      + "ECST shows the Atlanta Fed's GDPNow, annualized, against its own history; ECO lists each update as a release.",
+  },
 ];
 
 const ANSI = /\x1b\[[0-9;]*m/g;

package/src/cli/history-rows.ts

@@ -19,6 +19,8 @@ import { formatUtcTime } from "../utils/utc-time";
 import { historyCoverageNotice } from "../sources/history-coverage";
 import { barLastSession, barPeriodToDate, type BarPeriodToDate } from "../market-data/market/bar-period";
 import { barSizeFromGap, medianBarGap } from "../time-series/bar-spacing";
+import { isRegularSessionTime, sessionCalendarTimeZone } from "../market-data/market/freshness";
+import { zonedDateKey } from "../utils/zoned-date-time";
 
 const PRICE_KEYS = ["open", "high", "low", "close"] as const;
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -332,18 +334,35 @@ function listDates(dates: readonly string[]): string {
   return items.length > 1 ? `${items.slice(0, -1).join(", ")} and ${items.at(-1)}` : items[0] ?? "";
 }
 
+/** The venue's day in session at `now`: null when it is not trading, undefined when its hours are not known. */
+export function venueTradingDay(venue: string | undefined, now: number): string | null | undefined {
+  const zone = venue ? sessionCalendarTimeZone(venue) : null;
+  const trading = zone ? isRegularSessionTime(venue, now) : null;
+  if (!zone || trading === null) return undefined;
+  return trading ? zonedDateKey(now, zone) : null;
+}
+
 /**
  * What the partial, filled and unsettled bars are: "2026-10-12 is still
- * forming (partial), with no volume until the day closes", the bars rebuilt
- * from hourly bars, a future's closed session that "closes on its last trade
- * until its settlement is confirmed (unsettled)", and the latest trade an
- * intraday history ends with when it has no volume (latestTradeIndex). Null
- * when no bar is any of them.
+ * forming (partial), with no volume until the day closes", a day whose
+ * session has closed that "closes on the session's last price until the
+ * day's bar is final (partial)", the bars rebuilt from hourly bars, a
+ * future's closed session that "closes on its last trade until its
+ * settlement is confirmed (unsettled)", and the latest trade an intraday
+ * history ends with when it has no volume (latestTradeIndex). Null when no
+ * bar is any of them. `tradingDay`: the venue's day in session now, null
+ * when none is; left out when the venue's hours are not known, every
+ * partial bar is then still forming.
  */
 export function historyBarStatusNote(
-  rows: readonly Pick<HistoryRow, "date" | "partial" | "filled" | "unsettled" | "volume">[],
+  rows: readonly Pick<HistoryRow, "date" | "partial" | "filled" | "unsettled" | "volume" | "interval">[],
+  options: { tradingDay?: string | null } = {},
 ): string | null {
-  const partial = rows.filter((row) => row.partial);
+  // A day's bar the data service still marks partial once its session has closed: its own daily bar is not in yet.
+  const closed = (row: (typeof rows)[number]) =>
+    options.tradingDay !== undefined && row.interval === "1d" && row.date.slice(0, 10) !== options.tradingDay;
+  const partial = rows.filter((row) => row.partial && !closed(row));
+  const settling = rows.filter((row) => row.partial && closed(row));
   const latest = rows[latestTradeIndex(rows.map((row) => Date.parse(row.date)))];
   const filled = rows.filter((row) => row.filled);
   const unsettled = rows.filter((row) => row.unsettled);
@@ -352,6 +371,10 @@ export function historyBarStatusNote(
       ? `${listDates(partial.map((row) => row.date))} ${partial.length === 1 ? "is" : "are"} still forming (partial)`
         + (partial.every((row) => row.volume == null) ? ", with no volume until the day closes" : "")
       : null,
+    settling.length > 0
+      ? `${listDates(settling.map((row) => row.date))} ${settling.length === 1 ? "closes" : "close"} on the session's last price`
+        + ` until the day's bar is final (partial)` + (settling.every((row) => row.volume == null) ? ", with no volume until then" : "")
+      : null,
     filled.length > 0
       ? `${listDates(filled.map((row) => row.date))} ${filled.length === 1 ? "was" : "were"} rebuilt from hourly bars (filled)`
         + (filled.every((row) => row.volume == null) ? ", without volume" : "")

package/src/cli/known-gaps.ts

@@ -1,5 +1,6 @@
 import { listingSuffixExchange } from "../sources/listing-symbols";
 import { kindFromListingSyntax } from "../tickers/instrument-kind";
+import { macroReleaseTopic } from "../plugins/builtin/shared/macro-releases";
 import { parsePublicTickerKey } from "../utils/exchanges";
 import { listingAbroadVenue } from "../utils/sec";
 import { nimCommand } from "./bank-section";
@@ -387,7 +388,8 @@ export function knownGapForTicker(symbol: string): string | null {
 
 /**
  * The line for a query that names a known subject as a whole ("carbon allowances", "EUA"), a Treasury yield
- * typed as a ticker (US10Y), or a topic with no function ("defense budget"), else null.
+ * typed as a ticker (US10Y), a topic with no function ("defense budget"), or a macro release no series carries
+ * ("ISM manufacturing", "GDPNow"), else null.
  */
 export function knownGapMessage(query: string): string | null {
   const key = lookupKey(query);
@@ -395,5 +397,6 @@ export function knownGapMessage(query: string): string | null {
   const tenor = treasuryYieldTenor(query);
   return KNOWN_GAPS.find((gap) => gap.terms.some((term) => lookupKey(term) === key))?.message
     ?? (tenor ? treasuryYieldLine(tenor) : null)
-    ?? topicPointer(query)?.message ?? null;
+    ?? topicPointer(query)?.message
+    ?? macroReleaseTopic(query)?.line ?? null;
 }

package/src/cli/listing-arg.ts

@@ -9,6 +9,7 @@ import {
   quotedOnVenue,
   readAmbiguousCurrencyPair,
   readSharedCode,
+  savedRowOfBareSymbol,
   type ListingDeps,
   type ListingStore,
   type ListingVenue,
@@ -55,6 +56,7 @@ import {
   type TerminalListingCode,
 } from "../tickers/terminal-codes";
 import { listingAbroadVenue } from "../utils/sec";
+import { savedAbroadForBareSymbol, savedUsListingOf } from "../tickers/search/bare-symbol";
 import { listingSuffixCandidate, listingSuffixVenue, tickerHasListingSuffix } from "../sources/listing-symbols";
 import { notTheCoinNote } from "./commands/crypto-hints";
 
@@ -621,15 +623,18 @@ async function quoteListings(
   dataProvider: DataProvider,
   listings: readonly CliListing[],
   refresh: boolean,
+  datesChangeBasis = false,
 ): Promise<Array<Quote | null>> {
   if (listings.length === 0) return [];
   const targets = listings.map((listing) => listing.request);
   if (dataProvider.getQuotesBatch) {
-    const results = await dataProvider.getQuotesBatch(targets, { forceRefresh: refresh }).catch(logFailure("cli.listing-arg", "Read listing quote batch failed", []));
+    const results = await dataProvider.getQuotesBatch(targets, { forceRefresh: refresh, ...(datesChangeBasis ? { datesChangeBasis } : {}) })
+      .catch(logFailure("cli.listing-arg", "Read listing quote batch failed", []));
     return targets.map((target, index) => (results.find((result) => result.target === target) ?? results[index])?.quote ?? null);
   }
   return Promise.all(targets.map((target) => dataProvider.getQuote(target.symbol, target.exchange, {
     cacheMode: refresh ? "refresh" : "default",
+    ...(datesChangeBasis ? { datesChangeBasis } : {}),
   }).catch(logFailure("cli.listing-arg", "Read listing quote failed", null))));
 }
 
@@ -661,7 +666,7 @@ export async function quoteBareListing(
   listing: CliListing,
   deps: ListingDeps,
   request: ListingDataRequest,
-  { refresh = false }: { refresh?: boolean } = {},
+  { refresh = false, datesChangeBasis = false }: { refresh?: boolean; datesChangeBasis?: boolean } = {},
 ): Promise<BareListingQuote | null> {
   const venues = await bareListingVenues(listing, deps);
   if (!venues) return null;
@@ -672,10 +677,10 @@ export async function quoteBareListing(
   const first = [namedListing(listing, venues.exchange)];
   const rest = venues.others.map((venue) => namedListing(listing, venue.exchange));
   let tried = first;
-  let quotes = await quoteListings(deps.dataProvider, first, refresh);
+  let quotes = await quoteListings(deps.dataProvider, first, refresh, datesChangeBasis);
   if (!quotes[0] && rest.length > 0) {
     tried = [...first, ...rest];
-    quotes = [...quotes, ...await quoteListings(deps.dataProvider, rest, refresh)];
+    quotes = [...quotes, ...await quoteListings(deps.dataProvider, rest, refresh, datesChangeBasis)];
   }
   const found = quotes.findIndex(Boolean);
   if (found < 0) {
@@ -948,6 +953,10 @@ export async function loadSavedListingOf(
   for (const listing of listings) {
     if (found.some((entry) => entry.listing.key === listing.key)) continue;
     const ticker = await loadSavedListing(store, listing);
+    // A bare symbol's US listing comes before a row abroad saved under its bare key (SHEL, saved from SHEL.L).
+    if (ticker && !listing.exchange && savedAbroadForBareSymbol(listing.symbol, ticker)) {
+      add(listing, savedUsListingOf(listing.symbol, await store.loadAllTickers()));
+    }
     add(listing, ticker);
     // A suffixed key as typed may be saved with a venue (7203.T:JPX, GARAN.IS:XNYS): any row of that symbol.
     if (!ticker && !listing.exchange && tickerHasListingSuffix(listing.symbol)) {
@@ -1115,7 +1124,9 @@ export async function resolveCliListing(
     parsed = market;
   }
   let listing = await settleSharedCode(parsed, deps);
-  const saved = await loadSavedListing(deps.store, listing) ?? (typedKey ? await loadSuffixedRow(deps.store, typedKey, listing.exchange) : null);
+  const found = await loadSavedListing(deps.store, listing) ?? (typedKey ? await loadSuffixedRow(deps.store, typedKey, listing.exchange) : null);
+  // A bare symbol is its US listing when it has one, whatever row abroad holds the bare key (SHEL saved from SHEL.L).
+  const saved = listing.exchange ? found : await savedRowOfBareSymbol(listing.symbol, found, deps);
   // A code nothing could read stays the venue it is saved on.
   const savedExchange = canonicalExchange(saved?.metadata.exchange);
   if (listing.sharedCode && savedExchange) listing = { symbol: listing.symbol, exchange: savedExchange, key: `${listing.symbol}:${savedExchange}` };

package/src/cli/pane-functions/freshness.ts

@@ -100,8 +100,8 @@ export interface ReportFreshness {
    */
   sources?: ReportSourceAsOf[];
   /**
-   * Whole minutes from the oldest of `sources` (or, declared `oldestAge`, the
-   * oldest observation) to when this report was built: `oldest 9 min`.
+   * Whole minutes from the oldest of `sources` (or, declared `oldestAge` or
+   * `ageOnly`, the oldest observation) to when this report was built: `oldest 9 min`.
    */
   oldestAgeMinutes?: number;
   /** The data states no feed (`status` is `unreported`) and its line says only its time and age (`ageOnly`). */
@@ -125,16 +125,21 @@ export interface ReportFreshness {
   /**
    * Refreshing the data failed and a copy saved earlier answered: when that
    * copy was saved, an ISO instant in UTC. The status line then says
-   * `couldn't refresh; saved 21:49 UTC` in place of how current the data is.
+   * `couldn't refresh; saved copy from 21:49 UTC` in place of how current the data is.
    */
   savedAt?: string;
+  /**
+   * Nothing was served: the data service could not be reached and no saved
+   * copy answered. The line then names no time, since nothing was retrieved.
+   */
+  unreached?: true;
 }
 
 /**
  * The freshness a command prints, saying when what it shows (`shown`: its
  * rows, or the data its line is drawn from) came from a copy saved earlier
  * because refreshing it failed (`collectSavedCopies`): its status line then
- * reads `couldn't refresh; saved 21:49 UTC` instead of live or delayed.
+ * reads `couldn't refresh; saved copy from 21:49 UTC` instead of live or delayed.
  */
 export function withSavedCopy<F extends ReportFreshness | undefined>(freshness: F, shown: unknown): F {
   if (!freshness || freshness.savedAt) return freshness;
@@ -463,9 +468,11 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
   // A bar still forming covers its period through a later day than the one it is dated by.
   const periodToDate = readPeriodToDate(declared.periodToDate, now);
   const asOf = declaredAsOf ?? periodToDate?.through ?? newest([...observations.units, ...observations.extra]);
-  // The oldest source, not the newest, says how far behind the view can be.
-  const agedFrom = sources.length ? oldest(sources.map(({ time }) => time))
-    : declared.oldestAge || declared.ageOnly ? oldest(observations.units) ?? asOf : null;
+  // The oldest source, not the newest, says how far behind the view can be. A line that is dated by its age says how
+  // old its oldest observation is, even beside each source's newest: a source can stream some rows and not others.
+  const oldestSource = oldest(sources.map(({ time }) => time));
+  const agedFrom = declared.ageOnly ? oldest(observations.units) ?? oldestSource ?? asOf
+    : oldestSource ?? (declared.oldestAge ? oldest(observations.units) ?? asOf : null);
   const oldestAgeMinutes = agedFrom && !agedFrom.dateOnly ? Math.max(0, Math.floor((now - agedFrom.time) / 60_000)) : null;
   // A loader that dates its data itself also says how old the oldest part is, or nothing;
   // `oldest: null` says the rows are a history, whose first entry is not stale data.
@@ -819,7 +826,7 @@ function onRetrievalDay(iso: string, retrievedAt: string): boolean {
 
 /**
  * What a report answered from a saved copy says in place of how current its
- * data is: `couldn't refresh; saved 21:49 UTC`, with the day when the copy was
+ * data is: `couldn't refresh; saved copy from 21:49 UTC`, with the day when the copy was
  * saved on another day than the report was built.
  */
 function savedCopyText(savedAt: string, retrievedAt: string, local: boolean): string {
@@ -827,7 +834,7 @@ function savedCopyText(savedAt: string, retrievedAt: string, local: boolean): st
   if (!Number.isFinite(at)) return "couldn't refresh";
   const iso = new Date(at).toISOString();
   const time = onRetrievalDay(iso, retrievedAt) ? `${iso.slice(11, 16)} UTC${local ? localTimeSuffix(at) : ""}` : timeText(iso, local);
-  return `couldn't refresh; saved ${time}`;
+  return `couldn't refresh; saved copy from ${time}`;
 }
 
 /** `US and XETRA`, `US, XETRA and EPA`. */
@@ -913,10 +920,11 @@ function reopenText(market: ReportMarket, now: number, local: boolean): { text:
 
 /**
  * `markets closed until Mon`; `short` is the compact form a narrow capture
- * falls back to (`reopens Mon`). A time is always the regular session's open,
- * and says so (`pre-market open · regular session opens 13:30 UTC`), so it is
+ * falls back to (`reopens Mon`). A time is the regular session's open, and
+ * says so (`pre-market open · regular session opens 13:30 UTC`), so it is
  * never read as when the pre-market opens, nor a US market as closed until
- * then while its pre-market trades first.
+ * then while its pre-market trades first. A futures venue's Sunday open is no
+ * regular session's, so it reads `markets closed · reopens 22:00 UTC`.
  */
 function marketText(market: ReportMarket, now: number, short: boolean, local: boolean): string {
   const reopen = reopenText(market, now, local);
@@ -930,6 +938,8 @@ function marketText(market: ReportMarket, now: number, short: boolean, local: bo
       return short ? `pre-market · regular opens ${reopen.text}` : `pre-market open · regular session opens ${reopen.text}`;
     case "closed":
       if (!reopen) return short ? "closed" : "markets closed";
+      // A futures venue's Sunday open is its first trade of the week, which no regular session is.
+      if (reopen.time && market.firstTrade) return short ? `reopens ${reopen.text}` : `markets closed · reopens ${reopen.text}`;
       if (reopen.time) return short ? `regular opens ${reopen.text}` : `markets closed · regular session opens ${reopen.text}`;
       return short ? `reopens ${reopen.text}` : `markets closed until ${reopen.text}`;
     default: {
@@ -970,6 +980,7 @@ function statusLineParts(freshness: ReportFreshness, detail: StatusLineDetail =
   const undated = detail.date === "none";
   return [
     ...(freshness.sources?.length ? sourcesAsOfParts(freshness, freshness.sources, undated)
+      : freshness.unreached && !freshness.asOf ? []
       : [asOfText(freshness, detail.asOf === "short", local, undated)]),
     ...(freshness.schedule && detail.schedule !== "none"
       ? [typeof detail.schedule === "number" ? freshness.scheduleVariants?.[detail.schedule] ?? freshness.schedule : freshness.schedule] : []),
@@ -1174,7 +1185,8 @@ export function captureStatusLine({ report: loaded, selfDated, quoted, rendered
   }
   if (report && loaded?.declaresData) return sourced(report);
   if (quoted) return plain(quoted, "quotes");
-  if (report && (report.status !== "unreported" || report.ageOnly)) return sourced(report);
+  // A report that names no feed but dates its data by a session's close says so too: a board's figures outside the session.
+  if (report && (report.status !== "unreported" || report.ageOnly || report.asOfClose)) return sourced(report);
   return plain(rendered(), null);
 }
 

package/src/cli/pane-functions/function-help.ts

@@ -734,10 +734,10 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     bloomberg: ["IMAP"],
   },
   MEMB: {
-    summary: "ETF holdings with weights, shares, member returns, daily contributions and index changes. SPX and SPY use IVV holdings.",
-    usage: ["MEMB", "MEMB SPY", "MEMB IWM"],
+    summary: "ETF holdings with weights, shares, member returns, daily contributions, breadth and index changes. SPX and ^SPX use IVV holdings.",
+    usage: ["MEMB", "MEMB SPX", "MEMB ^RUT", "gloom fn MEMB SPX --tab breadth"],
     keys: [TABS, OPEN, MEMBERS_MENU],
-    data: same("Dated fund holdings and partial delayed member returns. Nasdaq-100 is not covered."),
+    data: same("Dated holdings and member returns. Breadth history uses current members (survivorship bias). Nasdaq-100 is not covered."),
     bloomberg: ["MEMB", "MRR", "IMOV"],
   },
   THEM: {
@@ -894,6 +894,13 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     data: US_SCANNER,
     bloomberg: [],
   },
+  SCAN: {
+    summary: "Your own intraday scan of US stocks over all listings, an index, a sector or a watchlist: moves over the last minutes, volume spikes against the average pace, new session highs and lows, VWAP crosses and gaps, above price, market cap and volume floors. Matches refresh through the session, and new ones can alert.",
+    usage: ["SCAN"],
+    keys: [TABS, OPEN, key("a", "dd condition"), key("s", "ave scan")],
+    data: US_SCANNER,
+    bloomberg: [],
+  },
   FLOW: {
     summary: "Sweeps, blocks and large premium prints as they hit the tape, with ticker, strike, expiry and premium.",
     usage: ["FLOW"],

package/src/cli/pane-functions/headless.ts

@@ -43,6 +43,7 @@ import { isRecord } from "../../utils/guards";
 import { splitSymbolWords } from "../symbol-args";
 import { formatUtcTime, localTimeSuffix } from "../../utils/utc-time";
 import { deriveHeadlessFreshness, formatFreshnessLine, staleRowsText, withSavedCopy, type ReportFreshness } from "./freshness";
+import { DATA_SERVICE_UNREACHABLE_MESSAGE } from "../../utils/network-failure";
 import { accessGateStatus, errorsAccessGate, isProLock, reportGateText } from "./access-gate";
 import { noArgumentMessage } from "./capabilities";
 import { lockedHeadlessReport } from "./lock-note";
@@ -780,13 +781,24 @@ export function headlessReportTables(
         // A section of one name or one date says so for every line it exports.
         const named = {
           ...(section.symbol?.trim() ? { symbolOrSeries: section.symbol.trim() } : {}),
-          ...(section.asOf?.trim() ? { asOf: section.asOf.trim() } : {}),
+          ...(section.asOf === null ? { asOf: null } : section.asOf?.trim() ? { asOf: section.asOf.trim() } : {}),
+          ...(section.period?.trim() ? { period: section.period.trim() } : {}),
+          ...(section.released?.trim() ? { released: section.released.trim() } : {}),
         };
         if (!("rows" in section && section.rows)) {
           const entries = exportEntriesTable(section.title, section.entries);
           // A figure that declares its unit names it in the unit column of its own line too.
-          const rowIdentities = section.entries.some((entry) => entry.unit?.trim())
-            ? section.entries.map((entry) => entry.unit?.trim() ? { currencyOrUnit: entry.unit.trim() } : undefined) : undefined;
+          // A line of its own period or release (a previous reading) names them rather than the section's.
+          const own = (entry: HeadlessPaneEntry): ExportIdentity | undefined => {
+            const identity = {
+              ...(entry.unit?.trim() ? { currencyOrUnit: entry.unit.trim() } : {}),
+              ...(entry.period !== undefined ? { period: entry.period } : {}),
+              ...(entry.released !== undefined ? { released: entry.released } : {}),
+              ...(entry.asOf !== undefined ? { asOf: entry.asOf } : {}),
+            };
+            return Object.keys(identity).length > 0 ? identity : undefined;
+          };
+          const rowIdentities = section.entries.some((entry) => own(entry)) ? section.entries.map(own) : undefined;
           return { ...entries, ...(Object.keys(named).length > 0 ? { identity: named } : {}), ...(rowIdentities ? { rowIdentities } : {}) };
         }
         const table = exportRowsTable(section.title, displayedColumns(columnsFor(section.rows, section.columns, definition.columns)), section.rows, { status: true });
@@ -819,6 +831,7 @@ export function headlessReportTables(
   const gate = reportGate(definition, result);
   return {
     tables,
+    ...(definition.exportDated ? { dated: true } : {}),
     identity: reportIdentity(definition, result, args),
     footer: reportFooterLines({
       freshness,
@@ -961,6 +974,22 @@ export function reportGaps(loaded: LoadedHeadlessPaneModel, freshness: ReportFre
     .filter(Boolean).join(", ") || null;
 }
 
+/**
+ * The freshness of a report that served nothing because the data service
+ * could not be reached (offline, a hung connection) and no saved copy
+ * answered: its line names no retrieval time, as nothing was retrieved.
+ */
+function withUnreached(
+  freshness: ReportFreshness,
+  result: HeadlessPaneResult,
+  { rowCount, unavailableSymbols, symbols }: { rowCount: number; unavailableSymbols: readonly string[]; symbols: readonly string[] },
+): ReportFreshness {
+  if (freshness.savedAt || freshness.asOf) return freshness;
+  const nothingServed = rowCount === 0 || (symbols.length > 0 && symbols.every((symbol) => unavailableSymbols.includes(symbol)));
+  const unreached = (result.errors ?? []).some((error) => error.includes(DATA_SERVICE_UNREACHABLE_MESSAGE));
+  return nothingServed && unreached ? { ...freshness, unreached: true } : freshness;
+}
+
 export async function buildHeadlessFunctionReport(
   resolved: ResolvedPaneFunction,
   context: MarketContext,
@@ -979,8 +1008,13 @@ export async function buildHeadlessFunctionReport(
   }
   const { complete, unavailableSymbols, rowCount, symbols } = reportCoverage(loaded);
   const serialized = serializeHeadlessPaneResult(loaded.definition, loaded.result);
-  // What the report shows from a saved copy, its refresh having failed, says so.
-  const freshness = withSavedCopy(deriveHeadlessFreshness(loaded.definition, loaded.result), loaded.result);
+  // What the report shows from a saved copy, its refresh having failed, says so; one that could not
+  // reach the data service for anything names no time it was retrieved.
+  const freshness = withUnreached(
+    withSavedCopy(deriveHeadlessFreshness(loaded.definition, loaded.result), loaded.result),
+    loaded.result,
+    { rowCount, unavailableSymbols, symbols },
+  );
   return {
     data: {
       kind: loaded.definition.shape,

package/src/cli/pane-functions/index.ts

@@ -36,7 +36,8 @@ import {
   ListingArgError, listingFateLoader, listingReadNotes, loadForListing, loadListingQuoteAnswer, quotedListingChoiceNotes, refuseMovedListing,
 } from "../listing-arg";
 import { isNotATickerMessage } from "../not-a-ticker";
-import { isCliFailure } from "../errors";
+import { isCliFailure, SERVICE_UNREACHABLE_CODE } from "../errors";
+import { DATA_SERVICE_UNREACHABLE_MESSAGE } from "../../utils/network-failure";
 import { isTickerLinkPeer } from "../../layout/ticker-navigation";
 import { knownGapMessage, commandPointer, commandPointerLeads, topicPointer } from "../known-gaps";
 import { selectReportTables, type CliReportTables } from "../report-tables";
@@ -247,7 +248,9 @@ function tablesHoldValues(tables: CliReportTables): boolean {
  * is a list (`failsWithoutData`) with no name that has any. A report with data
  * for some of what was asked, warnings or errors beside it, is a result: a
  * loss-maker's P/E band without a P/E, or IV history with only realized
- * volatility, exits 0.
+ * volatility, exits 0. Not one missing a part because the data service could
+ * not be reached: that is no answer rather than no data, and fails as
+ * retryable `service_unreachable`, whatever else it shows.
  */
 export function reportFailure(
   data: { empty: boolean; rowCount: number; symbols: readonly string[]; unavailableSymbols: readonly string[]; errors?: readonly string[]; reason?: unknown },
@@ -257,8 +260,12 @@ export function reportFailure(
   const missing = missingListings(data.symbols, data.unavailableSymbols);
   const noListing = data.symbols.length > 0 && data.symbols.every((symbol) => missing.has(listingKey(symbol)));
   const noValues = tables ? !tablesHoldValues(tables) : false;
-  if (!data.empty && !(noListing && noValues) && !(failsWithoutData && foundNothing(data))) return null;
   const reasons = [...data.errors ?? [], ...typeof data.reason === "string" ? [data.reason] : []];
+  const unreached = reasons.filter((reason) => reason.includes(DATA_SERVICE_UNREACHABLE_MESSAGE));
+  if (unreached.length > 0 && (data.empty || data.unavailableSymbols.length > 0)) {
+    return { code: SERVICE_UNREACHABLE_CODE, message: `${asked}: ${unreached.join("; ")}.`.replace(/\.\.$/, "."), retryable: true };
+  }
+  if (!data.empty && !(noListing && noValues) && !(failsWithoutData && foundNothing(data))) return null;
   const unavailable = data.unavailableSymbols.length > 0 ? `no data for ${data.unavailableSymbols.join(", ")}` : "no data";
   return { code: "no_data", message: `${asked}: ${reasons.length > 0 ? reasons.join("; ") : unavailable}.`.replace(/\.\.$/, ".") };
 }