gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/dividend-yield/view.test.ts

@@ -0,0 +1,58 @@
+import { expect, test } from "bun:test";
+import { toDividendPayment } from "./client";
+import { buildTrailingCashChartPoints } from "./view";
+
+test("cash chart uses complete calendar-year cash totals without inventing historical price yields", () => {
+  const payments = Array.from({ length: 25 }, (_, month) => toDividendPayment(
+    new Date(Date.UTC(2024, 1 + month, 1)).toISOString().slice(0, 10), 0.5, "USD",
+  )!);
+  payments.push(toDividendPayment("2027-02-01", 50, "USD")!);
+  const points = buildTrailingCashChartPoints(payments.reverse(), new Date("2026-02-01"));
+  expect(points).toHaveLength(13);
+  expect(points[0]?.date.toISOString().slice(0, 10)).toBe("2025-02-01");
+  expect(points.every((point) => point.close === 6)).toBe(true);
+  expect(buildTrailingCashChartPoints(payments.slice(1, 3), new Date("2026-09-10"))).toEqual([]);
+});
+
+test("cash chart reaches the current zero cash rate after payments stop", () => {
+  const points = buildTrailingCashChartPoints([
+    toDividendPayment("2023-08-04", 0.125, "USD")!,
+    toDividendPayment("2024-08-07", 0.125, "USD")!,
+  ], new Date("2026-09-10"));
+  expect(points.map((point) => [point.date.toISOString().slice(0, 10), point.close])).toEqual([
+    ["2024-08-04", 0], ["2024-08-07", 0.125], ["2025-08-07", 0], ["2026-09-10", 0],
+  ]);
+});
+
+test("cash chart drops on each expiry and combines same-day cash and expiries once", () => {
+  const points = buildTrailingCashChartPoints([
+    toDividendPayment("2022-01-01", 1, "USD")!,
+    toDividendPayment("2023-01-01", 1, "USD")!,
+    toDividendPayment("2023-04-01", 2, "USD")!,
+    toDividendPayment("2024-01-01", 4, "USD")!,
+    toDividendPayment("2024-01-01", 5, "USD")!,
+  ], new Date("2024-05-01"));
+  expect(points.map((point) => [point.date.toISOString().slice(0, 10), point.close])).toEqual([
+    ["2023-01-01", 1], ["2023-04-01", 3], ["2024-01-01", 11], ["2024-04-01", 9], ["2024-05-01", 9],
+  ]);
+});
+
+test("February 29 cash leaves the clamped annual window on March 1 of the following year", () => {
+  const points = buildTrailingCashChartPoints([
+    toDividendPayment("2022-01-01", 1, "USD")!,
+    toDividendPayment("2024-02-28", 2, "USD")!,
+    toDividendPayment("2024-02-29", 3, "USD")!,
+  ], new Date("2025-03-02"));
+  expect(points.slice(-3).map((point) => [point.date.toISOString().slice(0, 10), point.close])).toEqual([
+    ["2025-02-28", 3], ["2025-03-01", 0], ["2025-03-02", 0],
+  ]);
+});
+
+test("leap-day cash chart retains payments after the clamped February 28 cutoff", () => {
+  const points = buildTrailingCashChartPoints([
+    toDividendPayment("2022-02-28", 1, "USD")!,
+    toDividendPayment("2023-03-01", 4, "USD")!,
+    toDividendPayment("2024-02-29", 1, "USD")!,
+  ], new Date("2024-02-29T12:00:00Z"));
+  expect(points.at(-1)?.close).toBe(5);
+});

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

@@ -1,4 +1,39 @@
 import type { DividendPayment } from "./types";
