gloomberb 0.17.2 → 0.17.4

package/src/cli/index.ts

@@ -37,7 +37,8 @@ import { createSystemCliCommands } from "./commands/system";
 import { brokerCliCommand, ibkrCliCommand } from "./commands/broker";
 import { listPlugins, updatePlugins } from "./commands/plugins";
 import { installListedPlugin, removePlugin } from "../plugins/installer";
-import { functionCodeCommand, runPaneCatalog, runPaneFunction, runPaneScreenshot } from "./pane-functions";
+import { catalogCommandHits, functionCodeCommand, runPaneCatalog, runPaneFunction, runPaneScreenshot } from "./pane-functions";
+import { catalogPointer, type CatalogCommandHit } from "./unknown-command";
 import { catalogFredSeriesIds } from "./series-search";
 
 const { width: SHOT_WIDTH, height: SHOT_HEIGHT } = SHOT_SIZE_LIMITS;
@@ -64,7 +65,7 @@ function createCoreCliCommands(
         const topic = args[0];
         if (topic) {
           const command = lookupCommand(topic);
-          if (!command) failUnknownCommand(topic, allCommands(), await functionCodeCommand(ctx, topic, []));
+          if (!command) failUnknownCommand(topic, allCommands(), await unknownCommandPointers(ctx, topic, [], allCommands()));
           printCommandHelp(command, ctx);
           return;
         }
@@ -306,18 +307,47 @@ function printCommandHelp(command: CliCommandDef, ctx: CliCommandContext): void
   ctx.printResult({ data: { ...describeCliCommand(command), sections: command.help?.sections ?? [] } });
 }
 
