@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/utils/cli-output.ts

@@ -1,3 +1,4 @@
+import { asciiText, localeReadsUtf8 } from "./ascii-text";
 type CliAlign = "left" | "right" | "center";
 
 export interface CliTableColumn {
@@ -45,6 +46,8 @@ export interface CliTableOptions {
   indent?: number;
   /** Lines printed under each row, by row index, indented and muted: a footnote that belongs to the row. */
   below?: ReadonlyArray<readonly string[] | undefined>;
+  /** Each line under a row stays one line, cut to the table's width, rather than wrapping: a story's summary. */
+  cutBelow?: boolean;
 }
 
 export type CliStatEntry = readonly [label: string, value: string];
@@ -73,7 +76,12 @@ const NUMBER_JOINER = /^(?:\/|·|→|↑|↓|[-–]|to|up|down)$/;
 const PLAIN_EMPTY_CELL = "—";
 let colorEnabledOverride: boolean | null = null;
 let widthOverride: number | null = null;
+/** The widths `COLUMNS` is taken at for piped output, as `--width` takes them; anything else is ignored. */
+const MIN_COLUMNS_VARIABLE = 20;
+const MAX_COLUMNS_VARIABLE = 1000;
 let plainOverride: boolean | null = null;
+/** Whether the terminal reads only ASCII (`localeReadsUtf8`); undefined until first asked. */
+let asciiLocale: boolean | undefined;
 /** Output is being rendered for a file (`renderForFile`), which has no terminal width. */
 let renderingForFile = false;
 
@@ -143,6 +151,23 @@ export function cliPlainEnabled(): boolean {
   return plainOverride === true;
 }
 
+/** Tests say whether the terminal reads only ASCII; null asks the environment again. */
+export function setCliAsciiLocaleOverride(value: boolean | null): void {
+  asciiLocale = value ?? undefined;
+}
+
+/**
+ * Plain output to a terminal that cannot show UTF-8 (a C locale, a Windows
+ * code page such as 437): it is written in ASCII (`asciiText`), so a dash, a
+ * euro or a cent sign does not print as `—`. Output rendered for a file
+ * keeps its UTF-8.
+ */
+export function cliAsciiEnabled(): boolean {
+  if (plainOverride !== true || renderingForFile) return false;
+  asciiLocale ??= !localeReadsUtf8();
+  return asciiLocale;
+}
+
 /**
  * Whether output is plain without `--plain` or `--no-plain`: NO_COLOR is set
  * to a value (an empty one is unset, as the convention says), or stdout is
@@ -185,14 +210,20 @@ export function plainWords(text: string): string {
 }
 
 /** A table header's sort mark in words: `MKT VAL ▼` is "MKT VAL (sorted descending)". */
-function plainHeader(header: string): string {
+function plainHeader(header: string, ascii: boolean): string {
   const sorted = header.replace(/\s*([▲▼])\s*$/, (_match, mark: string) => ` (sorted ${mark === "▲" ? "ascending" : "descending"})`);
-  return plainWords(sorted.trimStart());
+  const worded = plainWords(sorted.trimStart());
+  return ascii ? asciiText(worded) : worded;
 }
 
-/** A plain table's cell: arrows in words, and "—" for no value. */
-function plainCell(cell: string): string {
-  return EMPTY_CELL.test(stripAnsi(cell).trim()) ? PLAIN_EMPTY_CELL : plainWords(cell);
+/**
+ * A plain table's cell: arrows in words, and "—" for no value. In ASCII
+ * (`cliAsciiEnabled`) before the columns are measured, so `EUR211.25` lines
+ * up as `€211.25` did.
+ */
+function plainCell(cell: string, ascii: boolean): string {
+  const plain = EMPTY_CELL.test(stripAnsi(cell).trim()) ? PLAIN_EMPTY_CELL : plainWords(cell);
+  return ascii ? asciiText(plain) : plain;
 }
 
 function applyAnsi(text: string, code: string): string {
@@ -217,11 +248,24 @@ export function setCliWidthOverride(value: number | null): void {
 /** Columns the output is fitted to: `--width`, else the terminal's, or null when output is piped or redirected. */
 export function cliTerminalWidth(): number | null {
   if (widthOverride != null) return widthOverride;
-  if (renderingForFile || !process.stdout.isTTY) return null;
+  if (renderingForFile) return null;
+  if (!process.stdout.isTTY) return columnsVariable();
   const columns = process.stdout.columns;
   return typeof columns === "number" && columns > 0 ? columns : null;
 }
 
+/**
+ * `COLUMNS=60 gloom ... | less`: piped output is fitted to the width the
+ * variable sets, as `--width` does, so a screen reader or a pager gets the
+ * same narrow layout a terminal does. Unset or not a width, output stays whole.
+ */
+function columnsVariable(): number | null {
+  const value = process.env.COLUMNS?.trim();
+  if (!value || !/^\d+$/.test(value)) return null;
+  const columns = Number(value);
+  return columns >= MIN_COLUMNS_VARIABLE && columns <= MAX_COLUMNS_VARIABLE ? columns : null;
+}
+
 function padDisplay(text: string, width: number, align: CliAlign = "left"): string {
   const padding = Math.max(0, width - visibleLength(text));
   if (padding === 0) return text;
@@ -263,7 +307,8 @@ export function truncateDisplay(text: string, width: number): string {
 
 /**
  * Word-wraps text to `width` cells. Lines that already fit are kept verbatim, so aligned
- * columns survive; continuation lines keep the paragraph's leading indent.
+ * columns survive; continuation lines keep the paragraph's leading indent, and words on one
+ * line keep the spaces between them (a heading's `  ·  `).
  */
 export function wrapText(text: string, width: number): string[] {
   const lines: string[] = [];
@@ -273,7 +318,13 @@ export function wrapText(text: string, width: number): string[] {
       continue;
     }
     const indent = /^ */.exec(paragraph)![0];
-    const words = paragraph.slice(indent.length).split(/ +/).filter(Boolean);
+    // Each word with the spaces before it, which a line break drops. A separator (`·`) ends its line, never starts one.
+    const words: { gap: string; word: string }[] = [];
+    for (const [, gap, word] of paragraph.slice(indent.length).matchAll(/( *)([^ ]+)/g)) {
+      const last = words.at(-1);
+      if (last && word === "·") last.word += `${gap}${word}`;
+      else words.push({ gap: gap!, word: word! });
+    }
     if (words.length === 0) {
       lines.push("");
       continue;
@@ -281,16 +332,16 @@ export function wrapText(text: string, width: number): string[] {
     let line = indent;
     let lineWidth = indent.length;
     let lineHasWord = false;
-    for (const word of words) {
+    for (const { gap, word } of words) {
       const wordWidth = visibleLength(word);
-      if (lineHasWord && lineWidth + 1 + wordWidth > width) {
+      if (lineHasWord && lineWidth + gap.length + wordWidth > width) {
         lines.push(line);
         line = indent;
         lineWidth = indent.length;
         lineHasWord = false;
       }
-      line += lineHasWord ? ` ${word}` : word;
-      lineWidth += (lineHasWord ? 1 : 0) + wordWidth;
+      line += lineHasWord ? `${gap}${word}` : word;
+      lineWidth += (lineHasWord ? gap.length : 0) + wordWidth;
       lineHasWord = true;
     }
     lines.push(line);
@@ -512,6 +563,22 @@ function wrapCell(text: string, width: number): string[] {
   });
 }
 
+/**
+ * The columns that say what a row is: the leading ones up to the first figure
+ * after a word (`#`, Coin and Name before Price; Symbol and Name before Last).
+ */
+function rowIdentityColumns(columns: readonly CliTableColumn[]): Set<number> {
+  const identity = new Set<number>();
+  let named = false;
+  for (const [index, column] of columns.entries()) {
+    const figure = column.align === "right";
+    if (figure && named) break;
+    identity.add(index);
+    named ||= !figure;
+  }
+  return identity;
+}
+
 interface TableLayout {
   kept: TableEntry[];
   stacked: TableEntry[];
@@ -532,13 +599,18 @@ function movesSooner(left: readonly number[], right: readonly number[]): boolean
  * (a name, a title) before dates and figures, then rightmost first. The
  * first column stays. The list ends at the first layout that keeps every
  * column it shows whole on one line: moving more only adds lines.
+ *
+ * Plain output (`--plain`, read aloud by a screen reader) keeps the columns
+ * that say what a row is on its first line, after only the ones too wide to
+ * sit there: a row is heard as "BTC Bitcoin" before its figures.
  */
-function tableLayouts(entries: TableEntry[], available: number): TableLayout[] {
+function tableLayouts(entries: TableEntry[], available: number, identity: ReadonlySet<number> = new Set()): TableLayout[] {
   const fit = (kept: TableEntry[]) => fitColumnWidths(kept.map((entry) => entry.width), kept.map((entry) => entry.floor), available);
   const first = entries[0]!;
   const room = available - first.floor - COLUMN_GAP;
   const order = (entry: TableEntry) => [
     entry.floor > room ? 1 : 0,
+    identity.has(entry.index) ? 0 : 1,
     entry.column.stackPriority ?? 0,
     entry.text && entry.width > SOFT_MIN_COLUMN_WIDTH ? 1 : 0,
     entry.index,
@@ -601,7 +673,7 @@ function renderTableLayout(
   const belowIndent = `${indent}${" ".repeat(COLUMN_GAP)}`;
   const belowWidth = Math.max(1, (available ?? 0) - COLUMN_GAP);
   const renderBelow = (index: number) => (options.below?.[index] ?? []).flatMap((line) => (
-    available == null ? [line] : wrapText(line, belowWidth)
+    available == null ? [line] : options.cutBelow ? [truncateDisplay(line, belowWidth)] : wrapText(line, belowWidth)
   )).map((line) => `${belowIndent}${cliStyles.muted(line)}`.trimEnd());
   // Columns moved under the rows print there as `Header value`, as many to a line as fit.
   const renderStacked = (cells: string[], rowIndex: number): string[] => {
@@ -645,9 +717,10 @@ function renderTableLayout(
  */
 export function renderTable(columns: CliTableColumn[], rows: string[][], options: CliTableOptions = {}): string {
   if (cliPlainEnabled()) {
-    columns = columns.map((column) => ({ ...column, header: plainHeader(column.header) }));
-    rows = rows.map((row) => columns.map((_, index) => plainCell(row[index] ?? "")));
-    if (options.below) options = { ...options, below: options.below.map((lines) => lines?.map(plainWords)) };
+    const ascii = cliAsciiEnabled();
+    columns = columns.map((column) => ({ ...column, header: plainHeader(column.header, ascii) }));
+    rows = rows.map((row) => columns.map((_, index) => plainCell(row[index] ?? "", ascii)));
+    if (options.below) options = { ...options, below: options.below.map((lines) => lines?.map((line) => ascii ? asciiText(plainWords(line)) : plainWords(line))) };
   }
   const maxWidth = options.maxWidth === undefined ? cliTerminalWidth() : options.maxWidth;
   const available = maxWidth == null ? null : maxWidth - (options.indent ?? 0);
@@ -674,7 +747,7 @@ export function renderTable(columns: CliTableColumn[], rows: string[][], options
   });
   let best = "";
   let bestLines = Infinity;
-  for (const layout of tableLayouts(entries, available)) {
+  for (const layout of tableLayouts(entries, available, cliPlainEnabled() ? rowIdentityColumns(columns) : undefined)) {
     const stacked = layout.stacked.filter((entry) => entry.column.stackRows !== 0).sort((left, right) => left.index - right.index);
     const text = renderTableLayout(columns, rows, options, layout.kept, stacked, available, true);
     const lines = text.split("\n").length;

package/src/utils/concurrency.ts

@@ -23,3 +23,27 @@ export function chunked<T>(items: readonly T[], size: number): T[][] {
   for (let index = 0; index < items.length; index += size) chunks.push(items.slice(index, index + size));
   return chunks;
 }
+
+/**
+ * One gate that every caller shares: at most `limit` tasks run at once, and
+ * the rest wait in the order they came. Unlike mapWithConcurrency, separate
+ * callers (two panes, a pane and a report) count against the same limit. A
+ * finished task hands its slot straight to the next waiting one, so a caller
+ * arriving in between never takes it.
+ */
+export function createConcurrencyLimiter(limit: number): <T>(task: () => Promise<T>) => Promise<T> {
+  const slots = Math.max(1, Math.floor(limit));
+  let active = 0;
+  const waiting: Array<() => void> = [];
+  return async (task) => {
+    if (active < slots) active += 1;
+    else await new Promise<void>((resolve) => waiting.push(resolve));
+    try {
+      return await task();
+    } finally {
+      const next = waiting.shift();
+      if (next) next();
+      else active -= 1;
+    }
+  };
+}

package/src/utils/exchanges.ts

@@ -93,6 +93,12 @@ export function isKnownExchangeCode(value?: string): boolean {
   return !!normalized && KNOWN_EXCHANGE_CODES.has(normalized);
 }
 
+/** "Warsaw Stock Exchange" for a venue with a name, the canonical code otherwise (NASDAQ, whose name is its code). */
+export function exchangeName(value?: string): string {
+  const code = canonicalExchange(value);
+  return EXCHANGE_NAMES[code] ?? code;
+}
+
 /** "Euronext Paris (EPA)" for a venue with a name, the canonical code otherwise. */
 export function exchangeLabel(value?: string): string {
   const code = canonicalExchange(value);

package/src/utils/external-url.ts

@@ -1,14 +1,13 @@
 /**
  * Scheme validation for links handed to the operating system.
  *
- * Opening a link natively means spawning `open` / `xdg-open` / `cmd /c start`
- * with a string that usually came from an external feed: RSS items, prediction
- * markets, news, filings, Substack. Two things make an unvalidated string
- * dangerous there — `file://` launches local content, and Windows routes the
- * argument through cmd's parser.
+ * Opening a link natively means spawning `open` / `xdg-open` / `rundll32` with
+ * a string that usually came from an external feed: RSS items, prediction
+ * markets, news, filings, Substack. `file://` and the other local schemes
+ * launch local content, so only http(s) goes through.
  *
- * Restricting to http(s) removes both. Returns the normalised URL so callers
- * spawn the parsed form rather than the raw input.
+ * Returns the normalised URL so callers spawn the parsed form rather than the
+ * raw input.
  */
 export function safeExternalUrl(value: string): string | null {
   if (!value.trim()) return null;
@@ -22,3 +21,17 @@ export function safeExternalUrl(value: string): string | null {
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
   return parsed.toString();
 }
+
+/**
+ * The command that hands an http(s) link to the system's own opener, with the
+ * link as the last argument, or null for any other link. Windows opens it
+ * through `url.dll` rather than `cmd /c start`: `&`, `|`, `^` and `%` are part
+ * of a link, and a command line would read them as its own.
+ */
+export function systemOpenCommand(rawUrl: string, platform: NodeJS.Platform): string[] | null {
+  const url = safeExternalUrl(rawUrl);
+  if (!url) return null;
+  if (platform === "darwin") return ["open", url];
+  if (platform === "win32") return ["rundll32.exe", "url.dll,FileProtocolHandler", url];
+  return ["xdg-open", url];
+}

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/futures-generic.ts

@@ -170,9 +170,9 @@ export function futuresGenericPriceBasis(generic: Pick<FuturesGeneric, "root">):
 
 /**
  * How a futures listing's price reads, whichever form it takes: a generic by
- * its root (VX1 points, TY1 32nds), and a continuous (`ES=F`, `SXO=F`) or
- * listed contract (`SXOZ26.CME`) of an index, sector or industry root in index
- * points, on the root's own venue or with none. The quote keeps its currency
+ * its root (VX1 points, TY1 32nds), and a continuous (`ES=F`, `ZN=F`) or
+ * listed contract (`ZNZ26.CBT`) in the same units as its root's generic,
+ * on the root's own venue or with none. The quote keeps its currency
  * for what a tick is worth. Null for every other listing, a security that
  * shares a root's code on another venue (XAU on Toronto, the XAR ETF) included.
  */
@@ -180,7 +180,7 @@ export function futuresListingPriceBasis(symbol: string, exchange?: string | nul
   const generic = futuresGenericListing(symbol, exchange);
   if (generic) return futuresGenericPriceBasis(generic);
   const listing = futuresListingVenue(symbol, exchange);
-  return listing?.root && ROOT_VENUES[listing.root] === listing.venue && POINT_ROOTS.has(listing.root) ? "points" : null;
+  return listing?.root && ROOT_VENUES[listing.root] === listing.venue ? futuresGenericPriceBasis({ root: listing.root }) : null;
 }
 
 /** Whether a root's date rules count back from first notice or from last trade. */

package/src/utils/http-proxy-upstream.ts

@@ -0,0 +1,124 @@
+import type { ProxiedRequestInit } from "./http-proxy-response";
+
+/** Set by the caller's browser or meaningful only to the hop it came from. */
+const STRIPPED_REQUEST_HEADERS = new Set([
+  "connection",
+  "content-length",
+  "host",
+  "keep-alive",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+]);
+/** Dropped when a redirect leaves the origin the plugin set them for. */
+const CROSS_ORIGIN_STRIPPED_HEADERS = ["authorization", "cookie", "proxy-authorization"];
+/** Dropped when a redirect turns the request into a bodiless GET. */
+const REQUEST_BODY_HEADERS = ["content-encoding", "content-language", "content-location", "content-type"];
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+const MAX_REDIRECTS = 5;
+
+/** Whether a proxy may reach a URL: the URL to fetch, or why not and the status to answer with. */
+export type ProxyTargetCheck = (url: string) => ProxyTargetVerdict | Promise<ProxyTargetVerdict>;
+type ProxyTargetVerdict = { url: URL } | { error: string; status: number };
+
+export type ProxyUpstreamResult = { response: Response } | { error: string; status: number };
+
+function upstreamHeaders(raw: Record<string, string>): Headers {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(raw)) {
+    if (STRIPPED_REQUEST_HEADERS.has(name.toLowerCase())) continue;
+    try {
+      headers.set(name, value);
+    } catch {
+      // Intentional ignore: a header name the runtime refuses is dropped, as a browser drops an unsettable header.
+    }
+  }
+  return headers;
+}
+
+/**
+ * Fetches a proxied plugin request, following redirects one hop at a time
+ * instead of letting `fetch` do it, so every `Location` passes the same
+ * `check` as the first URL. A host that redirects elsewhere (an open
+ * redirect, a moved API) would otherwise carry the request anywhere.
+ *
+ * Method and header handling mirror the Fetch spec: 303, and 301/302 after a
+ * POST, become a bodiless GET; credentials the plugin set are dropped when the
+ * redirect leaves the origin they were meant for.
+ */
+export async function fetchCheckingRedirects(
+  first: URL,
+  init: ProxiedRequestInit,
+  options: { fetch: typeof fetch; check: ProxyTargetCheck; signal: AbortSignal },
+): Promise<ProxyUpstreamResult> {
+  const headers = upstreamHeaders(init.headers);
+  const mode = init.redirect ?? "follow";
+  let url = first;
+  let method = init.method;
+  let body = init.body;
+
+  for (let followed = 0; ; followed += 1) {
+    const response = await options.fetch(url, { method, headers, body, redirect: "manual", signal: options.signal });
+    const location = REDIRECT_STATUSES.has(response.status) ? response.headers.get("location") : null;
+    // "manual" hands the redirect back to the plugin. If it follows it, that
+    // comes back through here as a new request and is checked like one.
+    if (location === null || mode === "manual") return { response };
+
+    await response.body?.cancel().catch(() => { /* Intentional ignore: the redirect's own body is never read, only dropped. */ });
+    if (mode === "error") return { error: "The upstream response was a redirect.", status: 502 };
+    if (followed >= MAX_REDIRECTS) return { error: "The upstream redirected too many times.", status: 502 };
+
+    let next: string;
+    try {
+      next = new URL(location, url).href;
+    } catch {
+      // Intentional ignore: a Location that does not parse is reported as an invalid redirect, never followed.
+      return { error: "The upstream sent an invalid redirect.", status: 502 };
+    }
+    const target = await options.check(next);
+    if ("error" in target) return { error: `The upstream redirect was refused. ${target.error}`, status: 502 };
+
+    if (target.url.origin !== url.origin) {
+      for (const name of CROSS_ORIGIN_STRIPPED_HEADERS) headers.delete(name);
+    }
+    if (
+      (response.status === 303 && method !== "GET" && method !== "HEAD")
+      || ((response.status === 301 || response.status === 302) && method === "POST")
+    ) {
+      method = "GET";
+      body = undefined;
+      for (const name of REQUEST_BODY_HEADERS) headers.delete(name);
+    }
+    url = target.url;
+  }
+}
+
+/**
+ * Reads a body, giving up once it passes `maxBytes`. Returns null when it was
+ * too large, after cancelling the stream so the rest is never pulled.
+ */
+export async function readBytesWithin(body: ReadableStream<Uint8Array> | null, maxBytes: number): Promise<Uint8Array | null> {
+  if (!body) return new Uint8Array(0);
+  const reader = body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > maxBytes) {
+      await reader.cancel().catch(() => { /* Intentional ignore: the rest of a body past the cap is dropped unread. */ });
+      return null;
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}