gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/ticker-detail/data-panes/historical-prices.tsx

@@ -2,6 +2,7 @@ import { useCallback, useMemo } from "react";
 import { TextAttributes } from "../../../../ui";
 import {
   DataTableView,
+  usePaneNoticeFooter,
   loadingText,
   unavailableText,
   usePaneFooter,
@@ -13,7 +14,10 @@ import { TIME_RANGES, type TimeRange } from "../../../../time-series/range";
 import type { PaneProps } from "../../../../types/plugin";
 import type { PricePoint } from "../../../../types/financials";
 import { colors, priceColor } from "../../../../theme/colors";
-import { formatCompact, formatNumber, formatPercent } from "../../../../utils/format";
+import { formatCompact, formatPercent } from "../../../../utils/format";
+import { publicTickerKey } from "../../../../utils/exchanges";
+import { formatPriceObservation } from "../../../../market-data/market/format";
+import { pricePointValues, priceHistoryIntegrityNotice } from "../../../../utils/price-history-integrity";
 import {
   useAssetData,
   useDebouncedPluginPaneState,
@@ -27,7 +31,7 @@ type HistoryColumn = DataTableColumn & { id: HistoryColumnId };
 
 export type HistoricalPriceRow = {
   key: string;
-  point: PricePoint;
+  point: ReturnType<typeof pricePointValues>;
   date: string;
   change: number | null;
   changePercent: number | null;
@@ -39,15 +43,16 @@ function pricePointDate(point: PricePoint): Date | null {
   return Number.isFinite(date.getTime()) ? date : null;
 }
 
-function formatMaybePrice(value: number | undefined): string {
-  return value == null ? "-" : formatNumber(value, 2);
+function formatMaybePrice(value: number | null | undefined, width: number): string {
+  return value == null || !Number.isFinite(value) ? "-"
+    : formatPriceObservation(value, { minimumFractionDigits: 2, maxWidth: width });
 }
 
 function formatMaybePercent(value: number | null): string {
   return value == null ? "-" : formatPercent(value);
 }
 
-function formatMaybeCompact(value: number | undefined): string {
+function formatMaybeCompact(value: number | null | undefined): string {
   return value == null ? "-" : formatCompact(value);
 }
 
@@ -55,19 +60,19 @@ export function buildHistoricalPriceRows(points: PricePoint[]): HistoricalPriceR
   const sorted = points
     .flatMap((point, sourceIndex) => {
       const date = pricePointDate(point);
-      return date ? [{ point, date, sourceIndex }] : [];
+      return date ? [{ point: pricePointValues(point), date, sourceIndex }] : [];
     })
     .sort((left, right) => left.date.getTime() - right.date.getTime());
   return sorted.map((entry, index) => {
     const previous = sorted[index - 1]?.point;
     const { point, date, sourceIndex } = entry;
-    const change = previous ? point.close - previous.close : null;
+    const change = previous?.close != null && point.close != null ? point.close - previous.close : null;
     return {
       key: `${date.toISOString()}:${sourceIndex}`,
       point,
       date: formatDateTime(date),
       change,
-      changePercent: previous?.close ? change! / previous.close : null,
+      changePercent: previous?.close && change !== null ? change / previous.close : null,
     };
   }).reverse();
 }
@@ -111,6 +116,7 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
   }, [dataProvider, range]);
   const { data, loading, error, reload } = useTickerRequest<PricePoint[]>(loader, symbol, exchange);
   const rows = useMemo(() => buildHistoricalPriceRows(data ?? []), [data]);
+  const integrityNotice = priceHistoryIntegrityNotice(rows.filter((row) => row.point.integrity).length);
   const columns = useMemo(() => buildHistoryColumns(width), [width]);
   const boundedSelectedIdx = rows.length > 0 ? Math.min(selectedIdx, rows.length - 1) : -1;
   const cycleRange = useCallback(() => setRange((current) => nextHistoryRange(current)), [setRange]);
@@ -142,15 +148,15 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
       case "date":
         return { text: row.date, color: selectedColor ?? colors.textDim };
       case "open":
-        return { text: formatMaybePrice(row.point.open), color: selectedColor ?? colors.text };
+        return { text: formatMaybePrice(row.point.open, column.width), color: selectedColor ?? colors.text };
       case "high":
-        return { text: formatMaybePrice(row.point.high), color: selectedColor ?? colors.text };
+        return { text: formatMaybePrice(row.point.high, column.width), color: selectedColor ?? colors.text };
       case "low":
-        return { text: formatMaybePrice(row.point.low), color: selectedColor ?? colors.text };
+        return { text: formatMaybePrice(row.point.low, column.width), color: selectedColor ?? colors.text };
       case "close":
-        return { text: formatNumber(row.point.close, 2), color: selectedColor ?? colors.textBright, attributes: TextAttributes.BOLD };
+        return { text: formatMaybePrice(row.point.close, column.width), color: selectedColor ?? colors.textBright, attributes: TextAttributes.BOLD };
       case "change":
-        return { text: row.change == null ? "-" : formatNumber(row.change, 2), color: selectedColor ?? priceColor(row.change ?? 0) };
+        return { text: formatMaybePrice(row.change, column.width), color: selectedColor ?? priceColor(row.change ?? 0) };
       case "changePercent":
         return { text: formatMaybePercent(row.changePercent), color: selectedColor ?? priceColor(row.changePercent ?? 0) };
       case "volume":
@@ -168,6 +174,13 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
     ],
   }), [cycleRange, error, loading, range]);
 
