gloomberb 0.16.1 → 0.16.3

package/src/plugins/builtin/holders/beneficial-view.tsx

@@ -0,0 +1,241 @@
+import { useCallback, useMemo, useState } from "react";
+import { TextAttributes, useRendererHost } from "../../../ui";
+import {
+  DataTableView,
+  EmptyState,
+  PaneStatusBody,
+  usePaneFooter,
+  usePaneNoticeFooter,
+  type DataTableCell,
+  type DataTableKeyEvent,
+} from "../../../components";
+import { handleRefreshKey, loadingErrorFooterInfo } from "../../../components/data-table/table-pane";
+import { useAsyncResource } from "../../../react/async-resource";
+import { useAutoRefresh } from "../../../react/auto-refresh";
+import { colors, priceColor } from "../../../theme/colors";
+import { isPlainKey } from "../../../utils/keyboard";
+import { nextHeaderSort } from "../../../utils/sort-values";
+import { usePluginAppActions, usePluginPaneState } from "../../runtime";
+import { SignInWall } from "../cloud/auth-actions";
+import { isCloudSessionRequired, useResearchCloudSession } from "../shared/research-cloud-session";
+import { openSecFilingInPane } from "../sec/command-bar-search";
+import { cachedBeneficialOwners, loadBeneficialOwners } from "./beneficial-client";
+import { beneficialCoverageNotices, beneficialListUnreadable } from "./beneficial-report";
+import {
+  buildBeneficialColumns,
+  buildBeneficialRows,
+  DEFAULT_BENEFICIAL_SORT,
+  formatFilerName,
+  formatOwnerShares,
+  formatPercentOfClass,
+  formatPointChange,
+  sortBeneficialRows,
+  stakeMarker,
+  type BeneficialColumn,
+  type BeneficialColumnId,
+  type BeneficialOwnerRow,
+  type BeneficialSortPreference,
+} from "./beneficial-model";
+import type { Holder13FMatch } from "./thirteenf-match";
+import type { HolderRow } from "./types";
+
+const STALE_SEGMENT = { id: "stale", parts: [{ text: "stale", tone: "warning" as const }] };
+
+/**
+ * The 13D/G tab: who disclosed more than 5% of the class, the stake each
+ * filer's latest report gives and how it moved, one row per filer, joined to
+ * the Table tab's 13F holders for the quarter's action. A latest report is
+ * the latest disclosure, not today's position.
+ */
+export function BeneficialOwnersView({
+  focused,
+  width,
+  symbol,
+  holderRows,
+  fundMatches,
+  onCycleView,
+  onRefreshHolders,
+}: {
+  focused: boolean;
+  width: number;
+  symbol: string | null;
+  holderRows: readonly HolderRow[];
+  fundMatches: ReadonlyMap<string, Holder13FMatch>;
+  onCycleView: () => void;
+  onRefreshHolders: () => void;
+}) {
+  const rendererHost = useRendererHost();
+  const { createPaneFromTemplate } = usePluginAppActions();
+  const session = useResearchCloudSession();
+  const [sortPreference, setSortPreference] = usePluginPaneState<BeneficialSortPreference>(
+    "beneficialSort",
+    DEFAULT_BENEFICIAL_SORT,
+  );
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+
+  // A session change retries a request the sign-in wall was shown for.
+  const loader = useMemo(
+    () => symbol ? (force: boolean) => loadBeneficialOwners(symbol, force) : null,
+    [symbol, session.requestKey],
+  );
+  const resource = useAsyncResource(loader, {
+    initialData: () => symbol ? cachedBeneficialOwners(symbol) : null,
+    clearOnError: (error) => error instanceof Error && isCloudSessionRequired(error.message),
+  });
+  useAutoRefresh(resource.updatedAt, resource.load);
+  const payload = resource.data?.payload ?? null;
+
+  const rows = useMemo(
+    () => buildBeneficialRows(payload?.owners ?? [], holderRows, fundMatches),
+    [fundMatches, holderRows, payload],
+  );
+  const sortedRows = useMemo(() => sortBeneficialRows(rows, sortPreference), [rows, sortPreference]);
+  const columns = useMemo(() => buildBeneficialColumns(width), [width]);
+  const selectedRow = sortedRows.find((row) => row.id === selectedId) ?? sortedRows[0] ?? null;
+
+  const openFiling = useCallback((row: BeneficialOwnerRow | null | undefined) => {
+    if (!row || !symbol) return;
+    openSecFilingInPane({ createPaneFromTemplate }, symbol, row.filing.accessionNumber);
+  }, [createPaneFromTemplate, symbol]);
+
+  const openFilingUrl = useCallback(() => {
+    const url = selectedRow?.filing.filingUrl;
+    if (url) void rendererHost.openExternal(url);
+  }, [rendererHost, selectedRow]);
+
+  const refresh = useCallback(() => {
+    void resource.reload();
+    onRefreshHolders();
+  }, [onRefreshHolders, resource]);
+
+  const handleKeyDown = useCallback((event: DataTableKeyEvent) => {
+    if (handleRefreshKey(event, refresh, { stopPropagation: true })) return true;
+    if (isPlainKey(event, "s")) {
+      event.preventDefault?.();
+      event.stopPropagation?.();
+      onCycleView();
+      return true;
+    }
+    return false;
+  }, [onCycleView, refresh]);
+
+  const handleHeaderClick = useCallback((columnId: string) => {
+    setSortPreference((current) => nextHeaderSort(current, columnId as BeneficialColumnId, {
+      firstDirection: (id) => id === "filer" || id === "form" ? "asc" : "desc",
+    }));
+  }, [setSortPreference]);
+
+  const renderCell = useCallback((
+    row: BeneficialOwnerRow,
+    column: BeneficialColumn,
+    _index: number,
+    rowState: { selected: boolean },
+  ): DataTableCell => {
+    const { filing } = row;
+    // A report of zero reads as history; a stake under 5% is still a stake.
+    const exited = row.stake === "exited";
+    const tone = exited ? colors.textMuted : colors.text;
+    switch (column.id) {
+      case "filer":
+        return {
+          text: formatFilerName(filing.filerName, Math.max(0, filing.reportingPersons.length - 1), column.width),
+          value: filing.filerName,
+          color: exited ? colors.textMuted : rowState.selected ? colors.selectedText : colors.textBright,
+          attributes: exited ? undefined : TextAttributes.BOLD,
+        };
+      case "form":
+        return { text: row.formLabel, color: tone };
+      case "percentOfClass": {
+        // A column too narrow for `4.9% <5%` keeps the figure alone.
+        const marker = column.width >= formatPercentOfClass(row, { marker: true }).length;
+        return {
+          text: formatPercentOfClass(row, { marker }),
+          value: filing.percentOfClass,
+          color: row.stake === "holder" ? colors.textBright : stakeMarker(row.stake) ? colors.textDim : colors.text,
+        };
+      }
+      case "change":
+        return {
+          text: formatPointChange(row.changePoints),
+          value: row.changePoints,
+          color: row.changePoints == null || row.changePoints === 0 ? colors.textDim : priceColor(row.changePoints),
+        };
+      case "shares":
+        return { text: formatOwnerShares(filing.shares), value: filing.shares, color: tone };
+      case "eventDate":
+        return { text: filing.eventDate ?? "-", value: filing.eventDate, color: colors.textDim };
+      case "filingDate":
+        return { text: filing.filingDate, value: filing.filingDate, color: colors.textDim };
+      case "thirteenF": {
+        const action = row.thirteenF;
+        if (!action) return { text: "-", value: null, color: colors.textDim };
+        return { text: action.label, color: action.value === 0 ? colors.textDim : priceColor(action.value) };
+      }
+    }
+  }, []);
+
+  const authWall = !payload && isCloudSessionRequired(resource.error);
+  const error = authWall ? null : resource.error;
+  // Listed filings that could not be read are a failure, not "no filings".
+  const unreadable = !!payload && beneficialListUnreadable(payload);
+  const coverageNotices = useMemo(
+    () => unreadable ? [] : beneficialCoverageNotices(payload?.coverage),
+    [payload, unreadable],
+  );
+  usePaneNoticeFooter({
+    registrationId: "holders-13dg:coverage",
+    notices: coverageNotices,
+    focused,
+    title: "13D/13G coverage",
+  });
+  usePaneFooter("holders-13dg", () => ({
+    info: [
+      ...(payload?.asOf ? [{ id: "as-of", parts: [{ text: `as of ${payload.asOf.slice(0, 10)}`, tone: "muted" as const }] }] : []),
+      ...(payload && resource.data?.stale ? [STALE_SEGMENT] : []),
+      ...loadingErrorFooterInfo(resource.loading, payload ? error : null),
+    ],
+    hints: selectedRow?.filing.filingUrl
+      ? [{ id: "filing", key: "o", label: "pen filing", onPress: openFilingUrl }]
+      : [],
+  }), [error, openFilingUrl, payload, resource.data?.stale, resource.loading, selectedRow]);
+
+  if (!symbol) return <EmptyState title="No ticker selected." />;
+  if (authWall) {
+    return <SignInWall placement="holders-13dg-signin" action="view 13D/13G filings" needsVerification={session.needsVerification} />;
+  }
+
+  return (
+    <PaneStatusBody
+      loading={resource.loading && !payload}
+      error={!payload ? error
+        : unreadable ? `${payload.coverage?.filings ?? 0} filings are listed for ${symbol} but none could be read this time. A refresh retries them.`
+        : null}
+      subject="13D/13G filings"
+      empty={!!payload && sortedRows.length === 0}
+      emptyTitle={`No 13D/13G filings in the last 4 years for ${symbol}.`}
+    >
+      <DataTableView<BeneficialOwnerRow, BeneficialColumn>
+        focused={focused}
+        selection={{
+          kind: "id",
+          selectedId: selectedRow?.id ?? null,
+          getId: (row) => row.id,
+          onChange: (id) => setSelectedId(id),
+        }}
+        onActivate={openFiling}
+        onRootKeyDown={handleKeyDown}
+        resetScrollKey={symbol}
+        rootWidth={width}
+        columns={columns}
+        items={sortedRows}
+        sortColumnId={sortPreference.columnId}
+        sortDirection={sortPreference.direction}
+        onHeaderClick={handleHeaderClick}
+        getItemKey={(row) => row.id}
+        renderCell={renderCell}
+        selectedTextOverridesCellColor
+        emptyStateTitle={`No 13D/13G filings in the last 4 years for ${symbol}.`}
+      />
+    </PaneStatusBody>
+  );
+}

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

