gloomberb 0.13.3 → 0.14.0

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

@@ -8,11 +8,13 @@ import { instrumentFromTicker } from "../../../market-data/request-types";
 import { usePaneTicker } from "../../../state/app/context";
 import type { ScrollBoxRenderable } from "../../../ui";
 import { EmptyState, FeedDataTableStackView, Spinner, useExternalLinkFooter, useTableLoadMore, type FeedDataTableItem } from "../../../components";
-import { usePluginPaneState } from "../../runtime";
+import { useDebouncedPluginPaneState, usePluginPaneState } from "../../runtime";
 import { isUsEquityTicker } from "../../../utils/sec";
 import { truncateWithEllipsis as truncateText } from "../../../utils/text-wrap";
-import { parseForm4Xml } from "./insider-data";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
+import { isCloudSessionRequired, useResearchCloudSession } from "../shared/research-cloud-session";
+import { SignInWall } from "../cloud/auth-actions";
+import { getSharedMarketDataCoordinator } from "../../../market-data/coordinator";
 import {
   buildInsiderTransactionDetailBody,
   buildInsiderTransactionTitle,
@@ -23,9 +25,16 @@ import {
 import { useSecFilingContentCache } from "../sec/filing-content";
 import {
   buildInsiderSummary,
+  buildInsiderDisclosureText,
+  matchesInsiderOwner,
+  insiderTransactionId,
+  insiderReportedName,
+  parseInsiderFiling,
   type ParsedInsiderFiling as ParsedFiling,
 } from "./model";
 import { insiderHeadless } from "./headless";
+import { isInsiderForm } from "./insider-data";
+import { isAmendedInsiderFiling, relevantInsiderAmendments } from "./amendments";
 
 export { insiderHeadless } from "./headless";
 
@@ -35,38 +44,46 @@ const FORM4_PAGE_SIZE = 20;
 const SEC_FILING_SCAN_LIMIT = 20_000;
 
 function toFeedItems(parsed: ParsedFiling[]): FeedDataTableItem[] {
-  return parsed.map(({ filing, transaction, isLoading }) => {
+  return parsed.map((entry) => {
+    const { filing, transaction, isLoading } = entry;
+    const id = insiderTransactionId(entry);
+    const amendment = isAmendedInsiderFiling(entry);
+    const disclosureText = buildInsiderDisclosureText(entry);
     const filingMeta = [
       `Filed ${formatFilingShortDate(filing.filingDate)}`,
       `Accession ${filing.accessionNumber}`,
       formatFilingFormLabel(filing.form),
+      ...(amendment ? ["Unreconciled amendment"] : []),
+      ...(entry.disclosure?.originalFilingDate ? [`Original filed ${entry.disclosure.originalFilingDate}`] : []),
     ];
 
     if (!transaction) {
+      const title = isLoading ? `Loading ${formatFilingFormLabel(filing.form)} filing...`
+        : amendment && entry.disclosure ? "Form 4/A disclosure" : "Form 4 transaction unavailable";
       return {
-        id: filing.accessionNumber,
-        eyebrow: formatFilingFormLabel(filing.form),
-        title: isLoading ? "Loading Form 4 filing..." : "Form 4 transaction unavailable",
+        id,
+        eyebrow: insiderReportedName(entry) ?? formatFilingFormLabel(filing.form),
+        title,
         timestamp: filing.filingDate,
-        detailTitle: isLoading ? "Loading Form 4 filing..." : "Form 4 transaction unavailable",
+        detailTitle: insiderReportedName(entry) ?? title,
         detailMeta: filingMeta,
         detailBody: isLoading
           ? "Loading filing content..."
-          : "This Form 4 filing could not be parsed into a transaction summary.",
+          : disclosureText || (amendment && entry.disclosure ? "No transaction lines reported." : "This Form 4 filing could not be parsed into a transaction summary."),
       };
     }
 
     return {
-      id: filing.accessionNumber,
+      id,
       eyebrow: transaction.reportedName,
-      title: buildInsiderTransactionTitle(transaction),
-      timestamp: transaction.filingDate,
+      title: `${amendment ? "4/A · " : ""}${buildInsiderTransactionTitle(transaction)}`,
+      timestamp: transaction.filingDate ?? filing.filingDate,
       detailTitle: transaction.reportedName,
       detailMeta: [
         ...(transaction.title ? [transaction.title] : []),
         ...filingMeta,
       ],
-      detailBody: buildInsiderTransactionDetailBody(transaction),
+      detailBody: [disclosureText, buildInsiderTransactionDetailBody(transaction)].filter(Boolean).join("\n\n"),
     };
   });
 }
@@ -76,7 +93,11 @@ function InsiderView({ width, height, focused }: { width: number; height: number
   const tickerKey = ticker?.metadata.ticker ?? "none";
   const [selectedIdx, setSelectedIdx] = usePluginPaneState<number>(`insider:selectedIdx:${tickerKey}`, 0);
   const [nameFilter, setNameFilter] = usePluginPaneState<string | null>(`insider:nameFilter:${tickerKey}`, null);
-  const [openItemId, setOpenItemId] = useState<string | null>(null);
+  const [openItemId, setOpenItemIdState] = useDebouncedPluginPaneState<string | null>(`insider:openItemId:${tickerKey}`, null);
+  const setOpenItemId = useCallback(
+    (itemId: string | null) => setOpenItemIdState(itemId, { immediate: true }),
+    [setOpenItemIdState],
+  );
   const eligibleTicker = isUsEquityTicker(ticker);
   const instrument = instrumentFromTicker(ticker, ticker?.metadata.ticker ?? null);
 
@@ -85,7 +106,7 @@ function InsiderView({ width, height, focused }: { width: number; height: number
   );
   const allFilings = useResolvedEntryValue(filingsEntry) ?? [];
   const form4Filings = useMemo(
-    () => allFilings.filter((f) => f.form.trim() === "4"),
+    () => allFilings.filter((f) => isInsiderForm(f.form)),
     [allFilings],
   );
   const [visibleCount, setVisibleCount] = useState(FORM4_PAGE_SIZE);
@@ -110,33 +131,41 @@ function InsiderView({ width, height, focused }: { width: number; height: number
     filingsEntry?.phase === "error"
       ? (filingsEntry.error?.message ?? "Failed to load SEC filings")
       : null;
+  // Hosted, the only filings source is Gloom Cloud, which needs an account.
+  const cloudSession = useResearchCloudSession();
+  const authWall = allFilings.length === 0 && isCloudSessionRequired(error);
+  const sessionKeyRef = useRef(cloudSession.requestKey);
+  useEffect(() => {
+    if (sessionKeyRef.current === cloudSession.requestKey) return;
+    sessionKeyRef.current = cloudSession.requestKey;
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !instrument || !eligibleTicker) return;
+    void coordinator.loadSecFilings({ instrument, count: SEC_FILING_SCAN_LIMIT }, { forceRefresh: true });
+  }, [cloudSession.requestKey, eligibleTicker, instrument]);
 
   const { contentCache: contentMap, pendingCount } = useSecFilingContentCache({
     scopeKey: `${ticker?.metadata.ticker ?? "none"}:${ticker?.metadata.exchange ?? ""}`,
     targets: visibleForm4Filings,
   });
 
-  const allParsed: ParsedFiling[] = useMemo(() => visibleForm4Filings.map((filing) => {
+  const allParsed: ParsedFiling[] = useMemo(() => visibleForm4Filings.flatMap((filing) => {
     const hasContent = contentMap.has(filing.accessionNumber);
     const xml = contentMap.get(filing.accessionNumber) ?? null;
-    return {
-      filing,
-      transaction: xml ? parseForm4Xml(xml) : null,
-      isLoading: !hasContent,
-    };
+    return parseInsiderFiling(filing, xml, !hasContent);
   }), [contentMap, visibleForm4Filings]);
 
   // Apply name filter
   const parsed = useMemo(() => (
     nameFilter
-      ? allParsed.filter((p) => p.transaction?.reportedName === nameFilter)
+      ? allParsed.filter((entry) => matchesInsiderOwner(entry, nameFilter))
       : allParsed
   ), [allParsed, nameFilter]);
   const feedItems = useMemo(() => toFeedItems(parsed), [parsed]);
-  const summary = useMemo(() => buildInsiderSummary(allParsed), [allParsed]);
-  const selectedTransaction = parsed[selectedIdx]?.transaction ?? null;
+  const summary = useMemo(() => buildInsiderSummary(parsed, Date.now(), allParsed), [parsed, allParsed]);
+  const amendments = useMemo(() => relevantInsiderAmendments(parsed, allParsed), [parsed, allParsed]);
+  const selectedFilterName = parsed[selectedIdx] ? insiderReportedName(parsed[selectedIdx]!) : null;
   const openFiling = openItemId
-    ? parsed.find(({ filing }) => filing.accessionNumber === openItemId)?.filing ?? null
+    ? parsed.find((entry) => insiderTransactionId(entry) === openItemId)?.filing ?? null
     : null;
 
   const toggleNameFilter = useCallback((reportedName: string) => {
@@ -147,6 +176,12 @@ function InsiderView({ width, height, focused }: { width: number; height: number
     setNameFilter(null);
     setSelectedIdx(0);
   }, [setNameFilter, setSelectedIdx]);
+  const filterActionRef = useRef<() => void>(() => {});
+  filterActionRef.current = () => {
+    if (nameFilter) clearNameFilter();
+    else if (selectedFilterName) toggleNameFilter(selectedFilterName);
+  };
+  const handleFilterPress = useCallback(() => filterActionRef.current(), []);
 
   const handleRootKeyDown = useCallback((event: {
     name?: string;
@@ -154,38 +189,35 @@ function InsiderView({ width, height, focused }: { width: number; height: number
     stopPropagation?: () => void;
   }) => {
     if (event.name !== "f") return false;
-    if (!selectedTransaction) return false;
+    if (!selectedFilterName) return false;
     event.stopPropagation?.();
     event.preventDefault?.();
-    toggleNameFilter(selectedTransaction.reportedName);
+    toggleNameFilter(selectedFilterName);
     return true;
-  }, [selectedTransaction, toggleNameFilter]);
+  }, [selectedFilterName, toggleNameFilter]);
 
-  const selectedFilterName = selectedTransaction?.reportedName ?? null;
   const pendingLabel = pendingCount > 0 ? `loading ${pendingCount}...` : "";
   const footerInfo = useMemo(() => [
-    ...(summary ? [{ id: "summary", parts: [{ text: truncateText(summary, Math.max(24, width - 20)), tone: "muted" as const }] }] : []),
+    ...(amendments.length ? [{ id: "amendment", parts: [{ text: "4/A unreconciled", tone: "warning" as const }] }] : []),
+    ...(!amendments.length && summary ? [{ id: "summary", parts: [{ text: truncateText(summary, Math.max(24, width - 20)), tone: "muted" as const }] }] : []),
     ...(nameFilter ? [{ id: "filter", parts: [{ text: `filter: ${truncateText(nameFilter, 24)}`, tone: "warning" as const }] }] : []),
     ...(pendingLabel ? [{ id: "pending", parts: [{ text: pendingLabel, tone: "muted" as const }] }] : []),
-  ], [nameFilter, pendingLabel, summary, width]);
+  ], [amendments.length, nameFilter, pendingLabel, summary, width]);
   const footerHints = useMemo(() => (
     selectedFilterName || nameFilter
       ? [{
           id: "filter",
           key: "f",
           label: "ilter",
-          onPress: () => {
-            if (nameFilter) clearNameFilter();
-            else if (selectedFilterName) toggleNameFilter(selectedFilterName);
-          },
+          onPress: handleFilterPress,
         }]
       : []
-  ), [clearNameFilter, nameFilter, selectedFilterName, toggleNameFilter]);
+  ), [handleFilterPress, nameFilter, selectedFilterName]);
   useExternalLinkFooter({
     registrationId: "insider",
     focused,
     url: error ? null : openFiling?.filingUrl,
-    source: openFiling?.form ? formatFilingFormLabel(openFiling.form) : null,
+    source: openFiling?.form && !amendments.length ? formatFilingFormLabel(openFiling.form) : null,
     info: footerInfo,
     hints: footerHints,
     label: "filing",
@@ -195,6 +227,7 @@ function InsiderView({ width, height, focused }: { width: number; height: number
     return <EmptyState title="No ticker selected." message="Select a ticker to view insider activity." />;
   }
   if (!eligibleTicker) return renderFilingNotice("Insider transactions are only shown for US equities.", width);
+  if (authWall) return <SignInWall action="view insider transactions" needsVerification={cloudSession.needsVerification} />;
   if (loading && allFilings.length === 0) return <Spinner label="Loading insider filings..." />;
   if (error) return <EmptyState title="Insider filings unavailable." message={error} />;
   if (!loading && form4Filings.length === 0) {
@@ -209,6 +242,7 @@ function InsiderView({ width, height, focused }: { width: number; height: number
       items={feedItems}
       selectedIdx={selectedIdx}
       onSelect={setSelectedIdx}
+      openItemId={openItemId}
       onOpenItemIdChange={setOpenItemId}
       onRootKeyDown={handleRootKeyDown}
       sourceLabel="Insider"

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

@@ -1,45 +1,58 @@
 import { describe, expect, test } from "bun:test";
 import { parseForm4Xml } from "./insider-data";
+import { buildInsiderRows, buildInsiderSummary, parseInsiderFiling } from "./model";
+import type { SecFilingItem } from "../../../types/data-provider";
 
-const SAMPLE_FORM4 = `<?xml version="1.0"?>
-<ownershipDocument>
-  <reportingOwner>
-    <reportingOwnerId><rptOwnerName>COOK TIMOTHY D</rptOwnerName></reportingOwnerId>
-    <reportingOwnerRelationship>
-      <isOfficer>1</isOfficer>
-      <officerTitle>Chief Executive Officer</officerTitle>
-    </reportingOwnerRelationship>
-  </reportingOwner>
-  <nonDerivativeTable>
-    <nonDerivativeTransaction>
-      <transactionDate><value>2024-04-01</value></transactionDate>
-      <transactionCoding><transactionCode>S</transactionCode></transactionCoding>
-      <transactionAmounts>
-        <transactionShares><value>50000</value></transactionShares>
-        <transactionPricePerShare><value>171.50</value></transactionPricePerShare>
-      </transactionAmounts>
-      <postTransactionAmounts>
-        <sharesOwnedFollowingTransaction><value>3500000</value></sharesOwnedFollowingTransaction>
-      </postTransactionAmounts>
-    </nonDerivativeTransaction>
-  </nonDerivativeTable>
-</ownershipDocument>`;
+const owner = `<reportingOwner><reportingOwnerId><rptOwnerName>OWNER &amp; CO</rptOwnerName><rptOwnerCik>123</rptOwnerCik></reportingOwnerId><reportingOwnerRelationship><officerTitle>CEO</officerTitle></reportingOwnerRelationship></reportingOwner>`;
+function transaction(code: string, security: string, shares: string, price: string, date = "2026-08-20", derivative = false) {
+  const tag = derivative ? "derivativeTransaction" : "nonDerivativeTransaction";
+  return `<${tag}>
+    <securityTitle><value>${security}</value></securityTitle>
+    <transactionDate><value>${date}</value></transactionDate>
+    <transactionCoding><transactionCode>${code}</transactionCode></transactionCoding>
+    <transactionAmounts><transactionShares><value>${shares}</value><footnoteId id="F1"/></transactionShares><transactionPricePerShare><value>${price}</value></transactionPricePerShare><transactionAcquiredDisposedCode><value>D</value></transactionAcquiredDisposedCode></transactionAmounts>
+    <postTransactionAmounts><sharesOwnedFollowingTransaction><value>292786</value></sharesOwnedFollowingTransaction></postTransactionAmounts>
+    <ownershipNature><directOrIndirectOwnership><value>I</value></directOrIndirectOwnership><natureOfOwnership><value>Family trust</value></natureOfOwnership></ownershipNature>
+  </${tag}>`;
+}
+const filing: SecFilingItem = { accessionNumber: "one", form: "4", filingDate: new Date("2026-08-24"), cik: "123", filingUrl: "https://www.sec.gov/one" };
 
-describe("parseForm4Xml", () => {
-  test("parses insider sale from Form 4 XML", () => {
-    const result = parseForm4Xml(SAMPLE_FORM4);
-    expect(result).not.toBeNull();
-    expect(result!.reportedName).toBe("COOK TIMOTHY D");
-    expect(result!.title).toBe("Chief Executive Officer");
-    expect(result!.transactionType).toBe("S");
-    expect(result!.shares).toBe(50000);
-    expect(result!.pricePerShare).toBe(171.50);
-    expect(result!.totalValue).toBe(50000 * 171.50);
-    expect(result!.sharesOwned).toBe(3500000);
+describe("Form 4 transaction parsing", () => {
+  test("keeps all gift, conversion and derivative rows with their own dates, security and ownership", () => {
+    const xml = `<ownershipDocument>${owner}<nonDerivativeTable>
+      <nonDerivativeHolding><securityTitle><value>Unrelated holding</value></securityTitle><postTransactionAmounts><sharesOwnedFollowingTransaction><value>999999</value></sharesOwnedFollowingTransaction></postTransactionAmounts></nonDerivativeHolding>
+      ${transaction("G", "Class A Common Stock", "55498", "0", "2026-08-10")}
+      ${transaction("G", "Class A Common Stock", "294502", "0", "2026-08-11")}
+      ${transaction("C", "Class B Common Stock", "402348", "")}
+      </nonDerivativeTable><derivativeTable>${transaction("M", "Restricted Stock Units", "877500", "0", "2026-08-20", true)}</derivativeTable></ownershipDocument>`;
+    const rows = parseForm4Xml(xml);
+    expect(rows).toHaveLength(4);
+    expect(rows.map((row) => [row.transactionType, row.shares, row.pricePerShare, row.filingDate?.toISOString().slice(0, 10), row.isDerivative])).toEqual([
+      ["G", 55498, 0, "2026-08-10", false], ["G", 294502, 0, "2026-08-11", false],
+      ["C", 402348, null, "2026-08-20", false], ["M", 877500, 0, "2026-08-20", true],
+    ]);
+    expect(rows[0]).toMatchObject({ reportedName: "OWNER & CO", securityTitle: "Class A Common Stock", acquiredDisposed: "D", ownershipType: "I", ownershipNature: "Family trust", sharesOwned: 292786, totalValue: 0 });
+    expect(rows[2]?.totalValue).toBeNull();
+    const projected = buildInsiderRows(parseInsiderFiling(filing, xml));
+    expect(new Set(projected.map((row) => row.id)).size).toBe(4);
+    expect(projected[1]).toMatchObject({ filingDate: "2026-08-24T00:00:00.000Z", transactionDate: "2026-08-11T00:00:00.000Z", side: "GIFT", transactionCode: "G", reportingOwners: [{ name: "OWNER & CO", cik: "123", title: "CEO" }] });
   });
 
-  test("returns null for non-Form-4 XML", () => {
-    expect(parseForm4Xml("<html>not a form</html>")).toBeNull();
-    expect(parseForm4Xml("")).toBeNull();
+  test("missing amounts and invalid dates remain unknown rather than becoming zero or today", () => {
+    const rows = parseForm4Xml(`<ownershipDocument>${owner}${transaction("F", "Class A", "", "", "2026-02-31")}</ownershipDocument>`);
+    expect(rows[0]).toMatchObject({ filingDate: null, shares: null, pricePerShare: null, totalValue: null, transactionType: "F" });
+    expect(parseForm4Xml("<html>not a filing</html>")).toEqual([]);
+    expect(buildInsiderRows(parseInsiderFiling(filing, "<ownershipDocument/>"))[0]?.status).toBe("unavailable");
+  });
+
+  test("summary excludes exercises and gifts, separates securities, and exposes missing sale prices", () => {
+    const xml = `<ownershipDocument>${owner}
+      ${transaction("S", "Class A", "100", "10")}${transaction("S", "Class A", "25", "")}
+      ${transaction("S", "Class B", "50", "20")}${transaction("S", "Options", "9000", "1", "2026-08-20", true)}
+      ${transaction("G", "Class A", "8000", "0")}${transaction("M", "Class A", "7000", "0")}
+      ${transaction("S", "Class A", "6000", "1", "2025-01-01")}
+      </ownershipDocument>`;
+    const summary = buildInsiderSummary(parseInsiderFiling(filing, xml), new Date("2026-09-10").getTime());
+    expect(summary).toBe("Loaded filings, last 90 days: Class A: Sold 125 shares (value unavailable) | Class B: Sold 50 shares ($1,000.00)");
   });
 });

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

@@ -1,50 +1,119 @@
+import { decodeHtmlEntities } from "../../../utils/html-entities";
 
 export interface InsiderTransaction {
-  filingDate: Date;
+  /** Transaction date, distinct from the enclosing SEC filing date. */
+  filingDate: Date | null;
   reportedName: string;
   title: string;
-  transactionType: "P" | "S" | "A" | "D" | "";
-  shares: number;
+  transactionType: string;
+  shares: number | null;
   pricePerShare: number | null;
   totalValue: number | null;
   sharesOwned: number | null;
   form: string;
+  transactionIndex?: number;
+  securityTitle?: string;
+  isDerivative?: boolean;
+  acquiredDisposed?: string;
+  ownershipType?: string;
+  ownershipNature?: string;
+  reportingOwners?: Array<{ name: string; cik: string; title: string }>;
+  footnoteIds?: string[];
 }
 
-export function parseForm4Xml(xml: string): InsiderTransaction | null {
-  const nameMatch = xml.match(/<rptOwnerName>([^<]+)<\/rptOwnerName>/);
-  if (!nameMatch) return null;
+export interface InsiderFilingDisclosure {
+  form: string;
+  originalFilingDate: string | null;
+  reportingOwners: Array<{ name: string; cik: string; title: string }>;
+  footnotes: Array<{ id: string; text: string }>;
+  remarks: string | null;
+}
 
-  const titleMatch = xml.match(/<officerTitle>([^<]+)<\/officerTitle>/);
-  const codeMatch = xml.match(/<transactionCode>([^<]+)<\/transactionCode>/);
-  const sharesMatch = xml.match(/<transactionShares>[\s\S]*?<value>([^<]+)<\/value>/);
-  const priceMatch = xml.match(/<transactionPricePerShare>[\s\S]*?<value>([^<]+)<\/value>/);
-  const ownedMatch = xml.match(/<sharesOwnedFollowingTransaction>[\s\S]*?<value>([^<]+)<\/value>/);
-  const dateMatch = xml.match(/<transactionDate>[\s\S]*?<value>([^<]+)<\/value>/);
+export function isInsiderForm(form: string): boolean {
+  return /^4(?:\/A)?$/i.test(form.trim());
+}
 
-  const shares = sharesMatch ? parseFloat(sharesMatch[1]!) : 0;
-  const price = priceMatch ? parseFloat(priceMatch[1]!) : null;
-  const code = codeMatch?.[1] ?? "";
+export function isInsiderAmendment(form: string): boolean {
+  return /^4\/A$/i.test(form.trim());
+}
 
+function tagContent(xml: string, tag: string): string | undefined {
+  return xml.match(new RegExp(`<(?:[\\w.-]+:)?${tag}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/(?:[\\w.-]+:)?${tag}\\s*>`, "i"))?.[1];
+}
+
+function tagText(xml: string, tag: string): string {
+  return decodeHtmlEntities((tagContent(xml, tag) ?? "").replace(/<[^>]*>/g, "").trim());
+}
+
+function numberValue(xml: string, tag: string): number | null {
+  const raw = tagText(tagContent(xml, tag) ?? "", "value");
+  if (!raw) return null;
+  const value = Number(raw.replace(/,/g, ""));
+  return Number.isFinite(value) ? value : null;
+}
+
+function reportingOwners(xml: string): InsiderFilingDisclosure["reportingOwners"] {
+  return [...xml.matchAll(/<(?:[\w.-]+:)?reportingOwner(?:\s[^>]*)?>([\s\S]*?)<\/(?:[\w.-]+:)?reportingOwner\s*>/gi)]
+    .map((match) => ({ name: tagText(match[1]!, "rptOwnerName"), cik: tagText(match[1]!, "rptOwnerCik"), title: tagText(match[1]!, "officerTitle") }));
+}
+
+function disclosureText(xml: string): string {
+  return decodeHtmlEntities(xml.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim());
+}
+
+export function parseForm4Disclosure(xml: string): InsiderFilingDisclosure | null {
+  if (!/<(?:[\w.-]+:)?ownershipDocument(?:\s|>)/i.test(xml)) return null;
+  const original = tagText(xml, "dateOfOriginalSubmission");
+  const date = /^\d{4}-\d{2}-\d{2}$/.test(original) ? new Date(`${original}T00:00:00Z`) : null;
   return {
-    filingDate: dateMatch ? new Date(dateMatch[1]!) : new Date(),
-    reportedName: nameMatch[1]!.trim(),
-    title: titleMatch?.[1]?.trim() ?? "",
-    transactionType: (code === "P" || code === "S" || code === "A" || code === "D") ? code : "",
-    shares: isNaN(shares) ? 0 : shares,
-    pricePerShare: price !== null && !isNaN(price) ? price : null,
-    totalValue: price !== null && !isNaN(price) && !isNaN(shares) ? shares * price : null,
-    sharesOwned: ownedMatch ? parseFloat(ownedMatch[1]!) : null,
-    form: "4",
+    form: tagText(xml, "documentType") || "4",
+    originalFilingDate: date && Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === original ? original : null,
+    reportingOwners: reportingOwners(xml),
+    footnotes: [...xml.matchAll(/<(?:[\w.-]+:)?footnote\s[^>]*\bid\s*=\s*["']([^"']+)["'][^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?footnote\s*>/gi)]
+      .map((match) => ({ id: match[1]!, text: disclosureText(match[2]!) })),
+    remarks: disclosureText(tagContent(xml, "remarks") ?? "") || null,
   };
 }
 
+export function parseForm4Xml(xml: string): InsiderTransaction[] {
+  const owners = reportingOwners(xml).filter((owner) => owner.name);
+  if (!owners.length) return [];
+  const blocks = [...xml.matchAll(/<(?:[\w.-]+:)?(nonDerivativeTransaction|derivativeTransaction)(?:\s[^>]*)?>([\s\S]*?)<\/(?:[\w.-]+:)?\1\s*>/gi)];
+  return blocks.map((match, transactionIndex) => {
+    const block = match[2]!;
+    const amounts = tagContent(block, "transactionAmounts") ?? "";
+    const shares = numberValue(amounts, "transactionShares");
+    const price = numberValue(amounts, "transactionPricePerShare");
+    const dateText = tagText(tagContent(block, "transactionDate") ?? "", "value");
+    const date = /^\d{4}-\d{2}-\d{2}$/.test(dateText) ? new Date(`${dateText}T00:00:00Z`) : null;
+    return {
+      filingDate: date && Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === dateText ? date : null,
+      reportedName: owners.map(({ name }) => name).join("; "),
+      title: [...new Set(owners.map(({ title }) => title).filter(Boolean))].join("; "),
+      reportingOwners: owners,
+      transactionType: tagText(tagContent(block, "transactionCoding") ?? "", "transactionCode"),
+      securityTitle: tagText(tagContent(block, "securityTitle") ?? "", "value"),
+      isDerivative: match[1]!.toLowerCase() === "derivativetransaction",
+      transactionIndex,
+      shares,
+      pricePerShare: price,
+      totalValue: shares != null && price != null ? shares * price : null,
+      sharesOwned: numberValue(tagContent(block, "postTransactionAmounts") ?? "", "sharesOwnedFollowingTransaction"),
+      acquiredDisposed: tagText(tagContent(amounts, "transactionAcquiredDisposedCode") ?? "", "value"),
+      ownershipType: tagText(tagContent(tagContent(block, "ownershipNature") ?? "", "directOrIndirectOwnership") ?? "", "value"),
+      ownershipNature: tagText(tagContent(tagContent(block, "ownershipNature") ?? "", "natureOfOwnership") ?? "", "value"),
+      form: tagText(xml, "documentType") || "4",
+      footnoteIds: [...new Set([...block.matchAll(/<(?:[\w.-]+:)?footnoteId\s[^>]*\bid\s*=\s*["']([^"']+)["']/gi)].map((note) => note[1]!))],
+    };
+  });
+}
+
 export function transactionTypeLabel(type: InsiderTransaction["transactionType"]): string {
-  switch (type) {
-    case "P": return "BUY";
-    case "S": return "SELL";
-    case "A": return "AWARD";
-    case "D": return "DISPOSE";
-    default: return "-";
-  }
+  const labels: Record<string, string> = {
+    P: "BUY", S: "SELL", A: "AWARD", D: "DISPOSE", M: "EXERCISE", C: "CONVERT",
+    F: "TAX/EXERCISE PAYMENT", G: "GIFT", X: "EXERCISE", O: "OUT-OF-MONEY EXERCISE",
+    E: "EXPIRATION", H: "CANCELLATION", I: "DISCRETIONARY", J: "OTHER", K: "SWAP",
+    L: "SMALL ACQUISITION", U: "TENDER", W: "INHERITANCE", Z: "TRUST TRANSFER",
+  };
+  return labels[type] ?? (type || "—");
 }