gloomberb 0.15.7 → 0.16.0

package/src/api-client/web-experiments.ts

@@ -0,0 +1,136 @@
+/**
+ * A/B experiments on the hosted web terminal (term.gloom.sh).
+ *
+ * The registry, the bucketing and the bot rules live with the API
+ * (gloomberb-platform `shared/experiments.ts`). The terminal asks for its arm
+ * at the moment an experiment's change would show, in every arm, and that
+ * request is the exposure: the API answers with the variant and counts the
+ * visitor in it. Turning an experiment off there takes effect here without a
+ * release.
+ *
+ * The first variant this browser is given is kept and sent back, so a visitor
+ * whose anonymous id changes later stays in the same arm, and it rides on every
+ * later milestone as `experiments`, which the API turns into `exp_<key>` and
+ * saves to the account once they sign in.
+ */
+
+export interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+export interface ExperimentAnswer {
+  accepted: boolean;
+  variant?: string;
+}
+
+export interface ExperimentExposureRequest {
+  experiment: string;
+  /** The variant this browser was given before, if any. */
+  variant?: string;
+}
+
+export interface WebExperimentEnvironment {
+  /** Absent with Do Not Track or Global Privacy Control: the terminal never minted one. */
+  anonymousId: string | undefined;
+  signedIn: boolean;
+  /** A browser driven by automation (`navigator.webdriver`). */
+  automated: boolean;
+  /** Kept across visits: the first variant of each experiment. */
+  local: StorageLike;
+  /** Kept for this browser session: the experiments already counted in it. */
+  session: StorageLike;
+  ask(request: ExperimentExposureRequest): Promise<ExperimentAnswer>;
+}
+
+export const EXPERIMENTS_STORAGE_KEY = "gloomberb.web.experiments";
+const EXPOSED_SESSION_KEY = "gloomberb.web.experiments-exposed";
+
+const ASSIGNMENT = /^([a-z][a-z0-9_]{0,47}):([a-z][a-z0-9_]{0,47})$/;
+const MAX_ASSIGNMENTS_LENGTH = 500;
+
+/** "web_terminal_trial_offer:offer,other:control", the API's format, to an ordered map. */
+function parseExperimentAssignments(value: string | null | undefined): Map<string, string> {
+  const assignments = new Map<string, string>();
+  for (const part of (value ?? "").split(",")) {
+    const match = ASSIGNMENT.exec(part.trim());
+    if (match && !assignments.has(match[1]!)) assignments.set(match[1]!, match[2]!);
+  }
+  return assignments;
+}
+
+function serializeExperimentAssignments(assignments: ReadonlyMap<string, string>): string | undefined {
+  let serialized = "";
+  for (const [key, variant] of assignments) {
+    const part = `${key}:${variant}`;
+    if (!ASSIGNMENT.test(part)) continue;
+    const next = serialized ? `${serialized},${part}` : part;
+    if (next.length > MAX_ASSIGNMENTS_LENGTH) break;
+    serialized = next;
+  }
+  return serialized || undefined;
+}
+
+function read(storage: StorageLike, key: string): string | null {
+  try {
+    return storage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+
+function write(storage: StorageLike, key: string, value: string): void {
+  try {
+    storage.setItem(key, value);
+  } catch {
+    /* Private browsing still runs the terminal; the arm is just not remembered. */
+  }
+}
+
+/** The stored assignments as the attribution string, or undefined when there are none. */
+export function storedExperimentAssignments(storage: StorageLike): string | undefined {
+  return serializeExperimentAssignments(parseExperimentAssignments(read(storage, EXPERIMENTS_STORAGE_KEY)));
+}
+
+const pending = new Map<string, Promise<string | null>>();
+
+/**
+ * The variant to show, or null to show nothing: the visitor is signed in, has
+ * no anonymous id, is an automated browser, was already counted in this
+ * browser session, or the API did not put them in the experiment (a bot, the
+ * experiment ended, the request failed). Call it when the change would show,
+ * in every arm.
+ */
+export function exposeExperiment(experiment: string, env: WebExperimentEnvironment): Promise<string | null> {
+  if (!env.anonymousId || env.signedIn || env.automated) return Promise.resolve(null);
+  if (parseSessionList(read(env.session, EXPOSED_SESSION_KEY)).has(experiment)) return Promise.resolve(null);
+  const inFlight = pending.get(experiment);
+  if (inFlight) return inFlight;
+
+  const request = (async () => {
+    const assignments = parseExperimentAssignments(read(env.local, EXPERIMENTS_STORAGE_KEY));
+    let answer: ExperimentAnswer;
+    try {
+      answer = await env.ask({ experiment, variant: assignments.get(experiment) });
+    } catch {
+      // Not counted, so the next page load in this session may ask again.
+      return null;
+    }
+    const exposed = parseSessionList(read(env.session, EXPOSED_SESSION_KEY));
+    exposed.add(experiment);
+    write(env.session, EXPOSED_SESSION_KEY, [...exposed].join(","));
+    if (!answer.accepted || !answer.variant || !ASSIGNMENT.test(`${experiment}:${answer.variant}`)) return null;
+    if (!assignments.has(experiment)) {
+      assignments.set(experiment, answer.variant);
+      const serialized = serializeExperimentAssignments(assignments);
+      if (serialized) write(env.local, EXPERIMENTS_STORAGE_KEY, serialized);
+    }
+    return answer.variant;
+  })().finally(() => pending.delete(experiment));
+  pending.set(experiment, request);
+  return request;
+}
+
+function parseSessionList(value: string | null): Set<string> {
+  return new Set((value ?? "").split(",").filter(Boolean));
+}

package/src/app/pane-runtime/plugin-bindings.ts

@@ -27,6 +27,8 @@ import {
 import type { PluginRegistry } from "../../plugins/registry";
 import { reportCrash } from "../../telemetry/crash-reports";
 import { recordFunctionOpen, usageFunctionForPane } from "../../telemetry/usage-counts";
+import { captureAttentionAction } from "../../telemetry/attention-counts";
+import { publicTickerKey } from "../../utils/exchanges";
 import {
   resolveTickerNavigationReplacementPane,
   shouldFocusTickerNavigationTarget,
@@ -252,6 +254,7 @@ export function bindAppPanePluginRegistry({
     },
     navigateTicker: (rawSymbol, options) => {
       if (isDetachedWindow) return;
+      const recordAttention = captureAttentionAction();
       recordFunctionOpen(usageFunctionForPane(pluginRegistry, TICKER_RESEARCH_PANE_ID));
       const sourcePaneId = options?.sourcePaneId ?? stateRef.current.focusedPaneId;
       const requests = tickerNavigationRequests.get(pluginRegistry) ?? new Map<string | null, symbol>();
@@ -311,12 +314,14 @@ export function bindAppPanePluginRegistry({
             };
             persistLayout(nextLayout);
             focusIfStillOwned(detailPane.instanceId);
+            recordAttention(publicTickerKey(symbol, target.listing?.exchange ?? target.ticker.metadata.exchange), "des");
           } else if (shouldFocusTickerNavigationTarget({
             sourcePaneId,
             currentFocusedPaneId: stateRef.current.focusedPaneId,
             targetPaneId: null,
           })) {
             placePinnedTickerTarget(target, { floating: false });
+            recordAttention(publicTickerKey(symbol, target.listing?.exchange ?? target.ticker.metadata.exchange), "des");
           }
         } catch (err) {
           if (!canPresentFeedback()) return;

package/src/app/pane-runtime/ticker-open-runtime.ts

@@ -24,7 +24,8 @@ import {
 } from "../../tickers/open-target";
 import { AmbiguousTickerError, findExactTickerSearchMatch } from "../../tickers/search";
 import { isDialogOpen } from "../../ui/dialog-stack";
-import { parsePublicTickerKey } from "../../utils/exchanges";
+import { parsePublicTickerKey, publicTickerKey } from "../../utils/exchanges";
+import { attentionActionForPane, captureAttentionAction } from "../../telemetry/attention-counts";
 import { tickerHasListingSuffix } from "../../sources/listing-symbols";
 import { instrumentFromTicker } from "../../market-data/request-types";
 import { tickerInstrumentLabel } from "../../tickers/instrument-label";
@@ -185,13 +186,18 @@ export function useAppTickerOpenRuntime({
   ]);
 
   const openPinnedTicker = useCallback(async (rawSymbol: string, options?: PinTickerOptions) => {
+    const recordAttention = captureAttentionAction();
     const selectedTicker = options?.instrument !== undefined && (options.instrument || options.listing) ? await tickerRepository.loadTicker(rawSymbol) : null;
     const target = selectedTicker
       ? { symbol: selectedTicker.metadata.ticker, ticker: selectedTicker, created: false, instrument: options?.instrument, listing: options?.listing }
       : await resolveOpenTickerTarget(rawSymbol, options?.instrument === null);
     if (!target) return;
     placePinnedTickerTarget(target, options);
-  }, [placePinnedTickerTarget, resolveOpenTickerTarget, tickerRepository]);
+    const action = attentionActionForPane(options?.paneType ?? TICKER_RESEARCH_PANE_ID);
+    if (action && pluginRegistry.panes.has(options?.paneType ?? TICKER_RESEARCH_PANE_ID)) {
+      recordAttention(publicTickerKey(target.symbol, target.listing?.exchange ?? target.ticker.metadata.exchange), action);
+    }
+  }, [placePinnedTickerTarget, pluginRegistry, resolveOpenTickerTarget, tickerRepository]);
 
   return {
     openPinnedTicker,

package/src/app/runtime/update.ts

@@ -7,8 +7,10 @@ import {
   checkForUpdateDetailed,
   performUpdate,
   type ReleaseInfo,
+  type UpdateCheckResult,
 } from "../../updater";
 import { VERSION } from "../../version";
+import { reportCrash } from "../../telemetry/crash-reports";
 import { runAutomated } from "../../telemetry/usage-counts";
 
 const UPDATE_CHECK_INTERVAL_MS = 60 * 60_000; // hourly
@@ -48,7 +50,17 @@ export function useAppUpdateRuntime({
       dispatch({ type: "SET_UPDATE_NOTICE", notice: null });
     }
 
-    const result = await checkForUpdateDetailed(VERSION);
+    // The desktop host can reject (its RPC request timed out). That is a
+    // failed check like any other: the hourly one must not end as an
+    // unhandled rejection, and a manual one must clear its progress state.
+    // The timeout is still reported, as it was when it went unhandled.
+    const result = await checkForUpdateDetailed(VERSION).catch((error: unknown): UpdateCheckResult => {
+      const message = error instanceof Error ? error.message : "";
+      if (message.startsWith("RPC request timed out")) {
+        reportCrash(error, { kind: "unhandled-rejection" });
+      }
+      return { kind: "error", error: message || "Update check failed" };
+    });
 
     if (!manual) {
       if (result.kind === "available") {

package/src/cli/commands/system.ts

@@ -19,6 +19,7 @@ const DOCTOR_COUNT_UNITS: Record<string, string> = { plugins: "loaded", capabili
 const TELEMETRY_CONFIG_KEYS = {
   "telemetry.crashReports": "crashReports",
   "telemetry.usage": "usage",
+  "telemetry.attention": "attention",
 } as const satisfies Record<string, keyof TelemetryConfig>;
 type TelemetryConfigKey = keyof typeof TELEMETRY_CONFIG_KEYS;
 const EDITABLE_CONFIG_KEYS = ["baseCurrency", "refreshIntervalMinutes", "theme", "valueFlashingEnabled", ...Object.keys(TELEMETRY_CONFIG_KEYS)];
@@ -195,6 +196,7 @@ export function createSystemCliCommands(): CliCommandDef[] {
           valueFlashingEnabled: context.config.valueFlashingEnabled,
           "telemetry.crashReports": context.config.telemetry?.crashReports !== false,
           "telemetry.usage": context.config.telemetry?.usage !== false,
+          "telemetry.attention": context.config.telemetry?.attention === true,
         };
 
         if (action === "list") {

package/src/cli/desktop-pane-shot.ts

@@ -546,7 +546,6 @@ async function readRenderedPaneState(session: CdpSession): Promise<DesktopPaneSh
         .forEach((table, tableIndex) => {
           const tableMetadata = semanticTables[tableIndex] && semanticTables[tableIndex].metadata || {};
           const semanticColumns = Array.isArray(tableMetadata.columns) ? tableMetadata.columns : [];
-          const semanticRows = Array.isArray(tableMetadata.rows) ? tableMetadata.rows : [];
           const headers = [...table.querySelectorAll('[data-gloom-role="data-table-header-cell"]')]
             .map((cell) => normalize(cell.innerText || cell.textContent));
           const rowElements = [...table.querySelectorAll(
@@ -555,7 +554,7 @@ async function readRenderedPaneState(session: CdpSession): Promise<DesktopPaneSh
           rowElements.forEach((row, rowIndex) => {
             const cellElements = [...row.querySelectorAll('[data-gloom-role="data-table-cell"]')];
             const values = cellElements.length > 0 ? cellElements : [row];
-            const semanticRow = semanticRows[rowIndex] || {};
+            const rowKey = row.getAttribute("data-gloom-row-key");
             const cells = values.map((cell, cellIndex) => {
               const semanticColumn = semanticColumns[cellIndex] || {};
               const text = normalize(cell.innerText || cell.textContent);
@@ -582,8 +581,8 @@ async function readRenderedPaneState(session: CdpSession): Promise<DesktopPaneSh
             rows.push({
               tableIndex,
               rowIndex,
-              ...(typeof semanticRow.key === "string" ? { key: semanticRow.key } : {}),
-              selected: row.getAttribute("data-selected") === "true" || semanticRow.selected === true,
+              ...(rowKey ? { key: rowKey } : {}),
+              selected: row.getAttribute("data-selected") === "true",
               cells,
             });
           });

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

@@ -9,6 +9,14 @@ import { cleanTickerInput } from "./options";
 import { parsePublicTickerKey, publicTickerKey } from "../../utils/exchanges";
 import type { ResolvedPaneFunction } from "./resolver";
 import { toMarketDataContext } from "../../market-data/selectors";
+import { loadSeasonalityHistory, SEASONALITY_HISTORY_RESOLUTION } from "../../plugins/builtin/seasonality/client";
+import type { InstrumentRef } from "../../market-data/request-types";
+import { CORRELATION_HISTORY_RESOLUTION, loadCorrelationHistory } from "../../plugins/builtin/correlation/history";
+import type { TimeRange } from "../../time-series/range";
+import { loadPeriodEndHistory, PERIOD_END_HISTORY_RESOLUTION } from "../../plugins/builtin/ticker-detail/financials/period-end-history";
+import { latestFinancialPeriodEnd } from "../../plugins/builtin/ticker-detail/financials/model";
+import { oldestRatioPeriodEnd, periodEndClose, ratioStatements } from "../../plugins/builtin/ticker-detail/financials/ratios";
+import { shotFinancialPeriod } from "./financial-ratio-shot";
 
 const SHOT_PRICE_HISTORY_RANGE = "5Y" as const;
 const FINANCIAL_ANALYSIS_PANE_ID = "financial-analysis";
@@ -57,6 +65,76 @@ export async function withShotPriceHistory(
   }
 }
 
+/**
+ * SEAS reads monthly closes. Captured history answers every request, so the
+ * weekly seed would stand in for them and price each month at a week's close.
+ * The pane's own load fetches them, tagged so no other cadence is answered.
+ */
+export async function withShotSeasonalityHistory(
+  context: MarketContext,
+  instrument: InstrumentRef,
+  financials: TickerFinancials,
+): Promise<TickerFinancials> {
+  const monthly = await loadSeasonalityHistory({ instrument, forceRefresh: context.refresh }, context.dataProvider);
+  if (monthly.error || monthly.stale) {
+    throw new Error(`${instrument.symbol}: ${monthly.error ?? "monthly price history is stale"}`);
+  }
+  return { ...financials, priceHistory: monthly.history, priceHistoryResolution: SEASONALITY_HISTORY_RESOLUTION };
+}
+
+/** Correlation and relationship panes read daily returns at every range. */
+export function readsDailyReturns(resolved: ResolvedPaneFunction): boolean {
+  return resolved.capability.id === "return-correlation" || resolved.capability.id === "security-relationship";
+}
+
+/**
+ * A range capture is weekly at 5Y and monthly at ALL. Captured history answers
+ * the panes' daily request, so it would turn their daily returns into weekly or
+ * monthly ones.
+ */
+export async function withShotDailyReturns(
+  context: MarketContext,
+  instrument: InstrumentRef,
+  exchange: string,
+  range: TimeRange,
+  financials: TickerFinancials,
+): Promise<TickerFinancials> {
+  const priceHistory = await loadCorrelationHistory(context.dataProvider, instrument.symbol, exchange, range,
+    { ...toMarketDataContext(instrument), ...(context.refresh ? { cacheMode: "refresh" as const } : {}) });
+  return { ...financials, priceHistory, priceHistoryResolution: CORRELATION_HISTORY_RESOLUTION };
+}
+
+/**
+ * Valuation prices each column at its period-end close and accepts only daily
+ * bars. Captured history answers every request, so the weekly seed stood in
+ * for them and every cell read "no price". The pane's own load fetches daily
+ * closes back to its oldest column, tagged so no other cadence is answered.
+ */
+export async function withShotPeriodEndHistory(
+  context: MarketContext,
+  instrument: InstrumentRef,
+  exchange: string,
+  resolved: ResolvedPaneFunction,
+  financials: TickerFinancials,
+): Promise<TickerFinancials> {
+  const statements = ratioStatements(financials, shotFinancialPeriod(resolved, financials));
+  const oldest = oldestRatioPeriodEnd(statements);
+  // Without statements the pane shows its empty state, which the shot reports.
+  if (!oldest) return financials;
+  const fail = (reason: string) => new Error(`${instrument.symbol}: ${reason}`);
+  const priceHistory = await loadPeriodEndHistory(context.dataProvider, instrument.symbol, exchange, oldest,
+    { ...toMarketDataContext(instrument), ...(context.refresh ? { cacheMode: "refresh" as const } : {}) })
+    .catch((error: unknown) => { throw fail(error instanceof Error ? error.message : String(error)); });
+  const last = priceHistory.reduce((latest, point) => Math.max(latest, new Date(point.date).getTime() || -Infinity), -Infinity);
+  if (!Number.isFinite(last)) throw fail("daily price history is unavailable");
+  const lastClose = new Date(last).toISOString().slice(0, 10);
+  const newest = latestFinancialPeriodEnd(statements)!;
+  if (lastClose < newest && periodEndClose(priceHistory, newest) === undefined) {
+    throw fail(`daily price history is stale: the last close is ${lastClose}, before the ${newest} period end`);
+  }
+  return { ...financials, priceHistory, priceHistoryResolution: PERIOD_END_HISTORY_RESOLUTION };
+}
+
 export function isFinancialAnalysisFunction(resolved: ResolvedPaneFunction): boolean {
   if (resolved.pane.id === FINANCIAL_ANALYSIS_PANE_ID) return true;
   if (resolved.template?.id === FINANCIAL_ANALYSIS_TEMPLATE_ID) return true;

package/src/cli/pane-functions/financial-ratio-shot.ts

@@ -0,0 +1,160 @@
+import type { TickerFinancials } from "../../types/financials";
+import type { DesktopPaneShotPayload, DesktopPaneShotRenderResult } from "../desktop-pane-shot";
+import type { ResolvedPaneFunction } from "./resolver";
+import { createValuationCurrencyContext } from "../../time-series/valuation-currency";
+import {
+  resolveFinancialPeriod,
+  resolveFinancialPeriodOption,
+  type FinancialPeriod,
+} from "../../plugins/builtin/ticker-detail/financials/model";
+import { PERIOD_END_HISTORY_RESOLUTION } from "../../plugins/builtin/ticker-detail/financials/period-end-history";
+import {
+  findRatioTab,
+  formatRatioInput,
+  formatRatioValue,
+  ratioPeriodEnd,
+  ratioTableForFinancials,
+  resolveFinancialSectionKey,
+  type RatioTabDef,
+  type RatioTableModel,
+} from "../../plugins/builtin/ticker-detail/financials/ratios";
+
+export interface PaneScreenshotFinancialRatioEvidence {
+  kind: "financial-ratios";
+  symbol: string;
+  statement: string;
+  period: FinancialPeriod;
+  /** The newest column with a ratio, and the close it was priced at. */
+  latest: {
+    date: string;
+    periodEnd: string;
+    price: number | null;
+    ratios: Array<{ id: string; label: string; value: number }>;
+  };
+}
+
+/** The ratio tab an FA shot opens, or null for a statement tab. */
+export function shotRatioTab(resolved: ResolvedPaneFunction): RatioTabDef | null {
+  if (resolved.capability.id !== "financial-statements") return null;
+  return findRatioTab(resolveFinancialSectionKey(String(resolved.options.statement ?? ""))) ?? null;
+}
+
+/** The period FA shows: the requested one, or the other when it has no statements. */
+export function shotFinancialPeriod(resolved: ResolvedPaneFunction, financials: TickerFinancials): FinancialPeriod {
+  const hasAnnual = financials.annualStatements.length > 0;
+  const hasQuarterly = financials.quarterlyStatements.length > 0;
+  const requested = typeof resolved.options.period === "string" ? resolveFinancialPeriodOption(resolved.options.period) : undefined;
+  return resolveFinancialPeriod(requested ?? (hasAnnual ? "annual" : "quarterly"), hasAnnual, hasQuarterly);
+}
+
+interface RatioShot {
+  symbol: string;
+  financials: TickerFinancials;
+  tab: RatioTabDef;
+  period: FinancialPeriod;
+  model: RatioTableModel;
+}
+
+/** The table the page computes from the captured data, with every ratio expanded. */
+function ratioShot(resolved: ResolvedPaneFunction, payload: DesktopPaneShotPayload): RatioShot | null {
+  const tab = shotRatioTab(resolved);
+  const [symbol, financials] = payload.financials[0] ?? [];
+  if (!tab || !symbol || !financials) return null;
+  const period = shotFinancialPeriod(resolved, financials);
+  // The page answers Valuation's daily request only from a daily capture.
+  const history = tab.key === "valuation" && financials.priceHistoryResolution === PERIOD_END_HISTORY_RESOLUTION
+    ? financials.priceHistory : null;
+  return { symbol, financials, tab, period, model: ratioTableForFinancials(financials, tab, period, history) };
+}
+
+const hasRatio = ({ model, tab }: RatioShot, index: number) => tab.ratios.some((def) => (
+  typeof model.cells.get(def.id)?.[index]?.value === "number"
+));
+
+/** Why the captured data cannot make a usable ratio shot, or null when it can. */
+export function financialRatioShotGap(resolved: ResolvedPaneFunction, payload: DesktopPaneShotPayload): string | null {
+  const shot = ratioShot(resolved, payload);
+  if (!shot) return null;
+  if (shot.tab.key === "valuation") {
+    const unpriced = shot.model.periods.flatMap(({ statement, price }) => typeof price === "number" ? [] : [statement]);
+    // A close in another currency than the statements prices nothing; the pane's footer says so.
+    if (unpriced.length) {
+      return createValuationCurrencyContext(shot.financials).warning(unpriced)
+        ?? `Valuation has no period-end close for ${unpriced.map(ratioPeriodEnd).join(", ")}, so those columns read "no price".`;
+    }
+  }
+  if (!shot.model.periods.some((_, index) => hasRatio(shot, index))) {
+    return `Every ${shot.tab.name} ratio is unreported or not meaningful.`;
+  }
+  return null;
+}
+
+export function financialRatioShotEvidence(
+  resolved: ResolvedPaneFunction,
+  payload: DesktopPaneShotPayload,
+): PaneScreenshotFinancialRatioEvidence | null {
+  const shot = ratioShot(resolved, payload);
+  if (!shot || financialRatioShotGap(resolved, payload)) return null;
+  const index = shot.model.periods.findIndex((_, column) => hasRatio(shot, column));
+  const { statement, price } = shot.model.periods[index]!;
+  return {
+    kind: "financial-ratios",
+    symbol: shot.symbol,
+    statement: shot.tab.key,
+    period: shot.period,
+    latest: {
+      date: statement.date,
+      periodEnd: ratioPeriodEnd(statement),
+      price: typeof price === "number" ? price : null,
+      ratios: shot.tab.ratios.flatMap((def) => {
+        const value = shot.model.cells.get(def.id)![index]!.value;
+        return typeof value === "number" ? [{ id: def.id, label: def.label, value }] : [];
+      }),
+    },
+  };
+}
+
+const STATEMENT_COLUMN = /^statement:(.+):(\d+)$/;
+
+/**
+ * Rendered ratio cells that differ from the table the captured data computes.
+ * A page that drew "no price" or "--" where the capture has a close, or drew
+ * other periods, is not a picture of the data.
+ */
+export function financialRatioRenderMismatches(
+  resolved: ResolvedPaneFunction,
+  payload: DesktopPaneShotPayload,
+  render: Pick<DesktopPaneShotRenderResult, "rows">,
+): string[] {
+  const shot = ratioShot(resolved, payload);
+  if (!shot) return [];
+  const { model, tab } = shot;
+  const rows = new Map(model.rows.map((row) => [row.id, row]));
+  const mismatches: string[] = [];
+  let compared = 0;
+  for (const rendered of render.rows) {
+    const row = rendered.key ? rows.get(rendered.key) : undefined;
+    if (!row) continue;
+    for (const cell of rendered.cells) {
+      const column = STATEMENT_COLUMN.exec(cell.columnId ?? "");
+      if (!column) continue;
+      const index = Number(column[2]);
+      const period = model.periods[index];
+      const header = cell.columnLabel.trim();
+      if (period?.statement.date !== column[1]) {
+        mismatches.push(`${tab.name} column ${header} is not a captured period`);
+        continue;
+      }
+      const amounts = model.cells.get(row.def.id)![index]!;
+      const expected = row.kind === "ratio"
+        ? formatRatioValue(row.def.format, amounts.value)
+        : formatRatioInput(row.def.inputs[row.index]!.format, amounts.inputs[row.index]!, row.divisor);
+      compared += 1;
+      if (cell.text.trim() !== expected.trim()) {
+        mismatches.push(`${tab.name} ${row.label} ${header} reads "${cell.text.trim()}", the captured data gives "${expected.trim()}"`);
+      }
+    }
+  }
+  if (compared === 0) mismatches.push(`${tab.name} ratio cells are missing`);
+  return mismatches;
+}