gloomberb 0.16.2 → 0.16.4

package/src/cli/not-a-ticker.ts

@@ -0,0 +1,37 @@
+import { notATickerSymbol } from "../sources/provider-errors";
+
+// "Not a ticker: APPLE." as the router words it; the symbol ends at the sentence's own period.
+const NOT_A_TICKER_SENTENCE = /Not a ticker: ((?:(?!\.\s)[^\n`\x1b])+?)\.(?=\s|\x1b|$)(?! Try `gloomberb search)/g;
+
+/** The symbol as the user typed it on the command line (`Apple`), not as the router saw it (`APPLE`). */
+function typedSymbol(symbol: string, args: readonly string[]): string {
+  const wanted = symbol.toUpperCase();
+  for (const arg of args) {
+    for (const part of arg.split(",")) {
+      const typed = part.trim().replace(/^\$/, "");
+      if (typed.toUpperCase() === wanted) return typed;
+    }
+  }
+  return symbol;
+}
+
+/** "Try `gloomberb search Apple`." naming what the user typed; a venue (`Apple:NYSE`) is not part of a search. */
+function searchHint(typed: string): string {
+  const query = typed.split(":")[0]!.trim() || typed;
+  return `Try \`gloomberb search ${/\s/.test(query) ? JSON.stringify(query) : query}\`.`;
+}
+
+/**
+ * Adds the search hint after each "Not a ticker: APPLE." in text meant for a person. The router
+ * only knows the symbol upper-cased, so the hint reads the user's own spelling from `args`.
+ */
+export function withSearchHints(text: string, args: readonly string[]): string {
+  return text.includes("Not a ticker: ")
+    ? text.replace(NOT_A_TICKER_SENTENCE, (sentence, symbol: string) => `${sentence} ${searchHint(typedSymbol(symbol, args))}`)
+    : text;
+}
+
+/** Whether an error message says the symbol is not a ticker. */
+export function isNotATickerMessage(message: string | null | undefined): boolean {
+  return message != null && notATickerSymbol(message) !== null;
+}

package/src/cli/options.ts

@@ -5,6 +5,10 @@ export interface CliGlobalOptions {
   quiet: boolean;
   color: boolean | null;
   limit?: number;
+  /** `--tail <n>`: the newest n rows of a dated series, in their printed order. Never set with `limit`. */
+  tail?: number;
+  /** `--width <n>`: fit tables to n columns. Unset, a terminal's own width fits them and piped output is not fitted. */
+  width?: number;
   refresh: boolean;
   dryRun: boolean;
   yes: boolean;
@@ -15,6 +19,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 {
@@ -30,23 +36,49 @@ export const DEFAULT_CLI_OPTIONS: CliGlobalOptions = {
   yes: false,
 };
 
-function parseLimit(value: string | undefined): number {
-  if (!value) throw new Error("Missing value for --limit.");
+function parseRowCount(flag: "--limit" | "--tail", value: string | undefined): number {
+  if (!value) throw new Error(`Missing value for ${flag}.`);
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1) {
-    throw new Error("--limit must be a positive integer.");
+    throw new Error(`${flag} must be a positive integer.`);
   }
   return parsed;
 }
 
+/** Commands whose own `--width` is a size in pixels, so it is not the table width. */
+const PIXEL_WIDTH_COMMANDS = new Set(["shot", "screenshot"]);
+const MIN_TABLE_WIDTH = 20;
+
+function parseColumnCount(value: string | undefined): number {
+  const parsed = Number(value);
+  if (!value || !Number.isInteger(parsed) || parsed < MIN_TABLE_WIDTH) {
+    throw new Error(`--width must be a whole number of columns, ${MIN_TABLE_WIDTH} or more, such as --width 80.`);
+  }
+  return parsed;
+}
+
+/** The first word that is not an option or the value of one: the command the arguments are for. */
+function commandWord(rawArgs: readonly string[]): string | undefined {
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index]!;
+    if (arg === "--") return rawArgs[index + 1];
+    if (arg === "--limit" || arg === "--tail" || arg === "--width") index += 1;
+    else if (!arg.startsWith("-")) return arg;
+  }
+  return undefined;
+}
+
 export function parseCliGlobalArgs(rawArgs: string[]): ParsedCliArgs {
   const options: CliGlobalOptions = { ...DEFAULT_CLI_OPTIONS };
   const args: string[] = [];
   let help = false;
+  let literalStart: number | null = null;
+  const ownsWidth = PIXEL_WIDTH_COMMANDS.has(commandWord(rawArgs)?.toLowerCase() ?? "");
 
   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;
     }
@@ -90,17 +122,33 @@ export function parseCliGlobalArgs(rawArgs: string[]): ParsedCliArgs {
       options.yes = true;
       continue;
     }
-    if (arg === "--limit") {
+    if (!ownsWidth && arg === "--width") {
       index += 1;
-      options.limit = parseLimit(rawArgs[index]);
+      options.width = parseColumnCount(rawArgs[index]);
+      continue;
+    }
+    if (!ownsWidth && arg.startsWith("--width=")) {
+      options.width = parseColumnCount(arg.slice("--width=".length));
+      continue;
+    }
+    if (arg === "--limit" || arg === "--tail") {
+      index += 1;
+      options[arg === "--limit" ? "limit" : "tail"] = parseRowCount(arg, rawArgs[index]);
       continue;
     }
     if (arg.startsWith("--limit=")) {
-      options.limit = parseLimit(arg.slice("--limit=".length));
+      options.limit = parseRowCount("--limit", arg.slice("--limit=".length));
+      continue;
+    }
+    if (arg.startsWith("--tail=")) {
+      options.tail = parseRowCount("--tail", arg.slice("--tail=".length));
       continue;
     }
     args.push(arg);
   }
+  if (options.limit != null && options.tail != null) {
+    throw new Error("Use --limit or --tail, not both: --limit keeps the first rows, --tail the newest.");
+  }
 
-  return { args, options, help };
+  return { args, options, help, literalStart: literalStart ?? args.length };
 }

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

@@ -9,6 +9,7 @@ import type {
 export type PaneFunctionReadiness = "ready" | "partial" | "live-dom" | "unsupported";
 type PaneFunctionScreenshotReadiness = PaneFunctionReadiness;
 type PaneFunctionTickerCardinality = "none" | "one" | "one-or-more" | "two-or-more" | "one-or-two";
+/** A headless option, or a rendered view's, which may name its value, show an example and check what is typed. */
 export type PaneFunctionOptionDef = HeadlessPaneOptionDef;
 export type NormalizedPaneFunctionOptions = Record<string, string | number | boolean>;
 
@@ -64,7 +65,7 @@ function fallbackCapability(
     limitations: [dataPane
       ? RENDERED_VIEW_LIMITATION
       : "This pane is an interactive surface and does not expose a data report."],
-    options: [],
+    options: [...(pane.reportOptions ?? [])],
   };
 }
 
@@ -134,6 +135,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) => (
@@ -154,6 +160,7 @@ function normalizeOptionValue(option: PaneFunctionOptionDef, rawValue: string |
     throw new Error(`Invalid --${option.key} value "${rawValue}". Use true or false.`);
   }
   if (rawValue === true) throw new Error(`--${option.key} requires a value.`);
+  if (option.normalize) return option.normalize(rawValue);
   if (option.type === "enum") return normalizeEnumValue(option, rawValue);
   if (option.type === "integer") {
     const value = Number(rawValue);
@@ -175,7 +182,11 @@ export function normalizeCapabilityOptions(
   settings: { strict?: boolean } = {},
 ): NormalizedPaneFunctionOptions {
   if (!capability.botSafe) {
-    return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, value]));
+    // A rendered view takes any pane setting; the options it declares are checked.
+    return Object.fromEntries(Object.entries(options).map(([key, value]) => {
+      const option = resolveOptionDef(capability, key);
+      return option ? [option.key, normalizeOptionValue(option, value)] : [key, value];
+    }));
   }
 
   const normalized: Record<string, string | number | boolean> = {};

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

