gloomberb 0.19.1 → 0.19.3

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

@@ -15,6 +15,10 @@ import type { DataProvider } from "../../../../types/data-provider";
 import type { PricePoint } from "../../../../types/financials";
 import { isRoundTheClockCoin } from "../../../../utils/crypto-pair";
 import { isCurrencyPairListing } from "../../../../utils/fx-market-hours";
+import { latestRegularSessionClose } from "../../../../market-data/market/freshness";
+import { futuresSessionOpenMinute } from "../../../../market-data/market/trading-sessions";
+import { calendarBarStart } from "../../../../time-series/chart-data";
+import { newestClosedSession, newestSessionClose, withOfficialCloses } from "../../../../time-series/official-close";
 import {
   effectiveReturnResolution,
   endsAtLatestBar,
@@ -39,6 +43,8 @@ export interface ReturnSeries {
   lastSession?: string;
   /** The venue whose sessions the window follows; empty when none is known. */
   venue: string;
+  /** The local date of the newest session, closed but without its official close yet: its last bar ends on the last trade. */
+  closingPrintPending?: string;
 }
 
 export interface ReturnSeriesRequest {
@@ -66,20 +72,76 @@ function historyErrorMessage(error: unknown, resolution: ManualChartResolution):
 /**
  * The venue whose sessions set where the window ends: the one the ticker
  * names, else the listing its quote names, so a bare VTI ends at the NYSE
- * Arca close on a weekend. Coins and currency pairs need none.
+ * Arca close on a weekend, with the listing's currency when that was read.
+ * Coins and currency pairs need none.
  */
-async function sessionVenue(provider: DataProvider, symbol: string, exchange: string): Promise<string> {
-  if (exchange || isRoundTheClockCoin(symbol) || isCurrencyPairListing(symbol, exchange)) return exchange;
+async function sessionVenue(provider: DataProvider, symbol: string, exchange: string): Promise<{ venue: string; currency?: string }> {
+  if (exchange || isRoundTheClockCoin(symbol) || isCurrencyPairListing(symbol, exchange)) return { venue: exchange };
   try {
     const metadata = provider.getQuoteMetadata
       ? await provider.getQuoteMetadata(symbol, exchange)
       : await provider.getQuote(symbol, exchange);
-    return metadata?.listingExchangeName ?? "";
+    return { venue: metadata?.listingExchangeName ?? "", ...(metadata?.currency ? { currency: metadata.currency } : {}) };
   } catch (error) {
-    return logFailure("ticker-detail.data-panes.returns-history", "Read return session venue failed", "")(error);
+    return { venue: logFailure("ticker-detail.data-panes.returns-history", "Read return session venue failed", "")(error) };
   }
 }
 
+const DAY_MS = 86_400_000;
+
+/**
+ * Intraday bars with each closed session's last bar on its official close
+ * (withOfficialCloses), so every total and the base they are measured from
+ * are the closes `history` and CMP give, not the last trade before the
+ * closing auction. Earlier sessions take their daily bar's close, dated by
+ * the venue's local date; the newest closed session the close
+ * newestSessionClose picks from the quote and its daily bar, or the note
+ * that its print is to come. Daily and longer bars, futures (which settle
+ * rather than close on a print) and listings without sessions are returned
+ * as loaded.
+ */
+async function withSessionCloses(
+  provider: DataProvider,
+  target: { symbol: string; exchange: string; venue: string; currency?: string },
+  interval: ManualChartResolution,
+  points: PricePoint[],
+  now: number,
+  context: { cacheMode: "refresh" } | undefined,
+): Promise<{ points: PricePoint[]; closingPrintPending?: string }> {
+  const venue = target.venue || undefined;
+  if (!isIntradayResolution(interval) || !points.length || futuresSessionOpenMinute(target.symbol, target.venue || target.exchange) != null
+    || !latestRegularSessionClose(venue, now)) return { points };
+  const newest = newestClosedSession(points, { venue, now });
+  // Whole UTC days, so the same window asks the same read (and its cached copy) all day.
+  const first = Math.floor(new Date(points[0]!.date).getTime() / DAY_MS) * DAY_MS - 2 * DAY_MS;
+  const end = Math.floor(Math.min(now, new Date(points.at(-1)!.date).getTime() + DAY_MS) / DAY_MS) * DAY_MS + DAY_MS - 1;
+  const [daily, quote] = await Promise.all([
+    fetchHistoryResult(provider, target.symbol, target.exchange, { kind: "detail", start: new Date(first), end: new Date(end), interval: "1d" }, context)
+      .catch(logFailure("ticker-detail.data-panes.returns-history", "Read the daily closes of a return window failed", null)),
+    // Only the newest closed session needs the quote's word on its close.
+    newest
+      ? Promise.resolve(provider.getQuote(target.symbol, target.exchange, context))
+        .catch(logFailure("ticker-detail.data-panes.returns-history", "Read the official close of a return window failed", null))
+      : null,
+  ]);
+  const dailyCloses = new Map<string, number>();
+  for (const bar of daily?.points ?? []) {
+    const time = new Date(bar.date).getTime();
+    if (!bar.partial && Number.isFinite(time) && Number.isFinite(bar.close) && bar.close > 0) {
+      dailyCloses.set(calendarBarStart(time, "1d", venue), bar.close);
+    }
+  }
+  const closes = new Map([...dailyCloses].filter(([date]) => date !== newest?.date));
+  const decided = newest
+    ? newestSessionClose(quote, { ...newest, venue, currency: target.currency ?? null, dailyClose: dailyCloses.get(newest.date) ?? null })
+    : null;
+  if (newest && decided && "close" in decided) closes.set(newest.date, decided.close);
+  return {
+    points: withOfficialCloses(points, closes, { venue, now }),
+    ...(newest && decided && "pending" in decided ? { closingPrintPending: newest.date } : {}),
+  };
+}
+
 /**
  * The bars of a return window and where it starts and ends, as RETURN, its
  * report and its capture all load them: the window ends now while the
@@ -91,7 +153,7 @@ export async function loadReturnSeries(provider: DataProvider, request: ReturnSe
   if (request.window) return loadReturnWindow(provider, request, request.window);
   const { symbol, exchange, range, support, now } = request;
   const interval = effectiveReturnResolution(range, request.resolution, support);
-  const venue = await sessionVenue(provider, symbol, exchange);
+  const { venue, currency } = await sessionVenue(provider, symbol, exchange);
   const windowEnd = returnWindowEnd({ symbol, exchange: venue }, now);
   const visibleFrom = returnVisibleFrom(range, interval, windowEnd.end, venue || undefined);
   const start = new Date(visibleFrom - returnLookbackMs(range, interval, support));
@@ -100,18 +162,24 @@ export async function loadReturnSeries(provider: DataProvider, request: ReturnSe
   let result;
   try {
     // Exact bounds first, then the interval's range history, as charts do
-    // when a source keeps no bars for the exact window.
-    result = await fetchHistoryResult(provider, symbol, exchange, { kind: "detail", start, end, interval }, context);
+    // when a source keeps no bars for the exact window or failed to load it
+    // (the range history may answer from a saved copy); the failure stands when that has none either.
+    let detailFailure: unknown = null;
+    result = await fetchHistoryResult(provider, symbol, exchange, { kind: "detail", start, end, interval }, context)
+      .catch((error: unknown) => { detailFailure = error; return null; });
     if (!result?.points.length) {
       result = await fetchHistoryResult(provider, symbol, exchange, { kind: "resolution", range: returnSupportRange(range), resolution: interval }, context) ?? result;
     }
+    if (!result?.points.length && detailFailure) throw detailFailure;
   } catch (error) {
     throw historyErrorMessage(error, interval);
   }
   if (!result) throw new Error("Price history unavailable");
   const latest = latestBarTime(result.points);
+  const closed = await withSessionCloses(provider, { symbol, exchange, venue, currency }, interval, result.points, now, context);
   return {
-    points: result.points,
+    points: closed.points,
+    ...(closed.closingPrintPending ? { closingPrintPending: closed.closingPrintPending } : {}),
     // A 1W to 5Y window's rows start after its base close, found among the bars by their session days.
     visibleFrom: endsAtLatestBar(range) && latest !== null && latest < windowEnd.end
       ? returnVisibleFrom(range, interval, latest, venue || undefined)
@@ -142,7 +210,7 @@ async function loadReturnWindow(provider: DataProvider, request: ReturnSeriesReq
   const step = CHART_RESOLUTION_STEP_MS[request.resolution];
   let interval = available.includes(request.resolution) ? request.resolution
     : available.find((candidate) => CHART_RESOLUTION_STEP_MS[candidate] >= step) ?? available.at(-1) ?? "1d";
-  const venue = await sessionVenue(provider, symbol, exchange);
+  const { venue, currency } = await sessionVenue(provider, symbol, exchange);
   const context = request.forceRefresh ? { cacheMode: "refresh" as const } : undefined;
   const load = async (resolution: ManualChartResolution) => {
     // A daily or longer bar is stamped at midnight UTC, so the window takes every bar from its first date's day, week or month on.
@@ -167,8 +235,10 @@ async function loadReturnWindow(provider: DataProvider, request: ReturnSeriesReq
     }
   }
   if (!loaded?.result) throw new Error("Price history unavailable");
+  const closed = await withSessionCloses(provider, { symbol, exchange, venue, currency }, interval, loaded.result.points, now, context);
   return {
-    points: loaded.result.points,
+    points: closed.points,
+    ...(closed.closingPrintPending ? { closingPrintPending: closed.closingPrintPending } : {}),
     visibleFrom: loaded.visibleFrom,
     visibleTo: Math.min(last, now),
     ...(loaded.result.coverageStart ? { coverageStart: loaded.result.coverageStart } : {}),

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

@@ -505,13 +505,46 @@ function coversLatestYear(ttm: FinancialTableStatement, latestYear: FinancialSta
   return days <= 7;
 }
 
+/** Counts of the shares a company has issued or has outstanding, which are never zero; treasury shares can be. */
+const OUTSTANDING_COUNT_FIELDS = ["basicShares", "dilutedShares", "shareIssued", "ordinarySharesNumber"] as const;
+
+/**
+ * Share counts that cannot be the company's: zero, or under a thousandth of its
+ * typical count (IAG's 4,642 for Q3 2025, millions read as shares, which shows
+ * as 0.00 bn and a fall of 100%). They are missing, not a value to grow from.
+ */
+function withoutImpossibleShareCounts(
+  annualStatements: FinancialStatement[],
+  quarterlyStatements: FinancialStatement[],
+): { annualStatements: FinancialStatement[]; quarterlyStatements: FinancialStatement[] } {
+  const all = [...annualStatements, ...quarterlyStatements];
+  const floors = new Map<string, number>();
+  for (const field of OUTSTANDING_COUNT_FIELDS) {
+    const counts = all.map((row) => row[field]).filter((value): value is number => typeof value === "number" && value > 0).sort((a, b) => a - b);
+    floors.set(field, counts.length ? counts[Math.floor(counts.length / 2)]! / 1000 : 0);
+  }
+  const impossible = (row: FinancialStatement, field: typeof OUTSTANDING_COUNT_FIELDS[number]) => {
+    const value = row[field];
+    return typeof value === "number" && (value <= 0 || value < floors.get(field)!);
+  };
+  const clean = (rows: FinancialStatement[]) => rows.map((row) => {
+    const drop = OUTSTANDING_COUNT_FIELDS.filter((field) => impossible(row, field));
+    if (!drop.length) return row;
+    const next = { ...row };
+    for (const field of drop) delete next[field];
+    return next;
+  });
+  return { annualStatements: clean(annualStatements), quarterlyStatements: clean(quarterlyStatements) };
+}
+
 export function selectFinancialStatements(
   period: FinancialPeriod,
   statement: string,
-  annualStatements: FinancialStatement[],
-  quarterlyStatements: FinancialStatement[],
+  servedAnnual: FinancialStatement[],
+  servedQuarterly: FinancialStatement[],
   limit = period === "annual" ? 5 : 6,
 ) {
+  const { annualStatements, quarterlyStatements } = withoutImpossibleShareCounts(servedAnnual, servedQuarterly);
   // A period with nothing on this statement (a fiscal year-end balance point on
   // the income statement) would render as an all-dash column.
   const tabRows = FINANCIAL_SUB_TABS.find((tab) => tab.key === statement)?.rows;

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

@@ -4,6 +4,7 @@ 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 { debtAndLeases, leaseBasis, type LeaseBasis } from "../../../../utils/lease-liabilities";
 import { cashAndShortTermInvestments, excludesCashRunway, formatRunwayMonths, SHORT_RUNWAY_HISTORY, monthlyOperatingBurn, QUARTER_MONTHS, reportsShortTermTotal, runwayMonths, YEAR_MONTHS } from "../../../../utils/cash-runway";
 import {
   buildPreviousStatementMap,
@@ -58,6 +59,8 @@ export interface RatioPeriod {
   price: RatioAmount;
   /** The filer reports cash and short-term investments as a total in some period on file (utils/cash-runway). */
   shortTermTotalOnFile?: boolean;
+  /** How net debt treats the lease liabilities the listing's balance sheets report; absent when none do. */
+  leaseBasis?: LeaseBasis;
 }
 
 interface RatioInputDef {
@@ -75,6 +78,13 @@ interface RatioInputDef {
   trailing?: boolean;
   /** A shorter name for quarterly columns, so the label, TTM and its unit fit the label column. */
   trailingLabel?: string;
+  /** Debt net of cash: where the listing reports lease liabilities, a row naming them follows it (withLeaseRow). */
+  netDebt?: boolean;
+  /**
+   * Not an operand: a line the input before it includes or leaves out, shown under it. Neither its value nor
+   * its gap enters the ratio.
+   */
+  memo?: boolean;
   value: (period: RatioPeriod) => RatioAmount;
 }
 
@@ -245,12 +255,41 @@ function marketCap(period: RatioPeriod): RatioAmount {
   return period.price * shares;
 }
 
+/**
+ * Total debt less cash and short-term investments, with the balance sheet's lease liabilities where the listing's
+ * are included (utils/lease-liabilities). A balance sheet without its lease line then has no net debt.
+ */
+function netDebt({ statement, leaseBasis: basis }: RatioPeriod): RatioAmount {
+  const cash = cashAndShortTerm(statement);
+  if (basis === "included") {
+    const lines = debtAndLeases(statement);
+    return lines === undefined || cash === undefined ? "not-reported" : lines.totalDebt + lines.leases - cash;
+  }
+  const debt = finite(statement.totalDebt);
+  return debt === undefined || cash === undefined ? "not-reported" : debt - cash;
+}
+
 function enterpriseValue(period: RatioPeriod): RatioAmount {
-  const debt = finite(period.statement.totalDebt);
-  const cash = cashAndShortTerm(period.statement);
-  if (debt === undefined || cash === undefined) return "not-reported";
+  const debt = netDebt(period);
+  if (isGap(debt)) return debt;
   const cap = marketCap(period);
-  return isGap(cap) ? cap : cap + debt - cash;
+  return isGap(cap) ? cap : cap + debt;
+}
+
+/** The lease liabilities net debt includes, or a US GAAP filer's operating leases it leaves out. */
+const LEASE_ROW_LABEL: Record<LeaseBasis, string> = { included: "incl. leases", excluded: "excl. op. leases" };
+
+/** The ratio with a row naming the listing's lease liabilities under its net debt, when it reports any. */
+function withLeaseRow(def: RatioDef, basis: LeaseBasis | undefined): RatioDef {
+  const at = def.inputs.findIndex((input) => input.netDebt);
+  if (!basis || at < 0) return def;
+  const row: RatioInputDef = {
+    label: LEASE_ROW_LABEL[basis],
+    format: "money",
+    memo: true,
+    value: ({ statement }) => reported(finite(statement.capitalLeaseObligations)),
+  };
+  return { ...def, inputs: [...def.inputs.slice(0, at + 1), row, ...def.inputs.slice(at + 1)] };
 }
 
 const DSO: RatioDef = {
@@ -378,15 +417,7 @@ export const RATIO_TABS: RatioTabDef[] = [
         label: "Net Debt / EBITDA",
         format: "multiple",
         inputs: [
-          {
-            label: "Net Debt",
-            format: "money",
-            value: ({ statement }) => {
-              const debt = finite(statement.totalDebt);
-              const cash = cashAndShortTerm(statement);
-              return debt === undefined || cash === undefined ? "not-reported" : debt - cash;
-            },
-          },
+          { label: "Net Debt", format: "money", netDebt: true, value: netDebt },
           trailingFlow("EBITDA", line("ebitda"), "÷"),
         ],
         compute: ([debt, ebitda]) => over(debt!, ebitda!),
@@ -517,7 +548,7 @@ export const RATIO_TABS: RatioTabDef[] = [
         label: "EV / EBITDA",
         format: "multiple",
         inputs: [
-          { label: "Enterprise Value", format: "money", value: enterpriseValue },
+          { label: "Enterprise Value", format: "money", netDebt: true, value: enterpriseValue },
           trailingFlow("EBITDA", line("ebitda"), "÷"),
         ],
         // A negative enterprise value makes the multiple meaningless too.
@@ -568,10 +599,11 @@ function inputAmount(input: RatioInputDef, period: RatioPeriod): RatioAmount {
 
 export function evaluateRatio(def: RatioDef, period: RatioPeriod): RatioCell {
   const inputs = def.inputs.map((input) => inputAmount(input, period));
-  const gap = GAP_ORDER.find((candidate) => inputs.includes(candidate));
+  const operands = inputs.filter((_, index) => !def.inputs[index]!.memo);
+  const gap = GAP_ORDER.find((candidate) => operands.includes(candidate));
   if (gap) return { value: gap, inputs };
-  const values = inputs.map((amount, index) => (
-    def.inputs[index]!.annualized && period.quarterly ? (amount as number) * QUARTERS_PER_YEAR : amount as number
+  const values = def.inputs.flatMap((input, index) => (
+    input.memo ? [] : [input.annualized && period.quarterly ? (inputs[index] as number) * QUARTERS_PER_YEAR : inputs[index] as number]
   ));
   const value = def.compute(values, period);
   return { value: isGap(value) || Number.isFinite(value) ? value : "not-meaningful", inputs };
@@ -702,6 +734,7 @@ export function ratioPeriods(
   onFile: { annual: readonly FinancialStatement[]; quarterly: readonly FinancialStatement[] } = { annual: [], quarterly: [] },
 ): RatioPeriod[] {
   const shortTermTotalOnFile = reportsShortTermTotal([...onFile.annual, ...onFile.quarterly, ...statements]);
+  const leases = leaseBasis([...onFile.annual, ...onFile.quarterly, ...statements]);
   return statements.map((statement) => {
     const quarterly = period === "quarterly" && statement.date !== "TTM";
     return {
@@ -711,6 +744,7 @@ export function ratioPeriods(
       ...(quarterly ? { trailing: trailingYear(statement, onFile.annual, onFile.quarterly) } : {}),
       price: price(statement),
       shortTermTotalOnFile,
+      ...(leases ? { leaseBasis: leases } : {}),
     };
   });
 }
@@ -758,11 +792,12 @@ export function buildRatioTableModel(
 ): RatioTableModel {
   const quarterly = periods.some((period) => period.quarterly);
   const totalOnFile = periods.some((period) => period.shortTermTotalOnFile);
+  const leases = periods.find((period) => period.leaseBasis)?.leaseBasis;
   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);
+      : withLeaseRow(def, leases));
   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");

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

@@ -1,4 +1,7 @@
-import { FINANCIAL_VINTAGE_NOTICE, filledPeriodsNote, stalePeriodNote, statementHistoryNotes } from "../../../utils/financial-statements";
+import {
+  FINANCIAL_VINTAGE_NOTICE, filledPeriodsNote, hasOlderStatements, reportsHalfYearly, stalePeriodNote, statementHistoryNotes,
+} from "../../../utils/financial-statements";
+import { canonicalExchange } from "../../../utils/exchanges";
 import { hasValidQuoteObservationTime } from "../../../market-data/quotes/freshness";
 import { EXTENDED_SESSION_LABELS, getQuoteSessionFields, quoteHeadlineTime, type ExtendedSession } from "../../../market-data/market/status";
 import type { HeadlessPaneColumn, HeadlessPaneDefinition, HeadlessPaneFreshness, HeadlessPaneOptionValues } from "../../../types/headless";
@@ -6,7 +9,8 @@ import type { TimeRange } from "../../../time-series/range";
 import { formatNumber, formatPercentRaw } from "../../../utils/format";
 import { formatMarketPrice, formatMarketPriceWithCurrency, formatPriceObservation, penceFigure, quoteFormatOptions, withCurrencyMinorDigits, type MarketFormatOptions } from "../../../market-data/market/format";
 import {
-  MISSING_VOLUME_TEXT, missingVolumeCount, missingVolumeNotice, pricePointValues, priceHistoryIntegrityNotice,
+  MISSING_VOLUME_TEXT, missingVolumeCount, missingVolumeNotice, pricePointValues, pricePointWickFlags, priceHistoryIntegrityNotice,
+  priceHistoryWickNotice,
 } from "../../../utils/price-history-integrity";
 import {
   buildFinancialTableModel, financialStatementCurrency, financialStatementDateNotice, financialStatementLimitations,
@@ -48,6 +52,7 @@ import { DAY_SO_FAR_TEXT, withSessionBar } from "../../../time-series/session-ba
 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 { CLOSING_PRINT_PENDING_TEXT } from "../../../time-series/official-close";
 import {
   closedHistoryBarDay, formingHistoryBar, HISTORY_DEFAULT_RANGE, historyBarDate, historyBarSize, historyBarSizeWord, historyDateHeader, isDailyOrLongerBar,
   type HistoryBarSize,
@@ -151,18 +156,23 @@ export const financialStatementsHeadless: HeadlessPaneDefinition<"rows"> = {
     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;
+    const periodDates = dates.map(({ date }) => date);
+    const missing = rows.length ? null : await missingPeriodsError(ctx, symbol, financials, requestedPeriod, hasRequestedStatements, options.statement);
     return {
       rows, columns, unavailableSymbols: rows.length ? [] : [symbol],
-      ...(!hasRequestedStatements ? { errors: [`${symbol}: No ${requestedPeriod} financial statement coverage.`] } : {}),
+      ...(missing ? { errors: [missing] } : {}),
       // 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)],
+      notes: [...stale ? [stale] : [], ...filled ? [filled] : [], ...offering ? [offering] : [],
+        ...statementHistoryNotes(requestedPeriod, periodDates, symbol, await reportOlderStatements(ctx, symbol, requestedPeriod, periodDates))],
       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,
         period: requestedPeriod, growthBasis: requestedPeriod === "quarterly" ? "QoQ" : "YoY", columns: dates,
         shareBasis: shareBases.size === 1 ? [...shareBases][0] ?? null : null,
         ...(receiptPeriods.length > 0 ? { adrRatio: financials.fundamentals?.adrRatio ?? financials.quote?.adrRatio ?? null } : {}),
-        notices: rows.length ? [FINANCIAL_VINTAGE_NOTICE, ...(shareBasisNotice ? [shareBasisNotice] : [])] : [],
+        // A quarter's change is against the quarter before it, which a reader of a table of quarters must be told.
+        notices: rows.length ? [FINANCIAL_VINTAGE_NOTICE, ...requestedPeriod === "quarterly" ? [QUARTERLY_GROWTH_NOTICE] : [],
+          ...(shareBasisNotice ? [shareBasisNotice] : [])] : [],
         limitations: financialStatementLimitations(financials),
         dateProvenance: financialStatementDateNotice(table?.statements ?? []),
       },
@@ -172,6 +182,44 @@ export const financialStatementsHeadless: HeadlessPaneDefinition<"rows"> = {
 
 const reportAmount = (amount: RatioAmount) => (typeof amount === "number" ? amount : null);
 
+/** What a table of quarters says its growth is measured against. */
+const QUARTERLY_GROWTH_NOTICE = "Growth is vs prior quarter.";
+
+type HeadlessContext = Parameters<typeof financialStatementsHeadless.load>[1];
+
+/** Whether GF, reading the listing's extended statement history, goes back further than the report (statementHistoryNotes). */
+function reportOlderStatements(ctx: HeadlessContext, symbol: string, period: "annual" | "quarterly", dates: readonly string[]) {
+  return hasOlderStatements(async () => {
+    const { symbol: bare, exchange } = await resolveHeadlessInstrument(ctx, symbol);
+    return ctx.marketData.getTickerFinancials(bare, exchange ?? "", { statementHistory: "extended" });
+  }, period, dates);
+}
+
+/**
+ * Why a statements report has no rows, and what to read instead: a listing
+ * with years but no quarters names its years, and says so of a company that
+ * reports half-yearly (Qantas on ASX). Null when it has years and quarters,
+ * whatever this table lacks.
+ */
+async function missingPeriodsError(
+  ctx: HeadlessContext,
+  symbol: string,
+  financials: Awaited<ReturnType<typeof loadHeadlessFinancials>>,
+  period: "annual" | "quarterly",
+  hasRequestedStatements: boolean,
+  statement: unknown,
+): Promise<string | null> {
+  const hasYears = financials.annualStatements.length > 0;
+  if (period === "annual" || !hasYears) return hasRequestedStatements ? null : `${symbol}: No ${period} financial statement coverage.`;
+  const exchange = await resolveHeadlessInstrument(ctx, symbol).then(({ exchange }) => canonicalExchange(exchange ?? ""))
+    .catch(logFailure("ticker-detail.headless", "Resolving the listing of a statements report failed", ""));
+  const halfYearly = reportsHalfYearly(exchange, financials.quarterlyStatements);
+  if (hasRequestedStatements && !halfYearly) return null;
+  const tab = typeof statement === "string" && statement && statement !== "income" ? ` --statement ${statement}` : "";
+  const years = `For its years: gloom fn FA ${symbol} --period annual${tab}`;
+  return halfYearly ? `${symbol} reports half-yearly, not quarterly. ${years}` : `${symbol}: No quarterly financial statement coverage. ${years}`;
+}
+
 /** 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],
@@ -240,16 +288,18 @@ async function loadRatioReport(
   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;
+  const periodDates = dates.map(({ date }) => date);
+  const missing = rows.length ? null : await missingPeriodsError(ctx, symbol, financials, period, hasRequestedStatements, tab.key);
   return {
     rows, columns, unavailableSymbols: rows.length ? [] : [symbol],
-    ...(!hasRequestedStatements ? { errors: [`${symbol}: No ${period} financial statement coverage.`] } : {}),
+    ...(missing ? { errors: [missing] } : {}),
     ...(tab.key === "valuation" && hasRequestedStatements && !history?.length ? { complete: false } : {}),
     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),
+      ...statementHistoryNotes(period, periodDates, symbol, await reportOlderStatements(ctx, symbol, period, periodDates)),
     ],
     metadata: {
       symbol, name: financials.quote?.name ?? symbol, currency: statementCurrency ?? null,
@@ -453,7 +503,9 @@ export const historicalPricesHeadless: HeadlessPaneDefinition<"rows"> = {
     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);
+    // A wick left out of the range is said, though the bar's close still counts.
+    const wickNotice = priceHistoryWickNotice(points.filter((point) => pricePointWickFlags(point).length > 0).length);
+    const reportNotices = [drawdownLine, notice, wickNotice].filter((line): line is string => line != null);
     return {
       rows: shown,
       columns: historyColumns(size, marked, false, false, decimals),
@@ -545,7 +597,10 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
       ...figures,
       ...forming || dayToDate ? [{ key: "partial", header: "Partial", format: (value: unknown) => value === true ? "true" : "" }] : [],
     ];
-    const textColumns: HeadlessPaneColumn[] = [timeColumn(true), ...figures];
+    // A narrow table drops the dollar moves, the interval's first, rather than putting Total % on a line under every row.
+    const textFigures = figures.map((column) => column.key === "intervalChange" ? { ...column, optional: true, dropPriority: 2 }
+      : column.key === "totalChange" ? { ...column, optional: true, dropPriority: 1 } : column);
+    const textColumns: HeadlessPaneColumn[] = [timeColumn(true), ...textFigures];
     // An interval the range is too long for is served in the nearest longer bar; say so rather than switch silently.
     const notices = [
       maxDrawdownLine,
@@ -568,8 +623,12 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
         oldest: null,
         ...(forming ? { periodToDate: forming } : closedDay ? { asOf: closedDay } : {}),
         ...(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) } : {}),
+        // The window ends at the last session while the market is shut, which the status line says, and whether its
+        // last bar ends on the official close yet.
+        ...(series.lastSession || series.closingPrintPending ? { note: [
+          series.lastSession ? closedMarketNote(series.lastSession, series.visibleTo) : null,
+          series.closingPrintPending ? CLOSING_PRINT_PENDING_TEXT : null,
+        ].filter(Boolean).join(", ") } : {}),
         ...(dayToDate ? { basis: "daily bars", note: `the newest bar is ${DAY_SO_FAR_TEXT}` } : {}),
       },
       metadata: {

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

@@ -4,14 +4,9 @@ import { holdsActiveTicker } from "../../../shares/pane-image";
 import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
 import { normalizeTickerInput } from "../../../tickers/search";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
-import { FinancialAnalysisPane } from "./financials/pane";
-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";
 import {
   buildQuoteMonitorSettingsDef,
@@ -47,7 +42,7 @@ export const tickerDetailModule: PluginModule = {
       id: TICKER_RESEARCH_PANE_ID,
       name: "Research",
       icon: "D",
-      component: TickerResearchPane,
+      get component(): typeof import("./pane").TickerResearchPane { const { TickerResearchPane } = require("./pane"); return 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.
@@ -70,7 +65,7 @@ export const tickerDetailModule: PluginModule = {
       id: "financial-analysis",
       name: "Financials",
       icon: "F",
-      component: FinancialAnalysisPane,
+      get component(): typeof import("./financials/pane").FinancialAnalysisPane { const { FinancialAnalysisPane } = require("./financials/pane"); return FinancialAnalysisPane; },
       headless: financialStatementsHeadless,
       defaultPosition: "right",
       tickerFollower: true,
@@ -82,7 +77,7 @@ export const tickerDetailModule: PluginModule = {
       id: "quote-monitor",
       name: "Quote Monitor",
       icon: "Q",
-      component: QuoteMonitorPane,
+      get component(): typeof import("./quote-monitor").QuoteMonitorPane { const { QuoteMonitorPane } = require("./quote-monitor"); return QuoteMonitorPane; },
       headless: quoteComparisonHeadless,
       defaultPosition: "right",
       defaultMode: "floating",
@@ -97,7 +92,7 @@ export const tickerDetailModule: PluginModule = {
       id: "historical-prices",
       name: "Historical Prices",
       icon: "H",
-      component: HistoricalPricesPane,
+      get component(): typeof import("./data-panes/historical-prices").HistoricalPricesPane { const { HistoricalPricesPane } = require("./data-panes/historical-prices"); return HistoricalPricesPane; },
       headless: historicalPricesHeadless,
       defaultPosition: "right",
       tickerFollower: true,
@@ -110,7 +105,7 @@ export const tickerDetailModule: PluginModule = {
       reportFreshness: { status: "not-a-feed", basis: "price history" },
       name: "Returns",
       icon: "R",
-      component: ReturnsPane,
+      get component(): typeof import("./data-panes/returns-pane").ReturnsPane { const { ReturnsPane } = require("./data-panes/returns-pane"); return ReturnsPane; },
       headless: returnsHeadless,
       defaultPosition: "right",
       tickerFollower: true,