gloomberb 0.10.4 → 0.11.0

package/src/plugins/builtin/dividend-yield/pane.tsx

@@ -0,0 +1,305 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, TextAttributes } from "../../../ui";
+import {
+  DataTableView,
+  StaticChartSurface,
+  usePaneFooter,
+  usePaneTicker,
+  type DataTableCell,
+  type DataTableKeyEvent,
+} from "../../../components";
+import type { ProjectedChartPoint } from "../../../components/chart/core/data";
+import { resolveChartPalette } from "../../../components/chart/core/renderer";
+import { colors, priceColor } from "../../../theme/colors";
+import { formatCurrency, formatNumber, formatPercentRaw } from "../../../utils/format";
+import { handleRefreshKey, loadingErrorFooterInfo } from "../shared/table-pane";
+import { fetchDividendData, type DividendData } from "./client";
+import {
+  buildDividendColumns,
+  DEFAULT_SORT_PREFERENCE,
+  nextSortPreference,
+  sortRows,
+  toDividendRows,
+  type DividendColumn,
+  type DividendRow,
+  type DividendSortPreference,
+} from "./model";
+import type { DividendMetrics, DividendPayment } from "./types";
+
+function formatYield(value: number | null): string {
+  if (value == null) return "—";
+  return `${(value * 100).toFixed(2)}%`;
+}
+
+function formatRate(value: number | null, currency: string): string {
+  if (value == null) return "—";
+  return formatCurrency(value, currency);
+}
+
+function formatGrowth(value: number | null): string {
+  if (value == null) return "—";
+  return formatPercentRaw(value * 100);
+}
+
+function formatDate(date: Date | null): string {
+  if (!date) return "—";
+  return date.toISOString().slice(0, 10);
+}
+
+function formatFrequency(freq: DividendMetrics["paymentFrequency"]): string {
+  if (!freq) return "—";
+  switch (freq) {
+    case "monthly": return "Monthly";
+    case "quarterly": return "Quarterly";
+    case "semi-annual": return "Semi-Annual";
+    case "annual": return "Annual";
+    case "irregular": return "Irregular";
+  }
+}
+
+interface MetricRow {
+  label: string;
+  value: string;
+  color?: string;
+  bold?: boolean;
+}
+
+function buildMetricRows(metrics: DividendMetrics, currency: string): MetricRow[] {
+  return [
+    { label: "Trailing Yield", value: formatYield(metrics.trailingYield), color: priceColor(metrics.trailingYield ?? 0), bold: true },
+    { label: "Forward Yield", value: formatYield(metrics.forwardYield), color: priceColor(metrics.forwardYield ?? 0) },
+    { label: "Trailing Rate", value: formatRate(metrics.trailingRate, currency) },
+    { label: "Forward Rate", value: formatRate(metrics.forwardRate, currency) },
+    { label: "1Y Growth", value: formatGrowth(metrics.growth1Y), color: priceColor(metrics.growth1Y ?? 0) },
+    { label: "3Y Growth", value: formatGrowth(metrics.growth3Y), color: priceColor(metrics.growth3Y ?? 0) },
+    { label: "Payout Ratio", value: metrics.payoutRatio != null ? `${(metrics.payoutRatio * 100).toFixed(1)}%` : "—" },
+    { label: "Frequency", value: formatFrequency(metrics.paymentFrequency) },
+    { label: "Ex-Dividend", value: formatDate(metrics.exDividendDate) },
+    { label: "Next Pay", value: formatDate(metrics.nextPayDate) },
+  ];
+}
+
+function buildYieldChartPoints(payments: DividendPayment[], currentPrice: number | null): ProjectedChartPoint[] {
+  if (payments.length === 0 || currentPrice == null || currentPrice <= 0) return [];
+  const sorted = [...payments].sort((a, b) => a.exDate.getTime() - b.exDate.getTime());
+  const DAY = 24 * 60 * 60 * 1000;
+  const points: ProjectedChartPoint[] = [];
+
+  for (const payment of sorted) {
+    const trailingCutoff = new Date(payment.exDate.getTime() - 365 * DAY);
+    const trailingSum = sorted
+      .filter((p) => p.exDate >= trailingCutoff && p.exDate <= payment.exDate)
+      .reduce((sum, p) => sum + p.amount, 0);
+    const yieldPct = (trailingSum / currentPrice) * 100;
+    points.push({
+      date: payment.exDate,
+      open: yieldPct,
+      high: yieldPct,
+      low: yieldPct,
+      close: yieldPct,
+      volume: 0,
+    });
+  }
+
+  return points;
+}
+
+function renderMetricCell(row: MetricRow, width: number) {
+  const valueWidth = Math.min(row.value.length, Math.max(6, width - 8));
+  const labelWidth = Math.max(8, width - valueWidth - 1);
+  return (
+    <Box height={1} flexDirection="row">
+      <Text fg={colors.textDim}>{row.label.slice(0, labelWidth).padEnd(labelWidth)}</Text>
+      <Text
+        fg={row.color ?? colors.text}
+        attributes={row.bold ? TextAttributes.BOLD : undefined}
+      >
+        {row.value}
+      </Text>
+    </Box>
+  );
+}
+
+const MIN_METRIC_COLUMN_WIDTH = 18;
+
+function DividendSummary({
+  metrics,
+  currency,
+  width,
+  chartPoints,
+}: {
+  metrics: DividendMetrics;
+  currency: string;
+  width: number;
+  chartPoints: ProjectedChartPoint[];
+}) {
+  const metricRows = buildMetricRows(metrics, currency);
+  // Two 18-cell blocks overflow anything narrower than 38 cells, so collapse.
+  const columnCount = width - 2 >= MIN_METRIC_COLUMN_WIDTH * 2 ? 2 : 1;
+  const colWidth = Math.max(MIN_METRIC_COLUMN_WIDTH, Math.floor((width - 2) / columnCount));
+  const rowCount = Math.ceil(metricRows.length / columnCount);
+  const chartHeight = chartPoints.length >= 2 ? 6 : 0;
+  const palette = resolveChartPalette(colors, "positive");
+
+  return (
+    <Box flexDirection="column">
+      <Box flexDirection="column" paddingX={1} height={rowCount}>
+        {Array.from({ length: rowCount }, (_, i) => {
+          const left = metricRows[i * columnCount]!;
+          const right = columnCount > 1 ? metricRows[i * columnCount + 1] : undefined;
+          return (
+            <Box key={left.label} height={1} flexDirection="row">
+              <Box width={colWidth}>{renderMetricCell(left, colWidth)}</Box>
+              {right ? <Box width={colWidth}>{renderMetricCell(right, colWidth)}</Box> : null}
+            </Box>
+          );
+        })}
+      </Box>
+      {chartPoints.length >= 2 && (
+        <Box flexDirection="column" paddingX={1} height={chartHeight}>
+          <StaticChartSurface
+            points={chartPoints}
+            width={Math.max(10, width - 2)}
+            height={chartHeight}
+            mode="line"
+            colors={palette}
+            yAxisLabel="Yield %"
+            yAxisColor={colors.textDim}
+            formatYAxisValue={(value) => `${value.toFixed(2)}%`}
+          />
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+function renderCell(
+  row: DividendRow,
+  column: DividendColumn,
+  _index: number,
+  rowState: { selected: boolean },
+): DataTableCell {
+  const selectedColor = rowState.selected ? colors.selectedText : undefined;
+  switch (column.id) {
+    case "exDate":
+      return { text: row.exDate, color: selectedColor ?? colors.textDim };
+    case "amount":
+      return {
+        text: formatNumber(row.amount, 4),
+        color: selectedColor ?? colors.textBright,
+        attributes: TextAttributes.BOLD,
+      };
+    case "currency":
+      return { text: row.currency, color: selectedColor ?? colors.textDim };
+  }
+}
+
+export function DividendYieldPane({ focused, width, height }: { focused: boolean; width: number; height: number }) {
+  const { symbol, ticker, financials } = usePaneTicker();
+  const currency = ticker?.metadata.currency ?? "USD";
+  const quotePrice = financials?.quote?.price ?? null;
+
+  const [data, setData] = useState<DividendData | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [sortPreference, setSortPreference] = useState<DividendSortPreference>(DEFAULT_SORT_PREFERENCE);
+  const [selectedIdx, setSelectedIdx] = useState(0);
+  const fetchGenRef = useRef(0);
+
+  const load = useCallback(async (sym: string, price: number | null) => {
+    fetchGenRef.current += 1;
+    const gen = fetchGenRef.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await fetchDividendData(sym, price);
+      if (fetchGenRef.current !== gen) return;
+      setData(result);
+      setSelectedIdx(0);
+    } catch (err) {
+      if (fetchGenRef.current !== gen) return;
+      setError(err instanceof Error ? err.message : String(err));
+      setData(null);
+    } finally {
+      if (fetchGenRef.current === gen) setLoading(false);
+    }
+  }, []);
+
+  // Ten years of history must not be refetched on every live price tick, so the
+  // quote is read through a ref instead of being an effect dependency.
+  const quotePriceRef = useRef(quotePrice);
+  quotePriceRef.current = quotePrice;
+
+  useEffect(() => {
+    if (!symbol) {
+      setData(null);
+      setError(null);
+      setLoading(false);
+      return;
+    }
+    void load(symbol, quotePriceRef.current);
+  }, [load, symbol]);
+
+  const refresh = useCallback(() => {
+    if (symbol) void load(symbol, quotePriceRef.current);
+  }, [load, symbol]);
+
+  usePaneFooter("dividend-yield", () => ({
+    info: loadingErrorFooterInfo(loading, error),
+  }), [error, loading]);
+
+  const payments = data?.payments ?? [];
+  const metrics = data?.metrics;
+  const rows = useMemo(() => toDividendRows(payments), [payments]);
+  const sortedRows = useMemo(() => sortRows(rows, sortPreference), [rows, sortPreference]);
+  const columns = useMemo(() => buildDividendColumns(width), [width]);
+  const chartPoints = useMemo(
+    () => buildYieldChartPoints(payments, data?.price ?? quotePrice),
+    [data?.price, payments, quotePrice],
+  );
+
+  const handleHeaderClick = useCallback((columnId: string) => {
+    setSortPreference((current) => nextSortPreference(current, columnId));
+  }, []);
+
+  const handleKeyDown = useCallback((event: DataTableKeyEvent) => {
+    return handleRefreshKey(event, refresh, { stopPropagation: true });
+  }, [refresh]);
+
+  const emptyTitle = !symbol
+    ? "No ticker selected."
+    : loading
+      ? "Loading dividends..."
+      : error ?? "No dividend history";
+
+  return (
+    <DataTableView<DividendRow, DividendColumn>
+      focused={focused}
+      selection={{
+        kind: "index",
+        selectedIndex: sortedRows.length === 0 ? null : Math.min(selectedIdx, sortedRows.length - 1),
+        onChange: (index) => setSelectedIdx(index),
+      }}
+      onRootKeyDown={handleKeyDown}
+      resetScrollKey={symbol}
+      rootWidth={width}
+      rootHeight={height}
+      rootBefore={metrics ? (
+        <DividendSummary
+          metrics={metrics}
+          currency={payments[0]?.currency ?? currency}
+          width={width}
+          chartPoints={chartPoints}
+        />
+      ) : undefined}
+      columns={columns}
+      items={sortedRows}
+      sortColumnId={sortPreference.columnId}
+      sortDirection={sortPreference.direction}
+      onHeaderClick={handleHeaderClick}
+      getItemKey={(row) => row.key}
+      renderCell={renderCell}
+      emptyStateTitle={emptyTitle}
+    />
+  );
+}

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

@@ -0,0 +1,22 @@
+export interface DividendPayment {
+  exDate: Date;
+  recordDate: Date | null;
+  paymentDate: Date | null;
+  declarationDate: Date | null;
+  amount: number;
+  currency: string;
+  type: "cash" | "special" | "stock" | "unknown";
+}
+
+export interface DividendMetrics {
+  trailingYield: number | null;
+  forwardYield: number | null;
+  trailingRate: number | null;
+  forwardRate: number | null;
+  payoutRatio: number | null;
+  growth1Y: number | null;
+  growth3Y: number | null;
+  paymentFrequency: "monthly" | "quarterly" | "semi-annual" | "annual" | "irregular" | null;
+  exDividendDate: Date | null;
+  nextPayDate: Date | null;
+}

package/src/plugins/builtin/earnings/data/cache.test.ts

@@ -63,9 +63,9 @@ describe("loadEarningsCalendar", () => {
     const msft = await loadEarningsCalendar(provider, ["MSFT"]);
     const aaplAgain = await loadEarningsCalendar(provider, ["aapl"]);
 
-    expect(aapl.map((event) => event.symbol)).toEqual(["AAPL"]);
-    expect(msft.map((event) => event.symbol)).toEqual(["MSFT"]);
-    expect(aaplAgain.map((event) => event.symbol)).toEqual(["AAPL"]);
+    expect(aapl.events.map((event) => event.symbol)).toEqual(["AAPL"]);
+    expect(msft.events.map((event) => event.symbol)).toEqual(["MSFT"]);
+    expect(aaplAgain.events.map((event) => event.symbol)).toEqual(["AAPL"]);
     expect(calls).toEqual([["AAPL"], ["MSFT"]]);
   });
 
@@ -85,10 +85,13 @@ describe("loadEarningsCalendar", () => {
       throw new Error("offline");
     });
 
-    const events = await loadEarningsCalendar(provider, ["AAPL"], { force: true });
+    const result = await loadEarningsCalendar(provider, ["AAPL"], { force: true });
 
-    expect(events).toHaveLength(1);
-    expect(events[0]!.symbol).toBe("AAPL");
-    expect(events[0]!.earningsDate).toBeInstanceOf(Date);
+    expect(result.events).toHaveLength(1);
+    expect(result.events[0]!.symbol).toBe("AAPL");
+    expect(result.events[0]!.earningsDate).toBeInstanceOf(Date);
+    // Cached events after a provider failure are stale, not a fresh load.
+    expect(result.stale).toBe(true);
+    expect(result.refreshError).toContain("offline");
   });
 });

