gloomberb 0.18.3 → 0.18.4

package/src/cli/desktop-pane-shot-view.ts

@@ -24,8 +24,8 @@ export const SHOT_VIEW_SCRIPT = "cli-pane-shot-entry.js";
 export const SHOT_VIEW_STYLESHEET = "styles.css";
 export const SHOT_VIEW_ARCHIVE = "shot-view.json.gz";
 
-const MISSING_VIEW_MESSAGE = "This copy of Gloomberb cannot draw panes: it was built without the page they are drawn in. "
-  + "Reinstall or update Gloomberb. The standalone gloomberb binary "
+const MISSING_VIEW_MESSAGE = "This copy of Gloom cannot draw panes: it was built without the page they are drawn in. "
+  + "Reinstall or update Gloom. The standalone gloom binary "
   + "(https://github.com/gloom-sh/gloomberb/releases/latest) also includes it.";
 
 let prebuiltArchive: string | null = null;

package/src/cli/desktop-pane-shot.ts

@@ -257,7 +257,7 @@ function shotPageHtml(view: ShotViewFiles, payload: DesktopPaneShotPayload): str
   return renderElectrobunViewHtml({
     stylesheet: view.get(SHOT_VIEW_STYLESHEET) ?? "",
     entrySrc: `./${SHOT_VIEW_SCRIPT}`,
-    title: "Gloomberb Pane Shot",
+    title: "Gloom Pane Shot",
     loadingText: "Rendering pane...",
     bootstrapScript: `
       window.__GLOOM_CLI_SHOT_PAYLOAD__ = ${payloadJson};

package/src/cli/earnings-calendar.ts

@@ -1,15 +1,15 @@
 import { logFailure } from "../utils/log-failure";
 import type { EarningsEvent } from "../types/data-provider";
+import type { EarningsDateStatus } from "../types/financials";
 import { isUsListingExchange } from "../utils/exchanges";
 import { listingChoiceNote, loadListingQuote, usLineOfListing, type CliListing, type ListingDeps, type ListingVenue } from "./listing-arg";
 import { sameCompany } from "../tickers/company-name";
 
 const DAY_MS = 86_400_000;
 
-/** How firm a report date is: "reported" once there is an actual, else "est" or "confirmed" as the calendar flags it. */
-export function earningsDateLabel(event: Pick<EarningsEvent, "isDateEstimate" | "epsActual">): string {
-  if (event.epsActual != null) return "reported";
-  return event.isDateEstimate === true ? "est" : event.isDateEstimate === false ? "confirmed" : "";
+/** How firm a report date is, as resolved (shared/earnings-calendar): reported, confirmed, or est for a projected one. */
+export function earningsDateLabel(status: EarningsDateStatus | null): string {
+  return status === "projected" ? "est" : status ?? "";
 }
 
 /** Whether the listing trades abroad, where the calendar is the listing's own exchange's rather than the US one. */

package/src/cli/entry.ts

@@ -1,12 +1,15 @@
-import { dispatchCli, failUnknownCliCommand } from "./index";
+import "./opentui-libc";
 import { inferCliErrorOptions, printCliError } from "./errors";
 import { isCliHelpFlag } from "./options";
+import { plainByDefault, setCliPlainOverride } from "../utils/cli-output";
 import { loadExternalPlugins } from "../plugins/loader";
 import { restoreExtractedPlugins } from "./restore-plugins";
 import { measurePerfAsync } from "../utils/perf-marks";
 import { flushCrashReports, reportCrash } from "../telemetry/crash-reports";
 import { CRASH_REPORT_EXIT_FLUSH_MS } from "../telemetry/crash-reports-node";
 import type { CliLaunchRequest } from "../types/plugin";
+import { detectUpdateAction } from "../updater";
+import { linkStandaloneCommand } from "../updater/command-names";
 import {
   OPEN_TUI_NATIVE_SMOKE_COMMAND,
   OPEN_TUI_RUNTIME_SMOKE_COMMAND,
@@ -19,6 +22,10 @@ import {
 } from "./native-smoke";
 
 async function launchOpenTuiApp(cliLaunchRequest: CliLaunchRequest | null = null): Promise<void> {
+  // Before anything in the app can reach for the render library, so a temp
+  // folder that cannot run it is worked around (or named) first.
+  const { loadRenderLib } = await import("../renderers/opentui/render-lib");
+  await measurePerfAsync("startup.opentui.render-lib", loadRenderLib);
   const { startOpenTuiApp } = await import("../renderers/opentui/start");
   // Before the catalog is read, so a plugin that moved out of this repository is
   // available in the same session rather than only after a restart.
@@ -58,11 +65,21 @@ export async function runCliEntrypoint(rawArgs = process.argv.slice(2)): Promise
     process.exit(0);
   }
 
+  // The standalone binary updates by replacing itself, so one installed as
+  // `gloomberb` before the rename gets `gloom` beside it here.
+  if (detectUpdateAction()?.kind === "self") linkStandaloneCommand(process.execPath);
+
   if (!command || ((command === "launch-ui" || command === "ui") && !rawArgs.some(isCliHelpFlag))) {
     await launchOpenTuiApp();
     return;
   }
 
+  // Loaded only for a command: a bare launch never reads the commands, and
+  // their modules are a noticeable part of what it would load before drawing.
+  const { dispatchCli, failUnknownCliCommand } = await import("./index");
+  // For a screen reader, a pipe or NO_COLOR: no rule lines, arrows in words, fixed table columns. Set
+  // for this process only; `--plain` / `--no-plain` decide it in dispatchCli, and commands run in-process keep theirs.
+  setCliPlainOverride(plainByDefault());
   const externalPlugins = await loadExternalPlugins();
   const dispatchResult = await dispatchCli(rawArgs, { externalPlugins });
   if (dispatchResult.kind === "handled") return;

package/src/cli/errors.ts

@@ -5,17 +5,29 @@ import { serializeCliError, type CliErrorObject } from "./result";
 import { cliStyles, cliTerminalWidth, wrapText } from "../utils/cli-output";
 import { withSearchHints, type FredSeriesCheck } from "./not-a-ticker";
 import { isProviderBusy, SEARCH_BUSY_CODE, SEARCH_BUSY_MESSAGE } from "../sources/provider-errors";
+import { DATA_SERVICE_UNREACHABLE_MESSAGE, isNetworkFailure } from "../utils/network-failure";
 
 const USAGE_PREFIX = "Usage: ";
 /** The code of every error a command fails with: bad input, nothing found, an option it does not take. */
 const CLI_ERROR_CODE = "cli_error";
+/** The code of a command whose requests never reached the data service. */
+const SERVICE_UNREACHABLE_CODE = "service_unreachable";
+
+/** What to check when nothing answered: the connection, and the proxy when one is set. */
+function unreachableHint(): string {
+  const env = typeof process === "undefined" ? {} : process.env;
+  const proxy = ["HTTPS_PROXY", "https_proxy", "ALL_PROXY", "all_proxy"].find((name) => env[name]?.trim());
+  return proxy
+    ? `Check the internet connection and the proxy in ${proxy}, then try again.`
+    : "Check the internet connection, then try again.";
+}
 
 export interface CliErrorContext {
   /** The command that failed, used to point at its help. */
   command?: string;
   /** What the user typed after the command, so a hint can repeat their own spelling of a symbol. */
   args?: readonly string[];
-  /** Which symbols are FRED series the catalog charts, so their hint is `gloomberb fred`. */
+  /** Which symbols are FRED series the catalog charts, so their hint is `gloom fred`. */
   isFredSeries?: FredSeriesCheck;
 }
 
@@ -82,6 +94,10 @@ function cliErrorObject(error: unknown): CliErrorObject {
   if (isProviderBusy(error)) {
     return { code: SEARCH_BUSY_CODE, message: SEARCH_BUSY_MESSAGE, retryable: true };
   }
+  // No answer came back at all: in Gloom's words, whichever fetch failed (Bun's "Unable to connect", a refused proxy).
+  if (isNetworkFailure(error)) {
+    return { code: SERVICE_UNREACHABLE_CODE, message: DATA_SERVICE_UNREACHABLE_MESSAGE, details: unreachableHint(), retryable: true };
+  }
   // Gloom Cloud refused what was asked (an unknown series, a bad date): the input was wrong, not the program.
   if (error instanceof ApiRequestError && error.status === 400) {
     return { code: CLI_ERROR_CODE, message: error.message };
@@ -102,6 +118,8 @@ export function inferCliErrorOptions(rawArgs: string[]): CliGlobalOptions {
     if (arg === "--quiet" || arg === "-q") options.quiet = true;
     if (arg === "--no-color") options.color = false;
     if (arg === "--color") options.color = true;
+    if (arg === "--plain") options.plain = true;
+    if (arg === "--no-plain") options.plain = false;
   }
   return options;
 }
@@ -117,7 +135,7 @@ function formatCliErrorText(error: CliErrorObject, context: CliErrorContext): st
       ...details.map((line) => cliStyles.muted(line)),
     ];
     if (context.command) {
-      lines.push(cliStyles.muted(`Run gloomberb help ${context.command} for details.`));
+      lines.push(cliStyles.muted(`Run gloom help ${context.command} for details.`));
     }
     return lines.join("\n");
   }

package/src/cli/exit-codes.ts

@@ -1,4 +1,4 @@
-/** What `gloomberb <command>` exits with, as `gloomberb help` lists them. */
+/** What `gloom <command>` exits with, as `gloom help` lists them. */
 export const CLI_EXIT_CODES = {
   ok: 0,
   /** Bad input, nothing found, a failed check, or an unexpected error. */

package/src/cli/export-source.ts

@@ -3,7 +3,7 @@
  * writes CSV or JSON, so an export can go in an audit file as it is: CSV ends
  * with `#` lines and JSON carries a `source` object with the same fields.
  * CSV and NDJSON rows also end with five fixed columns naming what each row
- * is (`EXPORT_IDENTITY_COLUMNS`).
+ * is (`EXPORT_IDENTITY_COLUMNS`), less any the table already has by name.
  */
 import { formatFreshnessLine, type ReportFreshness } from "./pane-functions/freshness";
 import { parseReportTime } from "../utils/utc-time";
@@ -28,16 +28,20 @@ export interface ExportSource {
   publicationTime: string | null;
   /** When the data was retrieved for this export: an ISO instant in UTC. */
   retrievalTime: string;
+  /** Refreshing the data failed and a copy saved earlier answered: when it was saved, an ISO instant in UTC. */
+  savedTime?: string;
 }
 
 export function exportSource(freshness: ReportFreshness): ExportSource {
   return {
     name: freshness.source,
     publisher: freshness.publisher ?? null,
-    observationDate: freshness.asOf,
+    // A figure as of its release is still dated by the period it covers; the release is its publication time.
+    observationDate: freshness.referencePeriod ?? freshness.asOf,
     ...(freshness.oldestObservation ? { oldestObservationDate: freshness.oldestObservation } : {}),
-    publicationTime: freshness.publishedAt ?? null,
+    publicationTime: freshness.publishedAt ?? (freshness.referencePeriod ? freshness.asOf : null),
     retrievalTime: freshness.retrievedAt,
+    ...(freshness.savedAt ? { savedTime: freshness.savedAt } : {}),
   };
 }
 
@@ -100,7 +104,8 @@ export function exportIdentityFields(freshness: ReportFreshness, identity: Expor
  * The lines an export ends with: the source line the text report ends with,
  * then the publisher, observation date (the newest; the oldest follows when
  * the data cites it), publication time and retrieval time, each `not
- * published` when the data does not say.
+ * published` when the data does not say, and when the copy was saved when a
+ * saved copy answered because refreshing it failed.
  */
 export function exportSourceLines(freshness: ReportFreshness): string[] {
   const source = exportSource(freshness);
@@ -112,5 +117,6 @@ export function exportSourceLines(freshness: ReportFreshness): string[] {
     ...(source.oldestObservationDate ? [`Oldest observation: ${source.oldestObservationDate}`] : []),
     `Publication time: ${stated(source.publicationTime)}`,
     `Retrieval time: ${source.retrievalTime}`,
+    ...(source.savedTime ? [`Saved time: ${source.savedTime}`] : []),
   ];
 }

package/src/cli/freshness.ts

@@ -1,9 +1,9 @@
-import type { FinancialStatement, Quote, TickerFinancials } from "../types/financials";
+import type { Quote, TickerFinancials } from "../types/financials";
 import type { HeadlessPaneFreshness, HeadlessPaneRow } from "../types/headless";
 import { deriveHeadlessFreshness, type ReportFreshness } from "./pane-functions/freshness";
 import { fxPairObservation, fxRateObservations, type FxRateTiming } from "../plugins/builtin/shared/fx-rate-freshness";
 import { quoteObservation, REPORTED_DATA } from "../plugins/builtin/shared/report-freshness";
-import { latestFinancialPeriod } from "../utils/latest-financial-period";
+import { latestReportedPeriod } from "../utils/latest-financial-period";
 
 /**
  * The source, as-of and status line of a plain CLI command, derived exactly as
@@ -53,12 +53,6 @@ export function fxPairFreshness(
   return observation ? rowsFreshness([observation], undefined, undefined, now) : undefined;
 }
 
-/** The newest reported period end in the statements, the period the trailing figures run through. */
-function latestReportedPeriod(financials: Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">): string | null {
-  const rows: FinancialStatement[] = [...financials.annualStatements, ...financials.quarterlyStatements];
-  return latestFinancialPeriod(rows, (row) => row.date)?.date ?? null;
-}
-
 /**
  * Fundamentals: reported figures, not a feed. Dated by when the statistics
  * block was observed, with the newest statement period they run through

package/src/cli/fx-forward.ts

@@ -0,0 +1,130 @@
+import type { CloudShortRate } from "../api-client/types";
+
+/**
+ * An FX forward implied by covered interest parity: the spot carried by each
+ * currency's short rate over the tenor. Not a dealer's quote, and said so
+ * wherever it is shown.
+ */
+
+/** What every forward says about itself. */
+export const IMPLIED_FORWARD_LABEL = "implied by rates, not a dealer quote";
+
+/** The longest tenor offered: past a year the short rates say little about the term rates a forward prices from. */
+const MAX_FORWARD_DAYS = 366;
+const DAY_MS = 86_400_000;
+
+export interface ForwardTenor {
+  /** As typed, normalised: `30d`, `3m`. */
+  label: string;
+  /** Calendar days from today to the forward date. */
+  days: number;
+}
+
+/**
+ * A tenor as days (`30d`), weeks (`4w`), months (`3m`) or years (`1y`). Months
+ * and years count calendar days from `today` to the same day that many months
+ * on (the month's last day when it has no such day), as a dated forward runs.
+ */
+export function parseForwardTenor(text: string, today: Date = new Date()): ForwardTenor | { error: string } {
+  const match = /^\s*(\d{1,3})\s*([dwmy])\s*$/i.exec(text);
+  if (!match) return { error: `"${text}" is not a tenor; write it as days, weeks, months or years, such as 30d, 2w, 3m or 1y.` };
+  const count = Number(match[1]);
+  const unit = match[2]!.toLowerCase();
+  if (count <= 0) return { error: "A forward tenor is at least one day." };
+  const start = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate());
+  let days: number;
+  if (unit === "d") days = count;
+  else if (unit === "w") days = count * 7;
+  else {
+    const months = unit === "m" ? count : count * 12;
+    const target = new Date(Date.UTC(today.getUTCFullYear(), today.getUTCMonth() + months, 1));
+    const lastDay = new Date(Date.UTC(target.getUTCFullYear(), target.getUTCMonth() + 1, 0)).getUTCDate();
+    target.setUTCDate(Math.min(today.getUTCDate(), lastDay));
+    days = Math.round((target.getTime() - start) / DAY_MS);
+  }
+  if (days > MAX_FORWARD_DAYS) return { error: "Forwards run to 1y: past a year, short rates say little about the term rates a forward prices from." };
+  return { label: `${count}${unit}`, days };
+}
+
+/** The size of one forward point: a pip, 0.01 for a pair quoted in yen and 0.0001 otherwise. */
+export function forwardPointSize(quoteCurrency: string): number {
+  return quoteCurrency === "JPY" ? 0.01 : 0.0001;
+}
+
+export interface ImpliedForward {
+  spot: number;
+  forward: number;
+  /** Forward less spot, in points of `pointSize`. */
+  points: number;
+  pointSize: number;
+  /** The forward's premium (positive) or discount over spot across the tenor, percent. */
+  premiumPercent: number;
+  /** The same premium a year: `premiumPercent` × 360 / days. */
+  annualizedPercent: number;
+}
+
+/**
+ * Covered interest parity for BASE/QUOTE (`spot` QUOTE per BASE): money in
+ * either currency earns its own rate as simple interest over `days` on its
+ * day count, so F = S × (1 + r_quote × d / basis_quote) / (1 + r_base × d / basis_base).
+ * Rates are percent a year.
+ */
+export function impliedForward(
+  spot: number,
+  days: number,
+  base: Pick<CloudShortRate, "dayCountBasis"> & { value: number },
+  quote: Pick<CloudShortRate, "dayCountBasis"> & { value: number; currency: string },
+): ImpliedForward {
+  const growth = (rate: { value: number; dayCountBasis: number }) => 1 + (rate.value / 100) * days / rate.dayCountBasis;
+  const forward = spot * growth(quote) / growth(base);
+  const pointSize = forwardPointSize(quote.currency);
+  const premiumPercent = (forward / spot - 1) * 100;
+  return {
+    spot,
+    forward,
+    points: (forward - spot) / pointSize,
+    pointSize,
+    premiumPercent,
+    annualizedPercent: premiumPercent * 360 / days,
+  };
+}
+
+/** A rate the forward can use: listed for the currency, with a value. */
+export type ShortRateLookup = { rate: CloudShortRate & { value: number } } | { error: string };
+
+/**
+ * The currency's short rate, or the sentence naming which rate is missing
+ * and why: none served for the currency, or the one served not read.
+ */
+export function shortRateFor(currency: string, rates: readonly CloudShortRate[]): ShortRateLookup {
+  const rate = rates.find((candidate) => candidate.currency === currency);
+  if (!rate) {
+    const served = [...new Set(rates.map((candidate) => candidate.currency))].sort();
+    return { error: `No short rate for ${currency}${served.length > 0 ? `; forwards are implied for ${served.join(", ")}` : ""}.` };
+  }
+  if (rate.value == null || !Number.isFinite(rate.value)) {
+    return { error: `${rate.name} (${currency}) could not be read${rate.unavailableReason ? `: ${rate.unavailableReason}` : ""}.` };
+  }
+  return { rate: rate as CloudShortRate & { value: number } };
+}
+
+/** `6.776%`: a rate as its publisher prints it, to four decimals at most. */
+export function formatRatePercent(value: number): string {
+  return `${Number(value.toFixed(4))}%`;
+}
+
+/** `+0.2416%`, signed, to four decimals. */
+export function formatSignedPercent(value: number, decimals = 4): string {
+  const fixed = value.toFixed(decimals);
+  return `${value >= 0 ? "+" : ""}${fixed}%`;
+}
+
+/** Forward points to a tenth of a point, signed: `+430.6`. */
+export function formatForwardPoints(points: number): string {
+  return `${points >= 0 ? "+" : ""}${points.toFixed(1)}`;
+}
+
+/** `TIIE 28d 6.776% (Banco de México, 2026-10-20; ACT/360)`. */
+export function describeShortRate(rate: CloudShortRate & { value: number }): string {
+  return `${rate.name} ${formatRatePercent(rate.value)} (${rate.publisher}, ${rate.asOf ?? "undated"}; ACT/${rate.dayCountBasis})`;
+}

package/src/cli/fx-pair.ts

@@ -1,9 +1,9 @@
 import { currencyMinorDigits } from "../market-data/market/format";
-import { parseTypedNumber, readCurrencyAmount } from "../utils/decimal-comma";
+import { parseTypedNumber, readConvertedAmount } from "../utils/decimal-comma";
 import { currenciesNamed } from "../utils/currency-names";
 
 /**
- * What `gloomberb fx` is asked for. A bare code is one unit of it in the base
+ * What `gloom fx` is asked for. A bare code is one unit of it in the base
  * currency (`NGN`: USD per 1 NGN). A pair is market convention, BASE/QUOTE:
  * `USD/NGN` is how many NGN one USD buys, and `ZAR/NGN` a cross of two codes
  * with neither in USD.
@@ -74,7 +74,7 @@ export function parseFxRequest(raw: string, baseCurrency: string): FxRequest | {
   return readAs.length > 0 ? { ...request, readAs } : request;
 }
 
-/** What `gloomberb fx` is asked for, with the amount to convert when one comes first. */
+/** What `gloom fx` is asked for, with the amount to convert when one comes first. */
 export interface FxArgs {
   request: FxRequest;
   /** The amount of `currency` to convert into `baseCurrency`; absent for a rate alone. */
@@ -97,10 +97,11 @@ function joinNameWords(args: readonly string[]): readonly string[] {
  * `fx` arguments: a currency or a pair (`EUR`, `USD/NGN`), or an amount and
  * what to convert it from and to (`1234.5 EUR/USD`, `1234,5 EUR USD`). The
  * amount is an amount of the first currency and reads as cash does
- * (`readCurrencyAmount`): `1.234,5` and `1,234.5` are 1234.5, and `1,234` or
- * `1.234` are thousands unless that currency has three decimals, where they are
- * refused naming both readings. An amount and one currency converts to USD
- * (`toUsdByDefault`). The error sentence otherwise.
+ * (`readConvertedAmount`): `1.234,5` and `1,234.5` are 1234.5, and `1.234` is
+ * 1234 unless that currency has three decimals. A comma before exactly three
+ * digits (`1,234`) is refused naming both readings, as `alerts add` refuses it.
+ * An amount and one currency converts to USD (`toUsdByDefault`). The error
+ * sentence otherwise.
  */
 export function parseFxArgs(words: readonly string[], baseCurrency: string): FxArgs | { error: string } {
   const args = joinNameWords(words);
@@ -129,10 +130,10 @@ export function parseFxArgs(words: readonly string[], baseCurrency: string): FxA
   const toUsdByDefault = codes.length === 1 && !codes[0]!.includes("/");
   const request = parseFxRequest(codes.join("/"), "USD");
   if ("error" in request) return request;
-  // The amount is in the currency converted from, so its units say what 1,234 means.
+  // The amount is in the currency converted from, so its units say what 1.234 means; 1,234 could be either.
   let amount: number;
   try {
-    amount = readCurrencyAmount(first, "The amount", request.currency);
+    amount = readConvertedAmount(first, "The amount", request.currency);
   } catch (error) {
     return { error: error instanceof Error ? error.message : String(error) };
   }

package/src/cli/glossary.ts

@@ -2,7 +2,7 @@ import { cliStyles, cliTerminalWidth, renderDefinitions, renderSection, wrapText
 
 /**
  * Plain-words meanings of the rates, auction, credit and bond yield, energy, perpetual-futures, portfolio,
- * fund, bond fund (SEC yield, tax-equivalent yield, muni/Treasury ratio), short interest, quote-board, futures (basis, contango, roll yield), VIX curve (term structure, 3M/30D, VVIX), CFTC positioning (COT trader classes, net % of open interest) and economic-calendar terms the functions
+ * fund, bond fund (SEC yield, tax-equivalent yield, muni/Treasury ratio), short interest, quote-board, futures (basis, contango, roll yield), VIX curve (term structure, 3M/30D, VVIX), CFTC positioning (COT trader classes, net % of open interest), depositary receipt (ADR ratio, premium, implied FX, the peso's CCL and MEP rates) and economic-calendar terms the functions
  * show in their rows, headers and footers.
  * `catalog glossary` lists them, `catalog explain <term>` prints one, and
  * `fn <function> --explain` and `portfolio show --explain` follow a report with
@@ -430,6 +430,37 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
     definition: "How loosely a fund follows its index: how much the gap between the fund's return and the index's swings, usually over a year. "
       + "Fees, cash and holdings that differ from the index widen it.",
   },
+  // A depositary receipt beside its home listing (ADR, DES), and the peso's market dollar rates `fx USD/ARS` lists.
+  {
+    term: "ADR ratio", aliases: ["adr", "adrs", "depositary receipt", "american depositary receipt", "depositary ratio", "ads ratio"],
+    functions: ["ADR", "DES"], shown: ["Ratio", "ADR Ratio", "ADR ratio"],
+    definition: "How many ordinary shares one depositary receipt holds: 1 ADR = 10 ordinary shares means one GGAL in New York is ten GGAL.BA shares in Buenos Aires. "
+      + "A receipt's price compares with its home price only once the home price is multiplied by the ratio.",
+  },
+  {
+    term: "ADR premium", aliases: ["adr discount", "adr vs home", "receipt premium", "adr premium/discount"],
+    functions: ["ADR"], shown: ["ADR vs home", "premium", "discount"],
+    definition: "How far a receipt trades above (a premium) or below (a discount) the home shares it holds, at the spot rate: spot / implied rate - 1. "
+      + "Arbitrage keeps it small where money moves freely; where it cannot (Argentina's controls, Taiwan's limits on foreign buying) it runs to several percent.",
+  },
+  {
+    term: "Implied FX", aliases: ["implied exchange rate", "implied dollar rate", "implied fx rate", "adr implied rate"],
+    functions: ["ADR"], shown: ["Implied"],
+    definition: "The exchange rate at which a receipt and its home shares cost the same: home price × ratio / ADR price. "
+      + "GGAL.BA at ARS 6,260, 10 shares a receipt and GGAL at $37.91 imply 6,260 × 10 / 37.91 = 1,651 pesos a dollar.",
+  },
+  {
+    term: "Contado con liquidación", short: "CCL", aliases: ["contado con liquidacion", "contado con liqui", "dolar ccl", "ccl rate", "blue chip swap"],
+    functions: ["ADR"],
+    definition: "The peso's dollar rate for moving money abroad through securities: buy shares in pesos in Buenos Aires, sell them (or their ADR) for dollars abroad. "
+      + "Read from an ADR pair (home × ratio / ADR) or a BYMA C line (peso price / C-line dollar price); it runs above the official wholesale rate.",
+  },
+  {
+    term: "Mercado electrónico de pagos", short: "MEP", aliases: ["mercado electronico de pagos", "dolar mep", "dolar bolsa", "mep rate"],
+    functions: ["ADR"],
+    definition: "The peso's dollar rate inside Argentina through securities: buy shares in pesos and sell their BYMA D line for dollars paid in Argentina. "
+      + "Read as the peso price over the D line's dollar price; it sits near the CCL rate, usually a little under it.",
+  },
   // Bond spreads and yields (CRD, the data catalog's ICE BofA yields, TRACE), a fund's SEC yield, which DVD's cash yield is not,
   // and the bond fund figures and tax-equivalent maths DVD and fundamentals give with --tax-rate.
   {
@@ -474,7 +505,7 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
     functions: ["DVD"], shown: ["Tax-equivalent yield", "Tax-Equivalent Yield"],
     definition: "The yield a taxable bond needs to match a tax-exempt muni fund after tax: yield / (1 - (federal rate + state rate)), on the SEC yield, "
       + "else the distribution yield. At 40.8% (37% plus the 3.8% net investment income tax), MUB's 4.04% is 6.83%. A state rate counts only for a "
-      + "single-state fund of that state (CMF, VTEC for California). gloomberb fn DVD and fundamentals take --tax-rate, --state-rate and --state.",
+      + "single-state fund of that state (CMF, VTEC for California). gloom fn DVD and fundamentals take --tax-rate, --state-rate and --state.",
   },
   {
     term: "Muni/Treasury ratio", aliases: ["muni treasury ratio", "muni-to-treasury ratio", "muni/ust ratio", "muni ratio", "municipal treasury ratio"],
@@ -561,8 +592,9 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
     term: "Float", aliases: ["free float", "public float", "float shares", "floating stock", "% float", "percent of float"],
     functions: ["SI", "SIW"], shown: ["Float"],
     definition: "The shares open to public trading: those outstanding less shares held by insiders and strategic holders, never more than the shares outstanding. "
-      + "% Float is shares short over today's float, so a settlement is measured against the float as it is now, not as it was then; "
-      + "SI gives it for the latest settlement only.",
+      + "The float is the source's own, held within the 10-K or 10-Q cover count and undated; a float held at that count is the count, dated by it. "
+      + "SIW's % Float is the latest settlement's shares short over today's float; SI reads each earlier settlement over the float when FINRA published it: "
+      + "the cover count known that day, at the share of today's count that floats.",
   },
   {
     // SIW's Setup column prints these two words.
@@ -622,7 +654,7 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
   {
     term: "Futures contract", aliases: ["futures", "future", "futures contracts", "contract", "contract month", "expiry", "expiration"],
     functions: ["FUT", "CTM"], shown: ["CONTRACT", "Contract"],
-    definition: "An agreement to buy or sell something, such as oil, gold or the S&P 500, at a set price on a set date. Each contract has a month (Dec 26) and expires, "
+    definition: "An agreement to buy or sell something, such as oil, gold or the S&P 500, at a set price on a set date. Each contract has a month (Dec 2026) and expires, "
       + "and most traders close out before then. A contract's own Settlement line says how it ends: in cash or by physical delivery.",
   },
   {
@@ -694,8 +726,16 @@ export const GLOSSARY: readonly GlossaryEntry[] = [
   {
     term: "Annualised basis", aliases: ["annualized basis", "ann basis", "ann. basis", "basis annualised"], functions: ["CTM", "PERP"], shown: ["Ann Basis", "ANN BASIS"],
     definition: "The basis restated as a yearly rate, so contracts of different length compare with each other and with a perpetual's funding APR: "
-      + "(Last / spot - 1) × 365 / days to expiry, simple rather than compounded, on the latest trade against the spot quote. "
-      + "Inside 30 days a few basis points of spot noise move it by whole points: 10 bp is about ±2 points at 18 days to expiry.",
+      + "(Last / spot - 1) × 365 / days to expiry, simple rather than compounded. CTM reads each last trade against spot in the same minute "
+      + "and counts days to final settlement to the hour. Inside a week a few basis points of spot noise move it by whole points "
+      + "(10 bp is about ±5 points at 7 days), so CTM greys it there and Vs Spot is the figure to read.",
+  },
+  {
+    term: "Crypto composite price", aliases: ["CCC", "crypto composite", "composite price", "composite crypto price"], functions: ["CTM"],
+    shown: ["crypto composite price"],
+    definition: "A coin's dollar price blended from trading on several crypto exchanges rather than taken from one, quoted around the clock; "
+      + "quotes list it under the code CCC. CTM reads CME crypto futures against it, while the futures settle to CME's own reference rate, "
+      + "so a small gap at expiry is expected.",
   },
   {
     term: "Contango", aliases: ["contango curve", "upward curve"], functions: ["CTM", "FUT"], shown: ["contango", "Contango"],
@@ -776,8 +816,8 @@ export interface GlossaryLookup {
   /** The entries the query names: by the term, its abbreviation or an alias. */
   exact: GlossaryEntry[];
   /**
-   * The others whose names start a word with each word of the query: `stop-out` finds stop-out vs average.
-   * Those that hold the words whole come first.
+   * The others whose names hold each word of the query: `stop-out` finds stop-out vs average. Beside a term the
+   * query names they hold the words whole; otherwise a word start is enough, and the whole ones come first.
    */
   partial: GlossaryEntry[];
 }
@@ -785,22 +825,26 @@ export interface GlossaryLookup {
 // Shorter words (the `b` and `c` of `B/C`) would find half the glossary.
 const MIN_PARTIAL_WORD = 3;
 
+/** A name's word holds a query word whole, or as its plural: `assets` holds `asset`, `floating` does not hold `float`. */
+const wholeWord = (have: string, word: string) => have === word || have === `${word}s` || have === `${word}es`;
+
 export function lookupGlossary(query: string): GlossaryLookup {
   const key = lookupKey(query);
   if (!key) return { exact: [], partial: [] };
   const exact = GLOSSARY.filter((entry) => names(entry).some((name) => lookupKey(name) === key));
   const wanted = words(query).filter((word) => word.length >= MIN_PARTIAL_WORD);
-  const partial = wanted.length === 0 ? [] : GLOSSARY.filter((entry) => {
-    if (exact.includes(entry)) return false;
+  if (wanted.length === 0) return { exact, partial: [] };
+  const others = GLOSSARY.filter((entry) => !exact.includes(entry));
+  const holding = (match: (have: string, word: string) => boolean) => others.filter((entry) => {
     const have = names(entry).flatMap(words);
-    return wanted.every((word) => have.some((name) => name.startsWith(word)));
+    return wanted.every((word) => have.some((name) => match(name, word)));
   });
-  // The entries that hold the words whole come before those that only start with them: `float` is the float, not the floating rate note.
-  const whole = (entry: GlossaryEntry) => {
-    const have = names(entry).flatMap(words);
-    return wanted.every((word) => have.includes(word));
-  };
-  return { exact, partial: partial.sort((left, right) => Number(whole(right)) - Number(whole(left))) };
+  // Related to a term the query names are only the terms that hold its words whole: `float` is the float of a
+  // stock, and the floating rate note only starts with the same letters. A query that names no term is a search,
+  // where a word start (`vol` for volume) still finds a term, after those that hold it whole.
+  const whole = holding(wholeWord);
+  if (exact.length > 0) return { exact, partial: whole };
+  return { exact, partial: [...whole, ...holding((name, word) => name.startsWith(word)).filter((entry) => !whole.includes(entry))] };
 }
 
 function escapeRegExp(text: string): string {
@@ -839,7 +883,7 @@ export function renderGlossaryEntries(entries: readonly GlossaryEntry[]): string
 /** What `--explain` adds under a report: the terms it shows, or a note that it shows none. */
 export function renderReportGlossary(token: string, entries: readonly GlossaryEntry[]): string {
   if (entries.length === 0) {
-    return wrapText(`${token} shows no glossary terms. gloomberb catalog glossary lists every term.`, textWidth())
+    return wrapText(`${token} shows no glossary terms. gloom catalog glossary lists every term.`, textWidth())
       .map((line) => cliStyles.muted(line)).join("\n");
   }
   return [renderSection("Terms"), ...renderGlossaryEntries(entries)].join("\n");
@@ -876,7 +920,7 @@ export function renderGlossaryIndex(): string {
       index === 0 ? `  ${cliStyles.command(owner)}${" ".repeat(labelWidth - 2 - owner.length)}${line}` : `${" ".repeat(labelWidth)}${line}`
     ))),
     "",
-    ...wrapText("gloomberb catalog glossary <term> explains one; fn <function> --explain and portfolio show --explain add the terms a report shows.", width)
+    ...wrapText("gloom catalog glossary <term> explains one; fn <function> --explain and portfolio show --explain add the terms a report shows.", width)
       .map((line) => cliStyles.muted(line)),
   ].join("\n");
 }