gloomberb 0.18.2 → 0.18.4

package/src/utils/decimal-comma.ts

@@ -20,6 +20,22 @@ export function numberErrorMessage(message: string, value: unknown): string {
   return dotted == null ? message : `${message.replace(/\.$/, "")}; use a dot: ${dotted}`;
 }
 
+/**
+ * What to tell someone who typed a decimal (`30,5` or `30.5`) for an option
+ * that takes only whole numbers: the whole numbers either side to type, never
+ * a decimal, so the way out is not itself refused ("--days takes whole days:
+ * 30 or 31, not "30,5"."). Null for text that is not a decimal number, or has
+ * no whole number at or above `minimum` beside it.
+ */
+export function wholeNumberOptionMessage(flag: string, noun: string, value: unknown, minimum = 1): string | null {
+  const text = typeof value === "number" ? String(value) : typeof value === "string" ? value.trim() : "";
+  const dotted = dottedDecimal(text) ?? text;
+  if (!/^[+-]?\d+\.\d+$/.test(dotted)) return null;
+  const number = Number(dotted);
+  const choices = [...new Set([Math.floor(number), Math.ceil(number)])].filter((choice) => choice >= minimum);
+  return choices.length > 0 ? `${flag} takes whole ${noun}: ${choices.join(" or ")}, not "${text}".` : null;
+}
+
 const DECIMAL_COMMA_RANGE = /^([+-]?\d+(?:,\d+)?)\s*(-|to|\.\.)\s*([+-]?\d+(?:,\d+)?)$/i;
 
 /**
@@ -155,6 +171,15 @@ export function readTypedNumber(value: unknown, label: string): number {
   return read.kind === "number" ? read.value : Number.NaN;
 }
 
+/** The refusal for an amount that reads two ways: both readings, the decimal one typed so it does not read two ways itself. */
+function ambiguousAmountError(value: unknown, reading: { thousands: number; decimal: number }, label: string, code: string): Error {
+  const decimal = String(reading.decimal);
+  const decimalAs = thousandsDotReadings(decimal) ? `${decimal}0` : decimal;
+  const digits = currencyMinorDigits(code);
+  const because = digits > 2 ? `${code} has ${digits} decimals` : undefined;
+  return new Error(`${label} ${ambiguousNumberMessage(String(value), reading, { because, decimalAs })}.`);
+}
+
 /**
  * A labelled amount of `currency` as `parseCurrencyAmount` reads it: the
  * number, or NaN when it is none. In a three-decimal currency `1,234` throws
@@ -164,15 +189,23 @@ export function readTypedNumber(value: unknown, label: string): number {
 export function readCurrencyAmount(value: unknown, label: string, currency: string): number {
   const code = currency.trim().toUpperCase();
   const read = parseCurrencyAmount(value, code);
-  if (read.kind === "ambiguous") {
-    const decimal = String(read.decimal);
-    const decimalAs = thousandsDotReadings(decimal) ? `${decimal}0` : decimal;
-    const because = `${code} has ${currencyMinorDigits(code)} decimals`;
-    throw new Error(`${label} ${ambiguousNumberMessage(String(value), read, { because, decimalAs })}.`);
-  }
+  if (read.kind === "ambiguous") throw ambiguousAmountError(value, read, label, code);
   return read.kind === "number" ? read.value : Number.NaN;
 }
 
+/**
+ * A labelled amount to convert (`fx 81,000 EUR/USD`) as `alerts add` reads a
+ * price: a comma and exactly three digits could be thousands or a decimal
+ * comma whatever the currency's minor units, so it throws naming both
+ * readings, the same string read the same way in both commands. Anything else
+ * reads as `readCurrencyAmount` reads it.
+ */
+export function readConvertedAmount(value: unknown, label: string, currency: string): number {
+  const read = parseTypedNumber(value);
+  if (read.kind === "ambiguous") throw ambiguousAmountError(value, read, label, currency.trim().toUpperCase());
+  return readCurrencyAmount(value, label, currency);
+}
+
 /** What a dot and exactly three digits after one to three (`81.000`, `81.250`) could mean. */
 export interface ThousandsDotReadings {
   /** The number as written, the dot a decimal point: 81. */

package/src/utils/exchange-announcements.ts

@@ -0,0 +1,71 @@
+import { listingSuffixExchange } from "../sources/listing-symbols";
+import { canonicalExchange, parsePublicTickerKey } from "./exchanges";
+
+/** Where a listing's company announcements are published: the venue's page for the company, or its disclosure search. */
+export interface ExchangeAnnouncementsPage {
+  /** "ASX announcements", "SEDAR+ filings": what the page is, for a reader. */
+  name: string;
+  url: string;
+}
+
+const EURONEXT = { name: "Euronext company news", url: "https://live.euronext.com/en/products/equities/company-news" };
+const SEDAR = { name: "SEDAR+ filings", url: "https://www.sedarplus.ca/landingpage/" };
+const NASDAQ_NORDIC = { name: "Nasdaq Nordic company news", url: "https://www.nasdaqomxnordic.com/news/companynews" };
+
+/**
+ * The page each venue abroad publishes its listed companies' announcements
+ * on. A venue whose site has a page per company gets the company's page
+ * (ASX, NZX); the others their regulator's or exchange's disclosure search,
+ * where the company is found by name or code.
+ */
+const PAGES: Readonly<Record<string, (code: string) => ExchangeAnnouncementsPage>> = {
+  ASX: (code) => ({ name: "ASX announcements", url: `https://www.asx.com.au/markets/trade-our-cash-market/announcements.${code.toLowerCase()}` }),
+  // Cboe Australia trades ASX companies under their ASX codes.
+  CXA: (code) => PAGES.ASX!(code),
+  NZX: (code) => ({ name: "NZX announcements", url: `https://www.nzx.com/companies/${encodeURIComponent(code)}/announcements` }),
+  TSX: () => SEDAR, TSXV: () => SEDAR, CSE: () => SEDAR, NEO: () => SEDAR,
+  LSE: () => ({ name: "London Stock Exchange RNS", url: "https://www.londonstockexchange.com/news?tab=news-explorer" }),
+  EPA: () => EURONEXT, AMS: () => EURONEXT, BRU: () => EURONEXT, LIS: () => EURONEXT, ISE: () => EURONEXT, OSL: () => EURONEXT, BIT: () => EURONEXT,
+  SFB: () => NASDAQ_NORDIC, HEL: () => NASDAQ_NORDIC, CPH: () => NASDAQ_NORDIC, ICEX: () => NASDAQ_NORDIC,
+  XETRA: () => ({ name: "Unternehmensregister", url: "https://www.unternehmensregister.de/" }),
+  FWB2: () => PAGES.XETRA!(""),
+  JPX: () => ({ name: "TDnet timely disclosures", url: "https://www.release.tdnet.info/inbs/I_main_00.html" }),
+  HKEX: () => ({ name: "HKEXnews", url: "https://www1.hkexnews.hk/search/titlesearch.xhtml?lang=en" }),
+  KRX: () => ({ name: "DART filings", url: "https://dart.fss.or.kr/" }),
+  KOSDAQ: () => PAGES.KRX!(""),
+  TWSE: () => ({ name: "MOPS filings", url: "https://mops.twse.com.tw/mops/web/index" }),
+  TPEX: () => PAGES.TWSE!(""),
+  NSE: () => ({ name: "NSE corporate announcements", url: "https://www.nseindia.com/companies-listing/corporate-filings-announcements" }),
+  BSE: () => ({ name: "BSE corporate announcements", url: "https://www.bseindia.com/corporates/ann.html" }),
+  SGX: () => ({ name: "SGX company announcements", url: "https://www.sgx.com/securities/company-announcements" }),
+  SET: () => ({ name: "SET company news", url: "https://www.set.or.th/en/market/news-and-alert/news" }),
+};
+
+/**
+ * The announcements page for a listing on a venue abroad: NST on
+ * ASX is ASX's announcements page for NST, a TSX listing SEDAR+. Null for a
+ * US venue and for a venue Gloom knows no page for.
+ */
+export function exchangeAnnouncementsPage(symbol: string, exchange: string | null | undefined): ExchangeAnnouncementsPage | null {
+  const page = PAGES[canonicalExchange(exchange ?? "")];
+  const code = symbol.trim().toUpperCase();
+  return page && code ? page(code) : null;
+}
+
+/** Whether Gloom Cloud lists the company's announcements on this venue (ASX). */
+export function listsExchangeAnnouncements(exchange: string | null | undefined): boolean {
+  const venue = canonicalExchange(exchange ?? "");
+  return venue === "ASX" || venue === "CXA";
+}
+
+/**
+ * `exchangeAnnouncementsPage` for a listing as a pane or command names it:
+ * NST:ASX, NST.AX, or NST with the venue beside it.
+ */
+export function listingAnnouncementsPage(key: string, exchange?: string | null): ExchangeAnnouncementsPage | null {
+  const parsed = parsePublicTickerKey(key.trim());
+  const suffixed = parsed.exchange ? null : listingSuffixExchange(parsed.symbol);
+  const venue = parsed.exchange || suffixed || exchange;
+  const symbol = suffixed ? parsed.symbol.replace(/\.[A-Z]+$/i, "") : parsed.symbol;
+  return venue ? exchangeAnnouncementsPage(symbol, venue) : null;
+}

package/src/utils/exchange-rate-snapshot.ts

@@ -1,3 +1,5 @@
+import { readIntradayBar, readStaleReason } from "../market-data/quotes/intraday-bar";
+import type { QuoteIntradayBar } from "../types/financials";
 import type { ExchangeRateSnapshot } from "../types/exchange-rate";
 import { fixedUsdRate } from "./currency-units";
 import { fxFreshUntil } from "./fx-market-hours";
@@ -13,6 +15,10 @@ interface FxRateMetadata {
   source?: string;
   /** How far the snapshot runs behind the market, as the source states it; 0 is real-time. */
   delayMinutes?: number;
+  /** The rate is the close of this bar of the pair's, not a print. */
+  intradayBar?: QuoteIntradayBar;
+  /** Why the rate stands when it reads stale, as the data service states it. */
+  staleReason?: string;
 }
 
 export function isUsableCachedExchangeRate(rate: number | null, currency: string,
@@ -57,6 +63,8 @@ export function exchangeRateMetadata(value: unknown, currency: string, now = Dat
   const delayMinutes = typeof data.delayMinutes === "number" && Number.isFinite(data.delayMinutes) && data.delayMinutes >= 0
     ? data.delayMinutes : undefined;
   const delay = Math.min(delayMinutes ?? 0, 15) * 60_000;
+  const intradayBar = readIntradayBar(data.intradayBar);
+  const staleReason = readStaleReason(data.staleReason);
   const staleAt = Math.min(declaredStaleAt ?? Infinity,
     fetchedAt === undefined ? Infinity : fxFreshUntil(fetchedAt, FX_FRESH_MS),
     asOf === undefined ? Infinity : fxFreshUntil(asOf, FX_FRESH_MS + delay),
@@ -68,5 +76,7 @@ export function exchangeRateMetadata(value: unknown, currency: string, now = Dat
     ...(Number.isFinite(staleAt) ? { staleAt } : {}),
     ...(typeof data.source === "string" ? { source: data.source } : {}),
     ...(delayMinutes !== undefined ? { delayMinutes } : {}),
+    ...(intradayBar ? { intradayBar } : {}),
+    ...(staleReason ? { staleReason } : {}),
   };
 }

package/src/utils/financial-statements.ts

@@ -1,4 +1,4 @@
-import type { FinancialStatement } from "../types/financials";
+import type { FinancialStatement, StatementFill, StatementFillField } from "../types/financials";
 import { copyIncomeField, incomeFieldOwner, INCOME_STATEMENT_FIELDS, isIncomeStatementField } from "./income-statement";
 import { mergeStatementGaps } from "./statement-gaps";
 
@@ -20,17 +20,93 @@ export function statementHistoryNotes(
   return period === "annual"
     ? [
       `annual history from ${oldest.slice(0, 4)}; older years not served`,
-      `earlier years, one metric at a time: gloomberb fn GF ${symbol} --period annual --periods 40`,
+      `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: gloomberb fn GF ${symbol} --period quarterly --periods 40`,
+      `earlier quarters, one metric at a time: gloom fn GF ${symbol} --period quarterly --periods 40`,
     ];
 }
 
+/** How old a statement's latest period may be before a report says how old it is. */
+const STALE_STATEMENT_MONTHS = 15;
+
+/** Whole months from a YYYY-MM-DD period end to `now`, in UTC. */
+function monthsSince(date: string, now: number): number | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(date);
+  if (!match) return null;
+  const today = new Date(now);
+  const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];
+  return (today.getUTCFullYear() - year) * 12 + (today.getUTCMonth() + 1 - month) - (today.getUTCDate() < day ? 1 : 0);
+}
+
+/**
+ * "Latest period 2024-06-30 is 27 months old.": what a statements report and
+ * FA say when the latest period with the statement's lead figure (revenue,
+ * total assets) ended more than 15 months ago, so a table that stops years
+ * back never reads as current (EVN:ASX's balance sheet stopped at 2024-06-30
+ * in October 2026). A newer period with only some figures (EVN's FY2025: EPS
+ * alone) is named as such. `periods` are the table's columns, any order; a
+ * column without a date (TTM) is not a period. Null when the latest period is
+ * recent, or no column has a date.
+ */
+export function stalePeriodNote(
+  periods: ReadonlyArray<{ date: string; lead: boolean }>,
+  now = Date.now(),
+): string | null {
+  const dated = periods.filter(({ date }) => /^\d{4}-\d{2}-\d{2}/.test(date)).map(({ date, lead }) => ({ date: date.slice(0, 10), lead }));
+  if (dated.length === 0) return null;
+  const newest = dated.reduce((latest, period) => (period.date > latest ? period.date : latest), "");
+  const lead = dated.filter((period) => period.lead).reduce((latest, period) => (period.date > latest ? period.date : latest), "") || newest;
+  const [year, month, day] = lead.split("-").map(Number) as [number, number, number];
+  // Over 15 months: past the same day 15 months on.
+  if (!(now > Date.UTC(year, month - 1 + STALE_STATEMENT_MONTHS, day, 23, 59, 59, 999))) return null;
+  const months = monthsSince(lead, now);
+  return `Latest period ${lead} is ${months} months old${newest > lead ? `; ${newest} has only some figures` : ""}.`;
+}
+
+const FILL_SOURCES: Record<StatementFill["source"], string> = { asx: "ASX key statistics" };
+const FILL_FIELDS: Record<StatementFillField, string> = {
+  totalRevenue: "revenue", netIncome: "net income", totalAssets: "total assets", totalLiabilities: "total liabilities",
+};
+
+/**
+ * "From ASX key statistics (read 2026-10-22): 2026-06-30 revenue, net income;
+ * 2025-06-30 revenue, net income.": the years a statements table shows that
+ * Gloom Cloud filled from the listing's exchange because the statements source
+ * does not have them yet, newest first, with the lines taken. `shown` keeps the
+ * lines the table has a row for. Null when no shown line was filled.
+ */
+export function filledPeriodsNote(
+  statements: readonly Pick<FinancialStatement, "date" | "filledFrom">[],
+  shown?: ReadonlySet<string>,
+): string | null {
+  const filled = statements.flatMap(({ date, filledFrom }) => {
+    const source = filledFrom && FILL_SOURCES[filledFrom.source];
+    const fields = (filledFrom?.fields ?? []).filter((field) => FILL_FIELDS[field] && (!shown || shown.has(field)));
+    return source && fields.length > 0 ? [{ date: date.slice(0, 10), source, fields, read: filledFrom.retrievedAt.slice(0, 10) }] : [];
+  }).sort((left, right) => right.date.localeCompare(left.date));
+  if (filled.length === 0) return null;
+  const read = filled.map((period) => period.read).sort().at(-1);
+  return `From ${filled[0]!.source} (read ${read}): ${filled.map(({ date, fields }) => `${date} ${fields.map((field) => FILL_FIELDS[field]).join(", ")}`).join("; ")}.`;
+}
+
+/**
+ * A merged row's fill, for the filled lines it still holds as the filled row
+ * gave them; a line another source's row supplied is that source's.
+ */
+function retainedFill(merged: FinancialStatement, rows: Array<FinancialStatement | undefined>): StatementFill | undefined {
+  for (const row of rows) {
+    const fill = row?.filledFrom;
+    const fields = fill?.fields.filter((field) => typeof merged[field] === "number" && Object.is(merged[field], row![field])) ?? [];
+    if (fill && fields.length > 0) return { ...fill, fields };
+  }
+  return undefined;
+}
+
 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"]);
+const STATEMENT_METADATA_KEYS = new Set(["date", "dateSource", "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. */
@@ -238,6 +314,9 @@ export function mergeFinancialStatementRows(
 
     // A gap either report declares for the period survives the other's value.
     mergeStatementGaps(merged, [row, fallback]);
+    const fill = retainedFill(merged, [row, fallback]);
+    if (fill) merged.filledFrom = fill;
+    else delete merged.filledFrom;
     // A fallback row-level date cannot safely date a different primary value.
     // Retained fallback fields still carry their own per-field provenance.
     for (const key of keys) if (!hasMetricValue(merged, key)) delete fieldAvailability[key];

package/src/utils/format.ts

@@ -1,4 +1,7 @@
-import { fixedUsdRate, minorUnitSign } from "./currency-units";
+import { fixedUsdRate, heldCurrencyUnit, minorUnitSign } from "./currency-units";
+
+/** What a cell or figure reads when the source gave no value; an export writes it as an empty cell. */
+export const MISSING_VALUE = "—";
 
 const currencyFormatters = new Map<string, Intl.NumberFormat>();
 const numberFormatters = new Map<number, Intl.NumberFormat>();
@@ -72,7 +75,7 @@ export function formatCurrency(
   currency = "USD",
   maximumFractionDigits: number = currencyPriceDigits(currency),
 ): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   return formatMoney(value, currency, maximumFractionDigits);
 }
 
@@ -87,7 +90,7 @@ export function formatCurrencyCode(
   currency = "USD",
   maximumFractionDigits: number = currencyPriceDigits(currency),
 ): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   if (minorUnitSign(currency)) return formatMoney(value, currency, maximumFractionDigits);
   const code = currency.trim().toUpperCase();
   const body = new Intl.NumberFormat("en-US", {
@@ -99,7 +102,7 @@ export function formatCurrencyCode(
 
 /** Preserve fractional per-share distributions, including split-adjusted history. */
 export function formatDistributionAmount(value: number | undefined, currency = "USD"): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   return formatMoney(value, currency, 6);
 }
 
@@ -112,20 +115,20 @@ function signedFixed(value: number, decimals: number): string {
 
 /** Format a number as percentage (e.g., +1.23%) */
 export function formatPercent(value: number | undefined): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   return `${signedFixed(value * 100, 2)}%`;
 }
 
 /** Format a level such as a yield or margin (0.0123 -> 1.23%). Levels are not changes, so they carry no sign. */
 export function formatLevelPercent(value: number | undefined): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   const fixed = (value * 100).toFixed(2);
   return `${/[1-9]/.test(fixed) ? fixed : fixed.replace("-", "")}%`;
 }
 
 /** Format a percentage that's already in percent form (e.g., 1.23 -> +1.23%) */
 export function formatPercentRaw(value: number | undefined): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   return `${signedFixed(value, 2)}%`;
 }
 
@@ -134,7 +137,7 @@ export function formatPercentRaw(value: number | undefined): string {
  * pass `fixedDecimals` so 1.70T lines up with 1.33T.
  */
 export function formatCompact(value: number | undefined, { fixedDecimals = false }: { fixedDecimals?: boolean } = {}): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   const { fixed, suffix } = compactParts(Math.abs(value));
   // Strip unnecessary trailing zeros after decimal point
   const trimmed = fixed.includes(".") && (!fixedDecimals || !suffix) ? fixed.replace(/\.?0+$/, "") : fixed;
@@ -170,7 +173,7 @@ function compactParts(abs: number): { fixed: string; suffix: string } {
  * carries + or -, except one that rounds to zero.
  */
 export function formatCompactAmount(value: number | undefined, { signed = false }: { signed?: boolean } = {}): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   const { fixed, suffix } = compactParts(Math.abs(value));
   if (!/[1-9]/.test(fixed)) return `${fixed}${suffix}`;
   const sign = value < 0 ? "-" : signed && value > 0 ? "+" : "";
@@ -183,13 +186,13 @@ export function formatCompactCurrency(
   currency = "USD",
   options: { fixedDecimals?: boolean } = {},
 ): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   return `${formatCompact(value, options)} ${currency}`;
 }
 
 /** Format a plain number with commas */
 export function formatNumber(value: number | undefined, decimals = 2): string {
-  if (value == null || !Number.isFinite(value)) return "—";
+  if (value == null || !Number.isFinite(value)) return MISSING_VALUE;
   return getNumberFormatter(decimals).format(value);
 }
 
@@ -235,7 +238,7 @@ export function pickUnit(values: (number | undefined)[]): { suffix: string; divi
 
 /** Format a number using a pre-determined divisor (no unit suffix) */
 export function formatWithDivisor(value: number | undefined, divisor: number): string {
-  if (value === undefined || value === null) return "—";
+  if (value === undefined || value === null) return MISSING_VALUE;
   const scaled = value / divisor;
   const abs = Math.abs(scaled);
   const decimals = abs >= 100 ? 1 : 2;
@@ -406,10 +409,26 @@ export function padTo(str: string, width: number, align: "left" | "right" | "cen
   return clipped + " ".repeat(padding);
 }
 
+/**
+ * USD per unit of a currency from USD-per-unit rates: the dollar and US cents
+ * (a grain future's USX) at their fixed rates, any other the market's; a
+ * minor unit (GBp, GBX, ZAc) without a rate of its own as its major
+ * currency's over its divisor.
+ */
+function usdPerUnit(currency: string, exchangeRates: Map<string, number>): number | undefined {
+  const own = fixedUsdRate(currency) ?? exchangeRates.get(currency);
+  if (own != null) return own;
+  const unit = heldCurrencyUnit(currency);
+  if (unit.divisor === 1) return undefined;
+  const major = fixedUsdRate(unit.currency) ?? exchangeRates.get(unit.currency);
+  return major == null ? undefined : major / unit.divisor;
+}
+
 /**
  * Convert using USD-per-unit rates. Missing FX remains unavailable (NaN), so
  * totals cannot silently mix source currency with base currency. Numeric
- * formatters render this as a dash and JSON encodes it as null.
+ * formatters render this as a dash and JSON encodes it as null. Pence (GBp,
+ * GBX) count a hundredth of a pound.
  */
 export function convertCurrency(
   value: number,
@@ -419,9 +438,8 @@ export function convertCurrency(
 ): number {
   if (!Number.isFinite(value)) return Number.NaN;
   if (fromCurrency === baseCurrency || value === 0) return value;
-  // The dollar and US cents (a grain future's USX) have fixed rates; any other is the market's.
-  const fromRate = fixedUsdRate(fromCurrency) ?? exchangeRates.get(fromCurrency);
-  const baseRate = fixedUsdRate(baseCurrency) ?? exchangeRates.get(baseCurrency);
+  const fromRate = usdPerUnit(fromCurrency, exchangeRates);
+  const baseRate = usdPerUnit(baseCurrency, exchangeRates);
   if (fromRate == null || baseRate == null || !Number.isFinite(fromRate) || !Number.isFinite(baseRate)
     || fromRate <= 0 || baseRate <= 0) return Number.NaN;
   return (value * fromRate) / baseRate;