gloomberb 0.18.2 → 0.18.4

package/src/plugins/builtin/crypto-etf-flows/headless.ts

@@ -0,0 +1,132 @@
+import type { CryptoEtfFlowsPayload } from "../../../api-client/crypto-etf-flows";
+import type { HeadlessPaneColumn } from "../../../types/headless";
+import type { HeadlessPaneDefinition } from "../../../types/plugin";
+import { REPORT_ROWS } from "../shared/headless-options";
+import { fetchCryptoEtfFlows } from "./client";
+import {
+  cryptoEtfFlowAsset,
+  cryptoEtfFlowAssetLabel,
+  cryptoEtfFlowSummary,
+  formatFlow,
+  formatFlowAmount,
+  pendingText,
+} from "./model";
+
+const flowCell = (value: unknown) => formatFlow(typeof value === "number" ? value : null);
+
+/** Date, the day's total and each fund, in US$ millions as published. */
+function flowColumns(payload: CryptoEtfFlowsPayload): HeadlessPaneColumn[] {
+  return [
+    { key: "date", header: "Date", shrink: false },
+    { key: "total", header: "Total", align: "right", format: flowCell },
+    // A fund the day still waits on reads "pending", as in the pane; none at all is a dash.
+    ...payload.funds.map((fund): HeadlessPaneColumn => ({
+      key: fund.ticker, header: fund.ticker, literalHeader: true, align: "right",
+      format: (value, row) => value == null && Array.isArray(row.pending) && row.pending.includes(fund.ticker) ? "pending" : flowCell(value),
+    })),
+    { key: "pending", header: "Pending", format: (value) => Array.isArray(value) && value.length ? value.join(", ") : "" },
+  ];
+}
+
+/** "Net flows of the US spot bitcoin ETFs in US$ millions. 2026-10-20: -$6.70M (IBIT pending); 5 days ..., since 2024-01-11 +$57.47B." */
+function summaryLine(payload: CryptoEtfFlowsPayload): string {
+  const summary = cryptoEtfFlowSummary(payload);
+  const pending = pendingText(summary.latest);
+  return [
+    `Net flows of the US spot ${cryptoEtfFlowAssetLabel(payload.asset).toLowerCase()} ETFs in US$ millions.`,
+    `${summary.latest?.date ?? payload.asOf}: ${formatFlowAmount(summary.latest?.total)}${pending ? ` (${pending})` : ""};`,
+    [
+      summary.week != null ? `5 days ${formatFlowAmount(summary.week)}` : null,
+      summary.month != null ? `20 days ${formatFlowAmount(summary.month)}` : null,
+      summary.firstDate ? `since ${summary.firstDate} ${formatFlowAmount(summary.sinceLaunch)}` : null,
+    ].filter(Boolean).join(", ") + ".",
+  ].join(" ");
+}
+
+export const cryptoEtfFlowsHeadless: HeadlessPaneDefinition<"rows"> = {
+  shape: "rows",
+  argument: { kind: "none" },
+  options: [
+    {
+      key: "asset",
+      description: "The spot bitcoin or ether ETFs.",
+      type: "enum",
+      values: [
+        { value: "btc", aliases: ["bitcoin", "xbt"] },
+        { value: "eth", aliases: ["ether", "ethereum"] },
+      ],
+      defaultValue: "btc",
+      example: "--asset eth",
+      settingKey: "asset",
+    },
+    {
+      key: "limit",
+      shot: REPORT_ROWS,
+      aliases: ["count", "rows", "days"],
+      description: "Most recent trading days listed.",
+      type: "integer",
+      defaultValue: 20,
+      minimum: 1,
+      maximum: 2000,
+    },
+  ],
+  columns: [
+    { key: "date", header: "Date" },
+    { key: "total", header: "Total", align: "right", format: flowCell },
+  ],
+  describe: (args) => `Crypto ETF Flows | ${cryptoEtfFlowAssetLabel(cryptoEtfFlowAsset(args.options.asset))}`,
+  discovery: {
+    aliases: ["ETFF"],
+    dataRequirements: ["Gloom Cloud spot crypto ETF flows"],
+    limitations: [
+      "US spot bitcoin and ether ETFs only, net creations and redemptions in US$ millions as Farside Investors publishes them.",
+      "The newest day fills in fund by fund; a fund that has not reported shows as pending.",
+    ],
+  },
+  freshness: { source: "Farside Investors", publisher: "Farside Investors", status: "not-a-feed", basis: "daily fund flows", cadence: "daily", tradingDayMarket: "US" },
+  async load(args, ctx) {
+    const asset = cryptoEtfFlowAsset(args.options.asset);
+    const payload = await fetchCryptoEtfFlows(asset, ctx.apiClient);
+    const limit = Math.max(1, Number(args.options.limit) || 20);
+    const rows = payload.days.slice(0, limit).map((day) => ({
+      date: day.date,
+      total: day.total,
+      ...Object.fromEntries(payload.funds.map((fund) => [fund.ticker, day.flows[fund.ticker] ?? null])),
+      pending: day.pending,
+    }));
+    const summary = cryptoEtfFlowSummary(payload);
+    return {
+      rows,
+      columns: flowColumns(payload),
+      notes: [summaryLine(payload), `Source: ${payload.source.publisher}, ${payload.source.url}`],
+      complete: !payload.stale,
+      ...(payload.stale ? { warnings: [`The flows were last read ${payload.fetchedAt.slice(0, 10)}; newer days may be missing.`] } : {}),
+      freshness: {
+        source: payload.source.publisher,
+        publisher: payload.source.publisher,
+        status: "not-a-feed",
+        basis: "daily fund flows",
+        cadence: "daily",
+        tradingDayMarket: "US",
+        asOf: payload.asOf,
+        oldest: null,
+      },
+      metadata: {
+        asset,
+        unit: payload.unit,
+        asOf: payload.asOf,
+        fetchedAt: payload.fetchedAt,
+        stale: payload.stale,
+        source: payload.source,
+        funds: payload.funds,
+        summary: {
+          latest: summary.latest ? { date: summary.latest.date, total: summary.latest.total, pending: summary.latest.pending } : null,
+          fiveDays: summary.week,
+          twentyDays: summary.month,
+          sinceLaunch: summary.sinceLaunch,
+          firstDate: summary.firstDate,
+        },
+      },
+    };
+  },
+};

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