@@ -1,5 +1,6 @@
 import type { DataProvider, MarketDataRequestContext } from "../../../types/data-provider";
 import type { HolderData } from "../../../types/financials";
+import { holderStakeMarketCap, holderValueCurrency } from "./format";
 
 export async function loadHolderData(
   provider: DataProvider,
@@ -20,10 +21,6 @@ export async function loadHolderSnapshot(
     loadHolderData(provider, symbol, exchange),
     provider.getTickerFinancials(symbol, exchange).catch(() => null),
   ]);
-  const quoteMarketCap = financials?.quote?.marketCap;
-  const marketCap = financials?.quote?.currency && data.currency
-    && financials.quote.currency !== data.currency
-    ? undefined
-    : quoteMarketCap;
-  return { data, marketCap };
+  const quote = financials?.quote;
+  return { data, marketCap: holderStakeMarketCap(quote?.marketCap, quote?.currency, holderValueCurrency(data)) };
 }

package/src/plugins/builtin/holders/format.ts

@@ -1,4 +1,4 @@
-import type { HolderRecord } from "../../../types/financials";
+import type { HolderData, HolderRecord } from "../../../types/financials";
 import { formatCompact, formatPercent, formatPercentRaw } from "../../../utils/format";
 import type { HolderRow } from "./types";
 