package/src/plugins/builtin/earnings/data/cache.ts

@@ -21,9 +21,17 @@ type PersistedEarningsEvent = Omit<EarningsEvent, "earningsDate" | "earningsCall
   earningsCallDate?: string | null;
 };
 
+export interface EarningsCalendarResult {
+  events: EarningsEvent[];
+  fetchedAt: number;
+  /** True when the provider failed and cached events were served instead. */
+  stale: boolean;
+  refreshError?: string;
+}
+
 let earningsPersistence: PluginPersistence | null = null;
 const memoryCache = new Map<string, MemoryCacheEntry>();
-const activeFetches = new Map<string, Promise<EarningsEvent[]>>();
+const activeFetches = new Map<string, Promise<EarningsCalendarResult>>();
 
 export function attachEarningsCalendarPersistence(persistence: PluginPersistence): void {
   earningsPersistence = persistence;
@@ -98,22 +106,24 @@ export async function loadEarningsCalendar(
   provider: DataProvider | null | undefined,
   symbols: string[],
   options?: { force?: boolean },
-): Promise<EarningsEvent[]> {
+): Promise<EarningsCalendarResult> {
   const normalizedSymbols = normalizeEarningsSymbols(symbols);
-  if (normalizedSymbols.length === 0 || !provider?.getEarningsCalendar) return [];
+  if (normalizedSymbols.length === 0 || !provider?.getEarningsCalendar) {
+    return { events: [], fetchedAt: Date.now(), stale: false };
+  }
 
   const key = buildEarningsCacheKey(normalizedSymbols);
   const force = options?.force ?? false;
   const memoryEntry = memoryCache.get(key);
   if (!force && memoryEntry && Date.now() - memoryEntry.fetchedAt < EARNINGS_CALENDAR_CACHE_POLICY.staleMs) {
-    return memoryEntry.data;
+    return { events: memoryEntry.data, fetchedAt: memoryEntry.fetchedAt, stale: false };
   }
 
   const freshPersisted = readPersistedCache(key);
   if (!force && freshPersisted && !freshPersisted.stale) {
     const data = deserializeEvents(freshPersisted.value);
     memoryCache.set(key, { data, fetchedAt: freshPersisted.fetchedAt });
-    return data;
+    return { events: data, fetchedAt: freshPersisted.fetchedAt, stale: false };
   }
 
   const activeFetch = activeFetches.get(key);
@@ -122,16 +132,20 @@ export async function loadEarningsCalendar(
   const fetchPromise = provider.getEarningsCalendar(normalizedSymbols)
     .then((data) => {
       writeCache(key, data);
-      return data;
+      return { events: data, fetchedAt: Date.now(), stale: false };
     })
-    .catch((error) => {
+    .catch((error: unknown) => {
+      // Cached events survive a provider outage, but never as a fresh load.
+      const refreshError = error instanceof Error ? error.message : String(error);
       const stalePersisted = freshPersisted ?? readPersistedCache(key, { allowExpired: true });
       if (stalePersisted) {
         const data = deserializeEvents(stalePersisted.value);
         memoryCache.set(key, { data, fetchedAt: stalePersisted.fetchedAt });
-        return data;
+        return { events: data, fetchedAt: stalePersisted.fetchedAt, stale: true, refreshError };
+      }
+      if (memoryEntry) {
+        return { events: memoryEntry.data, fetchedAt: memoryEntry.fetchedAt, stale: true, refreshError };
       }
-      if (memoryEntry) return memoryEntry.data;
       throw error;
     })
     .finally(() => {

package/src/plugins/builtin/earnings/index.tsx

@@ -6,6 +6,9 @@ import type { EarningsEvent } from "../../../types/data-provider";
 import { useAppSelector, usePaneInstance } from "../../../state/app/context";
 import { parseTickerListInput, formatTickerListInput } from "../../../tickers/list";
 import { useAssetData, usePluginPaneState, usePluginTickerActions } from "../../runtime";
+import { useAutoRefresh } from "../shared/auto-refresh";
+import type { PaneSettingsContext, PaneSettingsDef } from "../../../types/plugin";
+import { formatTickerListInput as formatTickers } from "../../../tickers/list";
 import {
   attachEarningsCalendarPersistence,
   loadEarningsCalendar,
@@ -32,8 +35,11 @@ function EarningsCalendarPane({ focused, width, height }: PaneProps) {
   const { navigateTicker } = usePluginTickerActions();
   const pane = usePaneInstance();
   const [events, setEvents] = useState<EarningsEvent[]>([]);
-  const [loading, setLoading] = useState(false);
+  // Starts loading so the first frame never claims there are no earnings.
+  const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
+  const [stale, setStale] = useState(false);
+  const [lastUpdated, setLastUpdated] = useState<number | null>(null);
   const [selectedIdx, setSelectedIdx] = usePluginPaneState<number>("selectedIdx", 0);
   const requestIdRef = useRef(0);
 
@@ -70,6 +76,7 @@ function EarningsCalendarPane({ focused, width, height }: PaneProps) {
     if (tickerSymbols.length === 0) {
       setEvents([]);
       setError(null);
+      setStale(false);
       setLoading(false);
       return;
     }
@@ -77,9 +84,12 @@ function EarningsCalendarPane({ focused, width, height }: PaneProps) {
     setLoading(true);
     setError(null);
     loadEarningsCalendar(dataProvider, tickerSymbols, { force })
-      .then((data) => {
+      .then((result) => {
         if (requestId !== requestIdRef.current) return;
-        setEvents(data);
+        setEvents(result.events);
+        setStale(result.stale);
+        setError(result.refreshError ?? null);
+        setLastUpdated(result.fetchedAt);
       })
       .catch((err) => {
         if (requestId !== requestIdRef.current) return;
@@ -95,6 +105,10 @@ function EarningsCalendarPane({ focused, width, height }: PaneProps) {
     reload(false);
   }, [reload]);
 
+  // The 30-minute cache decides whether a tick reaches the provider.
+  const refresh = useCallback(() => reload(false), [reload]);
+  useAutoRefresh(stale ? null : lastUpdated, refresh);
+
   useEffect(() => () => {
     requestIdRef.current += 1;
   }, []);
@@ -129,11 +143,11 @@ function EarningsCalendarPane({ focused, width, height }: PaneProps) {
 
   usePaneFooter("earnings-calendar", () => ({
     info: [
+      ...(stale ? [{ id: "stale", parts: [{ text: "STALE", tone: "warning" as const }] }] : []),
       ...(loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
       ...(error ? [{ id: "error", parts: [{ text: error, tone: "warning" as const }] }] : []),
     ],
-    hints: [{ id: "refresh", key: "r", label: "efresh", onPress: () => reload(true) }],
-  }), [error, loading, reload]);
+  }), [error, loading, stale]);
 
   return (
     <DataTableView<EarningsDisplayRow, EarningsColumn>
@@ -160,11 +174,47 @@ function EarningsCalendarPane({ focused, width, height }: PaneProps) {
       getItemKey={(row) => row.key}
       renderSectionHeader={renderEarningsSectionHeader}
       renderCell={renderCell}
-      emptyStateTitle={loading ? "Loading earnings..." : "No upcoming earnings found"}
+      emptyStateTitle={
+        loading
+          ? "Loading earnings..."
+          : tickerSymbols.length === 0
+            ? "No tickers in scope."
+            : "No upcoming earnings found"
+      }
     />
   );
 }
 
+/** The monitor's scope lives in pane settings, so it has to be editable there too. */
+function earningsSettings(context: PaneSettingsContext): PaneSettingsDef {
+  const collections = [
+    ...context.config.portfolios.map((portfolio) => ({ value: portfolio.id, label: portfolio.name })),
+    ...context.config.watchlists.map((watchlist) => ({ value: watchlist.id, label: watchlist.name })),
+  ];
+  const symbols = scopedSymbolsFromSettings(context.settings);
+  return {
+    title: "Earnings Scope",
+    values: { symbolsText: symbols.length > 0 ? formatTickers(symbols) : "" },
+    fields: [
+      {
+        key: "symbolsText",
+        label: "Tickers",
+        description: "Leave empty to follow a collection instead.",
+        type: "text",
+        placeholder: "AAPL, MSFT",
+        clearOnChange: ["symbols"],
+      },
+      ...(collections.length > 0 ? [{
+        key: "collectionId",
+        label: "Collection",
+        description: "Used when no tickers are listed above.",
+        type: "select" as const,
+        options: [{ value: "", label: "All tracked tickers" }, ...collections],
+      }] : []),
+    ],
+  };
+}
+
 export const earningsModule: PluginModule = {
   setup(ctx) {
     attachEarningsCalendarPersistence(ctx.persistence);
@@ -201,6 +251,7 @@ export const earningsModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 85, height: 25 },
+      settings: earningsSettings,
     },
   ],
 

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

@@ -4,6 +4,8 @@ import type { EconEvent } from "./types";
 import {
   attachEconCalendarPersistence,
   loadCalendar,
+  matchesCountry,
+  matchesImpact,
   resetEconCalendarPersistence,
 } from "./calendar-model";
 
@@ -36,13 +38,45 @@ describe("econ calendar cache", () => {
     attachEconCalendarPersistence(persistence);
 
     let calls = 0;
-    const events = await loadCalendar(false, async () => {
+    const result = await loadCalendar(false, async () => {
       calls += 1;
       return [makeEvent("fallback")];
     });
 
     expect(calls).toBe(0);
-    expect(events.map((event) => event.id)).toEqual(["pce"]);
-    expect(events[0]!.date).toBeInstanceOf(Date);
+    expect(result.data.map((event) => event.id)).toEqual(["pce"]);
+    expect(result.data[0]!.date).toBeInstanceOf(Date);
+    expect(result.stale).toBe(false);
+  });
+
+  test("marks a failed refresh stale instead of passing the cache off as fresh", async () => {
+    const persistence = new MemoryPluginPersistence();
+    attachEconCalendarPersistence(persistence);
+    await loadCalendar(false, async () => [makeEvent("pce")]);
+
+    const result = await loadCalendar(true, async () => {
+      throw new Error("calendar endpoint down");
+    });
+
+    expect(result.data.map((event) => event.id)).toEqual(["pce"]);
+    expect(result.stale).toBe(true);
+    expect(result.refreshError).toContain("calendar endpoint down");
+  });
+});
+
+describe("econ calendar filters", () => {
+  test("each impact level selects only its own events", () => {
+    const low = { ...makeEvent("low"), impact: "low" as const };
+    const high = makeEvent("high");
+    expect(matchesImpact(low, "low")).toBe(true);
+    expect(matchesImpact(high, "low")).toBe(false);
+    expect(matchesImpact(high, "all")).toBe(true);
+  });
+
+  test("G7 covers every member, not just the ones with a cached flag", () => {
+    for (const country of ["US", "GB", "FR", "DE", "IT", "JP", "CA", "EU"]) {
+      expect(matchesCountry({ ...makeEvent(country), country }, "G7")).toBe(true);
+    }
+    expect(matchesCountry({ ...makeEvent("cn"), country: "CN" }, "G7")).toBe(false);
   });
 });