gloomberb 0.18.4 → 0.19.0

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

@@ -1,20 +1,23 @@
 import { apiClient } from "../../../api-client";
 import { ApiRequestError } from "../../../api-client/errors";
-import type { FundMembersPayload, FundChangesPayload, MemberFundsPayload } from "../../../api-client/members";
+import type { FundMembersPayload, FundChangesPayload, MemberFundsPayload, FundBreadthPayload } from "../../../api-client/members";
 import { createPluginCache } from "../../../data/plugin-cache";
+import { companyNameCase } from "../../../tickers/company-name";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import { coveredFund, notCoveredMessage } from "./model";
 const policy = { staleMs: 60_000, expireMs: 2 * 60 * 60_000 };
 export const fundListCache = createPluginCache<MemberFundsPayload>({ kind: "member-funds", source: "gloom-cloud", schemaVersion: 1, policy });
 export const fundMembersCache = createPluginCache<FundMembersPayload>({ kind: "fund-members", source: "gloom-cloud", schemaVersion: 1, policy });
 export const fundChangesCache = createPluginCache<FundChangesPayload>({ kind: "fund-changes", source: "gloom-cloud", schemaVersion: 1, policy });
+export const fundBreadthCache = createPluginCache<FundBreadthPayload>({ kind: "fund-breadth", source: "gloom-cloud", schemaVersion: 1, policy });
 type Client = Pick<typeof apiClient, "getMemberFunds" | "getFundMembers" | "getFundChanges">;
 const number = (value: unknown) => value === null || typeof value === "number" && Number.isFinite(value);
 function validateMembers(data: FundMembersPayload) {
   if (!data?.fund?.ticker || !Number.isFinite(Date.parse(data.asOf)) || !Array.isArray(data.members)
     || !data.members.every((row) => typeof row.id === "string" && typeof row.name === "string" && [row.weight, row.price, row.changePercent, row.return1WPercent, row.return1MPercent, row.returnYtdPercent, row.contribution].every(number))
     || !data.aggregate || !number(data.aggregate.sum)) throw new Error("Unreadable fund holdings response");
-  return data;
+  // A holdings file writes every name in capitals; the pane, the report and a watchlist made from it read them as other panes do.
+  return { ...data, members: data.members.map((row) => ({ ...row, name: companyNameCase(row.name) })) };
 }
 function validateChanges(data: FundChangesPayload) {
   if (!data?.fund?.ticker || !Array.isArray(data.changes) || !data.changes.every((row) => typeof row.id === "string" && typeof row.reason === "string" && Array.isArray(row.estimates))) throw new Error("Unreadable fund changes response");
@@ -33,13 +36,13 @@ async function fetchPayload<T>(fetcher: () => Promise<T>, validate: (data: T) =>
  * same. The covered list tells them apart: a fund missing from a readable list is not covered; a list
  * that cannot be read, or that holds the fund, leaves the server-side message.
  */
-async function fetchFundPayload<T>(fund: string, fetcher: () => Promise<T>, validate: (data: T) => T, client: Client) {
+async function fetchFundPayload<T>(fund: string, fetcher: () => Promise<T>, validate: (data: T) => T, client: Client, unavailable = UNAVAILABLE) {
   try { return validate(await fetcher()); } catch (error) {
     if (error instanceof ApiRequestError && error.status === 404) {
       const funds = await fetchFunds(client).then((payload) => payload.funds, () => []);
       if (funds.length && !coveredFund(funds, fund)) throw new Error(notCoveredMessage(fund, funds));
     }
-    throw unavailableOnServer(error, UNAVAILABLE);
+    throw unavailableOnServer(error, unavailable);
   }
 }
 export const fetchFunds = (client: Client = apiClient) => fetchPayload(() => client.getMemberFunds(), validateFunds);
@@ -51,3 +54,15 @@ export const cachedMembers = (fund: string) => cachedCloudResource(fundMembersCa
 export const loadMembers = (fund: string, force = false) => loadCloudResource(fundMembersCache, fund, () => fetchMembers(fund), { force, validate: validateMembers });
 export const cachedChanges = (fund: string) => cachedCloudResource(fundChangesCache, fund, validateChanges);
 export const loadChanges = (fund: string, force = false) => loadCloudResource(fundChangesCache, fund, () => fetchChanges(fund), { force, validate: validateChanges });
+
+function validateBreadth(data: FundBreadthPayload) {
+  const row = (value: FundBreadthPayload["history"][number]) => value && /^\d{4}-\d{2}-\d{2}$/.test(value.date)
+    && [value.memberCount, value.observed, value.advances, value.declines, value.unchanged, value.advanceDeclineEligible, value.newHighs, value.newLows, value.highLowEligible].every(n => Number.isInteger(n) && n >= 0)
+    && [value.ma20, value.ma50, value.ma200].every(m => m && Number.isInteger(m.eligible) && m.eligible >= 0 && Number.isInteger(m.above) && m.above >= 0 && m.above <= m.eligible && number(m.percent))
+    && number(value.adLine);
+  if (!data?.fund?.ticker || !Array.isArray(data.history) || !data.history.every(row) || (data.latest !== null && !row(data.latest))) throw new Error("Unreadable fund breadth response");
+  return data;
+}
+export const fetchBreadth = (fund: string, client: Client & Pick<typeof apiClient, "getFundBreadth"> = apiClient) => fetchFundPayload(fund, () => client.getFundBreadth(fund), validateBreadth, client, "Fund breadth is not available on this server yet.");
+export const cachedBreadth = (fund: string) => cachedCloudResource(fundBreadthCache, fund, validateBreadth);
+export const loadBreadth = (fund: string, force = false) => loadCloudResource(fundBreadthCache, fund, () => fetchBreadth(fund), { force, validate: validateBreadth });

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, coverageText, decimal, DEFAULT_SORT, holdingsCaveats, holdingsSourceText, memberRows, percent } from "./model";
+import { fetchBreadth, fetchChanges, fetchFunds, fetchMembers } from "./client";
+import { canonicalFund, changeReason, coverageText, decimal, DEFAULT_SORT, holdingsCaveats, holdingsSourceText, memberRows, membersFeed, 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) },
@@ -9,14 +9,22 @@ const columns: HeadlessPaneColumn[] = [
   ...["changePercent", "return1WPercent", "return1MPercent", "returnYtdPercent"].map((key, i) => ({ key, header: ["1D", "1W", "1M", "YTD"][i]!, align: "right" as const, format: (value: unknown) => percent(value as number | null) })),
 ];
 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.", "Member prices are real-time with Pro and fifteen minutes delayed otherwise; partial 1D coverage.", "Nasdaq-100 is not covered."] },
+  shape: "rows", argument: { kind: "free-text", 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" }, { value: "breadth" }], defaultValue: "members", description: "Members, movers, changes or daily breadth." }],
+  discovery: { aliases: ["MEMB", "MRR", "IMOV"], limitations: ["ETF holdings, with file dates.", "Member prices are real-time with Pro and fifteen minutes delayed otherwise; partial 1D coverage.", "Nasdaq-100 is not covered.", "Breadth history uses current members (survivorship bias)."] },
   describe: (args) => args.rawArgument ? `MEMB ${args.rawArgument}` : "Index and ETF members",
   async load(args, context) {
     const input = args.symbols[0] ?? args.rawArgument ?? "";
     if (!input) return { freshness: { status: "not-a-feed", basis: "fund holdings files" }, rows: (await fetchFunds(context.apiClient)).funds.map((fund) => ({ ...fund })), columns: [{ key: "ticker", header: "Fund" }, { key: "name", header: "Index" }, { key: "asOf", header: "Holdings as of" }] };
     const fund = canonicalFund(input);
+    if (args.options.tab === "breadth") {
+      const data = await fetchBreadth(fund, context.apiClient);
+      return { freshness: { status: data.stale ? "stale" : data.basis === "intraday" ? data.access === "realtime" ? "live" : "delayed" : "not-a-feed", basis: data.basis === "intraday" ? "regular session" : "daily closes", delayMinutes: 15 },
+        rows: [...data.history, ...(data.basis === "intraday" && data.latest ? [data.latest] : [])].reverse().map(row => ({ ...row, above20: row.ma20.percent, above50: row.ma50.percent, above200: row.ma200.percent })),
+        columns: [{ key: "date", header: "Date" }, ...["advances", "declines", "unchanged", "above20", "above50", "above200", "newHighs", "newLows", "adLine", "advanceDeclineEligible", "memberCount"].map((key, index) => ({ key, header: ["Adv", "Dec", "Unch", ">20D %", ">50D %", ">200D %", "52W high", "52W low", "A/D line", "A/D covered", "Members"][index]!, align: "right" as const }))],
+        complete: !data.stale && !!data.latest && data.latest.advanceDeclineEligible === data.latest.memberCount,
+        metadata: { ...data, history: undefined, notices: ["Breadth history uses current members (survivorship bias).", "History uses daily closes; percentages exclude members without the full window. 52-week records strictly break the prior 252 sessions' high/low."] } };
+    }
     if (args.options.tab === "changes") {
       const data = await fetchChanges(fund, context.apiClient);
       return { freshness: { status: "not-a-feed", basis: "index changes" }, rows: data.changes.map((row) => ({ ...row, reason: changeReason(row) })), columns: [{ key: "effectiveDate", header: "Effective" }, { key: "added", header: "Added" }, { key: "removed", header: "Removed" }, { key: "daysToGo", header: "In days", align: "right" }, { key: "reason", header: "Reason" }],
@@ -28,10 +36,15 @@ export const membersHeadless: HeadlessPaneDefinition<"rows"> = {
     // Member prices are the pane's quotes: real-time for a Pro account, 15 minutes delayed otherwise. As in the
     // pane, the fund's snapshot says whether it is stale; the members' own flags are not what the pane reads.
     const live = data.access === "realtime";
-    return { freshness: { status: data.stale ? "stale" : live ? "live" : "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,
+    // Outside the regular session a Pro account's members are the session's close, not a live feed: the report
+    // is as of that close and says no feed, as the pane's footer names the close instead of "live".
+    const feed = membersFeed(data.access, Date.now());
+    const closed = feed.kind === "close";
+    const status = data.stale ? { status: "stale" as const, delayMinutes: 15 } : closed ? {} : { status: live ? "live" as const : "delayed" as const, delayMinutes: 15 };
+    return { freshness: { ...status, 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, notices: [
+      metadata: { fund: data.fund, asOf: data.asOf, ...(closed ? { sessionExchange: "NYSE", observedAt: new Date(feed.closedAt).toISOString() } : {}), 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 ${live ? "" : "delayed "}quote; those holdings are not counted` : ""].filter(Boolean).join(" | "),

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

@@ -1,18 +1,18 @@
 import type { GloomPlugin } from "../../../types/plugin";
-import { fundChangesCache, fundListCache, fundMembersCache } from "./client";
+import { fundBreadthCache, fundChangesCache, fundListCache, fundMembersCache } from "./client";
 import { membersHeadless } from "./headless";
 import { MembersPane } from "./pane";
-import { membersTitle } from "./model";
+import { membersTitle, TABS } from "./model";
 export const membersPlugin: GloomPlugin = {
-  id: "members", name: "Index and ETF members", version: "1.0.0", description: "ETF holdings, member returns, contributions and index changes", toggleable: true,
-  setup(ctx) { fundListCache.attach(ctx.persistence); fundMembersCache.attach(ctx.persistence); fundChangesCache.attach(ctx.persistence); },
-  dispose() { fundListCache.reset(); fundMembersCache.reset(); fundChangesCache.reset(); },
+  id: "members", name: "Index and ETF members", version: "1.0.0", description: "ETF holdings, member returns, contributions, breadth and index changes", toggleable: true,
+  setup(ctx) { fundBreadthCache.attach(ctx.persistence); fundListCache.attach(ctx.persistence); fundMembersCache.attach(ctx.persistence); fundChangesCache.attach(ctx.persistence); },
+  dispose() { fundBreadthCache.reset(); fundListCache.reset(); fundMembersCache.reset(); fundChangesCache.reset(); },
   panes: [{ id: "members", name: "Index and ETF members", icon: "M", component: MembersPane, tickerFollower: true,
     defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 132, height: 32 }, tableExport: true,
-    settings: { fields: [{ key: "tab", label: "View", type: "select", options: [{ value: "members", label: "Members" }, { value: "movers", label: "Movers" }, { value: "changes", label: "Changes" }] }] } }],
-  paneTemplates: [{ id: "members-pane", paneId: "members", label: "Index and ETF members", description: "ETF holdings, member returns, daily contributions and index changes.",
-    keywords: ["members", "index", "ETF", "holdings", "weights", "rebalance", "MRR", "IMOV"],
-    shortcut: { prefix: "MEMB", argKind: "ticker", argPlaceholder: "fund", argOptional: true, openWithoutArg: true }, headless: membersHeadless,
+    settings: { fields: [{ key: "tab", label: "View", type: "select", options: TABS }] } }],
+  paneTemplates: [{ id: "members-pane", paneId: "members", label: "Index and ETF members", description: "ETF holdings, member returns, daily contributions, breadth and index changes.",
+    keywords: ["members", "index", "ETF", "holdings", "weights", "rebalance", "breadth", "advancers", "decliners", "MRR", "IMOV"],
+    shortcut: { prefix: "MEMB", argKind: "text", argPlaceholder: "fund", argOptional: true, openWithoutArg: true }, headless: membersHeadless,
     createInstance: (_context, options) => { const symbol = (options?.arg ?? options?.symbol)?.trim().toUpperCase();
       return { placement: "floating", title: membersTitle(symbol ?? ""),
         ...(symbol ? { binding: { kind: "fixed", symbol } } : {}), settings: { tab: options?.values?.tab ?? "members" } }; },

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

@@ -2,13 +2,15 @@ import type { FundChange, FundMember, FundMembersPayload, MemberFundsPayload } f
 import type { DataTableColumn } from "../../../components";
 import { buildSectionedRows, type SectionedRow } from "../../../components/data-table/sections";
 import { getTableWidth } from "../../../components/ui/table-layout";
+import { isRegularSessionTime, latestRegularSessionClose } from "../../../market-data/market/freshness";
 import { compareSortValues, type SortPreference } from "../../../utils/sort-values";
-export type MembersTab = "members" | "movers" | "changes";
-export const TABS = [{ value: "members", label: "Members" }, { value: "movers", label: "Movers" }, { value: "changes", label: "Changes" }];
+import { closeLabel } from "../themes/model";
+export type MembersTab = "members" | "movers" | "changes" | "breadth";
+export const TABS = [{ value: "members", label: "Members" }, { value: "movers", label: "Movers" }, { value: "changes", label: "Changes" }, { value: "breadth", label: "Breadth" }];
 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" }];
 /** 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 LOCAL_ALIASES: Record<string, string> = { SPX: "IVV", "^SPX": "IVV", SPY: "IVV", "^GSPC": "IVV", "^MID": "IJH", SP400: "IJH", "^SP400": "IJH", "^SML": "IJR", SP600: "IJR", "^SP600": "IJR", RUT: "IWM", "^RUT": "IWM", RUI: "IWB", "^RUI": "IWB" };
 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. */
@@ -30,6 +32,17 @@ export function coverageText(aggregate: FundMembersPayload["aggregate"], short =
   const partial = aggregate.fresh1D < aggregate.total;
   return `${partial && !short ? "Partial " : ""}1D ${aggregate.fresh1D}/${aggregate.total} · ${decimal(aggregate.coveredWeight * 100, 1)}% wt`;
 }
+/**
+ * What a fund's member quotes are, as read at `readAt`. A Pro account's are live while the regular US session
+ * trades; outside it the server prices the members from the last completed session, so they are that session's
+ * close (`Fri 23 Oct close`), as THEM names it, never live. Everyone else's are 15 minutes delayed, in or out of
+ * a session. Hours that cannot be told read as live.
+ */
+export function membersFeed(access: FundMembersPayload["access"], readAt: number): { kind: "live" | "delayed" } | { kind: "close"; date: string; closedAt: number; label: string } {
+  if (access !== "realtime") return { kind: "delayed" };
+  const close = isRegularSessionTime("NYSE", readAt) === false ? latestRegularSessionClose("NYSE", readAt) : null;
+  return close ? { kind: "close", date: close.date, closedAt: close.close, label: closeLabel(close.date) } : { kind: "live" };
+}
 /** "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);
@@ -52,7 +65,13 @@ export function membersTitle(input: string) {
     : requested ? `MEMB ${requested}` : "Index and ETF members";
 }
 export const DEFAULT_SORT: SortPreference<string> = { columnId: "weight", direction: "desc" };
-export const percent = (value: number | null, suffix = "%", digits = 2) => value == null || !Number.isFinite(value) ? "--" : `${value > 0 ? "+" : ""}${value.toFixed(digits)}${suffix}`;
+/** A signed figure; one that rounds to zero is unsigned (0.00, never +0.00 or -0.00). */
+export function percent(value: number | null, suffix = "%", digits = 2) {
+  if (value == null || !Number.isFinite(value)) return "--";
+  const fixed = value.toFixed(digits);
+  if (!/[1-9]/.test(fixed)) return `${fixed.replace("-", "")}${suffix}`;
+  return `${value > 0 ? "+" : ""}${fixed}${suffix}`;
+}
 export const decimal = (value: number | null, digits = 2) => value == null || !Number.isFinite(value) ? "--" : value.toLocaleString("en-US", { minimumFractionDigits: digits, maximumFractionDigits: digits });
 export function sortMembers(rows: readonly FundMember[], sort: SortPreference<string>) {
   return [...rows].sort((a, b) => compareSortValues(a[sort.columnId as keyof FundMember] as number | string | null,

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

@@ -1,3 +1,4 @@
+import { Breadth } from "./breadth-pane";
 import { useCallback, useMemo, useRef, useState } from "react";
 import type { FundChange, FundMember } from "../../../api-client/members";
 import { delayedFooterSegment, DataTableStackView, DataTableView, DetailScrollBody, EmptyState, KeyValueRow, PaneFooterScope, PaneStatusBody, Prose, QueryBar, StatGrid,
@@ -5,7 +6,7 @@ import { delayedFooterSegment, DataTableStackView, DataTableView, DetailScrollBo
   type DataTableCell, type DataTableColumn, type PaneFooterSegment, type SectionedRow } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { useAsyncResource, useAutoRefresh, usePaneInstance, usePaneTickerIdentity, usePaneTitle, usePluginPaneState, usePluginTickerActions } from "../../../public/react";
-import { priceColor } from "../../../theme/colors";
+import { shownPriceColor } from "../../../theme/colors";
 import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, type ScrollBoxRenderable } from "../../../ui";
@@ -13,7 +14,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, coverageText, coveredFund, decimal, DEFAULT_SORT, holdingsCaveats, 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, membersFeed, 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,25 +48,29 @@ function Holdings({ fund, tab, width, height, focused, active }: ViewProps & { t
   usePaneRefreshKey(() => void resource.reload(), { focused, enabled: active && !search.active });
   const info = useMemo<PaneFooterSegment[]>(() => {
     if (!data) return [];
-    const feed = data.access === "realtime" ? "live" : "15m delayed";
+    // Outside the regular session a Pro account's members are the session's close, so the footer names it, not "live".
+    const feed = membersFeed(data.access, resource.updatedAt ?? Date.now());
+    const feedText = feed.kind === "close" ? feed.label : feed.kind === "live" ? "live" : "15m delayed";
     const dates = [...new Set(data.members.flatMap((row) => row.changePercent !== null && row.dailyAsOf ? [row.dailyAsOf.slice(0, 10)] : []))].sort();
     const date = dates.length === 1 ? dates[0] : dates.length ? `${dates[0]} to ${dates.at(-1)}` : data.fundDailyAsOf?.slice(0, 10);
+    // The close names its own date, so a quote date that is the same day is not said twice.
+    const dateSaid = feed.kind === "close" && dates.length === 1 && dates[0] === feed.date;
     const partial = data.aggregate.fresh1D < data.aggregate.total;
     return [
       { 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.
       ...(data.quotesUnavailable
-        ? [{ id: "quote-date", title: `${date ?? "Quote date unavailable"} · ${feed} · holdings ${data.asOf}`, parts: [{ text: "returns unavailable", tone: "muted" as const }] }]
+        ? [{ id: "quote-date", title: `${date ?? "Quote date unavailable"} · ${feedText} · holdings ${data.asOf}`, parts: [{ text: "returns unavailable", tone: "muted" as const }] }]
         : [
-          data.access === "realtime"
-            ? { id: "quote-live", quoteStatus: true, parts: [{ text: "live", tone: "positive" as const }] }
+          feed.kind === "live" ? { id: "quote-live", quoteStatus: true, parts: [{ text: "live", tone: "positive" as const }] }
+            : feed.kind === "close" ? { id: "quote-close", title: `${feed.label} · holdings ${data.asOf}`, quoteStatus: true, parts: [{ text: feed.label, tone: "muted" as const }] }
             : delayedFooterSegment({ id: "quote-delay", detail: "15m delayed", delay: "15m", quoteStatus: true }),
-          ...(date ? [{ id: "quote-date", title: `${date} · ${feed} · holdings ${data.asOf}`, quoteStatus: true,
+          ...(date && !dateSaid ? [{ id: "quote-date", title: `${date} · ${feedText} · holdings ${data.asOf}`, quoteStatus: true,
             parts: [{ text: width < 60 && dates.length === 1 ? date.slice(5) : date, tone: "muted" as const }] }] : []),
         ]),
       ...(width >= 60 ? [{ id: "holdings-date", asOf: true, parts: [{ text: `holdings ${data.asOf}`, tone: "muted" as const }] }] : []),
     ];
-  }, [data, width]);
+  }, [data, resource.updatedAt, 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: [
@@ -82,14 +87,15 @@ function Holdings({ fund, tab, width, height, focused, active }: ViewProps & { t
     if (column.id === "shares") return { text: decimal(row.shares, 0), value: row.shares };
     if (column.id === "price") return { text: decimal(row.price), value: row.price };
     const value = row[column.id as "changePercent"];
-    return { text: percent(value, column.id === "contribution" ? "" : "%", column.id === "contribution" ? 3 : 2), value, color: value === null ? colors.textMuted : priceColor(value, colors) };
+    const digits = column.id === "contribution" ? 3 : 2;
+    return { text: percent(value, column.id === "contribution" ? "" : "%", digits), value, color: value === null ? colors.textMuted : shownPriceColor(value, digits, colors) };
   }, [colors]);
   return <PaneStatusBody subject="fund holdings" loading={!data && resource.loading} error={!data ? resource.error : null}>
     {data && <DataTableView<SectionedRow<FundMember>> items={rows} columns={columns} rootWidth={width} rootHeight={height} focused={focused && !search.active}
       rootBefore={<Box flexDirection="column"><QueryBar width={width} search={{ value: query, onChange: setQuery, placeholder: "ticker, name or sector", focused, ...search.searchProps }} />
         {movers && <StatGrid width={width} items={[
-          { label: "Covered contrib.", value: percent(data.aggregate.sum, " pp"), color: priceColor(data.aggregate.sum ?? 0, colors) },
-          { label: `${fund} 1D`, value: percent(data.aggregate.fundReturn), color: priceColor(data.aggregate.fundReturn ?? 0, colors) },
+          { label: "Covered contrib.", value: percent(data.aggregate.sum, " pp"), color: shownPriceColor(data.aggregate.sum ?? 0, 2, colors) },
+          { label: `${fund} 1D`, value: percent(data.aggregate.fundReturn), color: shownPriceColor(data.aggregate.fundReturn ?? 0, 2, colors) },
           { label: "Difference", value: percent(data.aggregate.residual, " pp"), tone: data.aggregate.withinTolerance === false ? "warning" : "muted" },
         ]} />}</Box>}
       selection={{ kind: "id", selectedId: selected, getId: rowKey, onChange: (id) => setSelected(String(id)) }} getItemKey={rowKey}
@@ -150,14 +156,18 @@ function FundView({ fund, ...props }: Pick<PaneProps, "width" | "height" | "focu
   const initial = isTab(instance?.settings?.tab) ? instance.settings.tab : "members";
   const [storedTab, setTab] = usePluginPaneState<MembersTab>("tab", initial);
   const tab = isTab(storedTab) ? storedTab : "members";
-  const [visited, setVisited] = useState({ holdings: tab !== "changes", changes: tab === "changes" });
-  const selectTab = (value: string) => { if (isTab(value)) { setTab(value); setVisited((previous) => ({ holdings: previous.holdings || value !== "changes", changes: previous.changes || value === "changes" })); } };
+  const holdings = tab === "members" || tab === "movers";
+  const [visited, setVisited] = useState({ holdings, changes: tab === "changes", breadth: tab === "breadth" });
+  const selectTab = (value: string) => { if (isTab(value)) { setTab(value); setVisited((previous) => ({ holdings: previous.holdings || value === "members" || value === "movers", changes: previous.changes || value === "changes", breadth: previous.breadth || value === "breadth" })); } };
   const { strip, rows } = usePaneTabs({ tabs: TABS, activeValue: tab, onSelect: selectTab, focused: props.focused, compact: true, variant: "bare" });
   const height = Math.max(1, props.height - rows);
   return <Box width={props.width} height={props.height} flexDirection="column">
     {strip}
-    {visited.holdings && <Box visible={tab !== "changes"} flexGrow={1} flexBasis={0} overflow="hidden"><PaneFooterScope active={tab !== "changes"}>
-      <Holdings fund={fund} {...props} height={height} tab={tab} active={tab !== "changes"} focused={props.focused && tab !== "changes"} />
+    {visited.holdings && <Box visible={holdings} flexGrow={1} flexBasis={0} overflow="hidden"><PaneFooterScope active={holdings}>
+      <Holdings fund={fund} {...props} height={height} tab={tab} active={holdings} focused={props.focused && holdings} />
+    </PaneFooterScope></Box>}
+    {visited.breadth && <Box visible={tab === "breadth"} flexGrow={1} flexBasis={0} overflow="hidden"><PaneFooterScope active={tab === "breadth"}>
+      <Breadth fund={fund} {...props} height={height} active={tab === "breadth"} focused={props.focused && tab === "breadth"} />
     </PaneFooterScope></Box>}
     {visited.changes && <Box visible={tab === "changes"} flexGrow={1} flexBasis={0} overflow="hidden"><PaneFooterScope active={tab === "changes"}>
       <Changes fund={fund} {...props} height={height} active={tab === "changes"} focused={props.focused && tab === "changes"} />

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

@@ -112,6 +112,7 @@ function TickerNewsView({ width, height, focused }: { width: number; height: num
       ? [{ id: "summary", parts: [{ text: "summary loading", tone: "muted" as const }] }]
       : undefined,
     onPopOut: readableArticle ? popOutReadable : undefined,
+    feedAccess: newsState.access,
   });
 
   if (!ticker) {

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

@@ -29,10 +29,13 @@ const CATEGORY_LABELS: Record<string, string> = {
   us: "US",
 };
 
+function categoryKey(value: string | null | undefined): string {
+  return value?.trim().toLowerCase().replace(/[\s-]+/g, "_") ?? "";
+}
+
 export function formatNewsCategory(value: string | null | undefined): string {
-  const raw = value?.trim();
-  if (!raw) return "";
-  const key = raw.toLowerCase().replace(/[\s-]+/g, "_");
+  const key = categoryKey(value);
+  if (!key) return "";
   const mapped = CATEGORY_LABELS[key];
   if (mapped) return mapped;
   const words = key.split("_").filter(Boolean);
@@ -46,6 +49,19 @@ export function formatNewsCategory(value: string | null | undefined): string {
     .join(" ");
 }
 
+/**
+ * Labels for the news tables' category column, which is ten cells wide, for the
+ * ids whose label above would be cut in it. Anywhere with room (a story's
+ * detail) keeps the full label.
+ */
+const COLUMN_CATEGORY_LABELS: Record<string, string> = {
+  product_approval: "Approval",
+};
+
+export function formatNewsCategoryForColumn(value: string | null | undefined): string {
+  return COLUMN_CATEGORY_LABELS[categoryKey(value)] ?? formatNewsCategory(value);
+}
+
 const KNOWN_TICKERS = new Set([
   "AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "TSLA", "JPM", "JNJ", "UNH",
   "PG", "XOM", "CVX", "HD", "BAC", "V", "MA", "PFE", "KO", "PEP", "ABBV", "MRK",

package/src/plugins/builtin/news/wire/industry-pane.tsx

@@ -125,6 +125,7 @@ function IndustryNewsBody({ focused, width, height, entry, code, codeFilter }: P
     defaultSort: DEFAULT_SORT,
     refreshing: loaded.loading && loaded.articles.length > 0,
     error: loaded.error,
+    feedAccess: loaded.query ? loaded.newsState.access : null,
   });
   const { setSelectedArticleId } = stack;
 

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

@@ -1,5 +1,7 @@
 import { useMemo } from "react";
 import type { PaneFooterSegment } from "../../../../../components";
+import { delayedFooterSegment } from "../../../../../components/layout/pane/footer/model";
+import type { NewsAccess } from "../../../../../news/types";
 import { t, tf } from "../../../../../i18n";
 import { useAppLanguage } from "../../../../../i18n/react";
 import { useCloudAccessFooter } from "../../../shared/cloud-upgrade";
@@ -22,6 +24,18 @@ interface UseNewsArticleFooterOptions {
   loading?: boolean;
   error?: string | null;
   onPopOut?: () => void;
+  /** Which news the list on screen is, from the service's answer; null or absent when it did not say. */
+  feedAccess?: NewsAccess | null;
+}
+
+/**
+ * Whether the stories are the live wire: what the service's answer said when
+ * it said; otherwise held back for an account without real-time news, and
+ * not said at all for one with it. The plan never claims the live wire.
+ */
+function newsFeedRealtime(feedAccess: NewsAccess | null | undefined, hasProAccess: boolean): boolean | null {
+  if (feedAccess) return feedAccess === "realtime";
+  return hasProAccess ? null : false;
 }
 
 export function useNewsArticleFooter({
@@ -32,32 +46,44 @@ export function useNewsArticleFooter({
   loading = false,
   error,
   onPopOut,
+  feedAccess = null,
 }: UseNewsArticleFooterOptions) {
   const language = useAppLanguage();
+  const delayLabel = tf("{count}h", { count: CLOUD_NEWS_DELAY_HOURS });
   const { access, hint: upgradeHint, segment } = useCloudAccessFooter({
-    delayLabel: tf("{count}h", { count: CLOUD_NEWS_DELAY_HOURS }),
+    delayLabel,
     focused,
+    // A feed the service answered live has nothing to upgrade.
+    degraded: feedAccess !== "realtime",
     segmentId: "news-access",
     placement: "news-footer",
     shortcutScope: `${registrationId}:news-upgrade`,
   });
+  const realtime = newsFeedRealtime(feedAccess, access.hasProAccess);
 
   // A report or capture of the pane says how far its stories are held back, as the footer does, and dates the
   // list by its newest story, named so it is not read as the time now.
   useRemoteUiNode({
     role: "report-freshness",
     label: "News freshness",
-    getMetadata: () => (access.hasProAccess
+    getMetadata: () => (realtime === true
       ? { status: "live", asOfLabel: NEWEST_STORY }
-      : { status: "delayed", delayMinutes: CLOUD_NEWS_DELAY_HOURS * 60, asOfLabel: NEWEST_STORY }),
+      : realtime === false
+        ? { status: "delayed", delayMinutes: CLOUD_NEWS_DELAY_HOURS * 60, asOfLabel: NEWEST_STORY }
+        : { status: "not-a-feed", basis: "published stories", asOfLabel: NEWEST_STORY }),
   });
 
   const accessInfo = useMemo<PaneFooterSegment[]>(() => {
-    if (access.isPayingPro) {
+    // A trial keeps its days-left segment, which manages the plan.
+    if (realtime === true && !access.isTrialActive) {
       return [{ id: "news-access", parts: [{ text: t("real-time news"), tone: "positive" }] }];
     }
+    // Held back although the account has Pro (a read that went out before its session): say so, without a pitch.
+    if (feedAccess === "delayed" && access.hasProAccess) {
+      return [delayedFooterSegment({ id: "news-access", detail: tf("{delay} delayed", { delay: delayLabel }), delay: delayLabel })];
+    }
     return segment ? [segment] : [];
-  }, [access.isPayingPro, language, segment]);
+  }, [access.hasProAccess, access.isTrialActive, delayLabel, feedAccess, language, realtime, segment]);
   const footerInfo = useMemo(() => [...accessInfo, ...(info ?? [])], [accessInfo, info]);
 
   // The story's header names its source, so the footer keeps to the link.

package/src/plugins/builtin/news/wire/news/preset-pane.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useMemo } from "react";
 import { Box } from "../../../../../ui";
-import type { NewsArticle, NewsQuery } from "../../../../../news/types";
+import type { NewsAccess, NewsArticle, NewsQuery } from "../../../../../news/types";
 import { useLoadNewsStory, useNewsArticles, useNewsTableLoadMore } from "../../../../../news/hooks";
 import type { PaneProps } from "../../../../../types/plugin";
 import { useDebouncedPluginPaneState, usePluginConfigState, usePluginPaneState } from "../../../../runtime";
@@ -31,6 +31,8 @@ interface NewsArticleStackOptions {
   /** Rows stay on screen while a refresh runs, so the footer says it is loading. */
   refreshing: boolean;
   error: string | null;
+  /** Which news the rows are, from the service's answer, for the footer's real-time or delayed label. */
+  feedAccess?: NewsAccess | null;
 }
 
 /**
@@ -46,6 +48,7 @@ export function useNewsArticleStack({
   defaultSort,
   refreshing,
   error,
+  feedAccess,
 }: NewsArticleStackOptions) {
   const [selectedArticleId, setSelectedArticleId] = useDebouncedPluginPaneState<string | null>(
     `${paneKey}:selectedArticleId`,
@@ -95,6 +98,7 @@ export function useNewsArticleStack({
     loading: detailLoading || refreshing,
     error: [error, detailError].filter(Boolean).join(" ") || null,
     onPopOut: readableArticle ? popOutReadable : undefined,
+    feedAccess,
   });
 
   return {
@@ -172,6 +176,7 @@ export function NewsPresetPane({
     defaultSort,
     refreshing: loading && persisted.length > 0,
     error,
+    feedAccess: newsState.access,
   });
   const emptyCopy = newsListEmptyCopy({
     query: searchQuery,

package/src/plugins/builtin/news/wire/news/table.tsx

@@ -17,7 +17,7 @@ import { useLoadNewsStory } from "../../../../../news/hooks";
 import { formatFeedTime } from "../../../../../utils/datetime-format";
 import { logFailure } from "../../../../../utils/log-failure";
 import { nextHeaderSort } from "../../../../../utils/sort-values";
-import { formatNewsCategory } from "../categories";
+import { formatNewsCategoryForColumn } from "../categories";
 import { useOpenTickerChoice } from "../../../shared/ticker-choice";
 import { usePinnedMoment } from "../../../../../components/use-pinned-moment";
 
@@ -359,7 +359,7 @@ export function NewsArticleStackView({
       }
       case "categories":
         return {
-          text: formatNewsCategory(item.categories[0]) || "-",
+          text: formatNewsCategoryForColumn(item.categories[0]) || "-",
           color: tone(colors.textDim),
         };
       case "sentiment": {

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

@@ -68,6 +68,17 @@ export function parseOpenFdaDate(value: unknown): Date | null {
 
 const normalizeWords = (value: string): string => value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
 
+/** Each term once, in the order first coded, whatever its case: `Nausea` and `NAUSEA` are one. */
+function uniqueTerms(terms: readonly string[]): string[] {
+  const seen = new Set<string>();
+  return terms.filter((term) => {
+    const key = normalizeWords(term);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
 /** The search's words appear together in one of the fields, as openFDA matches a phrase. */
 function fieldsMatch(fields: Array<string | undefined>, query: string): boolean {
   const words = normalizeWords(query);
@@ -230,9 +241,10 @@ export function parseDrugReport(raw: unknown, query = "", role: DrugRole | null
     product: shown?.name ?? "Unnamed drug",
     role: shown?.role ?? null,
     drugs: drugs.map(({ name, role }) => ({ name, role })),
-    reactions: (Array.isArray(patient.reaction) ? patient.reaction : [])
+    // A report can code one reaction more than once (once per drug, or in another case): each is listed once.
+    reactions: uniqueTerms((Array.isArray(patient.reaction) ? patient.reaction : [])
       .map((entry) => asString(asRecord(entry).reactionmeddrapt))
-      .filter((entry): entry is string => !!entry),
+      .filter((entry): entry is string => !!entry)),
     outcome,
     outcomes,
     manufacturer: shown && shown.manufacturers.length === 1 ? shown.manufacturers[0]! : null,

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

@@ -3,8 +3,9 @@ import { OpenFdaPane } from "./pane";
 import { OPENFDA_PANE_ID, OPENFDA_PLUGIN_ID } from "./types";
 
 const createOpenFdaPaneInstance = (options?: PaneTemplateCreateOptions) => {
-  // A search of product and firm names, never a ticker: FDA records name the
-  // firm as it filed, not a symbol, so a ticker would match unrelated text.
+  // A search of product and firm names: FDA records name the firm as it filed,
+  // not a symbol. A ticker that matches nothing is searched as its company's
+  // name, which the pane looks up (`FDA AZN` is AstraZeneca's reports).
   const query = (options?.arg ?? options?.values?.query ?? "").trim();
   const encoded = encodeURIComponent(query).replace(/%/g, "~");
   return {

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

@@ -65,6 +65,15 @@ const TONES: Partial<Record<ColumnId, Record<string, StateTone>>> = {
   status: { Ongoing: "warning", Completed: "text", Terminated: "muted" },
 };
 
+/** The most terms a row's list cell names before counting the rest; the record names them all. */
+const MAX_CELL_TERMS = 3;
+
+/** A report's coded terms as a row shows them: the first few, then how many more (`Nausea, Rash, Fatigue +9 more`). */
+export function termsCellText(terms: readonly string[]): string {
+  const more = terms.length - MAX_CELL_TERMS;
+  return `${terms.slice(0, MAX_CELL_TERMS).join(", ")}${more > 0 ? ` +${more} more` : ""}`;
+}
+
 export function recordTone(column: ColumnId, text: string): StateTone {
   return TONES[column]?.[text] ?? "text";
 }