gloomberb 0.18.3 → 0.18.5

package/src/plugins/builtin/crypto-etf-flows/pane.tsx

@@ -0,0 +1,193 @@
+import { useCallback, useMemo } from "react";
+import type { CryptoEtfFlowAsset, CryptoEtfFlowDay } from "../../../api-client/crypto-etf-flows";
+import { isAccessDenied } from "../../../api-client/errors";
+import {
+  ChartTableHeader,
+  DataTableView,
+  PaneStatusBody,
+  QueryBar,
+  useChartTableSelection,
+  usePaneNoticeFooter,
+  usePaneStatusLinkFooter,
+  type DataTableCell,
+  type StatItem,
+} from "../../../components";
+import { formatCompactAxis } from "../../../components/chart-table";
+import { useChartViewReset } from "../../../components/chart/core/view-reset";
+import { scalarPoint, staticSeries } from "../../../components/chart/static/series";
+import { handleRefreshKey, usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { useAsyncResource, useAutoRefresh, usePaneSettingValue, usePluginPaneState, useUpdatedAgo } from "../../../public/react";
+import { colors } from "../../../theme/colors";
+import type { PaneProps } from "../../../types/plugin";
+import { Box } from "../../../ui";
+import { isPlainKeyboardEvent } from "../../../utils/keyboard";
+import { cachedCryptoEtfFlows, loadCryptoEtfFlows } from "./client";
+import {
+  CRYPTO_ETF_FLOW_ASSETS,
+  CRYPTO_ETF_FLOW_RANGES,
+  CRYPTO_ETF_FLOWS_PANE_ID,
+  cryptoEtfFlowAsset,
+  cryptoEtfFlowAssetLabel,
+  cryptoEtfFlowColumns,
+  cryptoEtfFlowRange,
+  cryptoEtfFlowSummary,
+  cumulativeFlows,
+  daysInRange,
+  flowColor,
+  formatFlow,
+  formatFlowAmount,
+  fundTickerOfColumn,
+  pendingText,
+  type CryptoEtfFlowColumn,
+  type CryptoEtfFlowRange,
+} from "./model";
+
+const EMPTY_DAYS: CryptoEtfFlowDay[] = [];
+const rowId = (day: CryptoEtfFlowDay) => day.date;
+const rowDate = (day: CryptoEtfFlowDay) => new Date(`${day.date}T00:00:00Z`);
+/** Ticks in one compact unit for the axis (`$40B`, `-$1.5B`), with the decimals the plotted range needs. */
+function formatFlowAxis(value: number, domain: Parameters<typeof formatCompactAxis>[1]): string {
+  const text = formatCompactAxis(value, domain);
+  return text.startsWith("-") ? `-$${text.slice(1)}` : `$${text}`;
+}
+/** The legend's running total, in dollars: no sign for an inflow, as a level reads. */
+const formatRunningTotal = (dollars: number) => formatFlowAmount(dollars / 1_000_000).replace(/^\+/, "");
+
+export function CryptoEtfFlowsPane({ focused, width, height }: PaneProps) {
+  const [assetSetting, setAssetSetting] = usePaneSettingValue<string>("asset", "btc");
+  const asset = cryptoEtfFlowAsset(assetSetting);
+  const [storedRange, setStoredRange] = usePluginPaneState<string>("range", "1Y");
+  const range = cryptoEtfFlowRange(storedRange);
+  const [selectedByAsset, setSelectedByAsset] = usePluginPaneState<Partial<Record<CryptoEtfFlowAsset, string>>>("selected", {});
+  const resetChartView = useChartViewReset();
+
+  const loader = useCallback((force: boolean) => loadCryptoEtfFlows(asset, force), [asset]);
+  const resource = useAsyncResource(loader, { initialData: () => cachedCryptoEtfFlows(asset), clearOnError: isAccessDenied });
+  // Reuse this asset's cached view immediately when switching back to it.
+  const current = resource.data ?? (resource.loading ? cachedCryptoEtfFlows(asset) : null);
+  // A copy of the other asset's flows is never drawn under this one's name.
+  const data = current?.payload.asset === asset ? current.payload : null;
+  const days = useMemo(() => data ? daysInRange(data.days, range) : EMPTY_DAYS, [data, range]);
+  const columns = useMemo(() => cryptoEtfFlowColumns(data), [data]);
+  const summary = useMemo(() => data ? cryptoEtfFlowSummary(data) : null, [data]);
+  const selectedId = selectedByAsset[asset] && days.some((day) => day.date === selectedByAsset[asset]) ? selectedByAsset[asset]! : days[0]?.date ?? null;
+  const selectDay = useCallback((id: string | null) => {
+    setSelectedByAsset((current) => ({ ...current, [asset]: id ?? undefined }));
+  }, [asset, setSelectedByAsset]);
+
+  const label = cryptoEtfFlowAssetLabel(asset);
+  // The running total since the first fund launched, drawn over the range the table lists.
+  const series = useMemo(() => {
+    if (!data) return [];
+    const first = days.at(-1)?.date ?? "";
+    const points = cumulativeFlows(data).filter((point) => point.date >= first)
+      .map((point) => scalarPoint(new Date(`${point.date}T00:00:00Z`), point.value * 1_000_000));
+    return [staticSeries(points, { id: `etf-flows:${asset}`, label: `${label} ETF net flows since launch`, color: colors.positive, calendarSpaced: true })];
+  }, [asset, data, days, label]);
+  const link = useChartTableSelection({ rows: days, getId: rowId, getDate: rowDate, selectedId, onSelect: selectDay, focused });
+
+  const latest = summary?.latest ?? null;
+  const pending = pendingText(latest);
+  const figures: StatItem[] = summary ? [
+    { id: "latest", label: "Latest day", value: formatFlowAmount(latest?.total), color: flowColor(latest?.total, colors),
+      detail: [latest?.date, pending].filter(Boolean).join(" · ") || undefined },
+    { id: "week", label: "5 days", value: formatFlowAmount(summary.week), color: flowColor(summary.week, colors) },
+    { id: "month", label: "20 days", value: formatFlowAmount(summary.month), color: flowColor(summary.month, colors) },
+    { id: "launch", label: "Since launch", value: formatFlowAmount(summary.sinceLaunch), color: flowColor(summary.sinceLaunch, colors),
+      detail: summary.firstDate ? `since ${summary.firstDate}` : undefined },
+  ] : [];
+
+  const updatedAgo = useUpdatedAgo(resource.updatedAt);
+  const footerInfo = useMemo(() => data ? [
+    { id: "as-of", parts: [{ text: `as of ${data.asOf}`, tone: "muted" as const }] },
+    ...(updatedAgo ? [{ id: "updated", parts: [{ text: updatedAgo, tone: "muted" as const }] }] : []),
+  ] : [], [data, updatedAgo]);
+  useAutoRefresh(resource.updatedAt, resource.load);
+  const refresh = useCallback(() => void resource.reload(), [resource.reload]);
+  usePaneRefreshKey(refresh, { focused });
+  usePaneStatusLinkFooter({
+    registrationId: CRYPTO_ETF_FLOWS_PANE_ID, focused, loading: resource.loading, error: data ? null : resource.error,
+    url: data?.source.url ?? null, source: data?.source.publisher ?? null, label: "publisher", showOpenHint: true,
+    info: footerInfo, stale: !!data && (data.stale || !!current?.stale),
+  });
+  usePaneNoticeFooter({
+    registrationId: `${CRYPTO_ETF_FLOWS_PANE_ID}:notices`, focused,
+    notices: [
+      ...(data?.stale ? [`The flows were last read ${data.fetchedAt.slice(0, 10)}; newer days may be missing.`] : []),
+      ...(data && current?.refreshError ? [current.refreshError] : []),
+    ],
+  });
+
+  const selectAsset = useCallback((value: string) => setAssetSetting(cryptoEtfFlowAsset(value).toLowerCase()), [setAssetSetting]);
+  const selectRange = useCallback((value: CryptoEtfFlowRange) => setStoredRange(value), [setStoredRange]);
+  // The number keys pick the range, as the bar's hints say; picking the one showing sends the chart back to it.
+  const handleKeyDown = useCallback((event: Parameters<typeof handleRefreshKey>[0]) => {
+    if (handleRefreshKey(event, refresh, { stopPropagation: true })) return true;
+    if (!isPlainKeyboardEvent(event)) return false;
+    const picked = CRYPTO_ETF_FLOW_RANGES.find((option) => option.hint === event.name);
+    if (!picked) return false;
+    event.preventDefault?.();
+    if (picked.value === range) resetChartView();
+    else selectRange(picked.value);
+    return true;
+  }, [range, refresh, resetChartView, selectRange]);
+
+  const renderCell = useCallback((day: CryptoEtfFlowDay, column: CryptoEtfFlowColumn): DataTableCell => {
+    if (column.id === "date") return { text: day.date, value: day.date, color: colors.text };
+    if (column.id === "total") return { text: formatFlow(day.total), value: day.total, color: flowColor(day.total, colors) };
+    const ticker = fundTickerOfColumn(column.id) ?? "";
+    const value = day.flows[ticker] ?? null;
+    // A fund that reported the day before and not yet today: its figure is to come, not none.
+    if (value == null && day.pending.includes(ticker)) return { text: "pending", value: null, color: colors.textMuted };
+    return { text: formatFlow(value), value, color: flowColor(value, colors) };
+  }, []);
+
+  const query = (
+    <QueryBar
+      width={width}
+      filters={[
+        { id: "asset", label: "Asset", inline: true, value: asset, options: CRYPTO_ETF_FLOW_ASSETS.map(({ value, label: name }) => ({ value, label: name })), onChange: selectAsset },
+        { id: "range", label: "Range", inline: true, chartRange: true, value: range, options: CRYPTO_ETF_FLOW_RANGES, onChange: (value: string) => selectRange(cryptoEtfFlowRange(value)) },
+      ]}
+      meta="US$ millions"
+    />
+  );
+
+  return (
+    <Box flexDirection="column" width={width} height={height}>
+      {query}
+      <PaneStatusBody loading={resource.loading && !data} error={!data ? resource.error : null} subject={`${label.toLowerCase()} ETF flows`}
+        empty={!resource.loading && !resource.error && !!data && !data.days.length} emptyTitle={`No ${label.toLowerCase()} ETF flows listed yet.`}>
+        {data ? (
+          <DataTableView<CryptoEtfFlowDay, CryptoEtfFlowColumn>
+            focused={focused}
+            rootWidth={width}
+            rootHeight={Math.max(0, height - 1)}
+            rootBefore={(
+              <ChartTableHeader
+                width={width}
+                height={Math.max(0, height - 1)}
+                tableRows={days.length}
+                tableColumns={columns}
+                figures={figures}
+                chart={{ series, formatValue: formatRunningTotal, formatAxisValue: formatFlowAxis, remoteKind: "crypto-etf-flows", ...link }}
+              />
+            )}
+            selection={{ kind: "id", selectedId, getId: rowId, onChange: selectDay }}
+            onRootKeyDown={handleKeyDown}
+            columns={columns}
+            items={days}
+            freezeFirstColumn
+            sortColumnId={null}
+            sortDirection="desc"
+            getItemKey={rowId}
+            renderCell={renderCell}
+            selectedTextOverridesCellColor
+            resetScrollKey={`${asset}:${range}`}
+            emptyStateTitle="No trading days in this range."
+          />
+        ) : null}
+      </PaneStatusBody>
+    </Box>
+  );
+}

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

@@ -288,6 +288,7 @@ export const debugPlugin: GloomPlugin = {
       name: "Debug Log",
       icon: "D",
       component: DebugPane,
+      reportFreshness: { status: "not-a-feed", basis: "debug log" },
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 120, height: 30 },

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

@@ -69,7 +69,7 @@ function createDividendYieldModule({
           id: "dividend-yield-pane",
           paneId: "dividend-yield",
           label: "Dividend Yield",
-          description: "Cash distribution history, trailing and forward yield, payout and growth; gloomberb fn DVD with several tickers ranks them by yield. "
+          description: "Cash distribution history, trailing and forward yield, payout and growth; gloom fn DVD with several tickers ranks them by yield. "
             + "A bond fund's SEC yield beside its distribution yield, and with --tax-rate a muni fund's tax-equivalent yield. Future payments are not forecast.",
           keywords: ["dividend", "dividends", "yield", "dvd", "income", "payout", "ex-date", "distribution", "dividend income", "income investing",
             "dividend growth", "payout ratio", "drip", "reinvest", "reinvestment", "dividend reinvestment", "rank dividend payers",

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

@@ -14,7 +14,7 @@ const DOCS_INSTANCE_ID = "docs";
 
 function requestedTopic(context: PaneTemplateContext, options?: PaneTemplateCreateOptions): DocsTopic {
   const registry = getSharedRegistry();
-  // The command line (`gloomberb fn DOCS RV`) has no registry: the argument goes to the reader as a search.
+  // The command line (`gloom fn DOCS RV`) has no registry: the argument goes to the reader as a search.
   const index = registry ? buildRegistryHelpIndex(registry) : null;
   const paneId = options?.values?.pane;
   if (paneId && registry && index) {

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

@@ -331,13 +331,13 @@ export function DocsPane({ focused, width, height }: PaneProps) {
   }, [entries, query, show]);
 
   const visibleEntries = useMemo(() => rows.filter(isSectionedItemRow).map((row) => row.item), [rows]);
-  // A request that matches nothing fails a report of the pane (`gloomberb fn DOCS zzzz`) instead of listing the whole index.
+  // A request that matches nothing fails a report of the pane (`gloom fn DOCS zzzz`) instead of listing the whole index.
   const requested = requestKey ? parseDocsTopicKey(requestKey) : null;
   const requestedQuery = requested?.kind === "home" ? requested.query?.trim() ?? "" : "";
   useRemoteUiNode(feed && requestedQuery && stack.length === 0 && query.trim() === requestedQuery && visibleEntries.length === 0 ? {
     role: "report-failure",
     label: "No docs entry",
-    getMetadata: () => ({ message: `No docs entry for ${requestedQuery}.`, details: "Run gloomberb fn DOCS for the index." }),
+    getMetadata: () => ({ message: `No docs entry for ${requestedQuery}.`, details: "Run gloom fn DOCS for the index." }),
   } : null);
   const effectiveSelectedKey = visibleEntries.some((entry) => entry.key === selectedKey)
     ? selectedKey

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

@@ -66,7 +66,7 @@ export function docsTopicForPane(
 export function docsTopicForArgument(index: HelpFunctionIndex | null, argument: string): DocsTopic {
   const query = argument.trim();
   if (!query) return { kind: "home" };
-  // A command line with no registry (`gloomberb fn DOCS RV`) cannot resolve a mnemonic here: the reader does, from its own entries.
+  // A command line with no registry (`gloom fn DOCS RV`) cannot resolve a mnemonic here: the reader does, from its own entries.
   const fn = index?.get(query.toUpperCase()) ?? index?.get((query.split(/\s+/)[0] ?? "").toUpperCase());
   if (fn) return docsTopicForFunction(fn);
   return { kind: "home", query };

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

@@ -21,6 +21,8 @@ const dateOrNull = (value: unknown) => value === null || date(value);
 const instantOrNull = (value: unknown) => value === null || typeof value === "string" && Number.isFinite(Date.parse(value));
 const finite = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
 const finiteOrNull = (value: unknown) => value === null || finite(value);
+/** A field older servers leave out: absent, null or a number. */
+const optionalFinite = (value: unknown) => value === undefined || finiteOrNull(value);
 const pairs = (value: unknown) => Array.isArray(value)
   && value.every((pair) => Array.isArray(pair) && Number.isInteger(pair[0]) && finite(pair[1]));
 
@@ -29,6 +31,7 @@ function validRow(row: DoeSeriesRow): boolean {
   return typeof row.id === "string" && typeof row.label === "string" && UNITS.has(row.unit) && TABS.has(row.tab)
     && dateOrNull(row.weekEnding) && finiteOrNull(row.value) && finiteOrNull(row.weekChange) && (row.value == null) === (row.weekEnding == null)
     && (row.read === null || typeof row.read === "string")
+    && (row.basis === undefined || row.basis === "published" || row.basis === "computed")
     && (ago === null || date(ago.weekEnding) && finite(ago.value) && finite(ago.change) && finiteOrNull(ago.changePercent))
     && (five === null || Array.isArray(five.years) && five.years.length > 0 && [five.min, five.max, five.average, five.vsAverage].every(finite)
       && five.min <= five.max && finiteOrNull(five.averageChange) && finiteOrNull(five.vsAveragePercent) && finiteOrNull(five.position))
@@ -44,7 +47,8 @@ function validateDoeBoard(payload: DoeBoardPayload): DoeBoardPayload {
     || !Array.isArray(payload.gaps) || !payload.gaps.every((gap) => typeof gap === "string")
     || !Array.isArray(payload.reports) || !payload.reports.every((report) => (report.id === "petroleum" || report.id === "gas")
       && dateOrNull(report.weekEnding) && dateOrNull(report.nextWeekEnding)
-      && instantOrNull(report.releasedAt) && instantOrNull(report.nextReleaseAt))
+      && instantOrNull(report.releasedAt) && instantOrNull(report.nextReleaseAt)
+      && optionalFinite(report.nextConsensus) && optionalFinite(report.nextPrior))
     || !Array.isArray(payload.series) || new Set(payload.series.map((row) => row.id)).size !== payload.series.length
     || !payload.series.every(validRow)) {
     throw new Error("The server returned an invalid EIA weekly board");

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

@@ -4,6 +4,7 @@ import { fetchDoeBoard } from "./client";
 import {
   DOE_TABS,
   DOE_UNIT_LABEL,
+  doeComparisonBasis,
   doeHeaderLine,
   doeReport,
   doeRows,
@@ -62,11 +63,16 @@ export function doeHeadless(defaultTab: DoeTab | "all"): HeadlessPaneDefinition<
     async load(args) {
       const data = await fetchDoeBoard();
       // 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.
-      const freshness = (tabs: readonly DoeTab[]) => {
+      // 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.
+      const freshness = (tabs: readonly DoeTab[], rows: readonly DoeSeriesRow[]) => {
         const reports = [...new Set(tabs.flatMap((tab) => doeReport(data, tab) ?? []))];
-        return { source: "EIA", status: "not-a-feed" as const, basis: "weekly release",
-          asOf: newestReportTime(reports.map((report) => report.releasedAt)),
+        const comparison = doeComparisonBasis(rows);
+        // The newest report's week and when EIA released it: `Fri 16 Oct 2026, released Thu 22 Oct 14:30 UTC`.
+        const releasedAt = newestReportTime(reports.map((report) => report.releasedAt));
+        const week = reports.find((report) => report.releasedAt === releasedAt)?.weekEnding;
+        return { source: "EIA", status: "not-a-feed" as const, basis: comparison ? `weekly release; ${comparison}` : "weekly release",
+          ...(week && releasedAt ? { asOf: week, releasedOn: releasedAt } : { asOf: releasedAt }),
           nextExpectedAt: oldestReportTime(reports.map((report) => report.nextReleaseAt)) };
       };
       const argument = Array.isArray(args.argument) ? args.argument.join(" ") : args.argument;
@@ -84,7 +90,7 @@ export function doeHeadless(defaultTab: DoeTab | "all"): HeadlessPaneDefinition<
               rows: seasonalRows(row) },
           ],
           errors: data.gaps,
-          freshness: freshness([row.tab]),
+          freshness: freshness([row.tab], [row]),
           metadata: { ...data, series: [row], complete: data.status === "available" },
         };
       }
@@ -96,7 +102,7 @@ export function doeHeadless(defaultTab: DoeTab | "all"): HeadlessPaneDefinition<
           rows: doeRows(data, tab).map(reportRow),
         })),
         errors: data.gaps,
-        freshness: freshness(tabs),
+        freshness: freshness(tabs, tabs.flatMap((tab) => doeRows(data, tab))),
         metadata: { ...data, complete: data.status === "available" },
       };
     },

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

@@ -131,19 +131,56 @@ function doeReleaseTime(iso: string): string {
   return `${parts.weekday} ${parts.month} ${parts.day} ${parts.hour}:${parts.minute} ET`;
 }
 
+/** The calendar's expectation for the next gas release, as the 1W change column reads it: "consensus +80 Bcf, prior +77 Bcf". */
+function doeExpected(report: DoeReportStatus): string | null {
+  if (report.id !== "gas") return null;
+  const parts = [
+    report.nextConsensus != null ? `consensus ${formatDoeChange("bcf", report.nextConsensus)} Bcf` : null,
+    report.nextPrior != null ? `prior ${formatDoeChange("bcf", report.nextPrior)} Bcf` : null,
+  ].filter((part): part is string => !!part);
+  return parts.length ? parts.join(", ") : null;
+}
+
 /**
  * The tab's report on one line: the data week, when it came out and when the
- * next one is due, with the holiday that moved it.
+ * next one is due, with the holiday that moved it and, for gas storage, the
+ * calendar's consensus and prior for it. Where the line runs longer than
+ * `width`, when the week came out gives way first, so the next release and
+ * what it is expected to show stay whole.
  */
-export function doeHeaderLine(report: DoeReportStatus | null, now = Date.now()): string | undefined {
+export function doeHeaderLine(report: DoeReportStatus | null, now = Date.now(), width = Number.POSITIVE_INFINITY): string | undefined {
   if (!report?.weekEnding) return undefined;
-  const parts = [`Week ending ${doeDay(report.weekEnding)}`];
-  if (report.releasedAt) parts.push(`released ${doeReleaseTime(report.releasedAt)}`);
+  const week = `Week ending ${doeDay(report.weekEnding)}`;
+  const released = report.releasedAt ? `released ${doeReleaseTime(report.releasedAt)}` : null;
+  let next: string | null = null;
   if (report.nextReleaseAt) {
     const due = Date.parse(report.nextReleaseAt) <= now ? "due" : "next";
-    parts.push(`${due} ${doeReleaseTime(report.nextReleaseAt)}${report.nextReleaseHoliday ? ` (${report.nextReleaseHoliday})` : ""}`);
+    const expected = doeExpected(report);
+    next = `${due} ${doeReleaseTime(report.nextReleaseAt)}${report.nextReleaseHoliday ? ` (${report.nextReleaseHoliday})` : ""}`
+      + (expected ? `, ${expected}` : "");
   }
-  return parts.join(" · ");
+  const line = [week, released, next].filter((part): part is string => !!part).join(" · ");
+  return line.length <= width || !released || !next ? line : [week, next].join(" · ");
+}
+
+const PUBLISHED_BASIS = "year-ago and 5-year average as EIA published";
+const COMPUTED_BASIS = "year-ago and 5-year average from EIA weekly history";
+
+/**
+ * What the year-ago and five-year columns are measured against, for the
+ * footer: the EIA's own published figures (gas storage) or the stored weekly
+ * history, and both where the rows mix them. Null from an older server,
+ * which does not say.
+ */
+export function doeComparisonBasis(rows: readonly DoeSeriesRow[]): string | null {
+  const shown = rows.filter((row) => row.yearAgo || row.fiveYear);
+  if (!shown.length || shown.some((row) => row.basis === undefined)) return null;
+  const published = shown.filter((row) => row.basis === "published");
+  if (published.length === shown.length) return PUBLISHED_BASIS;
+  if (!published.length) return COMPUTED_BASIS;
+  const tabs = (basis: string) => [...new Set(shown.filter((row) => row.basis === basis).map((row) => row.tab))]
+    .map((tab) => DOE_TABS.find((entry) => entry.value === tab)!.label.toLowerCase()).join(" and ");
+  return `${tabs("published")} ${PUBLISHED_BASIS}, ${tabs("computed")} from EIA weekly history`;
 }
 
 const DAY_MS = 86_400_000;

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

@@ -1,11 +1,13 @@
 import { useMemo } from "react";
 import type { DoeBoardPayload, DoeSeriesRow, DoeTab } from "../../../api-client/doe";
 import {
+  ChartRead,
   ChartTableHeader,
   CompositeChart,
   DataTableView,
   PaneStatusBody,
   QueryBar,
+  useChartReadRows,
   usePaneNoticeFooter,
   usePaneStatusFooter,
   usePaneTabs,
@@ -19,12 +21,12 @@ import { useThemeColors } from "../../../theme/theme-context";
 import type { ResolvedSeries } from "../../../time-series/types";
 import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
-import { ClippedText } from "../../../components/ui/display";
 import { DOE_NOT_AVAILABLE, getCachedDoeBoard, loadDoeBoard } from "./client";
 import {
   DOE_TABS,
   DOE_UNIT_LABEL,
   doeAxisFormatter,
+  doeComparisonBasis,
   doeHeaderLine,
   doeReport,
   doeRows,
@@ -51,8 +53,8 @@ const COLUMNS: DataTableColumn[] = [
   { id: "range", label: "5Y Range", width: 12, align: "left" },
 ];
 const PANELS = [{ id: "main" }];
-/** Legend, four plot rows, the week axis and the read under it. */
-const CHART_MIN_ROWS = 7;
+/** Legend, four plot rows and the week axis; the read under them takes its own rows. */
+const CHART_ROWS_ABOVE_READ = 6;
 
 function legendValue(row: DoeSeriesRow) {
   return (value: number) => `${value.toLocaleString("en-US", { minimumFractionDigits: row.unit === "kb" || row.unit === "pct" ? 1 : 0,
@@ -66,20 +68,19 @@ function legendValue(row: DoeSeriesRow) {
  * the years; the plain read sits under the axis.
  */
 function SeasonalChart({ row, series, width, height }: { row: DoeSeriesRow; series: ResolvedSeries[]; width: number; height: number }) {
-  const colors = useThemeColors();
   const weeks = row.seasonal?.weeks ?? 52;
   const latestWeek = row.seasonal?.current.at(-1)?.[0] ?? null;
   const viewport = useMemo(() => ({ start: doeWeekDate(1), end: doeWeekDate(weeks) }), [weeks]);
   const xAxis = useMemo(() => ({ ticks: doeWeekTicks(weeks), formatCursor: (ratio: number) => `W${Math.round(ratio * (weeks - 1)) + 1}` }), [weeks]);
-  // The plain read under the axis; the desktop cuts it where its line ends.
-  const read = row.read && width > 2 ? row.read : "";
+  // The plain read under the axis: wrapped in the terminal, cut by CSS where its line ends on the desktop.
+  const readRows = useChartReadRows([row.read], width);
   return (
     <Box width={width} height={height} flexDirection="column">
-      <CompositeChart series={series} panels={PANELS} width={width} height={Math.max(3, height - (read ? 1 : 0))}
+      <CompositeChart series={series} panels={PANELS} width={width} height={Math.max(3, height - readRows)}
         focused={false} navigable={false} showLegend showTimeAxis viewport={viewport} clipToViewport xAxis={xAxis}
         cursorDate={latestWeek ? doeWeekDate(latestWeek) : null} formatValue={legendValue(row)} formatAxisValue={doeAxisFormatter(row.unit)}
         remoteKind="doe-seasonal" />
-      {read ? <Box height={1} paddingX={1}><ClippedText fg={colors.textMuted} text={read} width={width - 2} /></Box> : null}
+      <ChartRead text={row.read} width={width} />
     </Box>
   );
 }
@@ -93,10 +94,13 @@ function DoeBoard({ payload, tab, initialSeries, width, height, focused }: {
   const [selectedId, setSelectedId] = usePluginPaneState<string | null>("selected", initialSeries);
   const selected = rows.find((row) => row.id === selectedId) ?? rows[0] ?? null;
   const series = useMemo(() => selected ? doeSeasonalSeries(selected, colors) : [], [selected, colors]);
-  const meta = doeHeaderLine(doeReport(payload, tab));
+  // The query bar's padding aside, the line keeps the next release whole on a narrow pane.
+  const meta = doeHeaderLine(doeReport(payload, tab), Date.now(), width - 2);
+  // Room for the longest read at this width, so the chart does not give way to the strip as the selection moves.
+  const readRows = useChartReadRows(rows.map((row) => row.read), width);
   const chart: ChartTableChart | null = selected && series.length ? {
     render: (size) => <SeasonalChart row={selected} series={series} width={size.width} height={size.height} />,
-    minRows: CHART_MIN_ROWS,
+    minRows: CHART_ROWS_ABOVE_READ + Math.max(1, readRows),
     strip: doeSeasonalStrip(selected, colors.positive),
   } : null;
   return (
@@ -134,8 +138,11 @@ export function DoePane({ width, height, focused }: PaneProps) {
   usePaneRefreshKey(() => void resource.reload(), { focused });
   usePaneNoticeFooter({ registrationId: "doe:notices", focused,
     notices: [...(data?.gaps ?? []), ...(resource.data?.refreshError ? [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]);
   usePaneStatusFooter({ registrationId: "doe", loading: resource.loading, error: notAvailable ? null : resource.error,
-    stale: !!data && resource.data?.stale });
+    stale: !!data && resource.data?.stale, info });
   return (
     <Box width={width} height={height} flexDirection="column">
       {strip}

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

@@ -4,8 +4,9 @@ import { getPublishedUsEquityCalendarDay } from "../../../market-data/published-
 import type { EarningsEvent } from "../../../types/data-provider";
 import type { EarningsDateStatus, EarningsEpsBasis, Quote } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
-import { dateStatusFromEstimateFlag, earningsDateStatus, earningsEpsBasis, isProvisionalActual } from "../shared/earnings-report";
-import { coherentEarningsValue } from "./estimate-basis";
+import { earningsDateStatus, earningsEpsBasis, isProvisionalActual } from "../shared/earnings-report";
+import { calendarStatus } from "../shared/earnings-calendar";
+import { coherentEarningsValue } from "../shared/earnings-estimate-basis";
 import { shortDate, surprise, weekday } from "./format";
 
 /** A held name is in a portfolio; a watched one only in watchlists. */
@@ -59,7 +60,7 @@ export function addDays(date: string, days: number): string {
 }
 
 /** NYSE sessions from the published calendar; weekdays for years it does not cover. */
-function isSession(date: string): boolean {
+export function isSession(date: string): boolean {
   const known = getPublishedUsEquityCalendarDay("NYSE", date);
   if (known) return known === "session";
   const day = new Date(`${date}T00:00:00Z`).getUTCDay();
@@ -149,7 +150,7 @@ 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. */
-export function fallbackReport(event: EarningsEvent, owned: ReadonlyMap<string, Ownership>): BoardReport {
+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;
   // Estimates in another currency would read as dollars beside the rest.
@@ -165,7 +166,8 @@ export function fallbackReport(event: EarningsEvent, owned: ReadonlyMap<string,
     date,
     timing,
     expectedTiming: false,
-    dateStatus: dateStatusFromEstimateFlag(event.isDateEstimate),
+    // A date gone by is reported, as every earnings surface reads it (shared/earnings-calendar).
+    dateStatus: calendarStatus(event, today),
     marketCap: null,
     epsEstimate,
     // The count belongs to the estimate beside it.
@@ -218,6 +220,11 @@ function compare(left: BoardReport, right: BoardReport, sort: BoardSort): number
   return sort.direction === "asc" ? a - b : b - a;
 }
 
+/** Held names, then watched, then the rest, when the board puts mine first; one rank for all otherwise. */
+export function ownershipRank(report: Pick<BoardReport, "owned">, mineFirst: boolean): number {
+  return !mineFirst ? 0 : report.owned === "held" ? 0 : report.owned === "watched" ? 1 : 2;
+}
+
 /**
  * Sections in date order, each ranked by the sort (largest company first by
  * default). With `mineFirst`, held names lead, then watched, then the rest.
@@ -228,7 +235,7 @@ export function boardRows(
   sort: BoardSort,
   mineFirst: boolean,
 ): BoardRow[] {
-  const rank = (report: BoardReport) => (!mineFirst ? 0 : report.owned === "held" ? 0 : report.owned === "watched" ? 1 : 2);
+  const rank = (report: BoardReport) => ownershipRank(report, mineFirst);
   const rows: BoardRow[] = [];
   for (const day of days) {
     const inDay = reports

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

@@ -1,4 +1,5 @@
 import type { DataTableCell, DataTableColumn } from "../../../components";
+import { withCompanyLogo } from "../../../components/company-logo";
 import { TABLE_COLUMN_GAP, tableColumnWidth } from "../../../components/ui/table-layout";
 import { colors } from "../../../theme/colors";
 import { TextAttributes } from "../../../ui";
@@ -81,6 +82,8 @@ export interface BoardCellContext {
   statusShown: boolean;
   /** The move on a report out today (reportMove); "loading" while its quote is. */
   move: (report: BoardReport) => number | "loading" | null;
+  /** The desktop and the web lead each name with the company's logo; the terminal draws none. */
+  logos?: boolean;
 }
 
 const NO_CONTEXT: BoardCellContext = { statusShown: true, move: () => null };
@@ -101,7 +104,7 @@ export function renderBoardCell(row: BoardRow, column: BoardColumn, context: Boa
     case "symbol":
       return { text: report.symbol, color: colors.text, attributes: TextAttributes.BOLD };
     case "name":
-      return { text: report.name, color: colors.text };
+      return withCompanyLogo({ text: report.name, color: colors.text }, report, context.logos === true);
     case "when": {
       const timing = report.timing ? TIMING_LABEL[report.timing] : "--";
       const text = row.showDay ? `${weekday(report.date)} ${timing}` : timing;