gloomberb 0.16.2 → 0.16.3

package/src/cli/history-rows.ts

@@ -1,19 +1,52 @@
 import type { PricePoint } from "../types/financials";
 import { marketPriceFractionDigitCeiling, resolveAssetDisplayKind } from "../market-data/market/format";
-import { isIntradayResolution, type ManualChartResolution } from "../time-series/resolution";
+import { TIME_RANGES, type TimeRange } from "../time-series/range";
+import { subtractTimeRange } from "../time-series/date-window";
+import {
+  CHART_RESOLUTION_STEP_MS,
+  isIntradayResolution,
+  RANGE_HISTORY_RESOLUTION,
+  type ManualChartResolution,
+} from "../time-series/resolution";
+import { currencyUnitLabel } from "../utils/currency-units";
 import { getPricePointTimestamp } from "../utils/price-history";
+import { pricePointIntegrityFlags, pricePointValues } from "../utils/price-history-integrity";
+import { formatUtcTime } from "../utils/utc-time";
 
 const PRICE_KEYS = ["open", "high", "low", "close"] as const;
+const DAY_MS = 24 * 60 * 60 * 1000;
 /** Daily bars are a day apart even when stamped at the session open. */
 const INTRADAY_MAX_GAP_MS = 20 * 60 * 60 * 1000;
+const INTRADAY_RESOLUTIONS = ["1m", "5m", "15m", "30m", "45m", "1h"] as const;
+/** A first bar later than this after the range's start is a late start, not a weekend or holiday. */
+const LATE_START_MIN_MS = 10 * DAY_MS;
+const LATE_START_MIN_BARS = 3;
 
