gloomberb 0.16.1 → 0.16.3

package/src/plugins/builtin/shared/members-menu.tsx

@@ -0,0 +1,260 @@
+import { ChoiceDialog, TextPromptDialog, usePaneMenuItems } from "../../../components";
+import { createFormCollectionActions } from "../../../components/form-modal/deps";
+import { t, tf } from "../../../i18n";
+import { usePluginAppActions } from "../../../public/react";
+import { useAppDispatch, useAppGetState, useAppSelector } from "../../../state/app/context";
+import { formatTickerListInput, MAX_TICKER_LIST_SIZE } from "../../../tickers/list";
+import type { TickerMetadata, TickerRecord } from "../../../types/ticker";
+import { useOptionalDialog, type PromptContext } from "../../../ui/dialog";
+import { canonicalExchange, publicTickerKey } from "../../../utils/exchanges";
+import { slugifyName } from "../../../utils/slugify";
+import { getSharedRegistry } from "../../registry";
+import { MAX_CORRELATION_TICKERS } from "../correlation/settings";
+import { ROTATION_LIMIT } from "../relative-rotation/model";
+import { SHORT_WATCH_LIMIT } from "../short-interest/watch-model";
+
+/** One US-listed member of a theme or fund, in the order its list shows it. */
+export interface MemberListing {
+  symbol: string;
+  name?: string | null;
+  exchange?: string | null;
+}
+
+/** The members a pane shows, and what to call them. */
+export interface MemberList {
+  /** Names the members in dialog titles: a theme's name or a fund's ticker. */
+  title: string;
+  /** The name the save dialog suggests. */
+  watchlistName: string;
+  members: readonly MemberListing[];
+  /** A search narrowing the list: what was typed and how many members the whole list has. */
+  search?: { query: string; total: number } | null;
+}
+
+interface MemberDestination {
+  templateId: string;
+  label: string;
+  /** The most symbols the destination takes; more would be refused or cut off there. */
+  limit: number;
+  minimum: number;
+}
+
+/**
+ * Functions that take a list of tickers through `options.symbols`. CORR and
+ * RIPL resolve the list the way the command bar does, which takes ten
+ * tickers; RIPL's own setting takes more, but not through a new pane.
+ */
+export const MEMBER_DESTINATIONS: readonly MemberDestination[] = [
+  { templateId: "relative-rotation-rrg", label: "Relative Rotation (RRG)", limit: ROTATION_LIMIT, minimum: 1 },
+  { templateId: "correlation-pane", label: "Correlation Matrix (CORR)", limit: MAX_CORRELATION_TICKERS, minimum: 2 },
+  { templateId: "short-watch-pane", label: "Short Squeeze Watch (SIW)", limit: SHORT_WATCH_LIMIT, minimum: 1 },
+  { templateId: "earnings-ripple-pane", label: "Earnings Ripple (RIPL)", limit: MAX_TICKER_LIST_SIZE, minimum: 1 },
+];
+
+/**
+ * A watchlist is a list to read and follow; a whole Russell 2000 stays in
+ * MEMB. Larger lists save their first 100 as listed.
+ */
+export const MEMBER_WATCHLIST_LIMIT = 100;
+
+/**
+ * Distinct members in list order, as `SYMBOL:EXCHANGE` when the list names the
+ * listing: CORR and RIPL resolve each one, and a bare CCJ also matches Xetra.
+ */
+export function memberSymbols(members: readonly MemberListing[]): string[] {
+  const seen = new Set<string>();
+  return members.flatMap((member) => {
+    const symbol = member.symbol.trim().toUpperCase();
+    if (!symbol || seen.has(symbol)) return [];
+    seen.add(symbol);
+    const exchange = member.exchange?.trim().toUpperCase();
+    return [exchange ? `${symbol}:${exchange}` : symbol];
+  });
+}
+
+/**
+ * What each destination would open: the first `limit` symbols as listed, or
+ * disabled below its minimum. A disabled row cannot be selected, so its reason
+ * sits beside the label rather than in the description under the list.
+ */
+export function memberDestinationChoices(symbols: readonly string[], destinations: readonly MemberDestination[]) {
+  return destinations.map((destination) => {
+    const taken = symbols.slice(0, destination.limit);
+    const tooFew = taken.length < destination.minimum;
+    return {
+      id: destination.templateId,
+      label: destination.label,
+      symbols: taken,
+      disabled: tooFew,
+      detail: tooFew ? tf("needs {count}", { count: destination.minimum }) : undefined,
+      description: tooFew ? undefined
+        : taken.length < symbols.length ? tf("First {count} of {total} as listed", { count: taken.length, total: symbols.length })
+        : tf("All {count}", { count: taken.length }),
+    };
+  });
+}
+
+/**
+ * The dialog text for `count` distinct members. A search says what it matched
+ * and how many members the whole list has, so a saved or opened subset never
+ * reads as the whole fund.
+ */
+function memberListText(list: Pick<MemberList, "title" | "search">, count: number) {
+  const query = list.search?.query.trim();
+  const search = query ? { query, total: list.search!.total } : null;
+  const saved = Math.min(count, MEMBER_WATCHLIST_LIMIT);
+  return {
+    openTitle: search ? tf("Open {title} members matching \"{query}\" in", { title: list.title, query: search.query })
+      : tf("Open {title} members in", { title: list.title }),
+    saveBody: count > MEMBER_WATCHLIST_LIMIT
+      ? search ? tf("The first {count} of the {matching} members matching \"{query}\", as listed.", { count: saved, matching: count, query: search.query })
+        : tf("The first {count} of {total} members, as listed.", { count: saved, total: count })
+      : search ? tf("{count} of {total} members match \"{query}\".", { count, total: search.total, query: search.query })
+      : tf("All {count} members.", { count }),
+  };
+}
+
+/** The requested name, numbered when a watchlist already has that name or id. */
+export function uniqueWatchlistName(requested: string, watchlists: readonly { id: string; name: string }[]): string {
+  const base = requested.trim();
+  const taken = (name: string) => watchlists.some((list) =>
+    list.name.toLowerCase() === name.toLowerCase() || list.id === slugifyName(name, "watchlist"));
+  let name = base;
+  for (let suffix = 2; taken(name); suffix += 1) name = `${base} ${suffix}`;
+  return name;
+}
+
+/**
+ * Tickers to create on the watchlist and existing ones to add to it, first
+ * `MEMBER_WATCHLIST_LIMIT` members as listed. A saved record of the same
+ * symbol on another venue (CCJ on Xetra) stays as it is: the member's listing
+ * gets its own `SYMBOL:EXCHANGE` record, the way search opens a second listing.
+ */
+export function planMemberWatchlist(
+  tickers: ReadonlyMap<string, TickerRecord>,
+  watchlistId: string,
+  members: readonly MemberListing[],
+): { create: TickerMetadata[]; update: TickerRecord[]; count: number } {
+  const seen = new Set<string>();
+  const create: TickerMetadata[] = [];
+  const update: TickerRecord[] = [];
+  for (const member of members) {
+    const symbol = member.symbol.trim().toUpperCase();
+    if (!symbol || seen.has(symbol)) continue;
+    if (seen.size >= MEMBER_WATCHLIST_LIMIT) break;
+    seen.add(symbol);
+    const exchange = member.exchange?.trim() ?? "";
+    let key = symbol;
+    let existing = tickers.get(symbol);
+    if (existing && exchange && existing.metadata.exchange
+      && canonicalExchange(existing.metadata.exchange) !== canonicalExchange(exchange)) {
+      key = publicTickerKey(symbol, exchange);
+      existing = tickers.get(key);
+    }
+    if (existing) {
+      if (!existing.metadata.watchlists.includes(watchlistId)) {
+        update.push({ ...existing, metadata: { ...existing.metadata, watchlists: [...existing.metadata.watchlists, watchlistId] } });
+      }
+      continue;
+    }
+    // Theme and fund members are US listings quoted in dollars. The sector is
+    // left to the ticker's profile, so a list never mixes two sector schemes.
+    create.push({ ticker: key, name: member.name || symbol, exchange, currency: "USD",
+      portfolios: [], watchlists: [watchlistId], positions: [], custom: {}, tags: [] });
+  }
+  return { create, update, count: seen.size };
+}
+
+/**
+ * Pane menu entries for a list of members (a theme's, a fund's): open them in
+ * RRG, CORR, SIW or RIPL, or save them as a watchlist. Functions of disabled
+ * plugins are left out; each destination gets as many as it takes.
+ */
+export function useMembersMenu(registrationId: string, list: MemberList | null) {
+  const dialog = useOptionalDialog();
+  const { createPaneFromTemplate, notify } = usePluginAppActions();
+  const dispatch = useAppDispatch();
+  const getState = useAppGetState();
+  const disabledPlugins = useAppSelector((state) => state.config.disabledPlugins);
+  usePaneMenuItems(registrationId, () => {
+    const registry = getSharedRegistry();
+    const symbols = list ? memberSymbols(list.members) : [];
+    if (!list || !symbols.length || !dialog || !registry) return null;
+    const destinations = MEMBER_DESTINATIONS.filter((destination) => {
+      const owner = registry.getPaneTemplatePluginId?.(destination.templateId);
+      return registry.paneTemplates.has(destination.templateId) && (!owner || !disabledPlugins.includes(owner));
+    });
+    const choices = memberDestinationChoices(symbols, destinations);
+    const text = memberListText(list, symbols.length);
+    const openIn = () => {
+      void dialog.prompt<string>({
+        closeOnClickOutside: true,
+        content: (context: PromptContext<string>) => <ChoiceDialog {...context} title={text.openTitle}
+          choices={choices.map(({ id, label, description, detail, disabled }) => ({ id, label: t(label), description, detail, disabled }))} />,
+      }).then((templateId) => {
+        const choice = choices.find((item) => item.id === templateId && !item.disabled);
+        // CORR and RIPL resolve `arg` like the command bar; RRG and SIW read `symbols`.
+        if (choice) createPaneFromTemplate(choice.id, { symbols: choice.symbols, arg: formatTickerListInput(choice.symbols) });
+      }).catch(() => {});
+    };
+    const saveAsWatchlist = async (requested: string) => {
+      // The writes hold the app for about a second with a hundred names; let the dialog close on screen first.
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      const name = uniqueWatchlistName(requested, getState().config.watchlists);
+      await createFormCollectionActions({ dataProvider: registry.marketData, dispatch, getState, pluginRegistry: registry,
+        tickerRepository: registry.tickerRepository }, (body, options) => {
+        if (options?.type === "error") notify({ body, type: "error" });
+      }).createWatchlist(name);
+      const watchlist = getState().config.watchlists.find((entry) => entry.name === name);
+      if (!watchlist) throw new Error(t("The watchlist was not created."));
+      const plan = planMemberWatchlist(getState().tickers, watchlist.id, list.members);
+      // One ticker that fails to save leaves the others on the list; the toast says how many made it.
+      let failed = 0;
+      const created: TickerRecord[] = [];
+      const saved: TickerRecord[] = [];
+      for (const metadata of plan.create) {
+        try {
+          const ticker = await registry.tickerRepository.createTicker(metadata);
+          created.push(ticker);
+          saved.push(ticker);
+        } catch {
+          failed += 1;
+        }
+      }
+      for (const ticker of plan.update) {
+        try {
+          await registry.tickerRepository.saveTicker(ticker);
+          saved.push(ticker);
+        } catch {
+          failed += 1;
+        }
+      }
+      // One state update for the whole list: an update per ticker redraws every pane a hundred times.
+      if (saved.length) {
+        const tickers = new Map(getState().tickers);
+        for (const ticker of saved) tickers.set(ticker.metadata.ticker, ticker);
+        dispatch({ type: "SET_TICKERS", tickers });
+      }
+      for (const ticker of created) registry.events.emit("ticker:added", { symbol: ticker.metadata.ticker, ticker });
+      notify(failed
+        ? { type: "error", body: tf("Saved {saved} of {count} members to {name}. {failed} could not be added.", { saved: plan.count - failed, count: plan.count, name, failed }) }
+        : { type: "success", body: tf("Saved {count} members to {name}.", { count: plan.count, name }) });
+    };
+    return [
+      ...(choices.length ? [{ id: "members-open-in", label: t("Open Members In…"), onSelect: openIn }] : []),
+      { id: "members-save-watchlist", label: t("Save as Watchlist…"), onSelect: () => {
+        // 54 columns fill the dialog; the prompt's default field is wider and runs past its frame.
+        void dialog.prompt<string>({
+          closeOnClickOutside: true,
+          content: (context: PromptContext<string>) => <TextPromptDialog {...context} title={t("Save as Watchlist")}
+            body={[text.saveBody]} label={t("Name")} initialValue={list.watchlistName} confirmLabel={t("Save")} width={54} />,
+        }).then((name) => {
+          if (!name?.trim()) return;
+          saveAsWatchlist(name).catch((error: unknown) => {
+            notify({ type: "error", body: error instanceof Error ? error.message : t("The watchlist was not saved.") });
+          });
+        }).catch(() => {});
+      } },
+    ];
+  }, [createPaneFromTemplate, dialog, disabledPlugins, dispatch, getState, list, notify]);
+}

