gloomberb 0.16.0 → 0.16.2

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

@@ -32,6 +32,8 @@ export function projectSectorRows(
     loading: false,
     quoteUnavailable: !byEtf.get(definition.etf) || byEtf.get(definition.etf)?.quoteUnavailable === true,
     quoteSessionDate: byEtf.get(definition.etf)?.quoteSessionDate ?? null,
+    quoteUpdatedAt: byEtf.get(definition.etf)?.quoteUpdatedAt ?? null,
+    quoteDataSource: byEtf.get(definition.etf)?.quoteDataSource,
     quoteIssue: byEtf.get(definition.etf)?.quoteIssue ?? null,
     lastReportedPrice: byEtf.get(definition.etf)?.lastReportedPrice ?? null,
     returnIntegrity: byEtf.get(definition.etf)?.returnIntegrity ?? {},
@@ -58,6 +60,8 @@ export function createSectorsHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
+    // Dated by each ETF's quote; the shared session date is the returns' end, not an observation.
+    freshness: { observedKey: "quoteUpdatedAt" },
     argument: { kind: "none" },
     options: [{
       key: "collection",
@@ -81,7 +85,11 @@ export function createSectorsHeadless(
       return {
         unavailableSymbols: unavailableSymbols.length > 0 ? unavailableSymbols : undefined,
         errors: rows.flatMap((row) => sectorRowIssues(row).map((issue) => `${row.etf}: ${issue}.`)),
-        rows: rows.map((row) => ({ ...row })),
+        // The quote behind each row says whether it is real-time or delayed, and how current it is.
+        rows: rows.map(({ quoteDataSource, ...row }) => ({
+          ...row,
+          ...(quoteDataSource === "live" || quoteDataSource === "delayed" ? { dataSource: quoteDataSource } : {}),
+        })),
         metadata: {
           collection: collectionId,
           available: outcomes.filter((outcome) => outcome.row).length,

package/src/plugins/builtin/sectors/move-bar.tsx

@@ -1,4 +1,5 @@
-import { Box, Text, useUiCapabilities } from "../../../ui";
+import { RatioBar } from "../../../components/ui/ratio-bar";
+import { Text } from "../../../ui";
 import { colors } from "../../../theme/colors";
 import { moveBarRatio } from "./sector-model";
 
@@ -7,37 +8,14 @@ export interface SectorMoveBarProps {
   width: number;
 }
 
-/**
- * The session move as a length, not as a number that is already in the 1D
- * column. Desktop draws a real element; the terminal falls back to block cells,
- * so box-drawing characters never reach the browser renderer.
- */
+/** The session move as a length, not as a number that is already in the 1D column. */
 export function SectorMoveBar({ changePercent, width }: SectorMoveBarProps) {
-  const isDesktopWeb = useUiCapabilities().nativePaneChrome === true;
   if (changePercent == null || width <= 0) return <Text fg={colors.textDim}>{""}</Text>;
-
-  const ratio = moveBarRatio(changePercent);
-  const color = changePercent >= 0 ? colors.positive : colors.negative;
-
-  if (isDesktopWeb) {
-    return (
-      <Box width={width} flexDirection="row" alignItems="center" overflow="hidden">
-        <Box
-          backgroundColor={color}
-          style={{
-            width: `${(ratio * 100).toFixed(2)}%`,
-            height: "9px",
-            borderRadius: "2px",
-            minWidth: ratio > 0 ? "2px" : "0",
-          }}
-        />
-      </Box>
-    );
-  }
-
-  const cells = ratio * width;
-  const full = Math.floor(cells);
-  const half = cells - full >= 0.5;
-  const bar = `${"█".repeat(full)}${half ? "▌" : ""}`;
-  return <Text fg={color}>{bar}</Text>;
+  return (
+    <RatioBar
+      ratio={moveBarRatio(changePercent)}
+      width={width}
+      color={changePercent >= 0 ? colors.positive : colors.negative}
+    />
+  );
 }

package/src/plugins/builtin/sectors/sector-model.ts

@@ -25,6 +25,8 @@ export interface SectorRow extends SectorDef {
   lastReportedPrice?: number | null;
   /** When the snapshot quote behind `price` was stamped; a live quote must be at least as new. */
   quoteUpdatedAt?: number | null;
+  /** Whether that quote is real-time or delayed, for the report's freshness line. */
+  quoteDataSource?: Quote["dataSource"];
   returnIntegrity?: Partial<Record<SectorReturnRange, PriceHistoryIntegrity>>;
   returnAsOfDate?: string | null;
   return1MStartDate?: string | null;

package/src/plugins/builtin/shared/crypto-pair.ts

@@ -0,0 +1,14 @@
+/**
+ * The coin a USD crypto pair names: BTC-USD gives BTC. CME lists bitcoin and
+ * ether futures, but BTC and ETH are also US equity tickers (Grayscale's mini
+ * trusts), so a futures function that falls back to the ticker under the
+ * cursor reads a bare symbol as the equity and only a pair as the coin.
+ */
+export function cryptoPairCoin(ticker: string): string | null {
+  return /^([A-Z0-9]{2,10})-USD$/.exec(ticker.trim().toUpperCase())?.[1] ?? null;
+}
+
+/** `BTC=F`: the spelling of a futures contract, which no equity shares. */
+export function isFuturesSymbol(ticker: string): boolean {
+  return ticker.trim().toUpperCase().endsWith("=F");
+}

package/src/plugins/builtin/shared/locked-rows.tsx

@@ -20,7 +20,7 @@ export function Blurred({ children }: { children: ReactNode }) {
 export function UpgradeLabel({ text, onPress, role }: { text: string; onPress: () => void; role?: string }) {
   const colors = useThemeColors();
   return (
-    <Box flexDirection="row" gap={1} onMouseDown={onPress} data-gloom-role={role}>
+    <Box flexDirection="row" gap={1} onMouseDown={onPress} data-gloom-role={role} data-gloom-ui="pro-lock">
       <Icon name="lock" size={11} color={colors.textBright} />
       <Text fg={colors.textBright}>{text}</Text>
     </Box>

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/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/index.tsx

@@ -10,7 +10,7 @@ const socialMentionsSettings = [
 ];
 export const socialMentionsModule: PluginModule = {
   panes: [{ id: "social-mentions", name: "Social Mentions", icon: "B", component: SocialMentionsPane,
-    defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 96, height: 30 },
+    defaultPosition: "right", tickerFollower: true, defaultMode: "floating", defaultFloatingSize: { width: 96, height: 30 },
     tableExport: true, headless: socialMentionsHeadless, settings: { title: "Social Mentions", fields: socialMentionsSettings } }],
   paneTemplates: [{ ...createTickerSurfacePaneTemplate({ id: "social-mentions-pane", paneId: "social-mentions", label: "Social Mentions",
     description: "Daily posts on X naming the ticker's cashtag, the day's top posts and their stance.",

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

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

@@ -27,27 +27,46 @@ import { SupplyFlow } from "./flow";
 import { SupplyGraphPane } from "./graph-pane";
 import {
   cellText, counterpartyKind, counterpartyKindLabel, counterpartyLabel, counterpartyName, disclosedValue, nativeValue, percentage, ROLE_COLORS, roleLabel,
-  shareParts, sortRows, type SupplySort,
+  shareParts, sortRows, supplyRoleCounts, type SupplySort,
 } from "./model";
 import { RowEvidence } from "./row-evidence";
 import { evidenceDate, evidenceLabel, isUnconfirmed, matchesSupplyOptions, supplyOptions, TIER_OPTIONS } from "./trust";
 
 type Item = { kind: "edge"; row: SupplyRow } | { kind: "locked"; id: string };
 const itemId = (item: Item) => item.kind === "edge" ? item.row.id : item.id;
-const ROLE_ORDER: SupplyRole[] = ["customer", "supplier", "partner", "competitor", "investee"];
 const ROLE_PLURALS: Record<SupplyRole, string> = { customer: "Customers", supplier: "Suppliers", partner: "Partners", competitor: "Competitors", investee: "Investees" };
-const BAR_CELLS = 8;
+/** A share figure is at most five cells (`99.9%`, `100%`), right-aligned so the bars line up. */
+const SHARE_FIGURE_CELLS = 5;
+/** Bar, gap and figure: below this a share cell shows the figure alone. */
+const SHARE_BAR_MIN_CELLS = 3 + 1 + SHARE_FIGURE_CELLS;
 
 /**
- * A narrow pane folds the ticker into the name and leaves the filing to the
- * evidence view before anything scrolls sideways. Value shows only when some
- * row discloses a value, retaining its original currency and units.
+ * Cells of a share column's bar: as long as the column allows after the figure
+ * and the longest basis that fits, between 3 and 8 cells, and the same on every
+ * row so the bars and figures line up. Zero leaves the figure alone.
  */
-function tableColumns(width: number, desktop: boolean, locked: boolean, valueWidth: number | null): DataTableColumn[] {
+function shareBarCells(width: number, bases: readonly number[]): number {
+  if (width < SHARE_BAR_MIN_CELLS) return 0;
+  // Room for the longest basis that can show at all; a longer one gives way, not every bar.
+  const basis = longestBasis(bases, width);
+  return Math.min(width >= 36 ? 8 : 5, Math.max(3, width - SHARE_FIGURE_CELLS - 2 - basis));
+}
+const longestBasis = (bases: readonly number[], width: number) => Math.max(0, ...bases.filter((cells) => SHARE_BAR_MIN_CELLS + 1 + cells <= width));
+
+/**
+ * Columns that fit the pane, giving up the least first: the share bar shortens
+ * to keep the whole basis, the name shortens to 18 cells, the ticker folds into
+ * the name and the period is left to the evidence view; then the share drops
+ * its basis and its bar, and the name shortens further. Only a pane narrower
+ * than that scrolls sideways, so the pane edge never cuts a share in half.
+ * Value shows only when some row discloses a value, retaining its original
+ * currency and units.
+ */
+function tableColumns(width: number, desktop: boolean, locked: boolean, valueWidth: number | null, bases: readonly number[]): DataTableColumn[] {
   const wide = width >= 150, medium = width >= 110;
   const name: DataTableColumn = { id: "name", label: "Counterparty", width: Math.max(locked && !desktop ? 34 : 0, wide ? 30 : medium ? 26 : 20), flexGrow: 1, align: "left" };
   const share: DataTableColumn = { id: "pct", label: "Share", width: wide ? 34 : medium ? 30 : 26, align: "left" };
-  const columns: DataTableColumn[] = [
+  let columns: DataTableColumn[] = [
     name,
     { id: "evidence", label: "Evidence", width: 12, align: "left" },
     ...(medium ? [{ id: "ticker", label: "Ticker", width: 8, align: "left" as const }] : []),
@@ -61,40 +80,57 @@ function tableColumns(width: number, desktop: boolean, locked: boolean, valueWid
       { id: "corroboration", label: "Origins", width: 8, align: "right" as const },
     ] : []),
   ];
-  // Preserve trust labels, native units and final columns before expanding the share and name.
+  const preferred = { share: share.width, name: name.width };
   // The table ignores its last trailing gutter when deciding whether it fits.
-  if (valueWidth !== null || width >= 80) {
-    share.width = Math.max(valueWidth !== null ? 10 : 14, share.width - Math.max(0, getTableWidth(columns) - width - 1));
-    name.width = Math.max(18, name.width - Math.max(0, getTableWidth(columns) - width - 1));
+  const overflow = () => getTableWidth(columns) - width - 1;
+  // Native units keep their column before the share keeps its bar or basis.
+  const shareFloor = valueWidth !== null ? SHARE_BAR_MIN_CELLS + 1 : SHARE_BAR_MIN_CELLS + 1 + longestBasis(bases, preferred.share);
+  const fit = (shareMin: number, nameMin = 18) => {
+    share.width = preferred.share; name.width = preferred.name;
+    share.width = Math.max(shareMin, share.width - Math.max(0, overflow()));
+    name.width = Math.max(nameMin, name.width - Math.max(0, overflow()));
+  };
+  fit(shareFloor);
+  for (const id of ["ticker", "fy"]) {
+    if (overflow() <= 0) break;
+    if (!columns.some((column) => column.id === id)) continue;
+    columns = columns.filter((column) => column.id !== id);
+    fit(shareFloor);
   }
+  // The narrowest panes keep the figure alone, then a shorter name, before anything scrolls.
+  if (overflow() > 0) fit(SHARE_BAR_MIN_CELLS);
+  if (overflow() > 0) fit(SHARE_FIGURE_CELLS + 2, 12);
   return columns;
 }
 
-/** Company, then disclosed counterparties per role: the strip that heads both tabs. */
-function supplyFigures(data: SupplyChainPayload, views: readonly ("says" | "names")[], options: Required<SupplyOptions>, flow: boolean): StatItem[] {
-  const shown = views.flatMap((view) => data[view]).filter((row) => matchesSupplyOptions(row, options) && !isUnconfirmed(row));
+/**
+ * Company, then the counterparties per role on this tab, with how many
+ * disclosures a free preview locks: the strip that heads the table and the flow.
+ */
+function supplyFigures(data: SupplyChainPayload, views: readonly ("says" | "names")[], options: Required<SupplyOptions>): StatItem[] {
   return [
     ...(data.entity ? [{ id: "company", label: "Company", value: data.entity.name }] : []),
-    ...ROLE_ORDER.flatMap((role) => {
-      const visible = shown.filter((row) => row.role === role).length;
-      const count = data.truncated && !flow && !options.includeLeads ? views.reduce((total, view) => total + data.counts[view][role], 0) : visible;
-      return count ? [{ id: role, label: ROLE_PLURALS[role], value: String(count), color: ROLE_COLORS[role],
-        detail: visible < count ? `${visible} shown` : undefined }] : [];
-    }),
+    ...supplyRoleCounts(data, views, options).map(({ role, counterparties, locked }) => ({ id: role, label: ROLE_PLURALS[role], value: String(counterparties),
+      color: ROLE_COLORS[role], detail: locked ? `+${locked} locked` : undefined })),
   ];
 }
 
-/** The share as a bar on a 0 to 100% scale, the figure, and what it is a share of. */
-function ShareCell({ row, focusId, width, selected }: { row: SupplyRow; focusId?: string; width: number; selected: boolean }) {
+/**
+ * The share as a bar on a 0 to 100% scale, the figure, and what it is a share
+ * of. The basis shows whole or not at all: a column too narrow for it keeps
+ * the bar and figure, and the evidence view says the rest.
+ */
+function ShareCell({ row, focusId, width, bases, selected }: { row: SupplyRow; focusId?: string; width: number; bases: readonly number[]; selected: boolean }) {
   const colors = useThemeColors();
   const share = shareParts(row, focusId);
   if (!share) return <Text fg={colors.textMuted}>{""}</Text>;
-  if (width < 14) return <Text fg={selected ? colors.selectedText : colors.textBright} attributes={TextAttributes.BOLD}>{share.value}</Text>;
-  const barWidth = width >= 36 ? BAR_CELLS : Math.min(5, Math.max(3, width - 11));
+  const bar = shareBarCells(width, bases);
+  if (!bar) return <Text fg={selected ? colors.selectedText : colors.textBright} attributes={TextAttributes.BOLD}>{share.value}</Text>;
+  const basis = bar + SHARE_FIGURE_CELLS + 2 + displayWidth(share.basis) <= width;
   return <Box flexDirection="row" width={width} height={1} gap={1} overflow="hidden">
-    <RatioBar ratio={row.pctOfRevenue! / 100} width={barWidth} color={ROLE_COLORS[row.role]} track />
-    <Text fg={selected ? colors.selectedText : colors.textBright} attributes={TextAttributes.BOLD}>{share.value.padStart(5)}</Text>
-    <Text fg={selected ? colors.selectedText : colors.textDim}>{truncateToDisplayWidth(share.basis, Math.max(4, width - barWidth - 7))}</Text>
+    <RatioBar ratio={row.pctOfRevenue! / 100} width={bar} color={ROLE_COLORS[row.role]} track />
+    <Text fg={selected ? colors.selectedText : colors.textBright} attributes={TextAttributes.BOLD}>{share.value.padStart(SHARE_FIGURE_CELLS)}</Text>
+    {basis ? <Text fg={selected ? colors.selectedText : colors.textDim}>{share.basis}</Text> : null}
   </Box>;
 }
 
@@ -180,7 +216,8 @@ function SupplyView({ symbol, width, height, focused }: Pick<PaneProps, "width"
   const focusId = data?.entity?.id;
   const values = rows.filter((row) => nativeValue(row) !== null || row.usd !== null);
   const valueWidth = values.length ? Math.min(28, Math.max(...values.map((row) => displayWidth(disclosedValue(row).replace(/ (disclosed|derived)$/, ""))))) : null;
-  const columns = tableColumns(width, desktop, locked > 0, valueWidth);
+  const bases = rows.flatMap((row) => { const share = shareParts(row, focusId); return share ? [displayWidth(share.basis)] : []; });
+  const columns = tableColumns(width, desktop, locked > 0, valueWidth, bases);
   const renderCell = (entry: SectionedRow<Item>, column: DataTableColumn, _index: number, state: { selected: boolean }): DataTableCell => {
     if (!isSectionedItemRow(entry)) return { text: "" };
     const item = entry.item;
@@ -222,7 +259,7 @@ function SupplyView({ symbol, width, height, focused }: Pick<PaneProps, "width"
         <Text fg={ink ?? ROLE_COLORS[row.role]}>{` ${roleLabel(row.role)}`}</Text>
       </Box> };
       case "pct": return { text: percentage(row) === "--" ? "" : `${shareParts(row, focusId)?.value ?? ""} ${shareParts(row, focusId)?.basis ?? ""}`.trim(), value: row.pctOfRevenue,
-        content: <ShareCell row={row} focusId={focusId} width={column.width} selected={state.selected} /> };
+        content: <ShareCell row={row} focusId={focusId} width={column.width} bases={bases} selected={state.selected} /> };
       case "usd": return nativeValue(row) === null && row.usd === null ? { text: "", value: null }
         : { text: disclosedValue(row).replace(/ (disclosed|derived)$/, ""), value: row.nativeAmount != null ? row.nativeAmount * (row.nativeScale ?? 1) : row.usd, color: colors.text };
       case "fy": return { text: row.period, color: colors.textDim };
@@ -233,7 +270,7 @@ function SupplyView({ symbol, width, height, focused }: Pick<PaneProps, "width"
   if (graphTab) return <Box width={width} height={height} flexDirection="column">{strip}<SupplyGraphPane symbol={symbol} tab={savedTab as "graph" | "path"} width={width} height={Math.max(3, height - tabRows)} focused={focused} /></Box>;
   if (!data && isCloudSessionRequired(resource.error)) return <SignInWall placement="supply-chain-signin" action="view supply chain disclosures" needsVerification={session.needsVerification} />;
   const bodyHeight = Math.max(3, height - tabRows);
-  const figures = data ? supplyFigures(data, tab === "flow" ? ["says", "names"] : [view], options, tab === "flow") : [];
+  const figures = data ? supplyFigures(data, tab === "flow" ? ["says", "names"] : [view], options) : [];
   const tierFilter = { id: "tiers", label: "Evidence", kind: "multi" as const, emptyLabel: "Primary", values: options.tiers, options: TIER_OPTIONS, onChange: (value: string[]) => { setTiers(supplyOptions(value).tiers); setSelected(null); setOpen(null); } };
   const header = <Box flexDirection="column" flexShrink={0}>
     <QueryBar width={width} filters={[{ id: "direction", label: "Direction", inline: true, value: view,
@@ -263,7 +300,9 @@ function SupplyView({ symbol, width, height, focused }: Pick<PaneProps, "width"
         </Box> : <DataTableView<SectionedRow<Item>> columns={columns}
           items={items} focused={focused && !openRow} rootWidth={width} rootHeight={bodyHeight} rootBefore={header}
           selection={{ kind: "id", selectedId: selected?.id ?? null, getId: (entry) => entry.key, onChange: (id) => setSelected(id) }} getItemKey={(entry) => entry.key}
-          isNavigable={isSectionedItemRow} renderSectionHeader={renderSectionedRowHeader}
+          isNavigable={isSectionedItemRow}
+          // The placeholders stand for every locked disclosure; the header counts those, as the figures do.
+          renderSectionHeader={(entry) => entry.kind === "section" && entry.label === "Pro" ? { text: `Pro (${locked})` } : renderSectionedRowHeader(entry)}
           onActivate={(entry) => { if (isSectionedItemRow(entry)) entry.item.kind === "edge" ? navigate(entry.item.row) : openUpgrade(); }}
           renderCell={renderCell} sortColumnId={sort.column} sortDirection={sort.direction}
           onHeaderClick={(column) => setSort((old) => ({ column, direction: old.column === column && old.direction === "desc" ? "asc" : "desc" }))}

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

@@ -6,6 +6,9 @@ import { aggregateText, DEFAULT_SORT, matchTheme, memberPrice, percent, PERIOD_L
 const periods: HeadlessPaneColumn[] = THEME_PERIODS.map((key) => ({ key, header: PERIOD_LABELS[key], align: "right", format: (value) => percent(value as number | null) }));
 export const themesHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
+  // The pane's stored snapshot: 15-minute delayed prices, refreshed every 15 minutes. As in the pane,
+  // the payload's stale flags are historical; a snapshot over 30 minutes old is what reads stale.
+  freshness: { status: "delayed", delayMinutes: 15, maxAgeMinutes: 30, ignoreStaleFlags: true },
   argument: { kind: "free-text", optional: true, placeholder: "theme", description: "Theme name or keyword, such as nuclear; omit for all themes." },
   options: [],
   discovery: { aliases: ["THEM"], dataRequirements: ["Gloom Cloud stored equity snapshot"],