-/** `function` is what the word is when it is a function's code, and the command that runs it. */
-function failUnknownCommand(token: string, commands: CliCommandDef[], fn: { code: string; command: string } | null = null): never {
-  if (fn) fail(`${fn.code} is a function: ${fn.command}`);
-  const suggestion = suggestCliCommand(
+function nearCommand(token: string, commands: CliCommandDef[]): string | null {
+  return suggestCliCommand(
     normalizeCliCommandToken(token),
     commands.flatMap((command) => [command.name, ...(command.aliases ?? [])]),
   );
+}
+
+interface UnknownCommandPointers {
+  /** The word is a function's code: the command that runs it. */
+  fn: { code: string; command: string } | null;
+  /** Functions the catalog finds for the word, read only when it is no code and no command is close to it. */
+  hits: CatalogCommandHit[];
+  /** What the reader typed after the word, which a pointer runs the function with. */
+  args: readonly string[];
+}
+
+/** What an unknown command word may point at: a function's code first, then what the catalog finds for it. */
+async function unknownCommandPointers(
+  ctx: CliCommandContext,
+  token: string,
+  args: readonly string[],
+  commands: CliCommandDef[],
+): Promise<UnknownCommandPointers> {
+  const fn = await functionCodeCommand(ctx, token, args);
+  const hits = fn || nearCommand(token, commands) ? [] : await catalogCommandHits(ctx, token);
+  return { fn, hits, args };
+}
+
+/**
+ * A function's code is pointed at `fn`; a typo of a command at the command;
+ * a word the catalog knows (`comps`, `peers`) at the functions it finds.
+ */
+function failUnknownCommand(token: string, commands: CliCommandDef[], pointers: UnknownCommandPointers): never {
+  if (pointers.fn) fail(`${pointers.fn.code} is a function: ${pointers.fn.command}`);
+  const suggestion = nearCommand(token, commands);
+  const catalog = suggestion ? null : catalogPointer(token, pointers.hits, pointers.args);
   fail(
     `Unknown command "${token}".`,
     suggestion
       ? `Did you mean ${suggestion}? Run gloomberb help to see every command.`
-      : "Run gloomberb help to see every command.",
+      : catalog ? `${catalog}\nRun gloomberb help to see every command.` : "Run gloomberb help to see every command.",
   );
 }
 
@@ -408,11 +438,13 @@ export async function failUnknownCliCommand(args: string[], options: DispatchCli
     // dispatchCli already reported flags that do not parse.
   }
   const registry = await createRegistry(options);
-  // A function's code typed as a command is pointed at `fn`, with the arguments the reader gave.
-  const fn = token && parsed
-    ? await functionCodeCommand(createCliCommandContext("core", registry, parsed.options, parsed.args.slice(1)), token, parsed.args.slice(1))
-    : null;
-  return failUnknownCommand(token, listedCommands(registry).map((entry) => entry.command), fn);
+  const commands = listedCommands(registry).map((entry) => entry.command);
+  // A function's code typed as a command is pointed at `fn`, and a word the catalog knows at its
+  // functions, with the arguments the reader gave.
+  const pointers = token && parsed
+    ? await unknownCommandPointers(createCliCommandContext("core", registry, parsed.options, parsed.args.slice(1)), token, parsed.args.slice(1), commands)
+    : { fn: null, hits: [], args: [] };
+  return failUnknownCommand(token, commands, pointers);
 }
 
 export async function runCli(args: string[], options: DispatchCliOptions = {}): Promise<boolean> {

package/src/cli/known-gaps.ts

@@ -49,7 +49,11 @@ const KNOWN_GAPS: ReadonlyArray<{ terms: readonly string[]; message: string }> =
  */
 const TOPIC_POINTERS: ReadonlyArray<{
   topic: string;
+  /** What is true of it, when "not in the terminal yet" is not: no source carries it. */
+  availability?: string;
   phrases: readonly string[];
+  /** Words that ask for the topic only as the whole query: "utilization" alone, but "capacity utilization" is another thing. */
+  whole?: readonly string[];
   closest: ReadonlyArray<readonly [code: string, gives: string]>;
 }> = [
   {
@@ -58,6 +62,16 @@ const TOPIC_POINTERS: ReadonlyArray<{
       "military budget", "military spending", "pentagon budget", "pentagon spending"],
     closest: [["AWARDS", "government contract awards by company"], ["THEM", "defense and aerospace theme: fn THEM defense"]],
   },
+  {
+    // SI's own limitations say the same, so a search for a borrow fee does not read SI as a source of one.
+    topic: "borrow fee, utilization and locate",
+    availability: "not available (no securities-lending data)",
+    phrases: ["borrow fee", "borrow fees", "borrow rate", "borrow rates", "borrow cost", "borrow costs", "cost to borrow", "short borrow",
+      "stock borrow", "borrow availability", "borrow utilization", "borrow utilisation", "shares to borrow", "hard to borrow",
+      "easy to borrow", "securities lending", "stock loan", "stock lending", "locate fee", "short locate"],
+    whole: ["borrow", "borrowing", "utilization", "utilisation", "locate", "locates", "htb", "lendable shares"],
+    closest: [["SI", "FINRA short interest and days to cover"], ["SIW", "crowded shorts across your names"], ["SIV", "daily short volume"]],
+  },
 ];
 
 /** The words of a text, lower case: `DoD-budget` and `dod budget` read alike. */
@@ -76,10 +90,15 @@ function containsWords(query: readonly string[], phrase: readonly string[]): boo
 /** The pointer for a query that asks about a topic no function covers, with the function codes it names. */
 export function topicPointer(query: string): { message: string; codes: string[] } | null {
   const asked = words(query);
-  const pointer = TOPIC_POINTERS.find(({ phrases }) => phrases.some((phrase) => containsWords(asked, words(phrase))));
+  const key = lookupKey(query);
+  const pointer = TOPIC_POINTERS.find(({ phrases, whole }) => phrases.some((phrase) => containsWords(asked, words(phrase)))
+    || whole?.some((word) => lookupKey(word) === key));
   if (!pointer) return null;
   const closest = pointer.closest.map(([code, gives]) => `${code} (${gives})`).join(", ");
-  return { message: `${pointer.topic}: not in the terminal yet; closest: ${closest}`, codes: pointer.closest.map(([code]) => code) };
+  return {
+    message: `${pointer.topic}: ${pointer.availability ?? "not in the terminal yet"}; closest: ${closest}`,
+    codes: pointer.closest.map(([code]) => code),
+  };
 }
 
 /**

package/src/cli/listing-arg.ts

@@ -39,6 +39,7 @@ import {
   typedExchangeCode,
 } from "../utils/exchanges";
 import { withMarketData } from "./scoped-context";
+import { stripStrayEdges } from "./symbol-args";
 import { isNoProviderMessage } from "../sources/provider-errors";
 import { dashedCoinPair } from "../utils/crypto-pair";
 import { currencyPairSpelling } from "../utils/currency-pair";
@@ -91,9 +92,21 @@ export interface ListingArg {
  * `resolveCliListing` asks search before reading them as USDNGN=X.
  */
 export function parseListingArg(
-  raw: string,
+  rawArg: string,
   exchangeOption?: string | null,
   { ownExchangeWins = false }: { ownExchangeWins?: boolean } = {},
+): ListingArg {
+  // A pasted ticker can bring the separator or quote marks that sat beside it (`UPST;`); search would ask for them.
+  const stripped = stripStrayEdges(rawArg);
+  const raw = stripped.text || rawArg;
+  const listing = parseCleanListingArg(raw, exchangeOption, { ownExchangeWins });
+  return stripped.text && stripped.notes.length > 0 ? { ...listing, readAs: stripped.notes.join(" ") } : listing;
+}
+
+function parseCleanListingArg(
+  raw: string,
+  exchangeOption: string | null | undefined,
+  { ownExchangeWins }: { ownExchangeWins: boolean },
 ): ListingArg {
   const optionCode = (exchangeOption ?? "").trim().toUpperCase();
   const option = canonicalExchange(optionCode);
@@ -167,9 +180,11 @@ async function settleSharedCode(listing: ListingArg, deps: ListingDeps): Promise
   }
   const { exchange } = reading;
   const key = `${symbol}:${exchange}`;
-  const readAs = exchange === meanings[0] ? {}
-    : { readAs: `Read ${symbol}:${code} as ${key}: ${code} is ${venueChoices(meanings)}, and ${symbol} trades on ${exchange}.` };
-  return { symbol, exchange, key, ...readAs };
+  const readAs = [
+    listing.readAs,
+    exchange === meanings[0] ? null : `Read ${symbol}:${code} as ${key}: ${code} is ${venueChoices(meanings)}, and ${symbol} trades on ${exchange}.`,
+  ].filter(Boolean).join(" ");
+  return { symbol, exchange, key, ...readAs ? { readAs } : {} };
 }
 
 /**

package/src/cli/listing-suggestion.ts

@@ -2,6 +2,8 @@ import type { DataProvider } from "../types/data-provider";
 import type { TickerRecord } from "../types/ticker";
 import { LISTING_SEARCH_LIMIT, searchTickerCandidates, type TickerSearchCandidate } from "../tickers/search";
 import { mapWithConcurrency } from "../utils/concurrency";
+import { isUsListingExchange } from "../utils/exchanges";
+import { STARTER_SYMBOLS } from "../tickers/starter-symbols";
 import { TickerNotFoundError } from "./ticker-resolution";
 
 /** How long a suggestion waits for search; a slow search leaves the plain "not found" as it was. */
@@ -118,13 +120,18 @@ async function searchAsCommand(query: string, { store, dataProvider }: Suggestio
 export async function suggestListing(input: string, deps: SuggestionDeps): Promise<ListingSuggestion | null> {
   const query = input.trim().replace(/^\$/, "");
   if (!query) return null;
+  const candidates = await searchCandidates(query, deps);
+  return candidates ? nearestListing(query, candidates) : null;
+}
+
+/** The search's candidates for a query, or null when it fails or is slow; it never throws and never waits longer than the timeout. */
+async function searchCandidates(query: string, deps: SuggestionDeps): Promise<TickerSearchCandidate[] | null> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
-    const candidates = await Promise.race([
+    return await Promise.race([
       Promise.resolve().then(() => (deps.search ?? ((text: string) => searchAsCommand(text, deps)))(query)),
       new Promise<null>((resolve) => { timer = setTimeout(() => resolve(null), deps.timeoutMs ?? SUGGESTION_TIMEOUT_MS); }),
     ]);
-    return candidates ? nearestListing(query, candidates) : null;
   } catch {
     return null;
   } finally {
@@ -132,6 +139,30 @@ export async function suggestListing(input: string, deps: SuggestionDeps): Promi
   }
 }
 
+/**
+ * The US ticker a symbol that quoted on a listing abroad was most likely typed
+ * for: APPL, which is Aptus Pharma on BSE, for AAPL. Search lists no AAPL for
+ * APPL, so the match comes from the US symbols a person is likely to mean (the
+ * starter watchlist and their own saved US tickers) that are one slip away,
+ * and only a single one counts. Search then names it; a US listing it does not
+ * find is no suggestion. Null when nothing is near, and for a symbol too short
+ * for one edit to leave it recognisable.
+ */
+export async function suggestUsTicker(typed: string, deps: SuggestionDeps): Promise<ListingSuggestion | null> {
+  const wanted = compact(typed);
+  if (wanted.length < MIN_TYPO_LENGTH) return null;
+  const saved = (await deps.store.loadAllTickers().catch(() => [])).filter((ticker) => isUsListingExchange(ticker.metadata.exchange));
+  const near = new Set([...STARTER_SYMBOLS, ...saved.map((ticker) => ticker.metadata.ticker)]
+    .map((symbol) => symbol.trim().toUpperCase())
+    .filter((symbol) => compact(symbol).length >= MIN_TYPO_LENGTH && editDistance(wanted, compact(symbol)) === 1));
+  if (near.size !== 1) return null;
+  const [symbol] = near;
+  const candidates = await searchCandidates(symbol!, deps);
+  if (!candidates) return { symbol: symbol!, name: "" };
+  const listed = candidates.find((candidate) => (candidate.label || candidate.symbol).toUpperCase() === symbol && isUsListingExchange(candidate.exchangeLabel));
+  return listed ? { symbol: symbol!, name: candidateName(listed) } : null;
+}
+
 /** The answer for a symbol search lists nothing for, with nothing else said (a company that left its symbol, a wrong exchange, a stopped listing each say more). */
 const PLAIN_NO_MATCH = /^No ticker match found for ".*"\.$/s;
 

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

@@ -1,5 +1,5 @@
 import type { DesktopPaneShotRenderedRow } from "../desktop-pane-shot";
-import { cliStyles, renderSection, renderTable } from "../../utils/cli-output";
+import { cliStyles, cliTerminalWidth, renderSection, renderTable, wrapText } from "../../utils/cli-output";
 import { formatUtcTime } from "../../utils/utc-time";
 import type { MarketContext } from "../types";
 import type { PaneFunctionReport } from "./report";
@@ -14,10 +14,14 @@ import { renderedReportFailure, renderedReportFreshness, renderedReportNotices,
 
 const DOM_REPORT_WIDTH = 1280;
 const DOM_REPORT_HEIGHT = 720;
+/** A pane whose reader has a page open grows to show all of it, up to about 18,000 px: a report saves no image to bound it. */
+const DOM_REPORT_MAX_HEIGHT_CELLS = 1000;
 const DOM_LIMITATION =
   "Only values visible in the rendered pane are returned; clipped or off-screen data may be omitted.";
 const DOM_EVERY_ROW =
   "Every row of the pane's table is returned, including rows scrolled out of view.";
+const DOM_WHOLE_PANE =
+  "The pane was grown to fit the page it has open, so all of its text is returned.";
 
 /** The sign-in wall's buttons, which a rendered view reads as words: `Log in ↵ Sign up free`. */
 const SIGN_IN_WALL_BUTTONS = /\s*\b(?:Log in|Sign up free|Resend Verification Email)(?:\s*\u21B5)?(?=\s|$)/g;
@@ -39,6 +43,28 @@ function signInWallText(visibleText: string): string {
   return headline ? `${headline} ${needs}` : needs;
 }
 
+const LIST_MARKER = /^\s*[\u2022\u25E6\u25AA\u00B7\u2013-]\s*$/;
+
+/**
+ * The words of a pane that is prose, not a table, a line to each block it draws
+ * and wrapped to the terminal's width (100 where it has none): the pane's own title,
+ * which the report's heading says already, is left off its top.
+ */
+function proseLines(render: PaneScreenshotResult["render"], title: string): string[] {
+  const lines = render.visibleLines?.length ? render.visibleLines : [render.visibleText];
+  const width = Math.min(cliTerminalWidth() ?? 100, 100);
+  const titled = lines[0]?.trim() === title ? lines.slice(1) : lines;
+  const body: string[] = [];
+  // A stack's detail opens under its Back button, a control and not part of the page.
+  for (const line of titled[0] === "Back" ? titled.slice(1) : titled) {
+    // A list marker is drawn as a block of its own, ahead of the item's words.
+    const marker = body.at(-1);
+    if (marker !== undefined && LIST_MARKER.test(marker)) body[body.length - 1] = `${marker.trim()} ${line}`;
+    else body.push(line);
+  }
+  return body.flatMap((line) => wrapText(line, width));
+}
+
 function rowsContainEllipsis(rows: DesktopPaneShotRenderedRow[]): boolean {
   return rows.some((row) => row.cells.some((cell) => /\u2026|\.\.\./.test(cell.text)));
 }
@@ -215,7 +241,7 @@ export function buildDomPaneReportFromRender(
   } else if (lockNote) {
     textLines.push(...lockNoteLines(lockNote));
   } else if (result.render.visibleText) {
-    textLines.push(gate === "sign-in" ? signInWallText(result.render.visibleText) : result.render.visibleText);
+    textLines.push(...(gate === "sign-in" ? [signInWallText(result.render.visibleText)] : proseLines(result.render, resolved.label)));
   } else {
     textLines.push(failureReason ?? "No rendered values were available.");
   }
@@ -231,6 +257,8 @@ export function buildDomPaneReportFromRender(
   const complete = failureReason === null && !truncated;
   // Each table published its rows and nothing else was cut: the report is the whole view.
   const everyRow = complete && result.render.reportRows !== undefined;
+  // A reader grown to fit its page (a docs page) and not cut once grown is read whole.
+  const wholePane = complete && !everyRow && resolved.pane.shotFitsReader === true;
   return {
     data: {
       kind: "rendered-view",
@@ -247,7 +275,8 @@ export function buildDomPaneReportFromRender(
       truncated,
       truncationReasons,
       ...(everyRow ? { everyRow } : {}),
-      limitation: everyRow ? DOM_EVERY_ROW : DOM_LIMITATION,
+      ...(wholePane ? { wholePane } : {}),
+      limitation: everyRow ? DOM_EVERY_ROW : wholePane ? DOM_WHOLE_PANE : DOM_LIMITATION,
       ...(lockReason ?? failureReason ? { reason: lockReason ?? failureReason } : {}),
       ...(notices.length > 0 ? { metadata: { ...rendered.facts, notices } } : {}),
       ...(locked ? { locked } : { freshness }),
@@ -278,12 +307,12 @@ export function appendDomReportFooter(
   ].join("\n");
 }
 
-/** How much of the pane a rendered-view report holds: none behind a wall, cut, every row its tables publish, or what the viewport shows. */
-export type DomReportView = "locked" | "clipped" | "every-row" | "visible";
+/** How much of the pane a rendered-view report holds: none behind a wall, cut, every row its tables publish, all of a pane grown to fit, or what the viewport shows. */
+export type DomReportView = "locked" | "clipped" | "every-row" | "whole" | "visible";
 
 export function domReportView(data: Readonly<Record<string, unknown>>): DomReportView {
   if (data.locked) return "locked";
-  return data.truncated === true ? "clipped" : data.everyRow === true ? "every-row" : "visible";
+  return data.truncated === true ? "clipped" : data.everyRow === true ? "every-row" : data.wholePane === true ? "whole" : "visible";
 }
 
 /** What a rendered-view report says about where its values come from. */
@@ -292,6 +321,8 @@ export function domReportNote(elapsedMs: number, view: DomReportView): string {
     ? "Rendered view: the pane is locked, so no values were read."
     : view === "every-row"
     ? "Rendered view: every row of the pane's table, including rows scrolled out of view."
+    : view === "whole"
+    ? "Rendered view: the pane grown to fit the whole page."
     : `Rendered view: values come from the visible pane. ${view === "clipped" ? "The rendered view is clipped." : "The rendered view may be clipped."}`;
   return `${source} Render time: ${elapsedMs} ms.`;
 }
@@ -356,6 +387,8 @@ export async function buildDomFunctionReport(
       theme: null,
       scale: 1,
       watermark: null,
+      fitReader: true,
+      maxHeightCells: DOM_REPORT_MAX_HEIGHT_CELLS,
       options: {},
       captureImage: false,
     });

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

@@ -10,8 +10,8 @@ import type {
 } from "../../types/plugin";
 import { localTimeSuffix, parseReportTime, type ReportTime } from "../../utils/utc-time";
 import { isRecord } from "../../utils/guards";
-import { latestRegularSessionClose } from "../../market-data/market/freshness";
-import { reportMarketSession, type ReportMarket, type SessionObservation } from "./market-session";
+import { latestRegularSessionClose, readIndexSession } from "../../market-data/market/freshness";
+import { reportMarketSession, reportVenueSessionDates, type ReportMarket, type SessionObservation, type VenueSessionDate } from "./market-session";
 
 /**
  * The four states of docs/usage.md#how-current-a-report-is, plus `unreported`
@@ -53,6 +53,12 @@ export interface ReportFreshness {
   tradingDayMarket?: string;
   /** Where the venues of a quote report stand now, from their session calendars. */
   market?: ReportMarket;
+  /**
+   * With a declared `datesEachVenue`, when the rows trade on more than one
+   * market: each market's session date, which the status line gives in place
+   * of the newest row's alone.
+   */
+  venueSessions?: VenueSessionDate[];
   /**
    * For a dataset (declared `dataset`, with no quote among its rows): whole UTC
    * days from the last day its newest observation covers to when this report
@@ -76,6 +82,8 @@ export interface ReportFreshness {
   oldestAgeMinutes?: number;
   /** What the figures are, said after the status: `funding = current estimate, pays 08:00 UTC`. */
   note?: string;
+  /** When the figures reach readers and when the next are due, said right after the as-of date. */
+  schedule?: string;
   /** Who published the figures, when the data names them. */
   publisher?: string;
   /** When the publisher released the data, an ISO instant in UTC or an ISO date, when the data states it. */
@@ -145,10 +153,12 @@ function readFeedSignals(record: Record<string, unknown>, signals: FeedSignals):
 function readSession(record: Record<string, unknown>, time: ReportTime | null, signals: FeedSignals): void {
   const exchange = record.sessionExchange;
   if (typeof exchange !== "string" || !exchange.trim()) return;
+  const calendar = readIndexSession(record.sessionCalendar);
   signals.sessions.push({
     exchange,
     ...(typeof record.marketState === "string" ? { marketState: record.marketState } : {}),
     time,
+    ...(calendar ? { calendar } : {}),
   });
 }
 
@@ -404,6 +414,7 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
     }
   }
   const { market, closeDate, closeMarket } = reportMarketSession(signals.sessions, now);
+  const venueSessions = declared.datesEachVenue && !declaredAsOf ? reportVenueSessionDates(signals.sessions, now) : [];
   // The close wording dates the newest observation, so only when that is what `asOf` is.
   const asOfClose = closeDate && asOf && !declaredAsOf ? closeDate : null;
   const tradingDayMarket = asOfClose ? closeMarket
@@ -417,6 +428,7 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
   const observation = lagDays != null ? declared.observation?.trim() : undefined;
 
   const note = declared.note?.trim();
+  const schedule = declared.schedule?.trim();
   const publisher = declared.publisher?.trim();
   const publishedAt = parseReportTime(declared.publishedAt);
   return {
@@ -434,11 +446,13 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
     ...(asOfClose ? { asOfClose } : {}),
     ...(tradingDayMarket ? { tradingDayMarket } : {}),
     ...(market ? { market } : {}),
+    ...(venueSessions.length > 0 ? { venueSessions } : {}),
     ...(lagDays != null ? { lagDays } : {}),
     ...(observation ? { observation } : {}),
     ...(sources.length ? { sources: sources.map(({ source, time }) => ({ source, asOf: isoTime(time) })) } : {}),
     ...(oldestAgeMinutes != null ? { oldestAgeMinutes } : {}),
     ...(note ? { note } : {}),
+    ...(schedule ? { schedule } : {}),
     ...(publisher ? { publisher } : {}),
     ...(publishedAt ? { publishedAt: isoTime(publishedAt) } : {}),
     retrievedAt: new Date(now).toISOString(),
@@ -628,6 +642,26 @@ function onRetrievalDay(iso: string, retrievedAt: string): boolean {
   return iso.slice(0, 10) === retrievedAt.slice(0, 10);
 }
 
+/** `US and XETRA`, `US, XETRA and EPA`. */
+function listText(items: readonly string[]): string {
+  return items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+}
+
+/**
+ * Each market's session date, markets on the same day and state said once:
+ * `US, XETRA and EPA Tue 13 Oct 2026 close`, or `US Tue 13 Oct 2026 close,
+ * XETRA Wed 14 Oct 2026 session` while Xetra trades.
+ */
+function venueSessionsText(sessions: readonly VenueSessionDate[]): string {
+  const groups: Array<{ markets: string[]; date: string; close: boolean }> = [];
+  for (const { market, date, close } of sessions) {
+    const group = groups.find((entry) => entry.date === date && entry.close === close);
+    if (group) group.markets.push(market);
+    else groups.push({ markets: [market], date, close });
+  }
+  return groups.map(({ markets, date, close }) => `${listText(markets)} ${dayText(date)} ${close ? "close" : "session"}`).join(", ");
+}
+
 /**
  * The dated as-of: a session close, a UTC time, a date, or when the report was
  * retrieved; with the oldest observation unless `short`, or when the line says
@@ -636,6 +670,7 @@ function onRetrievalDay(iso: string, retrievedAt: string): boolean {
  */
 function asOfText(freshness: ReportFreshness, short: boolean, local: boolean, undated = false): string {
   if (!freshness.asOf) return `retrieved ${timeText(freshness.retrievedAt, local)}`;
+  if (freshness.venueSessions?.length) return venueSessionsText(freshness.venueSessions);
   const market = freshness.tradingDayMarket;
   const period = freshness.periodicity;
   const time = parseReportTime(freshness.asOf);
@@ -713,6 +748,8 @@ interface StatusLineDetail {
   date?: "none";
   /** Leave out what the figures are (`funding = current estimate`). */
   note?: "none";
+  /** Leave out when the figures are published and the next are due. */
+  schedule?: "none";
 }
 
 /**
@@ -728,6 +765,7 @@ function statusLineParts(freshness: ReportFreshness, detail: StatusLineDetail =
   return [
     ...(freshness.sources?.length ? sourcesAsOfParts(freshness, freshness.sources, undated)
       : [asOfText(freshness, detail.asOf === "short", local, undated)]),
+    ...(freshness.schedule && detail.schedule !== "none" ? [freshness.schedule] : []),
     ...(freshness.oldestAgeMinutes != null ? [`oldest ${ageText(freshness.oldestAgeMinutes)}`] : []),
     statusText(freshness, detail.status === "short"),
     ...(freshness.market && detail.market !== "none" ? [marketText(freshness.market, now, detail.market === "short", local)] : []),
@@ -812,13 +850,13 @@ export function paneStatusLine(freshness: ReportFreshness): string {
 /**
  * `paneStatusLine` from longest to shortest, for a footer to show the first
  * that fits beside its keys: the market part shortens, the stale total goes,
- * then what the figures are.
+ * then what the figures are, then when they are published.
  */
 export function paneStatusLineVariants(freshness: ReportFreshness): string[] {
   // A dataset's line has no market or local time to leave out: it reads as its report and capture do.
   if (datesObservation(freshness)) return statusLineVariants(freshness);
   const pane: StatusLineDetail = { local: "none", date: "none" };
-  const details: StatusLineDetail[] = [pane, { ...pane, market: "short" }, { ...pane, market: "short", status: "short" }, { ...pane, market: "short", status: "short", note: "none" }];
+  const details: StatusLineDetail[] = [pane, { ...pane, market: "short" }, { ...pane, market: "short", status: "short" }, { ...pane, market: "short", status: "short", note: "none" }, { ...pane, market: "short", status: "short", note: "none", schedule: "none" }];
   return [...new Set(details.map((detail) => capitalize(statusLineParts(freshness, detail).join(" · "))))];
 }
 
@@ -855,9 +893,14 @@ export function statusLineVariants(freshness: ReportFreshness, { source = false
   // A line that dates each source keeps every source's time and their age to
   // the last: its day goes first, then what the figures are.
   const shortest = details.at(-1)!;
+  // What the figures are goes before when they are published.
+  const trailing: StatusLineDetail[] = [
+    ...(freshness.note ? [{ ...shortest, note: "none" as const }] : []),
+    ...(freshness.schedule ? [{ ...shortest, note: "none" as const, schedule: "none" as const }] : []),
+  ];
   const variants: StatusLineDetail[] = freshness.sources?.length
     ? [{}, ...details.map((detail) => ({ ...detail, date: "none" as const })), { ...shortest, date: "none", note: "none" }]
-    : freshness.note ? [...details, { ...shortest, note: "none" }] : details;
+    : [...details, ...trailing];
   const lines = [...new Set(variants.map((detail) => capitalize(statusLineParts(freshness, detail).join(" · "))))];
   // A line that dates each source names them already.
   if (!source || freshness.sources?.length) return lines;

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

@@ -749,7 +749,7 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     bloomberg: [],
   },
   FUT: {
-    summary: "Front-month futures across equity index, rates, energy, metals, agriculture, livestock and FX with last price and session change, grouped by sector.",
+    summary: "Each root's most active futures contract across equity index, equity sectors, rates, energy, metals, agriculture, livestock and FX with last price, unit and session change, grouped by sector.",
     usage: ["FUT"],
     keys: [SEARCH, OPEN],
     data: same(DELAYED),