package/src/plugins/builtin/shared/report-freshness.ts

@@ -0,0 +1,57 @@
+import type { HeadlessPaneFreshness } from "../../../types/headless";
+import type { Quote } from "../../../types/financials";
+import { isQuoteStaleForCurrentSession } from "../../../market-data/quotes/freshness";
+
+/**
+ * Freshness declarations shared by built-in reports. Each `fn` report ends
+ * with the source, as-of and status line these feed; see
+ * docs/usage.md#how-current-a-report-is.
+ */
+
+/** Analyses over end-of-day history: not a feed, but stale once the closes stop arriving. */
+export const DAILY_CLOSES: HeadlessPaneFreshness = { status: "not-a-feed", basis: "daily closes", cadence: "daily" };
+
+const DAY_MINUTES = 24 * 60;
+
+/**
+ * Price bars: a history, not a feed, stale once the bars stop arriving for
+ * their size. Intraday and daily bars follow the US trading sessions; a
+ * weekly or monthly bar is dated by the start of its period.
+ */
+export function barHistoryFreshness(resolution: string | null | undefined): HeadlessPaneFreshness {
+  if (resolution === "1wk") return { status: "not-a-feed", basis: "weekly bars", maxAgeMinutes: 14 * DAY_MINUTES };
+  if (resolution === "1mo") return { status: "not-a-feed", basis: "monthly bars", maxAgeMinutes: 45 * DAY_MINUTES };
+  if (resolution === "1d") return DAILY_CLOSES;
+  return { status: "not-a-feed", basis: "intraday bars", cadence: "daily" };
+}
+
+/** The bar size of a dated history, read from the gap between its last two bars. */
+export function barResolutionFromDates(dates: readonly (string | number | Date)[]): "1d" | "1wk" | "1mo" {
+  const times = dates.slice(-2).map((date) => new Date(date).getTime());
+  const gapDays = times.length === 2 && times.every(Number.isFinite) ? (times[1]! - times[0]!) / 86_400_000 : 1;
+  return gapDays >= 25 ? "1mo" : gapDays >= 6 ? "1wk" : "1d";
+}
+
+/** Company filings read from EDGAR. Old filings are not stale; there is no schedule to miss. */
+export const SEC_FILINGS: HeadlessPaneFreshness = { source: "SEC EDGAR", status: "not-a-feed", basis: "filed data", oldest: null };
+
+/** Places and listings that change only when someone edits them: venues, ports, pipelines. */
+export const REFERENCE_DATA: HeadlessPaneFreshness = { status: "not-a-feed", basis: "reference data", oldest: null };
+
+/** Company fundamentals, estimates and calendars: reported figures, not a feed. */
+export const REPORTED_DATA: HeadlessPaneFreshness = { status: "not-a-feed", basis: "reported data" };
+
+/**
+ * The standard freshness fields of one quote, spread into a report row so the
+ * report can say whether that row is live, delayed or stale for its session.
+ */
+export function quoteFreshnessFields(
+  quote: Quote | null | undefined,
+  now = Date.now(),
+): { dataSource?: "live" | "delayed"; stale?: boolean } {
+  if (!quote) return {};
+  return {
+    ...(quote.dataSource === "live" || quote.dataSource === "delayed" ? { dataSource: quote.dataSource } : {}),
+    stale: isQuoteStaleForCurrentSession(quote, now),
+  };
+}