+import type { ProjectedChartPoint } from "../../../components/chart/core/data";
+import { calendarYearsBefore } from "./calendar";
+
+export function formatDividendYield(value: number | null): string {
+  return value != null && Number.isFinite(value) ? `${(value * 100).toFixed(2)}%` : "—";
+}
+
+/** Cash history does not contain historical share prices, so cannot establish historical yields. */
+export function buildTrailingCashChartPoints(payments: DividendPayment[], now = new Date()): ProjectedChartPoint[] {
+  const sorted = payments.filter((payment) => payment.exDate <= now && Number.isFinite(payment.amount) && payment.amount > 0)
+    .sort((a, b) => a.exDate.getTime() - b.exDate.getTime());
+  const firstDate = sorted[0]?.exDate;
+  if (!firstDate) return [];
+  // Rolling cash changes both on ex-dates and when payments leave the window.
+  // Date rollover deliberately expires February 29 on March 1 in a non-leap
+  // year, when the clamped trailing-year cutoff first reaches that payment.
+  const dates = new Set<number>([now.getTime()]);
+  for (const payment of sorted) {
+    dates.add(payment.exDate.getTime());
+    const expiry = new Date(payment.exDate);
+    expiry.setUTCFullYear(expiry.getUTCFullYear() + 1);
+    if (expiry <= now) dates.add(expiry.getTime());
+  }
+  const points: ProjectedChartPoint[] = [];
+  for (const timestamp of [...dates].sort((a, b) => a - b)) {
+    const date = new Date(timestamp);
+    const cutoff = calendarYearsBefore(date, 1);
+    // Avoid drawing the first partial year of a fund's history as a full-year cash rate.
+    if (cutoff < firstDate) continue;
+    const cash = sorted.filter((p) => p.exDate > cutoff && p.exDate <= date)
+      .reduce((sum, p) => sum + p.amount, 0);
+    points.push({ date, open: cash, high: cash, low: cash, close: cash, volume: 0 });
+  }
+  return points;
+}
 
 export interface DividendRow {
   key: string;

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

@@ -77,7 +77,7 @@ describe("loadEarningsCalendar", () => {
       earningsDate: "2026-05-01T12:00:00.000Z",
     }], {
       sourceKey: "earnings",
-      schemaVersion: 2,
+      schemaVersion: 3,
       stale: true,
     });
 
@@ -94,4 +94,24 @@ describe("loadEarningsCalendar", () => {
     expect(result.stale).toBe(true);
     expect(result.refreshError).toContain("offline");
   });
+
+  test("refreshes old snapshots that discarded estimate units instead of treating them as current data", async () => {
+    const persistence = new MemoryPluginPersistence();
+    attachEarningsCalendarPersistence(persistence);
+    persistence.seedResource("calendar", "AAPL", [{
+      ...eventFor("AAPL"), earningsDate: "2026-05-01T12:00:00.000Z",
+    }], { sourceKey: "earnings", schemaVersion: 2 });
+    await expect(loadEarningsCalendar(makeProvider(async () => {
+      throw new Error("offline");
+    }), ["AAPL"])).rejects.toThrow("offline");
+
+    const fresh = eventFor("AAPL");
+    fresh.estimateBasis = { epsEstimate: {
+      source: "earningsTrend", sourceValue: 1.23,
+      period: "0q", periodEndDate: "2026-03-31", currency: "USD", sourceCurrency: "USD",
+    } };
+    const result = await loadEarningsCalendar(makeProvider(async () => [fresh]), ["AAPL"]);
+    expect(result.stale).toBe(false);
+    expect(result.events[0]?.estimateBasis).toEqual(fresh.estimateBasis);
+  });
 });

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

@@ -1,21 +1,15 @@
+import { createPluginCache } from "../../../../data/plugin-cache";
 import type { DataProvider, EarningsEvent } from "../../../../types/data-provider";
-import type { PersistedResourceValue } from "../../../../types/persistence";
-import type { PluginPersistence } from "../../../../types/plugin";
 
 const CACHE_KIND = "calendar";
 const CACHE_SOURCE = "earnings";
-const CACHE_SCHEMA_VERSION = 2;
+const CACHE_SCHEMA_VERSION = 3;
 
 export const EARNINGS_CALENDAR_CACHE_POLICY = {
   staleMs: 30 * 60 * 1000,
   expireMs: 7 * 24 * 60 * 60 * 1000,
 } as const;
 
