gloomberb 0.16.4 → 0.16.6

package/src/plugins/builtin/market-valuation/chart-series.ts

@@ -1,64 +1,27 @@
-import { chartSeriesProvider } from "../../../capabilities";
-import type { ChartSeriesCatalogItem, ChartSeriesCapability } from "../../../capabilities";
-import { colors } from "../../../theme/colors";
-import type { ResolvedSeries, TimeSeriesPoint } from "../../../time-series/types";
+import type { SeriesDefinition, SeriesLoadResult } from "../../../series/types";
 import { buildValuationSeries } from "./align";
 import { defaultValuationSeriesLoader, type ValuationSeriesLoader } from "./client";
 import { indicatorUnavailableReason, indicatorSeries, type IndicatorDef } from "./defs";
-import { findIndicator, INDICATORS } from "./indicators";
+import { INDICATORS } from "./indicators";
 import type { DatedSeries } from "./series";
 
-export const MARKET_VALUATION_CAPABILITY_ID = "market-valuation";
+/** `CAP:market-valuation:<indicator>`, the expression charts saved before the catalog had these. */
+const MARKET_VALUATION_NAMESPACE = "market-valuation";
 
-function catalogItem(indicator: IndicatorDef): ChartSeriesCatalogItem {
-  return {
-    seriesId: indicator.id,
-    label: indicator.label,
-    description: indicator.description,
-    detail: "Market valuation",
-    style: "line",
-  };
-}
-
-function matches(indicator: IndicatorDef, query: string): boolean {
-  const haystack = `${indicator.id} ${indicator.label} ${indicator.shortLabel} ${indicator.description}`;
-  return haystack.toLowerCase().includes(query);
+/** Shiller's series move once a month; the Z.1 and GDP ratios once a quarter. */
+function indicatorFrequency(indicator: IndicatorDef): "monthly" | "quarterly" {
+  return indicatorSeries(indicator).some((def) => def.source.kind === "shiller") ? "monthly" : "quarterly";
 }
 
 /**
- * A ratio is not a series anyone can fetch, so the pane's own computation is what
- * makes it chartable. Exposing it here lets G overlay, say, the Buffett indicator
- * against CPI without the pane being involved.
+ * A ratio is not a series anyone can fetch, so the pane's own computation is
+ * what makes it chartable: overlaying the Buffett indicator on CPI needs no
+ * valuation pane on screen.
  */
-export function createValuationChartSeriesCapability(
+export async function loadValuationIndicator(
+  indicator: IndicatorDef,
   loader: ValuationSeriesLoader = defaultValuationSeriesLoader,
-): ChartSeriesCapability {
-  return chartSeriesProvider({
-    id: MARKET_VALUATION_CAPABILITY_ID,
-    name: "Market Valuation",
-    provider: {
-      catalog: ({ limit }) => INDICATORS.slice(0, limit ?? INDICATORS.length).map(catalogItem),
-      search: ({ query, limit }) => {
-        const needle = query?.trim().toLowerCase();
-        const hits = needle
-          ? INDICATORS.filter((indicator) => matches(indicator, needle))
-          : [...INDICATORS];
-        return hits.slice(0, limit ?? hits.length).map(catalogItem);
-      },
-      resolve: async ({ seriesId }) => resolveValuationSeries(seriesId, loader),
-    },
-  });
-}
-
-export async function resolveValuationSeries(
-  seriesId: string,
-  loader: ValuationSeriesLoader = defaultValuationSeriesLoader,
-): Promise<ResolvedSeries> {
-  const indicator = findIndicator(seriesId);
-  if (indicator.id !== seriesId.trim().toLowerCase()) {
-    throw new Error(`Unknown valuation series ${seriesId}`);
-  }
-
+): Promise<SeriesLoadResult> {
   const unavailable = indicatorUnavailableReason(indicator);
   if (unavailable) throw new Error(unavailable);
   const legs = new Map<string, DatedSeries>();
@@ -74,26 +37,23 @@ export async function resolveValuationSeries(
   if (built.points.at(-1)?.ratio == null) {
     warnings.push(`${indicator.label}: latest observation unavailable (${built.points.at(-1)!.date})`);
   }
-  const points: TimeSeriesPoint[] = built.points.map((point) => {
-    const date = new Date(point.date);
-    return { date, observedAt: date, value: point.ratio };
-  });
-
   return {
-    id: `market-valuation:${indicator.id}`,
-    label: indicator.label,
-    color: colors.textBright,
-    // Source percentages need the same units as ratios scaled into percentages.
-    unit: indicator.axisUnit === "%" ? "%" : "x",
-    unitGroup: indicator.axisUnit === "%" ? "valuation-percent" : "valuation-ratio",
-    nativeFrequency: "daily",
-    dataShape: "scalar",
-    style: "line",
-    transform: "raw",
-    axis: "left",
-    panelId: "main",
-    interpolation: "none",
+    points: built.points.map((point) => ({ date: point.date, value: point.ratio })),
     ...(warnings.length ? { warning: warnings.join("; ") } : {}),
-    points,
   };
 }
+
+export function valuationSeriesDefinitions(
+  loader: ValuationSeriesLoader = defaultValuationSeriesLoader,
+): SeriesDefinition[] {
+  return INDICATORS.map((indicator) => ({
+    id: `${MARKET_VALUATION_NAMESPACE}:${indicator.id}`,
+    name: indicator.label,
+    unit: indicator.axisUnit === "%" ? "%" : "x",
+    frequency: indicatorFrequency(indicator),
+    group: "Valuation",
+    tags: [indicator.shortLabel, "market valuation"],
+    description: indicator.description,
+    load: () => loadValuationIndicator(indicator, loader),
+  }));
+}

package/src/plugins/builtin/market-valuation/index.tsx

@@ -1,6 +1,6 @@
 import type { PluginModule } from "../plugin-module";
 import { valuationCache } from "./cache";
-import { createValuationChartSeriesCapability } from "./chart-series";
+import { valuationSeriesDefinitions } from "./chart-series";
 import { INDICATORS, resolveIndicatorArg } from "./indicators";
 import { marketValuationHeadless } from "./headless";
 import { MarketValuationPane } from "./pane";
@@ -35,8 +35,8 @@ const KEYWORDS = [...new Set([
 ])];
 
 export const marketValuationModule: PluginModule = {
-  // Exposes each ratio as a chartable series, so G can overlay them on anything else.
-  capabilities: [createValuationChartSeriesCapability()],
+  // Each ratio is a catalog series, so G can overlay them on anything else.
+  series: valuationSeriesDefinitions(),
   panes: [{
     id: MARKET_VALUATION_PANE_ID,
     name: "Market Valuation",

package/src/plugins/builtin/market-valuation/indicators.ts

@@ -370,11 +370,6 @@ export const INDICATORS: readonly IndicatorDef[] = [
 
 export const DEFAULT_INDICATOR_ID = BUFFETT_INDICATOR.id;
 
-export function findIndicator(id: string | null | undefined): IndicatorDef {
-  const normalized = id?.trim().toLowerCase();
-  return INDICATORS.find((entry) => entry.id === normalized) ?? BUFFETT_INDICATOR;
-}
-
 /** Resolves shortcut arguments like `VAL cape` or `VAL buffett` onto an indicator. */
 export function resolveIndicatorArg(arg: string | null | undefined): IndicatorDef | null {
   const query = arg?.trim().toLowerCase();

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

@@ -1,6 +1,6 @@
 import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchChanges, fetchFunds, fetchMembers } from "./client";
-import { canonicalFund, changeReason, decimal, DEFAULT_SORT, memberRows, percent } from "./model";
+import { canonicalFund, changeReason, coverageText, decimal, DEFAULT_SORT, holdingsCaveats, holdingsSourceText, memberRows, percent } from "./model";
 const columns: HeadlessPaneColumn[] = [
   { key: "symbol", header: "Ticker" }, { key: "name", header: "Name" },
   { key: "weight", header: "Weight %", align: "right", format: (value) => value == null ? "--" : decimal(Number(value) * 100) },
@@ -11,7 +11,7 @@ const columns: HeadlessPaneColumn[] = [
 export const membersHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows", argument: { kind: "ticker", optional: true, placeholder: "fund", description: "Covered fund or index alias; omit for the fund list." },
   options: [{ key: "tab", type: "enum", values: [{ value: "members" }, { value: "movers" }, { value: "changes" }], defaultValue: "members", description: "Members, movers or changes." }],
-  discovery: { aliases: ["MEMB", "MRR", "IMOV"], limitations: ["ETF holdings, with file dates", "Partial delayed member return coverage", "Nasdaq-100 is not covered"] },
+  discovery: { aliases: ["MEMB", "MRR", "IMOV"], limitations: ["ETF holdings, with file dates.", "Partial delayed member return coverage.", "Nasdaq-100 is not covered."] },
   describe: (args) => args.rawArgument ? `MEMB ${args.rawArgument}` : "Index and ETF members",
   async load(args, context) {
     const input = args.symbols[0] ?? args.rawArgument ?? "";
@@ -30,6 +30,11 @@ export const membersHeadless: HeadlessPaneDefinition<"rows"> = {
     return { freshness: { status: data.stale ? "stale" : "delayed", delayMinutes: 15, ignoreStaleFlags: true }, rows, columns: movers ? [...columns.slice(0, 3), { key: "contribution", header: "Contrib. pp", align: "right", format: (value) => percent(value as number | null, "", 3) }] : columns,
       complete: !data.stale && data.aggregate.fresh1D === data.aggregate.total,
       unavailableSymbols: data.members.flatMap((row) => row.symbol && row.changePercent === null ? [row.symbol] : []),
-      metadata: { fund: data.fund, asOf: data.asOf, snapshotAsOf: data.snapshotAsOf, aggregate: data.aggregate, stale: data.stale } };
+      metadata: { fund: data.fund, asOf: data.asOf, snapshotAsOf: data.snapshotAsOf, aggregate: data.aggregate, stale: data.stale, notices: [
+        holdingsSourceText(input, data),
+        // The pane's coverage figure, and once what the table's dashes mean instead of leaving them bare.
+        [coverageText(data.aggregate), data.aggregate.fresh1D < data.aggregate.total ? "1D -- means no fresh delayed quote; those holdings are not counted" : ""].filter(Boolean).join(" | "),
+        ...holdingsCaveats(data, movers),
+      ] } };
   },
 };

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

@@ -1,4 +1,4 @@
-import type { FundChange, FundMember, MemberFundsPayload } from "../../../api-client/members";
+import type { FundChange, FundMember, FundMembersPayload, MemberFundsPayload } from "../../../api-client/members";
 import type { DataTableColumn } from "../../../components";
 import { buildSectionedRows, type SectionedRow } from "../../../components/data-table/sections";
 import { getTableWidth } from "../../../components/ui/table-layout";
@@ -7,14 +7,42 @@ export type MembersTab = "members" | "movers" | "changes";
 export const TABS = [{ value: "members", label: "Members" }, { value: "movers", label: "Movers" }, { value: "changes", label: "Changes" }];
 export const isTab = (value: unknown): value is MembersTab => TABS.some((tab) => tab.value === value);
 const COVERED = [{ ticker: "IVV", name: "S&P 500" }, { ticker: "IJH", name: "S&P 400" }, { ticker: "IJR", name: "S&P 600" }, { ticker: "IWM", name: "Russell 2000" }, { ticker: "IWB", name: "Russell 1000" }];
-export function canonicalFund(input: string) { const symbol = input.split(":")[0]!.trim().toUpperCase(); return ["SPX", "SPY", "^GSPC"].includes(symbol) ? "IVV" : symbol; }
+/** Symbols the app reads as a covered fund before asking the server, which knows its own aliases too. */
+const LOCAL_ALIASES: Record<string, string> = { SPX: "IVV", SPY: "IVV", "^GSPC": "IVV" };
+const requestedSymbol = (input: string) => input.split(":")[0]!.trim().toUpperCase();
+export function canonicalFund(input: string) { const symbol = requestedSymbol(input); return LOCAL_ALIASES[symbol] ?? symbol; }
 /** The covered fund the user asked for, by ticker or by an alias such as SPX, or undefined when it is not covered. */
 export function coveredFund(funds: MemberFundsPayload["funds"], input: string) {
   const symbol = canonicalFund(input);
   return funds.find((fund) => fund.ticker === symbol || fund.aliases.some((alias) => alias.toUpperCase() === symbol));
 }
+/** Every symbol that opens this fund: the server's aliases and the app's own. */
+function fundAliases(fund: MemberFundsPayload["funds"][number]) {
+  const local = Object.entries(LOCAL_ALIASES).flatMap(([alias, ticker]) => ticker === fund.ticker ? [alias] : []);
+  return [...new Set([...fund.aliases.map((alias) => alias.toUpperCase()), ...local])].filter((alias) => alias !== fund.ticker);
+}
 export function notCoveredMessage(input: string, funds: MemberFundsPayload["funds"]) {
-  return `${input.split(":")[0]!.trim().toUpperCase()} is not a covered fund. Covered: ${funds.map((fund) => fund.ticker).join(", ")}.`;
+  const covered = funds.map((fund) => { const aliases = fundAliases(fund); return aliases.length ? `${fund.ticker} (${aliases.join(", ")})` : fund.ticker; });
+  return `${requestedSymbol(input)} is not a covered fund. Covered: ${covered.join(", ")}.`;
+}
+/** "Partial 1D 334/504 · 91.5% wt": how many holdings have a fresh 1D return, and their share of the fund. */
+export function coverageText(aggregate: FundMembersPayload["aggregate"], short = false) {
+  const partial = aggregate.fresh1D < aggregate.total;
+  return `${partial && !short ? "Partial " : ""}1D ${aggregate.fresh1D}/${aggregate.total} · ${decimal(aggregate.coveredWeight * 100, 1)}% wt`;
+}
+/** "S&P 500, IVV holdings as of 2026-10-08 (for SPY)": the holdings file the members come from. */
+export function holdingsSourceText(input: string, data: Pick<FundMembersPayload, "fund" | "asOf">) {
+  const requested = requestedSymbol(input);
+  return `${data.fund.name}, ${data.fund.ticker} holdings as of ${data.asOf.slice(0, 10)}${requested && requested !== data.fund.ticker ? ` (for ${requested})` : ""}`;
+}
+/** Caveats about a fund's holdings and returns, shared by the pane's notices and the text report. */
+export function holdingsCaveats(data: FundMembersPayload, movers: boolean) {
+  return [
+    ...(data.quotesUnavailable ? ["Member returns and current prices are unavailable. Dated holdings remain available."] : []),
+    ...(movers && data.aggregate.fundReturn === null ? ["Fund 1D is unavailable; the difference cannot be calculated."] : []),
+    ...(movers && data.aggregate.withinTolerance === false ? [`The covered contribution sum differs from the fund by ${percent(data.aggregate.residual, " pp")}.`] : []),
+    ...(data.excludedDerivatives ? [`${data.excludedDerivatives} derivative positions are excluded from these share holdings.`] : []),
+  ];
 }
 export function membersTitle(input: string) {
   const requested = input.split(":")[0]!.trim().toUpperCase();

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

@@ -13,7 +13,7 @@ import { nextHeaderSort, type SortPreference } from "../../../utils/sort-values"
 import { isPlainArrowUp, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import { useMembersMenu, type MemberList } from "../shared/members-menu";
 import { cachedChanges, cachedFunds, cachedMembers, loadChanges, loadFunds, loadMembers } from "./client";
-import { canonicalFund, changeColumns, changeLabel, changeReason, coveredFund, decimal, DEFAULT_SORT, isTab, memberColumns, memberRows, membersTitle, notCoveredMessage, percent, TABS, type MembersTab } from "./model";
+import { canonicalFund, changeColumns, changeLabel, changeReason, coverageText, coveredFund, decimal, DEFAULT_SORT, holdingsCaveats, isTab, memberColumns, memberRows, membersTitle, notCoveredMessage, percent, TABS, type MembersTab } from "./model";
 
 type ViewProps = Pick<PaneProps, "width" | "height" | "focused"> & { fund: string; active: boolean };
 const rowKey = (row: SectionedRow<FundMember>) => row.key;
@@ -47,21 +47,19 @@ function Holdings({ fund, tab, width, height, focused, active }: ViewProps & { t
     const date = dates.length === 1 ? dates[0] : dates.length ? `${dates[0]} to ${dates.at(-1)}` : data.fundDailyAsOf?.slice(0, 10);
     const partial = data.aggregate.fresh1D < data.aggregate.total;
     return [
-      { id: "coverage", parts: [{ text: `${partial && width >= 60 ? "Partial " : ""}1D ${data.aggregate.fresh1D}/${data.aggregate.total} · ${decimal(data.aggregate.coveredWeight * 100, 1)}% wt`, tone: partial ? "warning" : "muted" }] },
-      { id: "quote-date", title: `${date ?? "Quote date unavailable"} · 15m delayed · holdings ${data.asOf}`,
+      { id: "coverage", parts: [{ text: coverageText(data.aggregate, width < 60), tone: partial ? "warning" : "muted" }] },
+      // A capture's status line says the quotes' date and delay too; it does not say returns are unavailable.
+      { id: "quote-date", title: `${date ?? "Quote date unavailable"} · 15m delayed · holdings ${data.asOf}`, quoteStatus: !data.quotesUnavailable,
         parts: [{ text: data.quotesUnavailable ? "returns unavailable" : width < 60 && dates.length === 1 ? `${date!.slice(5)} delayed` : `${date ? `${date} · ` : ""}15m delayed`, tone: "muted" }] },
-      ...(width >= 60 ? [{ id: "holdings-date", parts: [{ text: `holdings ${data.asOf}`, tone: "muted" as const }] }] : []),
+      ...(width >= 60 ? [{ id: "holdings-date", asOf: true, parts: [{ text: `holdings ${data.asOf}`, tone: "muted" as const }] }] : []),
     ];
   }, [data, width]);
   usePaneStatusFooter({ registrationId: "members:status", loading: !!data && resource.loading,
     stale: !!data && (data.stale || resource.data!.stale || !!resource.error), info });
   usePaneNoticeFooter({ registrationId: "members:notices", focused, notices: [
     ...(resource.error || resource.data?.refreshError ? [resource.error ?? resource.data!.refreshError!] : []),
-    ...(data?.quotesUnavailable ? ["Member returns and current prices are unavailable. Dated holdings remain available."] : []),
     ...(data && data.aggregate.fresh1D < data.aggregate.total ? [`Fresh 1D: ${data.aggregate.fresh1D}/${data.aggregate.total} holdings, ${decimal(data.aggregate.coveredWeight * 100, 1)}% of whole-fund weight. Missing returns are excluded.`] : []),
-    ...(movers && data && data.aggregate.fundReturn === null ? ["Fund 1D is unavailable; the difference cannot be calculated."] : []),
-    ...(movers && data?.aggregate.withinTolerance === false ? [`The covered contribution sum differs from the fund by ${percent(data.aggregate.residual, " pp")}.`] : []),
-    ...(data?.excludedDerivatives ? [`${data.excludedDerivatives} derivative positions are excluded from these share holdings.`] : []),
+    ...(data ? holdingsCaveats(data, movers) : []),
   ] });
   const renderCell = useCallback((item: SectionedRow<FundMember>, column: DataTableColumn): DataTableCell => {
     if (!isSectionedItemRow(item)) return { text: "" };

package/src/plugins/builtin/mna/distress/headless.ts

@@ -147,10 +147,10 @@ export const distressHeadless: HeadlessPaneDefinition<"rows"> = {
     aliases: ["DIST"],
     dataRequirements: ["Public SEC EDGAR filings and financial statement notes, TWSE and TPEx open data, BODACC and The Gazette notices"],
     limitations: [
-      "A company missing from a list may still be in difficulty; absence is not a finding",
-      "Going-concern disclosures come from monthly SEC data sets, weeks after filing",
-      "Listing status is not a statement about solvency, and some Taiwan dates are when the row was first seen",
-      "Insolvency notices are not linked to listed companies",
+      "A company missing from a list may still be in difficulty; absence is not a finding.",
+      "Going-concern disclosures come from monthly SEC data sets, weeks after filing.",
+      "Listing status is not a statement about solvency, and some Taiwan dates are when the row was first seen.",
+      "Insolvency notices are not linked to listed companies.",
     ],
   },
   options: OPTIONS,

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

@@ -2,6 +2,8 @@ import type { MnaDealsParams, MnaRegionFilter, MnaStatusFilter, MnaTargetFilter
 import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchMnaDeals } from "./client";
 import { formatDealValue, formatExpectedClose, stageLabel, termsLabel } from "./model";
+import { listingAbroadVenue } from "../../../utils/sec";
+import { shortCompanyName } from "../../../tickers/company-name";
 
 const text = (value: unknown) => (typeof value === "string" ? value : "");
 
@@ -29,9 +31,9 @@ export const mnaHeadless: HeadlessPaneDefinition<"rows"> = {
     aliases: ["MA"],
     dataRequirements: ["Gloom Cloud M&A deals read from news stories, press releases and SEC filings"],
     limitations: [
-      "Free accounts see deals 7 days after they were first reported",
-      "Spreads need live quotes and are drawn by the pane, not listed here",
-      "A private or non-US deal completes only when a story reports it",
+      "Free accounts see deals 7 days after they were first reported.",
+      "Spreads need live quotes and are drawn by the pane, not listed here.",
+      "A private or non-US deal completes only when a story reports it.",
     ],
   },
   options: [
@@ -44,12 +46,19 @@ export const mnaHeadless: HeadlessPaneDefinition<"rows"> = {
   describe: (args) => `M&A${args.symbols[0] ? ` | ${args.symbols[0]}` : ""} | ${text(args.options.status) || "pending"}`,
   async load(args, ctx) {
     const symbol = args.symbols[0];
+    // Deals carry US tickers, where SAN is not SAN:EPA's company: a listing abroad is looked up by its company's name.
+    const company = symbol && listingAbroadVenue(symbol)
+      ? await ctx.marketData.getQuote(symbol, "").then((quote) => quote.name?.trim() || null, () => null)
+      : null;
+    if (symbol && listingAbroadVenue(symbol) && !company) {
+      throw new Error(`Deals are filed by US ticker or company name, and ${symbol} has no company name to look them up by.`);
+    }
     const params: MnaDealsParams = {
       status: ((args.options.status as MnaStatusFilter | undefined) ?? (symbol ? "all" : "pending")),
       target: symbol ? undefined : (args.options.target as MnaTargetFilter | undefined),
       region: symbol ? undefined : (args.options.region as MnaRegionFilter | undefined),
-      symbol,
-      query: text(args.options.query) || undefined,
+      symbol: company ? undefined : symbol,
+      query: text(args.options.query) || (company ? shortCompanyName(company) : undefined),
       limit: Number(args.options.limit ?? 50),
     };
     const payload = await fetchMnaDeals(params, ctx.apiClient);
@@ -77,7 +86,10 @@ export const mnaHeadless: HeadlessPaneDefinition<"rows"> = {
         headline: deal.headline,
       })),
       errors: payload.lockedDeals > 0 ? [`${payload.lockedDeals} deals from the last ${payload.delayDays} days need Gloom Pro`] : [],
-      metadata: { asOf: payload.asOf, access: payload.access, delayDays: payload.delayDays, hasMore: payload.hasMore },
+      metadata: {
+        asOf: payload.asOf, access: payload.access, delayDays: payload.delayDays, hasMore: payload.hasMore,
+        ...(company ? { notices: [`Deals are filed by US ticker, so ${symbol}'s are the ones naming ${shortCompanyName(company)}.`] } : {}),
+      },
     };
   },
 };

package/src/plugins/builtin/money-markets/headless.ts

@@ -4,7 +4,7 @@ import { moneyMarketChange, moneyMarketNotices, moneyMarketRows, moneyMarketValu
 
 export const moneyMarketsHeadless: HeadlessPaneDefinition<"bundle"> = {
   discovery: { aliases: ["BTMM"], dataRequirements: ["Gloom Cloud money-markets endpoint"],
-    limitations: ["Published daily and weekly observations", "Treasury bill discount yields", "Net liquidity is a same-date proxy"] },
+    limitations: ["Published daily and weekly observations.", "Treasury bill discount yields.", "Net liquidity is a same-date proxy."] },
   shape: "bundle", argument: { kind: "none" },
   freshness: { source: "FRED", status: "not-a-feed", basis: "published daily and weekly data" },
   options: [{ key: "tab", type: "enum", description: "Money-market view.", values: [{ value: "rates" }, { value: "bills" }, { value: "liquidity" }], defaultValue: "rates" }],
@@ -18,9 +18,10 @@ export const moneyMarketsHeadless: HeadlessPaneDefinition<"bundle"> = {
       { key: "label", header: "Instrument" },
       { key: "value", header: "Level", align: "right", format: (value, row) => moneyMarketValue(value as number | null, row.unit as "percent" | "usd-billions") },
       { key: "change", header: "Change", align: "right", format: (value, row) => moneyMarketChange(value as number | null, row.changeUnit as "basis-points" | "usd-billions") },
-      { key: "previousAsOf", header: "Versus" },
-      { key: "percentileValue", header: "Pctl 1Y", align: "right", format: (value) => value == null ? "--" : Number(value).toFixed(0) },
-      { key: "asOf", header: "As of" }, { key: "status", header: "Status" },
+      // A narrow terminal moves the status, percentile and earlier date under each row first.
+      { key: "previousAsOf", header: "Versus", shrink: false, stackPriority: 1 },
+      { key: "percentileValue", header: "Pctl 1Y", align: "right", stackPriority: 2, format: (value) => value == null ? "--" : Number(value).toFixed(0) },
+      { key: "asOf", header: "As of", shrink: false }, { key: "status", header: "Status", stackPriority: 3 },
     ], rows: rows.map(({ history: _history, ...row }) => ({ ...row, percentileValue: row.percentile.value })) }],
       errors, unavailableSymbols: rows.filter((row) => row.status === "unavailable").flatMap((row) => row.sourceSeriesIds),
       metadata: { ...data, complete, selectedTab: args.options.tab } };

package/src/plugins/builtin/money-markets/index.tsx

@@ -2,8 +2,10 @@ import type { PluginModule } from "../plugin-module";
 import { moneyMarketsCache } from "./client";
 import { moneyMarketsHeadless } from "./headless";
 import { MoneyMarketsPane } from "./pane";
+import { MONEY_MARKET_SERIES } from "./series";
 
 export const moneyMarketsModule: PluginModule = {
+  series: MONEY_MARKET_SERIES,
   panes: [{ id: "money-markets", name: "Money Markets", icon: "$", component: MoneyMarketsPane,
     defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 88, height: 28 },
     tableExport: true, headless: moneyMarketsHeadless,

package/src/plugins/builtin/money-markets/series.ts

@@ -0,0 +1,41 @@
+import type { MoneyMarketObservation } from "../../../api-client/money-markets";
+import type { SeriesDefinition } from "../../../series/types";
+import { cachedSeriesWarning } from "../shared/series-warning";
+import { loadMoneyMarkets } from "./client";
+
+function observations(history: readonly MoneyMarketObservation[]) {
+  return history.map((point) => ({ date: point.date, value: point.value }));
+}
+
+/**
+ * The two money-market lines the pane computes: the rates and balances under
+ * them are FRED series in the catalog already.
+ */
+export const MONEY_MARKET_SERIES: readonly SeriesDefinition[] = [
+  {
+    id: "money-markets:net-liquidity",
+    name: "Net liquidity (Fed assets less TGA and reverse repo)",
+    unit: "billion USD",
+    frequency: "weekly",
+    group: "Rates",
+    tags: ["liquidity", "Fed balance sheet", "TGA", "RRP", "money markets"],
+    load: async () => {
+      const resource = await loadMoneyMarkets();
+      const warning = cachedSeriesWarning(resource);
+      return { points: observations(resource.payload.netLiquidity.history), ...(warning ? { warning } : {}) };
+    },
+  },
+  {
+    id: "money-markets:bill-slope",
+    name: "Treasury bill curve slope (1Y less 4W)",
+    unit: "bp",
+    frequency: "daily",
+    group: "Rates",
+    tags: ["bills", "curve", "money markets"],
+    load: async () => {
+      const resource = await loadMoneyMarkets();
+      const warning = cachedSeriesWarning(resource);
+      return { points: observations(resource.payload.billsCurve.slope.history), ...(warning ? { warning } : {}) };
+    },
+  },
+];

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

@@ -143,12 +143,10 @@ function TickerNewsView({ width, height, focused }: { width: number; height: num
           item={detailWithSummary}
           focused={listFocused}
           width={width}
-          showTitle={false}
         />
       ) : (
         <Box flexGrow={1} />
       )}
-      detailTitle={detailWithSummary?.title}
       columns={["time", "source", "title", "categories", "sentiment"]}
       rootBefore={(
         <QueryBar