gloomberb 0.18.2 → 0.18.4

package/src/plugins/builtin/ticker-detail/data-panes/returns-model.ts

@@ -9,7 +9,11 @@ import {
   type ManualChartResolution,
 } from "../../../../time-series/resolution";
 import type { PricePoint } from "../../../../types/financials";
-import { isAlwaysOpenExchange, isRegularSessionTime, latestRegularSessionClose } from "../../../../market-data/market/freshness";
+import { isAlwaysOpenExchange, isRegularSessionTime, latestRegularSessionClose, sessionCalendarTimeZone } from "../../../../market-data/market/freshness";
+import { barLastSession } from "../../../../market-data/market/bar-period";
+import {
+  barCloseDay, barSessionDay, isIntradayDailyBar, isReturnPeriod, periodBaseDay, periodBaseIndex,
+} from "../../../../market-data/market/period-return";
 import { isRoundTheClockCoin } from "../../../../utils/crypto-pair";
 import { currentFxClosureStart, isCurrencyPairListing } from "../../../../utils/fx-market-hours";
 import { pricePointValues } from "../../../../utils/price-history-integrity";
@@ -49,12 +53,56 @@ export function returnWindowStart(range: ReturnRange, end: number): number {
   return subtractTimeRange(new Date(end), range).getTime();
 }
 
+const utcDay = (time: number) => new Date(time).toISOString().slice(0, 10);
+
+/** The session date of `time` at a venue, on its clock; the UTC date where its sessions are unknown. */
+function venueDay(time: number, venue: string | undefined): string {
+  const zone = venue ? sessionCalendarTimeZone(venue) : null;
+  return zone ? zonedDateKey(time, zone) : utcDay(time);
+}
+
+/**
+ * The calendar date a 1W to 5Y window ending at `end` is measured from, the
+ * close on or before which is the base of its returns (periodBaseDay), as CMP
+ * and every period return measure it: 1M ending Wed 21 Oct is from Mon 21
+ * Sep's close. Null for 6H, 1D and 5D, which are spans of time, and ALL.
+ */
+export function returnBaseDay(range: ReturnRange, end: number, venue?: string): string | null {
+  return isReturnPeriod(range) ? periodBaseDay(venueDay(end, venue), range) : null;
+}
+
+/**
+ * Where the rows after a base day start, exclusive: past the base day's
+ * session close for intraday bars, and before the first bar whose close is
+ * from after it for daily (stamped by their date at midnight UTC), weekly
+ * and monthly ones (stamped by their period's first day, barCloseDay). For
+ * daily and longer bars this is what a request reaches back from; the rows
+ * start where returnRowsFrom finds the base among the loaded bars.
+ */
+function afterBaseDay(baseDay: string, resolution: ManualChartResolution, venue: string | undefined): number {
+  const nextDay = Date.parse(`${baseDay}T00:00:00Z`) + DAY_MS;
+  if (isIntradayResolution(resolution)) {
+    // Midnight UTC after the base day is past every venue's close of it and before its next one.
+    const close = venue ? latestRegularSessionClose(venue, nextDay) : null;
+    return close && close.date <= baseDay ? close.close - 1 : nextDay - 1;
+  }
+  for (let day = nextDay - 40 * DAY_MS; day <= nextDay; day += DAY_MS) {
+    if (barCloseDay(utcDay(day), resolution, venue) > baseDay) return day - 1;
+  }
+  return nextDay - 1;
+}
+
 /**
- * Where the rows start, exclusive: the window's start for intraday bars. A
- * daily or longer bar is stamped with its date at midnight UTC, so the window
- * takes every bar from its start date on.
+ * Where the rows start, exclusive, before the bars are loaded: what the
+ * request reaches back from. A 1W to 5Y window starts after its base day
+ * (returnBaseDay), so the close on or before it is the bar before the rows
+ * and the base of every return. Otherwise the window's start for intraday
+ * bars; a daily or longer bar is stamped with its date at midnight UTC, so
+ * the window takes every bar from its start date on.
  */