-interface MemoryCacheEntry {
-  data: EarningsEvent[];
-  fetchedAt: number;
-}
-
 type PersistedEarningsEvent = Omit<EarningsEvent, "earningsDate" | "earningsCallDate"> & {
   earningsDate: string;
   earningsCallDate?: string | null;
@@ -29,19 +23,12 @@ export interface EarningsCalendarResult {
   refreshError?: string;
 }
 
-let earningsPersistence: PluginPersistence | null = null;
-const memoryCache = new Map<string, MemoryCacheEntry>();
-const activeFetches = new Map<string, Promise<EarningsCalendarResult>>();
-
-export function attachEarningsCalendarPersistence(persistence: PluginPersistence): void {
-  earningsPersistence = persistence;
-}
-
-export function resetEarningsCalendarPersistence(): void {
-  earningsPersistence = null;
-  memoryCache.clear();
-  activeFetches.clear();
-}
+const cache = createPluginCache<EarningsEvent[], PersistedEarningsEvent[]>({
+  kind: CACHE_KIND, source: CACHE_SOURCE, schemaVersion: CACHE_SCHEMA_VERSION, policy: EARNINGS_CALENDAR_CACHE_POLICY,
+  encode: serializeEvents, decode: deserializeEvents,
+});
+export const attachEarningsCalendarPersistence = cache.attach;
+export const resetEarningsCalendarPersistence = cache.reset;
 
 function normalizeEarningsSymbols(symbols: string[]): string[] {
   return Array.from(
@@ -82,26 +69,6 @@ function deserializeEvents(events: PersistedEarningsEvent[]): EarningsEvent[] {
     ));
 }
 
-function readPersistedCache(
-  key: string,
-  options?: { allowExpired?: boolean },
-): PersistedResourceValue<PersistedEarningsEvent[]> | null {
-  return earningsPersistence?.getResource<PersistedEarningsEvent[]>(CACHE_KIND, key, {
-    sourceKey: CACHE_SOURCE,
-    schemaVersion: CACHE_SCHEMA_VERSION,
-    allowExpired: options?.allowExpired,
-  }) ?? null;
-}
-
-function writeCache(key: string, events: EarningsEvent[]): void {
-  memoryCache.set(key, { data: events, fetchedAt: Date.now() });
-  earningsPersistence?.setResource(CACHE_KIND, key, serializeEvents(events), {
-    sourceKey: CACHE_SOURCE,
-    schemaVersion: CACHE_SCHEMA_VERSION,
-    cachePolicy: EARNINGS_CALENDAR_CACHE_POLICY,
-  });
-}
-
 export async function loadEarningsCalendar(
   provider: DataProvider | null | undefined,
   symbols: string[],
@@ -111,49 +78,7 @@ export async function loadEarningsCalendar(
   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 { 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 { events: data, fetchedAt: freshPersisted.fetchedAt, stale: false };
-  }
-
-  const activeFetch = activeFetches.get(key);
-  if (activeFetch && !force) return activeFetch;
-
-  const fetchPromise = provider.getEarningsCalendar(normalizedSymbols)
-    .then((data) => {
-      writeCache(key, data);
-      return { events: data, fetchedAt: Date.now(), stale: false };
-    })
-    .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 { events: data, fetchedAt: stalePersisted.fetchedAt, stale: true, refreshError };
-      }
-      if (memoryEntry) {
-        return { events: memoryEntry.data, fetchedAt: memoryEntry.fetchedAt, stale: true, refreshError };
-      }
-      throw error;
-    })
-    .finally(() => {
-      if (activeFetches.get(key) === fetchPromise) {
-        activeFetches.delete(key);
-      }
-    });
-
-  activeFetches.set(key, fetchPromise);
-  return fetchPromise;
+  const result = await cache.load(buildEarningsCacheKey(normalizedSymbols),
+    () => provider.getEarningsCalendar!(normalizedSymbols), { force: options?.force, replace: options?.force });
+  return { events: result.data, fetchedAt: result.fetchedAt, stale: result.stale, refreshError: result.refreshError };
 }

