gloomberb 0.18.0 → 0.18.2

package/src/plugins/builtin/cot/model.ts

@@ -5,7 +5,7 @@ import type { PricePoint } from "../../../types/financials";
 import { formatPriceObservation } from "../../../market-data/market/format";
 import { cleanFloat32Price } from "../../../cli/history-rows";
 import { cryptoPairCoin, isFuturesSymbol } from "../shared/crypto-pair";
-import { FUTURES_CONTRACTS, futuresBoardContract, futuresBoardContractForTicker, type FuturesContract } from "../../../market-data/futures-board";
+import { bestNameMatch, FUTURES_CONTRACTS, futuresBoardContract, futuresBoardContractForTicker, futuresContractByName, type FuturesContract } from "../../../market-data/futures-board";
 
 export const COT_CLASSES: Record<CotFamily, Array<{ value: CotClass; label: string }>> = {
   legacy: [{ value: "noncommercial", label: "Noncommercial" }, { value: "commercial", label: "Commercial" }, { value: "nonreportable", label: "Nonreportable" }],
@@ -124,25 +124,48 @@ export function cotScope(value: unknown): CotScope { return value === "all" ? "a
 const rootAlias = (input: string) => ROOTS[input === "VIX" ? "VX" : input]?.code ?? null;
 const marketCode = (input: string) => /^[0-9A-Z]{5}[0-9A-Z+]$/.test(input) ? input : null;
 /**
- * A CFTC code or root typed as an argument or stored in a pane: every alias,
- * crypto included, and every FUT board root the CFTC reports. A typed root is
- * always the future, so ZM here is soybean meal, never Zoom.
+ * The FUT board row a typed argument names, by code, symbol or commodity name
+ * as FUT reads them (CC, CC=F, cocoa), or a verified root named the same way
+ * (bitcoin, VIX, SOFR, fed funds).
+ */
+function typedMarket(value: string): { board: FuturesContract } | { root: string } | null {
+  const board = futuresBoardContract(value) ?? futuresContractByName(value);
+  if (board) return { board };
+  const root = bestNameMatch(Object.keys(ROOTS), (key) => [ROOTS[key]!.name], value);
+  return root ? { root } : null;
+}
+/**
+ * A CFTC code, root or commodity name typed as an argument or stored in a
+ * pane: every alias, crypto included, every FUT board root the CFTC reports,
+ * and the names FUT finds them by (cocoa, coffee, sugar, gold, crude). A typed
+ * root is always the future, so ZM here is soybean meal, never Zoom. A CFTC
+ * code is tried after the names, as one could be spelled with six letters
+ * (COFFEE, COPPER).
  */
 export function cotContractCode(value: unknown): string | null {
   if (typeof value !== "string") return null;
   const input = value.trim().toUpperCase().replace(/=F$/, "");
-  const board = futuresBoardContract(value);
-  return rootAlias(input) ?? (board ? boardMarketCode(board) : null) ?? marketCode(input);
+  const alias = rootAlias(input);
+  if (alias) return alias;
+  const market = typedMarket(value);
+  if (market && "root" in market) return ROOTS[market.root]!.code;
+  return (market ? boardMarketCode(market.board) : null) ?? (market ? null : marketCode(input));
 }
+/** The markets the unknown-market hint names, by the code and the word a newcomer knows them by. */
+const SUGGESTED_MARKETS: ReadonlyArray<readonly [string, string]> = [
+  ["ES", "S&P 500"], ["CL", "crude oil"], ["NG", "natural gas"], ["GC", "gold"], ["HG", "copper"],
+  ["ZC", "corn"], ["CC", "cocoa"], ["KC", "coffee"], ["SB", "sugar"], ["ZN", "10-year note"],
+];
 /**
- * What a market `cotContractCode` does not know is told: a FUT board root the
- * CFTC does not report says so; anything else gets roots and a code that work.
+ * What a market `cotContractCode` does not know is told: a FUT board row the
+ * CFTC does not report says so; anything else gets codes and names that work,
+ * softs and metals among them, and a CFTC code.
  */
 export function cotUnknownMarketMessage(value: unknown): string {
-  const board = futuresBoardContract(value);
-  if (board) return `${board.code} (${board.name}) is not reported in the CFTC COT.`;
-  const roots = ["ES", "CL", "GC", "ZN"].filter((root) => ROOTS[root]);
-  return `Unknown market "${String(value)}". Try ${roots.join(", ")} or a CFTC market code such as ${ROOTS.GC!.code}.`;
+  const market = typeof value === "string" ? typedMarket(value) : null;
+  if (market && "board" in market) return `${market.board.code} (${market.board.name}) is not reported in the CFTC COT.`;
+  const known = SUGGESTED_MARKETS.map(([code, name]) => `${code} ${name}`).join(", ");
+  return `Unknown market "${String(value)}". Try a code or name such as ${known}, or a CFTC market code such as ${ROOTS.GC!.code}.`;
 }
 /**
  * The code for the ticker under the cursor, when COT is opened without an

package/src/plugins/builtin/credit-boards/cdx-pane.tsx

@@ -1,5 +1,6 @@
 import { useMemo } from "react";
 import {
+  DELAYED_SEGMENT,
   ChartTableHeader,
   CompositeChart,
   MarketBoardStack,
@@ -107,7 +108,7 @@ export function CdxPane({ focused, width, height }: PaneProps) {
   const asOf = formatAsOf(payload?.asOf ?? null);
   const info = useMemo<PaneFooterSegment[]>(() => [
     ...(asOf ? [{ id: "as-of", parts: [{ text: `as of ${asOf}`, tone: "muted" as const }] }] : []),
-    ...(payload ? [{ id: "delayed", parts: [{ text: "delayed", tone: "muted" as const }] }] : []),
+    ...(payload ? [DELAYED_SEGMENT] : []),
     ...(resource.data?.stale ? [{ id: "stale", parts: [{ text: "STALE", tone: "warning" as const }] }] : []),
   ], [asOf, payload, resource.data?.stale]);
   usePaneStatusFooter({

package/src/plugins/builtin/credit-boards/sovr-pane.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useMemo } from "react";
 import {
+  DELAYED_SEGMENT,
   ChartTableHeader,
   CompositeChart,
   formatBpAxis,
@@ -112,7 +113,7 @@ export function SovrPane({ focused, width, height }: PaneProps) {
   const asOf = formatAsOf(payload?.asOf ?? null);
   const info = useMemo<PaneFooterSegment[]>(() => [
     ...(asOf ? [{ id: "as-of", parts: [{ text: `as of ${asOf}`, tone: "muted" as const }] }] : []),
-    ...(payload ? [{ id: "delayed", parts: [{ text: "delayed", tone: "muted" as const }] }] : []),
+    ...(payload ? [DELAYED_SEGMENT] : []),
     ...(resource.data?.stale ? [{ id: "stale", parts: [{ text: "STALE", tone: "warning" as const }] }] : []),
   ], [asOf, payload, resource.data?.stale]);
   usePaneStatusFooter({

package/src/plugins/builtin/credit-conditions/index.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useMemo } from "react";
 import {
+  DELAYED_SEGMENT,
   ChartTableHeader,
   CompositeChart,
   formatBpAxis,
@@ -115,7 +116,7 @@ export function CreditConditionsPane({ paneId, focused, width, height }: PanePro
     notices: mixedDates ? ["The indexes carry different observation dates, so the spreads are not one session."] : [],
   });
   const footerInfo = useMemo<PaneFooterSegment[]>(() => [
-    ...(rows.length > 0 ? [{ id: "delayed", parts: [{ text: "delayed", tone: "muted" as const }] }] : []),
+    ...(rows.length > 0 ? [DELAYED_SEGMENT] : []),
     ...(partial ? [{ id: "partial", parts: [{ text: `PARTIAL ${rows.length}/${series.length}`, tone: "warning" as const, bold: true }] }] : []),
     ...(stale ? [{ id: "stale", parts: [{ text: "STALE", tone: "warning" as const }] }] : []),
     ...loadingErrorFooterInfo(loading, error),

package/src/plugins/builtin/crypto-board/client.ts

@@ -84,7 +84,34 @@ function withValidStablecoinFields(asset: CryptoMarketAsset): CryptoMarketAsset
   return { ...asset, ...(peg ? { peg: null } : {}), ...(range ? { range24h: null } : {}) };
 }
 
-export function validateCryptoMarkets(data: CryptoMarketsPayload): CryptoMarketsPayload {
+const DAY_MS = 86_400_000;
+/** How many UTC days old a coin's latest daily close may be for its previous close to stand, as Gloom Cloud judges a coin quote's. */
+const PREVIOUS_CLOSE_MAX_AGE_DAYS = 2;
+
+/**
+ * A coin of a board from before Gloom Cloud measured its moves since 00:00
+ * UTC (a server not yet updated, a copy cached from one), whose change runs
+ * over the screener's 24 hours: moved from its previous close instead, the
+ * close of its last UTC day while its daily closes reach the last two days.
+ * Otherwise that close may be weeks old (Toncoin on 18 Oct 2026), and the
+ * coin has no move.
+ */
+function onUtcDayBasis(asset: CryptoMarketAsset, now: number): CryptoMarketAsset {
+  const history = asset.history;
+  const last = history?.closes.findLastIndex((close) => close != null) ?? -1;
+  const lastDay = history && last >= 0 ? Date.parse(`${history.start}T00:00:00Z`) / DAY_MS + last : null;
+  const holds = lastDay != null && asset.previousClose != null && asset.previousClose > 0
+    && Math.floor(now / DAY_MS) - lastDay <= PREVIOUS_CLOSE_MAX_AGE_DAYS;
+  const change = holds ? asset.price - asset.previousClose! : null;
+  return {
+    ...asset,
+    previousClose: holds ? asset.previousClose : null,
+    change,
+    changePercent: change != null ? (change / asset.previousClose!) * 100 : null,
+  };
+}
+
+export function validateCryptoMarkets(data: CryptoMarketsPayload, now = Date.now()): CryptoMarketsPayload {
   if (
     !data
     || data.version !== 1
@@ -103,7 +130,11 @@ export function validateCryptoMarkets(data: CryptoMarketsPayload): CryptoMarkets
   ) {
     throw new Error("The server returned an invalid crypto board");
   }
-  const assets = data.assets.map(withValidStablecoinFields);
+  const legacy = data.dayChangeBasis !== "utc-day";
+  const assets = data.assets.map((asset) => {
+    const valid = withValidStablecoinFields(asset);
+    return legacy ? onUtcDayBasis(valid, now) : valid;
+  });
   return assets.every((asset, index) => asset === data.assets[index]) ? data : { ...data, assets };
 }
 

package/src/plugins/builtin/crypto-board/headless.ts

@@ -7,6 +7,7 @@ import { fetchCryptoMarkets, fetchStablecoinSupply } from "./client";
 import {
   buildCryptoRows,
   CRYPTO_BOARD_FRESHNESS,
+  CRYPTO_CHANGE_BASIS_LABEL,
   formatCryptoPercent,
   formatDayRangeTime,
   formatOffPeg,
@@ -30,7 +31,9 @@ const COIN_COLUMNS: HeadlessPaneColumn[] = [
   { key: "code", header: "Coin" },
   { key: "name", header: "Name" },
   { key: "price", header: "Price", align: "right", format: (_value, row) => String(row.priceText ?? "—") },
-  { key: "changePercent", header: "Chg %", align: "right", format: percent },
+  // Since 00:00 UTC, the day `quote` gives a coin (CRYPTO_CHANGE_BASIS_LABEL): the text says so, as the pane's
+  // CHG% UTC does, and an export keeps the header it has always had.
+  { key: "changePercent", header: "Chg %", textHeader: "Chg % UTC", align: "right", format: percent },
   { key: "return7d", header: "7D %", align: "right", format: percent },
   { key: "return30d", header: "30D %", align: "right", format: percent },
   { key: "return1y", header: "1Y %", align: "right", format: percent },
@@ -167,7 +170,7 @@ export const cryptoBoardHeadless: HeadlessPaneDefinition<"rows"> = {
         pegType: row.pegType,
       } : {}),
     }));