@@ -259,6 +259,11 @@ function paneCatalogSearchScore(entry: PaneCatalogEntry, query: string): number
   ].filter((value): value is string => !!value).join(" ").toLowerCase();
 
   let score = searchable.includes(query.toLowerCase()) ? 12 : 0;
+  // A query that is one of the function's own keywords ("hedge" for OSA) beats one found inside a
+  // longer keyword ("hedge funds" for 13F).
+  const keywords = [entry.label, ...entry.keywords, ...entry.capability.aliases]
+    .filter((value): value is string => !!value).map((value) => value.toLowerCase().replace(/\s+/g, " "));
+  if (keywords.includes(terms.join(" "))) score += 4;
   let matchedTerms = 0;
   for (const term of terms) {
     const normalized = normalizeLookupToken(term);
@@ -320,7 +325,8 @@ function optionChoices(option: PaneFunctionOptionDef): string[] {
 
 function optionFlags(option: PaneFunctionOptionDef): string {
   const choices = optionChoices(option).join("|");
-  return `--${option.key} <${choices && choices.length <= MAX_INLINE_CHOICES ? choices : option.values?.length ? "value" : option.type}>`;
+  const value = choices && choices.length <= MAX_INLINE_CHOICES ? choices : option.values?.length ? "value" : option.placeholder ?? option.type;
+  return `--${option.key} <${value}>`;
 }
 
 function optionDescription(option: PaneFunctionOptionDef): string {
@@ -365,7 +371,12 @@ function renderCatalogEntry(entry: PaneCatalogEntry): string {
   }
 
   lines.push("", renderSection("Examples"));
-  if (capability.reportReadiness !== "unsupported") lines.push(...wrapCommandLine(`gloomberb fn ${invocation}`, width));
+  if (capability.reportReadiness !== "unsupported") {
+    lines.push(...wrapCommandLine(`gloomberb fn ${invocation}`, width));
+    for (const option of capability.options) {
+      if (option.example) lines.push(...wrapCommandLine(`gloomberb fn ${invocation} ${option.example}`, width));
+    }
+  }
   lines.push(...wrapCommandLine(`gloomberb shot ${invocation} --output ${entry.token.toLowerCase()}.png`, width));
   return lines.join("\n");
 }

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

@@ -9,6 +9,7 @@ import { cleanTickerInput } from "./options";
 import { parsePublicTickerKey, publicTickerKey } from "../../utils/exchanges";
 import type { ResolvedPaneFunction } from "./resolver";
 import { toMarketDataContext } from "../../market-data/selectors";
+import { quoteMetadataFromQuote } from "../../market-data/quotes/metadata";
 import { loadSeasonalityHistory, SEASONALITY_HISTORY_RESOLUTION } from "../../plugins/builtin/seasonality/client";
 import type { InstrumentRef } from "../../market-data/request-types";
 import { CORRELATION_HISTORY_RESOLUTION, loadCorrelationHistory } from "../../plugins/builtin/correlation/history";
@@ -22,6 +23,26 @@ const SHOT_PRICE_HISTORY_RANGE = "5Y" as const;
 const FINANCIAL_ANALYSIS_PANE_ID = "financial-analysis";
 const FINANCIAL_ANALYSIS_TEMPLATE_ID = "financial-analysis-pane";
 
+async function loadStoredShotTicker(context: MarketContext, symbol: string): Promise<TickerRecord | null> {
+  const normalized = cleanTickerInput(symbol);
+  const { symbol: bare } = parsePublicTickerKey(normalized);
+  return await context.store.loadTicker(normalized)
+    ?? (bare !== normalized ? await context.store.loadTicker(bare) : null);
+}
+
+/**
+ * A holding the pane can value without a quote: some position carries the
+ * broker's own mark or market value. An option contract no quote covers stays
+ * at that mark in the pane, so a failed quote lookup for it is not an error.
+ */
+export async function loadBrokerMarkedHolding(context: MarketContext, symbol: string): Promise<TickerRecord | null> {
+  const ticker = await loadStoredShotTicker(context, symbol);
+  const marked = ticker?.metadata.positions.some(({ shares, markPrice, marketValue }) => (
+    shares !== 0 && (Number.isFinite(markPrice) || Number.isFinite(marketValue))
+  ));
+  return marked ? ticker : null;
+}
+
 export async function fetchTickerFinancials(
   context: MarketContext,
   symbol: string,
@@ -32,8 +53,7 @@ export async function fetchTickerFinancials(
 }> {
   const normalized = cleanTickerInput(symbol);
   const instrument = parsePublicTickerKey(normalized);
-  const tickerFile = await context.store.loadTicker(normalized)
-    ?? (instrument.symbol !== normalized ? await context.store.loadTicker(instrument.symbol) : null);
+  const tickerFile = await loadStoredShotTicker(context, symbol);
   const exchange = instrument.exchange ?? tickerFile?.metadata.exchange ?? "";
   const financials = await context.dataProvider.getTickerFinancials(instrument.symbol, exchange);
   return { tickerFile, financials, instrument: { symbol: instrument.symbol, ...(exchange ? { exchange } : {}) } };
@@ -142,14 +162,25 @@ export function isFinancialAnalysisFunction(resolved: ResolvedPaneFunction): boo
     && resolved.instance.settings?.lockedTabId === "financials";
 }
 
-export function createFallbackTicker(symbol: string, financials: TickerFinancials | null, context: MarketContext): TickerRecord {
+/**
+ * The ticker a shot shows for a symbol that is not saved. Without a usable
+ * quote (a thin US listing after the close), the listing comes from the quote
+ * metadata kept when the quote was dropped, or else from asking the source
+ * for it, so the pane still knows a US stock from a listing abroad. What no
+ * source knows stays empty rather than guessed from the base currency.
+ */
+export async function createFallbackTicker(symbol: string, financials: TickerFinancials | null, context: MarketContext): Promise<TickerRecord> {
   const instrument = parsePublicTickerKey(symbol);
   const quote = financials?.quote;
+  const known = quote ? quoteMetadataFromQuote(quote) : financials?.quoteMetadata;
+  const listing = instrument.exchange || known?.listingExchangeName
+    ? known
+    : await context.dataProvider.getQuoteMetadata?.(instrument.symbol, "").catch(() => null) ?? known;
   return {
     metadata: {
       ticker: instrument.symbol,
-      exchange: instrument.exchange ?? quote?.listingExchangeName ?? quote?.exchangeName ?? "",
-      currency: quote?.currency ?? context.config.baseCurrency,
+      exchange: instrument.exchange ?? listing?.listingExchangeName ?? "",
+      currency: listing?.currency ?? "",
       name: quote?.name ?? instrument.symbol,
       portfolios: [],
       watchlists: [],

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

@@ -7,6 +7,8 @@ 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";
+import { renderedReportFreshness, renderedReportNotices, renderedReportObservations } from "./report-notices";
 
 const DOM_REPORT_WIDTH = 1280;
 const DOM_REPORT_HEIGHT = 720;
@@ -17,12 +19,6 @@ function rowsContainEllipsis(rows: DesktopPaneShotRenderedRow[]): boolean {
   return rows.some((row) => row.cells.some((cell) => /\u2026|\.\.\./.test(cell.text)));
 }
 
-function isDomReportTruncated(
-  render: Pick<PaneScreenshotResult["render"], "rows" | "truncated">,
-): boolean {
-  return render.truncated || rowsContainEllipsis(render.rows);
-}
-
 /** Column identity per cell; a repeated label within one row stays distinct. */
 function domCellKeys(row: DesktopPaneShotRenderedRow): string[] {
   const seen = new Map<string, number>();
@@ -42,7 +38,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 +52,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 +68,55 @@ 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,
+  notices: readonly 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, notes: notices }),
+  };
+}
+
 function renderedFailureReason(
   result: PaneScreenshotResult,
   rows: DesktopPaneShotRenderedRow[],
@@ -99,8 +134,10 @@ function renderedFailureReason(
   return null;
 }
 
+/** The rows a report reads: every row of a table that publishes them all, else what the viewport shows. */
 function reportRows(result: PaneScreenshotResult): DesktopPaneShotRenderedRow[] {
-  if (result.render.rows.length > 0) return result.render.rows;
+  const rows = result.render.reportRows ?? result.render.rows;
+  if (rows.length > 0) return rows;
   if (
     result.render.loadingStateDetected
     || result.render.errorStateDetected
@@ -122,15 +159,20 @@ export function buildDomPaneReportFromRender(
   result: PaneScreenshotResult,
 ): PaneFunctionReport {
   const rows = reportRows(result);
-  const hasStructuredRows = result.render.rows.length > 0;
-  const truncated = isDomReportTruncated({ ...result.render, rows });
-  const truncationReasons = [...result.render.truncationReasons];
+  const hasStructuredRows = (result.render.reportRows ?? result.render.rows).length > 0;
+  // A table that reported every row is whole, whatever the viewport cut from the capture.
+  const truncationReasons = [...(result.render.reportTruncationReasons ?? result.render.truncationReasons)];
   if (rowsContainEllipsis(rows) && !truncationReasons.includes("one or more cells are visibly clipped")) {
     truncationReasons.push("one or more cells are visibly clipped");
   }
+  const truncated = truncationReasons.length > 0
+    || (result.render.reportTruncationReasons ? false : result.render.truncated);
   const failureReason = renderedFailureReason(result, rows);
   const unavailableSymbols = failureReason && result.symbols.length > 0 ? result.symbols : [];
-  const textLines = [resolved.label, ""];
+  // What the view leaves out and how to see more: FXC's other currencies, OMON's strikes outside its window.
+  const rendered = renderedReportNotices(result.render.semanticUi ?? []);
+  const notices = [...(resolved.pane.reportNotices?.(resolved.instance.settings ?? {}) ?? []), ...rendered.notices];
+  const textLines = [resolved.label, "", ...notices, ...(notices.length > 0 ? [""] : [])];
   if (hasStructuredRows) {
     textLines.push(...renderDomTables(rows));
   } else if (result.render.visibleText) {
@@ -139,11 +181,15 @@ export function buildDomPaneReportFromRender(
     textLines.push(failureReason ?? "No rendered values were available.");
   }
   if (failureReason && rows.length > 0) textLines.push("", failureReason);
-  const freshness = deriveRenderedFreshness(resolved.pane.reportFreshness, {
+  // A pane that knows its feed dates the report; the footer and cell times fill in the rest.
+  const declared = { ...resolved.pane.reportFreshness, ...renderedReportFreshness(result.render.semanticUi ?? []) };
+  const freshness = deriveRenderedFreshness(declared, {
     footerText: result.render.footerText ?? "",
     cellTimes: rows.flatMap((row) => row.cells.flatMap((cell) => cell.instant ?? [])),
+    observed: renderedReportObservations(result.render.semanticUi ?? []),
   });
 
+  const complete = failureReason === null && !truncated;
   return {
     data: {
       kind: "rendered-view",
@@ -153,7 +199,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,
@@ -161,9 +207,17 @@ export function buildDomPaneReportFromRender(
       truncationReasons,
       limitation: DOM_LIMITATION,
       ...(failureReason ? { reason: failureReason } : {}),
+      ...(notices.length > 0 ? { metadata: { ...rendered.facts, notices } } : {}),
       freshness,
     },
     text: textLines.join("\n").trimEnd(),
+    tables: domReportTables(
+      rows,
+      resolved.label,
+      freshness,
+      !complete && (failureReason ?? (truncationReasons.length > 0 ? truncationReasons.join("; ") : true)),
+      notices,
+    ),
   };
 }
 
@@ -173,15 +227,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 +252,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 +270,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 }) },
   };
 }