package/src/plugins/builtin/earnings/detail-model.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "bun:test";
+import type { EarningsEstimateBasis, EarningsEvent } from "../../../types/data-provider";
+import { buildEarningsDetail, formatGrowth, rangeBar } from "./detail-model";
+
+const trend = (value: number, currency: string | null = "USD"): EarningsEstimateBasis => ({
+  source: "earningsTrend",
+  sourceValue: value,
+  period: "0q",
+  periodEndDate: "2026-10-31",
+  ...(currency ? { currency } : {}),
+});
+
+function event(overrides: Partial<EarningsEvent> = {}): EarningsEvent {
+  return {
+    symbol: "NVDA",
+    name: "NVIDIA Corporation",
+    earningsDate: new Date("2026-11-17T21:00:00Z"),
+    earningsCallDate: null,
+    isDateEstimate: false,
+    epsEstimate: 2.47,
+    epsLow: 2.34,
+    epsHigh: 2.7,
+    epsYearAgo: 1.3,
+    epsGrowth: 0.9027,
+    epsAnalysts: 43,
+    epsTrend7dAgo: 2.474,
+    epsTrend30dAgo: 2.35,
+    epsRevisionUp7d: 34,
+    epsRevisionUp30d: 35,
+    epsRevisionDown7d: 3,
+    epsRevisionDown30d: 1,
+    epsActual: null,
+    revenueEstimate: 109e9,
+    revenueLow: 104.94e9,
+    revenueHigh: 116.25e9,
+    revenueYearAgo: 57.01e9,
+    revenueGrowth: 0.912,
+    revenueAnalysts: 43,
+    revenueActual: null,
+    surprise: null,
+    timing: "AMC",
+    estimateBasis: {
+      epsEstimate: trend(2.47), epsLow: trend(2.34), epsHigh: trend(2.7), epsYearAgo: trend(1.3),
+      epsGrowth: trend(0.9027, null), epsAnalysts: trend(43, null),
+      epsTrend7dAgo: trend(2.474), epsTrend30dAgo: trend(2.35),
+      epsRevisionUp7d: trend(34, null), epsRevisionUp30d: trend(35, null),
+      epsRevisionDown7d: trend(3, null), epsRevisionDown30d: trend(1, null),
+      revenueEstimate: trend(109e9), revenueLow: trend(104.94e9), revenueHigh: trend(116.25e9),
+      revenueYearAgo: trend(57.01e9), revenueGrowth: trend(0.912, null), revenueAnalysts: trend(43, null),
+    },
+    ...overrides,
+  };
+}
+
+describe("buildEarningsDetail", () => {
+  test("lays out the report facts and both estimate blocks", () => {
+    const detail = buildEarningsDetail(event());
+    expect(detail.date).toBe("Nov 17, 2026");
+    expect(detail.timing).toBe("after close");
+    expect(detail.dateStatus).toBe("confirmed");
+    expect(detail.period).toBe("current quarter ending 2026-10-31");
+    expect(detail.eps.consensus).toBe("USD 2.47");
+    expect(detail.eps.position).toBeCloseTo((2.47 - 2.34) / (2.7 - 2.34), 5);
+    expect(detail.eps.yearAgo).toBe("USD 1.30");
+    expect(detail.revenue.consensus).toBe("USD 109B");
+    expect(detail.revenue.trend).toEqual([]);
+  });
+
+  test("a move below the displayed precision reads as unchanged", () => {
+    const detail = buildEarningsDetail(event());
+    expect(detail.eps.trend.map((row) => [row.label, row.changeText])).toEqual([
+      ["30 days ago", "+0.12 since"],
+      ["7 days ago", "unchanged"],
+    ]);
+    expect(detail.eps.revisions).toEqual([
+      { label: "30d", up: 35, down: 1 },
+      { label: "7d", up: 34, down: 3 },
+    ]);
+  });
+
+  test("a range from a different forecast than the consensus is not drawn", () => {
+    const detail = buildEarningsDetail(event({
+      estimateBasis: {
+        ...event().estimateBasis,
+        epsLow: { source: "calendarEvents", sourceValue: 2.34, period: null, periodEndDate: null, currency: "USD" },
+      },
+    }));
+    expect(detail.eps.low).toBeNull();
+    expect(detail.eps.position).toBeNull();
+  });
+});
+
+test("rangeBar puts the marker between the ends", () => {
+  expect(rangeBar(0, 7)).toBe("├●────┤");
+  expect(rangeBar(1, 7)).toBe("├────●┤");
+  expect(rangeBar(0.5, 7)).toBe("├──●──┤");
+});
+
+test("formatGrowth is a signed percent with one decimal", () => {
+  expect(formatGrowth(0.9027)).toBe("+90.3%");
+  expect(formatGrowth(-0.05)).toBe("-5.0%");
+  expect(formatGrowth(null)).toBe("");
+});

package/src/plugins/builtin/earnings/detail-model.ts

