gloomberb 0.18.3 → 0.18.4

package/src/plugins/builtin/ticker-detail/financials/tab.tsx

@@ -16,6 +16,7 @@ import {
 import { colors, priceColor } from "../../../../theme/colors";
 import { fiscalYearEndMonth } from "../../../../utils/fiscal-period";
 import { padTo } from "../../../../utils/format";
+import { filledPeriodsNote, stalePeriodNote } from "../../../../utils/financial-statements";
 import {
   FINANCIAL_COL_W,
   FINANCIAL_LABEL_W,
@@ -29,6 +30,8 @@ import {
   formatFinancialCell,
   financialStatementCurrency,
   financialStatementLimitations,
+  financialStatementPeriods,
+  financialSubTabFields,
   formatFinancialValue,
   latestFinancialPeriodEnd,
   resolveFinancialPeriod,
@@ -51,9 +54,12 @@ import {
   ratioPeriodEnd,
   ratioPeriods,
   resolveFinancialSectionKey,
+  visibleRatios,
   type RatioAmount,
 } from "./ratios";
 import { PeriodEndHistoryLoader, RatioTable, ratioMetricColumn, type PeriodEndHistoryState, type RatioTableColumn } from "./ratio-table";
+import { latestBalanceSheetDate, useOfferingNote } from "./offerings";
+import { useBoundTicker } from "../../shared/ticker-request";
 import { createValuationCurrencyContext } from "../../../../time-series/valuation-currency";
 
 const RATIOS_SEGMENT = "ratios";
@@ -127,9 +133,11 @@ export function ResolvedFinancialsTab({
   const ratioTab = section.kind === "ratio" ? section.tab : null;
   // A ratio tab builds its own rows; the statement rows below idle on Income.
   const subTab = section.kind === "statement" ? section.tab : FINANCIAL_SUB_TABS[0]!;
+  // A ratio read over one quarter is not on the annual view, so its state does not count there.
+  const quarterlyView = resolveFinancialPeriod(period, hasAnnualStatements, hasQuarterlyStatements) === "quarterly";
   const currentGroupIds = useMemo(
-    () => ratioTab ? ratioTab.ratios.map((ratio) => ratio.id) : collectGroupIds(subTab.rows),
-    [ratioTab, subTab],
+    () => ratioTab ? visibleRatios(ratioTab, quarterlyView).map((ratio) => ratio.id) : collectGroupIds(subTab.rows),
+    [quarterlyView, ratioTab, subTab],
   );
   const hasCollapsedCurrentGroup = currentGroupIds.some((id) => collapsedGroups.has(id));
   const hasExpandedCurrentGroup = currentGroupIds.some((id) => !collapsedGroups.has(id));
@@ -426,20 +434,38 @@ export function ResolvedFinancialsTab({
       return (close === undefined ? null : currencies?.priceInStatementUnits(statement, close)) ?? "no-price";
     };
     const expanded = new Set(ratioTab.ratios.map((ratio) => ratio.id).filter((id) => !collapsedGroups.has(id)));
-    return buildRatioTableModel(ratioTab, ratioPeriods(displayStatements, openings, resolvedPeriod, price, { annual: annualStatements, quarterly: quarterlyStatements }), expanded);
+    return buildRatioTableModel(ratioTab, ratioPeriods(displayStatements, openings, resolvedPeriod, price, { annual: annualStatements, quarterly: quarterlyStatements }), expanded, financials?.profile);
   }, [
     annualStatements, collapsedGroups, currencies, displayStatements, history.data, history.error, history.loading,
-    isValuation, quarterlyStatements, ratioTab, resolvedPeriod,
+    isValuation, quarterlyStatements, ratioTab, resolvedPeriod, financials?.profile,
   ]);
   const ratioColumns = useMemo<RatioTableColumn[]>(() => [
     ratioMetricColumn(),
     ...columns.flatMap((column, index) => column.kind === "statement" ? [{ ...column, index: index - 1 }] : []),
   ], [columns]);
 
+  // The Balance Sheet and Liquidity show cash, which an offering filed since the latest balance sheet is not in yet.
+  const { symbol: boundSymbol, exchange: boundExchange } = useBoundTicker();
+  const offeringNote = useOfferingNote(boundSymbol, boundExchange, latestBalanceSheetDate(financials),
+    !!financials && (section.key === "balance" || section.key === "liquidity"));
+
+  // A latest period over 15 months old says how old it is, beside the data's other limits.
+  const stalePeriod = useMemo(
+    () => stalePeriodNote(financialStatementPeriods(displayStatements, subTab)),
+    [displayStatements, subTab],
+  );
+  // Years filled from the listing's exchange, with the lines this table shows.
+  const filledPeriods = useMemo(
+    () => filledPeriodsNote(displayStatements, ratioTab ? undefined : financialSubTabFields(subTab)),
+    [displayStatements, ratioTab, subTab],
+  );
   usePaneNoticeFooter({
     registrationId: "financials-notices",
     notices: [
+      ...(stalePeriod ? [stalePeriod] : []),
+      ...(filledPeriods ? [filledPeriods] : []),
       ...financialStatementLimitations(financials),
+      ...(offeringNote ? [offeringNote] : []),
       ...(isValuation && history.error && !history.data ? ["Period-end prices are unavailable, so valuation ratios are too."] : []),
       ...(isValuation ? [currencies?.warning(displayStatements) ?? ""] : []),
     ],

package/src/plugins/builtin/ticker-detail/headless-schema.ts

@@ -3,6 +3,16 @@ import { FINANCIAL_PERIOD_OPTION, HISTORY_RANGE_VALUES } from "../shared/headles
 import { historyIntervalsByRange } from "../../../cli/history-rows";
 import { HISTORY_DEFAULT_RANGE } from "./data-panes/history-bars";
 import { RETURN_INTERVAL_VALUES, RETURN_RANGES } from "./data-panes/returns-model";
+import { PRICE_WINDOW_FROM_HELP, PRICE_WINDOW_TO_HELP } from "../../../utils/price-window";
+import type { HeadlessPaneOptionDef } from "../../../types/headless";
+
+/** `--from 2007 --to 2009`: the report's bars for those dates. The pane keeps its range, so a capture refuses them. */
+const WINDOW_OPTIONS: HeadlessPaneOptionDef[] = [
+  { key: "from", type: "string", placeholder: "year|date", description: PRICE_WINDOW_FROM_HELP, example: "--from 2007 --to 2009",
+    shot: { reportOnly: "reads the report's bars for those dates" }, replaces: ["range"] },
+  { key: "to", type: "string", placeholder: "year|date", description: PRICE_WINDOW_TO_HELP,
+    shot: { reportOnly: "reads the report's bars for those dates" } },
+];
 
 type PaneSchema = Pick<HeadlessPaneDefinition, "argument" | "options" | "discovery">;
 
@@ -60,10 +70,11 @@ export const paneSchemas = {
         defaultValue: HISTORY_DEFAULT_RANGE,
         pluginState: { pluginId: "ticker-research" },
       },
+      ...WINDOW_OPTIONS,
     ],
     discovery: {
       id: "historical-prices",
-      aliases: ["historical prices", "price history", "ohlcv", "daily prices"],
+      aliases: ["historical prices", "price history", "ohlcv", "daily prices", "max drawdown"],
       screenshotReadiness: "partial",
     },
   },
@@ -88,10 +99,11 @@ export const paneSchemas = {
         defaultValue: "1h",
         pluginState: { pluginId: "ticker-research" },
       },
+      ...WINDOW_OPTIONS,
     ],
     discovery: {
       id: "returns",
-      aliases: ["returns", "interval returns", "cumulative return", "performance"],
+      aliases: ["returns", "interval returns", "cumulative return", "performance", "max drawdown"],
       // A capture is read from the rendered table, as before the report existed.
       screenshotReadiness: "live-dom",
     },

package/src/plugins/builtin/ticker-detail/headless.ts

@@ -1,20 +1,23 @@
-import { FINANCIAL_VINTAGE_NOTICE, statementHistoryNotes } from "../../../utils/financial-statements";
+import { FINANCIAL_VINTAGE_NOTICE, filledPeriodsNote, stalePeriodNote, statementHistoryNotes } from "../../../utils/financial-statements";
 import { hasValidQuoteObservationTime } from "../../../market-data/quotes/freshness";
 import { EXTENDED_SESSION_LABELS, getQuoteSessionFields, quoteHeadlineTime, type ExtendedSession } from "../../../market-data/market/status";
-import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/headless";
+import type { HeadlessPaneColumn, HeadlessPaneDefinition, HeadlessPaneFreshness, HeadlessPaneOptionValues } from "../../../types/headless";
 import type { TimeRange } from "../../../time-series/range";
 import { formatNumber, formatPercentRaw } from "../../../utils/format";
-import { formatMarketPrice, formatMarketPriceWithCurrency, formatPriceObservation, withCurrencyMinorDigits, type MarketFormatOptions } from "../../../market-data/market/format";
+import { formatMarketPrice, formatMarketPriceWithCurrency, formatPriceObservation, quoteFormatOptions, withCurrencyMinorDigits, type MarketFormatOptions } from "../../../market-data/market/format";
 import {
   MISSING_VOLUME_TEXT, missingVolumeCount, missingVolumeNotice, pricePointValues, priceHistoryIntegrityNotice,
 } from "../../../utils/price-history-integrity";
 import {
   buildFinancialTableModel, financialStatementCurrency, financialStatementDateNotice, financialStatementLimitations,
-  formatFinancialHeader, isPerShareFinancialRow, receiptShareCountLabel,
+  financialStatementPeriods, financialSubTabFields, formatFinancialHeader, isPerShareFinancialRow, receiptShareCountLabel,
 } from "./financials/model";
 import { adrRatioText } from "../../../utils/depositary-receipt";
 import { paneSchemas } from "./headless-schema";
 import { loadPeriodEndHistory } from "./financials/period-end-history";
+import { latestBalanceSheetDate, loadOfferingNote } from "./financials/offerings";
+import { reportsShortTermTotal, runwayMethod } from "../../../utils/cash-runway";
+import { logFailure } from "../../../utils/log-failure";
 import {
   RATIO_GAP_TEXT,
   findRatioTab,
@@ -32,16 +35,46 @@ import {
   loadHeadlessFinancials, loadHeadlessPriceHistory, loadHeadlessSymbols, resolveHeadlessInstrument,
 } from "../shared/headless-market-data";
 import { barHistoryFreshness, quoteFreshnessFields, REPORTED_DATA } from "../shared/report-freshness";
-import { cleanFloat32Price, historyPriceDecimals } from "../../../cli/history-rows";
+import {
+  BAR_INTERVAL_LABELS, barPriceDecimals, cleanFloat32Price, formatBarPrice, historyAllStart, historyAllStartNote, historyMissingPeriodsNote, historyPriceDecimals,
+} from "../../../cli/history-rows";
+import { formatUtcTime } from "../../../utils/utc-time";
+import { maxDrawdown, maxDrawdownText } from "../../../utils/max-drawdown";
+import { isPastPriceWindow, loadPriceWindowHistory, priceWindowText, readPriceWindow, type PriceWindow } from "../../../utils/price-window";
 import { historyCoverageNotice } from "../../../sources/history-coverage";
 import { getChartResolutionLabel, isIntradayResolution, RANGE_HISTORY_RESOLUTION, type ManualChartResolution } from "../../../time-series/resolution";
 import { DAY_SO_FAR_TEXT, withSessionBar } from "../../../time-series/session-bar";
-import { buildReturnRows, closedMarketNote, type ReturnRange } from "./data-panes/returns-model";
+import { buildReturnRows, closedMarketNote, isTodayReturnRow, returnBaseCloseDay, type ReturnRange } from "./data-panes/returns-model";
+import { periodBaseText } from "../../../market-data/market/period-return";
 import { loadReturnSeries } from "./data-panes/returns-history";
 import {
-  closedHistoryBarDay, formingHistoryBar, HISTORY_DEFAULT_RANGE, historyBarDate, historyBarSize, historyDateHeader, isDailyOrLongerBar, type HistoryBarSize,
+  closedHistoryBarDay, formingHistoryBar, HISTORY_DEFAULT_RANGE, historyBarDate, historyBarSize, historyBarSizeWord, historyDateHeader, isDailyOrLongerBar,
+  type HistoryBarSize,
 } from "./data-panes/history-bars";
 
+const optionText = (value: unknown) => typeof value === "string" && value.trim() ? value : undefined;
+
+/** The `--from`/`--to` window HP and RETURN read in place of their range; null when neither was given. */
+function readReportWindow(options: HeadlessPaneOptionValues): PriceWindow | null {
+  return readPriceWindow(optionText(options.from), optionText(options.to));
+}
+
+/** `2007 to 2009` for a report's title, when it reads a window. */
+function reportWindowText(options: HeadlessPaneOptionValues): string | null {
+  try {
+    const window = readReportWindow(options);
+    return window ? priceWindowText(window) : null;
+  } catch {
+    // Intentional ignore: the load reports a window it cannot read; the title keeps the range.
+    return null;
+  }
+}
+
+/** Bars of a window that closed before today: the history asked for, which no later bar makes stale. */
+function pastWindowFreshness(window: PriceWindow, size: HistoryBarSize, observedKey: string): HeadlessPaneFreshness {
+  return { status: "not-a-feed", basis: `${historyBarSizeWord(size)} bars, ${priceWindowText(window)}`, observedKey, oldest: null };
+}
+
 export const financialStatementsHeadless: HeadlessPaneDefinition<"rows"> = {
   ...paneSchemas["financial-analysis-pane"],
   shape: "rows",
@@ -76,12 +109,13 @@ export const financialStatementsHeadless: HeadlessPaneDefinition<"rows"> = {
       : allReceipts
         ? `Share counts are in ADRs and EPS is per ADR${ratio ? `; ${ratio}` : ""}.`
         : `Share counts are in ADRs and EPS is per ADR for ${receiptPeriods.join(", ")}${ratio ? ` (${ratio})` : ""}; other periods as reported.`;
-    const dates = table?.statements.map(({ date, currency, dateSource, providerDate, dateEvidence, availableAt, fieldAvailability, fieldSources, unavailableFields, epsBasis, unavailableEarnings, aggregation, shareBasis }) => ({
+    const dates = table?.statements.map(({ date, currency, dateSource, providerDate, dateEvidence, availableAt, fieldAvailability, fieldSources, unavailableFields, epsBasis, unavailableEarnings, aggregation, shareBasis, filledFrom }) => ({
       date, currency: currency ?? statementCurrency ?? null,
       shareBasis: shareBasis ?? null,
       availableAt: availableAt ?? null,
       fieldAvailability: fieldAvailability ? { ...fieldAvailability } : null,
       ...(fieldSources ? { fieldSources } : {}),
+      ...(filledFrom ? { filledFrom } : {}),
       ...(unavailableFields ? { unavailableFields } : {}),
       ...(epsBasis ? { epsBasis } : {}),
       ...(unavailableEarnings ? { unavailableEarnings } : {}),
@@ -110,11 +144,17 @@ export const financialStatementsHeadless: HeadlessPaneDefinition<"rows"> = {
         },
       })),
     ];
+    // The balance sheet's cash, when an offering since is not in it yet.
+    const offering = table?.subTab.key === "balance" ? await reportOfferingNote(ctx, symbol, financials) : null;
+    // A latest period over 15 months old says how old it is.
+    const stale = table ? stalePeriodNote(financialStatementPeriods(table.statements, table.subTab)) : null;
+    // Years filled from the listing's exchange, with the lines this table shows.
+    const filled = table ? filledPeriodsNote(table.statements, financialSubTabFields(table.subTab)) : null;
     return {
       rows, columns, unavailableSymbols: rows.length ? [] : [symbol],
       ...(!hasRequestedStatements ? { errors: [`${symbol}: No ${requestedPeriod} financial statement coverage.`] } : {}),
-      // The report closes with how far back its periods go, and how to read further.
-      notes: statementHistoryNotes(requestedPeriod, dates.map(({ date }) => date), symbol),
+      // The report closes with how old its latest period is, how far back its periods go, and how to read further.
+      notes: [...stale ? [stale] : [], ...filled ? [filled] : [], ...offering ? [offering] : [], ...statementHistoryNotes(requestedPeriod, dates.map(({ date }) => date), symbol)],
       metadata: {
         symbol, name: financials.quote?.name ?? symbol, currency: statementCurrency ?? null, unit: table?.unit ?? null, quoteCurrency: financials.quote?.currency ?? null,
         statement: table?.subTab.key ?? options.statement, statementLabel: table?.subTab.name ?? null,
@@ -131,6 +171,19 @@ export const financialStatementsHeadless: HeadlessPaneDefinition<"rows"> = {
 
 const reportAmount = (amount: RatioAmount) => (typeof amount === "number" ? amount : null);
 
+/** The note that an offering filed after the latest balance sheet is not in its cash yet; a failed read leaves it out. */
+async function reportOfferingNote(
+  ctx: Parameters<typeof financialStatementsHeadless.load>[1],
+  symbol: string,
+  financials: Awaited<ReturnType<typeof loadHeadlessFinancials>>,
+): Promise<string | null> {
+  const periodEnd = latestBalanceSheetDate(financials);
+  if (!periodEnd) return null;
+  return resolveHeadlessInstrument(ctx, symbol)
+    .then((listing) => loadOfferingNote(ctx.apiClient, listing, periodEnd, ctx.signal))
+    .catch(logFailure("ticker-detail.headless", "Reading the offering filings failed", null));
+}
+
 /** A ratio tab as a report: each ratio, then its inputs, per period. */
 async function loadRatioReport(
   ctx: Parameters<typeof financialStatementsHeadless.load>[1],
@@ -181,11 +234,22 @@ async function loadRatioReport(
       format: (_value: unknown, row: Record<string, unknown>) => (row.cells as Array<{ formatted: string }>)[index]!.formatted,
     })),
   ];
+  // Liquidity's runway says how it counts months, and that the cash predates an offering since.
+  const liquidity = tab.key === "liquidity" && table;
+  const runwayShown = liquidity && table.ratios.some((def) => def.format === "months"
+    && table.cells.get(def.id)!.some((cell) => typeof cell.value === "number"));
+  const offering = liquidity ? await reportOfferingNote(ctx, symbol, financials) : null;
   return {
     rows, columns, unavailableSymbols: rows.length ? [] : [symbol],
     ...(!hasRequestedStatements ? { errors: [`${symbol}: No ${period} financial statement coverage.`] } : {}),
     ...(tab.key === "valuation" && hasRequestedStatements && !history?.length ? { complete: false } : {}),
-    notes: statementHistoryNotes(period, dates.map(({ date }) => date), symbol),
+    notes: [
+      ...[stalePeriodNote(dates.map(({ periodEnd }) => ({ date: periodEnd, lead: true })))].filter((note): note is string => !!note),
+      ...[filledPeriodsNote(table?.periods.map(({ statement }) => statement) ?? [])].filter((note): note is string => !!note),
+      ...offering ? [offering] : [],
+      ...runwayShown ? [runwayMethod(reportsShortTermTotal([...financials.quarterlyStatements, ...financials.annualStatements]))] : [],
+      ...statementHistoryNotes(period, dates.map(({ date }) => date), symbol),
+    ],
     metadata: {
       symbol, name: financials.quote?.name ?? symbol, currency: statementCurrency ?? null,
       quoteCurrency: financials.quote?.currency ?? null,
@@ -270,14 +334,17 @@ export const quoteComparisonHeadless: HeadlessPaneDefinition<"rows"> = {
 };
 
 /**
- * The price columns of HP, which `fn HP` prints and exports with the date column of the bars' size. A bar without
+ * The price columns of HP, which `fn HP` prints and exports with the date column of the bars' size. Every price has
+ * the table's one decimal count (`decimals`, barPriceDecimals), as `history` and the pane print it; the columns a
+ * report declares before it has bars keep every digit the source sent. A bar without
  * volume in a history that reports it (`volumeMissing`) prints it as missing, never as 0.
  */
-const historyPriceColumns = (volumeMissing: boolean): HeadlessPaneColumn[] => ["open", "high", "low", "close", "volume"].map((key) => ({
+const historyPriceColumns = (volumeMissing: boolean, decimals?: number): HeadlessPaneColumn[] => ["open", "high", "low", "close", "volume"].map((key) => ({
   key, header: key, align: "right" as const,
   format: (value: unknown) => value == null || !Number.isFinite(Number(value)) ? key === "volume" && volumeMissing ? MISSING_VOLUME_TEXT : "-"
     : key === "volume" ? formatNumber(Number(value), 0)
-    : formatPriceObservation(Number(value), { minimumFractionDigits: 2 }),
+    : decimals == null ? formatPriceObservation(Number(value), { minimumFractionDigits: 2 })
+    : formatBarPrice(Number(value), decimals),
 }));
 
 /**
@@ -286,7 +353,7 @@ const historyPriceColumns = (volumeMissing: boolean): HeadlessPaneColumn[] => ["
  * whose period runs on (`2026-10 MTD`); the export keeps each bar's own date
  * and adds a `Partial` column when one is.
  */
-function historyColumns(size: HistoryBarSize, partial: boolean, text: boolean, volumeMissing = false): HeadlessPaneColumn[] {
+function historyColumns(size: HistoryBarSize, partial: boolean, text: boolean, volumeMissing = false, decimals?: number): HeadlessPaneColumn[] {
   const daily = isDailyOrLongerBar(size);
   const date: HeadlessPaneColumn = {
     key: "date",
@@ -298,33 +365,42 @@ function historyColumns(size: HistoryBarSize, partial: boolean, text: boolean, v
   const marked: HeadlessPaneColumn[] = partial && !text
     ? [{ key: "partial", header: "Partial", format: (value) => value === true ? "true" : "" }]
     : [];
-  return [date, ...historyPriceColumns(volumeMissing), ...marked];
+  return [date, ...historyPriceColumns(volumeMissing, decimals), ...marked];
 }
 
 export const historicalPricesHeadless: HeadlessPaneDefinition<"rows"> = {
   ...paneSchemas["historical-prices-pane"],
   shape: "rows",
   description: "OHLCV bars (date, open, high, low, close, volume) for one ticker over a range: daily to start, weekly for 5Y and monthly for ALL. The newest bar is marked partial while its day, week or month runs on; a day's bar then comes from the live quote.",
-  describe: ({ symbols, options }) => `Historical Prices | ${symbols[0]} | ${options.range ?? HISTORY_DEFAULT_RANGE}`,
+  describe: ({ symbols, options }) => `Historical Prices | ${symbols[0]} | ${reportWindowText(options) ?? options.range ?? HISTORY_DEFAULT_RANGE}`,
   columns: historyColumns("1d", false, false),
   async load({ symbols, options }, ctx) {
     const symbol = symbols[0]!;
     const range = (options.range ?? HISTORY_DEFAULT_RANGE) as TimeRange;
+    // --from 2007 --to 2009 reads those dates' bars in place of the range.
+    const window = readReportWindow(options);
+    const pastWindow = !!window && isPastPriceWindow(window);
     // A range of daily or longer bars reaches into the session now trading, whose bar is the quote's (withSessionBar).
     const { symbol: listing, exchange } = await resolveHeadlessInstrument(ctx, symbol);
     const [loaded, quote] = await Promise.all([
-      loadHeadlessPriceHistory(ctx, symbol, range),
-      isIntradayResolution(RANGE_HISTORY_RESOLUTION[range]) ? null : ctx.marketData.getQuote(listing, exchange ?? "").catch(() => null),
+      window ? loadPriceWindowHistory(ctx.marketData, listing, exchange ?? "", window).then((result) => result.points)
+        : loadHeadlessPriceHistory(ctx, symbol, range),
+      pastWindow || (!window && isIntradayResolution(RANGE_HISTORY_RESOLUTION[range])) ? null
+        : ctx.marketData.getQuote(listing, exchange ?? "").catch(() => null),
     ]);
     // The venue whose sessions say whether a day, week or month is still running: the key's, or for a bare symbol its quote's.
     const venue = exchange || quote?.listingExchangeName || quote?.exchangeName || undefined;
     const now = Date.now();
     const points = withSessionBar(loaded, quote, { now, venue });
+    // Providers serve float32 prices (4013.39990234 for 4013.4): the rows hold the decimal each is, as `history` does.
+    const clean = (value: number | null) => value == null ? null : cleanFloat32Price(value);
     const rows = points.map((point) => {
       const date = new Date(point.date);
+      const values = pricePointValues(point);
       return {
         date: Number.isFinite(date.getTime()) ? date.toISOString() : String(point.date),
-        ...pricePointValues(point),
+        open: clean(values.open), high: clean(values.high), low: clean(values.low), close: clean(values.close), volume: values.volume,
+        ...(values.integrity ? { integrity: values.integrity } : {}),
         ...(point.partial ? { partial: true } : {}),
         // A coin's day Gloom Cloud rebuilt from hourly bars has no volume of its own, as `history` marks it.
         ...(point.filled ? { filled: true } : {}),
@@ -336,28 +412,45 @@ export const historicalPricesHeadless: HeadlessPaneDefinition<"rows"> = {
     const forming = formingHistoryBar(size, rows.at(-1)?.date, venue, now);
     // A complete one is dated by the day its last session closed, the day its close is from.
     const closedDay = closedHistoryBarDay(size, rows.at(-1)?.date, venue, now);
+    // A daily bar of a session still trading is as of its listing's latest quote, never its midnight.
+    const quotedAt = size === "1d" && !closedDay && rows.length && quote && Number.isFinite(quote.lastUpdated)
+      && quote.lastUpdated >= Date.parse(`${rows.at(-1)!.date.slice(0, 10)}T00:00:00Z`) ? new Date(quote.lastUpdated).toISOString() : null;
     const shown = forming ? [...rows.slice(0, -1), { ...rows.at(-1)!, partial: true }] : rows;
+    // One decimal count for the table, by the instrument's display rules when the quote names its kind.
+    const decimals = barPriceDecimals(rows, quoteFormatOptions(quote).assetCategory);
     const marked = shown.some((row) => row.partial === true);
     const volumeMissing = missingVolumeCount(shown);
     const volumeNote = missingVolumeNotice(volumeMissing, shown.length);
+    // Every month or week without a bar is named, and ALL says where the source's bars start (BTC-USD's in 2014-09).
+    const interval = size === "intraday" ? null : size;
+    const gapNote = historyMissingPeriodsNote(rows.map((row) => Date.parse(row.date)), interval);
+    const allStart = window ? null : historyAllStart(range, interval, rows[0]?.date, now);
+    const notes = [allStart ? historyAllStartNote(allStart) : null, gapNote, volumeNote].filter((note): note is string => note != null);
     // The day's bar built from the quote is not a close; a coin's day in progress, as its source flags it, keeps its line.
     const dayToDate = points !== loaded && size === "1d" && shown.at(-1)?.partial === true;
     // A bar history: dated by its last bar, stale once bars of its size stop arriving.
-    const freshness = {
+    const freshness = pastWindow ? pastWindowFreshness(window, size, "date") : {
       ...barHistoryFreshness(isDailyOrLongerBar(size) ? size : null),
       observedKey: "date", oldest: null,
-      ...(forming ? { periodToDate: forming } : closedDay ? { asOf: closedDay } : {}),
+      ...(forming ? { periodToDate: forming } : closedDay ? { asOf: closedDay } : quotedAt ? { asOf: quotedAt } : {}),
       ...(dayToDate ? { basis: "daily bars", note: `the newest bar is ${DAY_SO_FAR_TEXT}`, ...(quote ? { asOf: new Date(quote.lastUpdated).toISOString() } : {}) } : {}),
     };
+    // The largest fall from a close to a later one in the bars shown, said under the title.
+    const drawdown = maxDrawdown(shown);
+    const drawdownLine = drawdown ? maxDrawdownText(drawdown, { basis: `${historyBarSizeWord(size)} closes`, price: (value) => formatBarPrice(value, decimals),
+      date: (value) => isDailyOrLongerBar(size) ? value.slice(0, 10) : formatUtcTime(value) }) : null;
+    const reportNotices = [drawdownLine, notice].filter((line): line is string => line != null);
     return {
       rows: shown,
-      columns: historyColumns(size, marked, false),
-      textColumns: historyColumns(size, marked, true, volumeMissing > 0),
+      columns: historyColumns(size, marked, false, false, decimals),
+      textColumns: historyColumns(size, marked, true, volumeMissing > 0, decimals),
       freshness,
-      ...(volumeNote ? { notes: [volumeNote] } : {}),
+      ...(notes.length > 0 ? { notes } : {}),
       ...(notice ? { complete: false } : {}),
       unavailableSymbols: rows.some((row) => row.close !== null) ? [] : [symbol],
-      metadata: { symbol, range, ...(size === "intraday" ? {} : { interval: size }), ...(notice ? { notices: [notice] } : {}) },
+      metadata: { symbol, range: window ? null : range, ...(window ? { requestedWindow: window } : {}), ...(size === "intraday" ? {} : { interval: size }),
+        ...(allStart ? { sourceStart: allStart } : {}), maxDrawdown: drawdown,
+        ...(reportNotices.length ? { notices: reportNotices } : {}) },
     };
   },
 };
@@ -372,17 +465,24 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
   ...paneSchemas["returns-pane"],
   shape: "rows",
   description: "Interval and cumulative price returns of one ticker's bars over a range: each bar's close, its move from the bar before, and its move from the bar before the window.",
-  describe: ({ symbols, options }) => `Returns | ${symbols[0]} | ${options.range ?? "5D"} | ${options.interval ?? "1h"}`,
+  describe: ({ symbols, options }) => `Returns | ${symbols[0]} | ${reportWindowText(options) ?? options.range ?? "5D"} | ${options.interval ?? "1h"}`,
   async load({ symbols, options }, ctx) {
     const key = symbols[0]!;
     const { symbol, exchange } = await resolveHeadlessInstrument(ctx, key);
     const range = (options.range ?? "5D") as ReturnRange;
     const requested = (options.interval ?? "1h") as ManualChartResolution;
+    // --from 2007 --to 2009 measures those dates' returns in place of the range.
+    const window = readReportWindow(options);
+    const pastWindow = !!window && isPastPriceWindow(window);
     const support = await Promise.resolve(ctx.marketData.getChartResolutionSupport?.(symbol, exchange ?? "") ?? []).catch(() => []);
+    const now = Date.now();
     const series = await loadReturnSeries(ctx.marketData, {
-      symbol, exchange: exchange ?? "", range, resolution: requested, support, now: Date.now(), forceRefresh: ctx.refresh,
+      symbol, exchange: exchange ?? "", range, resolution: requested, support, now, forceRefresh: ctx.refresh, window,
     });
     const returns = buildReturnRows(series.points, series.visibleFrom, series.visibleTo).reverse();
+    const venue = series.venue || undefined;
+    // The close every total is measured from, which the report names: `Totals from Mon 21 Sep close.`
+    const baseDay = returns.length ? returnBaseCloseDay(series.points, series.visibleFrom, series.resolution, venue, now) : null;
     const decimals = historyPriceDecimals(returns.flatMap((row) => row.price === null ? [] : [{
       open: null, high: null, low: null, close: cleanFloat32Price(row.price),
     }]));
@@ -400,10 +500,16 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
       ...(row.inconsistent ? { inconsistent: true } : {}),
     }));
     // A weekly or monthly bar whose period runs on is the period so far: marked partial, and dated by how far it runs.
-    const forming = formingHistoryBar(series.resolution, unmarked.at(-1)?.time, series.venue || undefined, Date.now());
-    const closedDay = closedHistoryBarDay(series.resolution, unmarked.at(-1)?.time, series.venue || undefined, Date.now());
-    const rows = forming ? [...unmarked.slice(0, -1), { ...unmarked.at(-1)!, partial: true }] : unmarked;
+    const forming = formingHistoryBar(series.resolution, unmarked.at(-1)?.time, venue, now);
+    const closedDay = closedHistoryBarDay(series.resolution, unmarked.at(-1)?.time, venue, now);
+    // Today's daily bar is the session still trading, not a close: marked partial (DTD), as `history` marks it.
+    const dayToDate = isTodayReturnRow(returns.at(-1), series.resolution, venue, now);
+    const rows = forming || dayToDate ? [...unmarked.slice(0, -1), { ...unmarked.at(-1)!, partial: true }] : unmarked;
     const price = (value: unknown) => typeof value === "number" && Number.isFinite(value) ? value.toFixed(decimals) : "-";
+    // The largest fall from a close to a later one in the window, said under the title.
+    const drawdown = maxDrawdown(unmarked.map((row) => ({ date: row.time, close: row.close })));
+    const maxDrawdownLine = drawdown ? maxDrawdownText(drawdown, { basis: `${BAR_INTERVAL_LABELS[series.resolution]} closes`, price,
+      date: (value) => intraday ? formatUtcTime(value) : value.slice(0, 10) }) : null;
     const figures: HeadlessPaneColumn[] = [
       { key: "close", header: "Price", align: "right", format: price },
       { key: "intervalChange", header: "Int $", align: "right", format: price },
@@ -422,13 +528,15 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
     const columns: HeadlessPaneColumn[] = [
       timeColumn(false),
       ...figures,
-      ...forming ? [{ key: "partial", header: "Partial", format: (value: unknown) => value === true ? "true" : "" }] : [],
+      ...forming || dayToDate ? [{ key: "partial", header: "Partial", format: (value: unknown) => value === true ? "true" : "" }] : [],
     ];
     const textColumns: HeadlessPaneColumn[] = [timeColumn(true), ...figures];
     // An interval the range is too long for is served in the nearest longer bar; say so rather than switch silently.
     const notices = [
+      maxDrawdownLine,
+      baseDay ? `Totals ${periodBaseText(baseDay, now)}.` : null,
       series.resolution !== requested
-        ? `${getChartResolutionLabel(requested)} bars do not reach back ${range}; these are ${getChartResolutionLabel(series.resolution)} bars.`
+        ? `${getChartResolutionLabel(requested)} bars do not ${window ? `cover ${priceWindowText(window)}` : `reach back ${range}`}; these are ${getChartResolutionLabel(series.resolution)} bars.`
         : null,
       historyCoverageNotice(series.coverageStart, series.visibleFrom),
       priceHistoryIntegrityNotice(rows.filter((row) => row.inconsistent).length) ?? null,
@@ -439,7 +547,7 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
       textColumns,
       unavailableSymbols: rows.length ? [] : [key],
       ...(rows.length ? {} : { errors: [`${key}: No bars in this window.`] }),
-      freshness: {
+      freshness: pastWindow ? pastWindowFreshness(window, series.resolution, "time") : {
         ...barHistoryFreshness(intraday ? null : series.resolution),
         observedKey: "time",
         oldest: null,
@@ -447,15 +555,20 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
         ...(series.venue ? { cadenceExchange: series.venue } : {}),
         // The window ends at the last session while the market is shut, which the status line says.
         ...(series.lastSession ? { note: closedMarketNote(series.lastSession, series.visibleTo) } : {}),
+        ...(dayToDate ? { basis: "daily bars", note: `the newest bar is ${DAY_SO_FAR_TEXT}` } : {}),
       },
       metadata: {
         symbol: key,
-        range,
+        range: window ? null : range,
+        // The dates asked for, as history and HP carry them; `window` below is the span of the bars served.
+        ...(window ? { requestedWindow: window } : {}),
         interval: series.resolution,
         requestedInterval: requested,
         window: { after: new Date(series.visibleFrom).toISOString(), through: new Date(series.visibleTo).toISOString() },
+        ...(baseDay ? { baseDay } : {}),
         ...(series.lastSession ? { marketClosed: true, lastSession: series.lastSession } : {}),
         basis: "Price returns of bar closes; dividends are not included",
+        maxDrawdown: drawdown,
         ...(notices.length ? { notices } : {}),
       },
     };

package/src/plugins/builtin/ticker-detail/index.tsx

@@ -9,6 +9,7 @@ import { HistoricalPricesPane } from "./data-panes/historical-prices";
 import { ReturnsPane } from "./data-panes/returns-pane";
 import { TickerResearchPane } from "./pane";
 import { futuresContractCache } from "./overview/futures-contract";
+import { offeringFilingsCache } from "./financials/offerings";
 import { TICKER_RESEARCH_BUILTIN_TABS } from "./research-tabs";
 import { QuoteMonitorPane } from "./quote-monitor";
 import { financialStatementsHeadless, historicalPricesHeadless, quoteComparisonHeadless, returnsHeadless } from "./headless";
@@ -19,6 +20,10 @@ import {
   getTickerResearchPaneSettings,
 } from "./settings";
 import { formatTickerListInput } from "../../../tickers/list";
+import { withCommandTab } from "../shared/command-tab";
+import { buildTickerSurfaceInstanceId } from "../shared/ticker-surface";
+import { adrPairHeadless, ADR_PAIR_KEYWORDS } from "./adr-pair/headless";
+import { ADR_PAIR_TAB_ID, ADR_PAIR_TEMPLATE_ID } from "./adr-pair/model";
 import {
   LIVE_STREAMING_QUICK_SETTING,
   withLiveStreamingSetting,
@@ -27,11 +32,15 @@ import {
 export const tickerDetailModule: PluginModule = {
   setup(ctx) {
     futuresContractCache.attach(ctx.persistence);
+    offeringFilingsCache.attach(ctx.persistence);
     for (const tab of TICKER_RESEARCH_BUILTIN_TABS) {
       ctx.registerTickerResearchTab(tab);
     }
   },
-  dispose() { futuresContractCache.reset(); },
+  dispose() {
+    futuresContractCache.reset();
+    offeringFilingsCache.reset();
+  },
 
   panes: [
     {
@@ -41,6 +50,8 @@ export const tickerDetailModule: PluginModule = {
       component: TickerResearchPane,
       defaultPosition: "right",
       tickerFollower: true,
+      // DES and ADR open this pane; ADR's window is named by its params (the tab it asked for), so settings never say whose a window is.
+      identitySettings: [],
       personalData: (context) => {
         const settings = getTickerResearchPaneSettings(context.settings);
         const tab = settings.hideTabs ? settings.lockedTabId : context.paneState.activeTabId;
@@ -114,7 +125,7 @@ export const tickerDetailModule: PluginModule = {
       paneId: TICKER_RESEARCH_PANE_ID,
       label: "Ticker Research",
       description: "Open another research pane for the selected ticker or current collection",
-      keywords: ["new", "ticker", "research", "detail", "pane", "inspector"],
+      keywords: ["new", "ticker", "research", "detail", "pane", "inspector", "runway", "cash runway", "burn", "cash burn", "months of cash"],
       shortcut: { prefix: "T", aliases: ["DES"], argPlaceholder: "ticker", argKind: "ticker" },
       canCreate: (context) => context.activeTicker !== null || context.activeCollectionId !== null,
       createInstance: (context) => (
@@ -134,6 +145,27 @@ export const tickerDetailModule: PluginModule = {
           : null,
       },
     },
+    {
+      // DES on its ADR vs Home tab: no pane of its own.
+      ...withCommandTab({
+        id: ADR_PAIR_TEMPLATE_ID,
+        paneId: TICKER_RESEARCH_PANE_ID,
+        label: "ADR vs Home",
+        description: "A depositary receipt beside its home listing: the ratio, both prices, the dollar rate they imply (the CCL rate for an Argentine pair), spot, and the receipt's premium or discount.",
+        keywords: [...ADR_PAIR_KEYWORDS],
+        shortcut: { prefix: "ADR", argPlaceholder: "ticker", argKind: "ticker" },
+        canCreate: (context, options) => normalizeTickerInput(context.activeTicker, options?.arg) !== null,
+        // One window a listing: ADR again focuses it and brings its tab back.
+        createInstance: (context, options) => {
+          const symbol = options?.symbol?.trim().toUpperCase() || normalizeTickerInput(context.activeTicker, options?.arg);
+          return symbol ? {
+            instanceId: buildTickerSurfaceInstanceId(TICKER_RESEARCH_PANE_ID, symbol, "ADR"),
+            title: symbol, binding: { kind: "fixed", symbol }, placement: "floating",
+          } : null;
+        },
+      }, ADR_PAIR_TAB_ID),
+      headless: adrPairHeadless,
+    },
     {
       id: "quote-monitor-pane",
       headless: quoteComparisonHeadless,
@@ -180,7 +212,7 @@ export const tickerDetailModule: PluginModule = {
         paneId: "returns",
         label: "Returns",
         description: "Inspect interval and cumulative price returns over a selectable range and granularity.",
-        keywords: ["returns", "return", "performance", "change", "interval", "granularity"],
+        keywords: ["returns", "return", "performance", "change", "interval", "granularity", "drawdown", "max drawdown", "peak to trough"],
         shortcut: "RETURN",
         publicShare: true,
         titlePrefix: "RETURN",
@@ -193,7 +225,7 @@ export const tickerDetailModule: PluginModule = {
         paneId: "historical-prices",
         label: "Historical Prices",
         description: "Open a historical OHLCV table for a ticker.",
-        keywords: ["historical", "prices", "hp", "ohlc", "volume"],
+        keywords: ["historical", "prices", "hp", "ohlc", "volume", "drawdown", "max drawdown", "peak to trough"],
         shortcut: "HP",
         publicShare: true,
       }),
@@ -205,7 +237,7 @@ export const tickerDetailModule: PluginModule = {
         paneId: "financial-analysis",
         label: "Financial Analysis",
         description: "Open financial statements for a ticker.",
-        keywords: ["fa", "financial", "analysis", "statements"],
+        keywords: ["fa", "financial", "analysis", "statements", "runway", "cash runway", "burn", "cash burn", "months of cash"],
         shortcut: "FA",
         publicShare: true,
         titlePrefix: "FA",