@@ -16,15 +16,45 @@ export function formatMaybePercent(value: number | undefined): string {
   return Math.abs(value) <= 1 ? formatPercent(value) : formatPercentRaw(value);
 }
 
+/**
+ * The currency holder values are in. Gloom Cloud names it when it differs
+ * from the listing's (dollars from 13F filings on a London line); an older
+ * service priced them in the listing's currency.
+ */
+export function holderValueCurrency(
+  data: Pick<HolderData, "valueCurrency" | "currency"> | null | undefined,
+  fallback?: string,
+): string | undefined {
+  return data?.valueCurrency?.trim() || data?.currency?.trim() || fallback;
+}
+
+/**
+ * The market cap a holding's value can be divided by: only one in the
+ * values' own currency. A cap whose currency, or values whose currency, is
+ * not known is taken as it was before currencies were stated.
+ */
+export function holderStakeMarketCap(
+  marketCap: number | undefined,
+  marketCapCurrency: string | null | undefined,
+  valueCurrency: string | null | undefined,
+): number | undefined {
+  if (marketCap == null) return undefined;
+  if (marketCapCurrency && valueCurrency && marketCapCurrency !== valueCurrency) return undefined;
+  return marketCap;
+}
+
+/** The reported stake, else the value over a market cap `holderStakeMarketCap` allowed. */
 export function resolveHolderOwnershipPercent(row: Pick<HolderRecord, "percentHeld" | "value">, marketCap: number | undefined): number | undefined {
   if (row.percentHeld != null) return row.percentHeld;
   if (row.value == null || row.value < 0 || marketCap == null || marketCap <= 0) return undefined;
   return row.value / marketCap;
 }
 
