@gloom-sh/terminal 0.18.5 → 0.19.1

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

@@ -1,7 +1,7 @@
 import type { HeadlessBundleResult, HeadlessPaneColumn } from "../../../types/headless";
 import { formatPercent } from "../../../utils/format";
 import type { DividendData } from "./client";
-import { formatDividendYield } from "./view";
+import { formatDividendYield, growthPaymentsDetail, PAYOUT_NOT_MEANINGFUL, trailingPaymentsText } from "./view";
 import type { FundBondFacts } from "../../../api-client/fund-facts";
 import { NOT_SEC_YIELD } from "../../../market-data/bond-funds";
 
@@ -38,10 +38,19 @@ function declaredPayDate(data: Pick<DividendData, "declared" | "metrics">, now =
  */
 function incompleteNote(entry: DividendRankingEntry): string | null {
   if ("error" in entry) return "not read";
-  const { historyError, summaryError } = entry.data;
-  if (historyError && summaryError) return "no cash history or summary";
+  const { historyError, summaryError, forwardFromFundamentals, metrics } = entry.data;
+  // A forward yield read from fundamentals in place of the summary is dated by the ex-date it annualizes.
+  const forward = summaryError && forwardFromFundamentals && metrics.forwardRateAsOf
+    ? `; fwd yield from fundamentals, ex ${metrics.forwardRateAsOf}` : "";
+  if (historyError && summaryError) return `no cash history or summary${forward}`;
   if (historyError) return "no cash history";
-  return summaryError ? "no summary" : null;
+  return summaryError ? `no summary${forward}` : null;
+}
+
+/** How a row's trailing yield was counted, when its year holds fewer payments than its cadence pays; null otherwise. */
+function yieldBasis(entry: DividendRankingEntry): string | null {
+  const counted = "data" in entry ? trailingPaymentsText(entry.data.metrics.trailingPayments, { cadence: true }) : null;
+  return counted ? `counts ${counted}` : null;
 }
 
 /** What a row is missing, in full, for the report's errors; null for a whole read. */
@@ -90,12 +99,17 @@ function rankDividendEntries(entries: readonly DividendRankingEntry[], now = new
         forwardYield: roundedRatio(metrics.forwardYield),
         ...bonds ? secYieldFields(entry) : {},
         payoutRatio: roundedRatio(metrics.payoutRatio),
+        payoutNotMeaningful: metrics.payoutNotMeaningful === true,
         growth1Y: roundedRatio(metrics.growth1Y),
         growth3Y: roundedRatio(metrics.growth3Y),
+        // Set when a year the figure compares is short of the cadence's payments: the figure is then n/a.
+        ...metrics.growth1YPayments ? { growth1YPayments: growthPaymentsDetail(metrics.growth1YPayments) } : {},
+        ...metrics.growth3YPayments ? { growth3YPayments: growthPaymentsDetail(metrics.growth3YPayments) } : {},
         lastExDate: isoDay(metrics.lastExDividendDate),
         payDate: declaredPayDate(data, now),
         frequency: metrics.paymentFrequency,
         note: incompleteNote(entry),
+        yieldBasis: yieldBasis(entry),
         error: incompleteReason(entry),
       },
     };
@@ -111,7 +125,9 @@ function rankDividendEntries(entries: readonly DividendRankingEntry[], now = new
 }
 
 const ratio = (value: unknown) => formatDividendYield(typeof value === "number" ? value : null);