package/src/plugins/builtin/shared/research-cells.tsx

@@ -1,4 +1,5 @@
 import type { DataTableCell, DataTableColumn } from "../../../components";
+import { RatioBar } from "../../../components/ui/ratio-bar";
 import { SplitBar } from "../../../components/ui/split-bar";
 import { blendHex } from "../../../theme/colors";
 import type { ThemeColors } from "../../../theme/colors";
@@ -39,21 +40,15 @@ export function listingCell(key: string | null | undefined, colors: ThemeColors,
  * so the eye compares lengths down the column. The bar gives way first in a
  * narrow column; the number never does.
  */
-export function shareCell(text: string, ratio: number | null, width: number, colors: ThemeColors, selected: boolean, desktop: boolean,
+export function shareCell(text: string, ratio: number | null, width: number, colors: ThemeColors, selected: boolean,
   color = blendHex(colors.bg, colors.borderFocused, 0.6)): DataTableCell {
   const textCells = displayWidth(text);
   const barCells = width - textCells - 1;
   if (ratio == null || !(ratio > 0) || barCells < 4) return { text, color: selected ? colors.selectedText : colors.text };
-  const fill = Math.max(0, Math.min(1, ratio));
-  const ink = selected ? colors.selectedText : color;
-  // The desktop draws the bar on a faint track; terminal cells draw the length alone, at half-cell steps,
+  // The desktop draws the bar on a faint track; terminal cells draw the length alone,
   // since a track of block cells would join the rows above and below into one wall.
-  const units = Math.max(1, Math.round(fill * barCells * 2));
   return { text, content: <Box flexDirection="row" height={1} width={width} overflow="hidden" alignItems="center">
-    <Box width={barCells} flexShrink={0} flexDirection="row" alignItems="center">
-      {desktop ? <SplitBar width={barCells} parts={[{ id: "share", value: fill, color: ink }, { id: "rest", value: 1 - fill, color: blendHex(colors.bg, color, 0.2) }]} />
-        : <Text fg={ink}>{`${"█".repeat(Math.floor(units / 2))}${units % 2 ? "▌" : ""}`}</Text>}
-    </Box>
+    <RatioBar ratio={ratio} width={barCells} color={selected ? colors.selectedText : color} track />
     <Box flexGrow={1} justifyContent="flex-end"><Text fg={selected ? colors.selectedText : colors.text}>{` ${text}`}</Text></Box>
   </Box> };
 }

package/src/plugins/builtin/short-interest/headless.ts

@@ -58,6 +58,8 @@ export function createShortInterestHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
+    // Settled twice a month and published about a week later; a month without one has missed it.
+    freshness: { source: "FINRA", status: "not-a-feed", basis: "twice-monthly settlement", observedKey: "settlementDate", oldest: null, maxAgeMinutes: 30 * 24 * 60 },
     argument: {
       kind: "ticker",
       placeholder: "ticker",

package/src/plugins/builtin/short-interest/watch-headless.ts

@@ -10,6 +10,7 @@ const signedPercent = (value: unknown) =>
 
 export const shortWatchHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
+  freshness: { source: "FINRA", status: "not-a-feed", basis: "twice-monthly settlement", observedKey: "settlementDate", maxAgeMinutes: 30 * 24 * 60 },
   argument: { kind: "symbol-list", maximum: SHORT_WATCH_LIMIT, description: "US tickers; the pane defaults to your portfolios and watchlists." },
   options: [],
   describe: "Short squeeze watch",

package/src/plugins/builtin/short-volume/headless.ts

@@ -4,6 +4,7 @@ import { volumePercent, volumePointStatus, volumeQuantity } from "./model";
 
 export const shortVolumeHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "US equity ticker.", placeholder: "ticker" },
+  freshness: { source: "FINRA", status: "not-a-feed", basis: "daily short volume", cadence: "daily", observedKey: "date", oldest: null },
   discovery: { aliases: ["SIV"], dataRequirements: ["Gloom Cloud FINRA daily short volume"],
     limitations: ["Regular-session off-exchange volume, not short interest", "Short volume includes exempt volume", "One-year history depends on source discovery and ingestion"] },
   options: [

package/src/plugins/builtin/short-volume/pane.tsx

@@ -27,7 +27,7 @@ function renderCell(row: ShortVolumeObservation, column: VolumeColumn, _index: n
 function VolumeDetail({ row, width, height }: { row: ShortVolumeObservation; width: number; height: number }) {
   const { nativePaneChrome } = useUiCapabilities();
   // The stack title is the date, so the rows start with the figures.
-  return <ScrollBox width={width} height={nativePaneChrome ? undefined : height} flexGrow={1} flexBasis={0} minHeight={0} contentOptions={{ paddingX: 1 }}>
+  return <ScrollBox scrollY width={width} height={nativePaneChrome ? undefined : height} flexGrow={1} flexBasis={0} minHeight={0} contentOptions={{ paddingX: 1 }}>
     <KeyValueRow labelWidth={DETAIL_LABEL_WIDTH} label="Off-exchange short ratio" value={volumePercent(row.ratioPercent)} />
     <KeyValueRow labelWidth={DETAIL_LABEL_WIDTH} label="Short shares" value={exactQuantity(row.shortVolume)} />
     <KeyValueRow labelWidth={DETAIL_LABEL_WIDTH} label="Exempt shares" value={exactQuantity(row.shortExemptVolume)} detail="included in short shares" />

package/src/plugins/builtin/social-mentions/headless.ts

@@ -5,6 +5,7 @@ import { socialCount, socialDayRows, socialRatio, socialStance, topPostCell } fr
 
 export const socialMentionsHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Ticker with a searchable cashtag (up to six letters and digits).", placeholder: "ticker" },
+  freshness: { source: "X posts", status: "not-a-feed", basis: "daily post counts" },
   discovery: { aliases: ["BUZZ"], dataRequirements: ["Gloom Cloud X mention history"],
     limitations: ["Daily $cashtag posts on X in UTC days, spam included", "Top posts and stance cover days that were looked up", "Views exist from 2022-12-22"] },
   options: [

package/src/plugins/builtin/social-mentions/pane.tsx

@@ -59,7 +59,7 @@ function DayDetail({ symbol, row, recent, width, height }: {
       { id: "ratio", label: "Vs median", value: socialRatio(row.ratio) },
       { id: "stance", label: "Stance", value: socialStance(row.stance), detail: stanceWord(row.stance) },
     ]} />
-    <ScrollBox width={width} height={nativePaneChrome ? undefined : Math.max(1, height - 3)} flexGrow={1} flexBasis={0} minHeight={0} contentOptions={{ paddingX: 1 }}>
+    <ScrollBox scrollY width={width} height={nativePaneChrome ? undefined : Math.max(1, height - 3)} flexGrow={1} flexBasis={0} minHeight={0} contentOptions={{ paddingX: 1 }}>
       <PaneStatusBody loading={posts.loading && !list.length} error={!list.length ? posts.error : null} subject="top posts"
         empty={!posts.loading && !list.length} emptyTitle="No top posts for this day.">
         <Box flexDirection="column" gap={1} width={lineWidth}>

package/src/plugins/builtin/supply-chain/headless.ts

@@ -4,6 +4,7 @@ import { fetchSupplyChain } from "./client";
 import { evidenceLabel, isUnconfirmed, matchesSupplyOptions, supplyOptions, trustTier } from "./trust";
 import { fetchSupplyGraph, graphOptions } from "./graph-client";
 import { exposureLabel, pathLabel } from "./graph-model";
+import { supplyRoleCounts } from "./model";
 
 const pathColumns = [
   { key: "route", header: "Route" }, { key: "hops", header: "Hops" },
@@ -54,6 +55,7 @@ function graphReport(data: GraphPayload, target: string): HeadlessBundleResult {
 
 export const supplyChainHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
+  freshness: { source: "Company filings, calls and news", status: "not-a-feed", basis: "disclosed relationships" },
   argument: { kind: "ticker", description: "Company ticker, exchange-qualified ticker, or id:<entity-id>.", placeholder: "ticker" },
   discovery: { aliases: ["SPLC", "SUPPLY"], dataRequirements: ["Gloom Cloud relationship evidence (Pro with free preview)"],
     limitations: ["Filings, company announcements, earnings calls and news where evidence is available globally", "Japan filings await an API key and Taiwan report ingestion is disabled", "English glosses are machine translations, separate from original evidence", "Absence is not proof of no relationship",
@@ -87,6 +89,9 @@ export const supplyChainHeadless: HeadlessPaneDefinition<"bundle"> = {
     }
     const options = supplyOptions(args.options.tiers);
     const data = await fetchSupplyChain(args.symbols[0]!, ctx.apiClient, options);
+    // The pane's figures, per tab: Table shows one direction, Flow both.
+    const figures = (key: "counterparties" | "locked") => Object.fromEntries(([["says", ["says"]], ["names", ["names"]], ["flow", ["says", "names"]]] as const)
+      .map(([scope, views]) => [scope, Object.fromEntries(supplyRoleCounts(data, views, options).filter((entry) => entry[key] > 0).map((entry) => [entry.role, entry[key]]))]));
     return { complete: !data.truncated, errors: data.truncated ? ["Additional relationships need Gloom Pro"] : [],
       sections: (["says", "names"] as const).flatMap((view) => [false, true].map((leads) => ({ title: `${view === "says" ? `${data.symbol} says` : `Names ${data.symbol}`}${leads ? " | Unconfirmed" : ""}`,
         rows: data[view].filter((row) => matchesSupplyOptions(row, options) && isUnconfirmed(row) === leads).map((row) => ({ counterparty: row.counterparty.name, ticker: row.counterparty.ticker, aggregate: row.counterparty.aggregate, role: row.role, direction: row.direction,
@@ -100,6 +105,7 @@ export const supplyChainHeadless: HeadlessPaneDefinition<"bundle"> = {
           quote: row.quote, quoteLanguage: row.quoteLanguage, quoteGloss: row.quoteGloss ?? null, quoteGlossKind: row.quoteGloss ? "machine_translation" : null,
           quoteMatchMode: row.quoteMatchMode, sourceUrl: row.filingUrl, filingUrl: row.filingUrl, sectionRef: row.sectionRef ?? null, sourceAttribution: row.sourceAttribution ?? null,
           evidence: row.evidence ?? [] })) })).filter((section) => section.rows.length > 0)),
-      metadata: { symbol: data.symbol, asOf: data.asOf, counts: data.counts, tierCounts: data.tierCounts, tiers: options.tiers, disclaimer: data.disclaimer } };
+      metadata: { symbol: data.symbol, asOf: data.asOf, counterparties: figures("counterparties"), locked: figures("locked"),
+        counts: data.counts, tierCounts: data.tierCounts, tiers: options.tiers, disclaimer: data.disclaimer } };
   },
 };

package/src/plugins/builtin/supply-chain/index.tsx

@@ -5,6 +5,11 @@ import { supplyChainCache } from "./client";
 import { supplyChainHeadless } from "./headless";
 import { SupplyChainPane } from "./pane";
 
+/** What another pane can open SPLC on: a Graph or Path view, its target and its query, as `graphOptions` reads them. */
+const OPENING_SETTINGS = ["tab", "to", "depth", "direction", "roles", "tiers"];
+const openingSettings = (values: Record<string, string> = {}) =>
+  Object.fromEntries(OPENING_SETTINGS.flatMap((key) => values[key] ? [[key, values[key]]] : []));
+
 export const supplyChainModule: PluginModule = {
   setup(ctx) { supplyChainCache.attach(ctx.persistence); graphCache.attach(ctx.persistence); },
   dispose() { supplyChainCache.reset(); graphCache.reset(); },
@@ -13,5 +18,9 @@ export const supplyChainModule: PluginModule = {
     tickerFollower: true, tableExport: true, headless: supplyChainHeadless }],
   paneTemplates: [{ ...createTickerSurfacePaneTemplate({ id: "supply-chain-pane", paneId: "supply-chain", label: "Supply Chain",
     description: "Pro global supply chain evidence from filings, company announcements, calls and news, with trust tiers, original quotes, native units, four-hop graphs, ranked paths and a free preview.",
-    keywords: ["supply", "supply chain", "suppliers", "customers", "concentration", "filings", "earnings calls", "news", "evidence", "global", "Korea", "Japan", "Taiwan", "graph", "paths", "Pro"], shortcut: "SPLC", shortcutAliases: ["SUPPLY"] }), headless: supplyChainHeadless }],
+    keywords: ["supply", "supply chain", "suppliers", "customers", "concentration", "filings", "earnings calls", "news", "evidence", "global", "Korea", "Japan", "Taiwan", "graph", "paths", "Pro"], shortcut: "SPLC", shortcutAliases: ["SUPPLY"],
+    settings: (_symbol, _context, options) => openingSettings(options?.values),
+    // A route opened from another pane gets a pane of its own, so the company's SPLC keeps its view.
+    viewKey: (_symbol, _context, options) => options?.values?.to ? `${options.values.tab ?? "graph"}:${options.values.to}` : undefined,
+  }), headless: supplyChainHeadless }],
 };

package/src/plugins/builtin/supply-chain/model.ts

@@ -1,7 +1,7 @@
-import type { SupplyRole, SupplyRow } from "../../../api-client/supply-chain";
+import type { SupplyChainPayload, SupplyOptions, SupplyRole, SupplyRow } from "../../../api-client/supply-chain";
 import { SERIES_COLORS } from "../../../time-series/resolve";
 import { revenueAmount } from "../revenue-breakdown/model";
-import { activeRelationship, corroborationLabel, evidenceDate, evidenceLabel, isUnconfirmed, trustTier } from "./trust";
+import { activeRelationship, corroborationLabel, evidenceDate, evidenceLabel, isUnconfirmed, matchesSupplyOptions, trustTier } from "./trust";
 
 /** One colour per role from the shared series palette, the same in the table, the flow and the evidence. */
 export const ROLE_COLORS: Record<SupplyRole, string> = {
@@ -64,6 +64,31 @@ export function counterpartyName(row: SupplyRow): string {
   return member ? `${member.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\s*\(undisclosed\)/gi, "")} (undisclosed)` : name;
 }
 export const roleLabel = (role: SupplyRole) => role[0]!.toUpperCase() + role.slice(1);
+
+const SUPPLY_ROLE_ORDER: readonly SupplyRole[] = ["customer", "supplier", "partner", "competitor", "investee"];
+export interface SupplyRoleCount { role: SupplyRole; counterparties: number; locked: number }
+
+/**
+ * The one count behind the figures over the table, the flow and the headless
+ * report: per role, the companies the reader can see, each counted once
+ * however many disclosures name it (the flow draws one card per counterparty
+ * and role). Unconfirmed leads, inactive links and cohort groups are not
+ * counterparties. The server's counts are disclosures, not companies, so what
+ * a free preview withholds is reported apart as locked disclosures rather
+ * than added to the companies.
+ */
+export function supplyRoleCounts(data: Pick<SupplyChainPayload, "says" | "names" | "counts">, views: readonly ("says" | "names")[], options: Required<SupplyOptions>): SupplyRoleCount[] {
+  return SUPPLY_ROLE_ORDER.map((role) => {
+    const companies = new Set<string>();
+    let locked = 0;
+    for (const view of views) {
+      const rows = data[view].filter((row) => row.role === role);
+      for (const row of rows) if (!row.counterparty.aggregate && !isUnconfirmed(row) && matchesSupplyOptions(row, options)) companies.add(row.counterparty.id);
+      locked += Math.max(0, data.counts[view][role] - rows.length);
+    }
+    return { role, counterparties: companies.size, locked };
+  }).filter((entry) => entry.counterparties > 0 || entry.locked > 0);
+}
 export const percentage = (row: SupplyRow) => row.pctOfRevenue === null || trustTier(row) !== 1 || isUnconfirmed(row) || !activeRelationship(row) ? "--" : `${Number(row.pctOfRevenue.toFixed(2))}% ${row.pctScope ? "scoped " : ""}${row.pctBasis ?? ""}`;
 export const dollars = (row: SupplyRow) => row.usd === null ? "--" : `${row.usdBasis === "derived" ? "≈ " : ""}$${revenueAmount(row.usd)} ${row.usdBasis}`;
 const scaleLabel = (scale: number) => scale === 1 ? "" : scale === 1_000 ? " thousand" : scale === 1_000_000 ? " million" : scale === 1_000_000_000 ? " billion" : ` ×${scale.toLocaleString("en-US")}`;