-interface HistoryRow {
+const BAR_INTERVAL_LABELS: Record<ManualChartResolution, string> = {
+  "1m": "1-minute",
+  "5m": "5-minute",
+  "15m": "15-minute",
+  "30m": "30-minute",
+  "45m": "45-minute",
+  "1h": "hourly",
+  "1d": "daily",
+  "1wk": "weekly",
+  "1mo": "monthly",
+};
+
+export interface HistoryRow {
   date: string;
   open: number | null;
   high: number | null;
   low: number | null;
-  close: number;
+  close: number | null;
   volume: number | null;
+  /** Currency code of the prices; null for index points or when no source says. */
+  currency: string | null;
+  /** Bar size, in the codes of `resolution`: 5m, 1h, 1d, 1wk, 1mo. */
+  interval: ManualChartResolution | null;
+  /** Each way the bar's prices contradict each other, such as `high<open`; null when they agree. */
+  flag: string | null;
 }
 
 function decimalPlaces(value: number): number {
@@ -43,29 +76,63 @@ function isUtcMidnight(time: number): boolean {
   return new Date(time).toISOString().endsWith("T00:00:00.000Z");
 }
 
+function medianGap(times: readonly number[]): number | null {
+  const finite = times.filter(Number.isFinite).sort((left, right) => left - right);
+  const gaps = finite.slice(1).map((time, index) => time - finite[index]!).filter((gap) => gap > 0).sort((left, right) => left - right);
+  return gaps.length > 0 ? gaps[Math.floor((gaps.length - 1) / 2)]! : null;
+}
+
 /** Without a declared cadence, bar spacing decides: daily bars may be stamped at the session open. */
 function looksIntraday(times: readonly number[]): boolean {
-  const finite = times.filter(Number.isFinite).sort((left, right) => left - right);
+  const finite = times.filter(Number.isFinite);
   if (finite.length < 2) return finite.some((time) => !isUtcMidnight(time));
-  const gaps = finite.slice(1).map((time, index) => time - finite[index]!).filter((gap) => gap > 0).sort((left, right) => left - right);
-  return gaps.length > 0 && gaps[Math.floor((gaps.length - 1) / 2)]! < INTRADAY_MAX_GAP_MS;
+  const gap = medianGap(finite);
+  return gap != null && gap < INTRADAY_MAX_GAP_MS;
+}
+
+/** The bar size served: as the source declared it, otherwise read from the typical spacing of the bars. */
+function historyInterval(times: readonly number[], resolution: ManualChartResolution | null): ManualChartResolution | null {
+  if (resolution) return resolution;
+  const gap = medianGap(times);
+  if (gap == null) return null;
+  if (gap < INTRADAY_MAX_GAP_MS) {
+    return INTRADAY_RESOLUTIONS.reduce((best, candidate) => (
+      Math.abs(CHART_RESOLUTION_STEP_MS[candidate] - gap) < Math.abs(CHART_RESOLUTION_STEP_MS[best] - gap) ? candidate : best
+    ));
+  }
+  const days = gap / DAY_MS;
+  return days >= 25 ? "1mo" : days >= 6 ? "1wk" : "1d";
 }
 
-/** Intraday bars keep their UTC time; daily and longer bars are trading dates. */
-export function historyRows(points: readonly PricePoint[], resolution: ManualChartResolution | null): HistoryRow[] {
+/**
+ * Intraday bars keep their UTC time; daily and longer bars are trading dates.
+ * A bar whose prices contradict each other is blanked exactly as HP blanks it,
+ * and says why in `flag`.
+ */
+export function historyRows(
+  points: readonly PricePoint[],
+  resolution: ManualChartResolution | null,
+  currency: string | null = null,
+): HistoryRow[] {
   const times = points.map(getPricePointTimestamp);
   const intraday = resolution ? isIntradayResolution(resolution) : looksIntraday(times);
+  const interval = historyInterval(times, resolution);
   return points.map((point, index) => {
     const time = times[index]!;
     const iso = Number.isFinite(time) ? new Date(time).toISOString() : "";
-    const price = (value: number | undefined) => value == null ? null : cleanFloat32Price(value);
+    const values = pricePointValues(point);
+    const flags = pricePointIntegrityFlags(point);
+    const price = (value: number | null) => value == null ? null : cleanFloat32Price(value);
     return {
       date: intraday ? iso.replace(".000Z", "Z") : iso.slice(0, 10),
-      open: price(point.open),
-      high: price(point.high),
-      low: price(point.low),
-      close: cleanFloat32Price(point.close),
-      volume: point.volume ?? null,
+      open: price(values.open),
+      high: price(values.high),
+      low: price(values.low),
+      close: price(values.close),
+      volume: values.volume,
+      currency,
+      interval,
+      flag: flags.length > 0 ? flags.join(",") : null,
     };
   });
 }
@@ -84,7 +151,7 @@ function neededDecimals(value: number, cap: number): number {
  * one, the largest price sets a seven significant digit ceiling (BTC keeps
  * cents, FX keeps pips, sub-cent coins keep their digits). Cents at least above 1.
  */
-export function historyPriceDecimals(rows: readonly HistoryRow[], assetCategory?: string): number {
+export function historyPriceDecimals(rows: readonly Pick<HistoryRow, typeof PRICE_KEYS[number]>[], assetCategory?: string): number {
   const values = rows.flatMap((row) => PRICE_KEYS.flatMap((key) => {
     const value = row[key];
     return value != null && Number.isFinite(value) && value !== 0 ? [Math.abs(value)] : [];
@@ -100,3 +167,108 @@ export function historyPriceDecimals(rows: readonly HistoryRow[], assetCategory?
   const decimals = needed[Math.floor(0.9 * (needed.length - 1))]!;
   return largest >= 1 ? Math.max(2, decimals) : decimals;
 }
+
+/** How far back ALL reaches, in whole years, from the window a history request for it asks for. */
+export function historyAllRangeYears(now = new Date()): number {
+  return Math.round((now.getTime() - subtractTimeRange(now, "ALL").getTime()) / (365.25 * DAY_MS));
+}
+
+/** "1D 5-minute, 1W hourly, 1M to 1Y daily, 5Y weekly, ALL monthly", from the table history requests use. */
+export function historyIntervalsByRange(): string {
+  const groups: Array<{ ranges: TimeRange[]; resolution: ManualChartResolution }> = [];
+  for (const range of TIME_RANGES) {
+    const resolution = RANGE_HISTORY_RESOLUTION[range];
+    const last = groups.at(-1);
+    if (last?.resolution === resolution) last.ranges.push(range);
+    else groups.push({ ranges: [range], resolution });
+  }
+  return groups.map(({ ranges, resolution }) => (
+    `${ranges.length > 1 ? `${ranges[0]} to ${ranges.at(-1)}` : ranges[0]} ${BAR_INTERVAL_LABELS[resolution]}`
+  )).join(", ");
+}
+
+export interface HistoryUnit {
+  kind: "currency" | "pair" | "points" | "unknown";
+  /** Currency code of the prices; null for index points or when no source says. */
+  currency: string | null;
+  /** What one price is: "USD", "ILA (agorot, 1/100 ILS)", "ZAR per USD", "index points"; null when unknown. */
+  unit: string | null;
+}
+
+/**
+ * What the prices are in. An FX pair is named by its symbol (ZAR=X is ZAR per
+ * USD, EURUSD=X is USD per EUR), an index is in points, and anything else is
+ * in the currency its quote states, a sub-unit named as such. Without one the
+ * unit is unknown rather than guessed from the exchange.
+ */
+export function historyUnit(symbol: string, quote: { currency?: string; instrumentType?: string } | null | undefined): HistoryUnit {
+  const pair = /^([A-Z]{3})([A-Z]{3})?=X$/.exec(symbol.trim().toUpperCase());
+  if (pair) {
+    const [base, counter] = pair[2] ? [pair[1]!, pair[2]] : ["USD", pair[1]!];
+    return { kind: "pair", currency: counter, unit: `${counter} per ${base}` };
+  }
+  if (quote?.instrumentType?.trim().toUpperCase() === "INDEX") return { kind: "points", currency: null, unit: "index points" };
+  const code = quote?.currency?.trim();
+  return code
+    ? { kind: "currency", currency: code, unit: currencyUnitLabel(code, { ofMajor: true }) }
+    : { kind: "unknown", currency: null, unit: null };
+}
+
+function historyDate(value: string): string {
+  return value.length > 10 ? formatUtcTime(value) : value;
+}
+
+/** The facts line under a history heading: "Currency USD", "daily bars", "2025-10-09 to 2026-10-08", "251 bars". */
+export function historyFacts(unit: HistoryUnit, rows: readonly Pick<HistoryRow, "date" | "interval">[]): string[] {
+  const first = rows[0]?.date;
+  const last = rows.at(-1)?.date;
+  const interval = rows[0]?.interval;
+  return [
+    unit.kind === "pair" ? unit.unit! : unit.kind === "points" ? "Index points" : `Currency ${unit.unit ?? "unknown"}`,
+    interval ? `${BAR_INTERVAL_LABELS[interval]} bars` : "",
+    first && last ? (first === last ? historyDate(first) : `${historyDate(first)} to ${historyDate(last)}`) : "",
+    `${rows.length} ${rows.length === 1 ? "bar" : "bars"}`,
+  ].filter(Boolean);
+}
+
+/**
+ * What an export should know that its rows do not show: bars coarser than the
+ * range is served in, or a first bar well after the start asked for, as for a
+ * listing younger than the range. Weekends and holidays are within tolerance.
+ */
+export function historyNotes(
+  range: TimeRange,
+  interval: ManualChartResolution | null,
+  firstDate: string | undefined,
+  now = Date.now(),
+): string[] {
+  if (!firstDate) return [];
+  const notes: string[] = [];
+  const expected = RANGE_HISTORY_RESOLUTION[range];
+  if (interval && CHART_RESOLUTION_STEP_MS[interval] > CHART_RESOLUTION_STEP_MS[expected]) {
+    const from = interval === "1mo" ? firstDate.slice(0, 7) : firstDate.slice(0, 10);
+    notes.push(`Asked ${range}, got ${BAR_INTERVAL_LABELS[interval]} bars from ${from}`);
+  }
+  const first = Date.parse(firstDate);
+  if (range !== "ALL" && Number.isFinite(first)) {
+    const tolerance = Math.max(LATE_START_MIN_MS, LATE_START_MIN_BARS * CHART_RESOLUTION_STEP_MS[interval ?? expected]);
+    if (first - subtractTimeRange(new Date(now), range).getTime() > tolerance) {
+      notes.push(`Asked ${range}, data starts ${firstDate.slice(0, 10)} (first available bar)`);
+    }
+  }
+  return notes;
+}
+
+/** "37 of 251 bars have high below open or close in the source data; ...", or null when every bar agrees. */
+export function historyFlagNote(rows: readonly Pick<HistoryRow, "flag">[]): string | null {
+  const flagged = rows.filter((row) => row.flag);
+  if (flagged.length === 0) return null;
+  const codes = new Set(flagged.flatMap((row) => row.flag!.split(",")));
+  const kinds = [
+    codes.has("high<open") || codes.has("high<close") ? "high below open or close" : "",
+    codes.has("low>open") || codes.has("low>close") ? "low above open or close" : "",
+    codes.has("low>high") ? "low above high" : "",
+  ].filter(Boolean);
+  const count = `${flagged.length} of ${rows.length} ${flagged.length === 1 && rows.length === 1 ? "bar" : "bars"}`;
+  return `${count} ${flagged.length === 1 ? "has" : "have"} ${kinds.join(", or ")} in the source data; their prices are left blank`;
+}

package/src/cli/index.ts

@@ -16,14 +16,16 @@ import {
   renderCliHelp,
   renderCommandHelp,
   suggestCliCommand,
+  TABLE_SECTION_OPTION,
   type CliHelpEntry,
 } from "./help";
 import { parsePaneFunctionArgs } from "./pane-functions/options";
+import { checkCliCommandOptions } from "./command-options";
 import { fail, inferCliErrorOptions, printCliError } from "./errors";
 import { setCliColorEnabledOverride } from "../utils/cli-output";
 import { search, searchCandidatesForCli, buildSearchReport } from "./commands/search";
 import { ticker } from "./commands/ticker";
-import { takeOption } from "./commands/command-utils";
+import { requireOneArg, takeOption } from "./commands/command-utils";
 import { EXCHANGE_OPTION } from "./listing-arg";
 import { apiCliCommand } from "./commands/api";
 import { marketDataCliCommands } from "./commands/market";
@@ -107,11 +109,8 @@ function createCoreCliCommands(
       execute: async (rawArgs, ctx) => {
         const args = [...rawArgs];
         const exchange = takeOption(args, "--exchange");
-        const symbol = args[0];
-        if (!symbol) {
-          ctx.fail("Usage: gloomberb ticker <symbol>");
-        }
-        await ticker(symbol!, {
+        const symbol = requireOneArg(args, "ticker <symbol>", "symbol", ctx);
+        await ticker(symbol, {
           exchange,
           initMarketData: ctx.initMarketData,
           fail: ctx.fail,
@@ -128,7 +127,7 @@ function createCoreCliCommands(
         usage: ["catalog [query] [--all] [--bot-safe]"],
         options: [
           { flags: "--all", description: "List every match instead of the first 25" },
-          { flags: "--bot-safe", description: "Only functions with a verified unattended report" },
+          { flags: "--bot-safe, --botsafe", description: "Only functions with a verified unattended report" },
         ],
         examples: ["catalog", "catalog options", "catalog HP"],
       },
@@ -146,12 +145,17 @@ function createCoreCliCommands(
         options: [
           { flags: "--<option> <value>", description: "A function setting; gloomberb catalog <function> lists them" },
           { flags: "--require-bot-safe", description: "Fail unless the function has a verified, complete report" },
+          {
+            ...TABLE_SECTION_OPTION,
+            description: `${TABLE_SECTION_OPTION.description} (CALLS keeps --section for the transcript part)`,
+          },
           EXCHANGE_OPTION,
         ],
         examples: [
           "fn HP AAPL",
           "fn ANR SAN:EPA",
           "fn CBR --json",
+          "fn WEI --csv --section europe > europe.csv",
           "fn 13F AAPL --view=ticker-holdings",
           "fn OVME --spot 100 --strike 100 --days 30 --volatility 25",
         ],
@@ -354,6 +358,7 @@ export async function dispatchCli(args: string[], options: DispatchCliOptions =
   const target = helpOnly ? registry.lookup.get("help")! : resolved;
   const commandArgs = helpOnly ? [resolved.command.name] : parsed.args.slice(1);
   try {
+    if (!helpOnly && resolved.builtin) checkCliCommandOptions(resolved.command, commandArgs, parsed.literalStart - 1);
     const result = await target.command.execute(
       commandArgs,
       createCliCommandContext(target.ownerId, registry, parsed.options),

package/src/cli/options.ts

@@ -15,6 +15,8 @@ export interface ParsedCliArgs {
   options: CliGlobalOptions;
   /** `--help` or `-h` appeared before `--`. The flag is removed from args. */
   help: boolean;
+  /** Index in `args` where the arguments after a bare `--` begin; they are never options. */
+  literalStart: number;
 }
 
 export function isCliHelpFlag(arg: string): boolean {
@@ -43,10 +45,12 @@ export function parseCliGlobalArgs(rawArgs: string[]): ParsedCliArgs {
   const options: CliGlobalOptions = { ...DEFAULT_CLI_OPTIONS };
   const args: string[] = [];
   let help = false;
+  let literalStart: number | null = null;
 
   for (let index = 0; index < rawArgs.length; index += 1) {
     const arg = rawArgs[index]!;
     if (arg === "--") {
+      literalStart = args.length;
       args.push(...rawArgs.slice(index + 1));
       break;
     }
@@ -102,5 +106,5 @@ export function parseCliGlobalArgs(rawArgs: string[]): ParsedCliArgs {
     args.push(arg);
   }
 
-  return { args, options, help };
+  return { args, options, help, literalStart: literalStart ?? args.length };
 }

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

@@ -134,6 +134,11 @@ function resolveOptionDef(
   ));
 }
 
+/** Whether the function has an option of its own under this name or an alias. */
+export function capabilityHasOption(capability: PaneFunctionCapability, key: string): boolean {
+  return resolveOptionDef(capability, key) !== undefined;
+}
+
 function normalizeEnumValue(option: PaneFunctionOptionDef, rawValue: string): string {
   const token = optionToken(rawValue);
   const match = option.values?.find((candidate) => (

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

@@ -7,6 +7,7 @@ import type { ResolvedPaneFunction } from "./resolver";
 import { collectShotSymbols } from "./data";
 import { renderDesktopShot, type PaneScreenshotResult } from "./screenshot";
 import { deriveRenderedFreshness, formatFreshnessLine, type ReportFreshness } from "./freshness";
+import { exportTextTable, reportFooterLines, type CliReportTables } from "../report-tables";
 
 const DOM_REPORT_WIDTH = 1280;
 const DOM_REPORT_HEIGHT = 720;
@@ -42,7 +43,13 @@ function cellText(cell: DesktopPaneShotRenderedRow["cells"][number]): string {
   return cell.instant ? formatUtcTime(cell.instant) || cell.text : cell.text;
 }
 
-function renderDomTables(rows: DesktopPaneShotRenderedRow[]): string[] {
+interface DomTable {
+  tableIndex: number;
+  columns: Array<{ key: string; header: string }>;
+  rows: Array<Map<string, DesktopPaneShotRenderedRow["cells"][number]>>;
+}
+
+function domTables(rows: DesktopPaneShotRenderedRow[]): DomTable[] {
   const byTable = new Map<number, DesktopPaneShotRenderedRow[]>();
   for (const row of rows) {
     const tableRows = byTable.get(row.tableIndex) ?? [];
@@ -50,7 +57,7 @@ function renderDomTables(rows: DesktopPaneShotRenderedRow[]): string[] {
     byTable.set(row.tableIndex, tableRows);
   }
 
-  return [...byTable.entries()].flatMap(([tableIndex, tableRows], index) => {
+  return [...byTable.entries()].map(([tableIndex, tableRows]) => {
     // Captured rows omit blank cells, so a cell's position is not its column.
     const columns: Array<{ key: string; header: string }> = [];
     for (const row of tableRows) {
@@ -66,22 +73,54 @@ function renderDomTables(rows: DesktopPaneShotRenderedRow[]): string[] {
         previous = position;
       }
     }
-    const output = renderTable(
+    return {
+      tableIndex,
       columns,
-      tableRows.map((row) => {
+      rows: tableRows.map((row) => {
         const keys = domCellKeys(row);
-        const textByKey = new Map(row.cells.map((cell, cellIndex) => [keys[cellIndex]!, cellText(cell)]));
-        return columns.map((column) => textByKey.get(column.key) ?? "");
+        return new Map(row.cells.map((cell, cellIndex) => [keys[cellIndex]!, cell]));
       }),
-    );
-    return [
-      ...(index > 0 ? [""] : []),
-      ...(byTable.size > 1 ? [renderSection(`Rendered table ${tableIndex + 1}`)] : []),
-      output,
-    ];
+    };
   });
 }
 
+function domTableTitle(table: DomTable): string {
+  return `Rendered table ${table.tableIndex + 1}`;
+}
+
+function renderDomTables(rows: DesktopPaneShotRenderedRow[]): string[] {
+  const tables = domTables(rows);
+  return tables.flatMap((table, index) => [
+    ...(index > 0 ? [""] : []),
+    ...(tables.length > 1 ? [renderSection(domTableTitle(table))] : []),
+    renderTable(
+      table.columns,
+      table.rows.map((cells) => table.columns.map((column) => {
+        const cell = cells.get(column.key);
+        return cell ? cellText(cell) : "";
+      })),
+    ),
+  ]);
+}
+
+/** The rendered tables as `--csv` writes them, with the instant behind a shortened time. */
+function domReportTables(
+  rows: DesktopPaneShotRenderedRow[],
+  title: string,
+  freshness: ReportFreshness,
+  incomplete: boolean | string,
+): CliReportTables {
+  const tables = domTables(rows);
+  return {
+    tables: tables.map((table) => exportTextTable(
+      tables.length > 1 ? domTableTitle(table) : title,
+      table.columns.map((column) => column.header),
+      table.rows.map((cells) => table.columns.map((column) => cells.get(column.key))),
+    )),
+    footer: reportFooterLines({ freshness, incomplete }),
+  };
+}
+
 function renderedFailureReason(
   result: PaneScreenshotResult,
   rows: DesktopPaneShotRenderedRow[],
@@ -144,6 +183,7 @@ export function buildDomPaneReportFromRender(
     cellTimes: rows.flatMap((row) => row.cells.flatMap((cell) => cell.instant ?? [])),
   });
 
+  const complete = failureReason === null && !truncated;
   return {
     data: {
       kind: "rendered-view",
@@ -153,7 +193,7 @@ export function buildDomPaneReportFromRender(
       options: resolved.options,
       rowCount: rows.length,
       empty: rows.length === 0,
-      complete: failureReason === null && !truncated,
+      complete,
       unavailableSymbols,
       rows,
       visibleText: result.render.visibleText,
@@ -164,6 +204,12 @@ export function buildDomPaneReportFromRender(
       freshness,
     },
     text: textLines.join("\n").trimEnd(),
+    tables: domReportTables(
+      rows,
+      resolved.label,
+      freshness,
+      !complete && (failureReason ?? (truncationReasons.length > 0 ? truncationReasons.join("; ") : true)),
+    ),
   };
 }
 
@@ -173,15 +219,20 @@ export function appendDomReportFooter(
   truncated: boolean,
   freshness: ReportFreshness,
 ): string {
-  const clipping = truncated ? "The rendered view is clipped." : "The rendered view may be clipped.";
   return [
     text,
     "",
-    `Rendered view: values come from the visible pane. ${clipping} Render time: ${elapsedMs} ms.`,
+    domReportNote(elapsedMs, truncated),
     cliStyles.muted(formatFreshnessLine(freshness)),
   ].join("\n");
 }
 
+/** What a rendered-view report says about where its values come from. */
+export function domReportNote(elapsedMs: number, truncated: boolean): string {
+  const clipping = truncated ? "The rendered view is clipped." : "The rendered view may be clipped.";
+  return `Rendered view: values come from the visible pane. ${clipping} Render time: ${elapsedMs} ms.`;
+}
+
 function failedDomReport(
   resolved: ResolvedPaneFunction,
   rawArg: string,
@@ -193,6 +244,7 @@ function failedDomReport(
     .trim();
   const reason = `The rendered view could not be read: ${message || "unknown renderer error"}`;
   const symbols = collectShotSymbols(resolved, rawArg);
+  const freshness = deriveRenderedFreshness(resolved.pane.reportFreshness, { footerText: "", cellTimes: [] });
   return {
     data: {
       kind: "rendered-view",
@@ -210,9 +262,10 @@ function failedDomReport(
       truncationReasons: [],
       limitation: DOM_LIMITATION,
       reason,
-      freshness: deriveRenderedFreshness(resolved.pane.reportFreshness, { footerText: "", cellTimes: [] }),
+      freshness,
     },
     text: [resolved.label, "", reason].join("\n"),
+    tables: { tables: [], footer: reportFooterLines({ freshness, incomplete: reason }) },
   };
 }
 

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

@@ -81,6 +81,8 @@ const SEARCH = key("/", "search");
 const OPEN_SOURCE = key("o", "pen source");
 const POP_OUT = key("p", "op out");
 const STEP = key("←/→", " step");
+/** THEM and MEMB members: open them in RRG, CORR, SIW or RIPL, or save them as a watchlist. */
+const MEMBERS_MENU = key(".", " open members in, save as watchlist");
 const CHART_KEYS = [key("s", "eries"), key("i", "ndicators"), key("t", "imeframe"), key("f", "ormulas")];
 
 export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
@@ -663,14 +665,14 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
   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"],
-    keys: [TABS, OPEN],
+    keys: [TABS, OPEN, MEMBERS_MENU],
     data: same("Dated fund holdings and partial delayed member returns. Nasdaq-100 is not covered."),
     bloomberg: ["MEMB", "MRR", "IMOV"],
   },
   THEM: {
     summary: "Curated thematic baskets with equal-weight returns and breadth. Open a theme to see its members, leaders and laggards. The Themes tab of BI.",
     usage: ["THEM", "THEM nuclear"],
-    keys: [TABS, OPEN, key("Esc", "back")],
+    keys: [TABS, OPEN, key("Esc", "back"), MEMBERS_MENU],
     data: same("Updated every 15 minutes"),
     bloomberg: ["IMAP", "custom baskets"],
   },