@@ -0,0 +1,44 @@
+import type { PluginModule } from "../plugin-module";
+import { cryptoEtfFlowsCache } from "./client";
+import { cryptoEtfFlowsHeadless } from "./headless";
+import { CRYPTO_ETF_FLOWS_PANE_ID } from "./model";
+import { CryptoEtfFlowsPane } from "./pane";
+
+/** ETFF: the daily net flows of the US spot bitcoin and ether ETFs, per fund. */
+export const cryptoEtfFlowsModule: PluginModule = {
+  panes: [
+    {
+      id: CRYPTO_ETF_FLOWS_PANE_ID,
+      name: "Crypto ETF Flows",
+      icon: "F",
+      component: CryptoEtfFlowsPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 120, height: 32 },
+      tableExport: true,
+      headless: cryptoEtfFlowsHeadless,
+    },
+  ],
+  paneTemplates: [
+    {
+      id: "crypto-etf-flows-pane",
+      paneId: CRYPTO_ETF_FLOWS_PANE_ID,
+      label: "Crypto ETF Flows",
+      description: "Daily net flows of the US spot bitcoin and ether ETFs, per fund in US$ millions, with the running total since launch, as Farside Investors publishes them.",
+      keywords: [
+        "etf flows", "bitcoin flows", "btc flows", "ether flows", "eth flows", "ethereum flows", "crypto flows",
+        "bitcoin etf flows", "ether etf flows", "spot bitcoin etf", "spot ether etf", "spot etf flows",
+        "flows", "inflows", "outflows", "net flows", "creations", "redemptions",
+        "ibit", "fbtc", "gbtc", "etha", "farside",
+      ],
+      shortcut: { prefix: "ETFF" },
+      headless: cryptoEtfFlowsHeadless,
+    },
+  ],
+  setup(ctx) {
+    cryptoEtfFlowsCache.attach(ctx.persistence);
+  },
+  dispose() {
+    cryptoEtfFlowsCache.reset();
+  },
+};

package/src/plugins/builtin/crypto-etf-flows/model.ts

