gloomberb 0.16.3 → 0.16.5

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) },
@@ -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,7 +47,7 @@ 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: "coverage", parts: [{ text: coverageText(data.aggregate, width < 60), tone: partial ? "warning" : "muted" }] },
       { id: "quote-date", title: `${date ?? "Quote date unavailable"} · 15m delayed · holdings ${data.asOf}`,
         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 }] }] : []),
@@ -57,11 +57,8 @@ function Holdings({ fund, tab, width, height, focused, active }: ViewProps & { t
     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/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 : "");
 
@@ -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/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/headless.ts

@@ -11,6 +11,7 @@ import {
   mapCloudNewsArticle,
 } from "../../../sources/gloomberb-cloud/news";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
+import { cloudNewsFreshness, cloudRealtimeAccess } from "../shared/report-freshness";
 
 const NEWS_COLUMNS = [
   { key: "publishedAt", header: "Published" },
@@ -27,11 +28,14 @@ export interface NewsHeadlessDependencies {
     context: HeadlessPaneContext,
   ): Promise<CloudNewsListResponse>;
   now(): Date;
+  /** Whether the session has real-time news; without it the stories are held back. */
+  realtimeAccess?(): Promise<boolean | null>;
 }
 
 const defaultDependencies: NewsHeadlessDependencies = {
   loadNews: (query, context) => context.apiClient.getCloudNews(cloudNewsParams(query)),
   now: () => new Date(),
+  realtimeAccess: cloudRealtimeAccess,
 };
 
 function newsRow(article: NewsArticle) {
@@ -67,6 +71,7 @@ function projectNewsHeadless(
   response: CloudNewsListResponse,
   args: HeadlessPaneLoadArgs,
   now: Date,
+  realtime: boolean | null,
 ): HeadlessSnapshotResult {
   const sentiment = selectedSentiment(args);
   const minImportance = Number(args.options.minImportance ?? 0);
@@ -81,8 +86,8 @@ function projectNewsHeadless(
   return {
     asOf: now.toISOString(),
     items,
-    // Published stories, dated by the newest; the list is a history, so its last story is not stale data.
-    freshness: { status: "not-a-feed", basis: "published stories", observedKey: "publishedAt", oldest: null },
+    // Dated by the newest story, held back for an account without real-time news.
+    freshness: cloudNewsFreshness(realtime),
     metadata: {
       nextCursor: response.nextCursor,
       sentiment,
@@ -179,6 +184,7 @@ export function createNewsFeedHeadless(
         await dependencies.loadNews(queryFor(args, "latest"), context),
         args,
         dependencies.now(),
+        await dependencies.realtimeAccess?.() ?? null,
       );
     },
   };
@@ -205,6 +211,7 @@ export function createTickerNewsHeadless(
         ),
         args,
         dependencies.now(),
+        await dependencies.realtimeAccess?.() ?? null,
       );
     },
   };

package/src/plugins/builtin/news/wire/news/footer.ts

@@ -10,6 +10,7 @@ import { CLOUD_NEWS_DELAY_HOURS } from "../../../../../api-client/plan-access";
 import { usePaneStatusLinkFooter } from "../../../../../components/layout/pane/status-footer";
 import { usePluginAppActions } from "../../../../runtime";
 import { useOptionalPaneInstanceId } from "../../../../../state/app/context";
+import { useRemoteUiNode } from "../../../../../remote/semantic-tree";
 
 interface NewsFooterArticle {
   title?: string | null;
@@ -60,6 +61,15 @@ export function useNewsArticleFooter({
     shortcutScope: `${registrationId}:news-upgrade`,
   });
 
+  // A report or capture of the pane says how far its stories are held back, as the footer does.
+  useRemoteUiNode({
+    role: "report-freshness",
+    label: "News freshness",
+    getMetadata: () => (access.hasProAccess
+      ? { status: "live" }
+      : { status: "delayed", delayMinutes: CLOUD_NEWS_DELAY_HOURS * 60 }),
+  });
+
   const accessInfo = useMemo<PaneFooterSegment[]>(() => {
     if (access.isPayingPro) {
       return [{ id: "news-access", parts: [{ text: t("real-time news"), tone: "positive" }] }];

package/src/plugins/builtin/notes/cli.ts

@@ -3,7 +3,7 @@ import { withCliServices, withConfigData } from "../../../cli/scoped-context";
 import { CLI_COMMAND_GROUPS } from "../../../cli/help";
 import { dryRunNote } from "../../../cli/helpers";
 import { requireArg, takeOption } from "../../../cli/commands/command-utils";
-import { EXCHANGE_OPTION, requireListingArg } from "../../../cli/listing-arg";
+import { EXCHANGE_OPTION, listingReadNotes, requireListingArg } from "../../../cli/listing-arg";
 import { createPluginPersistence } from "../../plugin-persistence";
 import type { CliCommandDef } from "../../../types/plugin";
 import { cliStyles } from "../../../utils/cli-output";
@@ -25,9 +25,14 @@ export const notesCliCommand: CliCommandDef = {
     const args = [...rawArgs];
     const exchange = takeOption(args, "--exchange");
     // A note belongs to one listing: SAN:EPA, or SAN with --exchange EPA.
-    const noteSymbol = async (usage: string) => (
-      await requireListingArg(requireArg(args[1], usage, ctx), exchange, ctx)
-    ).key;
+    // What a typed listing was read as (7203:TSE as 7203:JPX) is said beside the note.
+    let read: { warnings?: string[] } = {};
+    const noteSymbol = async (usage: string) => {
+      const listing = await requireListingArg(requireArg(args[1], usage, ctx), exchange, ctx);
+      const notes = listingReadNotes(listing);
+      if (notes.length > 0) read = { warnings: notes };
+      return listing.key;
+    };
     await withConfigData(ctx, async (config) => {
       const notes = new NotesFiles(config.dataDir);
       const action = args[0] ?? "list";
@@ -71,7 +76,7 @@ export const notesCliCommand: CliCommandDef = {
       }
       if (action === "show") {
         const symbol = await noteSymbol("Usage: gloomberb notes show <symbol>");
-        ctx.printResult({ data: { symbol, text: await notes.load(symbol) } }, {
+        ctx.printResult({ data: { symbol, text: await notes.load(symbol) }, ...read }, {
           text: (data) => data.text?.trim() ? data.text.trimEnd() : cliStyles.muted(`No note for ${symbol}.`),
         });
         return;
@@ -80,7 +85,7 @@ export const notesCliCommand: CliCommandDef = {
         const symbol = await noteSymbol("Usage: gloomberb notes set <symbol> <text...>");
         const text = args.slice(2).join(" ");
         if (!ctx.cliOptions.dryRun) await notes.save(symbol, text);
-        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, symbol, bytes: text.length } }, {
+        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, symbol, bytes: text.length }, ...read }, {
           text: (data) => `Saved the note for ${symbol}.${dryRunNote(data.dryRun)}`,
         });
         return;
@@ -90,7 +95,7 @@ export const notesCliCommand: CliCommandDef = {
         // Only picks the message; an unreadable note is still deleted.
         const existed = await notes.load(symbol).then((text) => !!text?.trim(), () => true);
         if (!ctx.cliOptions.dryRun) await notes.delete(symbol);
-        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, symbol } }, {
+        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, symbol }, ...read }, {
           text: (data) => existed
             ? `Deleted the note for ${symbol}.${dryRunNote(data.dryRun)}`
             : cliStyles.muted(`No note for ${symbol}.`),

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

@@ -280,7 +280,7 @@ export class OpenFdaClient {
   async listPage(dataset: OpenFdaDataset, query: string, offset: number, signal?: AbortSignal): Promise<OpenFdaPage> {
     const response = await openFdaFetch.fetch(buildOpenFdaUrl(dataset, query, offset), {
       headers: authorizationHeaders(),
-      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(DEFAULT_TIMEOUT_MS)]) : undefined,
+      signal,
     });
     // openFDA answers a search with no matches with a 404.
     if (response.status === 404) {

package/src/plugins/builtin/options/carry.ts

@@ -0,0 +1,95 @@
+import type { OptionContract } from "../../../types/financials";
+import { daysToExpiryFrom, optionMid, type OptionSide } from "../shared/volatility";
+import { optionSpread } from "./market-reference";
+
+/**
+ * What holding a contract costs in time value, read the same way by the OMON
+ * columns and the LEAPS screen (`gloomberb options --leaps`):
+ *
+ *   intrinsic          = max(0, spot - strike) for a call, max(0, strike - spot) for a put
+ *   extrinsic          = midpoint - intrinsic, the midpoint of a two-sided quote
+ *   extrinsic per year = extrinsic / spot / years to expiry
+ *
+ * Years are calendar days to the 16:00 New York close on the expiry date, over
+ * 365, counted from the instant the Greeks are valued at. Under a day from the
+ * close there is no yearly figure: a few cents over a few hours annualises to
+ * noise. Extrinsic is negative when the midpoint sits below intrinsic value, as
+ * a wide deep in-the-money quote can. Without a two-sided quote or a current
+ * spot there is no figure, never a zero.
+ */
+export interface OptionCarry {
+  /** Time value per share, in the contract's currency. */
+  extrinsic: number;
+  /** Time value as a fraction of spot per year: 0.042 reads 4.2%. Null under a day from expiry. */
+  extrinsicPerYear: number | null;
+}
+
+/** Less time than this to expiry and a yearly rate means nothing. */
+const MIN_CARRY_DAYS = 1;
+
+function positive(value: number | null | undefined): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function optionIntrinsicValue(side: OptionSide, strike: number, spot: number): number {
+  return Math.max(0, side === "call" ? spot - strike : strike - spot);
+}
+
+export function optionCarry(
+  contract: Pick<OptionContract, "bid" | "ask" | "strike" | "expiration">,
+  side: OptionSide,
+  spot: number | null | undefined,
+  valuationTime: number,
+): OptionCarry | null {
+  const mid = optionMid(contract);
+  if (mid == null || !positive(spot) || !positive(contract.strike)) return null;
+  const extrinsic = mid - optionIntrinsicValue(side, contract.strike, spot);
+  const days = daysToExpiryFrom(contract.expiration, valuationTime);
+  return { extrinsic, extrinsicPerYear: days >= MIN_CARRY_DAYS ? extrinsic / spot / (days / 365) : null };
+}
+
+/** Bid/ask width as a percent of the midpoint; null without a two-sided quote. */
+export function optionSpreadPercent(contract: Pick<OptionContract, "bid" | "ask">): number | null {
+  const spread = optionSpread(contract);
+  return spread.kind === "two-sided" ? spread.percentOfMid : null;
+}
+
+/**
+ * What a contract costs against the stock it covers: the midpoint of a
+ * two-sided quote over spot, so a protective put's premium reads as a share of
+ * the position it protects (a 5.495 put on a 778.57 underlying is 0.706%).
+ * Null without a two-sided quote or a current spot, never a zero.
+ */
+export function optionCostOfSpot(
+  contract: Pick<OptionContract, "bid" | "ask">,
+  spot: number | null | undefined,
+): number | null {
+  const mid = optionMid(contract);
+  return mid == null || !positive(spot) ? null : mid / spot;
+}
+
+/** Below this a cost of spot reads as a bound: the digits would outrun the column. */
+const MIN_COST_OF_SPOT_PERCENT = 0.001;
+
+/**
+ * A fraction as a percent to three significant digits: 0.00706 reads 0.706%,
+ * 0.0123 reads 1.23%, 0.123 reads 12.3%. Under a thousandth of a percent it
+ * reads <0.001%, so a far out-of-the-money quote stays inside the column.
+ */
+export function formatCostOfSpot(value: number | null | undefined): string {
+  if (value == null || !Number.isFinite(value) || value < 0) return "\u2014";
+  const percent = value * 100;
+  if (percent === 0) return "0%";
+  if (percent < MIN_COST_OF_SPOT_PERCENT) return `<${MIN_COST_OF_SPOT_PERCENT}%`;
+  // Rounded first, so 9.996 reads 10.0% rather than 10.00%.
+  const rounded = Number(percent.toPrecision(3));
+  const decimals = Math.max(0, 2 - Math.floor(Math.log10(rounded)));
+  return `${rounded.toFixed(decimals)}%`;
+}
+
+/** A fraction as a percent: one decimal under 100% (0.0421 reads 4.2%), whole percents above. */
+export function formatCarryPercent(value: number | null | undefined): string {
+  if (value == null || !Number.isFinite(value)) return "—";
+  const percent = value * 100;
+  return `${percent.toFixed(Math.abs(percent) < 100 ? 1 : 0)}%`;
+}