-    const metadata = { list: kind, status: data.status, asOf: data.asOf, generatedAt: data.generatedAt };
+    const metadata = { list: kind, status: data.status, asOf: data.asOf, generatedAt: data.generatedAt, changeBasis: CRYPTO_CHANGE_BASIS_LABEL };
     if (kind !== "stablecoin") return { rows, errors: data.warnings, metadata };
     const summary = supply ? supplySummaryLine(supply) : null;
     const history = supply ? supplyHistoryTable(supply) : null;

package/src/plugins/builtin/crypto-board/model.ts

@@ -57,6 +57,11 @@ export interface CryptoRow extends CryptoRowSupply {
   price: number;
   /** The price as the board prints it. */
   priceText: string;
+  /**
+   * The move since 00:00 UTC, from the previous UTC day's close, as `quote`
+   * measures a coin (CRYPTO_CHANGE_BASIS_LABEL); null when the coin has no
+   * such close to measure from.
+   */
   changePercent: number | null;
   return7d: number | null;
   return30d: number | null;
@@ -100,9 +105,28 @@ function closeDaysAgo(asset: CryptoMarketAsset, days: number, now: number): numb
   return isFiniteNumber(close) && close > 0 ? close : null;
 }
 
-const percentChange = (price: number, reference: number | null) =>
+const percentChange = (price: number, reference: number | null | undefined) =>
   reference != null && reference > 0 ? (price / reference - 1) * 100 : null;
 