@@ -0,0 +1,121 @@
+import type { CryptoEtfFlowAsset, CryptoEtfFlowDay, CryptoEtfFlowsPayload } from "../../../api-client/crypto-etf-flows";
+import type { DataTableColumn } from "../../../components";
+import { calendarMonthsBefore } from "../../../utils/calendar-date";
+import { formatCompactAmount, formatNumber } from "../../../utils/format";
+
+export const CRYPTO_ETF_FLOWS_PANE_ID = "crypto-etf-flows";
+
+export const CRYPTO_ETF_FLOW_ASSETS: ReadonlyArray<{ value: CryptoEtfFlowAsset; label: string }> = [
+  { value: "BTC", label: "Bitcoin" },
+  { value: "ETH", label: "Ether" },
+];
+
+export type CryptoEtfFlowRange = "1M" | "3M" | "1Y" | "ALL";
+
+/** The range the chart and the table show; the figures always read the whole history. */
+export const CRYPTO_ETF_FLOW_RANGES: ReadonlyArray<{ value: CryptoEtfFlowRange; label: string; hint: string }> = [
+  { value: "1M", label: "1M", hint: "1" },
+  { value: "3M", label: "3M", hint: "2" },
+  { value: "1Y", label: "1Y", hint: "3" },
+  { value: "ALL", label: "All", hint: "4" },
+];
+
+export function cryptoEtfFlowRange(value: unknown): CryptoEtfFlowRange {
+  return CRYPTO_ETF_FLOW_RANGES.find((range) => range.value === value)?.value ?? "1Y";
+}
+
+const RANGE_MONTHS: Record<Exclude<CryptoEtfFlowRange, "ALL">, number> = { "1M": 1, "3M": 3, "1Y": 12 };
+
+/** The days within a range of the newest one listed, newest first. */
+export function daysInRange(days: readonly CryptoEtfFlowDay[], range: CryptoEtfFlowRange): CryptoEtfFlowDay[] {
+  const newest = days[0]?.date;
+  if (!newest || range === "ALL") return [...days];
+  const start = calendarMonthsBefore(new Date(`${newest}T00:00:00Z`), RANGE_MONTHS[range]);
+  const from = start.toISOString().slice(0, 10);
+  return days.filter((day) => day.date > from);
+}
+
+/** `btc`, `bitcoin`, `ETH`, `ether`, `ethereum`: the asset a setting or option names; bitcoin otherwise. */
+export function cryptoEtfFlowAsset(value: unknown): CryptoEtfFlowAsset {
+  const text = typeof value === "string" ? value.trim().toUpperCase() : "";
+  return text === "ETH" || text === "ETHER" || text === "ETHEREUM" ? "ETH" : "BTC";
+}
+
+export const cryptoEtfFlowAssetLabel = (asset: CryptoEtfFlowAsset) => asset === "ETH" ? "Ether" : "Bitcoin";
+
+/** A day's flow in US$ millions as the table shows it: `+665.2`, `-83.6`, `0.0`, `—` for none. */
+export function formatFlow(value: number | null | undefined): string {
+  if (value == null || !Number.isFinite(value)) return "—";
+  const text = formatNumber(Math.abs(value), 1);
+  return value > 0 && text !== "0.0" ? `+${text}` : value < 0 && text !== "0.0" ? `-${text}` : text;
+}
+
+/** A sum of flows in US$ millions as a figure reads it: `+$526.7M`, `-$1.13B`, `$0`. */
+export function formatFlowAmount(millions: number | null | undefined): string {
+  if (millions == null || !Number.isFinite(millions)) return "—";
+  const text = formatCompactAmount(millions * 1_000_000, { signed: true });
+  return text.replace(/^([+-]?)/, "$1$");
+}
+
+/** Inflows green, outflows red; a day with no flow recedes, so the funds that moved stand out in a wide table. */
+export const flowColor = (value: number | null | undefined, colors: { positive: string; negative: string; textMuted: string }) =>
+  value == null || value === 0 ? colors.textMuted : value > 0 ? colors.positive : colors.negative;
+
+export interface CryptoEtfFlowSummary {
+  latest: CryptoEtfFlowDay | null;
+  /** Sums of the published daily totals over the newest days listed. */
+  week: number | null;
+  month: number | null;
+  /** Every listed day's total: the net flow since the first fund launched. */
+  sinceLaunch: number | null;
+  firstDate: string | null;
+}
+
+const sumTotals = (days: readonly CryptoEtfFlowDay[]) => days.some((day) => day.total != null)
+  ? days.reduce((sum, day) => sum + (day.total ?? 0), 0)
+  : null;
+
+/** The figures over the table: the newest day, the last 5 and 20 trading days, and since launch. */
+export function cryptoEtfFlowSummary(payload: CryptoEtfFlowsPayload): CryptoEtfFlowSummary {
+  const days = payload.days;
+  return {
+    latest: days[0] ?? null,
+    week: days.length >= 5 ? sumTotals(days.slice(0, 5)) : null,
+    month: days.length >= 20 ? sumTotals(days.slice(0, 20)) : null,
+    sinceLaunch: sumTotals(days),
+    firstDate: days.at(-1)?.date ?? null,
+  };
+}
+
+/** The running sum of the daily totals, oldest first: what the chart draws. */
+export function cumulativeFlows(payload: CryptoEtfFlowsPayload): Array<{ date: string; value: number }> {
+  let running = 0;
+  return payload.days.toReversed().map((day) => {
+    running += day.total ?? 0;
+    return { date: day.date, value: running };
+  });
+}
+
+/** "IBIT pending" or "IBIT, ETHB pending": the funds a day still waits on. */
+export function pendingText(day: CryptoEtfFlowDay | null | undefined): string | null {
+  return day?.pending.length ? `${day.pending.join(", ")} pending` : null;
+}
+
+export type CryptoEtfFlowColumn = Omit<DataTableColumn, "id"> & { id: string };
+
+/** Date and the day's total, then each fund in the publisher's order. */
+export function cryptoEtfFlowColumns(payload: CryptoEtfFlowsPayload | null | undefined): CryptoEtfFlowColumn[] {
+  return [
+    { id: "date", label: "Date", width: 12, align: "left" },
+    { id: "total", label: "Total", width: 9, align: "right", title: "The day's net flow across the funds, US$ millions" },
+    ...(payload?.funds ?? []).map((fund): CryptoEtfFlowColumn => ({
+      id: `fund:${fund.ticker}`,
+      label: fund.ticker,
+      width: Math.max(8, fund.ticker.length + 2),
+      align: "right",
+      ...(fund.name ? { title: fund.issuer ? `${fund.name} (${fund.issuer})` : fund.name } : {}),
+    })),
+  ];
+}
+
+export const fundTickerOfColumn = (columnId: string) => columnId.startsWith("fund:") ? columnId.slice(5) : null;

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/debt-maturities/pane.tsx