@@ -0,0 +1,165 @@
+import type { EarningsEstimateField, EarningsEvent } from "../../../types/data-provider";
+import { formatCompact, formatNumber } from "../../../utils/format";
+import { coherentEarningsValue, earningsForecastPeriod } from "./estimate-basis";
+
+const MONTH_NAMES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const;
+
+export interface EstimateBlock {
+  label: string;
+  /** Consensus with its currency, or null when the provider has none. */
+  consensus: string | null;
+  analysts: number | null;
+  low: number | null;
+  high: number | null;
+  /** Where the consensus sits between low and high, 0..1, when all three exist. */
+  position: number | null;
+  lowText: string;
+  highText: string;
+  yearAgo: string | null;
+  growth: number | null;
+  /** Consensus 30 and 7 days ago, with the change since. EPS only. */
+  trend: Array<{ label: string; value: string; change: number | null; changeText: string }>;
+  /** Up and down revisions over 30 and 7 days. EPS only. */
+  revisions: Array<{ label: string; up: number | null; down: number | null }>;
+}
+
+export interface EarningsDetail {
+  symbol: string;
+  name: string;
+  /** "Nov 17, 2026" */
+  date: string;
+  /** "after close", "before open", the call time, or null. */
+  timing: string | null;
+  dateStatus: "estimated" | "confirmed" | null;
+  /** "3Q2027 ending 2026-10-31" when every shown estimate agrees on the period. */
+  period: string | null;
+  eps: EstimateBlock;
+  revenue: EstimateBlock;
+}
+
+function money(event: EarningsEvent, field: EarningsEstimateField, formatter: (value: number) => string): string | null {
+  const value = coherentEarningsValue(event, field);
+  if (value == null) return null;
+  const currency = event.estimateBasis?.[field]?.currency;
+  return currency ? `${currency} ${formatter(value)}` : formatter(value);
+}
+
+function position(low: number | null, high: number | null, value: number | null): number | null {
+  if (low == null || high == null || value == null || high <= low) return null;
+  return Math.max(0, Math.min(1, (value - low) / (high - low)));
+}
+
+function block(
+  event: EarningsEvent,
+  label: string,
+  fields: { estimate: EarningsEstimateField; low: EarningsEstimateField; high: EarningsEstimateField; yearAgo: EarningsEstimateField; growth: EarningsEstimateField; analysts: EarningsEstimateField },
+  formatter: (value: number) => string,
+  withTrend: boolean,
+): EstimateBlock {
+  const estimate = coherentEarningsValue(event, fields.estimate);
+  const low = coherentEarningsValue(event, fields.low);
+  const high = coherentEarningsValue(event, fields.high);
+  const trend: EstimateBlock["trend"] = [];
+  const revisions: EstimateBlock["revisions"] = [];
+  if (withTrend) {
+    for (const [label, field] of [["30 days ago", "epsTrend30dAgo"], ["7 days ago", "epsTrend7dAgo"]] as const) {
+      const prior = coherentEarningsValue(event, field);
+      if (prior == null) continue;
+      const change = estimate != null ? estimate - prior : null;
+      const changeText = change == null ? "" : formatter(Math.abs(change));
+      // A move below the displayed precision is no move.
+      const flat = change != null && /^0(\.0+)?$/.test(changeText);
+      trend.push({
+        label,
+        value: formatter(prior),
+        change: flat ? 0 : change,
+        changeText: change == null ? "" : flat ? "unchanged" : `${change > 0 ? "+" : "-"}${changeText} since`,
+      });
+    }
+    for (const [label, up, down] of [["30d", "epsRevisionUp30d", "epsRevisionDown30d"], ["7d", "epsRevisionUp7d", "epsRevisionDown7d"]] as const) {
+      const upCount = coherentEarningsValue(event, up);
+      const downCount = coherentEarningsValue(event, down);
+      if (upCount == null && downCount == null) continue;
+      revisions.push({ label, up: upCount, down: downCount });
+    }
+  }
+  return {
+    label,
+    consensus: money(event, fields.estimate, formatter),
+    analysts: coherentEarningsValue(event, fields.analysts),
+    low,
+    high,
+    position: position(low, high, estimate),
+    lowText: low == null ? "" : formatter(low),
+    highText: high == null ? "" : formatter(high),
+    yearAgo: money(event, fields.yearAgo, formatter),
+    growth: coherentEarningsValue(event, fields.growth),
+    trend,
+    revisions,
+  };
+}
+
+function timingLabel(event: EarningsEvent): string | null {
+  switch (event.timing) {
+    case "BMO":
+      return "before open";
+    case "AMC":
+      return "after close";
+    case "TNS":
+      return "time not supplied";
+    default:
+      return event.earningsCallDate
+        ? `call ${event.earningsCallDate.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`
+        : null;
+  }
+}
+
+/** Yahoo labels forecast periods relative to now; say what they mean. */
+const PERIOD_LABELS: Record<string, string> = {
+  "0q": "current quarter",
+  "+1q": "next quarter",
+  "0y": "current year",
+  "+1y": "next year",
+};
+
+export function buildEarningsDetail(event: EarningsEvent): EarningsDetail {
+  const date = event.earningsDate;
+  const period = earningsForecastPeriod(event);
+  return {
+    symbol: event.symbol,
+    name: event.name,
+    date: `${MONTH_NAMES[date.getUTCMonth()]} ${date.getUTCDate()}, ${date.getUTCFullYear()}`,
+    timing: timingLabel(event),
+    dateStatus: event.isDateEstimate == null ? null : event.isDateEstimate ? "estimated" : "confirmed",
+    period: period ? `${PERIOD_LABELS[period.period] ?? period.period} ending ${period.periodEndDate}` : null,
+    eps: block(
+      event,
+      "EPS",
+      { estimate: "epsEstimate", low: "epsLow", high: "epsHigh", yearAgo: "epsYearAgo", growth: "epsGrowth", analysts: "epsAnalysts" },
+      (value) => formatNumber(value, 2),
+      true,
+    ),
+    revenue: block(
+      event,
+      "Revenue",
+      { estimate: "revenueEstimate", low: "revenueLow", high: "revenueHigh", yearAgo: "revenueYearAgo", growth: "revenueGrowth", analysts: "revenueAnalysts" },
+      formatCompact,
+      false,
+    ),
+  };
+}
+
+/** `├────●───┤` with the marker at `position`, `width` cells wide. */
+export function rangeBar(position: number, width: number): string {
+  const inner = Math.max(3, width - 2);
+  const marker = Math.round(position * (inner - 1));
+  let bar = "";
+  for (let index = 0; index < inner; index += 1) bar += index === marker ? "●" : "─";
+  return `├${bar}┤`;
+}
+
+/** Year-over-year growth as a signed percent with one decimal. */
+export function formatGrowth(value: number | null): string {
+  if (value == null || !Number.isFinite(value)) return "";
+  return `${value > 0 ? "+" : ""}${(value * 100).toFixed(1)}%`;
+}

