gloomberb 0.18.4 → 0.19.0

package/src/plugins/builtin/research/corporate-actions-pane.tsx

@@ -446,6 +446,7 @@ export function CorporateActionsView({
   const financialCurrency = tickerFinancials?.financialCurrency;
   const trailingEps = tickerFinancials?.fundamentals?.eps;
   const trailingEpsCurrency = tickerFinancials?.fundamentals?.epsCurrency;
+  const trailingEpsSource = tickerFinancials?.fundamentals?.trailingEpsSource;
   const fundamentalsCurrency = tickerFinancials?.fundamentals?.financialCurrency;
   const marketCapCurrency = tickerFinancials?.fundamentals?.marketCapCurrency;
   const quoteCurrency = tickerFinancials?.quote?.currency;
@@ -453,10 +454,10 @@ export function CorporateActionsView({
     () => (quarterlyStatements || financialCurrency || trailingEps != null ? {
       quarterlyStatements: quarterlyStatements ?? [],
       financialCurrency,
-      fundamentals: { eps: trailingEps, epsCurrency: trailingEpsCurrency, financialCurrency: fundamentalsCurrency, marketCapCurrency },
+      fundamentals: { eps: trailingEps, epsCurrency: trailingEpsCurrency, financialCurrency: fundamentalsCurrency, marketCapCurrency, trailingEpsSource },
       quote: quoteCurrency ? { currency: quoteCurrency } : null,
     } : null),
-    [financialCurrency, fundamentalsCurrency, marketCapCurrency, quarterlyStatements, quoteCurrency, trailingEps, trailingEpsCurrency],
+    [financialCurrency, fundamentalsCurrency, marketCapCurrency, quarterlyStatements, quoteCurrency, trailingEps, trailingEpsCurrency, trailingEpsSource],
   );
   const actionsLoader = useCallback((nextSymbol: string, nextExchange: string, forceRefresh: boolean) => {
     if (!dataProvider?.getCorporateActions) throw new Error("Corporate actions source unavailable");

package/src/plugins/builtin/research/event-model.ts

@@ -15,7 +15,7 @@ import {
 } from "../../../utils/format";
 import { computeTTM } from "../ticker-detail/financials/aggregation";
 import { declaredDividends } from "../../../utils/declared-dividends";
-import { fundamentalsEpsCurrency } from "../../../utils/fundamentals";
+import { fundamentalsEpsCurrency, SERVED_TRAILING_EPS } from "../../../utils/fundamentals";
 import {
   earningsDateStatus,
   earningsDetail,
@@ -175,11 +175,11 @@ function estimateValue(pair: EstimatePair): string {
 }
 
 /**
- * What the TTM row reads: the statements for its four quarters and revenue, and the trailing EPS Gloom Cloud serves
- * with the fundamentals, the figure `ticker` prints as EPS (TTM).
+ * What the TTM row reads: the statements for its four quarters and revenue, and the trailing EPS of the fundamentals,
+ * the figure `ticker` prints as EPS (TTM) (the filed quarters' when they give one, see time-series/filed-trailing-eps).
  */
 export type EventFinancials = Pick<TickerFinancials, "quarterlyStatements" | "financialCurrency"> & {
-  fundamentals?: Pick<NonNullable<TickerFinancials["fundamentals"]>, "eps" | "epsCurrency" | "financialCurrency" | "marketCapCurrency"> | null;
+  fundamentals?: Pick<NonNullable<TickerFinancials["fundamentals"]>, "eps" | "epsCurrency" | "financialCurrency" | "marketCapCurrency" | "trailingEpsSource"> | null;
   /** The listing's currency, which says whether an unlabelled EPS can be in the statements' (fundamentalsCurrency). */
   quote?: Pick<NonNullable<TickerFinancials["quote"]>, "currency"> | null;
 };
@@ -204,9 +204,10 @@ function adjustedQuarterSum(
 }
 
 /**
- * The TTM row's EPS is the GAAP diluted trailing figure, the one `ticker` prints as EPS (TTM). Without it, the four
- * statement quarters' diluted EPS summed. The reported rows above it are often adjusted, so they are never added to
- * it: only when all four are adjusted does the detail also give their sum.
+ * The TTM row's EPS is the GAAP diluted trailing figure `ticker` prints as EPS (TTM): the last four filed quarters',
+ * or Gloom Cloud's trailing figure, named so, when they give none. Without either, the four statement quarters'
+ * diluted EPS summed. The reported rows above it are often adjusted, so they are never added to it: only when all
+ * four are adjusted does the detail also give their sum.
  */
 function ttmRow(
   quarterlyStatements: readonly FinancialStatement[],
@@ -226,7 +227,8 @@ function ttmRow(
     date: latest?.date ?? "",
     status: "TTM",
     period: "4 qtrs",
-    detail: [eps == null ? "statement sum" : served ? "GAAP diluted" : "GAAP diluted (statements)",
+    detail: [eps == null ? "statement sum" : !served ? "GAAP diluted (statements)"
+      : financials?.fundamentals?.trailingEpsSource === "served" ? `GAAP diluted (${SERVED_TRAILING_EPS})` : "GAAP diluted",
       adjusted == null ? null : `adj sum ${formatNumber(adjusted, 2)}`].filter(Boolean).join(", "),
     epsCurrency: served ? fundamentalsEpsCurrency(financials) : ttm.currency ?? financials?.financialCurrency,
     revenueCurrency: ttm.currency ?? financials?.financialCurrency,

package/src/plugins/builtin/research/headless.ts

@@ -83,7 +83,7 @@ function projectEarningsEstimatesHeadless(
       returned: rows.length,
       truncated: rows.length < matching.length,
       coverageNote: notice?.text,
-      epsBasis: `${EPS_BASIS_NOTE} The TTM row's EPS is the GAAP diluted trailing figure ticker shows as EPS (TTM), or the four statement quarters' diluted EPS when none is served; reported quarters of different bases are never summed, and the row adds an adjusted sum only when all four quarters are adjusted.`,
+      epsBasis: `${EPS_BASIS_NOTE} The TTM row's EPS is the GAAP diluted trailing figure ticker shows as EPS (TTM): the last four filed quarters', or Gloom Cloud's TTM (named so) when they give none, or the four statement quarters' diluted EPS when neither is there; reported quarters of different bases are never summed, and the row adds an adjusted sum only when all four quarters are adjusted.`,
       dateNote: "Fiscal period dates are not announcement dates. Revenue is attached only to an identified statement period.",
       unmatchedReportedPeriods,
     },

package/src/plugins/builtin/research/relative-valuation-headless.ts

@@ -96,7 +96,10 @@ const VALUATION_COLUMNS: HeadlessPaneColumn[] = [
   ...([["fcfYield", "FCF Yield"], ["revenueGrowth", REVENUE_GROWTH_HEADER], ["operatingMargin", "TTM Op Margin"]] as const).map(([key, header]) => ({
     key, header, align: "right" as const,
     format: (value: unknown, row: Record<string, unknown>) => value == null ? gapText(row, key)
-      : key === "revenueGrowth" ? formatPercent(Number(value)) : formatLevelPercent(Number(value)),
+      : key === "revenueGrowth" ? formatPercent(Number(value))
+        // A margin of the latest fiscal year, where no trailing quarters were served, says which year.
+        : key === "operatingMargin" && typeof row.operatingMarginPeriod === "string"
+          ? `${formatLevelPercent(Number(value))} ${row.operatingMarginPeriod}` : formatLevelPercent(Number(value)),
   })),
 ];
 
@@ -226,6 +229,7 @@ export const relativeValuationHeadless: HeadlessPaneDefinition<"rows"> = {
           ...rows.flatMap((row) => row.evSalesUnavailable ? [`${row.symbol}: ${row.evSalesUnavailable}`] : []),
           ...rows.flatMap((row) => row.evSalesNote ? [`${row.symbol}: ${row.evSalesNote}`] : []),
           ...rows.flatMap((row) => row.marketCapNote ? [`${row.symbol}: ${row.marketCapNote}`] : []),
+          ...rows.flatMap((row) => row.marketCapWithheld ? [`${row.symbol}: ${row.marketCapWithheld}`] : []),
         ],
         multipleBasis: "Comparable P/E fields require a positive finite multiple over positive EPS, and evSales an enterprise value above zero; notMeaningful says why one is null, and reportedMultiples preserves the finite provider P/E values.",
         marketCapBasis: "Market caps retain their own currency and source. Fundamentals retrieval time is not a valuation date; quote timestamps do not date fallback caps.",

package/src/plugins/builtin/research/relative-valuation-model.ts

@@ -1,9 +1,10 @@
 import { formatCurrency } from "../../../utils/format";
 import { comparablePriceEarnings, notMeaningfulMultiples } from "../../../utils/price-earnings";
-import { marketCapBasisNote, viewMarketCapitalization } from "../../../utils/market-capitalization";
+import { marketCapBasisNote, viewMarketCapitalization, withheldMarketCap } from "../../../utils/market-capitalization";
 import { enterpriseValueNotMeaningful, enterpriseValueReconciliationNote, enterpriseValueWithdrawn, reportedEnterpriseValue } from "../../../utils/fundamentals";
 import { getExtendedSessionDisplay, getQuoteSessionFields } from "../../../market-data/market/status";
 import { atRegularSessionPrice, movePriceDerivedFigures, regularSessionValuationPrice } from "../../../market-data/quotes/regular-session-valuation";
+import { fiscalPeriodLabel, fiscalYearEndMonth } from "../../../utils/fiscal-period";
 import { latestFinancialPeriod, latestReportedPeriod } from "../../../utils/latest-financial-period";
 import type { Quote, TickerFinancials } from "../../../types/financials";
 
@@ -50,6 +51,25 @@ function fcfYieldGap(fundamentals: TickerFinancials["fundamentals"], capCurrency
 }
 export const RELATIVE_VALUATION_STALE_FUNDAMENTALS_NOTICE = "Fundamentals stale: retained values may be out of date";
 
+/**
+ * The operating margin of the latest fiscal year, for a row whose trailing
+ * twelve months are not whole (a quarter the source has not carried yet):
+ * that year's operating income over its revenue, named for the year ("FY25")
+ * so a cell never passes it off as trailing. Null when the latest year lacks
+ * either figure; an older year is never stood in for it.
+ */
+function fiscalYearOperatingMargin(annualStatements: TickerFinancials["annualStatements"] | undefined) {
+  const latest = latestFinancialPeriod(annualStatements, (row) => row.date);
+  if (!latest || !finiteNumber(latest.operatingIncome) || !finiteNumber(latest.totalRevenue) || latest.totalRevenue <= 0) return null;
+  const year = /^FY\d{2}(\d{2})$/.exec(fiscalPeriodLabel(latest.date, "annual", fiscalYearEndMonth(annualStatements ?? [])))?.[1];
+  return {
+    value: latest.operatingIncome / latest.totalRevenue,
+    // The fiscal year's own name; the calendar year of its end where the year cannot be named.
+    label: `FY${year ?? latest.date.slice(2, 4)}`,
+    periodEnd: latest.date.slice(0, 10),
+  };
+}
+
 /**
  * A peer's row. Last, its change and the extended print are the quote's
  * sessions as `quote` reads them (getQuoteSessionFields): after the close,
@@ -97,14 +117,17 @@ export function relativeValuationValues(snapshot: TickerFinancials | null) {
     && fundamentals.freeCashFlow != null && Number.isFinite(fundamentals.freeCashFlow) && capitalization.value > 0
     ? fundamentals.freeCashFlow / capitalization.value : null;
   const revenueGrowth = fundamentals?.revenueGrowth ?? fundamentals?.lastQuarterGrowth ?? null;
-  const operatingMargin = fundamentals?.operatingMargin ?? null;
+  const trailingOperatingMargin = fundamentals?.operatingMargin ?? null;
+  const fiscalYearMargin = trailingOperatingMargin == null ? fiscalYearOperatingMargin(financials?.annualStatements) : null;
+  const operatingMargin = trailingOperatingMargin ?? fiscalYearMargin?.value ?? null;
   const trailingPE = trailingNotMeaningful ? null : comparablePriceEarnings(reportedMultiples.trailingPE);
   const forwardPE = forwardNotMeaningful ? null : comparablePriceEarnings(reportedMultiples.forwardPE);
   // Every figure a row lacks says why, so an export's blank cell is never silent: N/M multiples say so themselves.
   const gaps: Partial<Record<RelativeValuationGapKey, string>> = {};
   if (session.price == null) gaps.price = quoteStale ? QUOTE_STALE : NOT_REPORTED;
   if (session.changePercent == null) gaps.changePercent = quoteStale ? QUOTE_STALE : NOT_REPORTED;
-  if (capitalization == null) gaps.marketCap = quoteStale && !fundamentals?.marketCap ? QUOTE_STALE : NOT_REPORTED;
+  const withheld = withheldMarketCap(fundamentals);
+  if (capitalization == null) gaps.marketCap = withheld?.gap ?? (quoteStale && !fundamentals?.marketCap ? QUOTE_STALE : NOT_REPORTED);
   if (trailingPE == null && !trailingNotMeaningful && reportedMultiples.trailingPE == null) gaps.trailingPE = NOT_REPORTED;
   if (forwardPE == null && !forwardNotMeaningful && reportedMultiples.forwardPE == null) gaps.forwardPE = NOT_REPORTED;
   if (evSales == null && !evSalesNotMeaningful) gaps.evSales = evSalesGap(fundamentals, quote?.currency, evSalesWithdrawn, enterpriseValueGap);
@@ -136,6 +159,8 @@ export function relativeValuationValues(snapshot: TickerFinancials | null) {
     marketCapProvenance: capitalization?.provenance ?? null,
     /** valuation's note when the cap is the share count times the price: the provider's figure it replaced. */
     marketCapNote: marketCapBasisNote(capitalization) ?? null,
+    /** Why Gloom Cloud withheld the cap (a receipt priced as ordinary shares), as `valuation` and EQS say it; null otherwise. */
+    marketCapWithheld: withheld?.note ?? null,
     trailingPE,
     forwardPE,
     reportedMultiples,
@@ -151,6 +176,9 @@ export function relativeValuationValues(snapshot: TickerFinancials | null) {
     fcfYield,
     revenueGrowth,
     operatingMargin,
+    /** The fiscal year the operating margin is of ("FY25") when no trailing figure was served; null when it is trailing twelve months. */
+    operatingMarginPeriod: fiscalYearMargin?.label ?? null,
+    operatingMarginPeriodEnd: fiscalYearMargin?.periodEnd ?? null,
     /** Why each missing figure is missing, in a few words the row draws in its place. */
     gaps,
   };

package/src/plugins/builtin/research/relative-valuation-pane.tsx

@@ -19,7 +19,7 @@ import { useSampledValue } from "../../../state/hooks/live-ticker-financials";
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import type { TickerFinancials } from "../../../types/financials";
 import { normalizeSymbol } from "../../../utils/exchanges";
-import { colors, priceColor } from "../../../theme/colors";
+import { colors, priceColor, shownPriceColor } from "../../../theme/colors";
 import { extendedSessionStateLabel, type ExtendedSession } from "../../../market-data/market/status";
 import { compareSortValues, nextHeaderSort, type SortDirection } from "../../../utils/sort-values";
 import { formatCompact, formatLevelPercent, formatNumber, formatPercent, formatPercentRaw } from "../../../utils/format";
@@ -97,7 +97,7 @@ function extendedMove(row: RelativeRow, columnId: ExtendedColumnId): number | nu
  * AFTER-HRS or OVERNIGHT column, named as BI and MOST name it, follows CHG%
  * for each session in `extendedSessions`.
  */
-function buildRelativeColumns(baseCurrency: string, extendedSessions: readonly ExtendedSession[]): RelativeColumn[] {
+function buildRelativeColumns(baseCurrency: string, extendedSessions: readonly ExtendedSession[], marginNamesYear: boolean): RelativeColumn[] {
   const symbolWidth = 8;
   const priceWidth = 10;
   const pctWidth = 8;
@@ -117,7 +117,8 @@ function buildRelativeColumns(baseCurrency: string, extendedSessions: readonly E
     { id: "fcfYield", label: "FCF%", width: metricWidth, align: "right" },
     // Latest quarter against the year before, and a trailing-twelve-month margin.
     { id: "revenueGrowth", label: REVENUE_GROWTH_LABEL, width: metricWidth, align: "right" },
-    { id: "operatingMargin", label: "TTM OP%", width: metricWidth, align: "right" },
+    // Wider while a peer's margin is of its latest fiscal year and names it ("16.83% FY25").
+    { id: "operatingMargin", label: "TTM OP%", width: marginNamesYear ? 12 : metricWidth, align: "right" },
   ];
 }
 
@@ -217,9 +218,10 @@ export function RelativeValuationPane({ focused, width, height }: PaneProps) {
   const fxRates = useFxRatesMap([baseCurrency, ...rows.map((row) => row.marketCapCurrency)]);
   // A pre-market or after-hours print gets its own column when a peer has one.
   const extendedSessionsKey = extendedSessionsOf(rows).join(",");
+  const marginNamesYear = rows.some((row) => row.operatingMarginPeriod != null);
   const columns = useMemo(
-    () => buildRelativeColumns(baseCurrency, extendedSessionsKey ? extendedSessionsKey.split(",") as ExtendedSession[] : []),
-    [baseCurrency, extendedSessionsKey],
+    () => buildRelativeColumns(baseCurrency, extendedSessionsKey ? extendedSessionsKey.split(",") as ExtendedSession[] : [], marginNamesYear),
+    [baseCurrency, extendedSessionsKey, marginNamesYear],
   );
 
   const comparableRows = useMemo(() => rows.map((row) => ({
@@ -295,12 +297,12 @@ export function RelativeValuationPane({ focused, width, height }: PaneProps) {
       case "price":
         return { text: formatRelativePrice(row.price, row.currency), color: colors.text };
       case "changePercent":
-        return { text: row.changePercent != null ? formatPercentRaw(row.changePercent) : "-", color: priceColor(row.changePercent ?? 0) };
+        return { text: row.changePercent != null ? formatPercentRaw(row.changePercent) : "-", color: shownPriceColor(row.changePercent ?? 0, 2) };
       case "preMarket":
       case "afterHours":
       case "overnight": {
         const move = extendedMove(row, column.id);
-        return { text: move != null ? formatPercentRaw(move) : "-", value: move, color: move == null ? colors.textDim : priceColor(move) };
+        return { text: move != null ? formatPercentRaw(move) : "-", value: move, color: move == null ? colors.textDim : shownPriceColor(move, 2) };
       }
       case "marketCap":
         return { text: formatCompact(row.marketCap ?? undefined, { fixedDecimals: true }), color: colors.textDim };
@@ -317,9 +319,9 @@ export function RelativeValuationPane({ focused, width, height }: PaneProps) {
       case "fcfYield":
         return { text: formatLevelPercent(row.fcfYield ?? undefined), color: priceColor(row.fcfYield ?? 0) };
       case "revenueGrowth":
-        return { text: formatPercent(row.revenueGrowth ?? undefined), color: priceColor(row.revenueGrowth ?? 0) };
+        return { text: formatPercent(row.revenueGrowth ?? undefined), color: shownPriceColor((row.revenueGrowth ?? 0) * 100, 2) };
       case "operatingMargin":
-        return { text: formatLevelPercent(row.operatingMargin ?? undefined), color: colors.text };
+        return { text: `${formatLevelPercent(row.operatingMargin ?? undefined)}${row.operatingMargin != null && row.operatingMarginPeriod ? ` ${row.operatingMarginPeriod}` : ""}`, color: colors.text };
     }
   }, []);
 

package/src/plugins/builtin/reverse-dcf/headless.ts

@@ -4,7 +4,8 @@ import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { formatCompactCurrency } from "../../../utils/format";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { loadReverseDcfInputs } from "./client";
-import { describeFcfMargin, DISCOUNT_RATES, projectReverseDcf, TERMINAL_GROWTH, TERMINAL_GROWTHS, type ImpliedGrowth } from "./model";
+import { describeFcfMargin, DISCOUNT_RATES, pastGrowthBasis, projectReverseDcf, TERMINAL_GROWTH, TERMINAL_GROWTHS, ttmBaseNote,
+  type ImpliedGrowth } from "./model";
 
 const percent = (value: unknown) => typeof value === "number" ? `${(value * 100).toFixed(1)}%` : "--";
 /** An assumption as it is set: 9%, 2.5%. */
@@ -35,6 +36,7 @@ export const reverseDcfHeadless: HeadlessPaneDefinition<"bundle"> = {
     const quote = inputs.financials?.quote;
     // The enterprise value is measured at the regular session price, so the report is dated by it: after the close, the close.
     const valuedAt = regularSessionValuationTime(quote);
+    const notes = [model.enterpriseValueNote, ttmBaseNote(model)].filter((note): note is string => !!note);
     return {
       sections: [
         { title: "Reverse DCF", columns: [{ key: "label", header: "" }, { key: "value", header: "Value" }], rows: [
@@ -42,7 +44,7 @@ export const reverseDcfHeadless: HeadlessPaneDefinition<"bundle"> = {
             : `${typeof growth === "number" ? percent(growth) : growth} at ${rate(discountRate)} discount, ${rate(TERMINAL_GROWTH)} terminal` },
           { label: "Implied revenue, year 10", value: model.impliedRevenue == null ? "--"
             : `${formatCompactCurrency(model.impliedRevenue, currency)} at ${describeFcfMargin(fcfMargin, fcfMarginBasis)}` },
-          { label: "Past FCF growth", value: model.pastGrowth ? `${percent(model.pastGrowth.rate)} over ${model.pastGrowth.years}y` : "--" },
+          { label: "Past FCF growth", value: model.pastGrowth ? `${percent(model.pastGrowth.rate)} ${pastGrowthBasis(model.pastGrowth)}` : "--" },
           { label: "FCF yield", value: percent(model.fcfYield) },
           { label: "Enterprise value", value: `${formatCompactCurrency(model.enterpriseValue ?? undefined, currency)}${model.enterpriseValueNote ? " (provider)" : ""}` },
           { label: "Free cash flow, TTM", value: formatCompactCurrency(model.freeCashFlow ?? undefined, currency) },
@@ -60,7 +62,7 @@ export const reverseDcfHeadless: HeadlessPaneDefinition<"bundle"> = {
       },
       unavailableSymbols: model.implied ? [] : [instrument.symbol],
       errors: [inputs.error, model.error].filter((value): value is string => !!value),
-      ...(model.enterpriseValueNote ? { notes: [model.enterpriseValueNote] } : {}),
+      ...notes.length > 0 ? { notes } : {},
       metadata: { currency: model.currency, discountRate, terminalGrowth: TERMINAL_GROWTH, discountRates: DISCOUNT_RATES, fcfMargin,
         fcfMarginSource: fcfMarginBasis.source, companyFcfMargin: fcfMarginBasis.company, fcfMarginGap: fcfMarginBasis.gap,
         impliedRevenue: model.impliedRevenue, stale: inputs.stale, fetchedAt: inputs.fetchedAt, methodology: "docs/research-data.md#reverse-dcf" },

package/src/plugins/builtin/reverse-dcf/model.ts

@@ -1,6 +1,8 @@
 import { unavailableText } from "../../../components/ui/status";
 import { atRegularSessionPrice } from "../../../market-data/quotes/regular-session-valuation";
 import type { Fundamentals, TickerFinancials } from "../../../types/financials";
+import { fiscalPeriodLabel, fiscalYearEndMonth } from "../../../utils/fiscal-period";
+import { formatCompactCurrency } from "../../../utils/format";
 import { enterpriseValueCheck, enterpriseValueLabel, enterpriseValueNotMeaningful, enterpriseValueReconciliationNote,
   enterpriseValueWithdrawn, reportedEnterpriseValue } from "../../../utils/fundamentals";
 
@@ -50,8 +52,10 @@ export interface ReverseDcfModel {
   fcfMarginBasis: FcfMarginBasis;
   /** Year-ten revenue at `fcfMargin`: trailing free cash flow grown at the implied rate for ten years, over the margin. */
   impliedRevenue: number | null;
-  /** Annual FCF growth between the latest annual statement and one up to five years earlier, when both are positive. */
-  pastGrowth: { rate: number; years: number } | null;
+  /** Annual FCF growth between the latest annual statement and one up to five years earlier, when both are positive. `period` names the two years: FY2021–FY2025. */
+  pastGrowth: { rate: number; years: number; period: string } | null;
+  /** The latest annual statement's free cash flow, which the past growth ends at, and the year it is of (FY2025). */
+  fiscalYearFcf: { value: number; label: string } | null;
   /** Implied growth for each discount rate (rows) at each terminal growth (columns). */
   sensitivity: { discountRate: number; implied: (ImpliedGrowth | null)[] }[];
   error: string | null;
@@ -82,15 +86,65 @@ export function solveImpliedGrowth(enterpriseValue: number, fcf: number, discoun
   return { kind: "rate", value: (low + high) / 2 };
 }
 
-function pastFcfGrowth(financials: TickerFinancials): ReverseDcfModel["pastGrowth"] {
-  const annual = financials.annualStatements
+/** The latest annual statements with a free cash flow, oldest first, as many as the past growth looks back over. */
+function annualFreeCashFlows(financials: TickerFinancials) {
+  return financials.annualStatements
     .filter((row) => typeof row.freeCashFlow === "number" && Number.isFinite(row.freeCashFlow))
     .sort((a, b) => a.date.localeCompare(b.date))
     .slice(-6);
+}
+
+/** The two years a past growth spans, as issuers name them: `FY2021–FY2025`; period end dates where a year is off the fiscal calendar. */
+function fiscalSpan(financials: TickerFinancials, from: string, to: string): string {
+  const month = fiscalYearEndMonth(financials.annualStatements);
+  const [start, end] = [from, to].map((date) => fiscalPeriodLabel(date, "annual", month)) as [string, string];
+  return start.startsWith("FY") && end.startsWith("FY") ? `${start}–${end}` : `${from.slice(0, 10)} to ${to.slice(0, 10)}`;
+}
+
+function pastFcfGrowth(financials: TickerFinancials): ReverseDcfModel["pastGrowth"] {
+  const annual = annualFreeCashFlows(financials);
   const first = annual[0], last = annual.at(-1);
   if (!first || !last || first === last || !(first.freeCashFlow! > 0) || !(last.freeCashFlow! > 0)) return null;
   const years = Math.round((Date.parse(last.date) - Date.parse(first.date)) / (365.25 * 86_400_000));
-  return years > 0 ? { rate: (last.freeCashFlow! / first.freeCashFlow!) ** (1 / years) - 1, years } : null;
+  return years > 0
+    ? { rate: (last.freeCashFlow! / first.freeCashFlow!) ** (1 / years) - 1, years, period: fiscalSpan(financials, first.date, last.date) }
+    : null;
+}
+
+function latestFiscalYearFcf(financials: TickerFinancials): ReverseDcfModel["fiscalYearFcf"] {
+  const last = annualFreeCashFlows(financials).at(-1);
+  return last ? { value: last.freeCashFlow!, label: fiscalPeriodLabel(last.date, "annual", fiscalYearEndMonth(financials.annualStatements)) } : null;
+}
+
+/** How far above the latest fiscal year's free cash flow the trailing twelve months' must be to say the two bases differ. */
+const TTM_BASE_RATIO = 1.5;
+
+/**
+ * How a trailing free cash flow more than 1.5 times the latest fiscal year's
+ * differs from it (`2.7x` FY2025's `5.3B USD`): the growth priced in starts
+ * from the trailing figure, the past growth ends at the year's. Null when they
+ * are near each other, the year's is not positive, or the model has no growth
+ * to say.
+ */
+export function ttmBaseGap(model: Pick<ReverseDcfModel, "freeCashFlow" | "fiscalYearFcf" | "currency" | "error">): { multiple: string; year: string; fcf: string } | null {
+  const { freeCashFlow, fiscalYearFcf } = model;
+  if (model.error || freeCashFlow == null || !fiscalYearFcf || !(fiscalYearFcf.value > 0) || !(freeCashFlow > fiscalYearFcf.value * TTM_BASE_RATIO)) return null;
+  return {
+    multiple: `${(freeCashFlow / fiscalYearFcf.value).toFixed(1)}x`,
+    year: fiscalYearFcf.label,
+    fcf: formatCompactCurrency(fiscalYearFcf.value, model.currency ?? undefined),
+  };
+}
+
+/** "The TTM base differs from FY2025: TTM FCF is 2.7x that year's 5.3B USD.", the one line a report adds when `ttmBaseGap` finds a gap. */
+export function ttmBaseNote(model: Parameters<typeof ttmBaseGap>[0]): string | null {
+  const gap = ttmBaseGap(model);
+  return gap ? `The TTM base differs from ${gap.year}: TTM FCF is ${gap.multiple} that year's ${gap.fcf}.` : null;
+}
+
+/** What the past growth rate is over, after the rate: `a year, FY2021–FY2025`. */
+export function pastGrowthBasis(growth: NonNullable<ReverseDcfModel["pastGrowth"]>): string {
+  return `a year, ${growth.period}`;
 }
 
 /**
@@ -145,7 +199,8 @@ export function projectReverseDcf(
   const empty: ReverseDcfModel = { symbol: options.symbol, currency, discountRate: options.discountRate, terminalGrowth: TERMINAL_GROWTH,
     enterpriseValue, computedEnterpriseValue: check?.computed ?? null, enterpriseValueNote: check ? enterpriseValueReconciliationNote(fundamentals) ?? null : null,
     freeCashFlow, fcfYield: null, implied: null, fcfMargin, fcfMarginBasis, impliedRevenue: null,
-    pastGrowth: financials ? pastFcfGrowth(financials) : null, sensitivity: [], error: null };
+    pastGrowth: financials ? pastFcfGrowth(financials) : null, fiscalYearFcf: financials ? latestFiscalYearFcf(financials) : null,
+    sensitivity: [], error: null };
   const valueCurrency = fundamentals?.marketCapCurrency;
   // ADRs and cross-listings can report cash flows in one currency and trade in another.
   if (currency && valueCurrency && currency !== valueCurrency) {

package/src/plugins/builtin/reverse-dcf/pane.tsx

@@ -10,8 +10,8 @@ import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
 import { formatCompact, formatCompactCurrency } from "../../../utils/format";
 import { loadReverseDcfInputs } from "./client";
-import { describeFcfMargin, DISCOUNT_RATES, FORECAST_YEARS, formatFcfMargin, projectReverseDcf, TERMINAL_GROWTH, TERMINAL_GROWTHS,
-  type ImpliedGrowth, type ReverseDcfModel } from "./model";
+import { describeFcfMargin, DISCOUNT_RATES, FORECAST_YEARS, formatFcfMargin, pastGrowthBasis, projectReverseDcf, TERMINAL_GROWTH, TERMINAL_GROWTHS,
+  ttmBaseGap, type ImpliedGrowth, type ReverseDcfModel } from "./model";
 
 export const DISCOUNT_OPTIONS = DISCOUNT_RATES.map((rate) => ({ value: String(Math.round(rate * 100)), label: `${Math.round(rate * 100)}%` }));
 /** The margin setting that follows the company's own trailing margin, the pane's default. */
@@ -91,15 +91,18 @@ export function ReverseDcfPane({ width, height, focused }: PaneProps) {
     const currency = model.currency ?? undefined;
     const implied = model.implied?.kind === "rate" ? model.implied.value : null;
     const past = model.pastGrowth;
+    const gap = ttmBaseGap(model);
     return [
       { id: "implied", label: "Priced-in growth", value: impliedText(model.implied),
         tone: implied == null || !past ? undefined : implied > past.rate ? "negative" : "positive",
         detail: `a year for ${FORECAST_YEARS}y, then ${pct(TERMINAL_GROWTH, false)}` },
       { id: "revenue", label: `Revenue, yr ${FORECAST_YEARS}`, value: formatCompactCurrency(model.impliedRevenue ?? undefined, currency),
         detail: `at ${describeFcfMargin(model.fcfMargin, model.fcfMarginBasis)}` },
-      { id: "past", label: "Past FCF growth", value: past ? pct(past.rate) : "--", detail: past ? `per year over ${past.years}y` : undefined },
+      { id: "past", label: "Past FCF growth", value: past ? pct(past.rate) : "--", detail: past ? pastGrowthBasis(past) : undefined },
       { id: "yield", label: "FCF yield", value: pct(model.fcfYield, false) },
-      { id: "fcf", label: "FCF", value: formatCompactCurrency(model.freeCashFlow ?? undefined, currency) },
+      // A trailing figure far above the fiscal year the past growth ends at says so beside itself.
+      { id: "fcf", label: "FCF", value: formatCompactCurrency(model.freeCashFlow ?? undefined, currency),
+        detail: gap ? `TTM base, ${gap.multiple} ${gap.year}'s ${gap.fcf}` : undefined },
       { id: "ev", label: "EV", value: formatCompactCurrency(model.enterpriseValue ?? undefined, currency),
         // More than 5% from market cap + debt - cash: the provider's, with the computed figure where it fits.
         detail: model.computedEnterpriseValue != null ? `provider vs ${formatCompact(model.computedEnterpriseValue)}` : undefined },

package/src/plugins/builtin/scanner/feed.ts

@@ -14,7 +14,7 @@ import { useAppVisible } from "../../../state/app/activity";
 import { ScannerClientContext } from "../shared/scanner-capture";
 import { delayedFooterSegment } from "../../../components/layout/pane/footer/model";
 
-export interface ScannerFeedState<T extends ScannerPayload> {
+export interface ScannerFeedState<T extends Pick<ScannerPayload, "status" | "access" | "delayMinutes">> {
   payload: T | null;
   /** True once the server refused the subscription (not signed in, or not Pro). */
   denied: boolean;
@@ -63,7 +63,7 @@ export function useFlowFeed(): ScannerFeedState<ScannerFlowPayload> {
  */
 export function useScannerStatusFooter(
   registrationId: string,
-  state: ScannerFeedState<ScannerPayload>,
+  state: ScannerFeedState<Pick<ScannerPayload, "status" | "access" | "delayMinutes">>,
   focused: boolean,
   extra: PaneFooterSegment | null = null,
 ): void {

package/src/plugins/builtin/scanner/flow-model.ts

@@ -81,6 +81,22 @@ function printRoot(underlying: string): string {
   return underlying.toUpperCase().replace(/\d+$/, "");
 }
 
+/**
+ * Whose prints the pane shows: one name (`FLOW NVDA`), which takes the place
+ * of the universe filter, or the market, narrowed to the user's own tickers
+ * when the universe filter says so.
+ */
+export interface FlowScope {
+  symbol?: string | null;
+  watchlist: ReadonlySet<string>;
+}
+
+/** The listed symbol a `FLOW <ticker>` pane is about, as the pane setting or report argument names it. */
+export function flowScopeSymbol(value: unknown): string | null {
+  const symbol = typeof value === "string" ? value.trim().toUpperCase() : "";
+  return symbol || null;
+}
+
 /**
  * The shared feed is published once for everyone, so every user preference is a
  * local predicate over the same events. Never push these upstream.
@@ -88,13 +104,14 @@ function printRoot(underlying: string): string {
 export function filterFlowEvents(
   events: readonly ScannerFlowEvent[] | undefined,
   filters: FlowFilters,
-  watchlist: ReadonlySet<string>,
+  scope: FlowScope,
   now = Date.now(),
 ): ScannerFlowEvent[] {
   const minPremium = Number(filters.minPremium);
   const minVolOi = filters.volOi === "off" ? null : Number(filters.volOi);
   const maxExpiryDays = filters.expiry === "all" ? null : Number(filters.expiry);
-  const roots = filters.universe === "watchlist" ? new Set([...watchlist].map(flowOptionRoot)) : null;
+  const roots = scope.symbol ? new Set([flowOptionRoot(scope.symbol)])
+    : filters.universe === "watchlist" ? new Set([...scope.watchlist].map(flowOptionRoot)) : null;
 
   return (events ?? []).filter((event) => {
     if (!(event.premium >= minPremium)) return false;
@@ -121,7 +138,15 @@ export function flowEmptyState(
   received: number,
   visible: number,
   status: ScannerStatus | undefined,
+  symbol: string | null = null,
 ): { title: string; hint: string } {
+  // One name's prints are mostly recorded ones, and a quiet name has none at all.
+  if (symbol) {
+    return {
+      title: `No ${symbol} prints under these filters.`,
+      hint: "Flow is recorded for the most active names, the day's movers and names with a flow alert.",
+    };
+  }
   if (received > visible) {
     return {
       title: `${received - visible} ${received - visible === 1 ? "print" : "prints"} hidden by filters.`,
@@ -219,22 +244,43 @@ export function mergeFlowRows(
 /** The pane's filters as a query for recorded prints, so each page is rows it will show. */
 export function flowHistoryQuery(
   filters: FlowFilters,
-  watchlist: ReadonlySet<string>,
+  scope: FlowScope,
   before?: { at: number; id: string },
   limit = FLOW_HISTORY_PAGE,
 ): ScannerFlowHistoryQuery {
   return {
     ...(before ? { before } : {}),
     limit,
+    ...flowFilterQuery(filters),
+    ...(scope.symbol ? { symbols: [scope.symbol.toUpperCase()] }
+      : filters.universe === "watchlist" ? { symbols: [...scope.watchlist].map((symbol) => symbol.toUpperCase()).sort() } : {}),
+  };
+}
+
+function flowFilterQuery(filters: FlowFilters): Omit<ScannerFlowHistoryQuery, "before" | "limit" | "symbols"> {
+  return {
     minPremium: Number(filters.minPremium),
     ...(filters.side === "calls" ? { right: "C" as const } : filters.side === "puts" ? { right: "P" as const } : {}),
     ...(filters.kind === "sweeps" ? { kind: "sweep" as const } : filters.kind === "blocks" ? { kind: "block" as const } : {}),
     ...(filters.volOi === "off" ? {} : { minVolOi: Number(filters.volOi) }),
     ...(filters.expiry === "all" ? {} : { maxExpiryDays: Number(filters.expiry) }),
-    ...(filters.universe === "watchlist" ? { symbols: [...watchlist].map((symbol) => symbol.toUpperCase()).sort() } : {}),
   };
 }
 
+/**
+ * The session summary's query as the Cloud route reads it: the same filters as
+ * the recorded prints, with one name as `symbol`, which also asks for its strikes.
+ */
+export function flowSessionSearch(filters: FlowFilters, scope: FlowScope): string {
+  const params = new URLSearchParams(flowHistorySearch({
+    ...flowFilterQuery(filters),
+    ...(!scope.symbol && filters.universe === "watchlist"
+      ? { symbols: [...scope.watchlist].map((symbol) => symbol.toUpperCase()).sort() } : {}),
+  }));
+  if (scope.symbol) params.set("symbol", scope.symbol.toUpperCase());
+  return params.toString();
+}
+
 function localDay(at: number): string {
   const date = new Date(at);
   return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;