gloomberb 0.16.3 → 0.16.5

package/src/plugins/builtin/holders/report-header.ts

@@ -20,6 +20,16 @@ export interface HolderReportFacts {
   listingCurrency?: string | null;
   /** Left out when the report's closing line already carries it. */
   asOf?: string | null;
+  /**
+   * What the list is as of, in place of `asOf`: `as of <date>` when every
+   * row shares one report date, `latest period per holder` when they differ.
+   */
+  period?: string | null;
+  /**
+   * False when the list is not the source's largest holders but the few
+   * filers that report the line at all (a home line abroad): no "top".
+   */
+  ranked?: boolean;
   /** Rows printed. */
   shown: number;
   /** Rows the source returned, before any limit. */
@@ -34,15 +44,39 @@ export function moneyColumnHeader(label: string, currency?: string | null): stri
   return unit ? `${label} (${unit})` : label;
 }
 
-function holderCountText(shown: number, reported: number, total?: number | null): string {
+function holderCountText(shown: number, reported: number, total?: number | null, ranked = true): string {
   if (total != null && Number.isFinite(total) && total >= reported) {
     return `${shown.toLocaleString("en-US")} of ${total.toLocaleString("en-US")} holders`;
   }
   if (reported === 0) return "none reported";
+  // A home line's few filers are all there is, not a top of anything.
+  if (!ranked) return shown < reported ? `${shown} of ${reported} reported` : `${reported} ${reported === 1 ? "holder" : "holders"} reported`;
   // Without a total the source's list is its largest holders, cut where it cuts it.
   return shown < reported ? `${shown} of top ${reported} reported` : `top ${reported} reported`;
 }
 
+/**
+ * What a holder list is as of. Each holder's row is its latest filed
+ * period, so one date is claimed only when every row has it; rows of
+ * different quarters read `latest period per holder`, and an empty list
+ * keeps the source's date.
+ */
+export function holderListPeriod(
+  rows: ReadonlyArray<{ reportDate?: unknown }>,
+  asOf?: string | null,
+): string | null {
+  const dates = new Set(rows.flatMap((row) => typeof row.reportDate === "string" && row.reportDate ? [row.reportDate] : []));
+  if (dates.size > 1) return "latest period per holder";
+  const [only] = dates;
+  const date = only ?? asOf;
+  return date ? `as of ${date}` : null;
+}
+
+/** Whether a holder list's rows are of more than one report date. */
+export function holderPeriodsDiffer(rows: ReadonlyArray<{ reportDate?: unknown }>): boolean {
+  return holderListPeriod(rows) === "latest period per holder";
+}
+
 /** A venue the app knows by its short name (NasdaqGS is NASDAQ); any other as the source wrote it. */
 function venueLabel(exchange?: string | null): string {
   const canonical = canonicalExchange(exchange ?? "");
@@ -51,15 +85,15 @@ function venueLabel(exchange?: string | null): string {
 
 /** What the list is, after the listing is named: its unit, date and how much of it is shown. */
 export function holderListFacts(
-  facts: Pick<HolderReportFacts, "currency" | "listingCurrency" | "asOf" | "shown" | "reported" | "total">,
+  facts: Pick<HolderReportFacts, "currency" | "listingCurrency" | "asOf" | "period" | "shown" | "reported" | "total" | "ranked">,
 ): string[] {
   const unit = currencyUnitLabel(facts.currency);
   // Dollars on a London line: say they are the values' unit, not the listing's.
   const otherUnit = unit && facts.listingCurrency?.trim() && facts.listingCurrency.trim() !== facts.currency?.trim();
   return [
     otherUnit ? `values in ${unit}` : unit,
-    facts.asOf ? `as of ${facts.asOf}` : "",
-    holderCountText(facts.shown, facts.reported, facts.total),
+    facts.period ?? (facts.asOf ? `as of ${facts.asOf}` : ""),
+    holderCountText(facts.shown, facts.reported, facts.total, facts.ranked),
   ].filter(Boolean);
 }
 
@@ -132,5 +166,6 @@ export function nonUsHolderCaveat(exchange?: string | null, currency?: string |
   if (!isNonUsHolderListing(exchange, currency)) return null;
   const canonical = canonicalExchange(exchange ?? "");
   const venue = resolveExchangeTimeZone(canonical) ? canonical : "local";
-  return `Positions come from institutional filings (mostly US 13F), not the ${venue} share register.`;
+  // Few filers report a line abroad, so a small position can lead the list.
+  return `Positions come from institutional filings (mostly US 13F), not the ${venue} share register, so the line's largest holders may be missing.`;
 }

package/src/plugins/builtin/holders/report-rows.ts

@@ -0,0 +1,240 @@
+import type { HeadlessPaneColumn } from "../../../types/plugin";
+import type { HolderData, ShareBasis } from "../../../types/financials";
+import { formatCompact, formatPercentRaw } from "../../../utils/format";
+import {
+  displayDate,
+  formatMoneyCompact,
+  formatPercentHeld,
+  formatSignedCompact,
+  holderPercent,
+  holderValueCurrency,
+  resolveHolderOwnershipPercent,
+} from "./format";
+import {
+  holderListPeriod,
+  holderPeriodsDiffer,
+  holderShareBasisMarker,
+  holderShareBasisNote,
+  holderValueBasis,
+  holdersHeaderLine,
+  moneyColumnHeader,
+  nonUsHolderCaveat,
+  sharedReportDate,
+} from "./report-header";
+import { buildRows, DEFAULT_SORT, sortRows } from "./table-model";
+import type { HolderColumnId, SortPreference } from "./types";
+
+/**
+ * A holder as `holders` and `fn HDS` report it; the keys are the JSON
+ * contract. `value` is in `currency`, the values' own currency; the percents
+ * are in percent (0.59 is 0.59% of the shares outstanding, 13.15 a 13.15%
+ * change on the quarter). A figure the source did not give is null.
+ */
+export interface HolderReportRow {
+  name: string;
+  ownerType: string;
+  value: number | null;
+  shares: number | null;
+  changeShares: number | null;
+  changePercent: number | null;
+  percentHeld: number | null;
+  reportDate: string | null;
+  currency: string;
+  shareBasis: ShareBasis | null;
+  [key: string]: unknown;
+}
+
+/** 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";
+const num = (value: unknown) => (typeof value === "number" && Number.isFinite(value) ? value : null);
+
+/**
+ * The HDS report's columns, which `holders --csv` and `--json` share. CSV
+ * reads `format`, so a value drawn as a plain figure exports its full number
+ * under a header naming the unit (`Mkt value (USD)`, `Held (%)`); the text
+ * report draws `textFormat`, with the currency sign and `<0.01%`.
+ */
+export const HOLDER_REPORT_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "name", header: "Holder" },
+  { key: "ownerType", header: "Type" },
+  {
+    key: "value",
+    header: "Mkt value",
+    align: "right",
+    format: (value) => num(value) == null ? "-" : formatCompact(num(value)!),
+    textFormat: (value, row) => formatMoneyCompact(num(value) ?? undefined, String(row.currency ?? "USD")),
+  },
+  {
+    key: "shares",
+    header: "Amount",
+    align: "right",
+    format: (value) => num(value) == null ? "-" : formatCompact(num(value)!),
+  },
+  {
+    key: BASIS_COLUMN_KEY,
+    header: "Basis",
+    format: (_value, row) => holderShareBasisMarker(row),
+  },
+  {
+    key: "changeShares",
+    header: "Chg",
+    align: "right",
+    format: (value) => formatSignedCompact(num(value) ?? undefined),
+  },
+  {
+    key: "changePercent",
+    header: "Chg%",
+    align: "right",
+    format: (value) => num(value) == null ? "-" : formatPercentRaw(num(value)!),
+  },
+  {
+    key: "percentHeld",
+    header: "Held",
+    align: "right",
+    format: (value) => num(value) == null ? "-" : `${num(value)!.toFixed(2)}%`,
+    textFormat: (value) => formatPercentHeld(num(value)),
+  },
+  {
+    key: "reportDate",
+    header: "Period",
+    format: (value) => displayDate(typeof value === "string" ? value : undefined),
+  },
+];
+
+/** `--sort` values, the same for `holders` and `fn HDS`. */
+export const HOLDER_SORT_KEYS: Record<string, HolderColumnId> = {
+  holder: "holder",
+  value: "value",
+  shares: "shares",
+  change: "changeShares",
+  "change-percent": "changePercent",
+  held: "percentHeld",
+  date: "reportDate",
+};
+
+/**
+ * Every holder of the list, largest value first unless another sort is
+ * asked for, with the stake and change in percent. A holder without a value
+ * sorts after those with one, whichever the direction. `ownerTypes` keeps
+ * only those kinds (`insider`, `13f`).
+ */
+export function holderReportRows(
+  data: HolderData,
+  {
+    marketCap,
+    sort = DEFAULT_SORT,
+    ownerTypes,
+  }: { marketCap?: number; sort?: SortPreference; ownerTypes?: ReadonlySet<string> } = {},
+): HolderReportRow[] {
+  const holders = ownerTypes ? data.holders.filter((holder) => ownerTypes.has(holder.ownerType)) : data.holders;
+  // The values' own currency: dollars from the 13F filings on a London line.
+  const currency = holderValueCurrency(data, "USD")!;
+  return sortRows(buildRows({ ...data, holders }), sort, marketCap).map((row) => ({
+    name: row.name,
+    ownerType: row.ownerType,
+    value: row.value ?? null,
+    shares: row.shares ?? null,
+    changeShares: row.changeShares ?? null,
+    changePercent: holderPercent(row.changePercent),
+    percentHeld: holderPercent(resolveHolderOwnershipPercent(row, marketCap)),
+    reportDate: row.reportDate ?? null,
+    currency,
+    shareBasis: row.shareBasis ?? null,
+  }));
+}
+
+/** The report dates of the rows, newest first: one when the list is of one quarter. */
+export function holderReportDates(rows: readonly HolderReportRow[]): string[] {
+  return [...new Set(rows.flatMap((row) => row.reportDate ? [row.reportDate] : []))].sort().reverse();
+}
+
+/** What the JSON rows' numbers are in, for `metadata.units`. */
+export function holderReportUnits(valueCurrency: string): Record<string, string> {
+  return { value: valueCurrency, changePercent: "%", percentHeld: "%" };
+}
+
+/** Whether any holder carries the quarter's change; many sources report none. */
+function holderChangeReported(rows: readonly HolderReportRow[]): boolean {
+  return rows.some((row) => row.changeShares != null || row.changePercent != null);
+}
+
+/**
+ * The report's columns for these rows: the change columns only when a row
+ * has a change, the basis column only when a row is held as receipts, and
+ * the value column named with its currency.
+ */
+export function holderReportColumns(rows: readonly HolderReportRow[], valueCurrency: string | null | undefined): HeadlessPaneColumn[] {
+  const changeReported = holderChangeReported(rows);
+  const marked = rows.some((row) => holderShareBasisMarker(row));
+  return HOLDER_REPORT_COLUMNS
+    .filter((column) => changeReported || !CHANGE_COLUMN_KEYS.has(column.key))
+    .filter((column) => marked || column.key !== BASIS_COLUMN_KEY)
+    .map((column) => column.key === "value" ? { ...column, header: moneyColumnHeader(column.header, valueCurrency) } : column);
+}
+
+/**
+ * The lines above the HDS table, which `holders --csv` also closes with: the
+ * listing, unit and count, how a value was reached (and where the change is
+ * when the source gives none), and what the positions and shares are.
+ */
+export function holderReportNotices({
+  data,
+  requested,
+  shown,
+  reported,
+  total,
+  sort = DEFAULT_SORT,
+}: {
+  data: HolderData;
+  /** The symbol as asked for, which `fn 13F` takes. */
+  requested: string;
+  shown: readonly HolderReportRow[];
+  /** Holders on the list before a limit. */
+  reported: number;
+  total: number | null;
+  sort?: SortPreference;
+}): { notices: string[]; valueBasis: string; positionsBasis: string | null; changeReported: boolean } {
+  const valueCurrency = holderValueCurrency(data, "USD")!;
+  const changeReported = holderChangeReported(shown);
+  const valueBasis = holderValueBasis(sharedReportDate(shown), data.valueBasis, valueCurrency);
+  const positionsBasis = shown.length > 0 ? nonUsHolderCaveat(data.exchange, data.currency ?? "USD") : null;
+  // The title names the ticker and the closing line carries the as-of date,
+  // which is one date only when every row has it.
+  const header = holdersHeaderLine({
+    name: data.name,
+    symbol: data.symbol && data.symbol !== requested ? data.symbol : null,
+    exchange: data.exchange,
+    currency: valueCurrency,
+    listingCurrency: data.currency,
+    period: holderPeriodsDiffer(shown) ? holderListPeriod(shown) : null,
+    shown: shown.length,
+    reported,
+    total,
+    ranked: !positionsBasis,
+  });
+  const basis = shown.length === 0 ? null : [
+    `Mkt value = ${valueBasis}.`,
+    changeReported ? "" : `Change vs prior quarter: not reported by this source; see fn 13F ${requested}`,
+  ].filter(Boolean).join(" ");
+  return {
+    notices: [header, basis, positionsBasis, holderShareBasisNote(data, shown), unvaluedHoldersNote(shown, sort)]
+      .filter((line): line is string => !!line),
+    valueBasis,
+    positionsBasis,
+    changeReported,
+  };
+}
+
+/**
+ * Holders the list gives no value for (a home line's position its filing
+ * could not tie to a priced security) sort after every valued one, and a
+ * value-ordered report says so rather than ranking them silently.
+ */
+export function unvaluedHoldersNote(rows: readonly HolderReportRow[], sort: SortPreference = DEFAULT_SORT): string | null {
+  if (sort.columnId !== "value") return null;
+  const unvalued = rows.filter((row) => row.value == null).length;
+  if (unvalued === 0 || unvalued === rows.length) return null;
+  return `${unvalued} ${unvalued === 1 ? "holder has" : "holders have"} no value and ${unvalued === 1 ? "is" : "are"} listed last.`;
+}

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

@@ -1,16 +1,19 @@
-import type { DataProvider, SecFilingItem } from "../../../types/data-provider";
+import type { DataProvider } from "../../../types/data-provider";
 import { parseInsiderFiling, type ParsedInsiderFiling } from "./model";
 import { isInsiderForm } from "./insider-data";
+import { filesAsForeignPrivateIssuer } from "./issuer";
 
-async function loadInsiderFilings(
-  provider: DataProvider,
-  symbol: string,
-  count: number,
-  exchange = "",
-): Promise<SecFilingItem[]> {
-  if (!provider.getSecFilings) throw new Error("Insider filing data unavailable");
-  const filings = await provider.getSecFilings(symbol, count, exchange);
-  return filings.filter((filing) => isInsiderForm(filing.form));
+// Recent EDGAR dumps cap at 1,000 mixed forms; older archives are read until
+// this many filings or the company's history ends.
+const SEC_FILING_SCAN_LIMIT = 20_000;
+
+export interface InsiderFilingsLoad {
+  /** The rows of the company's own Form 4 filings, newest first. */
+  parsed: ParsedInsiderFiling[];
+  /** Every Form 4 listed was read, none is the company's own, and it reports as a foreign private issuer. */
+  foreignPrivateIssuer: boolean;
+  /** The SEC lists no filing of any form for the company. */
+  noFilings: boolean;
 }
 
 function throwIfAborted(signal: AbortSignal | undefined): void {
@@ -18,29 +21,41 @@ function throwIfAborted(signal: AbortSignal | undefined): void {
   throw signal.reason instanceof Error ? signal.reason : new Error("Insider filing load was aborted.");
 }
 
+/**
+ * Reads the company's Form 4 filings newest first, one at a time, until
+ * `limit` of them are its own. A form it filed as an owner of another
+ * company's shares is read and left out, so a list of only those is read to
+ * the end before it can say there are none.
+ */
 export async function loadParsedInsiderFilings(
   provider: DataProvider,
   symbol: string,
   options: { limit: number; exchange?: string; signal?: AbortSignal },
-): Promise<ParsedInsiderFiling[]> {
+): Promise<InsiderFilingsLoad> {
+  if (!provider.getSecFilings) throw new Error("Insider filing data unavailable");
   if (!provider.getSecFilingContent) throw new Error("Insider filing content unavailable");
-  const filings = (await loadInsiderFilings(
-    provider,
-    symbol,
-    20_000,
-    options.exchange,
-  )).slice(0, options.limit);
+  const filings = await provider.getSecFilings(symbol, SEC_FILING_SCAN_LIMIT, options.exchange ?? "");
 
   const parsed: ParsedInsiderFiling[] = [];
+  let own = 0;
   for (const filing of filings) {
+    if (own >= options.limit) break;
+    if (!isInsiderForm(filing.form)) continue;
     throwIfAborted(options.signal);
+    let content: string | null;
     try {
-      const content = await provider.getSecFilingContent(filing);
-      parsed.push(...parseInsiderFiling(filing, content));
+      content = await provider.getSecFilingContent(filing);
     } catch {
       throwIfAborted(options.signal);
+      // An unread filing may be the company's own; it stays as a row that says so.
       parsed.push({ filing, transaction: null, isLoading: false });
+      own += 1;
+      continue;
     }
+    const entries = parseInsiderFiling(filing, content);
+    if (entries.length === 0) continue;
+    parsed.push(...entries);
+    own += 1;
   }
-  return parsed;
+  return { parsed, foreignPrivateIssuer: own === 0 && filesAsForeignPrivateIssuer(filings), noFilings: filings.length === 0 };
 }

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

@@ -3,9 +3,11 @@ import type {
   HeadlessPaneContext,
   HeadlessPaneDefinition,
   HeadlessPaneLoadArgs,
+  HeadlessPaneRow,
 } from "../../../types/plugin";
 import { formatCompact, formatCurrency } from "../../../utils/format";
-import { loadParsedInsiderFilings } from "./client";
+import { loadParsedInsiderFilings, type InsiderFilingsLoad } from "./client";
+import { insiderEmptyNotice } from "./issuer";
 import {
   buildInsiderRows,
   buildInsiderSummary,
@@ -15,9 +17,12 @@ import {
   matchesInsiderTypeFilter,
   type ParsedInsiderFiling,
 } from "./model";
-import { relevantInsiderAmendments } from "./amendments";
+import { isAmendedInsiderFiling, relevantInsiderAmendments } from "./amendments";
 import { formatInsiderName } from "./display";
 import { SEC_FILINGS } from "../shared/report-freshness";
+import { resolveHeadlessIssuerListing } from "../shared/headless-market-data";
+import { noSecReportsNotice } from "../../../utils/sec";
+import { parsePublicTickerKey } from "../../../utils/exchanges";
 
 const INSIDER_COLUMNS: HeadlessPaneColumn[] = [
   { key: "form", header: "Form" },
@@ -62,15 +67,23 @@ const INSIDER_COLUMNS: HeadlessPaneColumn[] = [
     align: "right",
     format: (value) => value == null ? "-" : `$${formatCompact(Number(value))}`,
   },
+  // An amendment's original date, remarks and footnotes, under the amendment's own row.
+  { key: "note", header: "Note", underRow: true, format: (value) => typeof value === "string" ? value : "" },
 ];
 
+/** What a Form 4/A says about itself, for its last row in the report. */
+function amendmentNote(entry: ParsedInsiderFiling): string {
+  const original = entry.disclosure?.originalFilingDate;
+  return [original ? `Original filed ${original}` : "", ...buildInsiderDisclosureText(entry).split("\n")].filter(Boolean).join("\n");
+}
+
 export interface InsiderHeadlessDependencies {
   loadParsed(
     symbol: string,
     limit: number,
     args: HeadlessPaneLoadArgs,
     ctx: HeadlessPaneContext,
-  ): Promise<ParsedInsiderFiling[]>;
+  ): Promise<InsiderFilingsLoad>;
 }
 
 const defaultDependencies: InsiderHeadlessDependencies = {
@@ -80,6 +93,17 @@ const defaultDependencies: InsiderHeadlessDependencies = {
   }),
 };
 
+/**
+ * "CAR Group (ASX) files no SEC reports." for a listing abroad the SEC lists
+ * nothing for, as `filings` says it; null for a US listing or a symbol with no
+ * venue, whose empty list is only no Form 4.
+ */
+async function noSecReportsEmpty(ctx: HeadlessPaneContext, key: string): Promise<string | null> {
+  const listing = await resolveHeadlessIssuerListing(ctx, key);
+  if (!listing.exchange) return null;
+  return noSecReportsNotice({ symbol: parsePublicTickerKey(key).symbol, exchange: listing.exchange, name: listing.name ?? null });
+}
+
 export function createInsiderHeadless(
   dependencies: InsiderHeadlessDependencies = defaultDependencies,
 ): HeadlessPaneDefinition<"rows"> {
@@ -113,7 +137,7 @@ export function createInsiderHeadless(
       {
         key: "limit",
         aliases: ["count", "rows"],
-        description: "Maximum Form 4 and Form 4/A filings to parse.",
+        description: "Maximum of the company's own Form 4 and Form 4/A filings to parse.",
         type: "integer",
         defaultValue: 20,
         minimum: 1,
@@ -125,7 +149,9 @@ export function createInsiderHeadless(
     async load(args, ctx) {
       const symbol = args.symbols[0]!;
       const limit = Number(args.options.limit);
-      const parsed = await dependencies.loadParsed(symbol, limit, args, ctx);
+      const { parsed, foreignPrivateIssuer, noFilings } = await dependencies.loadParsed(symbol, limit, args, ctx);
+      const empty = parsed.length > 0 ? null
+        : (noFilings ? await noSecReportsEmpty(ctx, symbol) : null) ?? insiderEmptyNotice(foreignPrivateIssuer);
       const name = String(args.options.name ?? "").trim().toLocaleLowerCase();
       const type = isInsiderTypeFilter(args.options.type) ? args.options.type : "all";
       const owned = name
@@ -136,8 +162,16 @@ export function createInsiderHeadless(
       const incomplete = [...new Set(buildInsiderRows(parsed)
         .filter((row) => row.status !== "parsed" && row.status !== "disclosure")
         .map((row) => row.accessionNumber))];
+      // A filing's lines sit together, so its note goes once, under the last of them.
+      const rows: HeadlessPaneRow[] = buildInsiderRows(filtered, parsed).map((row, index) => {
+        const entry = filtered[index]!;
+        const last = filtered[index + 1]?.filing.accessionNumber !== entry.filing.accessionNumber;
+        return isAmendedInsiderFiling(entry) && last ? { ...row, note: amendmentNote(entry) || null } : row;
+      });
       return {
-        rows: buildInsiderRows(filtered, parsed),
+        rows,
+        // Nothing at all: the company has no Form 4 of its own, which is the whole answer.
+        ...(empty ? { empty, unavailableSymbols: [] } : {}),
         errors: [
           ...incomplete.map((accessionNumber) => `${accessionNumber}: Form 4 transactions are unavailable or incomplete.`),
           ...amendments.map((scope) => `${scope.accessionNumber}: Form 4/A is unreconciled; affected transaction totals are unavailable.`),
@@ -146,11 +180,7 @@ export function createInsiderHeadless(
           symbol,
           summary: buildInsiderSummary(owned, Date.now(), parsed),
           amendments,
-          notices: amendments.map((scope) => {
-            const entry = parsed.find(({ filing }) => filing.accessionNumber === scope.accessionNumber)!;
-            return [`Form 4/A ${scope.accessionNumber}${scope.originalFilingDate ? ` | Original filed ${scope.originalFilingDate}` : ""}`,
-              buildInsiderDisclosureText(entry)].filter(Boolean).join("\n");
-          }),
+          foreignPrivateIssuer,
           parsed: new Set(parsed.filter(({ transaction }) => transaction != null).map(({ filing }) => filing.accessionNumber)).size,
           transactions: filtered.filter(({ transaction }) => transaction != null).length,
           requested: limit,

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

@@ -22,7 +22,8 @@ import {
   type StatItem,
 } from "../../../components";
 import { useDebouncedPluginPaneState, usePluginPaneState } from "../../runtime";
-import { isUsEquityTicker } from "../../../utils/sec";
+import { mayBeSecEquityListing, mayBeUsEquityTicker, noSecReportsNotice, nonUsSecListingVenue } from "../../../utils/sec";
+import { parsePublicTickerKey } from "../../../utils/exchanges";
 import { formatCompact } from "../../../utils/format";
 import { nextHeaderSort } from "../../../utils/sort-values";
 import { formatShortDate } from "../../../utils/datetime-format";
@@ -48,6 +49,7 @@ import {
 import { formatInsiderName } from "./display";
 import { insiderHeadless } from "./headless";
 import { isInsiderForm } from "./insider-data";
+import { filesAsForeignPrivateIssuer, insiderEmptyNotice, isOtherIssuerFiling } from "./issuer";
 import { relevantInsiderAmendments } from "./amendments";
 import { usePaneTickerIdentity } from "../../../state/hooks/pane-ticker";
 import {
@@ -130,7 +132,9 @@ function InsiderView({ width, height, focused }: { width: number; height: number
     [setOpenItemIdState],
   );
   const [sort, setSort] = useState<StackSortPreference<InsiderColumnId>>({ columnId: "date", direction: "desc" });
-  const eligibleTicker = isUsEquityTicker(ticker);
+  const eligibleTicker = mayBeSecEquityListing(ticker);
+  // A listing abroad is looked up by its company; an empty list means it files nothing with the SEC.
+  const abroadVenue = ticker ? nonUsSecListingVenue(ticker.metadata.ticker, ticker.metadata.exchange) : null;
   const instrument = instrumentFromTicker(ticker, ticker?.metadata.ticker ?? null);
 
   const filingsEntry = useSecFilingsQuery(
@@ -185,6 +189,17 @@ function InsiderView({ width, height, focused }: { width: number; height: number
     scopeKey: `${ticker?.metadata.ticker ?? "none"}:${ticker?.metadata.exchange ?? ""}`,
     targets: visibleForm4Filings,
   });
+  // The list also holds the Form 4s the company filed as an owner of another
+  // company's shares, which only their documents tell apart. Until one of its
+  // own is read, the pages are read on to the end, so a list of none says so.
+  const ownerFilingsShown = useMemo(() => visibleForm4Filings.some((filing) => (
+    isOtherIssuerFiling(filing, contentMap.get(filing.accessionNumber))
+  )), [contentMap, visibleForm4Filings]);
+  const ownFilingShown = useMemo(() => visibleForm4Filings.some((filing) => (
+    contentMap.has(filing.accessionNumber) && !isOtherIssuerFiling(filing, contentMap.get(filing.accessionNumber))
+  )), [contentMap, visibleForm4Filings]);
+  const searchingOwn = !ownFilingShown && pendingCount === 0 && shownCount < form4Filings.length;
+  const noOwnFilings = !loading && !ownFilingShown && pendingCount === 0 && shownCount >= form4Filings.length;
 
   const allParsed: ParsedFiling[] = useMemo(() => visibleForm4Filings.flatMap((filing) => {
     const hasContent = contentMap.has(filing.accessionNumber);
@@ -223,13 +238,13 @@ function InsiderView({ width, height, focused }: { width: number; height: number
   // load here until it fills a page, back to a year at most.
   const oldestShown = visibleForm4Filings[visibleForm4Filings.length - 1]?.filingDate;
   const oldestShownTime = oldestShown ? new Date(oldestShown).getTime() : Number.NaN;
-  const wantsOlderFilings = (typeFilter !== "all" || nameFilter != null)
+  const wantsOlderFilings = (typeFilter !== "all" || nameFilter != null || ownerFilingsShown)
     && shown.length < Math.max(FORM4_PAGE_SIZE, height)
     && shownCount < Math.min(form4Filings.length, AUTO_FILL_FILING_CAP)
     && oldestShownTime >= Date.now() - AUTO_FILL_DAYS * DAY_MS;
   useEffect(() => {
-    if (wantsOlderFilings && pendingCount === 0) loadNextPage();
-  }, [loadNextPage, pendingCount, shownCount, wantsOlderFilings]);
+    if (searchingOwn || (wantsOlderFilings && pendingCount === 0)) loadNextPage();
+  }, [loadNextPage, pendingCount, searchingOwn, shownCount, wantsOlderFilings]);
 
   const summary = useMemo(() => buildInsiderSummaryFigures(parsed, Date.now(), allParsed), [parsed, allParsed]);
   // A page loading in on scroll clears the totals until it is read; the last
@@ -353,15 +368,17 @@ function InsiderView({ width, height, focused }: { width: number; height: number
   if (authWall) return <SignInWall placement="insider-signin" action="view insider transactions" needsVerification={cloudSession.needsVerification} />;
   if (loading && allFilings.length === 0) return <Spinner label="Loading insider filings..." />;
   if (error && allFilings.length === 0) return <EmptyState title="Insider filings unavailable." message={error} />;
-  if (!loading && form4Filings.length === 0) {
-    return renderFilingNotice(`No Form 4 filings found for ${ticker.metadata.ticker}.`, width);
+  if (noOwnFilings) {
+    return renderFilingNotice(abroadVenue && allFilings.length === 0
+      ? noSecReportsNotice({ symbol: parsePublicTickerKey(ticker.metadata.ticker).symbol, exchange: abroadVenue, name: ticker.metadata.name ?? null })
+      : insiderEmptyNotice(filesAsForeignPrivateIssuer(allFilings)), width);
   }
 
   // Until a filing is read there is nothing to say; after that the empty
   // list says how far back the filings it has read go, while older ones load.
   const oldestRead = allParsed.findLast((entry) => !entry.isLoading)?.filing.filingDate;
   const since = oldestRead ? ` since ${formatShortDate(oldestRead, { utc: true })}` : "";
-  const emptyTitle = typeCounts.all === 0 && (pendingCount > 0 || wantsOlderFilings)
+  const emptyTitle = typeCounts.all === 0 && (pendingCount > 0 || wantsOlderFilings || searchingOwn)
     ? "Loading Form 4 transactions..."
     : typeFilter === "trades"
       ? `No open-market buys or sells${nameFilter ? " by this insider" : ""}${since}.`
@@ -458,7 +475,7 @@ export const insiderModule: PluginModule = {
         description: "Insider transaction activity for the selected ticker.",
         keywords: ["insider", "form 4", "ownership", "transactions", "ins"],
         shortcut: "INS",
-        canCreate: (_context, options) => !options?.ticker || isUsEquityTicker(options.ticker),
+        canCreate: (_context, options) => !options?.ticker || mayBeSecEquityListing(options.ticker),
       }),
       headless: insiderHeadless,
     },
@@ -471,7 +488,7 @@ export const insiderModule: PluginModule = {
       order: 47,
       component: InsiderView,
       instruments: ["equity"],
-      isVisible: ({ ticker }) => isUsEquityTicker(ticker),
+      isVisible: ({ ticker }) => mayBeUsEquityTicker(ticker),
     });
   },
 };

package/src/plugins/builtin/insider/insider-data.ts

@@ -104,6 +104,16 @@ function disclosureText(xml: string): string {
   return decodeHtmlEntities(xml.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim());
 }
 
+/**
+ * The CIK of the company whose shares the form reports, without leading
+ * zeros, or null when the document is not a Form 4 or names none.
+ */
+export function parseForm4IssuerCik(xml: string): string | null {
+  if (!/<(?:[\w.-]+:)?ownershipDocument(?:\s|>)/i.test(xml)) return null;
+  const cik = tagText(tagContent(xml, "issuer") ?? "", "issuerCik").replace(/^0+/, "");
+  return /^\d+$/.test(cik) ? cik : null;
+}
+
 export function parseForm4Disclosure(xml: string): InsiderFilingDisclosure | null {
   if (!/<(?:[\w.-]+:)?ownershipDocument(?:\s|>)/i.test(xml)) return null;
   const original = tagText(xml, "dateOfOriginalSubmission");