gloomberb 0.18.3 → 0.18.4

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

@@ -1,2122 +0,0 @@
-import { logFailure } from "../../utils/log-failure";
-import { isNoSourceAnswer } from "../../sources/provider-errors";
-import { fetchTape } from "../../plugins/builtin/time-sales/client";
-import { captureScannerEvent, SCANNER_PANE_KINDS, type ScannerCapture } from "../../plugins/builtin/shared/scanner-capture";
-import { isOptionsUnavailableError } from "../../market-data/options-alternatives";
-import type { TapeCapture } from "../../plugins/builtin/time-sales/snapshot-client";
-import { apiClient } from "../../api-client";
-import { snapshotInstrumentKey, type SnapshotMarketData } from "../../market-data/snapshot-provider";
-import { toMarketDataContext } from "../../market-data/selectors";
-import type { ChartPaneModel } from "../../plugins/builtin/chart-composer/headless";
-import { buildHeadlessPaneLoadArgs, loadResolvedHeadlessPaneModel, reportCoverage, reportGaps, type LoadedHeadlessPaneModel } from "./headless";
-import { dirname, resolve } from "path";
-import { mkdir } from "fs/promises";
-import type { PaneRuntimeState } from "../../core/state/app/state";
-import { CHART_COMPOSER_PANE_ID, type AppConfig } from "../../types/config";
-import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../../types/financials";
-import type { TickerRecord } from "../../types/ticker";
-import { slugifyName } from "../../utils/slugify";
-import {
-  readRequestInit,
-  toResponseEnvelope,
-  type HttpProxyRequestEnvelope,
-  type HttpProxyResponseEnvelope,
-} from "../../utils/http-proxy-response";
-import { requireThemeId } from "../commands/themes";
-import { isRecord } from "../../utils/guards";
-
-const DEFAULT_SHOT_DEVICE_SCALE_FACTOR = 2;
-import {
-  renderDesktopPaneScreenshot,
-  type DesktopPaneShotApiProxy,
-  type DesktopPaneShotBridge,
-  type DesktopPaneShotIntradayHistory,
-  type DesktopPaneShotPayload,
-  type DesktopPaneShotRenderResult,
-} from "../desktop-pane-shot";
-import { optionPaneState, SHOT_SIZE_LIMITS, type ShotSizeClamp } from "./options";
-import type { ResolvedPaneFunction } from "./resolver";
-import type { MarketContext } from "../types";
-import { capabilityPluginState, findCapabilityOption } from "./capabilities";
-import { resolvePersistedCloudSessionToken } from "./cloud-session";
-import type { RemoteUiNodeSnapshot } from "../../remote/types";
-import {
-  graphRowsForFinancials,
-  limitGraphRowsBySymbol,
-  metricDef,
-} from "../../time-series/reporting";
-import { getTimeSeriesField } from "../../time-series/field-catalog";
-import {
-  buildFinancialTableModel,
-  financialStatementCurrency,
-  formatFinancialHeader,
-} from "../../plugins/builtin/ticker-detail/financials/model";
-import type {
-  FundamentalPeriod,
-  GraphKind,
-  GraphMetricKey,
-} from "../../time-series/reporting";
-import type { TimeRange } from "../../time-series/range";
-import { appendLiveQuotePoint } from "../../time-series/chart-data";
-import { subtractTimeRange } from "../../time-series/date-window";
-import {
-  buildPresetDateWindow,
-  getVisibleWindowForDateRange,
-} from "../../components/chart/core/date-window";
-import { parseChartSpec } from "../../plugins/builtin/chart-composer/chart-spec";
-import {
-  defaultValuationSeriesLoader,
-  requiredSeries as valuationRequiredSeries,
-} from "../../plugins/builtin/market-valuation/client";
-import type { DatedObservation } from "../../plugins/builtin/market-valuation/series";
-import { defaultStatLoader } from "../../plugins/builtin/econ-statistics/client";
-import { STATS } from "../../plugins/builtin/econ-statistics/stats";
-import { parsePublicTickerKey, publicTickerKey } from "../../utils/exchanges";
-import { getCloudApiBaseUrl } from "../../api-client/request";
-import { collectExternalPluginBundles } from "../../renderers/electrobun/bun/external-plugins";
-import type { ResolvedSeries } from "../../time-series/types";
-import { getQuoteMonitorPaneSettings } from "../../plugins/builtin/ticker-detail/settings";
-import { isNotATickerMessage } from "../not-a-ticker";
-import { HISTORY_DEFAULT_RANGE } from "../../plugins/builtin/ticker-detail/data-panes/history-bars";
-import { accessGateSentence, accessGateStatus } from "./access-gate";
-import { findCollection } from "../../plugins/builtin/portfolio-list/cli/render";
-import { peekCachedBrokerAccounts } from "../../plugins/builtin/portfolio-list/cached-account";
-import {
-  paneEvidenceMismatches,
-  paneScreenshotEvidenceHook,
-  renderedPaneEvidence,
-  type PaneScreenshotEvidence,
-} from "./screenshot-evidence";
-import {
-  collectShotSymbols,
-  clipPriceHistoryToRange,
-  createFallbackTicker,
-  fetchTickerFinancials,
-  loadBrokerMarkedHolding,
-  loadStoredShotTicker,
-  isFinancialAnalysisFunction,
-  readsDailyReturns,
-  withShotDailyReturns,
-  withShotPeriodEndHistory,
-  withShotPriceHistory,
-  withShotReturnHistory,
-  withShotSeasonalityHistory,
-} from "./data";
-import { declaredReportFreshness, renderedReportFreshness, renderedReportNotices, renderedReportObservations } from "./report-notices";
-import { captureStatusLine, deriveCaptureReport, deriveHeadlessFreshness, deriveRenderedFreshness, type CaptureReport, type CaptureStatusLine, type ReportFreshness } from "./freshness";
-import { quotesFreshness } from "../freshness";
-import {
-  financialRatioRenderMismatches,
-  financialRatioShotEvidence,
-  financialRatioShotGap,
-  shotRatioTab,
-  type PaneScreenshotFinancialRatioEvidence,
-} from "./financial-ratio-shot";
-
-const DESKTOP_CELL_WIDTH_PX = 8;
-const DESKTOP_CELL_HEIGHT_PX = 18;
-const OPTIONS_PANE_ID = "options";
-const MARKET_VALUATION_PANE_ID = "market-valuation";
-const ECON_STATISTICS_PANE_ID = "econ-statistics";
-const CREDENTIAL_FIELD_NAMES = new Set([
-  "accesstoken",
-  "accessurl",
-  "apikey",
-  "apisecret",
-  "authorization",
-  "cookie",
-  "credentials",
-  "oauth",
-  "passphrase",
-  "password",
-  "privatekey",
-  "refreshtoken",
-  "secret",
-  "sessiontoken",
-  "token",
-]);
-
-/**
- * The proxy receives the desktop session out of band. Keeping this separate
- * from DesktopPaneShotPayload prevents the token from entering the page,
- * semantic evidence, or JSON CLI output.
- */
-function isCredentialField(key: string): boolean {
-  const normalized = key.replace(/[^a-z0-9]/gi, "").toLowerCase();
-  return CREDENTIAL_FIELD_NAMES.has(normalized)
-    || normalized.endsWith("password")
-    || normalized.endsWith("passphrase")
-    || normalized.endsWith("secret")
-    || normalized.endsWith("token")
-    || normalized.endsWith("credential")
-    || normalized.endsWith("cookie")
-    || normalized.endsWith("apikey")
-    || normalized.endsWith("accesskey")
-    || normalized.endsWith("privatekey")
-    || normalized.endsWith("authorization")
-    || normalized.endsWith("accessurl");
-}
-
-/** Removes credential-shaped object fields before data enters the page or JSON output. */
-export function stripDesktopShotCredentials<T>(value: T): T {
-  if (Array.isArray(value)) {
-    return value.map((entry) => stripDesktopShotCredentials(entry)) as T;
-  }
-  if (!value || typeof value !== "object" || value instanceof Date) return value;
-  const clean: Record<string, unknown> = {};
-  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
-    if (isCredentialField(key)) continue;
-    clean[key] = stripDesktopShotCredentials(entry);
-  }
-  return clean as T;
-}
-
-export function resolveDesktopShotApiProxy(
-  context: Pick<MarketContext, "persistence">,
-): DesktopPaneShotApiProxy {
-  return {
-    baseUrl: getCloudApiBaseUrl(),
-    sessionToken: resolvePersistedCloudSessionToken(context),
-  };
-}
-
-/**
- * Data the page may request while it renders. The cloud API is only one of the
- * router's sources, so calling it directly from the page dropped whatever
- * another provider contributes: analyst rating price targets came back empty
- * and corporate actions vanished whenever the cloud leg failed. Quotes are
- * here for board panes that list symbols the payload was never built for.
- * These run on the Bun side through the same router `gloomberb fn` uses.
- */
-const SHOT_BRIDGE_MARKET_OPERATIONS = new Set([
-  "getAnalystResearch",
-  "getCorporateActions",
-  "getEarningsCalendar",
-  "getHolders",
-  "getOptionsChain",
-  "getCloudTape",
-  "getPriceHistory",
-  "getPriceHistoryForResolution",
-  "getQuote",
-  "getQuoteMetadata",
-  "getQuotesBatch",
-  "getSecFilingContent",
-  "getSecFilingDocuments",
-  "getSecFilings",
-]);
-
-const SHOT_BRIDGE_HTTP_TIMEOUT_MS = 20_000;
-
-export function createDesktopShotBridge(
-  context: Pick<MarketContext, "dataProvider">,
-  tapeBootstrap: typeof fetchTape = fetchTape,
-): DesktopPaneShotBridge {
-  return {
-    async marketData(operation, args) {
-      if (!SHOT_BRIDGE_MARKET_OPERATIONS.has(operation)) {
-        throw new Error(`Screenshot market bridge does not serve "${operation}".`);
-      }
-      if (operation === "getCloudTape") {
-        const [symbol, exchange] = args;
-        if (typeof symbol !== "string" || typeof exchange !== "string") throw new Error("Tape screenshots require a symbol and listing exchange.");
-        return tapeBootstrap(symbol, exchange);
-      }
-      const provider = context.dataProvider as unknown as Record<string, unknown>;
-      const handler = provider[operation];
-      if (typeof handler !== "function") {
-        throw new Error(`No provider available for ${operation}.`);
-      }
-      return await (handler as (...values: unknown[]) => Promise<unknown>).apply(
-        context.dataProvider,
-        args,
-      );
-    },
-    httpFetch: (request) => runDesktopShotHttpFetch(request),
-  };
-}
-
-/**
- * Panes such as DVD fetch a third-party API directly. A browser cannot: the
- * request is cross-origin and dies in CORS, so the pane reported that the
- * ticker pays no dividend. The desktop renderer already proxies these through
- * its native half; the screenshot page gets the same treatment.
- */
-async function runDesktopShotHttpFetch(
-  request: HttpProxyRequestEnvelope,
-): Promise<HttpProxyResponseEnvelope> {
-  const target = new URL(request.url);
-  if (target.protocol !== "http:" && target.protocol !== "https:") {
-    throw new Error(`Screenshot HTTP bridge refuses ${target.protocol} requests.`);
-  }
-  const { method, headers, body, redirect } = readRequestInit(request.init);
-  const response = await fetch(target, {
-    method,
-    headers,
-    body,
-    redirect,
-    signal: AbortSignal.timeout(SHOT_BRIDGE_HTTP_TIMEOUT_MS),
-  });
-  return toResponseEnvelope(response);
-}
-
-/** Same reason as the valuation legs: the renderer cannot fill its own cache. */
-async function collectShotStatSeries(
-  resolved: ResolvedPaneFunction,
-): Promise<Array<[string, DatedObservation[]]>> {
-  if (resolved.pane.id !== ECON_STATISTICS_PANE_ID) return [];
-  const loaded = await Promise.all(STATS.map(async (def) => {
-    try {
-      const result = await defaultStatLoader(def);
-      const observations = Array.isArray(result) ? result : result.observations;
-      return [def.seriesId, observations] as [string, DatedObservation[]];
-    } catch (error) {
-      logFailure("cli.screenshot", "Read screenshot statistics series failed")(error);
-      return null;
-    }
-  }));
-  return loaded.filter((entry): entry is [string, DatedObservation[]] => !!entry);
-}
-
-/**
- * The pane reads its legs from a client cache the shot renderer cannot fill itself,
- * so fetch them here on the Bun side and hand them over with the payload.
- */
-async function collectShotValuationSeries(
-  resolved: ResolvedPaneFunction,
-): Promise<Array<[string, DatedObservation[]]>> {
-  if (resolved.pane.id !== MARKET_VALUATION_PANE_ID) return [];
-  const loaded = await Promise.all(valuationRequiredSeries().map(async (def) => {
-    try {
-      const series = await defaultValuationSeriesLoader(def);
-      return [def.key, series.observations] as [string, DatedObservation[]];
-    } catch (error) {
-      logFailure("cli.screenshot", "Read screenshot valuation series failed")(error);
-      return null;
-    }
-  }));
-  return loaded.filter((entry): entry is [string, DatedObservation[]] => !!entry);
-}
-
-export interface PaneScreenshotExpectedSelection {
-  control: "metric" | "statement" | "ratio" | "period";
-  value?: string;
-  label?: string;
-}
-
-interface PaneScreenshotChartPointEvidence {
-  date: string;
-  close: number;
-}
-
-export interface PaneScreenshotChartSeriesEvidence {
-  symbol: string;
-  pointCount: number;
-  first: PaneScreenshotChartPointEvidence | null;
-  last: PaneScreenshotChartPointEvidence | null;
-  projectionBaseValue?: number | null;
-  projectionLatestRawValue?: number | null;
-  projectionLatestValue?: number | null;
-}
-
-export interface PaneScreenshotExpectedChartEvidence {
-  kind: "stock-price" | "price-comparison" | "chart-composer";
-  symbols: string[];
-  rangePreset: string;
-  axisMode?: string;
-  resolution?: string;
-  sourceSeries?: PaneScreenshotChartSeriesEvidence[];
-  baseSeries?: Array<{
-    id: string;
-    sourceKind: "security" | "economic" | "capability";
-    symbol?: string;
-    fieldId?: string;
-    economicSeriesId?: string;
-    capabilityId?: string;
-    providerSeriesId?: string;
-    first?: { date: string; value: number | null } | null;
-    last?: { date: string; value: number | null } | null;
-    style: string;
-    transform: string;
-    panelId: string;
-    visible: boolean;
-  }>;
-}
-
-interface PaneScreenshotPriceComparisonEvidence {
-  kind: "price-comparison";
-  symbols: string[];
-  range: string;
-  series: Array<{
-    symbol: string;
-    base: { date: string; value: number };
-    latest: { date: string; value: number };
-    returnPercent: number;
-  }>;
-}
-
-interface PaneScreenshotPriceSeriesEvidence {
-  kind: "price-series";
-  symbol: string;
-  range: string;
-  pointCount: number;
-  first: PaneScreenshotChartPointEvidence;
-  last: PaneScreenshotChartPointEvidence;
-  resolution?: string;
-  sessionDates?: string[];
-}
-
-interface PaneScreenshotFundamentalSeriesEvidence {
-  kind: "fundamental-series";
-  metric: string;
-  period: FundamentalPeriod;
-  series: Array<{
-    symbol: string;
-    rows: Array<{ date: string; value: number }>;
-  }>;
-}
-
-interface PaneScreenshotFinancialStatementEvidence {
-  kind: "financial-statement";
-  symbol: string;
-  statement: string;
-  period: FundamentalPeriod;
-  latest: {
-    date: string;
-    metrics: Array<{
-      id: string;
-      key: string;
-      label: string;
-      value: number;
-    }>;
-  };
-}
-
-export type PaneScreenshotDataEvidence =
-  | PaneScreenshotPriceSeriesEvidence
-  | PaneScreenshotPriceComparisonEvidence
-  | PaneScreenshotFundamentalSeriesEvidence
-  | PaneScreenshotFinancialStatementEvidence
-  | PaneScreenshotFinancialRatioEvidence
-  | PaneScreenshotEvidence;
-
-export interface PaneScreenshotReadinessSignals {
-  rowCount: number;
-  loadingStateDetected: boolean;
-  errorStateDetected: boolean;
-  emptyStateDetected: boolean;
-  complete: boolean;
-  semanticMismatch: boolean;
-  requiresStructuredDataEvidence: boolean;
-  hasStructuredDataEvidence: boolean;
-}
-
-export function isPaneScreenshotUsable(signals: PaneScreenshotReadinessSignals): boolean {
-  return signals.rowCount > 0
-    && !signals.loadingStateDetected
-    && !signals.errorStateDetected
-    && !signals.emptyStateDetected
-    && signals.complete
-    && !signals.semanticMismatch
-    && (!signals.requiresStructuredDataEvidence || signals.hasStructuredDataEvidence);
-}
-
-export interface PaneScreenshotResult {
-  kind: "pane-screenshot";
-  target: string;
-  capability: {
-    id: string;
-    botSafe: boolean;
-    outputKind: string;
-    reportReadiness: ResolvedPaneFunction["capability"]["reportReadiness"];
-    screenshotReadiness: ResolvedPaneFunction["capability"]["screenshotReadiness"];
-  };
-  symbols: string[];
-  options: Record<string, string | number | boolean>;
-  rowCount: number;
-  empty: boolean;
-  complete: boolean;
-  unavailableSymbols: string[];
-  semanticMismatch: boolean;
-  usable: boolean;
-  unusableReason: string | null;
-  dataEvidence: PaneScreenshotDataEvidence | null;
-  /** What the pane says its view leaves out, such as OMON's "21 of 145 strikes". */
-  notices?: string[];
-  /**
-   * For a pane that grows to show every row (FUT): how many of the rows its
-   * table reports the image shows, section headers left out. `shown` is less
-   * than `total` when the height limit or `--height` cut the board.
-   */
-  tableRows?: { shown: number; total: number };
-  /** What the pane's report leaves out when it is not complete, as `fn` words it: `2 stale`. */
-  gaps?: string;
-  /** How current the captured data is, as the capture's status line says it; absent with `--no-status`. */
-  freshness?: ReportFreshness;
-  outputPath: string;
-  render: DesktopPaneShotRenderResult & {
-    expectedText: string[];
-    missingExpectedText: string[];
-    expectedSelections: PaneScreenshotExpectedSelection[];
-    missingExpectedSelections: PaneScreenshotExpectedSelection[];
-    expectedChart: PaneScreenshotExpectedChartEvidence | null;
-    chartEvidenceMismatches: string[];
-  };
-}
-
-export function defaultScreenshotPath(resolved: ResolvedPaneFunction, rawArg: string): string {
-  const suffix = slugifyName([resolved.token, rawArg].filter(Boolean).join("-"), "pane");
-  return resolve(process.cwd(), `gloomberb-${suffix}.png`);
-}
-
-/**
- * The pixels of the PNG a `shot` of this size writes: the layout snapped to
- * whole cells, drawn at the device scale factor (twice the layout size, as
- * `--scale` trades cells for glyph size at the same output size).
- */
-function shotImagePixels(widthPx: number, heightPx: number, scale = 1): { width: number; height: number } {
-  const device = DEFAULT_SHOT_DEVICE_SCALE_FACTOR * scale;
-  return {
-    width: Math.round(Math.max(1, Math.floor(widthPx / scale / DESKTOP_CELL_WIDTH_PX)) * DESKTOP_CELL_WIDTH_PX * device),
-    height: Math.round(Math.max(1, Math.floor(heightPx / scale / DESKTOP_CELL_HEIGHT_PX)) * DESKTOP_CELL_HEIGHT_PX * device),
-  };
-}
-
-/** Whether a capture of this pane, on the tab it opens, grows to show every row (PaneDef.shotFitsRows). */
-function paneFitsRows(resolved: Pick<ResolvedPaneFunction, "pane" | "instance">): boolean {
-  const fits = resolved.pane.shotFitsRows;
-  return typeof fits === "function" ? fits(resolved.instance) : fits === true;
-}
-
-/** The tallest layout, in cells, a capture may grow to at this scale: the `--height` limit. */
-function shotMaxHeightCells(scale: number): number {
-  return Math.max(1, Math.floor(SHOT_SIZE_LIMITS.height.max / scale / DESKTOP_CELL_HEIGHT_PX));
-}
-
-/** What `shot` says when it drew another size than the one asked for, naming the PNG it wrote. */
-export function shotSizeWarnings(
-  clamped: readonly ShotSizeClamp[] | undefined,
-  size: { width: number; height: number; scale?: number },
-): string[] {
-  if (!clamped?.length) return [];
-  const pixels = shotImagePixels(size.width, size.height, size.scale);
-  return clamped.map(({ dimension, requested, used }) => {
-    const { min, max } = SHOT_SIZE_LIMITS[dimension];
-    const bound = requested < min ? `below the ${min} minimum` : `above the ${max} maximum`;
-    const drawn = dimension === "width" ? `${pixels.width} px wide` : `${pixels.height} px tall`;
-    return `--${dimension} ${requested} is ${bound}, so the capture used ${used} and the PNG is ${drawn}.`;
-  });
-}
-
-/** The options typed, by their key: an alias or another spelling (`--min-amount`) reads as the option it names. */
-function givenOptionKeys(capability: ResolvedPaneFunction["capability"], options: Record<string, string | true>): ReadonlySet<string> {
-  return new Set(Object.keys(options).flatMap((key) => findCapabilityOption(capability, key)?.key ?? []));
-}
-
-export async function buildDesktopShotPayload(
-  resolved: ResolvedPaneFunction,
-  context: MarketContext,
-  rawArg: string,
-  options: Record<string, string | true>,
-  widthPx: number,
-  heightPx: number,
-  theme: string | null,
-  scale: number,
-  watermark: string | null,
-  loadModel: () => Promise<LoadedHeadlessPaneModel> = () => loadResolvedHeadlessPaneModel(resolved, context, rawArg),
-  scannerFeed: Pick<typeof apiClient, "subscribeScanner"> = apiClient,
-): Promise<DesktopPaneShotPayload> {
-  // The requested size is the output size. Scale shrinks the CSS viewport and
-  // raises the device scale factor by the same factor, so a 1200px wide shot at
-  // scale 1.5 lays out 100 cells instead of 150 and every glyph is 1.5x larger.
-  // Snap to whole cells: rounding up used to make the pane a few pixels taller
-  // than the capture, which clipped the bottom axis of charts.
-  const widthCells = Math.max(1, Math.floor(widthPx / scale / DESKTOP_CELL_WIDTH_PX));
-  const heightCells = Math.max(1, Math.floor(heightPx / scale / DESKTOP_CELL_HEIGHT_PX));
-  widthPx = widthCells * DESKTOP_CELL_WIDTH_PX;
-  heightPx = heightCells * DESKTOP_CELL_HEIGHT_PX;
-  const deviceScaleFactor = DEFAULT_SHOT_DEVICE_SCALE_FACTOR * scale;
-  const initialPaneState = optionPaneState(resolved.options);
-  const pluginState = capabilityPluginState(resolved.capability, resolved.options);
-  if (Object.keys(pluginState).length > 0) {
-    initialPaneState.pluginState = {
-      ...(initialPaneState.pluginState ?? {}),
-      ...pluginState,
-    };
-  }
-  if (isFinancialAnalysisFunction(resolved) && !initialPaneState.activeTabId) {
-    initialPaneState.activeTabId = "financials";
-  }
-  // The pane opens on what the report found (13F: the fund a name resolved to, on its view's tab).
-  const opened = resolved.headless?.shotState
-    ? await resolved.headless.shotState(
-      buildHeadlessPaneLoadArgs(resolved.headless, resolved.token, rawArg, resolved.options),
-      async () => (await loadModel()).result as never,
-      givenOptionKeys(resolved.capability, options),
-    )
-    : null;
-  for (const [pluginId, state] of Object.entries(opened?.pluginState ?? {})) {
-    initialPaneState.pluginState = {
-      ...(initialPaneState.pluginState ?? {}),
-      [pluginId]: { ...(initialPaneState.pluginState?.[pluginId] ?? {}), ...state },
-    };
-  }
-  const paneState = stripDesktopShotCredentials<Record<string, PaneRuntimeState>>({
-    [resolved.instance.instanceId]: initialPaneState,
-  });
-  let shotInstance = stripDesktopShotCredentials<typeof resolved.instance>(
-    opened?.settings ? { ...resolved.instance, settings: { ...resolved.instance.settings, ...opened.settings } } : resolved.instance,
-  );
-  const layout = {
-    dockRoot: null,
-    instances: [shotInstance],
-    floating: [{
-      instanceId: resolved.instance.instanceId,
-      x: 0,
-      y: 0,
-      width: widthCells,
-      height: heightCells,
-      zIndex: 1,
-    }],
-    detached: [],
-  };
-  const config = stripDesktopShotCredentials<AppConfig>({
-    ...context.config,
-    ...(theme ? { theme: requireThemeId(theme) } : {}),
-    layout,
-    layouts: [{
-      name: "CLI Shot",
-      layout,
-      paneState,
-      focusedPaneId: resolved.instance.instanceId,
-    }],
-    activeLayoutIndex: 0,
-    onboardingComplete: true,
-  });
-
-  const tickers: TickerRecord[] = [];
-  const financials: Array<[string, TickerFinancials]> = [];
-  const intradayHistories: DesktopPaneShotIntradayHistory[] = [];
-  let instrumentFinancials: SnapshotMarketData["instrumentFinancials"];
-  let historyVariants: SnapshotMarketData["historyVariants"];
-  const optionsChains: Array<[string, OptionsChain]> = [];
-  const tapeSnapshots: TapeCapture[] = [];
-  const [valuationSeries, statSeries] = await Promise.all([
-    collectShotValuationSeries(resolved),
-    collectShotStatSeries(resolved),
-  ]);
-  const includeOptionsChains = resolved.pane.id === OPTIONS_PANE_ID || resolved.template?.paneId === OPTIONS_PANE_ID;
-  let chartModel: ChartPaneModel | undefined;
-  const evidenceHook = paneScreenshotEvidenceHook(resolved);
-  if (evidenceHook?.prepare) {
-    const prepared = await evidenceHook.prepare({ resolved, context, settings: shotInstance.settings ?? {}, loadModel });
-    shotInstance = { ...shotInstance, settings: { ...shotInstance.settings, ...prepared.settings } };
-    for (const [symbol, data] of prepared.financials ?? []) {
-      financials.push([symbol, data]);
-      tickers.push(await createFallbackTicker(symbol, data, context));
-    }
-  } else if (resolved.pane.id === "analytics") {
-    const loaded = await loadModel();
-    shotInstance = { ...shotInstance, settings: { ...shotInstance.settings, analyticsView: "risk", riskSnapshot: loaded.result.metadata?.model ?? null } };
-  } else if (resolved.pane.id === CHART_COMPOSER_PANE_ID) {
-    const loaded = await loadModel();
-    chartModel = loaded.result as ChartPaneModel;
-    shotInstance = { ...shotInstance, settings: { ...shotInstance.settings, chartSpec: chartModel.spec } };
-    const authored = parseChartSpec(resolved.instance.settings?.chartSpec);
-    const captured = new Map(chartModel.snapshot.financials);
-    instrumentFinancials = chartModel.snapshot.instrumentFinancials;
-    historyVariants = chartModel.snapshot.historyVariants;
-    const identities = new Map(chartModel.spec.series.flatMap((series) => {
-      if (series.source.kind !== "security") return [];
-      const key = publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange);
-      const original = authored?.series.find(({ id }) => id === series.id)?.source;
-      const label = original?.kind === "security" ? publicTickerKey(original.instrument.symbol, original.instrument.exchange) : key;
-      return [[snapshotInstrumentKey(series.source.instrument), { key, label, target: series.source.instrument }] as const];
-    }));
-    for (const [identity, { key, label, target }] of identities) {
-      const data = (target.instrument ? instrumentFinancials?.find(entry => snapshotInstrumentKey(entry.instrument) === identity)?.financials : captured.get(key))
-        ?? { annualStatements: [], quarterlyStatements: [], priceHistory: [] };
-      if (!target.instrument) financials.push([label, data]);
-      const { symbol } = parsePublicTickerKey(key);
-      const ticker = await context.store.loadTicker(key) ?? await context.store.loadTicker(symbol);
-      tickers.push(ticker ?? await createFallbackTicker(key, data, context));
-    }
-    intradayHistories.push(...chartModel.snapshot.intradayHistories.map((history) => ({
-      ...history, start: history.start?.toISOString() ?? null, end: history.end?.toISOString() ?? null,
-    })));
-  } else for (const symbol of await collectShotSymbolsWithCollections(resolved, context, rawArg)) {
-    let entry: Awaited<ReturnType<typeof fetchTickerFinancials>>;
-    try {
-      entry = await fetchTickerFinancials(context, symbol);
-    } catch (error) {
-      // A report that reads its own argument (CDS's issuer name) renders it with no ticker data, as `fn` does.
-      if (resolved.headless?.argument.kind === "free-text" && isNotATickerMessage(error instanceof Error ? error.message : null)) continue;
-      if (!COLLECTION_PANE_IDS.has(resolved.pane.id)) throw error;
-      // The pane values a holding no quote covers, such as an option contract,
-      // at the broker's mark. It has no financials to capture.
-      const holding = await loadBrokerMarkedHolding(context, symbol);
-      if (holding) {
-        tickers.push(holding);
-        continue;
-      }
-      // Any other holding no source quotes (an over-the-counter name none
-      // carries) is still a row of the list: it shows without a price, and the
-      // capture names it under "No data for" rather than failing. A read that
-      // was refused, rate limited or timed out fails the capture, to be taken again.
-      if (!isNoSourceAnswer(error)) throw error;
-      const stored = await loadStoredShotTicker(context, symbol);
-      if (!stored) throw error;
-      tickers.push(stored);
-      financials.push([symbol, { annualStatements: [], quarterlyStatements: [], priceHistory: [] }]);
-      continue;
-    }
-    const requestedRange = shotPriceHistoryRange(resolved);
-    let data = entry.financials;
-    const exchange = entry.instrument.exchange
-      ?? entry.tickerFile?.metadata.exchange
-      ?? data.quote?.listingExchangeName
-      ?? data.quote?.exchangeName
-      ?? "";
-    const fiveYearsDaily = resolved.pane.id === "realized-vol" || resolved.pane.id === "iv-history" || resolved.pane.id === "macro-day"
-      // KELLY's History tab reads monthly returns off five years of daily closes.
-      || resolved.pane.id === "kelly-sizer";
-    if (fiveYearsDaily || resolved.pane.id === "iv-screen" || resolved.pane.id === "short-watch"
-      || resolved.pane.id === "backtest" || resolved.pane.id === OPTIONS_PANE_ID) {
-      // Generic 5Y snapshots can contain weekly bars. The snapshot provider
-      // treats captured history as authoritative, even for a later 1d request.
-      // Preserve the pane's daily buffer and warmup before the renderer clips it.
-      if (!context.dataProvider.getPriceHistoryForResolution) {
-        throw new Error("Daily-history screenshots require daily history resolution support.");
-      }
-      const priceHistory = await context.dataProvider.getPriceHistoryForResolution(
-        entry.instrument.symbol, exchange,
-        fiveYearsDaily ? "5Y" : resolved.pane.id === "backtest" ? "ALL" : "1Y",
-        "1d", toMarketDataContext(entry.instrument),
-      );
-      data = { ...data, priceHistory };
-    } else if (shotRatioTab(resolved)?.key === "valuation") {
-      data = await withShotPeriodEndHistory(context, entry.instrument, exchange, resolved, data);
-    } else if (resolved.pane.id === "seasonality") {
-      data = await withShotSeasonalityHistory(context, entry.instrument, resolved, data);
-    } else if (resolved.pane.id === "returns") {
-      data = await withShotReturnHistory(context, entry.instrument, exchange, resolved, data);
-    } else if (requestedRange && readsDailyReturns(resolved)) {
-      data = await withShotDailyReturns(context, entry.instrument, exchange, requestedRange, data);
-    } else if (requestedRange) {
-      try {
-        const priceHistory = await context.dataProvider.getPriceHistory(entry.instrument.symbol, exchange, requestedRange);
-        data = { ...data, priceHistory: clipPriceHistoryToRange(priceHistory, requestedRange) };
-      } catch {
-        data = await withShotPriceHistory(context, symbol, entry.tickerFile, data);
-      }
-    } else {
-      // The cloud's financials carry no price history. The snapshot provider
-      // treats a captured dataset as authoritative, so an empty history here
-      // left the overview chart and quote monitor sparklines blank instead of
-      // letting the pane fetch them.
-      data = await withShotPriceHistory(context, symbol, entry.tickerFile, data);
-    }
-    tickers.push(entry.tickerFile ?? await createFallbackTicker(symbol, data, context));
-    financials.push([symbol, data]);
-    if (resolved.pane.id === "time-sales") {
-      tapeSnapshots.push([entry.instrument.symbol, exchange, await fetchTape(entry.instrument.symbol, exchange)]);
-    }
-    if (includeOptionsChains && context.dataProvider.getOptionsChain) {
-      // A future with no chain of its own is the pane's to explain (the listed alternative), not a failed shot.
-      const chain = await context.dataProvider.getOptionsChain(entry.instrument.symbol, exchange, undefined,
-        context.refresh ? { cacheMode: "refresh" } : undefined).catch((error: unknown) => {
-        if (isOptionsUnavailableError(error)) return null;
-        throw error;
-      });
-      if (chain) optionsChains.push([symbol, chain]);
-    }
-  }
-  // A scanner pane reads one answer from the capture's own session: the page's socket is refused (see createSnapshotScannerClient).
-  const scannerKind = SCANNER_PANE_KINDS[resolved.pane.id];
-  const scannerSnapshots: ScannerCapture[] = scannerKind
-    ? [[scannerKind, await captureScannerEvent(scannerFeed, scannerKind, new AbortController().signal)]]
-    : [];
-  layout.instances[0] = shotInstance;
-  config.layout.instances[0] = shotInstance;
-  if (config.layouts[0]) config.layouts[0].layout.instances[0] = shotInstance;
-
-  const payload: DesktopPaneShotPayload = {
-    config,
-    marketDataProviderId: context.dataProvider.id,
-    paneId: resolved.instance.instanceId,
-    widthCells,
-    heightCells,
-    widthPx,
-    heightPx,
-    deviceScaleFactor,
-    watermark,
-    tickers,
-    ...(COLLECTION_PANE_IDS.has(resolved.pane.id)
-      ? { brokerAccounts: peekCachedBrokerAccounts(context.config, context.persistence?.resources) }
-      : {}),
-    financials,
-    ...(instrumentFinancials?.length ? { instrumentFinancials } : {}),
-    ...(historyVariants?.length ? { historyVariants } : {}),
-    intradayHistories,
-    optionsChains,
-    ...(tapeSnapshots.length ? { tapeSnapshots } : {}),
-    ...(scannerSnapshots.length ? { scannerSnapshots } : {}),
-    valuationSeries,
-    statSeries,
-    paneState,
-    externalPlugins: await collectExternalPluginBundles(),
-  };
-  if (chartModel) payload.chartModel = chartModel.chart;
-  return payload;
-}
-
-/** Panes that render the user's portfolio or watchlist rather than an argument. */
-const COLLECTION_PANE_IDS = new Set(["portfolio-list", "analytics", "kelly-sizer", "earnings-calendar"]);
-
-/**
- * The page only knows the tickers the payload carries, so a collection pane
- * captured with just the argument symbol showed an empty portfolio. Portfolio
- * and watchlist members ride along for the panes that display them.
- */
-async function collectShotSymbolsWithCollections(
-  resolved: ResolvedPaneFunction,
-  context: MarketContext,
-  rawArg: string,
-): Promise<string[]> {
-  if (!COLLECTION_PANE_IDS.has(resolved.pane.id)) return collectShotSymbols(resolved, rawArg);
-  // `shot PF Retirement` names a portfolio, not a ticker to fetch.
-  const symbols = rawArg.trim() && findCollection(context.config, rawArg) ? [] : collectShotSymbols(resolved, rawArg);
-  const members = (await context.store.loadAllTickers())
-    .filter(({ metadata }) => metadata.portfolios.length > 0 || metadata.watchlists.length > 0)
-    .map(({ metadata }) => metadata.ticker);
-  return [...new Set([...symbols, ...members])];
-}
-
-function shotPriceHistoryRange(resolved: ResolvedPaneFunction): TimeRange | null {
-  // Captured history is authoritative, and the generic 5Y capture is weekly.
-  if (resolved.pane.id === "quote-monitor") return getQuoteMonitorPaneSettings(resolved.instance.settings).chartPeriod;
-  switch (resolved.capability.id) {
-    case "return-correlation":
-      return (resolved.options.rangePreset ?? "1Y") as TimeRange;
-    case "historical-prices":
-      return (resolved.options.range ?? HISTORY_DEFAULT_RANGE) as TimeRange;
-    case "security-relationship":
-      return (resolved.options.range ?? "1Y") as TimeRange;
-    default:
-      return null;
-  }
-}
-
-/** The bridge, keeping every quote it serves the page: what a pane that loads its own quotes (WEI) shows. */
-function recordBridgedQuotes(bridge: DesktopPaneShotBridge): { bridge: DesktopPaneShotBridge; quotes: Quote[] } {
-  const quotes: Quote[] = [];
-  const keep = (value: unknown) => {
-    if (isRecord(value) && typeof value.symbol === "string" && typeof value.price === "number") quotes.push(value as unknown as Quote);
-  };
-  return {
-    quotes,
-    bridge: {
-      ...bridge,
-      async marketData(operation, args) {
-        const result = await bridge.marketData(operation, args);
-        if (operation === "getQuote") keep(result);
-        if (operation === "getQuotesBatch" && Array.isArray(result)) {
-          for (const entry of result) keep(isRecord(entry) ? entry.quote : null);
-        }
-        return result;
-      },
-    },
-  };
-}
-
-/**
- * How current a capture's data is (`captureStatusLine`). A pane that dates its
- * view itself (the news wire's delay, FXC's rates) is taken at its word, and so
- * is a report that says what its data is (EE's estimates, MDAY's study): the
- * quotes the page loaded beside them do not date them. A pane that declares a
- * status is never dated by the quotes it shows; otherwise those quotes date it,
- * with their delay and where their markets stand. Then the pane's report, as
- * `fn` ends; then what the rendered view carries. A function that opens one
- * view of a pane hosting several declares it on its template (DDIS in Fixed
- * Income), so its filings, not the issuer's stock quote, date the capture.
- */
-export function shotFreshness(
-  resolved: Pick<ResolvedPaneFunction, "pane" | "template">,
-  payload: Pick<DesktopPaneShotPayload, "financials" | "instrumentFinancials">,
-  render: Pick<DesktopPaneShotRenderResult, "semanticUi" | "footerText" | "rows">,
-  bridgedQuotes: readonly Quote[],
-  report: CaptureReport | undefined,
-  now = Date.now(),
-): CaptureStatusLine {
-  const published = renderedReportFreshness(render.semanticUi ?? []);
-  const declared = { ...declaredReportFreshness(resolved), ...published };
-  const quotes = [
-    ...payload.financials.map(([, financials]) => financials.quote),
-    ...(payload.instrumentFinancials ?? []).map(({ financials }) => financials.quote),
-    ...bridgedQuotes,
-  ];
-  // A pane that publishes the observations behind its figures (FXC's rates) dates itself.
-  const observed = renderedReportObservations(render.semanticUi ?? []);
-  const quoted = declared.status || observed.length > 0
-    ? undefined
-    : quotesFreshness(quotes, declared.source ? { source: declared.source } : undefined, now);
-  return captureStatusLine({
-    report,
-    selfDated: Object.keys(published).length > 0 || observed.length > 0,
-    quoted,
-    rendered: () => deriveRenderedFreshness(declared, {
-      footerText: render.footerText ?? "",
-      cellTimes: render.rows.flatMap((row) => row.cells.flatMap((cell) => (cell.instant ? [cell.instant] : []))),
-      observed,
-    }, now),
-  });
-}
-
-/**
- * A capture's data dated as its `fn` report dates it, from the same loader:
- * COT's weekly report, CHOKE's transits, GPU's prices. Undefined for a pane
- * without a report, or when it did not load.
- */
-async function reportShotFreshness(
-  resolved: Pick<ResolvedPaneFunction, "headless">,
-  loadModel: () => Promise<LoadedHeadlessPaneModel>,
-  now = Date.now(),
-): Promise<CaptureReport | undefined> {
-  if (!resolved.headless) return undefined;
-  try {
-    const loaded = await loadModel();
-    return deriveCaptureReport(loaded.definition, loaded.result, now);
-  } catch (error) {
-    logFailure("cli.screenshot", "Read screenshot report freshness failed")(error);
-    return undefined;
-  }
-}
-
-/** What a capture's report says about its own completeness (`fn`'s `complete`), as `reportCoverage` derives it. */
-export interface ShotReportCoverage {
-  complete: boolean;
-  unavailableSymbols: string[];
-  gaps?: string;
-}
-
-/**
- * Whether the pane's report covers what was asked, loaded once with the
- * capture's other uses of it. Undefined for a pane without a report, or when
- * it did not load.
- */
-export async function reportShotCoverage(
-  resolved: Pick<ResolvedPaneFunction, "headless">,
-  loadModel: () => Promise<LoadedHeadlessPaneModel>,
-): Promise<ShotReportCoverage | undefined> {
-  if (!resolved.headless) return undefined;
-  try {
-    const loaded = await loadModel();
-    const { complete, unavailableSymbols } = reportCoverage(loaded);
-    const gaps = reportGaps(loaded, deriveHeadlessFreshness(loaded.definition, loaded.result));
-    return { complete, unavailableSymbols, ...(gaps ? { gaps } : {}) };
-  } catch (error) {
-    logFailure("cli.screenshot", "Read screenshot report coverage failed")(error);
-    return undefined;
-  }
-}
-
-/**
- * The capture's result with its report's completeness: a capture of a partial
- * report is partial too, whatever the rendered view shows. Whether the image
- * is fit to use stays what the render says.
- */
-export function withReportCoverage(result: PaneScreenshotResult, coverage: ShotReportCoverage | undefined): PaneScreenshotResult {
-  if (!coverage || coverage.complete) return result;
-  return {
-    ...result,
-    complete: false,
-    unavailableSymbols: [...new Set([...result.unavailableSymbols, ...coverage.unavailableSymbols])],
-    ...(coverage.gaps ? { gaps: coverage.gaps } : {}),
-  };
-}
-
-/**
- * The words after `Status` in a capture's text output: why it is not
- * complete, empty, matching its data or usable, `partial: 2 stale`. Empty when
- * nothing is wrong.
- */
-export function shotStatusIssues(
-  data: Pick<PaneScreenshotResult, "empty" | "complete" | "gaps" | "semanticMismatch" | "usable"> & {
-    render: Pick<PaneScreenshotResult["render"], "accessGate">;
-  },
-): string[] {
-  const gated = data.render.accessGate && (data.empty || !data.usable) ? data.render.accessGate : null;
-  return [
-    gated ? accessGateStatus(gated) : data.empty ? "empty" : null,
-    // A gate already says why a report is not whole.
-    data.complete ? null : data.gaps ? `partial: ${data.gaps}` : gated ? null : "partial",
-    data.semanticMismatch ? "does not match the data" : null,
-    data.usable ? null : "not usable",
-  ].filter((issue): issue is string => issue != null);
-}
-
-/** How long a rendered capture waits for its report's freshness before dating itself without it. */
-const SHOT_REPORT_WAIT_MS = 20_000;
-
-/**
- * The value of the report's `tab` option for the tab the capture shows, when
- * it was asked for another: `DOE --tab all` draws Crude, so it is dated by
- * Wednesday's petroleum report, not by Thursday's gas storage. Undefined when
- * it shows the tab asked for.
- */
-export function shownReportTab(
-  resolved: Pick<ResolvedPaneFunction, "headless" | "options">,
-  semanticUi: readonly RemoteUiNodeSnapshot[],
-): string | undefined {
-  const asked = resolved.options.tab;
-  const values = resolved.headless?.options?.find(({ key }) => key === "tab")?.values?.map(({ value }) => value) ?? [];
-  if (asked == null || values.length === 0) return undefined;
-  for (const node of semanticUi) {
-    const active = node.role === "tabs" ? node.metadata?.activeValue : undefined;
-    if (typeof active === "string" && values.includes(active)) return active === String(asked) ? undefined : active;
-  }
-  return undefined;
-}
-
-/** `pending`'s value, or undefined when it has not settled within `ms`; a later result is dropped. */
-function settledWithin<T>(pending: Promise<T>, ms: number): Promise<T | undefined> {
-  let cancel = () => {};
-  const expired = new Promise<undefined>((resolve) => {
-    const timer = setTimeout(() => resolve(undefined), ms);
-    cancel = () => clearTimeout(timer);
-  });
-  return Promise.race([pending, expired]).finally(() => cancel());
-}
-
-/** One load of the pane's report per capture, shared by the payload and the status line. */
-function onceLoader(load: () => Promise<LoadedHeadlessPaneModel>): () => Promise<LoadedHeadlessPaneModel> {
-  let pending: Promise<LoadedHeadlessPaneModel> | undefined;
-  return () => (pending ??= load());
-}
-
-export async function renderDesktopShot({
-  resolved,
-  context,
-  rawArg,
-  outputPath,
-  width,
-  height,
-  theme,
-  scale,
-  watermark,
-  statusLine = false,
-  fitRows = false,
-  fitReader = false,
-  maxHeightCells,
-  options,
-  captureImage = true,
-  onStalledReport,
-}: {
-  resolved: ResolvedPaneFunction;
-  context: MarketContext;
-  rawArg: string;
-  outputPath: string;
-  width: number;
-  height: number;
-  theme?: string | null;
-  scale?: number;
-  watermark?: string | null;
-  /** Draw the dated status line in the capture's footer. Reports and `--no-status` leave it out. */
-  statusLine?: boolean;
-  /** No `--height` was asked for: a pane that fits its rows (FUT) grows to show them all. */
-  fitRows?: boolean;
-  /** A pane whose reader has a page open grows to show all of its text (a report's, which saves no image). */
-  fitReader?: boolean;
-  /** How tall a pane that fits its rows or its reader may grow, in cells, where the height limit of a saved image does not apply. */
-  maxHeightCells?: number;
-  options: Record<string, string | true>;
-  captureImage?: boolean;
-  /**
-   * Called when the report behind the status line was still loading at the
-   * wait's end: the load was aborted, but a loader that ignores the signal
-   * may keep the process alive.
-   */
-  onStalledReport?: () => void;
-}): Promise<PaneScreenshotResult> {
-  if (captureImage) await mkdir(dirname(outputPath), { recursive: true });
-  const apiProxy = resolveDesktopShotApiProxy(context);
-  const previousSessionToken = apiClient.getSessionToken();
-  let payload: DesktopPaneShotPayload;
-  let render: DesktopPaneShotRenderResult;
-  let freshness: ReportFreshness | undefined;
-  let coverage: Promise<ShotReportCoverage | undefined> | undefined;
-  let covered: ShotReportCoverage | undefined;
-  // A report still loading when the status line stops waiting for it is
-  // aborted, and the caller told: a loader that ignores the signal goes on.
-  const reportLoads = new AbortController();
-  let loading = 0;
-  const loadReport = (target: ResolvedPaneFunction) => {
-    loading += 1;
-    return loadResolvedHeadlessPaneModel(target, context, rawArg, reportLoads.signal).finally(() => { loading -= 1; });
-  };
-  const abandonReports = () => {
-    if (loading === 0 || reportLoads.signal.aborted) return;
-    reportLoads.abort(new Error("The capture stopped waiting for its report."));
-    onStalledReport?.();
-  };
-  apiClient.setSessionToken(apiProxy.sessionToken);
-  try {
-    const loadModel = onceLoader(() => loadReport(resolved));
-    payload = await buildDesktopShotPayload(
-      resolved,
-      context,
-      rawArg,
-      options,
-      width,
-      height,
-      theme ?? null,
-      scale ?? 1,
-      watermark ?? null,
-      loadModel,
-    );
-    if (statusLine && captureImage) payload.statusLine = true;
-    const fitRoles = [
-      ...(fitRows && paneFitsRows(resolved) ? ["data-table-body-scroll"] : []),
-      ...(fitReader && resolved.pane.shotFitsReader ? ["detail-scroll-body"] : []),
-    ];
-    if (fitRoles.length > 0) {
-      payload.maxHeightCells = maxHeightCells ?? shotMaxHeightCells(scale ?? 1);
-      payload.fitRoles = fitRoles;
-    }
-    // Loads while the page renders.
-    const report = payload.statusLine ? reportShotFreshness(resolved, loadModel) : undefined;
-    // The same load says whether the report is complete, with or without a status line.
-    coverage = captureImage ? reportShotCoverage(resolved, loadModel) : undefined;
-    const recorded = recordBridgedQuotes(createDesktopShotBridge(context));
-    const shotPayload = payload;
-    render = await renderDesktopPaneScreenshot(payload, outputPath, apiProxy, {
-      captureImage,
-      bridge: recorded.bridge,
-      statusLine: async (rendered) => {
-        const tab = report && shownReportTab(resolved, rendered.semanticUi);
-        const shown = tab ? reportShotFreshness(resolved, () => loadReport({ ...resolved, options: { ...resolved.options, tab } })) : report;
-        const line = shotFreshness(resolved, shotPayload, rendered, recorded.quotes, shown && await settledWithin(shown, SHOT_REPORT_WAIT_MS));
-        abandonReports();
-        freshness = line.freshness;
-        return { variants: line.variants, dates: line.dates };
-      },
-    });
-    covered = coverage && await settledWithin(coverage, SHOT_REPORT_WAIT_MS);
-  } finally {
-    apiClient.setSessionToken(previousSessionToken);
-    abandonReports();
-  }
-  const renderedInstance = payload.config.layout.instances.find(({ instanceId }) => instanceId === payload.paneId);
-  if (renderedInstance) resolved = { ...resolved, instance: renderedInstance };
-  const assessed = withReportCoverage(assessPaneScreenshot(resolved, payload, render, rawArg, outputPath), covered);
-  return freshness ? { ...assessed, freshness } : assessed;
-}
-
-/**
- * For a pane that grows to fit its rows, the rows its table reports (every
- * one, `reportEveryRow`) and how many of them the image shows, by key;
- * section headers count in neither. Null for any other pane, or a table that
- * reports only what is drawn.
- */
-export function shotTableRows(
-  resolved: Pick<ResolvedPaneFunction, "pane" | "instance">,
-  render: Pick<DesktopPaneShotRenderResult, "rows" | "reportRows">,
-): { shown: number; total: number } | null {
-  if (!paneFitsRows(resolved) || !render.reportRows?.length) return null;
-  const reported = render.reportRows.filter((row) => !row.section && row.key);
-  if (reported.length === 0) return null;
-  const drawn = new Set(render.rows.flatMap((row) => row.key ? [`${row.tableIndex}:${row.key}`] : []));
-  return { shown: reported.filter((row) => drawn.has(`${row.tableIndex}:${row.key}`)).length, total: reported.length };
-}
-
-/** What a rendered capture shows, and whether it is fit to use. */
-export function assessPaneScreenshot(
-  resolved: ResolvedPaneFunction,
-  payload: DesktopPaneShotPayload,
-  render: DesktopPaneShotRenderResult,
-  rawArg: string,
-  outputPath: string,
-): PaneScreenshotResult {
-  const evidenceHook = paneScreenshotEvidenceHook(resolved);
-  // The sizer carries portfolio members to value holdings and the earnings board
-  // to mark them, but each shows only what its argument asks for.
-  const symbols = evidenceHook?.symbols?.({ resolved, payload })
-    ?? (resolved.pane.id === "kelly-sizer" || resolved.pane.id === "earnings-calendar" ? collectShotSymbols(resolved, rawArg)
-      : payload.financials.map(([symbol]) => symbol));
-  const usesLiveDomEvidence = resolved.capability.screenshotReadiness === "live-dom" && !evidenceHook;
-  // A live pane without a table, such as a ticker overview, shows its data
-  // as labeled values.
-  const rowCount = usesLiveDomEvidence
-    ? render.rows.length || filledKeyValueCount(render.visibleKeyValues)
-    : shotSemanticRowCount(resolved, payload, render.semanticUi);
-  const unavailableSymbols = usesLiveDomEvidence
-    ? []
-    : shotUnavailableSymbols(resolved, payload, render.semanticUi);
-  const complete = unavailableSymbols.length === 0;
-  const expectedText = shotExpectedText(resolved, symbols, payload);
-  const normalizedVisibleText = render.visibleText.toLowerCase();
-  const missingExpectedText = expectedText.filter((value) => !normalizedVisibleText.includes(value.toLowerCase()));
-  const expectedSelections = shotExpectedSelections(resolved);
-  const missingExpectedSelections = missingActiveTabSelections(
-    render.semanticUi,
-    expectedSelections,
-  );
-  const expectedChart = shotExpectedChart(resolved, payload);
-  const dataEvidence = shotDataEvidenceFor(resolved, payload, render.semanticUi);
-  const chartEvidenceMismatches = [
-    ...(expectedChart ? chartEvidenceMismatchesFor(render.semanticUi, expectedChart) : []),
-    ...intradayChartEvidenceMismatchesFor(resolved, payload, render.semanticUi),
-    ...paneEvidenceMismatches(resolved, payload, render),
-    ...financialRatioRenderMismatches(resolved, payload, render),
-    ...surfaceNotDrawnMismatches(render),
-  ];
-  const semanticMismatch = missingExpectedText.length > 0
-    || missingExpectedSelections.length > 0
-    || chartEvidenceMismatches.length > 0;
-  const empty = render.loadingStateDetected
-    || render.errorStateDetected
-    || render.emptyStateDetected
-    || rowCount === 0
-    || semanticMismatch;
-  const usable = isPaneScreenshotUsable({
-    rowCount,
-    loadingStateDetected: render.loadingStateDetected,
-    errorStateDetected: render.errorStateDetected,
-    emptyStateDetected: render.emptyStateDetected,
-    complete,
-    semanticMismatch,
-    requiresStructuredDataEvidence: requiresStructuredDataEvidence(resolved),
-    hasStructuredDataEvidence: dataEvidence !== null,
-  });
-  const unusableReason = usable
-    ? null
-    : shotUnusableReasonFor(resolved, payload, render, unavailableSymbols, semanticMismatch);
-  const tableRows = shotTableRows(resolved, render);
-  const notices = [
-    ...renderedReportNotices(render.semanticUi ?? []).notices,
-    ...unquotedHoldingsNotice(resolved, payload),
-    ...(render.surfaces?.some((surface) => surface.renderer === "software")
-      ? ["The 3D surface was drawn by the software renderer: this browser has no WebGL."] : []),
-  ];
-  return {
-    kind: "pane-screenshot",
-    target: resolved.token,
-    capability: {
-      id: resolved.capability.id,
-      botSafe: resolved.capability.botSafe,
-      outputKind: resolved.capability.outputKind,
-      reportReadiness: resolved.capability.reportReadiness,
-      screenshotReadiness: resolved.capability.screenshotReadiness,
-    },
-    symbols,
-    options: stripDesktopShotCredentials(resolved.options),
-    rowCount,
-    empty,
-    complete,
-    unavailableSymbols,
-    semanticMismatch,
-    usable,
-    unusableReason,
-    dataEvidence,
-    ...(notices.length > 0 ? { notices } : {}),
-    ...(tableRows ? { tableRows } : {}),
-    outputPath,
-    render: {
-      ...stripDesktopShotCredentials(render),
-      expectedText,
-      missingExpectedText,
-      expectedSelections,
-      missingExpectedSelections,
-      expectedChart,
-      chartEvidenceMismatches,
-    },
-  };
-}
-
-/**
- * The holdings of a portfolio or watchlist capture no source quoted (an
- * over-the-counter name none carries), whose rows show no price: "No quote
- * for KISB; its row shows no price."
- */
-function unquotedHoldingsNotice(resolved: ResolvedPaneFunction, payload: DesktopPaneShotPayload): string[] {
-  if (!COLLECTION_PANE_IDS.has(resolved.pane.id)) return [];
-  const unquoted = payload.financials.flatMap(([symbol, financials]) => (
-    !financials.quote && financials.priceHistory.length === 0 && financials.annualStatements.length === 0 ? [symbol] : []
-  ));
-  if (unquoted.length === 0) return [];
-  return [`No quote for ${unquoted.join(", ")}; ${unquoted.length === 1 ? "its row shows" : "their rows show"} no price.`];
-}
-
-function requiresStructuredDataEvidence(resolved: ResolvedPaneFunction): boolean {
-  return paneScreenshotEvidenceHook(resolved) !== null || [
-    "price-chart",
-    "intraday-price-chart",
-    "price-comparison",
-    "fundamental-series",
-    "financial-statements",
-  ].includes(resolved.capability.id);
-}
-
-const PLACEHOLDER_VALUE = /^(?:[-\u2013\u2014]+|n\/?a)?$/i;
-
-/** Labeled values that hold data. A grid of labels over "-" placeholders,
- * as for a ticker without fundamentals, is an empty pane. */
-export function filledKeyValueCount(rows: DesktopPaneShotRenderResult["visibleKeyValues"]): number {
-  return (rows ?? []).filter(({ label, text }) => {
-    const value = text.startsWith(label) ? text.slice(label.length) : text;
-    return !PLACEHOLDER_VALUE.test(value.trim());
-  }).length;
-}
-
-/**
- * A 3D surface that is not the real drawing: the frame has no mesh, or the 2D
- * grid stands in for it. Both are fine for a person using the pane and wrong
- * for a capture of it.
- */
-export function surfaceNotDrawnMismatches(render: Pick<DesktopPaneShotRenderResult, "surfaces">): string[] {
-  const surfaces = render.surfaces ?? [];
-  return [
-    ...(surfaces.some((surface) => surface.state === "blank") ? ["the 3D surface drew no mesh"] : []),
-    ...(surfaces.some((surface) => surface.renderer === "grid") ? ["the 3D surface was replaced by a 2D grid"] : []),
-  ];
-}
-
-export function shotUnusableReasonFor(
-  resolved: ResolvedPaneFunction,
-  payload: DesktopPaneShotPayload,
-  render: Pick<DesktopPaneShotRenderResult, "loadingStateDetected" | "errorStateDetected" | "emptyStateDetected" | "accessGate" | "surfaces">,
-  unavailableSymbols: string[],
-  semanticMismatch: boolean,
-): string {
-  if (resolved.capability.id === "intraday-price-chart") {
-    const intraday = payload.intradayHistories[0];
-    if (intraday?.unavailableReason) return intraday.unavailableReason;
-    if (intraday && intraday.points.length > 0) {
-      return `Intraday bars were loaded for ${intraday.symbol}, but the chart did not render them.`;
-    }
-    const symbol = payload.financials[0]?.[0] ?? resolved.createOptions?.symbol ?? "the ticker";
-    return `No intraday price history is available for ${symbol} for the requested session window.`;
-  }
-  if (render.loadingStateDetected) return "The pane was still loading when the screenshot was captured.";
-  if (render.accessGate) return accessGateSentence(render.accessGate);
-  if (render.errorStateDetected) return "The pane rendered an error state.";
-  if (render.emptyStateDetected) return "The pane rendered an empty state.";
-  const surfaceGap = surfaceNotDrawnMismatches(render)[0];
-  if (surfaceGap) return `${surfaceGap[0]!.toUpperCase()}${surfaceGap.slice(1)}.`;
-  if (unavailableSymbols.length > 0) return `Data is unavailable for ${unavailableSymbols.join(", ")}.`;
-  const ratioGap = financialRatioShotGap(resolved, payload);
-  if (ratioGap) return ratioGap;
-  if (semanticMismatch) return "The rendered content did not match the requested capability.";
-  return "The pane did not produce verifiable screenshot evidence.";
-}
-
-const STATEMENT_EVIDENCE_KEYS: Record<string, ReadonlySet<string>> = {
-  income: new Set([
-    "totalRevenue",
-    "grossProfit",
-    "operatingIncome",
-    "netIncome",
-    "netIncomeCommonStockholders",
-    "eps",
-    "basicEps",
-  ]),
-  cashflow: new Set([
-    "operatingCashFlow",
-    "capitalExpenditure",
-    "freeCashFlow",
-  ]),
-  balance: new Set([
-    "totalAssets",
-    "totalLiabilities",
-    "cashAndCashEquivalents",
-    "totalDebt",
-    "totalEquity",
-    "commonStockEquity",
-  ]),
-};
-
-export function shotDataEvidenceFor(
-  resolved: ResolvedPaneFunction,
-  payload: DesktopPaneShotPayload,
-  semanticUi: RemoteUiNodeSnapshot[] = [],
-): PaneScreenshotDataEvidence | null {
-  const evidenceHook = paneScreenshotEvidenceHook(resolved);
-  if (evidenceHook) return renderedPaneEvidence(evidenceHook, semanticUi);
-  const spec = payload.chartModel ? parseChartSpec(payload.config.layout.instances.find((instance) => instance.instanceId === payload.paneId)?.settings?.chartSpec) : null;
-  const visibleSeries = payload.chartModel && spec ? spec.series.flatMap((entry) => {
-    if (entry.source.kind !== "security" || entry.visible === false) return [];
-    const output = payload.chartModel!.series.find((series) => series.id === entry.id);
-    return [{
-      symbol: publicTickerKey(entry.source.instrument.symbol, entry.source.instrument.exchange),
-      points: (output?.points ?? []).flatMap((point) => {
-        const close = point.rawValue === undefined ? point.value ?? point.close : point.rawValue;
-        return typeof close === "number" && Number.isFinite(close) ? [{ date: point.date, close }] : [];
-      }),
-    }];
-  }) : null;
-  if (resolved.capability.id === "intraday-price-chart") {
-    const intraday = payload.intradayHistories[0];
-    if (!intraday || intraday.points.length === 0) return null;
-    const evidence = chartSeriesEvidence(intraday.symbol, intraday.points);
-    if (!evidence.first || !evidence.last) return null;
-    return {
-      kind: "price-series",
-      symbol: intraday.symbol,
-      range: intraday.rangePreset,
-      pointCount: evidence.pointCount,
-      first: evidence.first,
-      last: evidence.last,
-      resolution: intraday.resolution,
-      sessionDates: intraday.sessionDates,
-    };
-  }
-
-  if (resolved.capability.id === "price-chart") {
-    const range = String(resolved.options.rangePreset ?? "5Y") as TimeRange;
-    const [symbol, financials] = payload.financials[0] ?? [];
-    const captured = visibleSeries?.[0];
-    const evidence = captured ? chartSeriesEvidence(captured.symbol, captured.points)
-      : visibleSeries === null && symbol && financials ? normalizeChartSeries(symbol, financials, range).evidence : null;
-    if (!evidence?.first || !evidence.last || evidence.pointCount <= 0) return null;
-    return { kind: "price-series", range, ...evidence, first: evidence.first, last: evidence.last };
-  }
-
-  if (resolved.capability.id === "price-comparison") {
-    const range = String(resolved.options.rangePreset ?? "1Y") as TimeRange;
-    const normalizedSeries = visibleSeries ?? payload.financials.map(([symbol, financials]) => ({
-      symbol,
-      points: normalizeChartSeries(symbol, financials, range).points,
-    }));
-    const latestTimestamp = Math.max(
-      ...normalizedSeries.flatMap(({ points }) => points.map(({ date }) => date.getTime())),
-    );
-    if (!Number.isFinite(latestTimestamp)) return null;
-    const projectionStart = subtractTimeRange(new Date(latestTimestamp), range).getTime();
-    const series = normalizedSeries.flatMap(({ symbol, points }) => {
-      const projectionPoints = visibleSeries ? points : points.filter(({ date }) => date.getTime() >= projectionStart);
-      const base = projectionPoints[0];
-      const latest = projectionPoints.at(-1);
-      if (!base || !latest || !Number.isFinite(base.close) || !Number.isFinite(latest.close) || base.close === 0) {
-        return [];
-      }
-      return [{
-        symbol,
-        base: { date: base.date.toISOString(), value: base.close },
-        latest: { date: latest.date.toISOString(), value: latest.close },
-        returnPercent: ((latest.close - base.close) / base.close) * 100,
-      }];
-    });
-    if (series.length !== normalizedSeries.length) return null;
-    return {
-      kind: "price-comparison",
-      symbols: series.map(({ symbol }) => symbol),
-      range,
-      series,
-    };
-  }
-
-  if (resolved.capability.id === "fundamental-series") {
-    const metric = resolved.options.metric as GraphMetricKey;
-    const period = resolved.options.period as FundamentalPeriod;
-    const periodCount = resolved.options.periods == null ? null : Number(resolved.options.periods);
-    const evidencePeriodCount = Math.min(
-      periodCount ?? (period === "annual" ? 6 : 8),
-      period === "annual" ? 6 : 8,
-    );
-    const series = visibleSeries?.map(({ symbol, points }) => ({
-      symbol, rows: points.slice(-evidencePeriodCount).map(({ date, close }) => ({ date: date.toISOString().slice(0, 10), value: close })),
-    })) ?? payload.financials.map(([symbol, financials]) => ({
-      symbol,
-      rows: limitGraphRowsBySymbol(
-        graphRowsForFinancials(financials, "fundamental", metric, period, symbol),
-        evidencePeriodCount,
-      )
-        .sort((left, right) => left.date.localeCompare(right.date))
-        .map(({ date, value }) => ({ date, value })),
-    }));
-    if (series.some(({ rows }) => rows.length === 0)) return null;
-    return { kind: "fundamental-series", metric, period, series };
-  }
-
-  if (shotRatioTab(resolved)) return financialRatioShotEvidence(resolved, payload);
-  if (resolved.capability.id === "financial-statements") {
-    const [symbol, financials] = payload.financials[0] ?? [];
-    if (!symbol || !financials) return null;
-    const table = buildFinancialTableModel(financials, {
-      period: resolved.options.period as FundamentalPeriod,
-      statement: String(resolved.options.statement),
-    });
-    if (!table || table.statements.length === 0) return null;
-    const allowedKeys = STATEMENT_EVIDENCE_KEYS[table.subTab.key] ?? new Set<string>();
-    const latestPopulated = table.statements.flatMap((statement, statementIndex) => {
-      const seenKeys = new Set<string>();
-      const metrics = table.rows.flatMap((row) => {
-        const key = String(row.key ?? row.summaryKey ?? "");
-        const value = row.cells[statementIndex]?.value;
-        if (!allowedKeys.has(key) || seenKeys.has(key) || typeof value !== "number" || !Number.isFinite(value)) {
-          return [];
-        }
-        seenKeys.add(key);
-        return [{
-          id: row.id,
-          key,
-          label: row.unitLabel,
-          value,
-        }];
-      });
-      return metrics.length > 0 ? [{ statement, metrics }] : [];
-    })[0];
-    if (!latestPopulated) return null;
-    return {
-      kind: "financial-statement",
-      symbol,
-      statement: table.subTab.key,
-      period: table.period,
-      latest: {
-        date: latestPopulated.statement.date,
-        metrics: latestPopulated.metrics,
-      },
-    };
-  }
-
-  return null;
-}
-
-function normalizeChartSeries(
-  symbol: string,
-  financials: TickerFinancials,
-  range: TimeRange,
-): {
-  evidence: PaneScreenshotChartSeriesEvidence;
-  points: Array<{ date: Date; close: number }>;
-} {
-  const sorted = clipPriceHistoryToRange(financials.priceHistory, range)
-    .flatMap((point) => {
-      const date = new Date(point.date);
-      return Number.isFinite(date.getTime()) ? [{ ...point, date }] : [];
-    })
-    .sort((left, right) => left.date.getTime() - right.date.getTime());
-  const points = appendLiveQuotePoint(sorted, financials.quote, { assetCategory: financials.quoteMetadata?.instrumentType })
-    .slice()
-    .sort((left, right) => new Date(left.date).getTime() - new Date(right.date).getTime());
-  return {
-    points,
-    evidence: chartSeriesEvidence(symbol, points),
-  };
-}
-
-function chartSeriesEvidence(
-  symbol: string,
-  points: PricePoint[],
-): PaneScreenshotChartSeriesEvidence {
-  const pointEvidence = (
-    point: typeof points[number] | undefined,
-  ): PaneScreenshotChartPointEvidence | null => (
-    point && Number.isFinite(point.date.getTime())
-      ? { date: point.date.toISOString(), close: point.close }
-      : null
-  );
-  return {
-    symbol,
-    pointCount: points.length,
-    first: pointEvidence(points[0]),
-    last: pointEvidence(points.at(-1)),
-  };
-}
-
-export function chartSeriesEvidenceWithinRange(
-  symbol: string,
-  points: PricePoint[],
-  range: TimeRange,
-): PaneScreenshotChartSeriesEvidence {
-  const dateWindow = buildPresetDateWindow(points.map(({ date }) => date), range);
-  const visiblePoints = getVisibleWindowForDateRange(points, dateWindow, 0).points;
-  return chartSeriesEvidence(symbol, visiblePoints);
-}
-
-function shotExpectedChart(
-  resolved: ResolvedPaneFunction,
-  payload: DesktopPaneShotPayload,
-): PaneScreenshotExpectedChartEvidence | null {
-  if (resolved.pane.id === CHART_COMPOSER_PANE_ID) {
-    const spec = parseChartSpec(resolved.instance.settings?.chartSpec);
-    if (!spec) return null;
-    const capabilityPoint = (point: ResolvedSeries["points"][number] | undefined) => point
-      ? {
-          date: point.date.toISOString(),
-          value: typeof (point.value ?? point.close) === "number" ? point.value ?? point.close ?? null : null,
-        }
-      : null;
-    return {
-      kind: "chart-composer",
-      symbols: [...new Set(spec.series.flatMap((series) => (
-        series.source.kind === "security"
-          ? [publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange)]
-          : []
-      )))],
-      rangePreset: spec.viewport.range,
-      resolution: spec.viewport.resolution,
-      baseSeries: spec.series.map((series) => ({
-        id: series.id,
-        sourceKind: series.source.kind,
-        ...(series.source.kind === "security"
-          ? {
-            symbol: publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange),
-            fieldId: series.source.fieldId,
-          }
-          : series.source.kind === "economic"
-            ? { economicSeriesId: series.source.seriesId }
-            : (() => {
-                const resolvedSeries = payload.chartModel?.series.find((entry) => entry.id === series.id);
-                return {
-                  capabilityId: series.source.capabilityId,
-                  providerSeriesId: series.source.seriesId,
-                  first: capabilityPoint(resolvedSeries?.points[0]),
-                  last: capabilityPoint(resolvedSeries?.points.at(-1)),
-                };
-              })()),
-        style: series.style,
-        transform: series.transform,
-        panelId: series.panelId,
-        visible: series.visible !== false,
-      })),
-    };
-  }
-  if (resolved.capability.id === "price-chart") {
-    const range = String(resolved.options.rangePreset ?? "5Y") as TimeRange;
-    const sourceSeries = payload.financials.slice(0, 1).map(([symbol, financials]) => {
-      const { points } = normalizeChartSeries(symbol, financials, range);
-      return chartSeriesEvidenceWithinRange(symbol, points, range);
-    });
-    return {
-      kind: "stock-price",
-      symbols: sourceSeries.map(({ symbol }) => symbol),
-      rangePreset: range,
-      axisMode: "price",
-      sourceSeries,
-    };
-  }
-  if (resolved.capability.id === "price-comparison") {
-    const range = String(resolved.options.rangePreset ?? "1Y") as TimeRange;
-    const normalizedSeries = payload.financials.map(([symbol, financials]) => (
-      normalizeChartSeries(symbol, financials, range)
-    ));
-    const latestTimestamp = Math.max(
-      ...normalizedSeries.flatMap(({ points }) => points.map(({ date }) => date.getTime())),
-    );
-    const projectionStart = Number.isFinite(latestTimestamp)
-      ? subtractTimeRange(new Date(latestTimestamp), range).getTime()
-      : Number.NaN;
-    const axisMode = String(resolved.options.axisMode ?? "percent");
-    const sourceSeries = normalizedSeries.map(({ evidence, points }) => {
-      const projectionPoints = points.filter(({ date }) => date.getTime() >= projectionStart);
-      const baseValue = projectionPoints[0]?.close ?? null;
-      const latestRawValue = projectionPoints.at(-1)?.close ?? null;
-      const latestValue = baseValue == null || latestRawValue == null
-        ? null
-        : axisMode === "percent"
-          ? ((latestRawValue - baseValue) / baseValue) * 100
-          : latestRawValue;
-      return {
-        ...evidence,
-        projectionBaseValue: baseValue,
-        projectionLatestRawValue: latestRawValue,
-        projectionLatestValue: latestValue,
-      };
-    });
-    return {
-      kind: "price-comparison",
-      symbols: sourceSeries.map(({ symbol }) => symbol),
-      rangePreset: range,
-      axisMode,
-      resolution: String(resolved.options.chartResolution ?? "1d"),
-      sourceSeries,
-    };
-  }
-  return null;
-}
-
-function readStringArray(value: unknown): string[] | null {
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string")
-    ? value
-    : null;
-}
-
-function closeEnough(actual: unknown, expected: number): boolean {
-  return typeof actual === "number"
-    && Number.isFinite(actual)
-    && Math.abs(actual - expected) <= Math.max(1e-8, Math.abs(expected) * 1e-8);
-}
-
-function pointEvidenceMatches(
-  actual: unknown,
-  expected: PaneScreenshotChartPointEvidence | null,
-): boolean {
-  if (expected === null) return actual === null;
-  return isRecord(actual)
-    && actual.date === expected.date
-    && closeEnough(actual.close, expected.close);
-}
-
-function sourceSeriesMismatches(
-  actual: unknown,
-  expected: PaneScreenshotChartSeriesEvidence[],
-): string[] {
-  if (!Array.isArray(actual)) return ["chart source-series evidence is missing"];
-  if (actual.length !== expected.length) return ["chart source-series count does not match"];
-  const mismatches: string[] = [];
-  expected.forEach((expectedSeries, index) => {
-    const actualSeries = actual[index];
-    if (!isRecord(actualSeries) || actualSeries.symbol !== expectedSeries.symbol) {
-      mismatches.push(`chart source symbol ${index + 1} does not match`);
-      return;
-    }
-    if (actualSeries.pointCount !== expectedSeries.pointCount) {
-      mismatches.push(`${expectedSeries.symbol} chart source point count does not match`);
-    }
-    if (!pointEvidenceMatches(actualSeries.first, expectedSeries.first)) {
-      mismatches.push(`${expectedSeries.symbol} chart source first value does not match`);
-    }
-    if (!pointEvidenceMatches(actualSeries.last, expectedSeries.last)) {
-      mismatches.push(`${expectedSeries.symbol} chart source last value does not match`);
-    }
-  });
-  return mismatches;
-}
-
-export function chartEvidenceMismatchesFor(
-  semanticUi: RemoteUiNodeSnapshot[],
-  expected: PaneScreenshotExpectedChartEvidence,
-): string[] {
-  const node = semanticUi.find((candidate) => (
-    candidate.role === "chart-data"
-    && candidate.metadata?.kind === expected.kind
-  ));
-  const metadata = node?.metadata;
-  if (!metadata) return ["rendered chart-data semantic evidence is missing"];
-
-  const mismatches: string[] = [];
-  const symbols = readStringArray(metadata.symbols);
-  if (!symbols || symbols.join("\0") !== expected.symbols.join("\0")) {
-    mismatches.push("rendered chart symbols do not match");
-  }
-  if (metadata.rangePreset !== expected.rangePreset) {
-    mismatches.push("rendered chart range does not match");
-  }
-
-  if (expected.kind === "chart-composer") {
-    if (expected.resolution != null && metadata.resolution !== expected.resolution) {
-      mismatches.push("rendered chart resolution does not match");
-    }
-    const actualSeries = Array.isArray(metadata.baseSeries) ? metadata.baseSeries : [];
-    const expectedSeries = expected.baseSeries ?? [];
-    if (actualSeries.length !== expectedSeries.length) {
-      mismatches.push("rendered chart base-series count does not match");
-    } else {
-      expectedSeries.forEach((series, index) => {
-        const actual = actualSeries[index];
-        if (!isRecord(actual)
-          || actual.id !== series.id
-          || actual.sourceKind !== series.sourceKind
-          || actual.symbol !== series.symbol
-          || actual.fieldId !== series.fieldId
-          || actual.economicSeriesId !== series.economicSeriesId
-          || actual.capabilityId !== series.capabilityId
-          || actual.providerSeriesId !== series.providerSeriesId
-          || (series.sourceKind === "capability" && (
-            JSON.stringify(actual.first) !== JSON.stringify(series.first)
-            || JSON.stringify(actual.last) !== JSON.stringify(series.last)
-          ))
-          || actual.style !== series.style
-          || actual.transform !== series.transform
-          || actual.panelId !== series.panelId
-          || actual.visible !== series.visible) {
-          mismatches.push(`rendered chart series ${series.id} does not match`);
-          return;
-        }
-        if (series.visible && (typeof actual.pointCount !== "number" || actual.pointCount <= 0)) {
-          mismatches.push(`rendered chart series ${series.id} is empty`);
-        }
-      });
-    }
-    if (typeof metadata.projectedPointCount !== "number" || metadata.projectedPointCount <= 0) {
-      mismatches.push("rendered chart projection is empty");
-    }
-    return mismatches;
-  }
-
-  if (expected.kind === "stock-price") {
-    if (metadata.axisMode !== expected.axisMode) {
-      mismatches.push("rendered chart axis mode does not match");
-    }
-    const expectedSeries = expected.sourceSeries?.[0];
-    if (!expectedSeries) return [...mismatches, "expected stock chart source evidence is missing"];
-    mismatches.push(...sourceSeriesMismatches([{
-      symbol: symbols?.[0],
-      pointCount: metadata.sourcePointCount,
-      first: metadata.sourceFirst,
-      last: metadata.sourceLast,
-    }], expected.sourceSeries ?? []));
-    if (typeof metadata.projectedPointCount !== "number" || metadata.projectedPointCount <= 0) {
-      mismatches.push("rendered stock chart projection is empty");
-    }
-    return mismatches;
-  }
-
-  if (metadata.requestedAxisMode !== expected.axisMode || metadata.effectiveAxisMode !== expected.axisMode) {
-    mismatches.push("rendered comparison axis mode does not match");
-  }
-  if (
-    expected.resolution != null
-    && (
-      metadata.selectedResolution !== expected.resolution
-      || metadata.effectiveResolution !== expected.resolution
-    )
-  ) {
-    mismatches.push("rendered comparison resolution does not match");
-  }
-  const expectedSourceSeries = expected.sourceSeries ?? [];
-  mismatches.push(...sourceSeriesMismatches(metadata.sourceSeries, expectedSourceSeries));
-
-  const projectionSeries = Array.isArray(metadata.projectionSeries)
-    ? metadata.projectionSeries
-    : [];
-  if (projectionSeries.length !== expectedSourceSeries.length) {
-    mismatches.push("rendered comparison projection-series count does not match");
-  } else {
-    expectedSourceSeries.forEach((expectedSeries, index) => {
-      const actualSeries = projectionSeries[index];
-      if (!isRecord(actualSeries) || actualSeries.symbol !== expectedSeries.symbol) {
-        mismatches.push(`${expectedSeries.symbol} comparison projection is missing`);
-        return;
-      }
-      const baseValue = expectedSeries.projectionBaseValue;
-      const latestRawValue = expectedSeries.projectionLatestRawValue;
-      if (baseValue == null || latestRawValue == null) {
-        mismatches.push(`${expectedSeries.symbol} expected comparison values are empty`);
-        return;
-      }
-      const latestValue = expectedSeries.projectionLatestValue;
-      if (!closeEnough(actualSeries.baseValue, baseValue)) {
-        mismatches.push(`${expectedSeries.symbol} comparison base value does not match`);
-      }
-      if (!closeEnough(actualSeries.latestRawValue, latestRawValue)) {
-        mismatches.push(`${expectedSeries.symbol} comparison latest value does not match`);
-      }
-      if (latestValue == null || !closeEnough(actualSeries.latestValue, latestValue)) {
-        mismatches.push(`${expectedSeries.symbol} comparison transformed value does not match`);
-      }
-      if (actualSeries.pointCount !== metadata.projectedPointCount) {
-        mismatches.push(`${expectedSeries.symbol} comparison projection point count does not match`);
-      }
-    });
-  }
-  if (typeof metadata.projectedPointCount !== "number" || metadata.projectedPointCount <= 0) {
-    mismatches.push("rendered comparison projection is empty");
-  }
-  return mismatches;
-}
-
-export function intradayChartEvidenceMismatchesFor(
-  resolved: ResolvedPaneFunction,
-  payload: DesktopPaneShotPayload,
-  semanticUi: RemoteUiNodeSnapshot[],
-): string[] {
-  if (resolved.capability.id !== "intraday-price-chart") return [];
-  const intraday = payload.intradayHistories[0];
-  if (!intraday || intraday.points.length === 0) return [];
-  const metadata = semanticUi.find((node) => (
-    node.role === "chart-data" && node.metadata?.kind === "chart-composer"
-  ))?.metadata;
-  if (!metadata) return ["rendered intraday chart-data semantic evidence is missing"];
-  const baseSeries = Array.isArray(metadata.baseSeries) ? metadata.baseSeries : [];
-  const actual = baseSeries[0];
-  if (!isRecord(actual)) return ["rendered intraday base series is missing"];
-
-  const expected = chartSeriesEvidence(intraday.symbol, intraday.points);
-  const mismatches: string[] = [];
-  if (actual.pointCount !== expected.pointCount) {
-    mismatches.push("rendered intraday point count does not match");
-  }
-  if (metadata.projectedPointCount !== expected.pointCount) {
-    mismatches.push("rendered intraday projection point count does not match");
-  }
-  const pointMatches = (
-    actualPoint: unknown,
-    expectedPoint: PaneScreenshotChartPointEvidence | null,
-  ): boolean => {
-    if (!isRecord(actualPoint) || !expectedPoint) return false;
-    return actualPoint.date === expectedPoint.date
-      && typeof actualPoint.value === "number"
-      && closeEnough(actualPoint.value, expectedPoint.close);
-  };
-  if (!pointMatches(actual.first, expected.first)) {
-    mismatches.push("rendered intraday first bar does not match");
-  }
-  if (!pointMatches(actual.last, expected.last)) {
-    mismatches.push("rendered intraday last bar does not match");
-  }
-  return mismatches;
-}
-
-export function shotUnavailableSymbols(
-  resolved: ResolvedPaneFunction,
-  payload: DesktopPaneShotPayload,
-  semanticUi: RemoteUiNodeSnapshot[] = [],
-): string[] {
-  const evidenceHook = paneScreenshotEvidenceHook(resolved);
-  if (evidenceHook) return evidenceHook.unavailable(renderedPaneEvidence(evidenceHook, semanticUi), { resolved, payload });
-  if (resolved.capability.id === "chart-composer") {
-    const metadata = semanticUi.find((node) => (
-      node.role === "chart-data" && node.metadata?.kind === "chart-composer"
-    ))?.metadata;
-    const baseSeries = Array.isArray(metadata?.baseSeries) ? metadata.baseSeries : [];
-    return baseSeries.flatMap((entry) => {
-      if (!isRecord(entry) || (typeof entry.pointCount === "number" && entry.pointCount > 0)) return [];
-      if (entry.sourceKind === "security" && typeof entry.symbol === "string") return [entry.symbol];
-      if (entry.sourceKind === "economic" && typeof entry.economicSeriesId === "string") {
-        return [`FRED:${entry.economicSeriesId}`];
-      }
-      if (entry.sourceKind === "capability" && typeof entry.capabilityId === "string" && typeof entry.providerSeriesId === "string") {
-        return [`CAP:${entry.capabilityId}:${entry.providerSeriesId}`];
-      }
-      return [];
-    });
-  }
-  if (resolved.capability.id === "intraday-price-chart") {
-    const symbol = payload.intradayHistories[0]?.symbol ?? payload.financials[0]?.[0];
-    const metadata = semanticUi.find((node) => (
-      node.role === "chart-data" && node.metadata?.kind === "chart-composer"
-    ))?.metadata;
-    const renderedPoints = typeof metadata?.projectedPointCount === "number"
-      ? metadata.projectedPointCount
-      : 0;
-    return symbol && renderedPoints <= 0 ? [symbol] : [];
-  }
-  const graphKind = shotGraphKind(resolved);
-  if (graphKind) {
-    const metric = resolved.options.metric as GraphMetricKey;
-    const period = resolved.options.period as FundamentalPeriod;
-    const periodCount = resolved.options.periods == null ? null : Number(resolved.options.periods);
-    return payload.financials.flatMap(([symbol, financials]) => (
-      limitGraphRowsBySymbol(
-        graphRowsForFinancials(financials, graphKind, metric, period, symbol),
-        periodCount,
-      ).length === 0 ? [symbol] : []
-    ));
-  }
-  if (["price-chart", "historical-prices"].includes(resolved.capability.id)) {
-    return payload.financials.flatMap(([symbol, financials]) => financials.priceHistory.length > 0 ? [] : [symbol]);
-  }
-  if (["price-comparison", "return-correlation", "security-relationship"].includes(resolved.capability.id)) {
-    return payload.financials.flatMap(([symbol, financials]) => financials.priceHistory.length > 1 ? [] : [symbol]);
-  }
-  if (resolved.capability.id === "financial-statements") {
-    return payload.financials.flatMap(([symbol, financials]) => {
-      const count = resolved.options.period === "quarterly"
-        ? financials.quarterlyStatements.length
-        : financials.annualStatements.length;
-      return count > 0 ? [] : [symbol];
-    });
-  }
-  return payload.financials.flatMap(([symbol, financials]) => financials.quote ? [] : [symbol]);
-}
-
-function shotGraphKind(resolved: ResolvedPaneFunction): GraphKind | null {
-  if (resolved.capability.id === "fundamental-series") return "fundamental";
-  if (resolved.capability.id === "valuation-series") return "valuation";
-  return null;
-}
-
-export function shotSemanticRowCount(
-  resolved: ResolvedPaneFunction,
-  payload: DesktopPaneShotPayload,
-  semanticUi: RemoteUiNodeSnapshot[] = [],
-): number {
-  const evidenceHook = paneScreenshotEvidenceHook(resolved);
-  if (evidenceHook) return renderedPaneEvidence(evidenceHook, semanticUi)?.plottedValueCount ?? 0;
-  if (resolved.capability.id === "chart-composer") {
-    const metadata = semanticUi.find((node) => (
-      node.role === "chart-data" && node.metadata?.kind === "chart-composer"
-    ))?.metadata;
-    const baseSeries = Array.isArray(metadata?.baseSeries) ? metadata.baseSeries : [];
-    return baseSeries.reduce((count, entry) => (
-      count + (isRecord(entry) && typeof entry.pointCount === "number" ? Math.max(0, entry.pointCount) : 0)
-    ), 0);
-  }
-  if (resolved.capability.id === "intraday-price-chart") {
-    const metadata = semanticUi.find((node) => (
-      node.role === "chart-data" && node.metadata?.kind === "chart-composer"
-    ))?.metadata;
-    return typeof metadata?.projectedPointCount === "number"
-      ? Math.max(0, metadata.projectedPointCount)
-      : 0;
-  }
-  const graphKind = shotGraphKind(resolved);
-  if (graphKind) {
-    const metric = resolved.options.metric as GraphMetricKey;
-    const period = resolved.options.period as FundamentalPeriod;
-    const periodCount = resolved.options.periods == null ? null : Number(resolved.options.periods);
-    return payload.financials.reduce((count, [symbol, financials]) => (
-      count + limitGraphRowsBySymbol(
-        graphRowsForFinancials(financials, graphKind, metric, period, symbol),
-        periodCount,
-      ).length
-    ), 0);
-  }
-  if (["price-chart", "historical-prices"].includes(resolved.capability.id)) {
-    return payload.financials[0]?.[1].priceHistory.length ?? 0;
-  }
-  if (["price-comparison", "return-correlation", "security-relationship"].includes(resolved.capability.id)) {
-    return payload.financials.filter(([, financials]) => financials.priceHistory.length > 1).length;
-  }
-  if (resolved.capability.id === "financial-statements") {
-    const financials = payload.financials[0]?.[1];
-    const period = resolved.options.period;
-    return period === "quarterly"
-      ? financials?.quarterlyStatements.length ?? 0
-      : financials?.annualStatements.length ?? 0;
-  }
-  return payload.financials.filter(([, financials]) => !!financials.quote).length;
-}
-
-export function shotExpectedText(
-  resolved: ResolvedPaneFunction,
-  symbols: string[],
-  payload: DesktopPaneShotPayload,
-): string[] {
-  const expected = [...symbols, ...(paneScreenshotEvidenceHook(resolved)?.expectedText?.({ resolved, payload }) ?? [])];
-  const graphKind = shotGraphKind(resolved);
-  if (graphKind) {
-    const metric = resolved.options.metric as GraphMetricKey;
-    const definition = metricDef(graphKind, metric);
-    const period = resolved.options.period as FundamentalPeriod;
-    const periodCount = resolved.options.periods == null ? null : Number(resolved.options.periods);
-    if (resolved.pane.id === CHART_COMPOSER_PANE_ID) {
-      // Chart series are labelled with the field short label ("P/S"), not the
-      // catalog label ("Price / Sales").
-      const field = getTimeSeriesField(`${graphKind}.${metric}`);
-      expected.push(field?.shortLabel ?? definition.label);
-      return expected.filter(Boolean);
-    }
-    expected.push(definition.label);
-    for (const [symbol, financials] of payload.financials) {
-      const latestRow = limitGraphRowsBySymbol(
-        graphRowsForFinancials(financials, graphKind, metric, period, symbol),
-        periodCount,
-      ).sort((left, right) => left.date.localeCompare(right.date)).at(-1);
-      if (latestRow) {
-        expected.push(latestRow.date);
-        expected.push(definition.format(latestRow.value));
-      }
-    }
-  } else if (resolved.capability.id === "financial-statements") {
-    const statementLabels: Record<string, string> = {
-      income: "Income",
-      balance: "Balance",
-      cashflow: "Cash Flow",
-    };
-    // A ratio tab names itself in the query bar and leads with its first ratio.
-    const ratioTab = shotRatioTab(resolved);
-    expected.push(ratioTab?.name ?? statementLabels[String(resolved.options.statement)] ?? "");
-    expected.push(resolved.options.period === "annual" ? "Annual" : "Quarterly");
-    const financials = payload.financials[0]?.[1];
-    if (financials) {
-      const table = buildFinancialTableModel(financials, {
-        period: resolved.options.period as FundamentalPeriod,
-        statement: String(resolved.options.statement),
-      });
-      const latestStatement = table?.statements[0];
-      const firstMetric = table?.rows[0];
-      // The pane prints the compact header: date, currency and an S/P source marker.
-      if (latestStatement) {
-        const currency = latestStatement.currency ?? financialStatementCurrency(
-          financials,
-          [...(financials.annualStatements ?? []), ...(financials.quarterlyStatements ?? [])],
-        );
-        expected.push(formatFinancialHeader(
-          latestStatement.date,
-          currency,
-          latestStatement.dateSource,
-          true,
-          latestStatement.aggregation?.periodEnd,
-        ).trim());
-      }
-      const firstLabel = ratioTab ? ratioTab.ratios[0]?.label : firstMetric?.unitLabel;
-      if (firstLabel) expected.push(firstLabel);
-    }
-  }
-  return expected.filter(Boolean);
-}
-
-function shotExpectedSelections(
-  resolved: ResolvedPaneFunction,
-): PaneScreenshotExpectedSelection[] {
-  if (resolved.pane.id === CHART_COMPOSER_PANE_ID) return [];
-  if (shotGraphKind(resolved)) {
-    return [{
-      control: "metric",
-      value: String(resolved.options.metric),
-    }];
-  }
-  if (resolved.capability.id !== "financial-statements") return [];
-  const ratioTab = shotRatioTab(resolved);
-  if (ratioTab) {
-    return [
-      { control: "ratio", value: ratioTab.key, label: ratioTab.name },
-      { control: "period", value: String(resolved.options.period) },
-    ];
-  }
-  const labels: Record<string, string> = {
-    income: "Income",
-    cashflow: "Cash Flow",
-    balance: "Balance Sheet",
-  };
-  return [
-    {
-      control: "statement",
-      label: labels[String(resolved.options.statement)] ?? String(resolved.options.statement),
-    },
-    {
-      control: "period",
-      value: String(resolved.options.period),
-    },
-  ];
-}
-
-export function missingActiveTabSelections(
-  semanticUi: RemoteUiNodeSnapshot[],
-  expected: PaneScreenshotExpectedSelection[],
-): PaneScreenshotExpectedSelection[] {
-  const activeTabs = semanticUi.flatMap((node): { value: string | null; label: string | null }[] => {
-    if (!node.metadata) return [];
-    // Query bars carry the active choice of each inline filter and the view.
-    if (node.role === "query-bar") {
-      const selections = Array.isArray(node.metadata.selections) ? node.metadata.selections : [];
-      return selections.flatMap((selection) => (
-        isRecord(selection) ? [{
-          value: typeof selection.value === "string" ? selection.value : null,
-          label: typeof selection.label === "string" ? selection.label : null,
-        }] : []
-      ));
-    }
-    if (node.role !== "tabs") return [];
-    const activeValue = typeof node.metadata.activeValue === "string"
-      ? node.metadata.activeValue
-      : null;
-    const tabs = Array.isArray(node.metadata.tabs)
-      ? node.metadata.tabs.filter((tab): tab is Record<string, unknown> => (
-        !!tab && typeof tab === "object" && !Array.isArray(tab)
-      ))
-      : [];
-    const activeTab = tabs.find((tab) => String(tab.value) === activeValue);
-    return [{
-      value: activeValue,
-      label: typeof activeTab?.label === "string" ? activeTab.label : null,
-    }];
-  });
-
-  return expected.filter((selection) => !activeTabs.some((active) => (
-    (selection.value == null || active.value === selection.value)
-    && (selection.label == null || active.label?.toLowerCase() === selection.label.toLowerCase())
-  )));
-}