gloomberb 0.18.1 → 0.18.2

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/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

@@ -191,6 +191,37 @@ export function matchesCountry(event: EconEvent, filter: CountryFilter): boolean
   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 {
   if (ms <= 60_000) return "in <1m";
   const totalMin = Math.floor(ms / 60_000);
@@ -229,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/index.tsx

@@ -20,6 +20,7 @@ import type { PluginModule } from "../plugin-module";
 import { colors, blendHex } from "../../../theme/colors";
 import type { EconEvent } from "./types";
 import { FRED_CATALOG_SERIES } from "./fred-catalog";
+import { ECON_PRINT_NOTIFICATIONS_ENABLED_KEY, retainVisiblePrintRefresh, setupHighImpactPrintNotifications } from "./print-watch";
 import { EconDetailView } from "./detail-view";
 import {
   COUNTRY_CYCLE,
@@ -35,6 +36,7 @@ import {
   formatCountdown,
   formatStaleness,
   getCalendarCache,
+  subscribeCalendar,
   impactIndicator,
   loadCalendar,
   matchesCountry,
@@ -75,10 +77,16 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
   // loadCalendar serves a fresh cache without a request, so the pane can always
   // ask and still follow the global cadence once the cache goes stale.
   const calendar = useAsyncResource<CalendarResult>(loadEvents, { initialData: cachedEvents });
+  // A load made elsewhere, such as the print watch asking while a release is
+  // due, reaches the open pane through the cache; the newer of the two wins.
+  const [cacheVersion, setCacheVersion] = useState(0);
+  useEffect(() => subscribeCalendar(() => setCacheVersion((version) => version + 1)), []);
+  const cached = useMemo(() => getCalendarCache(), [cacheVersion]);
+  const shown = cached && (!calendar.data || cached.fetchedAt > calendar.data.fetchedAt) ? cached : calendar.data;
   const { loading } = calendar;
-  const events = calendar.data?.data ?? NO_EVENTS;
-  const stale = calendar.data?.stale ?? false;
-  const fetchedAt = calendar.data?.fetchedAt ?? null;
+  const events = shown?.data ?? NO_EVENTS;
+  const stale = shown?.stale ?? false;
+  const fetchedAt = shown?.fetchedAt ?? null;
   // A cache that could not be refreshed arrives as a result, not a failure.
   const error = calendar.error ?? (loading ? null : calendar.data?.refreshError ?? null);
   // The selected row and the open event are remembered by event id, so a
@@ -94,8 +102,11 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
 
   useAutoRefresh(stale ? null : fetchedAt, calendar.load);
 
-  // Tick every 30s to update staleness + countdown, only while the pane can be seen.
   const paneVisible = usePaneVisible();
+  // In view, a due high-impact print is asked for on the print watch's timing
+  // and lands here through the cache; a covered or hidden pane asks nothing.
+  useEffect(() => (paneVisible ? retainVisiblePrintRefresh() : undefined), [paneVisible]);
+  // Tick every 30s to update staleness + countdown, only while the pane can be seen.
   useEffect(() => {
     if (!paneVisible) return;
     setNow(Date.now());
@@ -437,6 +448,8 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
   );
 }
 
+let stopPrintWatch: (() => void) | null = null;
+
 export const economicCalendarModule: PluginModule = {
   series: FRED_CATALOG_SERIES,
   panes: [{
@@ -449,6 +462,16 @@ export const economicCalendarModule: PluginModule = {
     defaultMode: "floating",
     defaultFloatingSize: { width: 100, height: 30 },
     tableExport: true,
+    settings: {
+      title: "Economic Calendar Settings",
+      fields: [{
+        key: ECON_PRINT_NOTIFICATIONS_ENABLED_KEY,
+        label: "Notifications",
+        description: "Notify when a high-impact release prints, even while this pane is closed.",
+        type: "toggle",
+        storage: "plugin",
+      }],
+    },
   }],
   paneTemplates: [{
     id: "econ-calendar-pane",
@@ -461,8 +484,12 @@ export const economicCalendarModule: PluginModule = {
   }],
   setup(ctx) {
     attachEconCalendarPersistence(ctx.persistence);
+    stopPrintWatch?.();
+    stopPrintWatch = setupHighImpactPrintNotifications(ctx);
   },
   dispose() {
+    stopPrintWatch?.();
+    stopPrintWatch = null;
     resetEconCalendarPersistence();
   },
 };