-export function returnVisibleFrom(range: ReturnRange, resolution: ManualChartResolution, end: number): number {
+export function returnVisibleFrom(range: ReturnRange, resolution: ManualChartResolution, end: number, venue?: string): number {
+  const baseDay = returnBaseDay(range, end, venue);
+  if (baseDay) return afterBaseDay(baseDay, resolution, venue);
   const start = returnWindowStart(range, end);
   if (isIntradayResolution(resolution)) return start;
   const day = new Date(start);
@@ -62,6 +110,31 @@ export function returnVisibleFrom(range: ReturnRange, resolution: ManualChartRes
   return day.getTime() - 1;
 }
 
+/**
+ * Where the rows start among the loaded bars, exclusive. A 1W to 5Y window
+ * of daily or longer bars starts after the bar on or before its base day,
+ * each bar dated by its session day (barSessionDay; a week or month by the
+ * day it closes), so that close is the bar before the rows however the feed
+ * stamps it: a JPX bar at 00:00 JST is 15:00 UTC the day before. Without a
+ * bar on or before the base day, every bar is a row. Otherwise
+ * returnVisibleFrom.
+ */
+export function returnRowsFrom(
+  points: readonly PricePoint[],
+  range: ReturnRange,
+  resolution: ManualChartResolution,
+  end: number,
+  venue?: string,
+): number {
+  const estimate = returnVisibleFrom(range, resolution, end, venue);
+  const baseDay = returnBaseDay(range, end, venue);
+  const bars = toBars(points);
+  if (!baseDay || isIntradayResolution(resolution) || !bars.length) return estimate;
+  const days = bars.map((bar) => barCloseDay(barSessionDay(bar.timestamp, venue), resolution, venue));
+  const index = periodBaseIndex(days, baseDay, Number.POSITIVE_INFINITY);
+  return index < 0 ? bars[0]!.timestamp - 1 : bars[index]!.timestamp;
+}
+
 /**
  * These windows are shorter than a closed market's gap, so they also end at
  * the latest bar when it is earlier: a venue whose sessions the app does not
@@ -120,6 +193,11 @@ function lookbackDays(resolution: ManualChartResolution): number {
   return 62;
 }
 
+/** How far before a dated window (`--from`) the request reaches for the bar before it: a weekend and a holiday. */
+export function returnWindowLookbackMs(resolution: ManualChartResolution): number {
+  return lookbackDays(resolution) * DAY_MS;
+}
+
 /**
  * How far before the window the request reaches. The bar just before the
  * window is the base of every return, so the request covers a weekend or
@@ -245,6 +323,35 @@ export function buildReturnRows(
   return rows.reverse();
 }
 
+/**
+ * The session day of the close every return of a window is measured from
+ * (buildReturnRows' base): the bar before its rows, else its first priced
+ * bar. A daily bar's date, a weekly or monthly bar's last session, an
+ * intraday bar's session date at its venue. Null for a window without rows.
+ */
+export function returnBaseCloseDay(
+  points: readonly PricePoint[],
+  visibleFrom: number,
+  resolution: ManualChartResolution,
+  venue: string | undefined,
+  now: number,
+): string | null {
+  const bars = toBars(points);
+  const first = bars.findIndex((bar) => bar.timestamp > visibleFrom);
+  if (first < 0) return null;
+  const base = first > 0 && bars[first - 1]!.close !== null ? bars[first - 1] : bars.slice(first).find((bar) => bar.close !== null);
+  if (!base) return null;
+  if (isIntradayResolution(resolution)) return venueDay(base.timestamp, venue);
+  const day = barSessionDay(base.timestamp, venue);
+  const period = resolution === "1wk" ? "week" : resolution === "1mo" ? "month" : null;
+  return period ? barLastSession(day, period, venue, now) ?? barCloseDay(day, resolution, venue) : day;
+}
+
+/** Whether the newest daily row is the session still trading at its venue, which its table marks. */
+export function isTodayReturnRow(row: Pick<ReturnRow, "timestamp"> | undefined, resolution: ManualChartResolution, venue: string | undefined, now: number): boolean {
+  return !!row && resolution === "1d" && isIntradayDailyBar(barSessionDay(row.timestamp, venue), venue, now);
+}
+
 /** The latest bar time in a loaded history, or null when it has none. */
 export function latestBarTime(points: readonly PricePoint[]): number | null {
   let latest: number | null = null;

package/src/plugins/builtin/ticker-detail/data-panes/returns-pane.tsx

@@ -37,12 +37,16 @@ import {
   buildReturnRows,
   closedMarketNote,
   effectiveReturnResolution,
+  isTodayReturnRow,
+  returnBaseCloseDay,
   RETURN_RANGES,
   type ReturnRange,
   type ReturnRow,
 } from "./returns-model";
 import { loadReturnSeries, type ReturnSeries } from "./returns-history";
 import { formingHistoryBar, formingHistoryBarText, historyBarDate } from "./history-bars";
+import { periodBaseText } from "../../../../market-data/market/period-return";
+import { DAY_SO_FAR_TEXT } from "../../../../time-series/session-bar";
 
 type ReturnColumnId = "time" | "price" | "intervalChange" | "intervalPercent" | "cumulativeChange" | "cumulativePercent";
 type ReturnColumn = DataTableColumn & { id: ReturnColumnId };
@@ -192,15 +196,24 @@ export function ReturnsPane({ focused, width, height }: PaneProps) {
     () => data ? formingHistoryBar(data.resolution, newestDate, data.venue || undefined, Date.now()) : null,
     [data, newestDate],
   );
-  const formingKey = forming ? returnRows[0]?.key : undefined;
+  // Today's daily bar is the session still trading, marked as Historical Prices marks it.
+  const dayToDate = !!data && isTodayReturnRow(returnRows[0], data.resolution, data.venue || undefined, Date.now());
+  const formingKey = forming || dayToDate ? returnRows[0]?.key : undefined;
   const barSize = data?.resolution ?? shownResolution;
+  // The close every total is measured from: `from Mon 21 Sep close`.
+  const baseText = useMemo(() => {
+    const day = data && returnRows.length ? returnBaseCloseDay(data.points, data.visibleFrom, data.resolution, data.venue || undefined, Date.now()) : null;
+    return day ? periodBaseText(day) : null;
+  }, [data, returnRows.length]);
   // A shut market's window ends at its last session, which the footer names.
   const marketInfo = useMemo<PaneFooterSegment[]>(() => [
+    ...baseText ? [{ id: "base", parts: [{ text: baseText, tone: "muted" as const }] }] : [],
     ...data?.lastSession
       ? [{ id: "market", parts: [{ text: closedMarketNote(data.lastSession, data.visibleTo), tone: "muted" as const }] }]
       : [],
     ...forming && newestDate ? [{ id: "forming", parts: [{ text: formingHistoryBarText(forming, newestDate), tone: "muted" as const }] }] : [],
-  ], [data, forming, newestDate]);
+    ...dayToDate ? [{ id: "forming", parts: [{ text: DAY_SO_FAR_TEXT, tone: "muted" as const }] }] : [],
+  ], [baseText, data, dayToDate, forming, newestDate]);
   usePaneStatusFooter({ registrationId: "returns", loading, error, hints, info: marketInfo });
 
   const integrityNotice = priceHistoryIntegrityNotice(returnRows.filter((row) => row.inconsistent).length);
@@ -288,6 +301,8 @@ export function ReturnsPane({ focused, width, height }: PaneProps) {
         ["Range", data?.range ?? range],
         ["Interval", getChartResolutionLabel(data?.resolution ?? shownResolution)],
         ...(forming && newestDate ? [["Partial bar", `${newestDate}, ${formingHistoryBarText(forming, newestDate)}`]] : []),
+        ...(dayToDate && newestDate ? [["Partial bar", `${newestDate}, ${DAY_SO_FAR_TEXT}`]] : []),
+        ...(baseText ? [["Base", baseText]] : []),
         ["Window", data ? `after ${new Date(data.visibleFrom).toISOString()} through ${new Date(data.visibleTo).toISOString()}` : ""],
         ...(data?.lastSession ? [["Market", closedMarketNote(data.lastSession, data.visibleTo)]] : []),
         ["Time zone", "UTC, bar open"],

package/src/plugins/builtin/ticker-detail/financials/aggregation.ts

@@ -1,6 +1,7 @@
 import type { EarningsField, FinancialStatement } from "../../../../types/financials";
 import { completeAvailability, statementFieldAvailability } from "../../../../utils/financial-statements";
 import { hasStatementGap } from "../../../../utils/statement-gaps";
+import { trailingEpsAcrossFiscalYearEnd } from "../../../../utils/trailing-eps";
 
 export type FinancialPeriod = "annual" | "quarterly";
 
@@ -159,6 +160,8 @@ const BALANCE_KEYS = new Set<string>([
 function aggregateQuarterlyStatements(
   statements: FinancialStatement[],
   date: string,
+  /** Every quarter and fiscal year on file, for EPS across a fiscal Q4 that reports none. */
+  onFile: { quarterly: readonly FinancialStatement[]; annual: readonly FinancialStatement[] } = { quarterly: [], annual: [] },
 ): FinancialTableStatement | null {
   if (statements.length !== 4) return null;
   // A provider may return semiannual reports or skip a quarter. Four rows do
@@ -215,6 +218,11 @@ function aggregateQuarterlyStatements(
     if (values.length === 4) {
       (aggregate as unknown as Record<string, unknown>)[key] = values.reduce((left, right) => left + right, 0);
       retainAvailability(key, statements);
+    } else if (key === "eps" || key === "basicEps") {
+      const acrossYearEnd = trailingEpsAcrossFiscalYearEnd(statements, onFile.quarterly, onFile.annual, key);
+      if (!acrossYearEnd) continue;
+      aggregate[key] = acrossYearEnd.value;
+      retainAvailability(key, acrossYearEnd.inputs);
     }
   }
 
@@ -252,18 +260,24 @@ function aggregateQuarterlyStatements(
  * reads a flow over a year from. Null when fewer than four consecutive
  * quarters end there.
  */
-export function trailingFourQuarters(quarterlyStatements: readonly FinancialStatement[], end: string) {
+export function trailingFourQuarters(
+  quarterlyStatements: readonly FinancialStatement[],
+  end: string,
+  annualStatements: readonly FinancialStatement[] = [],
+) {
   const sorted = [...quarterlyStatements].sort((a, b) => a.date.localeCompare(b.date));
   const index = sorted.findIndex((statement) => statement.date === end);
-  return index < 3 ? null : aggregateQuarterlyStatements(sorted.slice(index - 3, index + 1), "TTM");
+  return index < 3 ? null : aggregateQuarterlyStatements(sorted.slice(index - 3, index + 1), "TTM", { quarterly: sorted, annual: annualStatements });
 }
 
-export function computeTTM(quarterlyStatements: FinancialStatement[]) {
-  return aggregateQuarterlyStatements([...quarterlyStatements].sort((a, b) => a.date.localeCompare(b.date)).slice(-4), "TTM");
+export function computeTTM(quarterlyStatements: FinancialStatement[], annualStatements: readonly FinancialStatement[] = []) {
+  const sorted = [...quarterlyStatements].sort((a, b) => a.date.localeCompare(b.date));
+  return aggregateQuarterlyStatements(sorted.slice(-4), "TTM", { quarterly: sorted, annual: annualStatements });
 }
 
-function computePreviousTtm(quarterlyStatements: FinancialStatement[]) {
-  return aggregateQuarterlyStatements([...quarterlyStatements].sort((a, b) => a.date.localeCompare(b.date)).slice(-8, -4), "prevTTM");
+function computePreviousTtm(quarterlyStatements: FinancialStatement[], annualStatements: readonly FinancialStatement[]) {
+  const sorted = [...quarterlyStatements].sort((a, b) => a.date.localeCompare(b.date));
+  return aggregateQuarterlyStatements(sorted.slice(-8, -4), "prevTTM", { quarterly: sorted, annual: annualStatements });
 }
 
 export function buildPreviousStatementMap(
@@ -295,7 +309,7 @@ export function buildPreviousStatementMap(
   }
 
   if (ttm) {
-    const previousTtm = computePreviousTtm(quarterlyStatements);
+    const previousTtm = computePreviousTtm(quarterlyStatements, annualStatements);
     const latest = quarterlyStatements.at(-1);
     const prior = quarterlyStatements.at(-5);
     const days = latest && prior ? (Date.parse(latest.date) - Date.parse(prior.date)) / 86_400_000 : NaN;

package/src/plugins/builtin/ticker-detail/financials/model.ts

@@ -123,6 +123,8 @@ export function canCompareFinancialRow(
 ): boolean {
   if (!previous) return false;
   const key = row.kind === "group" ? row.summaryKey : row.key;
+  // A line filled from the exchange is not compared with the statements source's: the two define revenue differently.
+  if (key && filledLine(current, key) !== filledLine(previous, key)) return false;
   const sameShareBasis = current.shareBasis === previous.shareBasis;
   if (key && SHARE_COUNT_FIELDS.has(key)) return sameShareBasis;
   if (key && PER_SHARE_EARNINGS_FIELDS.has(key) && !sameShareBasis) return false;
@@ -131,6 +133,10 @@ export function canCompareFinancialRow(
   return !!currentCurrency && currentCurrency === previousCurrency;
 }
 
+function filledLine(statement: FinancialStatement, key: keyof FinancialStatement): boolean {
+  return statement.filledFrom?.fields.some((field) => field === key) === true;
+}
+
 export function semanticGrowthValue(
   growth: number | undefined,
   direction: FinancialGrowthDirection,
@@ -513,7 +519,7 @@ export function selectFinancialStatements(
     .filter((candidate) => !tabRows || tabRows.some((row) => hasFinancialRowValue(row, [candidate])))
     .slice(-limit)
     .reverse();
-  const trailing = period === "annual" && statement !== "balance" ? computeTTM(quarterlyStatements) : null;
+  const trailing = period === "annual" && statement !== "balance" ? computeTTM(quarterlyStatements, annualStatements) : null;
   // Right after a fiscal year closes, the last four quarters are that year:
   // the reported year is shown, not a second column of the same period.
   const ttm = trailing && !coversLatestYear(trailing, rawStatements[0]) ? trailing : null;
@@ -606,3 +612,32 @@ export function buildFinancialTableModel(
 
   return { period, subTab, statements, rows, unit };
 }
+
+/**
+ * A statement table's columns for stalePeriodNote, each with whether the
+ * statement's lead line (its first: revenue, total assets, free cash flow)
+ * has a figure in it, so a newer column with only some figures (an EPS
+ * alone) is not read as the latest period.
+ */
+export function financialStatementPeriods(
+  statements: readonly FinancialTableStatement[],
+  subTab: Pick<FinancialSubTab, "rows">,
+): Array<{ date: string; lead: boolean }> {
+  const lead = subTab.rows[0];
+  return statements.map((statement) => ({ date: statement.date, lead: !!lead && hasFinancialRowValue(lead, [statement]) }));
+}
+
+/** The statement lines a table has a row for (filledPeriodsNote), group totals included. */
+export function financialSubTabFields(subTab: Pick<FinancialSubTab, "rows">): Set<string> {
+  const fields = new Set<string>();
+  const visit = (rows: readonly FinancialRowDef[]) => {
+    for (const row of rows) {
+      if (isFinancialGroup(row)) {
+        if (row.summaryKey) fields.add(row.summaryKey);
+        visit(row.children);
+      } else if (row.key) fields.add(row.key);
+    }
+  };
+  visit(subTab.rows);
+  return fields;
+}

package/src/plugins/builtin/ticker-detail/financials/offerings.ts

@@ -0,0 +1,56 @@
+import { useCallback, useMemo } from "react";
+import { apiClient } from "../../../../api-client";
+import { createPluginCache } from "../../../../data/plugin-cache";
+import { useAsyncResource } from "../../../../public/react";
+import type { TickerFinancials } from "../../../../types/financials";
+import { fetchOfferingFilings, offeringNote, offeringsAfter, type OfferingFiling } from "../../../../utils/cash-runway";
+import { latestFinancialPeriod } from "../../../../utils/latest-financial-period";
+import { nonUsSecListingVenue } from "../../../../utils/sec";
+import { cachedCloudResource, loadCloudResource } from "../../shared/cloud-resource";
+
+/** A prospectus is filed days before the cash lands; an hour-old list is recent enough for the note. */
+export const offeringFilingsCache = createPluginCache<OfferingFiling[]>({
+  kind: "offering-filings", source: "gloom-cloud", schemaVersion: 1,
+  policy: { staleMs: 60 * 60_000, expireMs: 7 * 24 * 60 * 60_000 },
+});
+
+/** The newest balance sheet the statements carry: the latest quarter's, or the latest year's without quarters. */
+export function latestBalanceSheetDate(financials: Pick<TickerFinancials, "annualStatements" | "quarterlyStatements"> | null | undefined): string | null {
+  const latest = latestFinancialPeriod([...financials?.quarterlyStatements ?? [], ...financials?.annualStatements ?? []], (row) => row.date);
+  return latest?.date ?? null;
+}
+
+/** Offering prospectuses for a US company; a listing abroad files none of these. */
+function offeringSymbol(symbol: string | null | undefined, exchange: string | undefined): string | null {
+  const key = symbol?.trim().toUpperCase();
+  return key && !nonUsSecListingVenue(key, exchange) ? key : null;
+}
+
+/** The note that an offering filed after `periodEnd` is not in the cash yet, for a report. A failed read leaves it out. */
+export async function loadOfferingNote(
+  client: Parameters<typeof fetchOfferingFilings>[0],
+  listing: { symbol: string; exchange?: string },
+  periodEnd: string | null,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  const key = offeringSymbol(listing.symbol, listing.exchange);
+  if (!key || !periodEnd) return null;
+  const { payload } = await loadCloudResource(offeringFilingsCache, key, () => fetchOfferingFilings(client, key, signal), { signal });
+  return offeringNote(offeringsAfter(payload, periodEnd), periodEnd);
+}
+
+/**
+ * The same note for a pane: read only while `enabled` (the views that show
+ * cash), from the cached list first. Nothing while it loads or when the read
+ * fails, as the note is context, not the data.
+ */
+export function useOfferingNote(symbol: string | null | undefined, exchange: string | undefined, periodEnd: string | null, enabled: boolean): string | null {
+  const key = enabled && periodEnd ? offeringSymbol(symbol, exchange) : null;
+  const loader = useCallback(async (force: boolean) => (
+    await loadCloudResource(offeringFilingsCache, key!, () => fetchOfferingFilings(apiClient, key!), { force })
+  ).payload, [key]);
+  const cached = useMemo(() => key ? cachedCloudResource(offeringFilingsCache, key)?.payload ?? null : null, [key]);
+  const { data } = useAsyncResource(key ? loader : null, { initialData: () => cached });
+  const filings = data ?? cached;
+  return key && periodEnd && filings ? offeringNote(offeringsAfter(filings, periodEnd), periodEnd) : null;
+}

package/src/plugins/builtin/ticker-detail/financials/ratios.ts

@@ -1,9 +1,10 @@
 import { createValuationCurrencyContext } from "../../../../time-series/valuation-currency";
-import type { FinancialStatement, PricePoint, TickerFinancials } from "../../../../types/financials";
+import type { CompanyProfile, FinancialStatement, PricePoint, TickerFinancials } from "../../../../types/financials";
 import { formatNumber, pickUnit } from "../../../../utils/format";
 import { pricePointIntegrity } from "../../../../utils/price-history-integrity";
 import { formatPerShareNumber } from "../../../../utils/reported-money";
 import { hasStatementGap } from "../../../../utils/statement-gaps";
+import { cashAndShortTermInvestments, excludesCashRunway, formatRunwayMonths, SHORT_RUNWAY_HISTORY, monthlyOperatingBurn, QUARTER_MONTHS, reportsShortTermTotal, runwayMonths, YEAR_MONTHS } from "../../../../utils/cash-runway";
 import {
   buildPreviousStatementMap,
   trailingFourQuarters,
@@ -21,21 +22,23 @@ import {
  * Why a ratio or one of its inputs has no number: a line the statements do
  * not carry for the period, a ratio whose denominator makes it meaningless
  * (a loss under P/E, negative equity under ROE), no close at the period end,
- * a close still loading, or a quarter with fewer than four quarters to sum
- * for a trailing flow.
+ * a close still loading, a quarter with fewer than four quarters to sum
+ * for a trailing flow, or operations that brought cash in, where a runway
+ * has no burn to divide by.
  */
-export type RatioGap = "not-reported" | "short-history" | "not-meaningful" | "no-price" | "loading";
+export type RatioGap = "not-reported" | "short-history" | "no-burn" | "not-meaningful" | "no-price" | "loading";
 export type RatioAmount = number | RatioGap;
 
 export const RATIO_GAP_TEXT: Record<RatioGap, string> = {
   "not-reported": "not reported",
-  "short-history": "< 4 quarters",
+  "short-history": SHORT_RUNWAY_HISTORY,
+  "no-burn": "no burn",
   "not-meaningful": "N/M",
   "no-price": "no price",
   loading: "--",
 };
 
-export type RatioFormat = "percent" | "multiple" | "days";
+export type RatioFormat = "percent" | "multiple" | "days" | "months";
 export type RatioInputFormat = "money" | "perShare" | "days";
 
 /** One column of a ratio tab: a period's statement and what its ratios also need. */
@@ -53,6 +56,8 @@ export interface RatioPeriod {
   trailing?: FinancialTableStatement | null;
   /** The close at the period end in the statement's currency. */
   price: RatioAmount;
+  /** The filer reports cash and short-term investments as a total in some period on file (utils/cash-runway). */
+  shortTermTotalOnFile?: boolean;
 }
 
 interface RatioInputDef {
@@ -79,6 +84,8 @@ export interface RatioDef {
   format: RatioFormat;
   /** The sign carries meaning (a loss, a negative return), so the value takes the sign colour. */
   signed?: boolean;
+  /** Read over one quarter, so the annual view, whose columns are years, leaves it out. */
+  quarterlyOnly?: boolean;
   inputs: RatioInputDef[];
   /** From the inputs after annualization. */
   compute: (values: number[], period: RatioPeriod) => RatioAmount;
@@ -277,6 +284,26 @@ const DPO: RatioDef = {
   compute: ([balance, daily]) => over(balance!, daily!),
 };
 
+/** Cash used by operations per month: a quarter's operating cash flow over 3 months, a year's over 12. */
+const monthlyBurn = (months: number) => ({ statement }: RatioPeriod): RatioAmount => (
+  monthlyOperatingBurn(finite(statement.operatingCashFlow), months) ?? "not-reported"
+);
+
+/** Cash alone for a filer that reports no total with short-term investments, never for one missing it in a period. */
+const runwayCash = ({ statement, shortTermTotalOnFile }: RatioPeriod): RatioAmount => (
+  cashAndShortTermInvestments(statement, shortTermTotalOnFile)?.amount ?? "not-reported"
+);
+
+/** Months of cash and short-term investments at a monthly operating burn (utils/cash-runway, as `ticker` reads it). */
+const runway = (id: string, label: string, burn: RatioInputDef, quarterlyOnly = false): RatioDef => ({
+  id,
+  label,
+  format: "months",
+  ...(quarterlyOnly ? { quarterlyOnly } : {}),
+  inputs: [{ label: "Cash + ST Inv", format: "money", value: runwayCash }, burn],
+  compute: ([cash, perMonth]) => runwayMonths(cash!, perMonth!),
+});
+
 const dayCount = (label: string, def: RatioDef, operator?: RatioInputDef["operator"]): RatioInputDef => ({
   label, operator, format: "days", value: (period) => evaluateRatio(def, period).value,
 });
@@ -440,6 +467,11 @@ export const RATIO_TABS: RatioTabDef[] = [
         ],
         compute: ([cash, liabilities]) => over(cash!, liabilities!),
       },
+      // Both burns, as a quarter swings for a company paid in lumps; the trailing one reads the year in annual columns.
+      runway("runway-quarter", "Runway, Qtr Burn (mo)",
+        { label: "Op Burn/Mo", operator: "÷", format: "money", value: monthlyBurn(QUARTER_MONTHS) }, true),
+      runway("runway-ttm", "Runway, TTM Burn (mo)",
+        { label: "Op Burn/Mo", operator: "÷", format: "money", trailing: true, value: monthlyBurn(YEAR_MONTHS) }),
     ],
   },
   {
@@ -527,7 +559,7 @@ export const RATIO_TAB_KEYS = new Set(RATIO_TABS.map((tab) => tab.key));
  * report explains more than a missing close, and a close still loading may
  * yet arrive.
  */
-const GAP_ORDER: RatioGap[] = ["not-reported", "short-history", "not-meaningful", "no-price", "loading"];
+const GAP_ORDER: RatioGap[] = ["not-reported", "short-history", "no-burn", "not-meaningful", "no-price", "loading"];
 
 function inputAmount(input: RatioInputDef, period: RatioPeriod): RatioAmount {
   if (!input.trailing || !period.quarterly) return input.value(period);
@@ -556,6 +588,7 @@ function ratioInputLabel(input: RatioInputDef, quarterly: boolean): string {
 export function formatRatioValue(format: RatioFormat, amount: RatioAmount): string {
   if (isGap(amount)) return RATIO_GAP_TEXT[amount];
   if (format === "percent") return `${formatNumber(amount * 100, 1)}%`;
+  if (format === "months") return formatRunwayMonths(amount, "");
   if (format === "days") return formatNumber(amount, 1);
   return `${formatNumber(amount, Math.abs(amount) < 10 ? 2 : 1)}x`;
 }
@@ -657,7 +690,7 @@ function trailingYear(
     Math.abs(Date.parse(candidate.date) - end) <= SAME_PERIOD_END_DAYS * 86_400_000
     && (!candidate.currency || !statement.currency || candidate.currency === statement.currency)
   ));
-  return year ?? trailingFourQuarters(quarterlyStatements, statement.date);
+  return year ?? trailingFourQuarters(quarterlyStatements, statement.date, annualStatements);
 }
 
 export function ratioPeriods(
@@ -668,6 +701,7 @@ export function ratioPeriods(
   /** Every statement on file, not only the columns shown, for quarterly columns' trailing years. */
   onFile: { annual: readonly FinancialStatement[]; quarterly: readonly FinancialStatement[] } = { annual: [], quarterly: [] },
 ): RatioPeriod[] {
+  const shortTermTotalOnFile = reportsShortTermTotal([...onFile.annual, ...onFile.quarterly, ...statements]);
   return statements.map((statement) => {
     const quarterly = period === "quarterly" && statement.date !== "TTM";
     return {
@@ -676,6 +710,7 @@ export function ratioPeriods(
       quarterly,
       ...(quarterly ? { trailing: trailingYear(statement, onFile.annual, onFile.quarterly) } : {}),
       price: price(statement),
+      shortTermTotalOnFile,
     };
   });
 }
@@ -700,6 +735,8 @@ export type RatioTableRow =
 
 export interface RatioTableModel {
   tab: RatioTabDef;
+  /** The tab's ratios the period shows: a quarterly-only one is left out of years. */
+  ratios: RatioDef[];
   periods: RatioPeriod[];
   /** Each ratio's cell per period, by ratio id. */
   cells: Map<string, RatioCell[]>;
@@ -708,14 +745,26 @@ export interface RatioTableModel {
 
 const UNIT_WORDS: Record<string, string> = { K: "k", M: "mn", B: "bn", T: "tn" };
 
+/** The ratios a tab shows for quarterly or annual columns. */
+export function visibleRatios(tab: RatioTabDef, quarterly: boolean): RatioDef[] {
+  return quarterly ? tab.ratios : tab.ratios.filter((def) => !def.quarterlyOnly);
+}
+
 export function buildRatioTableModel(
   tab: RatioTabDef,
   periods: RatioPeriod[],
   expandedRatioIds: ReadonlySet<string> | "all",
+  profile?: CompanyProfile,
 ): RatioTableModel {
   const quarterly = periods.some((period) => period.quarterly);
-  const cells = new Map(tab.ratios.map((def) => [def.id, periods.map((period) => evaluateRatio(def, period))]));
-  const inputs = tab.ratios.flatMap((def) => def.inputs.map((input, index) => {
+  const totalOnFile = periods.some((period) => period.shortTermTotalOnFile);
+  const ratios = visibleRatios(tab, quarterly)
+    .filter((def) => def.format !== "months" || !excludesCashRunway(profile))
+    .map((def) => def.format === "months" && !totalOnFile
+      ? { ...def, inputs: def.inputs.map((input, index) => index === 0 ? { ...input, label: "Cash" } : input) }
+      : def);
+  const cells = new Map(ratios.map((def) => [def.id, periods.map((period) => evaluateRatio(def, period))]));
+  const inputs = ratios.flatMap((def) => def.inputs.map((input, index) => {
     const values = cells.get(def.id)!.map((cell) => cell.inputs[index]).filter((value) => typeof value === "number");
     const { suffix, divisor } = input.format === "money" ? pickUnit(values) : { suffix: "", divisor: 1 };
     const unit = UNIT_WORDS[suffix] ?? suffix;
@@ -733,12 +782,12 @@ export function buildRatioTableModel(
   // Each money input names its unit: a ratio tab has few of them, and a unit
   // stated once in the query bar is the first thing a narrow pane cuts.
   const rows: RatioTableRow[] = [];
-  for (const def of tab.ratios) {
+  for (const def of ratios) {
     const expanded = expandedRatioIds === "all" || expandedRatioIds.has(def.id);
     rows.push({ kind: "ratio", id: def.id, def, label: def.label, expanded });
     if (expanded) rows.push(...inputs.filter((row) => row.def === def));
   }
-  return { tab, periods, cells, rows };
+  return { tab, ratios, periods, cells, rows };
 }
 
 export const findRatioTab = (key: string) => RATIO_TABS.find((tab) => tab.key === key);
@@ -777,5 +826,5 @@ export function ratioTableForFinancials(
     const close = history ? periodEndClose(history, ratioPeriodEnd(statement)) : undefined;
     return (close === undefined ? null : currencies.priceInStatementUnits(statement, close)) ?? "no-price";
   };
-  return buildRatioTableModel(tab, ratioPeriods(statements, ratioOpenings(period, annual, quarterly), period, price, { annual, quarterly }), "all");
+  return buildRatioTableModel(tab, ratioPeriods(statements, ratioOpenings(period, annual, quarterly), period, price, { annual, quarterly }), "all", financials.profile);
 }