+/** What the board's day change is measured from, as `quote` labels a coin's: its header says it (CHG% UTC). */
+export const CRYPTO_CHANGE_BASIS_LABEL = "since 00:00 UTC";
+
+/**
+ * A coin's move since 00:00 UTC, the basis `quote` gives a coin: its live
+ * quote's while that quote is measured from the previous close, otherwise the
+ * board's, which Gloom Cloud measures the same way (with a live price, from
+ * the board's previous close). A coin either says moves over 24 hours, or not
+ * at all, has none here, so the column never mixes the two.
+ */
+function utcDayChangePercent(asset: CryptoMarketAsset, quote: Quote | null, price: number): number | null {
+  if (quote && quote.changeBasis == null) {
+    if (isFiniteNumber(quote.changePercent)) return quote.changePercent;
+    if (positive(quote.previousClose)) return percentChange(price, quote.previousClose);
+  }
+  if (asset.changeBasis != null) return null;
+  return quote ? percentChange(price, asset.previousClose) : asset.changePercent;
+}
+
 /** A live quote replaces the board's snapshot once it is at least as new. */
 function liveQuote(
   asset: CryptoMarketAsset,
@@ -134,11 +158,7 @@ function buildCryptoRow(
   now = Date.now(),
 ): CryptoRow {
   const price = quote?.price ?? asset.price;
-  const changePercent = quote && isFiniteNumber(quote.changePercent)
-    ? quote.changePercent
-    : quote
-      ? percentChange(price, asset.previousClose)
-      : asset.changePercent;
+  const changePercent = utcDayChangePercent(asset, quote, price);
   // Supply moves slowly; the price is what makes market cap live. Scaling the
   // reported cap keeps the source's supply basis and the board's ranking.
   const marketCap = isFiniteNumber(asset.marketCap)
@@ -389,7 +409,7 @@ const COLUMN_SPECS: CryptoColumnSpec[] = [
   { id: "code", label: "COIN", width: 7, align: "left" },
   { id: "name", label: "NAME", width: 10, align: "left", optional: 1 },
   { id: "price", label: "PRICE", width: 13, align: "right" },
-  { id: "changePercent", label: "CHG%", width: 8, align: "right" },
+  { id: "changePercent", label: "CHG% UTC", title: "Change since 00:00 UTC", width: 8, align: "right" },
   { id: "return7d", label: "7D%", width: 8, align: "right" },
   { id: "return30d", label: "30D%", width: 8, align: "right", optional: 3 },
   { id: "return1y", label: "1Y%", width: 10, align: "right", optional: 5 },
@@ -415,7 +435,7 @@ const STABLECOIN_COLUMN_SPECS: CryptoColumnSpec[] = [
   { id: "low24hAt", label: "LOW UTC", width: 9, align: "left" },
   { id: "high24h", label: "24H HIGH", width: 8, align: "right", optional: 1 },
   { id: "high24hAt", label: "HIGH UTC", width: 9, align: "left", optional: 2 },
-  { id: "changePercent", label: "CHG%", width: 8, align: "right", optional: 5 },
+  { id: "changePercent", label: "CHG% UTC", title: "Change since 00:00 UTC", width: 8, align: "right", optional: 5 },
   { id: "return7d", label: "7D%", width: 8, align: "right", optional: 6 },
   { id: "return30d", label: "30D%", width: 8, align: "right", optional: 8 },
   { id: "return1y", label: "1Y%", width: 10, align: "right", optional: 9 },

package/src/plugins/builtin/custom-view/loader.ts

@@ -141,8 +141,9 @@ export async function trialLoadViewSource(
   });
   try {
     const loading = loadViewSource(spec, config, controller.signal, registry);
-    // A load that outlives the wait has nobody left to tell.
-    loading.catch(() => {});
+    loading.catch(() => {
+      // Intentional ignore: the race reports load failures; after timeout its result already explains the unchecked source.
+    });
     const outcome = await Promise.race([loading, timedOut]);
     if (outcome === "timeout") {
       return [`The source had not answered after ${Math.max(1, Math.round(timeoutMs / 1_000))} s, so it was not checked. The view opens and keeps loading.`];

package/src/plugins/builtin/custom-view/pane.tsx

@@ -14,6 +14,7 @@ import { PaneStatusBody, TextPromptDialog, usePaneFooter } from "../../../compon
 import { useAsyncResource } from "../../../react/async-resource";
 import { useShortcut } from "../../../react/input";
 import { isPlainKey } from "../../../utils/keyboard";
+import { logFailure } from "../../../utils/log-failure";
 import { usePaneInstance, usePaneAppConfig } from "../../../state/app/context";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
@@ -241,7 +242,7 @@ export function CustomViewPane({ focused, width, height }: PaneProps) {
               footer="Shift+Enter newline · Esc cancel"
             />
           ),
-        }).catch(() => undefined);
+        }).catch(logFailure("custom-view.pane", "The view revision prompt failed"));
         const edited = specText ? parseViewSpecOr(specText) : null;
         if (!edited) return;
         if ("error" in edited) throw new Error(edited.error);
@@ -268,7 +269,7 @@ export function CustomViewPane({ focused, width, height }: PaneProps) {
                 selectedChoiceId="reload"
               />
             ),
-          }).catch(() => undefined);
+          }).catch(logFailure("custom-view.pane", "The view conflict prompt failed"));
           if (choice === "overwrite") {
             const published = await apiClient.publishTeamViewRevision(current.id, {
               spec: edited.spec as unknown as Record<string, unknown>,
@@ -295,7 +296,7 @@ export function CustomViewPane({ focused, width, height }: PaneProps) {
               selectedChoiceId={defaultTeam ?? undefined}
             />
           ),
-        }).catch(() => undefined);
+        }).catch(logFailure("custom-view.pane", "The view team prompt failed"));
       if (!teamId) return;
       const name = await dialog.prompt<string>({
         content: (context: PromptContext<string>) => (
@@ -308,7 +309,7 @@ export function CustomViewPane({ focused, width, height }: PaneProps) {
             width={40}
           />
         ),
-      }).catch(() => undefined);
+      }).catch(logFailure("custom-view.pane", "The view name prompt failed"));
       if (!name) return;
       const created = await apiClient.createTeamView(teamId, {
         name,

package/src/plugins/builtin/custom-view/view-spec.ts

@@ -270,6 +270,7 @@ export function parseViewSpec(value: unknown): ViewSpec | null {
     try {
       decoded = JSON.parse(value);
     } catch {
+      // Intentional ignore: malformed input is represented by a null spec.
       return null;
     }
   }

package/src/plugins/builtin/dividend-yield/headless.ts

@@ -15,6 +15,7 @@ import type { Quote } from "../../../types/financials";
 import { regularSessionValuationPrice } from "../../../market-data/quotes/regular-session-valuation";
 import { dividendPriceStatus, dividendQuotePriceMetadata } from "./reference-price";
 import { mapWithConcurrency } from "../../../utils/concurrency";
+import { logFailure } from "../../../utils/log-failure";
 import { projectDividendRanking, roundedRatio, type DividendRankingEntry } from "./ranking";
 import { REPORT_FILTER, REPORT_ROWS } from "../shared/headless-options";
 import type { FundBondFacts } from "../../../api-client/fund-facts";
@@ -50,6 +51,9 @@ export interface DividendYieldHeadlessDependencies {
   loadTreasury?(context: HeadlessPaneContext): Promise<TreasuryTenor[] | null>;
 }
 
+/** Already logged at the quote boundary; keep it distinct from absent bond facts. */
+class BondClassificationError extends Error {}
+
 const defaultDependencies: DividendYieldHeadlessDependencies = {
   async loadData(symbol, context) {
     let currentPrice: number | null = null;
@@ -63,7 +67,8 @@ const defaultDependencies: DividendYieldHeadlessDependencies = {
       currentPrice = regularSessionValuationPrice(quote);
       currentPriceCurrency = quote.currency;
       referenceQuote = quote;
-    } catch {
+    } catch (error) {
+      logFailure("dividend-yield.headless", "Read dividend reference quote failed")(error);
       currentPrice = null;
     }
     const data = await fetchDividendData(symbol, currentPrice, exchange, currentPriceCurrency);
@@ -75,7 +80,11 @@ const defaultDependencies: DividendYieldHeadlessDependencies = {
   async loadBond(symbol, context) {
     const instrument = await context.resolveInstrument?.(symbol);
     const exchange = instrument?.exchange ?? "";
-    const quote = await context.marketData.getQuote(symbol, exchange).catch(() => undefined);
+    const quote = await context.marketData.getQuote(symbol, exchange)
+      .catch((error) => {
+        logFailure("dividend-yield.headless", "Read bond fund classification quote failed")(error);
+        throw new BondClassificationError("Bond fund quote check failed");
+      });
     const venue = exchange || quote?.exchangeName || "";
     if (resolveTickerInstrumentKind(null, { quote }) !== "fund" || (venue && !isUsListingExchange(venue))) return null;
     return fetchFundBondFacts(instrument?.symbol ?? symbol, context.apiClient);
@@ -125,7 +134,7 @@ export function projectDividendYieldHeadless(
   const metrics = data.metrics;
   const currency = data.currency ?? data.payments[0]?.currency ?? "";
   const priceStatus = dividendPriceStatus(data.price, data.priceAsOf, data.priceStale);
-  const errors = [data.historyError, data.summaryError].filter((error): error is string => !!error);
+  const errors = [data.historyError, data.summaryError, tax?.checkError].filter((error): error is string => !!error);
 
   return {
     ...(errors.length > 0 ? { complete: false, errors } : {}),
@@ -249,15 +258,26 @@ export function createDividendYieldHeadless(
       // One symbol is its full report; several are one table ranked by yield.
       if (args.symbols.length <= 1) {
         const symbol = args.symbols[0] ?? String(args.argument);
+        let bondCheckError: string | undefined;
         const [data, bond, treasury] = await Promise.all([
           dependencies.loadData(symbol, context),
-          // A fund's bond facts never fail the report: without them its yields read as before.
-          dependencies.loadBond?.(symbol, context).catch(() => null) ?? null,
-          rates ? dependencies.loadTreasury?.(context).catch(() => null) ?? null : null,
+          // Optional enrichment without a tax rate; a requested tax check must distinguish failure from absence.
+          dependencies.loadBond?.(symbol, context)
+            .catch((error) => {
+              if (error instanceof BondClassificationError) {
+                bondCheckError = error.message;
+              } else {
+                logFailure("dividend-yield.headless", "Read bond fund facts for report failed")(error);
+                bondCheckError = "Bond fund facts check failed";
+              }
+              return null;
+            }) ?? null,
+          rates ? dependencies.loadTreasury?.(context)
+            .catch(logFailure("dividend-yield.headless", "Read Treasury curve for tax comparison failed", null)) ?? null : null,
         ]);
         const forward = data.metrics.lapse ? null : distributionBasis(data.metrics.forwardYield, "forward", data.metrics.forwardRateAsOf ?? null);
         const tax = rates ? analyzeTaxEquivalent({
-          symbol: symbol.toUpperCase(), bond, rates, treasury,
+          symbol: symbol.toUpperCase(), bond, rates, treasury, checkError: bondCheckError,
           distribution: forward ?? distributionBasis(data.metrics.trailingYield, "trailing"),
         }) : null;
         return projectDividendYieldHeadless(data, args, { bond, tax });
@@ -275,7 +295,9 @@ export function createDividendYieldHeadless(
       }
       const entries = await mapWithConcurrency(args.symbols, RANKING_CONCURRENCY, async (symbol): Promise<DividendRankingEntry> => {
         // A fund's bond facts never fail its row: without them it ranks as before.
-        const bond = dependencies.loadBond?.(symbol, context).catch(() => null) ?? null;
+        const bond = dependencies.loadBond?.(symbol, context)
+          .catch((error) => error instanceof BondClassificationError ? null
+            : logFailure("dividend-yield.headless", "Read bond fund facts for ranking failed", null)(error)) ?? null;
         try {
           return { symbol, data: await dependencies.loadData(symbol, context), bond: await bond };
         } catch (error) {

package/src/plugins/builtin/dividend-yield/provider-client.ts

@@ -3,6 +3,7 @@ import { regularSessionValuationPrice } from "../../../market-data/quotes/regula
 import { resolveCurrencyUnit } from "../../../utils/currency-units";
 import { cashInMajorUnits } from "../../../utils/dividend-cash";
 import { dividendReferencePrice } from "../../../utils/trailing-dividend";
+import { logFailure } from "../../../utils/log-failure";
 import { buildDividendMetrics, INCOMPLETE_DIVIDEND_HISTORY, MISSING_DIVIDEND_CURRENCY, toDividendPayment, type DividendData } from "./client";
 import { dividendQuotePriceMetadata } from "./reference-price";
 
@@ -17,7 +18,8 @@ export async function fetchProviderDividendData(
   if (!provider.getCorporateActions) throw new Error("Dividend history source unavailable.");
   const [sourceActions, quote] = await Promise.all([
     provider.getCorporateActions(symbol, exchange),
-    provider.getQuote(symbol, exchange).catch(() => null),
+    provider.getQuote(symbol, exchange)
+      .catch(logFailure("dividend-yield.provider-client", "Read dividend reference quote failed", null)),
   ]);
   // In the major unit as the history arrives, as the provider router serves it.
   const actions = cashInMajorUnits(sourceActions);

package/src/plugins/builtin/earnings-calls/headless.ts

@@ -70,8 +70,8 @@ const defaultDependencies: EarningsCallsHeadlessDependencies = {
 };
 
 /** A refused read says what the lock note says (CALLS is Pro whole), so a free account meets the same words as a signed-out one. */
-function explainDenied(ticker: string | null) {
-  return (error: unknown): never => { throw explainRefusal(error, callsLockNote, { symbol: ticker }); };
+function explainDenied(ticker: string | null, context: HeadlessPaneContext) {
+  return async (error: unknown): Promise<never> => { throw await explainRefusal(error, callsLockNote, { symbol: ticker, context }); };
 }
 
 function callRow(call: CloudEarningsCallPayload) {
@@ -285,7 +285,7 @@ export function createEarningsCallsHeadless(
     },
     async load(args, context) {
       const ticker = typeof args.argument === "string" ? args.argument : null;
-      const calls = await dependencies.loadCalls(ticker, 200, context).catch(explainDenied(ticker));
+      const calls = await dependencies.loadCalls(ticker, 200, context).catch(explainDenied(ticker, context));
       if (!ticker || !readsTranscript(args)) {
         return projectEarningsCallsHeadless(calls, { ...args, options: { ...args.options, limit: args.options.limit ?? 50 } });
       }
@@ -299,7 +299,7 @@ export function createEarningsCallsHeadless(
         }
         throw new Error(`No ${quarter} earnings call found for ${ticker}.`);
       }
-      const transcript = await dependencies.loadTranscript(selected.id, context).catch(explainDenied(ticker));
+      const transcript = await dependencies.loadTranscript(selected.id, context).catch(explainDenied(ticker, context));
       if (isPendingTranscript(transcript)) {
         throw new Error(`Transcript for ${ticker} ${quarter} is still being produced.`);
       }

package/src/plugins/builtin/earnings-calls/lock-note.ts

@@ -1,17 +1,26 @@
 import type { PaneLock } from "../../../types/plugin";
-import { proLockNote } from "../shared/pro-lock-note";
+import { resolveHeadlessInstrument } from "../shared/headless-market-data";
+import { proLockNote, type FreeRoute } from "../shared/pro-lock-note";
+
+const EVENTS_ROUTE: FreeRoute = {
+  text: (ticker, company) => `gloomberb events ${ticker} lists ${company}'s earnings dates, with the EPS reported at each and the next estimate.`,
+  answers: async (symbol, context) => {
+    const { symbol: ticker, exchange } = await resolveHeadlessInstrument(context, symbol);
+    return ((await context.marketData.getCorporateActions?.(ticker, exchange))?.earnings.length ?? 0) > 0;
+  },
+};
 
 /**
  * CALLS is Pro whole, the list of calls included. `events` needs no account
  * and lists a company's earnings dates, each with the EPS it reported and the
  * next one's estimate, without the call or its transcript.
  */
-export function callsLockNote(lock: PaneLock): string {
+export function callsLockNote(lock: PaneLock): Promise<string> {
   return proLockNote(lock, {
     token: "CALLS",
     argument: "optional",
     does: "it reads each earnings call into a transcript with speaker turns, analyst Q&A and extracted guidance",
     shows: "it",
-    free: (ticker, company) => `gloomberb events ${ticker} lists ${company}'s earnings dates, with the EPS reported at each and the next estimate.`,
+    free: [EVENTS_ROUTE],
   });
 }

package/src/plugins/builtin/econ/calendar-model.ts

@@ -14,7 +14,8 @@ const CACHE_POLICY = {
 } as const;
 
 export type ImpactFilter = "high" | "medium" | "low" | "all";
-export type CountryFilter = "all" | "US" | "G7" | "EU";
+/** A region the pane cycles through, or one country by its two-letter code (`econ --country TR`). */
+export type CountryFilter = "all" | "US" | "G7" | "EU" | (string & {});
 
 export const FILTER_CYCLE: ImpactFilter[] = ["all", "high", "medium", "low"];
 /**
@@ -187,7 +188,38 @@ export function matchesCountry(event: EconEvent, filter: CountryFilter): boolean
   if (filter === "US") return event.country === "US";
   if (filter === "G7") return G7_COUNTRIES.has(event.country);
   if (filter === "EU") return event.country === "EU";
-  return true;
+  return event.country === filter;
+}
+
+/**
+ * How long after its release time a high-impact print is still news: the
+ * calendar is asked for it this long, and a print that turns up later is
+ * recorded without a toast.
+ */
+export const PRINT_PENDING_MS = 20 * 60 * 1000;
+
+/** High-impact releases whose time has come in the last {@link PRINT_PENDING_MS} and that have no actual yet. */
+export function pendingHighImpactPrints(events: readonly EconEvent[], now: number): EconEvent[] {
+  return events.filter((event) => {
+    if (event.impact !== "high" || event.actual) return false;
+    const releasedFor = now - event.date.getTime();
+    return releasedFor >= 0 && releasedFor <= PRINT_PENDING_MS;
+  });
+}
+
+export function hasPendingHighImpactPrint(events: readonly EconEvent[], now: number): boolean {
+  return pendingHighImpactPrints(events, now).length > 0;
+}
+
+/** High-impact rows that were blank in `previous` and have an actual in `next`. */
+export function landedHighImpactPrints(
+  previous: ReadonlyMap<string, string | null>,
+  next: readonly EconEvent[],
+): EconEvent[] {
+  return next.filter((event) => {
+    if (event.impact !== "high" || !event.actual || !previous.has(event.id)) return false;
+    return !previous.get(event.id);
+  });
 }
 
 export function formatCountdown(ms: number): string {
@@ -228,6 +260,10 @@ export function getCalendarCache(options?: { allowExpired?: boolean }): EconCale
   return cache.get(CACHE_KEY, options);
 }
 
+export function subscribeCalendar(listener: () => void): () => void {
+  return cache.subscribe(CACHE_KEY, listener);
+}
+
 export interface EconCalendarLoadResult extends EconCalendarCacheEntry {
   refreshError?: string;
 }

package/src/plugins/builtin/econ/fred-catalog.ts

@@ -1,4 +1,4 @@
-import { fredSeriesUrl } from "../../../sources/gloomberb-cloud/fred-series";
+import { fredSeriesUrl, seriesNotOnFred } from "../../../sources/gloomberb-cloud/fred-series";
 import type { SeriesDefinition, SeriesFrequency } from "../../../series/types";
 
 type FredRow = readonly [seriesId: string, name: string, unit: string, frequency: SeriesFrequency, tags?: readonly string[]];
@@ -8,6 +8,8 @@ type FredRow = readonly [seriesId: string, name: string, unit: string, frequency
  * maturities (UST:2Y and so on, from the yield curve) and the credit spreads
  * and yields (from the credit plugin). Ids follow the server's allowlist: a
  * series added there is listed here to reach the catalog.
+ * Türkiye's CPI is served the same way but is not on FRED; its rows name
+ * TurkStat (`seriesNotOnFred`).
  */
 const GROUPS: ReadonlyArray<{ group: string; rows: readonly FredRow[] }> = [
   {
@@ -123,6 +125,8 @@ const GROUPS: ReadonlyArray<{ group: string; rows: readonly FredRow[] }> = [
       ["T5YIE", "5Y breakeven inflation", "%", "daily", ["breakeven", "expectations", "TIPS"]],
       ["T10YIE", "10Y breakeven inflation", "%", "daily", ["breakeven", "expectations", "TIPS"]],
       ["T5YIFR", "5Y, 5Y forward inflation expectation", "%", "daily", ["breakeven", "expectations", "5y5y"]],
+      ["TURCPIYOY", "Türkiye CPI, y/y", "%", "monthly", ["CPI", "headline", "Turkey", "TR", "inflation", "lira"]],
+      ["TURCPIMOM", "Türkiye CPI, m/m", "%", "monthly", ["CPI", "headline", "Turkey", "TR", "inflation", "lira"]],
     ],
   },
   {
@@ -191,7 +195,7 @@ export const FRED_CATALOG_SERIES: readonly SeriesDefinition[] = GROUPS.flatMap((
     frequency,
     group,
     ...(tags?.length ? { tags } : {}),
-    publisher: "FRED",
+    publisher: seriesNotOnFred(seriesId)?.publisher ?? "FRED",
     url: fredSeriesUrl(seriesId),
     expression: `FRED:${seriesId}`,
   }))

package/src/plugins/builtin/econ/fred-series-map.ts

@@ -51,12 +51,23 @@ const SERIES_MAP: Record<string, FredMapping> = {
   "unit labor costs q/q": { seriesId: "ULCNFB", displayMode: "qoq-annualized", relatedTickers: ["SPY", "^TNX"] },
 };
 
+/** Other countries' releases Gloom Cloud serves a series for, by country and normalized title. */
+const COUNTRY_SERIES_MAP: Record<string, Record<string, FredMapping>> = {
+  // TurkStat's CPI, published as percent changes; the related ticker is the US-listed MSCI Turkey ETF.
+  TR: {
+    "cpi y/y": { seriesId: "TURCPIYOY", displayMode: "level", relatedTickers: ["TUR"] },
+    "cpi m/m": { seriesId: "TURCPIMOM", displayMode: "level", relatedTickers: ["TUR"] },
+  },
+};
+
 function normalizeEventTitle(title: string): string {
   return title.toLowerCase().trim();
 }
 
 export function resolveFredMapping(eventTitle: string, country: string): FredMapping | null {
-  // Only US events have FRED data
+  const elsewhere = COUNTRY_SERIES_MAP[country];
+  if (elsewhere) return elsewhere[normalizeEventTitle(eventTitle)] ?? null;
+  // Otherwise only US events have FRED data
   if (country !== "US" && country !== "USD") return null;
 
   const normalized = normalizeEventTitle(eventTitle);