@@ -410,8 +410,9 @@ export function DebtMaturitiesPane({ width, height, focused }: PaneProps) {
   const detailOpen =
     tab === "maturities" ? !!openBucketRow : tab === "history" && !!openHistoryRow;
   const tabsFocused = focused && !detailOpen;
+  const signInWall = !data && isCloudSessionRequired(resource.error);
   const { strip: tabStrip, rows: tabRows } = usePaneTabs(
-    latest
+    symbol && !signInWall
       ? { tabs: TABS, activeValue: tab, onSelect: setTab, focused: tabsFocused, dense: true }
       : null,
   );
@@ -522,7 +523,7 @@ export function DebtMaturitiesPane({ width, height, focused }: PaneProps) {
         message="Select a ticker to view debt maturities."
       />
     );
-  if (!data && isCloudSessionRequired(resource.error))
+  if (signInWall)
     return (
       <SignInWall
         placement="debt-maturities-signin"
@@ -532,6 +533,7 @@ export function DebtMaturitiesPane({ width, height, focused }: PaneProps) {
     );
   return (
     <Box width={width} height={height} flexDirection="column">
+      {tabStrip}
       <PaneStatusBody
         loading={resource.loading && !data}
         error={!data ? resource.error : null}
@@ -542,7 +544,6 @@ export function DebtMaturitiesPane({ width, height, focused }: PaneProps) {
       >
         {latest ? (
           <>
-            {tabStrip}
             {tab === "filing" ? (
               <FilingDetail latest={latest} quarter={quarter} width={width} height={bodyHeight} />
             ) : tab === "maturities" ? (

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");