gloomberb 0.19.0 → 0.19.2

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

@@ -2,6 +2,7 @@ import { formatFxRate } from "../cli/fx-pair";
 import type { EnterpriseValueCheck, Fundamentals, Quote, TickerFinancials } from "../types/financials";
 import { quotedFxPair } from "./currency-pair";
 import { resolveCurrencyUnit } from "./currency-units";
+import { isUsListingExchange } from "./exchanges";
 import { formatCompact } from "./format";
 import { formatUtcTime } from "./utc-time";
 
@@ -44,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;
   }
@@ -86,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.
  */
@@ -96,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}.`;
 }
 
 /**
@@ -119,24 +132,53 @@ export function computedEnterpriseValueNote(fundamentals: Parameters<typeof ente
 }
 
 /** What names the currency of the trailing figures: the fundamentals' own labels, else the statements' on a listing that trades in theirs. */
-type FundamentalsCurrencies = Pick<TickerFinancials, "financialCurrency"> & {
+type FundamentalsCurrencies = Pick<TickerFinancials, "financialCurrency" | "statementHistory"> & {
   fundamentals?: Pick<Fundamentals, "financialCurrency" | "epsCurrency" | "marketCapCurrency"> | null;
-  quote?: Pick<Quote, "currency"> | null;
+  quote?: Pick<Quote, "currency" | "exchangeName" | "listingExchangeName" | "isDepositaryReceipt"> | null;
 };
 
+/** What a caller knows of the listing beyond its quote: the day it listed (its IPO's), when known. */
+interface ListingAge {
+  listedSince?: string | null;
+  now?: Date;
+}
+
+/** A listing that started within about a year: its statements may not be served yet. */
+const RECENT_LISTING_DAYS = 372;
+
+/**
+ * The listing's own currency, standing in for figures with no statements to tell their currency by: only for a
+ * listing of the last year or so (a recent IPO such as HAWK) or a US listing in dollars that is no receipt, and
+ * never after a statements read that failed. A minor unit (GBp) does not say whether figures are pence or pounds.
+ */
+function listingCurrencyFallback(financials: FundamentalsCurrencies | null | undefined, listing: ListingAge): string | undefined {
+  const listed = financials?.fundamentals?.marketCapCurrency?.trim() || financials?.quote?.currency?.trim();
+  if (!listed || resolveCurrencyUnit(listed).divisor !== 1) return undefined;
+  if (financials?.statementHistory?.status === "retryable-failure") return undefined;
+  const currency = resolveCurrencyUnit(listed).currency;
+  const since = listing.listedSince ? Date.parse(`${listing.listedSince.slice(0, 10)}T00:00:00Z`) : NaN;
+  const recent = Number.isFinite(since) && (listing.now ?? new Date()).getTime() - since <= RECENT_LISTING_DAYS * 86_400_000;
+  const quote = financials?.quote;
+  const home = currency === "USD" && quote?.isDepositaryReceipt !== true
+    && isUsListingExchange(quote?.listingExchangeName || quote?.exchangeName);
+  return recent || home ? currency : undefined;
+}
+
 /**
  * The currency of the trailing EPS, revenue, income and cash flows: the one the fundamentals declare for themselves.
  * A block that declares none is in the statements' currency only when the listing trades in it; on a listing quoted
  * in another (a receipt in USD beside TWD books, YPFD in ARS beside USD statements) its currency is unknown, since
- * Gloom Cloud labels every block whose currency it can tell. Never the quote's.
+ * Gloom Cloud labels every block whose currency it can tell. With no statements to tell by, the listing's own
+ * currency where that is safe (listingCurrencyFallback).
  */
 export function fundamentalsCurrency(
   financials: FundamentalsCurrencies | null | undefined,
+  listing: ListingAge = {},
 ): string | undefined {
   const declared = financials?.fundamentals?.financialCurrency?.trim();
   if (declared) return declared;
   const statements = financials?.financialCurrency?.trim();
-  if (!statements) return undefined;
+  if (!statements) return listingCurrencyFallback(financials, listing);
   const listed = financials?.fundamentals?.marketCapCurrency?.trim() || financials?.quote?.currency?.trim();
   return !listed || resolveCurrencyUnit(listed).currency === resolveCurrencyUnit(statements).currency ? statements : undefined;
 }
@@ -147,8 +189,9 @@ export function fundamentalsCurrency(
  */
 export function fundamentalsEpsCurrency(
   financials: FundamentalsCurrencies | null | undefined,
+  listing: ListingAge = {},
 ): string | undefined {
-  return financials?.fundamentals?.epsCurrency?.trim() || fundamentalsCurrency(financials);
+  return financials?.fundamentals?.epsCurrency?.trim() || fundamentalsCurrency(financials, listing);
 }
 
 const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;

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 };
+}

package/src/utils/main-thread-stall.ts

@@ -9,15 +9,31 @@ const SAMPLE_INTERVAL_MS = 250;
  */
 const STALL_THRESHOLD_MS = 400;
 
+/** The facts a `sqlite.blocked` step was measured with (data/sqlite/retry.ts). */
+interface StallSqliteDetail {
+  /** The statement's fixed name, such as "touch cached resource". */
+  operation: string;
+  attempts: number;
+  /** Whether it waited on another connection's lock, rather than being slow on its own. */
+  lockWait: boolean;
+}
+
 export interface StallEvent {
   blockedMs: number;
   /** The last measured section before the stall (perf-marks), if any. */
   lastMeasured?: string;
   /** How long before the stall was noticed that section ended. */
   lastMeasuredEndedMsAgo?: number;
+  /** When that section was a SQLite statement that held the thread. */
+  sqlite?: StallSqliteDetail;
+  /** How long the process had been running when the stall was noticed. */
+  uptimeMs?: number;
+  /** Whether the process had finished starting (`markStartupComplete`). */
+  phase?: "startup" | "steady";
 }
 
 let stallSink: ((event: StallEvent) => void) | null = null;
+let startupComplete = false;
 
 /**
  * Where this process's stalls go besides the Debug Log: the stall log and its
@@ -31,6 +47,20 @@ export function setStallSink(next: ((event: StallEvent) => void) | null): () =>
   };
 }
 
+/**
+ * The process is up: its first screen has its data, or (the desktop app's
+ * Bun process) the main window has what it asked for. Stalls before this are
+ * reported as startup ones.
+ */
+export function markStartupComplete(): void {
+  startupComplete = true;
+}
+
+/** Test seam. */
+export function resetStartupCompleteForTests(): void {
+  startupComplete = false;
+}
+
 function noteStall(event: StallEvent): void {
   try {
     stallSink?.(event);
@@ -39,6 +69,14 @@ function noteStall(event: StallEvent): void {
   }
 }
 
+/** The facts of a `sqlite.blocked` sample, when they have the shape retry.ts gives them. */
+function sqliteDetail(metadata: Record<string, unknown> | undefined): StallSqliteDetail | undefined {
+  if (!metadata) return undefined;
+  const { operation, attempts, lockWait } = metadata;
+  if (typeof operation !== "string" || typeof attempts !== "number") return undefined;
+  return { operation, attempts, lockWait: lockWait === true };
+}
+
 export interface MainThreadStallMonitorOptions {
   intervalMs?: number;
   thresholdMs?: number;
@@ -60,7 +98,9 @@ function defaultNow(): number {
  * comes back late, the app was unresponsive for exactly that long. The report
  * carries the last measured section and how long before the stall it ended,
  * which is usually enough to tell "the cache read did it" from "the render
- * did it" in a report that only says the app hung for a few seconds.
+ * did it" in a report that only says the app hung for a few seconds, and how
+ * long the process had been up, so a slow start reads apart from a hang
+ * hours in.
  */
 export function startMainThreadStallMonitor(
   options: MainThreadStallMonitorOptions = {},
@@ -72,7 +112,8 @@ export function startMainThreadStallMonitor(
   const cancel = options.cancel ?? ((handle) => clearInterval(handle as ReturnType<typeof setInterval>));
   const report = options.report
     ?? ((blockedMs, context) => {
-      recordPerfSample("runtime.stall", blockedMs, context);
+      // Logged, but not a step: the next stall still names the work before it.
+      recordPerfSample("runtime.stall", blockedMs, context, { lastStep: false });
       noteStall({ blockedMs, ...context });
     });
 
@@ -83,10 +124,14 @@ export function startMainThreadStallMonitor(
     previous = current;
     if (blockedMs < thresholdMs) return;
     const sample = lastPerfSample();
+    const sqlite = sample?.name === "sqlite.blocked" ? sqliteDetail(sample.metadata) : undefined;
     report(blockedMs, {
       ...(sample
         ? { lastMeasured: sample.name, lastMeasuredEndedMsAgo: Math.round(current - sample.endedAt) }
         : {}),
+      ...(sqlite ? { sqlite } : {}),
+      uptimeMs: Math.round(current),
+      phase: startupComplete ? "steady" : "startup",
     });
   }, intervalMs);
   if (handle && typeof (handle as { unref?: () => void }).unref === "function") {

package/src/utils/perf-marks.ts

@@ -20,27 +20,34 @@ function now(): number {
     : Date.now();
 }
 
-// Two scalars rather than an object: every measured section writes them, and
-// only the stall monitor ever reads them.
+// Scalars rather than an object: every measured section writes them, and
+// only the stall monitor ever reads them. The metadata is the caller's own
+// object, kept by reference.
 let lastSampleName: string | null = null;
 let lastSampleEndedAt = 0;
+let lastSampleMetadata: Record<string, unknown> | undefined;
 
 /**
- * The most recent measured section and when it ended. The stall monitor reads
- * it so a report of "the app froze" carries the last thing the app is known to
- * have been doing.
+ * The most recent measured section, when it ended and what it was measured
+ * with. The stall monitor reads it so a report of "the app froze" carries the
+ * last thing the app is known to have been doing.
  */
-export function lastPerfSample(): { name: string; endedAt: number } | null {
-  return lastSampleName == null ? null : { name: lastSampleName, endedAt: lastSampleEndedAt };
+export function lastPerfSample(): { name: string; endedAt: number; metadata?: Record<string, unknown> } | null {
+  if (lastSampleName == null) return null;
+  return { name: lastSampleName, endedAt: lastSampleEndedAt, ...(lastSampleMetadata ? { metadata: lastSampleMetadata } : {}) };
 }
 
 function logSlowPerfSample(
   name: string,
   durationMs: number,
   metadata?: Record<string, unknown>,
+  lastStep = true,
 ): void {
-  lastSampleName = name;
-  lastSampleEndedAt = now();
+  if (lastStep) {
+    lastSampleName = name;
+    lastSampleEndedAt = now();
+    lastSampleMetadata = metadata;
+  }
   const payload = {
     durationMs: Math.round(durationMs * 10) / 10,
     ...(metadata ?? {}),
@@ -60,13 +67,18 @@ export function isPerfTraceEnabled(): boolean {
   return traceToStderr;
 }
 
-/** A sample measured elsewhere (a React Profiler callback, for instance). */
+/**
+ * A sample measured elsewhere (a React Profiler callback, for instance).
+ * `lastStep: false` logs it without making it the step a later stall names:
+ * the stall monitor's own samples, which measure no work.
+ */
 export function recordPerfSample(
   name: string,
   durationMs: number,
   metadata?: Record<string, unknown>,
+  options?: { lastStep?: boolean },
 ): void {
-  logSlowPerfSample(name, durationMs, metadata);
+  logSlowPerfSample(name, durationMs, metadata, options?.lastStep !== false);
 }
 
 export function measurePerf<T>(

package/src/utils/price-history-integrity.ts

@@ -46,6 +46,50 @@ export function pricePointIntegrityFlags(point: PricePoint): string[] {
   return flags;
 }
 
+/**
+ * A wick too far from its bar's body to have traded: a low under half the lower
+ * of open and close, or a high over twice the higher, as `low<close/2` or
+ * `high>2*open` (IAG on LSE, 2021-11-29: a low of 0.0155 under a close of
+ * 1.316). Only that wick is withheld: the open and close stand, so closes,
+ * returns and drawdowns read the bar while lows, highs and ranges do not.
+ * Empty when the wicks are plausible, or when the bar's prices contradict
+ * each other, which blanks it whole (pricePointIntegrityFlags).
+ */
+export function pricePointWickFlags(point: PricePoint): string[] {
+  const { open, high, low, close } = point;
+  if (pricePointIntegrityFlags(point).length > 0) return [];
+  const body = [["open", open], ["close", close]].filter((entry): entry is [string, number] => isFiniteNumber(entry[1]));
+  if (body.length === 0) return [];
+  // On a tie the close names the side, as the price the bar is read by.
+  const [bottomName, bottom] = body.reduce((least, entry) => entry[1] <= least[1] ? entry : least);
+  const [topName, top] = body.reduce((most, entry) => entry[1] >= most[1] ? entry : most);
+  const flags: string[] = [];
+  if (isFiniteNumber(low) && bottom > 0 && low < bottom / 2) flags.push(`low<${bottomName}/2`);
+  if (isFiniteNumber(high) && top > 0 && high > top * 2) flags.push(`high>2*${topName}`);
+  return flags;
+}
+
+/** Whether a flag code is a withheld wick (pricePointWickFlags), whose bar keeps its open and close. */
+export function isWickFlag(code: string): boolean {
+  return /^(low<(open|close)\/2|high>2\*(open|close))$/.test(code);
+}
+
+/** A bar's high and low with a wick too far from its body to have traded (pricePointWickFlags) left out. */
+export function pricePointWicks(point: PricePoint): { high: number | undefined; low: number | undefined } {
+  const flags = pricePointWickFlags(point);
+  return {
+    high: flags.some((flag) => flag.startsWith("high")) ? undefined : point.high,
+    low: flags.some((flag) => flag.startsWith("low")) ? undefined : point.low,
+  };
+}
+
+/** "1 bar has a low or high too far from its open and close to have traded; left out of ranges.", or undefined for none. */
+export function priceHistoryWickNotice(count: number): string | undefined {
+  return count > 0
+    ? `${count === 1 ? "1 bar has a low or high" : `${count} bars have lows or highs`} too far from ${count === 1 ? "its" : "their"} open and close to have traded; left out of ranges.`
+    : undefined;
+}
+
 export function pricePointIntegrity(point: PricePoint): PriceHistoryIntegrity | undefined {
   if (pricePointIntegrityFlags(point).length === 0) return undefined;
   const date = new Date(point.date);
@@ -58,8 +102,10 @@ export function pricePointIntegrity(point: PricePoint): PriceHistoryIntegrity |
 /** Calculation/display fields deliberately exclude the contradictory source row. */
 export function pricePointValues(point: PricePoint, integrity = pricePointIntegrity(point)) {
   const value = (number: number | undefined) => !integrity && isFiniteNumber(number) ? number : null;
+  // A wick too far from the body to have traded is left out; the rest of the bar stands.
+  const wicks = pricePointWicks(point);
   return {
-    open: value(point.open), high: value(point.high), low: value(point.low),
+    open: value(point.open), high: value(wicks.high), low: value(wicks.low),
     close: value(point.close), volume: value(point.volume),
     ...(integrity ? { integrity } : {}),
   };

package/src/version.ts

@@ -3,7 +3,7 @@ import packageJson from "../package.json" with { type: "json" };
 export const VERSION = packageJson.version;
 
 /**
- * The npm package this copy came from: `gloomberb`, or `@gloom-sh/terminal`
- * once releases are also published under that name.
+ * The npm package this copy came from: `@gloom-sh/terminal` or `gloomberb`,
+ * which every release publishes with the same build.
  */
 export const PACKAGE_NAME = packageJson.name;