gloomberb 0.19.1 → 0.19.2

package/src/tickers/search/home-listing.ts

@@ -1,5 +1,5 @@
-import { canonicalExchange } from "../../utils/exchanges";
-import { companyNameExtraWords, sameCompany } from "../company-name";
+import { canonicalExchange, isUsListingExchange } from "../../utils/exchanges";
+import { companyLines, companyNameExtraWords, namedByService, type CompanyLineFacts } from "../company-name";
 import { answersOnlyByKeyword, isQualifiedTickerQuery } from "./ranking";
 import type { TickerSearchCandidate } from "./types";
 
@@ -29,6 +29,69 @@ export function lineDistance(type: string, exchange: string, symbol: string): 0
   return SECONDARY_VENUES.has(exchange) || /\d/.test(symbol) && /[A-Za-z]/.test(symbol) ? 1 : 0;
 }
 
+/** How the primary-listing choice weighs one of a company's lines. */
+export interface WeighedCompanyLine {
+  /** `listingDistance`: 0 its own line, 1 a line quoting shares listed elsewhere, 2 a receipt. */
+  distance: number;
+  /** The search score the service gives the listings people look up most; null when it gives none. */
+  score: number | null;
+}
+
+/**
+ * The line a company's search lists as its primary listing instead of `lead`,
+ * the line search put first, often the one-off cross-listing whose short name
+ * matched the query (LUFTHANSA on Budapest): its lines go by how far each is
+ * from being its own line, then by the search score. The lead gives way only
+ * to a closer line, or to one searched at least twice as often, or any scored
+ * line when it has no score. With `named` (the service marked the lead with
+ * the name as typed) no score outweighs the mark: only a closer line does.
+ * `lines` holds the lead. `search` and a company's name typed for a listing
+ * (`findListingOfCompanyName`) choose by this one rule, so both open the same
+ * listing.
+ */
+export function primaryCompanyLine<T>(
+  lead: T,
+  lines: readonly T[],
+  weigh: (line: T) => WeighedCompanyLine,
+  options: { named?: boolean } = {},
+): T {
+  const order = (line: T) => lines.indexOf(line);
+  const [home] = [...lines].sort((a, b) => weigh(a).distance - weigh(b).distance
+    || (weigh(b).score ?? -1) - (weigh(a).score ?? -1) || order(a) - order(b));
+  if (!home || home === lead) return lead;
+  const [best, first] = [weigh(home), weigh(lead)];
+  const closer = best.distance < first.distance;
+  const moreSearched = !options.named && best.distance === first.distance && best.score != null
+    && (first.score == null || best.score >= first.score * 2);
+  return closer || moreSearched ? home : lead;
+}
+
+/** A row as `companyLines` weighs it. */
+function lineFacts(candidate: TickerSearchCandidate): CompanyLineFacts {
+  return {
+    name: candidateName(candidate),
+    exchange: candidateExchange(candidate),
+    receipt: listingDistance(candidate) === 2,
+    home: candidate.result?.homeListing === true,
+  };
+}
+
+/** The rows of `lead`'s company among `items` (`companyLines`): never a line of another business its name is in (Siemens Energy for Siemens). */
+function companyRows<T extends TickerSearchCandidate>(lead: T, items: readonly T[]): T[] {
+  return companyLines(lead, items.filter((item) => item === lead || isListedEquity(item)), lineFacts);
+}
+
+/** `primaryCompanyLine` among `items` of `start`'s company, for the command bar's rows. */
+function primaryLineOf<T extends TickerSearchCandidate>(start: T, items: readonly T[], query: string): T {
+  const name = candidateName(start);
+  const named = !!start.result && namedByService(query, start.result);
+  const lines = companyRows(start, items).filter((item) => item === start
+    || !named || companyNameExtraWords(candidateName(item), name) != null);
+  return primaryCompanyLine(start, lines, (item) => ({
+    distance: listingDistance(item), score: item.result?.popularity ?? item.popularity ?? null,
+  }), { named });
+}
+
 function candidateName(candidate: TickerSearchCandidate): string {
   return candidate.result?.name || candidate.detail.split(" | ")[0] || "";
 }