+  usePaneNoticeFooter({
+    registrationId: "historical-prices:integrity",
+    notices: integrityNotice ? [integrityNotice] : [],
+    focused,
+    title: "Price history data",
+  });
+
   return (
     <DataTableView<HistoricalPriceRow, HistoryColumn>
       focused={focused}
@@ -186,6 +199,16 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
       onHeaderClick={() => {}}
       getItemKey={(row) => row.key}
       renderCell={renderCell}
+      getExportMetadata={() => [
+        ["Ticker", symbol ? publicTickerKey(symbol, exchange) : ""],
+        ["Requested range", range],
+        ["Time zone", "UTC"],
+        ["Price units", "Provider history units; general currency and price-basis metadata are unavailable"],
+        ["Status", error ? (rows.length ? "Retained after refresh failure" : "Unavailable")
+          : loading ? (rows.length ? "Refreshing" : "Loading") : rows.length ? "Available" : "Empty"],
+        ...(integrityNotice ? [["Warning", integrityNotice]] : []),
+        ...(error ? [["Error", error]] : []),
+      ]}
       emptyStateTitle={error
         ? unavailableText("Historical prices")
         : loading

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

@@ -0,0 +1,79 @@
+import { expect, test } from "bun:test";
+import type { FinancialStatement } from "../../../../types/financials";
+import { computeTTM } from "./aggregation";
+import { buildFinancialTableModel } from "./model";
+
+const dates = ["2025-03-31", "2025-06-30", "2025-09-30", "2025-12-31"];
+const filed = ["2025-05-01", "2025-08-01", "2025-11-01", "2026-02-01"];
+
+test("TTM keeps quarter provenance and follows flow, opening, closing and average-share availability", () => {
+  const quarters: FinancialStatement[] = dates.map((date, index) => ({
+    date, currency: "USD", dateSource: "sec",
+    dateEvidence: { startDate: ["2025-01-01", "2025-04-01", "2025-07-01", "2025-10-01"][index]!, filed: filed[index]!, accessionNumber: `controlled-${index}` },
+    totalRevenue: (index + 1) * 10, netIncome: 0, basicEps: 0, eps: 0,
+    beginningCashPosition: 100 + index * 10, endCashPosition: 110 + index * 10,
+    totalAssets: 200 + index, basicShares: 100 - index * 10, availableAt: filed[index],
+  }));
+  const source = structuredClone(quarters);
+  const ttm = computeTTM([...quarters].reverse())!;
+  expect(ttm).toMatchObject({ totalRevenue: 100, netIncome: 0, basicEps: 0, eps: 0,
+    beginningCashPosition: 100, endCashPosition: 140, totalAssets: 203, basicShares: 85,
+    availableAt: "2026-02-01", aggregation: { kind: "trailing-four-quarters", periodEnd: "2025-12-31" } });
+  expect(ttm.fieldAvailability).toMatchObject({ totalRevenue: "2026-02-01", netIncome: "2026-02-01",
+    basicEps: "2026-02-01", eps: "2026-02-01", basicShares: "2026-02-01",
+    beginningCashPosition: "2025-05-01", endCashPosition: "2026-02-01", totalAssets: "2026-02-01" });
+  expect(ttm.aggregation!.sourcePeriods.map(({ date, dateEvidence }) => [date, dateEvidence]))
+    .toEqual(source.map(({ date, dateEvidence }) => [date, dateEvidence]));
+  ttm.aggregation!.sourcePeriods[0]!.dateEvidence!.filed = "changed export";
+  expect(quarters).toEqual(source);
+});
+
+test("partial field availability cannot borrow row or period filing dates for a TTM field", () => {
+  const quarters: FinancialStatement[] = dates.map((date, index) => ({
+    date, currency: "USD", totalRevenue: 10, netIncome: 0, totalAssets: 100,
+    availableAt: filed[index], fieldAvailability: { totalRevenue: filed[index]! },
+  }));
+  const ttm = computeTTM(quarters)!;
+  expect(ttm).toMatchObject({ totalRevenue: 40, netIncome: 0, totalAssets: 100,
+    fieldAvailability: { totalRevenue: "2026-02-01" } });
+  expect(ttm.availableAt).toBeUndefined();
+  expect(ttm.fieldAvailability?.netIncome).toBeUndefined();
+  expect(ttm.fieldAvailability?.totalAssets).toBeUndefined();
+  quarters[1]!.fieldAvailability!.totalRevenue = "invalid";
+  expect(computeTTM(quarters)!.fieldAvailability?.totalRevenue).toBeUndefined();
+});
+
+test("growth needs established monetary units but preserves counts across currency changes", () => {
+  const annualStatements: FinancialStatement[] = [
+    { date: "2023-12-31", totalRevenue: 100, basicShares: 10, dilutedShares: 12 },
+    { date: "2024-12-31", currency: "JPY", totalRevenue: 200, basicShares: 20, dilutedShares: 24 },
+    { date: "2025-12-31", currency: "USD", totalRevenue: 300, basicShares: 30, dilutedShares: 36 },
+  ];
+  const table = buildFinancialTableModel({ annualStatements, quarterlyStatements: [], financialCurrency: "USD" }, { expandAll: true })!;
+  expect(table.rows.find(({ summaryKey }) => summaryKey === "totalRevenue")!.cells.map(({ growth }) => growth))
+    .toEqual([undefined, undefined, undefined]);
+  for (const key of ["basicShares", "dilutedShares"]) {
+    expect(table.rows.find((row) => row.key === key)!.cells.map(({ growth }) => growth)).toEqual([0.5, 1, undefined]);
+  }
+  expect(table.rows.find(({ summaryKey }) => summaryKey === "totalRevenue")!.cells.map(({ value }) => value)).toEqual([300, 200, 100]);
+});
+
+test("an uncontradicted reporting currency supports known zero and loss comparisons without quote currency", () => {
+  const table = buildFinancialTableModel({ financialCurrency: "GBP", annualStatements: [
+    { date: "2024-12-31", totalRevenue: 100, netIncome: -10, basicEps: 1, eps: 0.8 },
+    { date: "2025-12-31", totalRevenue: 0, netIncome: 0, basicEps: 0, eps: 0 },
+  ], quarterlyStatements: [] }, { expandAll: true })!;
+  expect(table.rows.find(({ summaryKey }) => summaryKey === "totalRevenue")!.cells[0]).toMatchObject({ value: 0, growth: -1 });
+  expect(table.rows.find(({ summaryKey }) => summaryKey === "netIncome")!.cells[0]).toMatchObject({ value: 0, growth: 1 });
+  expect(table.rows.find(({ key }) => key === "basicEps")!.cells[0]).toMatchObject({ value: 0, growth: -1 });
+  expect(table.rows.find(({ key }) => key === "eps")!.cells[0]).toMatchObject({ value: 0, growth: -1 });
+});
+
+test("TTM share growth survives different currency windows while monetary growth stays unavailable", () => {
+  const quarterlyStatements: FinancialStatement[] = ["2024", "2025"].flatMap((year, index) => (
+    dates.map((date) => ({ date: year + date.slice(4), currency: index ? "USD" : "JPY", totalRevenue: 100, basicShares: index ? 20 : 10 }))
+  ));
+  const table = buildFinancialTableModel({ annualStatements: [{ date: "2025-12-31", currency: "USD", totalRevenue: 400 }], quarterlyStatements }, { expandAll: true })!;
+  expect(table.rows.find(({ summaryKey }) => summaryKey === "totalRevenue")!.cells[0].growth).toBeUndefined();
+  expect(table.rows.find(({ key }) => key === "basicShares")!.cells[0]).toMatchObject({ value: 20, growth: 1 });
+});

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

@@ -1,7 +1,18 @@
 import type { FinancialStatement } from "../../../../types/financials";
+import { completeAvailability, statementFieldAvailability } from "../../../../utils/financial-statements";
 
 export type FinancialPeriod = "annual" | "quarterly";
 
+export interface FinancialTableStatement extends FinancialStatement {
+  aggregation?: {
+    kind: "trailing-four-quarters";
+    periodEnd: string;
+    sourcePeriods: Array<Pick<FinancialStatement,
+      "date" | "currency" | "dateSource" | "providerDate" | "dateEvidence" | "availableAt" | "fieldAvailability" | "fieldSources" | "unavailableFields" | "withdrawnObservations"
+    >>;
+  };
+}
+
 const FLOW_KEYS = new Set<string>([
   "totalRevenue",
   "costOfRevenue",
@@ -23,6 +34,7 @@ const FLOW_KEYS = new Set<string>([
   "interestExpense",
   "taxProvision",
   "netIncome",
+  "netIncomeIncludingNoncontrollingInterests",
   "ebitda",
   "basicEps",
   "eps",
@@ -75,8 +87,6 @@ const FLOW_KEYS = new Set<string>([
   "cashDividendsPaid",
   "commonStockDividendPaid",
   "netOtherFinancingCharges",
-  "beginningCashPosition",
-  "endCashPosition",
   "changesInCash",
   "effectOfExchangeRateChanges",
 ]);
@@ -140,43 +150,92 @@ const BALANCE_KEYS = new Set<string>([
   "shareIssued",
   "ordinarySharesNumber",
   "treasurySharesNumber",
-  "basicShares",
-  "dilutedShares",
+  "endCashPosition",
 ]);
 
 function aggregateQuarterlyStatements(
   statements: FinancialStatement[],
   date: string,
-): FinancialStatement | null {
-  if (statements.length < 4) return null;
+): FinancialTableStatement | null {
+  if (statements.length !== 4) return null;
+  // A provider may return semiannual reports or skip a quarter. Four rows do
+  // not necessarily cover twelve months; never label those sums as TTM.
+  for (let index = 1; index < statements.length; index += 1) {
+    const days = (Date.parse(statements[index]!.date) - Date.parse(statements[index - 1]!.date)) / 86_400_000;
+    if (!Number.isFinite(days) || days < 60 || days > 120) return null;
+  }
+  const currencies = new Set(statements.map((statement) => statement.currency));
+  if (currencies.size > 1) return null;
 
-  const aggregate: FinancialStatement = { date };
+  const aggregate: FinancialTableStatement = {
+    date,
+    currency: [...currencies][0],
+    aggregation: {
+      kind: "trailing-four-quarters",
+      periodEnd: statements.at(-1)!.date,
+      sourcePeriods: statements.map(({ date, currency, dateSource, providerDate, dateEvidence, availableAt, fieldAvailability, fieldSources, unavailableFields, withdrawnObservations }) => ({
+        date, currency, dateSource, providerDate,
+        ...(dateEvidence ? { dateEvidence: { ...dateEvidence } } : {}),
+        availableAt,
+        ...(fieldAvailability ? { fieldAvailability: { ...fieldAvailability } } : {}),
+        ...(fieldSources ? { fieldSources: { ...fieldSources } } : {}),
+        ...(unavailableFields ? { unavailableFields: [...unavailableFields] } : {}),
+        ...(withdrawnObservations ? { withdrawnObservations: [...withdrawnObservations] } : {}),
+      })),
+    },
+  };
+  const availability: Record<string, string> = {};
+  const includedFields: string[] = [];
+  const retainAvailability = (key: string, sources: FinancialStatement[]) => {
+    includedFields.push(key);
+    const availableAt = completeAvailability(sources.map((source) => statementFieldAvailability(source, key)));
+    if (availableAt) availability[key] = availableAt;
+  };
   for (const key of FLOW_KEYS) {
     const values = statements
       .map((statement) => (statement as unknown as Record<string, unknown>)[key])
-      .filter((value): value is number => typeof value === "number");
+      .filter((value): value is number => typeof value === "number" && Number.isFinite(value));
     if (values.length === 4) {
       (aggregate as unknown as Record<string, unknown>)[key] = values.reduce((left, right) => left + right, 0);
+      retainAvailability(key, statements);
     }
   }
 
   const latest = statements[statements.length - 1]!;
   for (const key of BALANCE_KEYS) {
     const value = (latest as unknown as Record<string, unknown>)[key];
-    if (typeof value === "number") {
+    if (typeof value === "number" && Number.isFinite(value)) {
       (aggregate as unknown as Record<string, unknown>)[key] = value;
+      retainAvailability(key, [latest]);
     }
   }
 
+  const openingCash = statements[0]!.beginningCashPosition;
+  if (openingCash != null && Number.isFinite(openingCash)) {
+    aggregate.beginningCashPosition = openingCash;
+    retainAvailability("beginningCashPosition", [statements[0]!]);
+  }
+
+  // These are average shares over each quarter, unlike balance-sheet shares.
+  for (const key of ["basicShares", "dilutedShares"] as const) {
+    const values = statements.map((statement) => statement[key]);
+    if (values.every((value): value is number => value != null && Number.isFinite(value))) {
+      aggregate[key] = values.reduce((sum, value) => sum + value, 0) / 4;
+      retainAvailability(key, statements);
+    }
+  }
+  if (Object.keys(availability).length > 0) aggregate.fieldAvailability = availability;
+  const availableAt = completeAvailability(includedFields.map((key) => availability[key]));
+  if (availableAt) aggregate.availableAt = availableAt;
   return aggregate;
 }
 
 export function computeTTM(quarterlyStatements: FinancialStatement[]) {
-  return aggregateQuarterlyStatements(quarterlyStatements.slice(-4), "TTM");
+  return aggregateQuarterlyStatements([...quarterlyStatements].sort((a, b) => a.date.localeCompare(b.date)).slice(-4), "TTM");
 }
 
 function computePreviousTtm(quarterlyStatements: FinancialStatement[]) {
-  return aggregateQuarterlyStatements(quarterlyStatements.slice(-8, -4), "prevTTM");
+  return aggregateQuarterlyStatements([...quarterlyStatements].sort((a, b) => a.date.localeCompare(b.date)).slice(-8, -4), "prevTTM");
 }
 
 export function buildPreviousStatementMap(
@@ -189,12 +248,30 @@ export function buildPreviousStatementMap(
   const previousMap = new Map<string, FinancialStatement>();
 
   for (let index = 1; index < sourceStatements.length; index += 1) {
-    previousMap.set(sourceStatements[index]!.date, sourceStatements[index - 1]!);
+    const current = sourceStatements[index]!;
+    // Providers can include off-cycle 12-month observations (for example ADR
+    // EPS) between fiscal years. They must not hide a comparable prior year.
+    // More than one annual candidate is ambiguous; do not guess its identity.
+    const candidates = period === "annual"
+      ? sourceStatements.filter((candidate) => {
+        const days = (Date.parse(current.date) - Date.parse(candidate.date)) / 86_400_000;
+        return days >= 300 && days <= 430;
+      })
+      : [sourceStatements[index - 1]!];
+    if (candidates.length !== 1) continue;
+    const previous = candidates[0]!;
+    const days = (Date.parse(current.date) - Date.parse(previous.date)) / 86_400_000;
+    const [minimum, maximum] = period === "annual" ? [300, 430] : [60, 120];
+    if (days < minimum! || days > maximum! || !Number.isFinite(days)) continue;
+    previousMap.set(current.date, previous);
   }
 
   if (ttm) {
     const previousTtm = computePreviousTtm(quarterlyStatements);
-    if (previousTtm) {
+    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;
+    if (previousTtm && days >= 300 && days <= 430) {
       previousMap.set("TTM", previousTtm);
     }
   }

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

@@ -2,6 +2,10 @@ import { describe, expect, test } from "bun:test";
 import type { TickerFinancials } from "../../../../types/financials";
 import {
   buildFinancialTableModel,
+  computeGrowth,
+  computeTTM,
+  formatFinancialCell,
+  financialStatementCurrency,
   resolveFinancialPeriodOption,
   resolveFinancialSubTabKey,
 } from "./model";
@@ -23,6 +27,24 @@ function createFinancials(): TickerFinancials {
 }
 
 describe("financial statement table model", () => {
+  test("large growth fits beside precise EPS without truncating its sign or percent unit", () => {
+    const growth = computeGrowth(0.004125, -0.00000254)!;
+    const cell = formatFinancialCell("0.004125", growth);
+    expect(cell.valueText.trim()).toBe("0.004125");
+    expect(cell.growthText.trim()).toBe("+163k%");
+    expect(cell.valueText.length + cell.growthText.length).toBe(18);
+    for (const rate of [-999.995, -100, 99.995, 9999.995, 1e12, -1e100, 1e100, -1e307, 1e307]) {
+      const formatted = formatFinancialCell("0.004125", rate).growthText.trim();
+      expect(formatted.endsWith("%")).toBe(true);
+      expect(formatted.length).toBeLessThanOrEqual(6);
+      expect(formatted).toContain(rate < 0 ? "-" : formatted.startsWith(">") ? ">" : "+");
+    }
+    expect(computeGrowth(Number.MAX_VALUE, Number.MIN_VALUE)).toBeUndefined();
+    expect(computeGrowth(Number.MAX_VALUE, -Number.MAX_VALUE)).toBe(2);
+    expect(computeGrowth(-Number.MAX_VALUE, Number.MAX_VALUE)).toBe(-2);
+    expect(formatFinancialCell("1", Number.POSITIVE_INFINITY).growthText.trim()).toBe("");
+  });
+
   test("uses annual rows with a TTM column when quarterly data is available", () => {
     const table = buildFinancialTableModel(createFinancials(), {
       period: "annual",
@@ -37,6 +59,7 @@ describe("financial statement table model", () => {
 
   test("applies financial row semantics to growth color values", () => {
     const table = buildFinancialTableModel({
+      financialCurrency: "USD",
       annualStatements: [
         {
           date: "2024-12-31",
@@ -82,3 +105,132 @@ describe("financial statement table model", () => {
     expect(resolveFinancialSubTabKey("cf")).toBe("cashflow");
   });
 });
+
+
+test("TTM keeps opening/closing cash and averages period shares instead of summing balances", () => {
+  const quarters = ["2025-03-31", "2025-06-30", "2025-09-30", "2025-12-31"].map((date, index) => ({
+    date, currency: "USD", totalRevenue: 10, beginningCashPosition: 100 + index * 10,
+    endCashPosition: 110 + index * 10, changesInCash: 10, totalAssets: 200 + index,
+    basicShares: 100 - index * 10, dilutedShares: 110 - index * 10,
+  }));
+  const ttm = computeTTM([...quarters].reverse());
+  expect(ttm).toMatchObject({ currency: "USD", totalRevenue: 40, beginningCashPosition: 100,
+    endCashPosition: 140, changesInCash: 40, totalAssets: 203, basicShares: 85, dilutedShares: 95 });
+});
+
+test("TTM rejects missing quarters, semiannual reports, and incompatible or partially known currencies", () => {
+  const dates = ["2024-06-30", "2024-12-31", "2025-06-30", "2025-12-31"];
+  expect(computeTTM(dates.map((date) => ({ date, totalRevenue: 100 })))).toBeNull();
+  expect(computeTTM(["2025-03-31", "2025-06-30", "2025-09-30", "2025-12-31"].map((date, index) => ({
+    date, totalRevenue: 100, currency: index === 0 ? "USD" : undefined,
+  })))).toBeNull();
+  expect(computeTTM(["2024-09-30", "2025-03-31", "2025-06-30", "2025-09-30"].map((date) => ({ date, totalRevenue: 100 })))).toBeNull();
+  expect(computeTTM(["2025-03-31", "2025-06-30", "2025-09-30", "2025-12-31"].map((date, index) => ({
+    date, totalRevenue: 100, currency: index === 0 ? "EUR" : "USD",
+  })))).toBeNull();
+});
+
+test("statement reporting currency stays separate from converted summary fundamentals", () => {
+  const summary = { financialCurrency: "TWD", fundamentals: { financialCurrency: "USD" } };
+  expect(financialStatementCurrency(summary, [{ date: "2025-12-31", totalRevenue: 3.8e12 }])).toBe("TWD");
+  expect(financialStatementCurrency({}, [{ date: "2025-12-31", currency: "TWD" }])).toBe("TWD");
+  expect(financialStatementCurrency({ fundamentals: { financialCurrency: "USD" } }, [{ date: "2025-12-31" }])).toBeUndefined();
+});
+
+test("growth is unavailable across missing years or a reporting currency change", () => {
+  const table = buildFinancialTableModel({ annualStatements: [
+    { date: "2022-12-31", currency: "USD", totalRevenue: 100 },
+    { date: "2024-12-31", currency: "USD", totalRevenue: 200 },
+    { date: "2025-12-31", currency: "EUR", totalRevenue: 180 },
+  ], quarterlyStatements: [] });
+  expect(table?.rows.find((row) => row.summaryKey === "totalRevenue")?.cells.map((cell) => cell.growth)).toEqual([undefined, undefined, undefined]);
+});
+
+test("annual growth finds a unique prior year around interleaved ADR EPS observations", () => {
+  const annualStatements = [
+    { date: "2025-03-31", currency: "JPY", totalRevenue: 48_036_704_000_000, eps: 3595.6 },
+    { date: "2025-06-30", currency: "JPY", eps: 3251.3 },
+    { date: "2025-09-30", currency: "JPY", eps: 3534.8 },
+    { date: "2026-03-31", currency: "JPY", totalRevenue: 50_684_952_000_000, eps: 2952.5 },
+  ];
+  const model = () => buildFinancialTableModel({ annualStatements, quarterlyStatements: [] }, {
+    period: "annual", statement: "income", expandAll: true,
+  })!;
+  const revenue = (table: ReturnType<typeof model>) => table.rows.find((row) => row.summaryKey === "totalRevenue")!.cells[0]!;
+  const table = model();
+  expect(revenue(table)).toMatchObject({ value: 50_684_952_000_000 });
+  expect(revenue(table).growth).toBeCloseTo(0.0551296775);
+  expect(table.rows.find((row) => row.key === "eps")!.cells[0]!.growth).toBeCloseTo(-0.1788574925);
+  expect(table.statements.map((row) => row.date)).toEqual([...annualStatements].reverse().map((row) => row.date));
+
+  annualStatements[0]!.currency = "USD";
+  expect(revenue(model()).growth).toBeUndefined();
+  annualStatements[0]!.currency = "JPY";
+  annualStatements.splice(1, 0, { date: "2025-04-30", currency: "JPY", totalRevenue: 49_000_000_000_000, eps: 3500 });
+  expect(revenue(model()).growth).toBeUndefined();
+});
+
+test("annual balance sheets show the latest dated snapshot with comparable year-on-year growth", () => {
+  const financials = {
+    annualStatements: [{ date: "2025-12-31", currency: "USD", totalAssets: 200 }],
+    quarterlyStatements: [
+      { date: "2025-06-30", currency: "USD", totalAssets: 160 },
+      { date: "2026-06-30", currency: "USD", totalAssets: 240 },
+    ],
+  };
+  const table = buildFinancialTableModel(financials, { period: "annual", statement: "balance" })!;
+  expect(table.statements.map(({ date }) => date)).toEqual(["2026-06-30", "2025-12-31"]);
+  expect(table.rows.find(({ summaryKey }) => summaryKey === "totalAssets")?.cells[0]).toMatchObject({ value: 240, growth: 0.5 });
+  financials.quarterlyStatements[0]!.currency = "EUR";
+  const changedCurrency = buildFinancialTableModel(financials, { period: "annual", statement: "balance" })!;
+  expect(changedCurrency.rows.find(({ summaryKey }) => summaryKey === "totalAssets")?.cells[0]?.growth).toBeUndefined();
+  financials.quarterlyStatements = [{ date: "2025-12-31", currency: "USD", totalAssets: 200 }];
+  expect(buildFinancialTableModel(financials, { period: "annual", statement: "balance" })?.statements.map(({ date }) => date)).toEqual(["2025-12-31"]);
+});
+
+test("an EPS-only quarter cannot replace the latest available balance sheet", () => {
+  // Reduced from the public BAC capture: June coverage has EPS but no balance sheet.
+  const financials: TickerFinancials = {
+    annualStatements: [{ date: "2025-12-31", currency: "USD", totalAssets: 3_411_738_000_000 }],
+    quarterlyStatements: [
+      { date: "2025-03-31", currency: "USD", totalAssets: 3_349_424_000_000 },
+      { date: "2026-03-31", currency: "USD", totalAssets: 3_496_186_000_000 },
+      { date: "2026-06-30", currency: "USD", eps: 1.21 },
+    ],
+    priceHistory: [],
+  };
+  const source = structuredClone(financials);
+  const balance = buildFinancialTableModel(financials, { period: "annual", statement: "balance" })!;
+  expect(balance.statements.map(({ date }) => date)).toEqual(["2026-03-31", "2025-12-31"]);
+  const assets = balance.rows.find(({ summaryKey }) => summaryKey === "totalAssets")!.cells[0]!;
+  expect(assets.value).toBe(3_496_186_000_000);
+  expect(assets.growth).toBeCloseTo(3_496_186_000_000 / 3_349_424_000_000 - 1);
+  const income = buildFinancialTableModel(financials, { period: "quarterly", statement: "income", expandAll: true })!;
+  expect(income.statements[0]!.date).toBe("2026-06-30");
+  expect(income.rows.find(({ key }) => key === "eps")!.cells[0]!.value).toBe(1.21);
+  expect(financials).toEqual(source);
+
+  // Missing/non-finite fields are not balance coverage, but a reported zero is.
+  financials.quarterlyStatements.at(-1)!.totalAssets = NaN;
+  expect(buildFinancialTableModel(financials, { period: "annual", statement: "balance" })!.statements[0]!.date).toBe("2026-03-31");
+  financials.quarterlyStatements.at(-1)!.totalDebt = 0;
+  const zero = buildFinancialTableModel(financials, { period: "annual", statement: "balance", expandAll: true })!;
+  expect(zero.statements[0]!.date).toBe("2026-06-30");
+  expect(zero.rows.find(({ key }) => key === "totalDebt")!.cells[0]!.value).toBe(0);
+});
+
+test("liabilities plus equity requires its own components and cannot copy total assets", () => {
+  const table = buildFinancialTableModel({
+    annualStatements: [
+      { date: "2022-12-31", totalAssets: 100, totalLiabilities: 60, totalEquityGrossMinorityInterest: 35 },
+      { date: "2023-12-31", totalAssets: 110, totalLiabilities: 70, totalEquity: 40 },
+      { date: "2024-12-31", totalAssets: 120, totalLiabilities: 80, totalEquityGrossMinorityInterest: 0 },
+      { date: "2025-12-31", totalAssets: 130 },
+    ],
+    quarterlyStatements: [],
+  }, { period: "annual", statement: "balance" })!;
+  const total = table.rows.find(({ id }) => id === "balance:liabilities-equity:0")!;
+  expect(total.cells.map(({ value }) => value)).toEqual([undefined, 80, undefined, 95]);
+  expect(total.cells[0]!.valueText.trim()).toBe("—");
+  expect(table.rows.find(({ summaryKey }) => summaryKey === "totalAssets")!.cells.map(({ value }) => value)).toEqual([130, 120, 110, 100]);
+});