+/** A stake too small for two decimals reads "<0.01%", not a zero. */
 export function formatHolderOwnershipPercent(value: number | undefined): string {
   if (value == null) return "-";
   const percent = Math.abs(value) <= 1 ? value * 100 : value;
+  if (percent > 0 && percent < 0.005) return "<0.01%";
   return `${percent.toFixed(2)}%`;
 }
 

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

@@ -12,11 +12,40 @@ import {
   formatMaybePercent,
   formatMoneyCompact,
   formatSignedCompact,
+  holderValueCurrency,
   resolveHolderOwnershipPercent,
 } from "./format";
 import { buildRows, sortRows } from "./table-model";
 import type { HolderData } from "../../../types/financials";
 import type { HolderColumnId } from "./types";
+import { SEC_FILINGS } from "../shared/report-freshness";
+import {
+  holderShareBasisMarker,
+  holderShareBasisNote,
+  holderValueBasis,
+  holdersHeaderLine,
+  moneyColumnHeader,
+  nonUsHolderCaveat,
+  sharedReportDate,
+} from "./report-header";
+
+/** Columns a source fills only when it reports the quarter's change. */
+const CHANGE_COLUMN_KEYS = new Set(["changeShares", "changePercent"]);
+/** Shown only when some row is held as depositary receipts, as on a home line abroad. */
+const BASIS_COLUMN_KEY = "shareBasis";
+import type { BeneficialOwnersPayload } from "../../../api-client/beneficial-owners";
+import { fetchBeneficialOwners, type BeneficialOwnersRequest } from "./beneficial-client";
+import type { BeneficialColumnId } from "./beneficial-model";
+import {
+  BENEFICIAL_REPORT_COLUMNS,
+  beneficialCoverageNotices,
+  beneficialListComplete,
+  beneficialListFacts,
+  beneficialRouteForm,
+  buildBeneficialReportRows,
+  HOLDER_FORMS,
+  parseHolderForm,
+} from "./beneficial-report";
 
 const HOLDER_COLUMNS: HeadlessPaneColumn[] = [
   { key: "name", header: "Holder" },
@@ -36,6 +65,11 @@ const HOLDER_COLUMNS: HeadlessPaneColumn[] = [
     align: "right",
     format: (value) => value == null ? "-" : formatCompact(Number(value)),
   },
+  {
+    key: BASIS_COLUMN_KEY,
+    header: "Basis",
+    format: (_value, row) => holderShareBasisMarker(row),
+  },
   {
     key: "changeShares",
     header: "Chg",
@@ -71,6 +105,17 @@ const SORT_COLUMNS: Record<string, HolderColumnId> = {
   date: "reportDate",
 };
 
+/** The same sort keys order the 13D/13G rows; `value` and `held` are the percent of class. */
+const BENEFICIAL_SORT_COLUMNS: Record<string, BeneficialColumnId> = {
+  holder: "filer",
+  value: "percentOfClass",
+  shares: "shares",
+  change: "change",
+  "change-percent": "thirteenF",
+  held: "percentOfClass",
+  date: "filingDate",
+};
+
 interface HolderSnapshot {
   data: HolderData;
   marketCap?: number;
@@ -82,17 +127,28 @@ export interface HoldersHeadlessDependencies {
     args: HeadlessPaneLoadArgs,
     ctx: HeadlessPaneContext,
   ): Promise<HolderSnapshot>;
+  loadBeneficialOwners(
+    symbol: string,
+    request: BeneficialOwnersRequest,
+    ctx: HeadlessPaneContext,
+  ): Promise<BeneficialOwnersPayload>;
 }
 
 const defaultDependencies: HoldersHeadlessDependencies = {
   loadSnapshot: (symbol, _args, ctx) => loadHolderSnapshot(ctx.marketData, symbol),
+  loadBeneficialOwners: (symbol, request, ctx) => fetchBeneficialOwners(symbol, request, {
+    client: ctx.apiClient,
+    signal: ctx.signal,
+  }),
 };
 
 export function createHoldersHeadless(
-  dependencies: HoldersHeadlessDependencies = defaultDependencies,
+  overrides: Partial<HoldersHeadlessDependencies> = {},
 ): HeadlessPaneDefinition<"rows"> {
+  const dependencies = { ...defaultDependencies, ...overrides };
   return {
     shape: "rows",
+    freshness: { ...SEC_FILINGS, basis: "13F filings" },
     argument: {
       kind: "ticker",
       placeholder: "ticker",
@@ -124,23 +180,81 @@ export function createHoldersHeadless(
       },
       {
         key: "view",
-        description: "Rendered pane view: the holder table or the ownership treemap.",
+        description: "Rendered pane view: the holder table, the ownership treemap or the 13D/13G beneficial owners.",
         type: "enum",
-        values: [{ value: "table" }, { value: "chart" }],
+        values: [{ value: "table" }, { value: "chart" }, { value: "13dg", aliases: ["beneficial"] }],
         defaultValue: "table",
         pluginState: { pluginId: "ticker-research", key: "viewMode" },
       },
+      {
+        key: "form",
+        description: "Rows: 13f for institutional holders, 13d or 13g for beneficial owners over 5% of the class (activists, crowding into large stakes), all for both kinds.",
+        type: "enum",
+        values: HOLDER_FORMS.map((value) => ({ value })),
+        defaultValue: "13f",
+      },
+      {
+        key: "history",
+        description: "With a 13d, 13g or all form, every report newest first instead of the latest per filer.",
+        type: "boolean",
+        defaultValue: false,
+      },
     ],
     columns: HOLDER_COLUMNS,
     describe: (args) => `Holders | ${args.symbols[0]}`,
     async load(args, ctx) {
       const symbol = args.symbols[0]!;
+      const requestedForm = parseHolderForm(args.options.form) ?? "13f";
+      // The 13D/G view reports what it shows when no form is asked for.
+      const form = requestedForm === "13f" && args.options.view === "13dg" ? "all" : requestedForm;
+      if (form !== "13f") {
+        const history = args.options.history === true;
+        const [payload, snapshot] = await Promise.all([
+          dependencies.loadBeneficialOwners(symbol, { form: beneficialRouteForm(form), history }, ctx),
+          // The 13F column is a join; the 13D/13G rows stand without it.
+          dependencies.loadSnapshot(symbol, args, ctx).catch(() => null),
+        ]);
+        const rows = buildBeneficialReportRows(payload, {
+          history,
+          holders: snapshot?.data ?? null,
+          sort: {
+            columnId: BENEFICIAL_SORT_COLUMNS[String(args.options.sort)] ?? "percentOfClass",
+            direction: args.options.order === "asc" ? "asc" : "desc",
+          },
+        });
+        const limited = rows.slice(0, Number(args.options.limit));
+        return {
+          columns: BENEFICIAL_REPORT_COLUMNS,
+          rows: limited,
+          // Reports that could not be read this time are missing from the rows.
+          complete: beneficialListComplete(payload),
+          freshness: { ...SEC_FILINGS, basis: "13D/13G filings", observedKey: "filingDate" },
+          metadata: {
+            symbol: payload.ticker || symbol,
+            name: payload.companyName || null,
+            cik: payload.cik || null,
+            form,
+            history,
+            asOf: payload.asOf,
+            coverage: payload.coverage,
+            notices: [
+              [payload.companyName || symbol, ...beneficialListFacts(payload, form, rows.length, history)].join(" · "),
+              ...beneficialCoverageNotices(payload.coverage),
+            ],
+            returned: limited.length,
+            total: rows.length,
+          },
+        };
+      }
       const { data, marketCap } = await dependencies.loadSnapshot(symbol, args, ctx);
       const currency = data.currency ?? "USD";
-      const rows = sortRows(buildRows(data), {
+      // A London line's values can be dollars from the 13F filings; they are labelled and formatted as such.
+      const valueCurrency = holderValueCurrency(data, currency)!;
+      const sorted = sortRows(buildRows(data), {
         columnId: SORT_COLUMNS[String(args.options.sort)] ?? "value",
         direction: args.options.order === "asc" ? "asc" : "desc",
-      }, marketCap)
+      }, marketCap);
+      const rows = sorted
         .slice(0, Number(args.options.limit))
         .map((row) => ({
           name: row.name,
@@ -151,16 +265,57 @@ export function createHoldersHeadless(
           changePercent: row.changePercent ?? null,
           percentHeld: resolveHolderOwnershipPercent(row, marketCap) ?? null,
           reportDate: row.reportDate ?? null,
-          currency,
+          currency: valueCurrency,
+          shareBasis: row.shareBasis ?? null,
         }));
+      const total = data.summary?.institutionsCount ?? null;
+      const changeReported = rows.some((row) => row.changeShares != null || row.changePercent != null);
+      const reportDate = sharedReportDate(rows);
+      const valueBasis = holderValueBasis(reportDate, data.valueBasis, valueCurrency);
+      const positionsBasis = rows.length > 0 ? nonUsHolderCaveat(data.exchange, currency) : null;
+      const shareBasisNote = holderShareBasisNote(data, rows);
+      const markedRows = rows.some((row) => holderShareBasisMarker(row));
+      // The title names the ticker and the closing line carries the as-of date.
+      const header = holdersHeaderLine({
+        name: data.name,
+        symbol: data.symbol && data.symbol !== symbol ? data.symbol : null,
+        exchange: data.exchange,
+        currency: valueCurrency,
+        listingCurrency: data.currency,
+        shown: rows.length,
+        reported: sorted.length,
+        total,
+      });
+      const basis = rows.length === 0 ? null : [
+        `Mkt value = ${valueBasis}.`,
+        changeReported ? "" : `Change vs prior quarter: not reported by this source; see fn 13F ${symbol}`,
+      ].filter(Boolean).join(" ");
       return {
+        // A change column that is empty on every row says nothing; the line above explains it once.
+        columns: HOLDER_COLUMNS
+          .filter((column) => changeReported || !CHANGE_COLUMN_KEYS.has(column.key))
+          .filter((column) => markedRows || column.key !== BASIS_COLUMN_KEY)
+          .map((column) => column.key === "value" ? { ...column, header: moneyColumnHeader(column.header, valueCurrency) } : column),
         rows,
         metadata: {
           symbol: data.symbol || symbol,
           name: data.name ?? null,
+          exchange: data.exchange ?? null,
           currency,
+          valueCurrency,
+          ...(data.isDepositaryReceipt != null ? { isDepositaryReceipt: data.isDepositaryReceipt } : {}),
+          ...(data.shareBasis ? { shareBasis: data.shareBasis } : {}),
+          ...(data.adrRatio != null ? { adrRatio: data.adrRatio } : {}),
           asOf: data.asOf ?? null,
           summary: data.summary ?? null,
+          shown: rows.length,
+          reported: sorted.length,
+          total,
+          truncated: rows.length < (total ?? sorted.length),
+          valueBasis,
+          changeReported,
+          positionsBasis,
+          notices: [header, basis, positionsBasis, shareBasisNote].filter((line): line is string => !!line),
         },
       };
     },

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

@@ -1,11 +1,12 @@
 import type { PluginModule } from "../plugin-module";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
+import { beneficialOwnersCache } from "./beneficial-client";
 import { holdersHeadless } from "./headless";
 import { HoldersView } from "./pane";
 
-
 export const holdersModule: PluginModule = {
   setup(ctx) {
+    beneficialOwnersCache.attach(ctx.persistence);
     ctx.registerTickerResearchTab({
       id: "holders",
       name: "Holders",
@@ -14,6 +15,9 @@ export const holdersModule: PluginModule = {
       instruments: ["equity"],
     });
   },
+  dispose() {
+    beneficialOwnersCache.reset();
+  },
 
   panes: [
     {
@@ -35,8 +39,11 @@ export const holdersModule: PluginModule = {
         id: "holders-pane",
         paneId: "holders",
         label: "Holders",
-        description: "Institutional holders for the selected ticker.",
-        keywords: ["holders", "ownership", "institutional", "owners", "hds"],
+        description: "Institutional holders from 13F filings, and 13D/13G beneficial owners: activist and passive stakes over 5% of the class.",
+        keywords: [
+          "holders", "ownership", "institutional", "owners", "hds",
+          "13d", "13g", "13d/g", "schedule 13d", "schedule 13g", "beneficial owners", "beneficial ownership", "activist", "activists",
+        ],
         shortcut: "HDS",
       }),
       headless: holdersHeadless,