@@ -51,24 +114,46 @@ function isListedEquity(candidate: TickerSearchCandidate): boolean {
  * service marks as the company's home (`homeListing`) takes the lead from
  * the company's first row. Without that mark, a receipt in the lead gives
  * way to the company's own shares on an exchange (`listingDistance` 0, not
- * an OTC or regional line), the name nearest the receipt's first. A query that names a venue (LVMH:TSX,
- * 7203.T) asked for that line, and a saved row keeps the lead.
+ * an OTC or regional line), the name nearest the receipt's first. Then the
+ * line `search` calls the company's primary listing (`primaryCompanyLine`)
+ * takes the lead, so a name opens what `search` lists first: LHA on XETRA
+ * for "lufthansa", not LUFTHANSA on Budapest. A company's lines are never
+ * another business's its name is in (`companyLines`: Siemens Energy AG for
+ * Siemens AG). The row the service marks with the word as typed is the
+ * company the word means, ahead of a line abroad whose symbol is the word:
+ * "siemens" is SIE on XETRA, not SIEMENS on NSE (Siemens Ltd.); a US line
+ * keeps its ticker. A query that names a venue (LVMH:TSX, 7203.T) asked for
+ * that line, and a saved row keeps the lead.
  */
 export function withHomeListingLead<T extends TickerSearchCandidate>(items: T[], query: string): T[] {
   if (isQualifiedTickerQuery(query)) return items;
   const lead = items.find((item) => item.instrumentClass !== "fund" && item.instrumentClass !== "derivative"
     && !answersOnlyByKeyword(item, query));
   if (!lead || !isListedEquity(lead)) return items;
+  const typedSymbol = lead.symbol.toUpperCase() === query.trim().toUpperCase();
+  const meant = typedSymbol && !isUsListingExchange(candidateExchange(lead)) && !(lead.result && namedByService(query, lead.result))
+    // A company's shares under another symbol: an index the code also names (SPX) or the word's own line elsewhere (SAP) is not it.
+    ? items.find((item) => item !== lead && isListedEquity(item) && item.instrumentClass === "equity" && !!item.result
+      && item.symbol.toUpperCase() !== lead.symbol.toUpperCase() && namedByService(query, item.result))
+    : undefined;
+  if (meant) return moveAhead(items, meant, lead);
   const name = candidateName(lead);
-  const lines = items.filter((item) => item !== lead && isListedEquity(item) && sameCompany(name, candidateName(item)));
+  const lines = companyRows(lead, items).filter((item) => item !== lead);
   const nearest = (candidates: T[]) => [...candidates].sort((a, b) => nameGap(name, candidateName(a)) - nameGap(name, candidateName(b))
     || items.indexOf(a) - items.indexOf(b))[0];
   const marked = lines.filter((item) => item.result?.homeListing === true);
+  const own = listingDistance(lead) === 2 ? nearest(lines.filter((item) => listingDistance(item) === 0)) : undefined;
   const home = lead.result?.homeListing === true ? undefined
     : marked.length ? nearest(marked)
-    : listingDistance(lead) === 2 ? nearest(lines.filter((item) => listingDistance(item) === 0))
-    : undefined;
-  if (!home) return items;
+    // A listing searched by its own symbol is that listing, as `search` keeps it.
+    : typedSymbol ? own
+    : primaryLineOf(own ?? lead, [lead, ...lines], query);
+  if (!home || home === lead) return items;
+  return moveAhead(items, home, lead);
+}
+
+/** `items` with `home` moved just ahead of `lead`. */
+function moveAhead<T>(items: readonly T[], home: T, lead: T): T[] {
   const rest = items.filter((item) => item !== home);
   const at = rest.indexOf(lead);
   return [...rest.slice(0, at), home, ...rest.slice(at)];

package/src/tickers/search/index.ts

@@ -54,7 +54,7 @@ export {
   rankTickerSearchItems,
 } from "./ranking";
 export { upsertTickerFromSearchResult } from "./upsert";
-export { candidateExchange, listingDistance } from "./home-listing";
+export { candidateExchange, listingDistance, primaryCompanyLine } from "./home-listing";
 
 const MAX_NAMED_LISTINGS = 6;
 

package/src/time-series/market.ts

@@ -1,5 +1,5 @@
 import type { PricePoint, TickerFinancials } from "../types/financials";
-import { pricePointIntegrity, pricePointValues, priceHistoryIntegrityNotice, mergePriceHistoryIntegrity, type PriceHistoryIntegrity } from "../utils/price-history-integrity";
+import { pricePointIntegrity, pricePointValues, pricePointWicks, priceHistoryIntegrityNotice, mergePriceHistoryIntegrity, type PriceHistoryIntegrity } from "../utils/price-history-integrity";
 import { canonicalTimeSeriesFieldId, isFundamentalFieldId, isMarketFieldId } from "./field-catalog";
 import { extractFundamentalSeries } from "./fundamentals";
 import type { ChartSeriesPriceHistoryIntegrity, ResolvedSeries, SecuritySeriesSource, SeriesPeriod, TimeSeriesPoint } from "./types";
@@ -73,8 +73,10 @@ function aggregatePriceHistory(
   for (const point of sorted) {
     const key = periodKey(point.date, period);
     const open = isFiniteNumber(point.open) ? point.open : point.close;
-    const high = isFiniteNumber(point.high) ? point.high : point.close;
-    const low = isFiniteNumber(point.low) ? point.low : point.close;
+    // A wick too far from its bar's body to have traded does not set the week's or month's range.
+    const wicks = pricePointWicks(point);
+    const high = isFiniteNumber(wicks.high) ? wicks.high : isFiniteNumber(point.high) ? Math.max(open, point.close) : point.close;
+    const low = isFiniteNumber(wicks.low) ? wicks.low : isFiniteNumber(point.low) ? Math.min(open, point.close) : point.close;
     const current = buckets.get(key);
     if (!current) {
       buckets.set(key, {

package/src/time-series/price-comparison.ts

@@ -63,7 +63,24 @@ export function observationDate(time: number, series: Pick<ResolvedSeries, "time
   return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
 }
 
-/** Date-only research windows select local sessions; runtime timestamps remain exact. */
+/**
+ * The day the weekly or monthly bar holding `date` is dated by: its week's
+ * Monday or its month's 1st, as `history --from` keeps the week or month its
+ * first date falls in. A daily bar is its own day.
+ */
+function windowBarStart(date: string, resolution: "1d" | "1wk" | "1mo"): string {
+  if (resolution === "1mo") return `${date.slice(0, 7)}-01`;
+  if (resolution === "1d") return date;
+  const day = Date.parse(`${date}T00:00:00Z`);
+  return new Date(day - ((new Date(day).getUTCDay() + 6) % 7) * 86_400_000).toISOString().slice(0, 10);
+}
+
+/**
+ * Date-only research windows select local sessions; runtime timestamps remain
+ * exact. Weekly and monthly bars keep the bar the window starts in: a window
+ * from 2019-12-31 in monthly bars starts with December 2019's, whose close is
+ * that day's, so a comparison is measured from it.
+ */
 export function priceObservationWindowFilter(
   series: ResolvedSeries,
   bounds: { start: number | null; end: number | null },
@@ -74,11 +91,12 @@ export function priceObservationWindowFilter(
   const calendarWindow = calendarBars && dateWindow
     && /^\d{4}-\d{2}-\d{2}$/.test(dateWindow.start)
     && /^\d{4}-\d{2}-\d{2}$/.test(dateWindow.end) ? dateWindow : null;
+  const start = calendarWindow ? windowBarStart(calendarWindow.start, resolution as "1d" | "1wk" | "1mo") : null;
   return (time) => {
     if (!Number.isFinite(time)) return false;
     const key = calendarWindow ? observationDate(time, series) : null;
     return key !== null
-      ? key >= calendarWindow!.start && key <= calendarWindow!.end
+      ? key >= start! && key <= calendarWindow!.end
       : (bounds.start === null || time >= bounds.start) && (bounds.end === null || time <= bounds.end);
   };
 }

package/src/time-series/resolve.ts

@@ -1,4 +1,5 @@
 import { logFailure } from "../utils/log-failure";
+import { servedFromSavedCopy } from "../data/saved-copies";
 import { hasValidQuoteObservationTime } from "../market-data/quotes/freshness";
 import { delistingLabel } from "../market-data/quotes/delisting";
 import { financialPeriodCoverage, financialPeriodCoverageWarnings, limitSeriesObservations } from "./financial-period-coverage";
@@ -827,7 +828,7 @@ async function resolveChartSpecPass(
           cache.capabilitySeriesByRequest.set(key, pending);
           cache.revision += 1;
         }
-        return baseCapabilitySeries(seriesSpec, await pending, index);
+        return asSavedCopy(baseCapabilitySeries(seriesSpec, await pending, index));
       }
       if (seriesSpec.source.kind === "economic") {
         const request: FredSeriesRequest = {
@@ -845,6 +846,8 @@ async function resolveChartSpecPass(
           priorityWarnings.push(`${result.label}: ${coverageNotice}`);
           coverageNotices.push(`${result.label}: ${coverageNotice}`);
         }
+        // A saved copy that answered for a failed refresh is dated in the footer, as every pane's is.
+        if (result && fred.source === "stale-fallback") return asSavedCopy({ ...result, savedAt: fred.fetchedAt });
         const freshnessWarning = staleFredWarning(fred);
         if (result && freshnessWarning) priorityWarnings.push(`${result.label}: ${freshnessWarning}`);
         return result;
@@ -1180,6 +1183,7 @@ async function resolveChartSpecPass(
     loading: false,
     errors,
     warnings: [...new Set([...priorityWarnings, ...warnings])],
+    ...savedCopyOf(rawSeries.filter((entry) => visibleSeriesIds.has(entry.id))),
     ...(coverageNotices.length ? { coverageNotices: [...new Set(coverageNotices)] } : {}),
     ...(returnBasisNotice ? { returnBasisNotice } : {}),
     ...(delistings.size ? { delistings: [...delistings.values()] } : {}),
@@ -1188,3 +1192,18 @@ async function resolveChartSpecPass(
     ...(builtBarSize && rawSeries.some((entry) => entry.barSize === builtBarSize) ? { barSize: builtBarSize } : {}),
   };
 }
+
+/**
+ * A series drawn from a copy a failed refresh left answering (`savedAt`),
+ * marked as one, so a command charting it ends with "couldn't refresh; saved
+ * copy from …" as the app's footer says.
+ */
+function asSavedCopy(series: ResolvedSeries): ResolvedSeries {
+  return series.savedAt != null ? servedFromSavedCopy(series, series.savedAt) : series;
+}
+
+/** The oldest saved copy among `series` that answered for a failed refresh, which the chart's footer dates. */
+function savedCopyOf(series: readonly ResolvedSeries[]): { savedAt?: number } {
+  const saved = series.flatMap((entry) => entry.savedAt != null && Number.isFinite(entry.savedAt) ? [entry.savedAt] : []);
+  return saved.length ? { savedAt: Math.min(...saved) } : {};
+}

package/src/time-series/types.ts

@@ -265,6 +265,8 @@ export interface ResolvedSeries {
   /** Rejected valuation price inputs, retained independently of usable observations. */
   valuationPriceIssues?: import("./valuation-price").ValuationPriceIssue[];
   warning?: string;
+  /** When the copy the points came from was saved (ms), when its refresh failed and that copy answered. */
+  savedAt?: number;
   /** Listed in the legend so it can be restored, but not drawn. */
   hidden?: boolean;
   /**
@@ -324,6 +326,11 @@ export interface ChartResolutionResult {
   loading: boolean;
   errors: string[];
   warnings: string[];
+  /**
+   * The oldest saved copy a shown series answered from after its refresh
+   * failed (ms), which the chart's footer dates: "saved copy from …".
+   */
+  savedAt?: number;
   /**
    * Where a series' source starts after the range asked for, and why (a
    * publisher's cap on history), as `warnings` also carries it, so a report

package/src/types/financials.ts

@@ -268,7 +268,8 @@ export interface TtmConversion {
 }
 
 /**
- * How a served enterprise value ties to market cap + total debt - cash from the latest balance sheet served beside it.
+ * How a served enterprise value ties to market cap + total debt (+ leases, `leases`) - cash from the latest balance sheet
+ * served beside it.
  * `matches` within 5%; `differs` beyond it (or beyond 2% on the other side of the market cap from net debt), within
  * 0.7x to 1.5x, shown labelled as the provider's; `withdrawn` outside that band, with no EV or EV/revenue; `unchecked`
  * without a recent balance sheet carrying both lines. `computed`: an insurer's or a holding company's EV, which is
@@ -284,15 +285,24 @@ export interface EnterpriseValueCheck {
   /** The market cap the EV is measured on; absent only on a not-meaningful source EV served without one. */
   marketCap?: number;
   totalDebt?: number;
+  /** The balance sheet's lease liabilities the bridge adds to total debt, as FA's net debt does (utils/lease-liabilities); absent when none were added. */
+  leases?: number;
   cash?: number;
   /** YYYY-MM-DD of the balance sheet the debt and cash come from. */
   balanceSheetDate?: string;
-  /** marketCap + totalDebt - cash. */
+  /** marketCap + totalDebt + leases - cash. */
   computed?: number;
   /** `cash` is cash and equivalents alone: an insurer's or a holding company's investments stay in its EV. */
   investmentsKept?: true;
-  /** Why the EV is not meaningful (`not-meaningful`). */
+  /** Why the EV is not meaningful (`not-meaningful`), or why a withdrawn EV no balance sheet checked is withdrawn. */
   reason?: string;
+  /** A balance sheet in another currency than the market cap: its currency and the rate at its date
+   * (`currency` per unit of `from`) that `totalDebt`, `leases` and `cash` were converted at. */
+  fx?: { from: string; rate: number };
+  /** The provider converted its EV from the statements' currency. */
+  convertedFrom?: string;
+  /** Withdrawn because the provider applied that conversion twice: its EV over `computed` is the conversion rate. */
+  convertedTwice?: true;
 }
 
 /** How a trailing P/E converts the EPS it divides by, when that EPS is in another currency than the price. */
@@ -784,6 +794,11 @@ export interface FinancialStatement {
   date: string;
   /** Source of the fiscal period date; does not establish metric publication dates. */
   dateSource?: "sec" | "provider";
+  /**
+   * The accounting standard the issuer reports in, from the taxonomy of its latest annual report to the SEC (10-K,
+   * 20-F or 40-F): BABA's 20-F is US GAAP, NVO's IFRS. Absent for a company that files none with the SEC.
+   */
+  accountingStandard?: "us-gaap" | "ifrs";
   /** Original vendor period date when independent filing evidence changes it. */
   providerDate?: string;
   /** Filing evidence for the period identity only, not availability of every field. */

package/src/ui/host.tsx

@@ -709,7 +709,12 @@ export interface SaveTextFileRequest {
 
 export interface RendererHost {
   requestExit(): void;
-  startWindowDrag?(): Promise<void> | void;
+  /**
+   * From a press on a title bar. `press.detail` counts the clicks: where the
+   * system's title bars maximize on a double-click, the second press does that
+   * instead of moving the window.
+   */
+  startWindowDrag?(press?: { detail?: number }): Promise<void> | void;
   controlWindow?(action: "minimize" | "toggle-maximize" | "close"): Promise<void> | void;
   /**
    * Opens a link in the person's browser. Resolves false when no browser could

package/src/utils/financial-statements.ts

@@ -1,31 +1,88 @@
-import type { FinancialStatement, StatementFill, StatementFillField } from "../types/financials";
+import type { FinancialStatement, StatementFill, StatementFillField, TickerFinancials } from "../types/financials";
+import { settleWithin } from "./async-deadline";
+import { logFailure } from "./log-failure";
 import { copyIncomeField, incomeFieldOwner, INCOME_STATEMENT_FIELDS, isIncomeStatementField } from "./income-statement";
 import { mergeStatementGaps } from "./statement-gaps";
 
 export const FINANCIAL_VINTAGE_NOTICE = "Latest available statements may include restatements. Historical as-of values are not reconstructed.";
 
+/** The oldest dated period of a report's columns (a TTM column has no date), or null when none has one. */
+function oldestPeriod(dates: readonly string[]): string | null {
+  return dates.filter((date) => /^\d{4}-\d{2}-\d{2}/.test(date)).map((date) => date.slice(0, 10)).sort()[0] ?? null;
+}
+
 /**
  * The closing lines of a statements report that say how far back it goes, from
- * the oldest period it served: the report holds no older ones, and `GF` reads
- * one metric over more periods, as far as its own history reaches. Empty when
- * no period has a date, so a report with nothing in it says nothing.
+ * the oldest period it served: the report holds no older ones. `older` says
+ * whether `GF`, which reads one metric from the listing's extended history
+ * (`hasOlderStatements`), goes further back: it is pointed to only then, and
+ * when it does not, the listing has no older ones at all (IAG on LSE: its
+ * statements start in 2022, in GF too). Null when that could not be told in
+ * time: the report then says nothing of older periods. Empty too when no
+ * period has a date, so a report with nothing in it says nothing.
  */
 export function statementHistoryNotes(
   period: "annual" | "quarterly",
   dates: readonly string[],
   symbol: string,
+  older: boolean | null,
 ): string[] {
-  const oldest = dates.filter((date) => /^\d{4}-\d{2}-\d{2}/.test(date)).map((date) => date.slice(0, 10)).sort()[0];
-  if (!oldest) return [];
-  return period === "annual"
-    ? [
-      `annual history from ${oldest.slice(0, 4)}; older years not served`,
-      `earlier years, one metric at a time: gloom fn GF ${symbol} --period annual --periods 40`,
-    ]
-    : [
-      `quarterly history from ${oldest}; older quarters not served`,
-      `earlier quarters, one metric at a time: gloom fn GF ${symbol} --period quarterly --periods 40`,
-    ];
+  const oldest = oldestPeriod(dates);
+  if (!oldest || older === null) return [];
+  const [from, unit] = period === "annual" ? [oldest.slice(0, 4), "years"] : [oldest, "quarters"];
+  if (older === false) return [`${period} history from ${from}; older ${unit} not available for this listing`];
+  return [
+    `${period} history from ${from}; older ${unit} not served`,
+    ...older ? [`earlier ${unit}, one metric at a time: gloom fn GF ${symbol} --period ${period} --periods 40`] : [],
+  ];
+}
+
+/**
+ * How long a statements report waits on the extended history for its
+ * older-periods note, as a lock note waits on its routes' checks: a read still
+ * out then leaves the report on time, without the note. The read goes on and
+ * warms the cache for the next report.
+ */
+const OLDER_STATEMENTS_WAIT_MS = 3_000;
+
+/**
+ * Whether the listing's extended statement history, which `GF` reads, has a
+ * period older than the oldest of `dates`, a report's columns: a US filer's
+ * filings reach years back; a listing abroad has nothing past what the report
+ * served. Null when the history could not be read within `waitMs`.
+ */
+export async function hasOlderStatements(
+  loadExtended: () => Promise<Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">>,
+  period: "annual" | "quarterly",
+  dates: readonly string[],
+  waitMs = OLDER_STATEMENTS_WAIT_MS,
+): Promise<boolean | null> {
+  const oldest = oldestPeriod(dates);
+  if (!oldest) return null;
+  const read = Promise.resolve().then(loadExtended).catch((error: unknown) => {
+    logFailure("utils.financial-statements", "Reading the extended statement history failed")(error);
+    throw error;
+  });
+  const extended = await settleWithin(read, waitMs);
+  if (!extended) return null;
+  const rows = period === "annual" ? extended.annualStatements : extended.quarterlyStatements;
+  return rows.some((row) => /^\d{4}-\d{2}-\d{2}/.test(row.date) && row.date.slice(0, 10) < oldest);
+}
+
+/** Venues whose companies report half-yearly and yearly, with no quarterly statements: Australia's (ASX, and Cboe Australia, which trades ASX companies) and New Zealand's. */
+const HALF_YEARLY_VENUES = new Set(["ASX", "CXA", "NZX"]);
+const DAY_MS = 86_400_000;
+
+/**
+ * Whether a listing's company reports half-yearly rather than quarterly: it
+ * lists on a venue whose companies do (Qantas on ASX), or the periods of its
+ * "quarterly" statements are half a year apart.
+ */
+export function reportsHalfYearly(exchange: string | null | undefined, quarterly: readonly Pick<FinancialStatement, "date">[]): boolean {
+  if (exchange && HALF_YEARLY_VENUES.has(exchange.toUpperCase())) return true;
+  const times = quarterly.map(({ date }) => Date.parse(`${date.slice(0, 10)}T00:00:00Z`)).filter(Number.isFinite).sort((a, b) => a - b);
+  const gaps = times.slice(1).map((time, index) => (time - times[index]!) / DAY_MS);
+  return gaps.length > 0 && gaps.every((days) => days > 150 && days < 215);
 }
 
 /** How old a statement's latest period may be before a report says how old it is. */
@@ -106,7 +163,7 @@ function retainedFill(merged: FinancialStatement, rows: Array<FinancialStatement
 
 export const SEC_EPS_BASIS_NOTICE = "SEC EPS uses corroborated split-adjusted share bases. Unverified bases are unavailable.";
 
-const STATEMENT_METADATA_KEYS = new Set(["date", "dateSource", "providerDate", "dateEvidence", "currency", "availableAt", "fieldAvailability", "epsBasis", "fieldSources", "unavailableFields", "withdrawnObservations", "operatingResult", "operatingResultAggregation", "earningsResult", "unavailableEarnings", "filledFrom"]);
+const STATEMENT_METADATA_KEYS = new Set(["date", "dateSource", "accountingStandard", "providerDate", "dateEvidence", "currency", "availableAt", "fieldAvailability", "epsBasis", "fieldSources", "unavailableFields", "withdrawnObservations", "operatingResult", "operatingResultAggregation", "earningsResult", "unavailableEarnings", "filledFrom"]);
 const NEARBY_PERIOD_END_MS = 7 * 24 * 60 * 60 * 1_000;
 
 /** An explicit field map is authoritative: omitted fields have unknown availability. */

package/src/utils/fundamentals.ts

@@ -45,7 +45,10 @@ export function enterpriseValueCheck(
   // Not meaningful needs no figure of its own: a source EV below zero may come with no cap or currency.
   if (check.status === "not-meaningful") return withdrawn ? check : undefined;
   if (!check.currency) return undefined;
-  if (check.status === "withdrawn") return withdrawn && finiteNumber(check.computed) && finiteNumber(check.source) ? check : undefined;
+  // A withdrawn EV comes with the figure it was checked against, or with why no balance sheet checked it.
+  if (check.status === "withdrawn") {
+    return withdrawn && ((finiteNumber(check.computed) && finiteNumber(check.source)) || !!check.reason?.trim()) ? check : undefined;
+  }
   if (check.status === "computed") {
     return finiteNumber(check.computed) && fundamentals?.enterpriseValue === check.computed ? check : undefined;
   }
@@ -87,8 +90,9 @@ export function enterpriseValueLabel(fundamentals: Parameters<typeof enterpriseV
 /**
  * The reconciliation line under a labelled, withdrawn or not meaningful EV: "EV 61.75B USD (provider) vs 63.75B
  * computed from market cap + total debt - cash (balance sheet 2026-06-30).", "EV N/M: cash and short-term investments
- * exceed market cap + total debt (balance sheet 2026-06-30)." For an EV withdrawn without a check, that the source
- * failed validation. Undefined when the EV matches, is unchecked or computed, or has no check. Read it from the
+ * exceed market cap + total debt (balance sheet 2026-06-30)." A balance sheet in another currency names the rate it
+ * was converted at ("balance sheet 2026-06-30, EUR at 0.8614 GBP"). A withdrawn EV no balance sheet checked gives
+ * Gloom Cloud's reason; one withdrawn without a check, that the source failed validation. Undefined when the EV matches, is unchecked or computed, or has no check. Read it from the
  * fundamentals the rows show (atRegularSessionPrice moves the check with the EV and the market cap), so its figures
  * are theirs.
  */
@@ -97,14 +101,22 @@ export function enterpriseValueReconciliationNote(fundamentals: Parameters<typeo
   if (notMeaningful) return `EV N/M: ${notMeaningful.charAt(0).toLowerCase()}${notMeaningful.slice(1)}.`;
   const check = enterpriseValueCheck(fundamentals);
   if (!check && enterpriseValueWithdrawn(fundamentals)) return "EV unavailable: the provider's figure failed validation.";
+  const reason = check?.reason?.trim().replace(/\.$/, "");
+  if (check?.status === "withdrawn" && !finiteNumber(check.computed) && reason) {
+    return `EV unavailable: ${reason.charAt(0).toLowerCase()}${reason.slice(1)}.`;
+  }
   if (!check || !finiteNumber(check.computed) || !finiteNumber(check.source)
     || (check.status !== "differs" && check.status !== "withdrawn")) return undefined;
   const source = `${formatCompact(check.source)} ${check.currency}`;
   const computed = formatCompact(check.computed);
-  const basis = `market cap + total debt - cash${check.balanceSheetDate ? ` (balance sheet ${check.balanceSheetDate})` : ""}`;
+  const leases = finiteNumber(check.leases) && check.leases > 0 ? " + leases" : "";
+  const fx = check.fx && finiteNumber(check.fx.rate) ? `, ${check.fx.from} at ${check.fx.rate.toPrecision(4)} ${check.currency}` : "";
+  const sheet = check.balanceSheetDate ? ` (balance sheet ${check.balanceSheetDate}${fx})` : "";
+  const basis = `market cap + total debt${leases} - cash${sheet}`;
   if (check.status === "differs") return `EV ${source} (provider) vs ${computed} computed from ${basis}.`;
   const ratio = check.computed > 0 ? ` is ${(check.source / check.computed).toFixed(1)}x` : " is far from";
-  return `EV unavailable: the provider's ${source}${ratio} the ${computed} computed from ${basis}.`;
+  const twice = check.convertedTwice && check.convertedFrom ? `; it converts ${check.convertedFrom} to ${check.currency} twice` : "";
+  return `EV unavailable: the provider's ${source}${ratio} the ${computed} computed from ${basis}${twice}.`;
 }
 
 /**

package/src/utils/lease-liabilities.ts

@@ -0,0 +1,54 @@
+import type { FinancialStatement } from "../types/financials";
+
+/**
+ * How net debt treats the lease liabilities a listing's balance sheets report (docs/financial-ratios.md#leases):
+ *
+ * - `included`: added to total debt. IFRS 16 puts every lessee lease on the balance sheet and reports EBITDA before
+ *   lease costs, so leverage with the leases in is like for like (IAG's June 2026 balance sheet: 6.96bn of
+ *   borrowings, 6.91bn of leases, 9.18bn of cash).
+ * - `excluded`: a company reporting under US GAAP, whatever form it files (a 10-K, or a 20-F as BABA, PDD and JD
+ *   do). Its finance leases are already in total debt and its operating lease cost is in EBITDA, so its operating
+ *   leases stay out.
+ *
+ * The standard is the one Gloom Cloud reads from the issuer's latest annual report to the SEC
+ * (`accountingStandard`), the signal its enterprise value check bridges by. Where no row states it, a row dated by
+ * a 10-K or 10-Q (`dateSource: "sec"`) is US GAAP, and a company that files none with the SEC is IFRS.
+ */
+export type LeaseBasis = "included" | "excluded";
+
+type LeaseLines = Pick<FinancialStatement, "capitalLeaseObligations" | "dateSource" | "accountingStandard">;
+
+const finite = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
+
+/** The listing's lease basis, or undefined when no balance sheet on file reports lease liabilities. */
+export function leaseBasis(statements: Iterable<LeaseLines>): LeaseBasis | undefined {
+  let leases = false;
+  let standard: FinancialStatement["accountingStandard"];
+  let secDated = false;
+  for (const statement of statements) {
+    if (finite(statement.capitalLeaseObligations) && statement.capitalLeaseObligations > 0) leases = true;
+    standard ??= statement.accountingStandard;
+    if (statement.dateSource === "sec") secDated = true;
+  }
+  if (!leases) return undefined;
+  return (standard ? standard === "us-gaap" : secDated) ? "excluded" : "included";
+}
+
+/** Amounts are whole units; some providers round a leg to the thousand. */
+const close = (a: number, b: number) => Math.abs(a - b) <= Math.max(1_000, Math.abs(a) * 1e-6);
+
+/**
+ * A balance sheet's total debt and lease liabilities. A total that already holds the lease line (long-term and
+ * current debt plus leases) is read as the borrowings beside it, so the leases count once. Undefined without both
+ * lines: a missing lease line is never zero.
+ */
+export function debtAndLeases(
+  statement: Pick<FinancialStatement, "totalDebt" | "capitalLeaseObligations" | "longTermDebt" | "currentDebt">,
+): { totalDebt: number; leases: number } | undefined {
+  const total = statement.totalDebt;
+  const leases = statement.capitalLeaseObligations;
+  if (!finite(total) || !finite(leases) || leases < 0) return undefined;
+  const { longTermDebt: long, currentDebt: current } = statement;
+  const holds = leases > 0 && (finite(long) || finite(current)) && close(total, (long ?? 0) + (current ?? 0) + leases);
+  return { totalDebt: holds ? total - leases : total, leases };
+}