-const growth = (value: unknown) => formatPercent(typeof value === "number" ? value : undefined);
+/** A growth figure, or n/a when one of its years is short (the row's `<key>Payments`). */
+const growth = (key: "growth1Y" | "growth3Y") => (value: unknown, row: Record<string, unknown>) =>
+  typeof value !== "number" && typeof row[`${key}Payments`] === "string" ? "n/a" : formatPercent(typeof value === "number" ? value : undefined);
 const day = (value: unknown) => typeof value === "string" && value ? value : "—";
 
 const RANKING_COLUMNS: HeadlessPaneColumn[] = [
@@ -120,12 +136,15 @@ const RANKING_COLUMNS: HeadlessPaneColumn[] = [
     description: "Cash distributions with ex-dates in the past twelve months over the reference price." },
   { key: "forwardYield", header: "Fwd yield", align: "right", format: ratio, stackPriority: 1,
     description: "Indicated annual rate over the reference price; none once the dividend has stopped." },
-  { key: "payoutRatio", header: "Payout", align: "right", format: ratio,
-    description: "Trailing twelve-month dividends over trailing twelve-month diluted EPS." },
-  { key: "growth1Y", header: "1Y growth", align: "right", format: growth,
-    description: "Trailing twelve-month cash per share against a year earlier." },
-  { key: "growth3Y", header: "3Y CAGR", align: "right", format: growth,
-    description: "Compound annual growth of trailing twelve-month cash per share over three years." },
+  { key: "payoutRatio", header: "Payout", align: "right",
+    // CSV and NDJSON say `n/m` where JSON has null; the text report draws `N/M` as P/E does.
+    format: (value, row) => row.payoutNotMeaningful === true ? PAYOUT_NOT_MEANINGFUL.toLowerCase() : ratio(value),
+    textFormat: (value, row) => row.payoutNotMeaningful === true ? PAYOUT_NOT_MEANINGFUL : ratio(value),
+    description: "Trailing twelve-month dividends over trailing twelve-month diluted EPS; N/M when that EPS is zero or negative." },
+  { key: "growth1Y", header: "1Y growth", align: "right", format: growth("growth1Y"),
+    description: "Trailing twelve-month cash per share against a year earlier; n/a when either year holds fewer payments than the cadence pays." },
+  { key: "growth3Y", header: "3Y CAGR", align: "right", format: growth("growth3Y"),
+    description: "Compound annual growth of trailing twelve-month cash per share over three years; n/a when either year holds fewer payments than the cadence pays." },
   { key: "lastExDate", header: "Last ex", format: day, shrink: false },
   { key: "payDate", header: "Pay date", format: day, shrink: false, stackPriority: 2,
     description: "Pay date of the next declared distribution; past distributions carry ex-dates only." },
@@ -148,7 +167,11 @@ function rankingColumns(bonds: boolean): HeadlessPaneColumn[] {
 
 /** Shown once a row is incomplete, so a missing figure never reads as a non-payer's. */
 const NOTE_COLUMN: HeadlessPaneColumn = { key: "note", header: "Note", format: (value) => typeof value === "string" ? value : "",
-  description: "What the read of this ticker is missing: not read, no cash history (yields and growth), or no summary (forward yield, payout, pay date)." };
+  description: "What the read of this ticker is missing: not read, no cash history (yields and growth), or no summary (forward yield, payout, pay date); a forward yield read from fundamentals instead is dated by its ex-date." };
+
+/** Shown once a regular payer's trailing year holds fewer payments than its cadence pays, which says nothing is missing from the read itself. */
+const YIELD_BASIS_COLUMN: HeadlessPaneColumn = { key: "yieldBasis", header: "Yield basis", format: (value) => typeof value === "string" ? value : "",
+  description: "How many payments the trailing yield counts when a regular payer's year holds fewer than its cadence pays (a gap in its ex-dates)." };
 
 /** `fn DVD A B C`: one table of every symbol, ranked by trailing yield. */
 export function projectDividendRanking(entries: readonly DividendRankingEntry[], now = new Date()): HeadlessBundleResult {
@@ -167,7 +190,7 @@ export function projectDividendRanking(entries: readonly DividendRankingEntry[],
     } : {}),
     sections: [{
       title: `Ranked by trailing yield; payout is over TTM diluted EPS${bonds ? `; a bond fund's yields are distribution yields, ${NOT_SEC_YIELD}` : ""}`,
-      columns: incomplete.length > 0 ? [...rankingColumns(bonds), NOTE_COLUMN] : rankingColumns(bonds),
+      columns: [...rankingColumns(bonds), ...incomplete.length > 0 ? [NOTE_COLUMN] : [], ...rows.some((row) => row.yieldBasis) ? [YIELD_BASIS_COLUMN] : []],
       rows,
       // Every figure is a percent; each exported row names its ticker and the time of the price its yields are over.
       unit: "pct",
@@ -178,7 +201,7 @@ export function projectDividendRanking(entries: readonly DividendRankingEntry[],
       rankedBy: "trailingYield",
       symbols: entries.map((entry) => entry.symbol),
       yieldMethod: "Cash distributions with ex-dates in the preceding 12 months, one payment per period for a regular cadence, divided by the reference share price, in the listing's own currency.",
-      payoutMethod: "Trailing twelve-month dividends over trailing twelve-month diluted EPS, as the source states it.",
+      payoutMethod: "Trailing twelve-month dividends over trailing twelve-month diluted EPS, as the source states it; N/M (not meaningful) when that EPS is zero or negative.",
       growthMethod: "Trailing twelve-month cash per share now against one and three years before; 3Y is a compound annual rate.",
       payDateMethod: "Pay date of the next declared distribution; past distributions carry ex-dates only.",
       ...bonds ? { secYieldMethod: `A bond fund's 30-day SEC yield as its sponsor publishes it, dated by secYieldAsOf, as a ratio like the other yields; its trailingYield and forwardYield are distribution yields, ${NOT_SEC_YIELD}.` } : {},

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

@@ -1,5 +1,5 @@
 import type { DividendLapse } from "../../../utils/forward-dividend";
-import type { DistributionCadence } from "../../../utils/trailing-dividend";
+import type { DistributionCadence, TrailingPayments } from "../../../utils/trailing-dividend";
 
 export interface DividendPayment {
   exDate: Date;
@@ -9,6 +9,14 @@ export interface DividendPayment {
   amount: number;
   currency: string;
   type: "cash" | "special" | "stock" | "unknown";
+  /** The amount as the company declared it, in another currency than `currency` (BP's dollars beside the pence its London line paid). */
+  declared?: { amount: number; currency: string };
+}
+
+/** A short year a growth figure would compare: its payments, and the day it ends (absent for the trailing year). */
+export interface GrowthPayments extends TrailingPayments {
+  /** YYYY-MM-DD; absent when the short year is the trailing one. */
+  yearTo?: string;
 }
 
 export interface DividendMetrics {
@@ -16,13 +24,23 @@ export interface DividendMetrics {
   forwardYield: number | null;
   trailingRate: number | null;
   forwardRate: number | null;
-  /** The ex-date of the distribution the forward rate annualizes, YYYY-MM-DD. */
+  /** The ex-date of the distribution the forward rate annualizes, YYYY-MM-DD; with `forwardBasis`, the latest of the year's payments. */
   forwardRateAsOf: string | null;
+  /** `uneven`: the year's regular payments differ widely, so the forward rate is their total rather than one annualized (unevenRegularPayments). */
+  forwardBasis?: "uneven" | null;
   /** Set once the dividend has stopped (lapsedDividend), when there is no forward rate or yield. */
   lapse?: DividendLapse | null;
   payoutRatio: number | null;
+  /** Trailing EPS is zero or negative, so a payout ratio says nothing: shown "N/M", never a ratio. */
+  payoutNotMeaningful?: boolean;
+  /** A regular payer's trailing year holds fewer payments than its cadence: the yield counts only these. */
+  trailingPayments?: TrailingPayments | null;
   growth1Y: number | null;
   growth3Y: number | null;
+  /** Set when one of the two years 1Y growth compares holds fewer payments than the cadence pays: no growth, and how many it holds. */
+  growth1YPayments?: GrowthPayments | null;
+  /** The same for the two years the 3Y rate compares. */
+  growth3YPayments?: GrowthPayments | null;
   paymentFrequency: DistributionCadence | null;
   lastExDividendDate: Date | null;
   /** Announced ex-date after now, from the summary or a future-dated history record. */

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

@@ -1,7 +1,8 @@
-import type { DividendPayment } from "./types";
+import type { DividendPayment, GrowthPayments } from "./types";
 import type { ProjectedChartPoint } from "../../../components/chart/core/data";
 import { calendarMonthsBefore } from "../../../utils/calendar-date";
-import { LATE_GRACE_DAYS, trailingCashAt } from "../../../utils/trailing-dividend";
+import { NOT_MEANINGFUL, formatPriceEarnings } from "../../../utils/price-earnings";
+import { LATE_GRACE_DAYS, trailingCashAt, type TrailingPayments } from "../../../utils/trailing-dividend";
 
 const DAY = 24 * 60 * 60 * 1000;
 
@@ -9,6 +10,30 @@ export function formatDividendYield(value: number | null): string {
   return value != null && Number.isFinite(value) ? `${(value * 100).toFixed(2)}%` : "—";
 }
 
+/** A payout over zero or negative earnings, written as a P/E over a loss is. */
+export const PAYOUT_NOT_MEANINGFUL = formatPriceEarnings(NOT_MEANINGFUL);
+
+/** How many payments a trailing yield counts, for a regular payer whose year holds fewer than its cadence pays: "9 of 12 payments". */
+export function trailingPaymentsText(payments: TrailingPayments | null | undefined, { cadence = false }: { cadence?: boolean } = {}): string | null {
+  return payments ? `${payments.counted} of ${payments.expected} ${cadence ? `${payments.cadence} ` : ""}payments` : null;
+}
+
+/** How many payments a growth figure's short year holds: "1 of 2 payments", naming an earlier year by its end. */
+export function growthPaymentsDetail(payments: GrowthPayments): string {
+  return `${payments.counted} of ${payments.expected} payments${payments.yearTo ? ` in the year to ${payments.yearTo}` : ""}`;
+}
+
+/** What a growth figure reads when one of its years is short: "n/a: 1 of 2 payments". */
+export function growthPaymentsText(payments: GrowthPayments): string {
+  return `n/a: ${growthPaymentsDetail(payments)}`;
+}
+
+/** A history served stale, dated by its read when the source gave it. */
+export function staleHistoryText(fetchedAt: string | undefined): string {
+  const day = fetchedAt && /^\d{4}-\d{2}-\d{2}/.test(fetchedAt) ? fetchedAt.slice(0, 10) : null;
+  return `Stale cash history${day ? ` as of ${day}` : ""}; recent distributions may be missing.`;
+}
+
 /** 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)
@@ -52,6 +77,8 @@ export interface DividendRow {
   exDate: string;
   amount: number;
   currency: string;
+  /** The amount as the company declared it, in another currency (DividendPayment.declared). */
+  declared?: { amount: number; currency: string };
 }
 
 export function toDividendRows(payments: DividendPayment[]): DividendRow[] {
@@ -60,5 +87,6 @@ export function toDividendRows(payments: DividendPayment[]): DividendRow[] {
     exDate: payment.exDate.toISOString().slice(0, 10),
     amount: payment.amount,
     currency: payment.currency,
+    ...(payment.declared ? { declared: payment.declared } : {}),
   }));
 }

package/src/plugins/builtin/docs/targets.ts

@@ -10,6 +10,7 @@
  * entry in the docs the app ships.
  */
 import { DOCS_SITE } from "../../../docs/content";
+import { ATTENTION_LISTED } from "../attention/listing";
 import type { DocsTopic } from "../../../docs/topics";
 import {
   helpFunctionForPane,
@@ -25,7 +26,10 @@ const PANE_DOCS: Readonly<Record<string, DocsTopic>> = {
   "twitter-feed": { kind: "function", code: "TWIT" },
   // One article opened from a news list.
   "news-story": { kind: "function", code: "N" },
-  "attention-trending": { kind: "page", slug: "attention" },
+  // The ATTN page while it is listed. Until then the docs have none, so both
+  // panes open the page on Attention Counts, where their numbers come from.
+  "attention-trending": ATTENTION_LISTED ? { kind: "page", slug: "attention" } : { kind: "page", slug: "cloud-and-data" },
+  ...(ATTENTION_LISTED ? {} : { attention: { kind: "page", slug: "cloud-and-data" } as const }),
   // The reader itself: its ? goes back to the index.
   docs: { kind: "home" },
 };

package/src/plugins/builtin/doe/headless.ts

@@ -1,6 +1,6 @@
 import type { DoeSeriesRow, DoeTab } from "../../../api-client/doe";
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
-import { fetchDoeBoard } from "./client";
+import { loadDoeBoard } from "./client";
 import {
   DOE_TABS,
   DOE_UNIT_LABEL,
@@ -61,7 +61,8 @@ export function doeHeadless(defaultTab: DoeTab | "all"): HeadlessPaneDefinition<
         "Five-year ranges read earlier years on the same calendar day.", "A range holds fewer than five years where a series is younger."] },
     describe: "EIA weekly petroleum and natural gas storage",
     async load(args) {
-      const data = await fetchDoeBoard();
+      // Read afresh; a failed read answers from the board an earlier one saved, which the report says it is.
+      const data = (await loadDoeBoard(true)).payload;
       // Each tab is dated by its own EIA report (petroleum Wednesday, gas Thursday);
       // once the next one is a day overdue the tables have missed it. The basis
       // names what Vs 1Y and Vs 5Y avg are measured against.

package/src/plugins/builtin/doe/pane.tsx

@@ -13,8 +13,10 @@ import {
   usePaneTabs,
   type ChartTableChart,
   type DataTableColumn,
+  type PaneFooterSegment,
 } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { savedCopyFooterSegment } from "../../../components/layout/pane/footer";
 import { useAsyncResource, useAutoRefresh, usePaneSettingValue, usePluginPaneState } from "../../../public/react";
 import { usePaneInstance } from "../../../state/app/context";
 import { useThemeColors } from "../../../theme/theme-context";
@@ -136,13 +138,21 @@ export function DoePane({ width, height, focused }: PaneProps) {
   const { strip, rows: tabRows } = usePaneTabs({ tabs: [...DOE_TABS], activeValue: tab, onSelect: setTab, focused, dense: true });
   useAutoRefresh(resource.updatedAt, resource.load);
   usePaneRefreshKey(() => void resource.reload(), { focused });
+  // A refresh that failed shows the board an earlier read saved, and says when that copy is from.
+  const savedAt = resource.data?.savedAt ?? null;
   usePaneNoticeFooter({ registrationId: "doe:notices", focused,
-    notices: [...(data?.gaps ?? []), ...(resource.data?.refreshError ? [resource.data.refreshError] : [])] });
+    notices: [...(data?.gaps ?? []), ...(resource.data?.refreshError && savedAt == null ? [resource.data.refreshError] : [])] });
   // What Vs 1Y and Vs 5Y are measured against on this tab: the EIA's published figures for gas storage.
   const basis = useMemo(() => data ? doeComparisonBasis(doeRows(data, tab)) : null, [data, tab]);
-  const info = useMemo(() => basis ? [{ id: "basis", parts: [{ text: basis, tone: "muted" as const }] }] : undefined, [basis]);
+  const info = useMemo(() => {
+    const segments: PaneFooterSegment[] = [
+      ...(basis ? [{ id: "basis", parts: [{ text: basis, tone: "muted" as const }] }] : []),
+      ...(savedAt != null ? [savedCopyFooterSegment("saved-copy", savedAt)] : []),
+    ];
+    return segments.length ? segments : undefined;
+  }, [basis, savedAt]);
   usePaneStatusFooter({ registrationId: "doe", loading: resource.loading, error: notAvailable ? null : resource.error,
-    stale: !!data && resource.data?.stale, info });
+    stale: !!data && !!resource.data?.stale && savedAt == null, info });
   return (
     <Box width={width} height={height} flexDirection="column">
       {strip}

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

@@ -5,8 +5,7 @@ import type { EarningsEvent } from "../../../types/data-provider";
 import type { EarningsDateStatus, EarningsEpsBasis, Quote } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 import { earningsDateStatus, earningsEpsBasis, isProvisionalActual } from "../shared/earnings-report";
-import { calendarStatus } from "../shared/earnings-calendar";
-import { coherentEarningsValue } from "../shared/earnings-estimate-basis";
+import { calendarReport } from "../shared/earnings-calendar";
 import { shortDate, surprise, weekday } from "./format";
 
 /** A held name is in a portfolio; a watched one only in watchlists. */
@@ -149,33 +148,35 @@ export function boardReport(report: EarningsCalendarReport, owned: ReadonlyMap<s
   };
 }
 
-/** A company the stored calendar does not carry (a listing abroad, a date past its horizon) from the per-ticker calendar. */
+/**
+ * A company the stored calendar does not carry (a listing abroad, a date past
+ * its horizon) from the per-ticker calendar, read as every earnings surface
+ * reads its report (shared/earnings-calendar): a date gone by is reported, and
+ * keeps a consensus only when it is that report's, not the next quarter's.
+ */
 export function fallbackReport(event: EarningsEvent, owned: ReadonlyMap<string, Ownership>, today: string): BoardReport {
-  const date = event.earningsDate.toISOString().slice(0, 10);
-  const timing = event.timing === "BMO" ? "bmo" : event.timing === "AMC" ? "amc" : null;
+  const report = calendarReport(event, today);
   // Estimates in another currency would read as dollars beside the rest.
   const dollars = (field: "epsEstimate" | "revenueEstimate") => {
     const currency = event.estimateBasis?.[field]?.currency;
-    return currency && currency !== "USD" ? null : coherentEarningsValue(event, field);
+    return currency && currency !== "USD" ? null : report[field];
   };
   const epsEstimate = dollars("epsEstimate");
   return {
-    key: `${event.symbol}:${date}`,
+    key: `${event.symbol}:${report.date}`,
     symbol: event.symbol,
     name: event.name || event.symbol,
-    date,
-    timing,
+    date: report.date,
+    timing: report.timing,
     expectedTiming: false,
-    // A date gone by is reported, as every earnings surface reads it (shared/earnings-calendar).
-    dateStatus: calendarStatus(event, today),
+    dateStatus: report.dateStatus,
     marketCap: null,
     epsEstimate,
-    // The count belongs to the estimate beside it.
-    epsAnalysts: epsEstimate == null ? null : coherentEarningsValue(event, "epsAnalysts"),
+    // The count and the basis belong to the estimate beside them.
+    epsAnalysts: epsEstimate == null ? null : report.epsAnalysts,
     epsActual: null,
     provisional: false,
-    // The estimate's basis goes with it.
-    epsBasis: epsEstimate == null ? null : earningsEpsBasis(event.epsBasis),
+    epsBasis: epsEstimate == null ? null : report.epsBasis,
     epsSurprise: null,
     revenueEstimate: dollars("revenueEstimate"),
     impliedMove: null,

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

@@ -2,7 +2,6 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   DataTableStackView,
   PageStackView,
-  PaneStatusBody,
   QueryBar,
   usePaneFooter,
   usePaneMenuItems,
@@ -62,8 +61,7 @@ import {
   earningsScopeOptions,
   MINE_SCOPE,
   readEarningsScope,
-  SECTOR_HOLDINGS_FUND,
-  sectorSymbols,
+  fundSymbols,
   type EarningsScope,
 } from "./scope";
 
@@ -78,9 +76,8 @@ const MARKET_PER_DAY = 200;
 const MAX_SYMBOLS = 200;
 
 const MARKET_SCOPE: EarningsScope = { kind: "all" };
-const loadSectorHoldings = (force: boolean) => loadMembers(SECTOR_HOLDINGS_FUND, force);
-/** A sector fund's companies the board reads, its largest first. */
-const sectorNames = (...args: Parameters<typeof sectorSymbols>) => sectorSymbols(...args).slice(0, MAX_SYMBOLS);
+/** A fund's companies the board reads, its largest first. */
+const fundNames = (members: Parameters<typeof fundSymbols>[0]) => fundSymbols(members).slice(0, MAX_SYMBOLS);
 
 type Order = "cap" | "mine";
 type BoardView = "table" | "calendar";
@@ -100,7 +97,7 @@ interface BoardData {
 /**
  * ERN without a ticker: the market's report days, largest companies first,
  * with the implied move and each company's average move. With tickers, or the
- * Names filter (Mine, a portfolio, a watchlist or a sector fund's holdings),
+ * Names filter (Mine, a portfolio, a watchlist or a fund's holdings),
  * the upcoming reports of those companies instead.
  */
 export function EarningsBoard({ focused, width, height, scopedSymbols, highlight = null }: {
@@ -152,9 +149,7 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
     () => earningsScopeOptions({ portfolios: config.portfolios, watchlists: config.watchlists }),
     [config.portfolios, config.watchlists],
   );
-  const chosenScope = readEarningsScope(savedScope ?? (mineOnly ? MINE_SCOPE : ALL_SCOPE), scopeOptions);
-  // The terminal keeps its Mine toggle, so a choice only the desktop offers reads as the market there.
-  const scopeOption = desktop || chosenScope.value === MINE_SCOPE ? chosenScope : scopeOptions[0]!;
+  const scopeOption = readEarningsScope(savedScope ?? (mineOnly ? MINE_SCOPE : ALL_SCOPE), scopeOptions);
   const scoped = scopedSymbols.length > 0;
   const scope = scoped ? MARKET_SCOPE : scopeOption.scope;
   const view: BoardView = !desktop ? "table"
@@ -174,17 +169,17 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
       .sort()
       .join(",");
   }, [scope, tickers]);
-  const sector = scope.kind === "sector" ? scope : null;
-  // A sector fund's companies come with its holdings, which the loader reads; the others are known here.
+  const fund = scope.kind === "fund" ? scope : null;
+  // A fund's companies come with its holdings, which the loader reads; the others are known here.
   const named = useMemo(() => {
     const names = scoped ? [...scopedSymbols]
       : scope.kind === "portfolio" || scope.kind === "watchlist" ? (collectionKey ? collectionKey.split(",") : [])
-        : scope.kind === "sector" ? [] : [...owned.keys()];
+        : scope.kind === "fund" ? [] : [...owned.keys()];
     return names.slice(0, MAX_SYMBOLS);
   }, [collectionKey, owned, scope.kind, scoped, scopedSymbols]);
   // Named companies also go to the per-ticker calendar, which covers listings the stored one does not;
-  // a sector fund's are S&P 500 companies, all in the stored one.
-  const perTicker = !market && !sector;
+  // fund scopes use the stored calendar, including members outside the S&P 500.
+  const perTicker = !market && !fund;
   // The days ahead by default; a chosen week or day, past or ahead, for the market and for named companies alike.
   const days = useMemo(() => (market || range ? boardRangeDays(range, today) : relativeDays(today)), [market, range, today]);
   const weekOffset = boardRangeWeek(range, today);
@@ -196,13 +191,14 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
       ? { from: days[0]!.from, to: days.at(-1)!.to, perDay: market ? MARKET_PER_DAY : 0, symbols: named }
       : { from: today, to: addDays(today, HORIZON_DAYS), perDay: 0, symbols: named },
   [calendar, days, market, named, range, today, week]);
-  // A sector fund's read is named by the fund: its companies are known once its holdings are.
-  const queryKey = sector ? `${sector.etf}|${earningsCalendarKey(query)}` : earningsCalendarKey(query);
+  // A fund's read is named by the fund: its companies are known once its holdings are.
+  const queryKey = fund ? `${fund.etf}|${earningsCalendarKey(query)}` : earningsCalendarKey(query);
 
   const loader = useCallback(async (force: boolean): Promise<BoardData> => {
-    const names = sector ? sectorNames((await loadSectorHoldings(force)).payload.members, sector.sectors) : named;
-    if (!market && names.length === 0) return { queryKey, reports: [], stale: false, refreshError: null };
-    const read = sector ? { ...query, symbols: names } : query;
+    const holdings = fund ? await loadMembers(fund.etf, force) : null;
+    const names = holdings ? fundNames(holdings.payload.members) : named;
+    if (!market && names.length === 0) return { queryKey, reports: [], stale: !!holdings && (holdings.stale || holdings.payload.stale), refreshError: holdings?.refreshError ?? null };
+    const read = fund ? { ...query, symbols: names } : query;
     const [cloud, fallback] = await Promise.allSettled([
       loadEarningsBoard(read, force),
       !perTicker ? Promise.resolve([] as EarningsEvent[]) : loadEarningsCalendar(dataProvider, names, { force }).then((result) => result.events
@@ -218,24 +214,24 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
     return {
       queryKey,
       reports: [...reports, ...extra],
-      stale: cloud.status === "fulfilled" && cloud.value.stale,
+      stale: (!!holdings && (holdings.stale || holdings.payload.stale)) || (cloud.status === "fulfilled" && cloud.value.stale),
       refreshError: cloud.status === "rejected"
         ? (cloud.reason instanceof Error ? cloud.reason.message : String(cloud.reason))
-        : cloud.value.refreshError,
+        : holdings?.refreshError ?? cloud.value.refreshError,
     };
-  }, [calendar, dataProvider, market, named, owned, perTicker, query, queryKey, range, sector, today]);
+  }, [calendar, dataProvider, market, named, owned, perTicker, query, queryKey, range, fund, today]);
   const resource = useAsyncResource(loader, {
     keepPreviousData: true,
     initialData: () => {
-      const holdings = sector ? cachedMembers(SECTOR_HOLDINGS_FUND) : null;
-      if (sector && !holdings) return null;
-      const cached = cachedEarningsCalendar(sector && holdings ? { ...query, symbols: sectorNames(holdings.payload.members, sector.sectors) } : query);
-      return cached ? { queryKey, reports: cached.payload.reports.map((report) => boardReport(report, owned)), stale: false, refreshError: null } : null;
+      const holdings = fund ? cachedMembers(fund.etf) : null;
+      if (fund && !holdings) return null;
+      const cached = cachedEarningsCalendar(holdings ? { ...query, symbols: fundNames(holdings.payload.members) } : query);
+      return cached ? { queryKey, reports: cached.payload.reports.map((report) => boardReport(report, owned)), stale: !!holdings?.payload.stale, refreshError: null } : null;
     },
   });
-  const data = resource.data;
-  // The week on screen is only the one read for it, never the last week's kept while this one loads or after it failed.
-  const weekData = data?.queryKey === queryKey ? data : null;
+  // A new fund or range never shows the previous scope while its holdings load or fail.
+  const data = resource.data?.queryKey === queryKey ? resource.data : null;
+  const weekData = data;
   const rows = useMemo(() => boardRows(data?.reports ?? [], days, sort, order === "mine"), [data, days, order, sort]);
   const reportRows = useMemo(() => rows.filter((row): row is BoardRow & { kind: "report" } => row.kind === "report"), [rows]);
   const slotsPerRow = calendarSlotsPerRow(width);
@@ -336,16 +332,12 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
   usePaneRefreshKey(() => void resource.reload(), { focused, enabled: calendar && !open });
 
   const sortColumn = (Object.entries(SORTABLE).find(([, value]) => value === sort.column)?.[0]) ?? null;
-  const mineFilter: QueryBarFilter[] = scoped ? [] : [
-    { id: "mine", kind: "toggle", label: "Mine", value: scope.kind === "mine", defaultValue: false, onChange: (mine: boolean) => setScope(mine ? MINE_SCOPE : ALL_SCOPE) },
-  ];
-  // The desktop's Mine is one choice of the Names filter, beside each portfolio, watchlist and sector fund.
   const namesFilter: QueryBarFilter[] = scoped ? [] : [{
     id: "names",
     label: "Names",
     value: scopeOption.value,
     defaultValue: ALL_SCOPE,
-    options: scopeOptions.map(({ value, label, description }) => ({ value, label, description })),
+    options: scopeOptions.map(({ value, label, description, group, scope }) => ({ value, label, description, group, short: !desktop && scope.kind === "fund" ? scope.etf : undefined })),
     onChange: (value: string) => setScope(value),
   }];
   const orderView: QueryBarView<Order> = { value: order, options: ORDER_OPTIONS, onChange: setOrder };
@@ -371,7 +363,7 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
       onChange: (value: string) => { setRange(value); setSelectedKey(null); },
     };
   // On the desktop the view picks the table or the week, and the order is a filter beside the names and the Range.
-  const queryBar = !desktop ? <QueryBar width={width} filters={[...mineFilter, rangeFilter]} view={orderView} /> : (
+  const queryBar = !desktop ? <QueryBar width={width} filters={[...namesFilter, rangeFilter]} view={orderView} /> : (
     <QueryBar
       width={width}
       filters={[
@@ -431,41 +423,40 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
   }
 
   return (
-    <PaneStatusBody loading={resource.loading && !data} error={!data ? resource.error : null} subject="the earnings calendar">
-      <DataTableStackView<BoardRow, BoardColumn>
-        focused={focused}
-        rootWidth={width}
-        rootHeight={height}
-        rootBefore={queryBar}
-        columns={columns}
-        items={rows}
-        getItemKey={(row) => row.key}
-        isNavigable={(row) => row.kind === "report"}
-        renderSectionHeader={renderBoardSection}
-        renderCell={renderCell}
-        getRowVersion={rowVersion}
-        selectedTextOverridesCellColor
-        sortColumnId={sortColumn}
-        sortDirection={sort.direction}
-        onHeaderClick={(columnId) => {
-          const column = SORTABLE[columnId as BoardColumn["id"]];
-          if (!column) return;
-          setSort((current) => ({ column, direction: current.column === column && current.direction === "desc" ? "asc" : column === "symbol" ? "asc" : "desc" }));
-        }}
-        selection={{
-          kind: "index",
-          selectedIndex: selected ? rows.indexOf(selected) : -1,
-          onChange: (_index, row) => { if (row.kind === "report") setSelectedKey(row.key); },
-        }}
-        onActivate={(row) => { if (row.kind === "report") setOpenKey(row.key); }}
-        onRootKeyDown={handleKeyDown}
-        detailOpen={!!open}
-        onBack={() => setOpenKey(null)}
-        detailTitle={open ? `${open.symbol} · ${open.name}` : undefined}
-        detailContent={history}
-        emptyStateTitle={emptyStateTitle}
-      />
-    </PaneStatusBody>
+    <DataTableStackView<BoardRow, BoardColumn>
+      focused={focused}
+      rootWidth={width}
+      rootHeight={height}
+      rootBefore={queryBar}
+      status={{ loading: resource.loading && !data, error: !data ? resource.error : null, subject: "the earnings calendar" }}
+      columns={columns}
+      items={rows}
+      getItemKey={(row) => row.key}
+      isNavigable={(row) => row.kind === "report"}
+      renderSectionHeader={renderBoardSection}
+      renderCell={renderCell}
+      getRowVersion={rowVersion}
+      selectedTextOverridesCellColor
+      sortColumnId={sortColumn}
+      sortDirection={sort.direction}
+      onHeaderClick={(columnId) => {
+        const column = SORTABLE[columnId as BoardColumn["id"]];
+        if (!column) return;
+        setSort((current) => ({ column, direction: current.column === column && current.direction === "desc" ? "asc" : column === "symbol" ? "asc" : "desc" }));
+      }}
+      selection={{
+        kind: "index",
+        selectedIndex: selected ? rows.indexOf(selected) : -1,
+        onChange: (_index, row) => { if (row.kind === "report") setSelectedKey(row.key); },
+      }}
+      onActivate={(row) => { if (row.kind === "report") setOpenKey(row.key); }}
+      onRootKeyDown={handleKeyDown}
+      detailOpen={!!open}
+      onBack={() => setOpenKey(null)}
+      detailTitle={open ? `${open.symbol} · ${open.name}` : undefined}
+      detailContent={history}
+      emptyStateTitle={emptyStateTitle}
+    />
   );
 }