package/src/plugins/builtin/earnings/detail-view.tsx

@@ -0,0 +1,131 @@
+import { useMemo } from "react";
+import { Button } from "../../../components/ui/button";
+import { colors } from "../../../theme/colors";
+import { Box, Text, TextAttributes } from "../../../ui";
+import type { EarningsEvent } from "../../../types/data-provider";
+import { buildEarningsDetail, formatGrowth, rangeBar, type EstimateBlock } from "./detail-model";
+
+interface EarningsDetailViewProps {
+  event: EarningsEvent;
+  width: number;
+  height: number;
+  onOpenTicker: (symbol: string) => void;
+  onOpenEstimates: (symbol: string) => void;
+  onOpenCalls: (symbol: string) => void;
+  onOpenAnalysts: (symbol: string) => void;
+}
+
+function signColor(value: number | null): string {
+  if (value == null) return colors.textDim;
+  return value > 0 ? colors.positive : value < 0 ? colors.negative : colors.textDim;
+}
+
+/** One estimate: the consensus, where it sits in the range, and how it moved. */
+function EstimatePanel({ block, width }: { block: EstimateBlock; width: number }) {
+  const labelWidth = 13;
+  const barWidth = Math.max(12, width - block.lowText.length - block.highText.length - 4);
+  return (
+    <Box flexDirection="column" width={width} overflow="hidden">
+      <Box height={1}>
+        <Text fg={colors.textDim} attributes={TextAttributes.BOLD}>{block.label.toUpperCase()}</Text>
+      </Box>
+      <Box height={1} flexDirection="row">
+        <Text fg={block.consensus ? colors.textBright : colors.textDim} attributes={TextAttributes.BOLD}>
+          {block.consensus ?? "no consensus"}
+        </Text>
+        {block.analysts != null ? (
+          <Text fg={colors.textDim}>{`  ${block.analysts} ${block.analysts === 1 ? "analyst" : "analysts"}`}</Text>
+        ) : null}
+      </Box>
+      {block.position != null ? (
+        <Box height={1} flexDirection="row">
+          <Text fg={colors.textDim}>{`${block.lowText} `}</Text>
+          <Text fg={colors.borderFocused}>{rangeBar(block.position, barWidth)}</Text>
+          <Text fg={colors.textDim}>{` ${block.highText}`}</Text>
+        </Box>
+      ) : block.lowText || block.highText ? (
+        <Box height={1}>
+          <Text fg={colors.textDim}>{`range ${block.lowText || "?"} to ${block.highText || "?"}`}</Text>
+        </Box>
+      ) : null}
+      {block.yearAgo || block.growth != null ? (
+        <Box height={1} flexDirection="row">
+          <Box width={labelWidth} flexShrink={0}>
+            <Text fg={colors.textDim}>year ago</Text>
+          </Box>
+          <Text fg={colors.text}>{block.yearAgo ?? ""}</Text>
+          {block.growth != null ? (
+            <Text fg={signColor(block.growth)}>{`${block.yearAgo ? "  " : ""}${formatGrowth(block.growth)}`}</Text>
+          ) : null}
+        </Box>
+      ) : null}
+      {block.trend.map((row) => (
+        <Box key={row.label} height={1} flexDirection="row">
+          <Box width={labelWidth} flexShrink={0}>
+            <Text fg={colors.textDim}>{row.label}</Text>
+          </Box>
+          <Text fg={colors.text}>{row.value}</Text>
+          {row.changeText ? <Text fg={signColor(row.change)}>{`  ${row.changeText}`}</Text> : null}
+        </Box>
+      ))}
+      {block.revisions.map((row) => {
+        const net = row.up != null && row.down != null ? row.up - row.down : null;
+        return (
+          <Box key={row.label} height={1} flexDirection="row">
+            <Box width={labelWidth} flexShrink={0}>
+              <Text fg={colors.textDim}>{`revisions ${row.label}`}</Text>
+            </Box>
+            <Text fg={signColor(net)}>{`${row.up ?? "?"} up · ${row.down ?? "?"} down`}</Text>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}
+
+/**
+ * Everything the provider knows about one upcoming report, laid out instead
+ * of squeezed into fifteen columns, with the deeper surfaces one key away.
+ */
+export function EarningsDetailView({
+  event,
+  width,
+  height,
+  onOpenTicker,
+  onOpenEstimates,
+  onOpenCalls,
+  onOpenAnalysts,
+}: EarningsDetailViewProps) {
+  const detail = useMemo(() => buildEarningsDetail(event), [event]);
+  const inner = Math.max(20, width - 2);
+  const wide = inner >= 76;
+  const panelWidth = wide ? Math.floor((inner - 3) / 2) : inner;
+  const facts = [
+    detail.date,
+    detail.timing,
+    detail.dateStatus ? `date ${detail.dateStatus}` : null,
+    detail.period,
+  ].filter((part): part is string => !!part);
+
+  return (
+    <Box flexDirection="column" width={width} height={height} paddingX={1} overflow="hidden">
+      <Box height={1} flexDirection="row">
+        <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>{detail.date}</Text>
+        {facts.length > 1 ? (
+          <Text fg={detail.dateStatus === "estimated" ? colors.warning : colors.textDim}>{`  ${facts.slice(1).join(" · ")}`}</Text>
+        ) : null}
+      </Box>
+      <Box flexDirection={wide ? "row" : "column"} marginTop={1} gap={wide ? 3 : 1}>
+        <EstimatePanel block={detail.eps} width={panelWidth} />
+        <EstimatePanel block={detail.revenue} width={panelWidth} />
+      </Box>
+      <Box height={1} flexDirection="row" gap={1} marginTop={1}>
+        <Text fg={colors.textDim}>Open</Text>
+        <Button stopPropagation label="ticker" variant="ghost" compact onPress={() => onOpenTicker(detail.symbol)} />
+        <Button stopPropagation label="estimates" variant="ghost" compact onPress={() => onOpenEstimates(detail.symbol)} />
+        <Button stopPropagation label="calls" variant="ghost" compact onPress={() => onOpenCalls(detail.symbol)} />
+        <Button stopPropagation label="analysts" variant="ghost" compact onPress={() => onOpenAnalysts(detail.symbol)} />
+      </Box>
+    </Box>
+  );
+}