gloomberb 0.14.1 → 0.15.0

package/src/plugins/builtin/thirteenf/headless.test.ts

@@ -1,4 +1,5 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+import { apiClient } from "../../../api-client";
 import { createTestDataProvider } from "../../../test-support/data-provider";
 import { createDefaultConfig } from "../../../types/config";
 import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
@@ -145,4 +146,37 @@ describe("13F headless model", () => {
     })]);
     expect(holdings.metadata).toMatchObject({ view: "holdings", fund: detail.name });
   });
+
+  describe("ticker argument", () => {
+    const holder = (index: number) => ({ id: `f${index}`, cik: `${index}`, fund: `Fund ${index}`, ticker: "KO", cusip: "191216100", issuer: "Coca-Cola",
+      type: "SH", value: 100, shares: 1, weight: null, previousWeight: null, weightChange: null, action: "held" });
+    const page = (offset: number, count: number, hasMore: boolean) => ({ ticker: "KO", quarter: "2026Q2", period: "2026-06-30", previousPeriod: "2026-03-31",
+      rows: Array.from({ length: count }, (_, index) => holder(offset + index)), warnings: [], asOf: "", holderCount: 60, newCount: 0, exitCount: 0,
+      totalValue: null, valueScope: "page", hasMore, nextOffset: offset + count });
+    let spy: ReturnType<typeof spyOn> | null = null;
+    afterEach(() => { spy?.mockRestore(); spy = null; });
+
+    test("pages holders up to the limit and reports more", async () => {
+      const offsets: number[] = [];
+      spy = spyOn(apiClient, "getCloudSec13F").mockImplementation((async (_view: string, params: { offset: number }) => {
+        offsets.push(params.offset);
+        return page(params.offset, 25, params.offset < 50);
+      }) as never);
+      const headless = createThirteenFHeadless({ loadBrowser: async () => ({ rows: [] }), loadDetail: async () => detail });
+      const result = await headless.load({ ...args("auto", 40), argument: "KO", rawArgument: "KO" }, context());
+      expect(offsets).toEqual([0, 25]);
+      expect(result.rows).toHaveLength(40);
+      expect(result.metadata).toMatchObject({ view: "ticker-holdings", truncated: true });
+    });
+
+    test("falls back to the holders listing for a ticker without a mapped CUSIP", async () => {
+      spy = spyOn(apiClient, "getCloudSec13F").mockImplementation((async () => { throw new Error("No 13F CUSIP found for ZZZZ"); }) as never);
+      const tabs: string[] = [];
+      const headless = createThirteenFHeadless({ loadBrowser: async (tab) => { tabs.push(tab); return { rows: [], warning: "No 13F holders for ZZZZ" }; }, loadDetail: async () => detail });
+      const result = await headless.load({ ...args("auto"), argument: "ZZZZ", rawArgument: "ZZZZ" }, context());
+      expect(tabs).toEqual(["byTicker"]);
+      expect(result.metadata).toMatchObject({ view: "byTicker" });
+      await expect(headless.load({ ...args("ticker-holdings"), argument: "ZZZZ", rawArgument: "ZZZZ" }, context())).rejects.toThrow(/No 13F CUSIP/);
+    });
+  });
 });

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

@@ -5,6 +5,8 @@ import type {
   HeadlessPaneLoadArgs,
 } from "../../../types/plugin";
 import { normalizeCik } from "./api";
+import { buildFundOverlap } from "./overlap";
+import { appendTickerHoldings, loadCrowding, loadTickerHoldings, type TickerHoldings } from "./signals";
 import {
   loadBrowserRows,
   loadFundDetail,
@@ -12,6 +14,7 @@ import {
 } from "./data";
 import {
   DEFAULT_BROWSER_SORT,
+  browserSortFor,
   DEFAULT_HOLDING_SORT,
   DEFAULT_TIMELINE_SORT,
   buildFundHoldingRows,
@@ -33,12 +36,22 @@ import {
   formatRawPercentMaybe,
   formatShares,
   formatShortDate,
+  formatWeightMaybe,
 } from "./format";
 import type {
   FundDetailData,
   ThirteenFBrowserTab,
 } from "./types";
 
+const numberOrNull = (value: unknown): number | null => typeof value === "number" && Number.isFinite(value) ? value : null;
+const money = (value: unknown) => formatMoneyCompact(numberOrNull(value));
+const weight = (value: unknown) => formatWeightMaybe(numberOrNull(value));
+const shares = (value: unknown) => formatShares(numberOrNull(value));
+const weightPoints = (value: unknown) => {
+  const change = numberOrNull(value);
+  return change == null ? "--" : `${change > 0 ? "+" : ""}${(change * 100).toFixed(2)}pp`;
+};
+
 const BROWSER_COLUMNS: HeadlessPaneColumn[] = [
   { key: "name", header: "Fund" },
   { key: "cik", header: "CIK" },
@@ -84,7 +97,7 @@ const HOLDING_COLUMNS: HeadlessPaneColumn[] = [
     header: "13F %",
     description: "Share of the filing's reported value, including underlying notional for options; not portfolio allocation.",
     align: "right",
-    format: (value) => formatPercentMaybe(value == null ? null : Number(value)),
+    format: weight,
   },
   {
     key: "shares",
@@ -126,6 +139,9 @@ const FILING_COLUMNS: HeadlessPaneColumn[] = [
 ];
 
 type HeadlessThirteenFView =
+  | "overlap"
+  | "crowding"
+  | "ticker-holdings"
   | "auto"
   | "performance"
   | "funds"
@@ -200,12 +216,18 @@ export function createThirteenFHeadless(
       optional: true,
     },
     options: [
+      { key: "rank", description: "Crowding order.", type: "enum", values: [{ value: "new" }, { value: "exits" }, { value: "increases" }, { value: "decreases" }], defaultValue: "new" },
+      { key: "compare", description: "Second fund name or CIK for overlap.", type: "string" },
+      { key: "offset", description: "Fund offset for ticker-holdings.", type: "integer", defaultValue: 0, minimum: 0, maximum: 100000 },
       {
         key: "view",
         description: "Fund browser mode or detail tab.",
         type: "enum",
         values: [
           { value: "auto" },
+          { value: "crowding" },
+          { value: "overlap" },
+          { value: "ticker-holdings" },
           { value: "performance" },
           { value: "funds" },
           { value: "by-ticker", aliases: ["ticker", "byTicker"] },
@@ -229,8 +251,53 @@ export function createThirteenFHeadless(
     async load(args, ctx) {
       const query = typeof args.argument === "string" ? args.argument.trim() : "";
       const requestedView = String(args.options.view) as HeadlessThirteenFView;
-      const view = requestedView === "auto" && isCikQuery(query) ? "holdings" : requestedView;
+      // A ticker's holders with their positions, not the holders' whole books.
+      const view = requestedView !== "auto" ? requestedView
+        : isCikQuery(query) ? "holdings"
+          : inferBrowserTabFromQuery(query) === "byTicker" ? "ticker-holdings"
+            : requestedView;
       const limit = Number(args.options.limit);
+      if (view === "overlap") {
+        const fund = await resolveFund(query, args, ctx, dependencies);
+        const other = await resolveFund(String(args.options.compare ?? ""), args, ctx, dependencies);
+        const [first, second] = await Promise.all([dependencies.loadDetail(fund.cik, fund.name, args, ctx), dependencies.loadDetail(other.cik, other.name, args, ctx)]);
+        const samePeriod = !!first.latestForm && first.latestForm.periodOfReport === second.latestForm?.periodOfReport;
+        const rows = buildFundOverlap(first, second);
+        return { columns: [{ key: "ticker", header: "Ticker" }, { key: "type", header: "Type" }, { key: "issuer", header: "Issuer" }, { key: "weight", header: "First weight", align: "right", format: weight }, { key: "comparedWeight", header: "Second weight", align: "right", format: weight }], rows: rows.slice(0, limit).map(row => ({ ...row })), errors: [...(first.warnings ?? []), ...(second.warnings ?? []), ...(!samePeriod ? ["The funds have different latest reporting quarters."] : [])], metadata: { firstFund: first.name, secondFund: second.name, firstPeriod: first.latestForm?.periodOfReport ?? null, secondPeriod: second.latestForm?.periodOfReport ?? null, truncated: rows.length > limit } };
+      }
+      if (view === "crowding") {
+        const { rows: sourceRows, ...metadata } = await loadCrowding(ctx.signal);
+        const rank = String(args.options.rank ?? "new");
+        const rows = [...sourceRows].sort((left, right) => {
+          if (rank === "new") return right.newCount - left.newCount;
+          if (rank === "exits") return right.exitCount - left.exitCount;
+          if (left.weightChange == null) return right.weightChange == null ? 0 : 1;
+          if (right.weightChange == null) return -1;
+          return (left.weightChange - right.weightChange) * (rank === "decreases" ? 1 : -1);
+        });
+        return { columns: [{ key: "ticker", header: "Ticker" }, { key: "issuer", header: "Issuer" }, { key: "type", header: "Type" }, { key: "holderCount", header: "Funds", align: "right" }, { key: "newCount", header: "New", align: "right" }, { key: "exitCount", header: "Exits", align: "right" }, { key: "weightChange", header: "Weight change", align: "right", format: weightPoints }, { key: "comparedFunds", header: "Compared", align: "right" }, { key: "totalValue", header: "Value", align: "right", format: money }], rows: rows.slice(0, limit).map(row => ({ ...row })),
+          // The pane states the fund sample beside the table; the text report needs it too.
+          metadata: { ...metadata, view, rank, truncated: rows.length > limit, notices: [`${metadata.period}: ${metadata.loadedFunds}/${metadata.sourceFunds} ranked funds`] }, errors: metadata.warnings };
+      }
+      let holdings: TickerHoldings | null = null;
+      if (view === "ticker-holdings") {
+        if (!query) throw new Error("13F ticker holdings requires a ticker.");
+        const ticker = query.replace(/^\$/, "").toUpperCase();
+        try {
+          holdings = await loadTickerHoldings(ticker, Number(args.options.offset ?? 0), ctx.signal);
+          // The endpoint pages 25 funds at a time.
+          while (holdings.hasMore && holdings.rows.length < limit) {
+            holdings = appendTickerHoldings(holdings, await loadTickerHoldings(ticker, holdings.nextOffset, ctx.signal));
+          }
+        } catch (error) {
+          // A ticker without a mapped CUSIP falls back to the holders listing.
+          if (requestedView !== "auto" || ctx.signal?.aborted) throw error;
+        }
+      }
+      if (holdings) {
+        const { rows, ...metadata } = holdings;
+        return { columns: [{ key: "fund", header: "Fund" }, { key: "cik", header: "CIK" }, { key: "type", header: "Type" }, { key: "value", header: "Value", align: "right", format: money }, { key: "shares", header: "Shares", align: "right", format: shares }, { key: "weight", header: "13F weight", align: "right", format: weight }, { key: "action", header: "Action" }], rows: rows.slice(0, limit).map(row => ({ ...row })), metadata: { ...metadata, view, truncated: rows.length > limit || metadata.hasMore }, errors: metadata.warnings };
+      }
 
       if (view === "holdings" || view === "filings") {
         const fund = await resolveFund(query, args, ctx, dependencies);
@@ -282,13 +349,14 @@ export function createThirteenFHeadless(
         };
       }
 
-      const tab = browserTab(view, query);
+      const tab = browserTab(view === "ticker-holdings" ? requestedView : view, query);
       const result = await dependencies.loadBrowser(tab, query, limit, args, ctx);
       return {
-        columns: BROWSER_COLUMNS,
-        rows: sortBrowserRows(result.rows, DEFAULT_BROWSER_SORT)
+        columns: result.rows[0]?.priorReturns?.length ? [...BROWSER_COLUMNS.filter(column => !["filedAsOfDate", "tableEntryTotal"].includes(column.key)), ...result.rows[0].priorReturns.map((point, index) => ({ key: `return${index + 1}`, header: point.quarter, align: "right" as const, format: (value: unknown) => formatRawPercentMaybe(typeof value === "number" ? value : null) }))]
+          : tab === "performance" ? BROWSER_COLUMNS : BROWSER_COLUMNS.filter(column => column.key !== "estQuarterReturn"),
+        rows: sortBrowserRows(result.rows, browserSortFor(DEFAULT_BROWSER_SORT, tab))
           .slice(0, limit)
-          .map((row) => ({ ...row })),
+          .map((row) => ({ ...row, ...Object.fromEntries((row.priorReturns ?? []).map((point, index) => [`return${index + 1}`, point.value])) })),
         ...(result.warning ? { errors: [result.warning] } : {}),
         metadata: {
           view: tab,

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

@@ -12,6 +12,8 @@ import {
   resetThirteenFApiPersistence,
 } from "./api";
 import { thirteenFHeadless } from "./headless";
+import { ThirteenFTickerPane } from "./signals-pane";
+import { isKnownNonUsListing } from "../../../utils/sec";
 
 export { thirteenFHeadless } from "./headless";
 
@@ -26,6 +28,14 @@ function initialCikFromQuery(query: string): string | undefined {
 export const thirteenFModule: PluginModule = {
   setup(ctx) {
     attachThirteenFApiPersistence(ctx.persistence);
+    ctx.registerTickerResearchTab({
+      id: "thirteenf",
+      name: "13F",
+      order: 39,
+      component: ThirteenFTickerPane,
+      instruments: ["equity", "fund"],
+      isVisible: ({ ticker }) => !isKnownNonUsListing(ticker),
+    });
   },
 
   dispose() {
@@ -67,7 +77,8 @@ export const thirteenFModule: PluginModule = {
           instanceId: initialCik
             ? `${THIRTEENF_PANE_ID}:${initialCik}`
             : `${THIRTEENF_PANE_ID}:${browserMode}:${encodeURIComponent(query || "performance").replace(/%/g, "~")}`,
-          title: query ? `13F ${query}` : "13F Funds",
+          // The title bar already shows the Funds tab, so the bare pane is just "13F".
+          title: query ? `13F ${query}` : "13F",
           placement: "floating",
           settings: {
             query,

package/src/plugins/builtin/thirteenf/model.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import {
+  browserSortFor,
   buildFilingPositionRows,
   buildFundHoldingRows,
   buildTimelineRows,
@@ -47,6 +48,13 @@ function holding(overrides: Partial<ThirteenFHoldingRecord>): ThirteenFHoldingRe
 }
 
 describe("13F model", () => {
+  test("a stored return sort falls back to reported value outside the performance ranking", () => {
+    const stored = { columnId: "estQuarterReturn" as const, direction: "desc" as const };
+    expect(browserSortFor(stored, "performance")).toBe(stored);
+    expect(browserSortFor(stored, "byTicker")).toEqual({ columnId: "value", direction: "desc" });
+    expect(browserSortFor({ columnId: "fund", direction: "asc" }, "funds")).toEqual({ columnId: "fund", direction: "asc" });
+  });
+
   test("infers browser mode from command query", () => {
     expect(inferBrowserTabFromQuery("")).toBe("performance");
     expect(inferBrowserTabFromQuery("AAPL")).toBe("byTicker");

package/src/plugins/builtin/thirteenf/model.ts

@@ -32,6 +32,7 @@ export const THIRTEENF_OPTIONS_NOTE = "Option values and shares refer to the und
 export const FUND_DETAIL_TABS: Array<{ label: string; value: ThirteenFDetailTab }> = [
   { label: "Holdings", value: "holdings" },
   { label: "Filings", value: "filings" },
+  { label: "Overlap", value: "overlap" },
 ];
 
 export const DEFAULT_BROWSER_SORT: FundSortPreference<FundBrowserColumnId> = {
@@ -39,6 +40,18 @@ export const DEFAULT_BROWSER_SORT: FundSortPreference<FundBrowserColumnId> = {
   direction: "desc",
 };
 
+const RETURN_SORT_COLUMNS = new Set<FundBrowserColumnId>(["estQuarterReturn", "return1", "return2", "return3"]);
+
+/** Estimated returns exist only on the performance ranking; other lists sort by reported value instead. */
+export function browserSortFor(
+  preference: FundSortPreference<FundBrowserColumnId>,
+  tab: ThirteenFBrowserTab,
+): FundSortPreference<FundBrowserColumnId> {
+  return tab !== "performance" && RETURN_SORT_COLUMNS.has(preference.columnId)
+    ? { columnId: "value", direction: "desc" }
+    : preference;
+}
+
 export const DEFAULT_HOLDING_SORT: FundSortPreference<FundHoldingColumnId> = {
   columnId: "value",
   direction: "desc",
@@ -427,6 +440,9 @@ export function buildTimelineRows(forms: ThirteenFFormSummary[]): FundTimelineRo
 
 function browserSortValue(row: FundBrowserRow, columnId: FundBrowserColumnId): string | number | null {
   switch (columnId) {
+    case "return1": return row.priorReturns?.[0]?.value ?? null;
+    case "return2": return row.priorReturns?.[1]?.value ?? null;
+    case "return3": return row.priorReturns?.[2]?.value ?? null;
     case "fund":
       return row.name;
     case "cik":
@@ -446,6 +462,7 @@ function browserSortValue(row: FundBrowserRow, columnId: FundBrowserColumnId): s
 
 function holdingSortValue(row: FundHoldingRow, columnId: FundHoldingColumnId): string | number | null {
   switch (columnId) {
+    case "mine": return row.mine ? 1 : 0;
     case "ticker":
       return row.ticker || row.cusip;
     case "type":
@@ -573,18 +590,16 @@ export function nextSortPreference<TColumn extends string>(
   };
 }
 
-export function buildBrowserColumns(width: number): FundBrowserColumn[] {
+/** The name column takes the room the figures leave; the table lays it out. */
+export function buildBrowserColumns(withEstimate = true): FundBrowserColumn[] {
   const cikWidth = 12;
   const periodWidth = 10;
   const filedWidth = 9;
   const valueWidth = 11;
   const rowsWidth = 6;
-  const retWidth = 9;
-  const fixedWidth = cikWidth + periodWidth + filedWidth + valueWidth + rowsWidth + retWidth;
-  const separators = 7;
-  const fundWidth = Math.max(18, width - fixedWidth - separators - 2);
+  const retWidth = withEstimate ? 9 : 0;
   return [
-    { id: "fund", label: "FUND", width: fundWidth, align: "left" },
+    { id: "fund", label: "FUND", width: 18, align: "left", flexGrow: 1 },
     { id: "cik", label: "CIK", width: cikWidth, align: "left" },
     { id: "period", label: "PERIOD", width: periodWidth, align: "left" },
     ...(retWidth > 0 ? [{ id: "estQuarterReturn" as const, label: "EST 13F", width: retWidth, align: "right" as const }] : []),
@@ -594,7 +609,7 @@ export function buildBrowserColumns(width: number): FundBrowserColumn[] {
   ];
 }
 
-export function buildFilingPositionColumns(width: number): FilingPositionColumn[] {
+export function buildFilingPositionColumns(): FilingPositionColumn[] {
   const tickerWidth = 9;
   const typeWidth = 8;
   const valueWidth = 12;
@@ -602,12 +617,10 @@ export function buildFilingPositionColumns(width: number): FilingPositionColumn[
   const sharesWidth = 11;
   const cusipWidth = 10;
   const discretionWidth = 8;
-  const fixedWidth = tickerWidth + typeWidth + valueWidth + weightWidth + sharesWidth + cusipWidth + discretionWidth;
-  const issuerWidth = Math.max(16, width - fixedWidth - 9);
   return [
     { id: "ticker", label: "TICKER", width: tickerWidth, align: "left" },
     { id: "type", label: "TYPE", width: typeWidth, align: "left" },
-    { id: "issuer", label: "ISSUER", width: issuerWidth, align: "left" },
+    { id: "issuer", label: "ISSUER", width: 16, align: "left", flexGrow: 1 },
     { id: "value", label: "VALUE", width: valueWidth, align: "right" },
     { id: "weight", label: "13F %", width: weightWidth, align: "right" },
     { id: "shares", label: "SHARES", width: sharesWidth, align: "right" },
@@ -616,7 +629,7 @@ export function buildFilingPositionColumns(width: number): FilingPositionColumn[
   ];
 }
 
-export function buildHoldingColumns(width: number): FundHoldingColumn[] {
+export function buildHoldingColumns(): FundHoldingColumn[] {
   const tickerWidth = 9;
   const typeWidth = 8;
   const valueWidth = 12;
@@ -625,12 +638,10 @@ export function buildHoldingColumns(width: number): FundHoldingColumn[] {
   const sharesWidth = 11;
   const changeWidth = 11;
   const actionWidth = 7;
-  const fixedWidth = tickerWidth + typeWidth + valueWidth + pnlWidth + weightWidth + sharesWidth + changeWidth + actionWidth;
-  const issuerWidth = Math.max(18, width - fixedWidth - 10);
   return [
     { id: "ticker", label: "TICKER", width: tickerWidth, align: "left" },
     { id: "type", label: "TYPE", width: typeWidth, align: "left" },
-    { id: "issuer", label: "ISSUER", width: issuerWidth, align: "left" },
+    { id: "issuer", label: "ISSUER", width: 18, align: "left", flexGrow: 1 },
     { id: "value", label: "VALUE", width: valueWidth, align: "right" },
     { id: "estimatedPnl", label: "EST P&L", width: pnlWidth, align: "right" },
     { id: "weight", label: "13F %", width: weightWidth, align: "right" },

package/src/plugins/builtin/thirteenf/overlap-pane.tsx

@@ -0,0 +1,108 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { DataTableStackView, DataTableView, KeyValueRow, QueryBar, usePaneNoticeFooter, useTableLoadMore, type DataTableColumn } from "../../../components";
+import { useShortcut } from "../../../react/input";
+import { colors } from "../../../theme/colors";
+import { Box, type InputRenderable, type ScrollBoxRenderable } from "../../../ui";
+import { isDetailBackNavigationKey } from "../../../utils/back-navigation";
+import { isPlainKey } from "../../../utils/keyboard";
+import { usePluginPaneState, usePluginTickerActions } from "../../runtime";
+import { useMineTickers } from "../shared/mine-tickers";
+import { usePaneStatusFooter } from "../shared/pane-footer";
+import { normalizeCik, searchThirteenFFunds } from "./api";
+import { loadFundDetail } from "./data";
+import { formatWeightMaybe } from "./format";
+import { isCikQuery } from "./model";
+import { buildFundOverlap, type FundOverlapRow } from "./overlap";
+import type { FundDetailData, ThirteenFFund } from "./types";
+
+export function FundOverlapView({ data, focused, width }: { data: FundDetailData; focused: boolean; width: number }) {
+  const [query, setQuery] = usePluginPaneState<string>("overlap:query", "");
+  const [target, setTarget] = usePluginPaneState<ThirteenFFund | null>("overlap:target", null);
+  const [selectedId, setSelectedId] = usePluginPaneState<string | null>("overlap:selected", null);
+  const [selectedPositionId, setSelectedPositionId] = usePluginPaneState<string | null>("overlap:position", null);
+  const [funds, setFunds] = useState<ThirteenFFund[]>([]);
+  const [peer, setPeer] = useState<FundDetailData | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [searchFocused, setSearchFocused] = useState(false);
+  const searchRef = useRef<InputRenderable | null>(null);
+  const [focusToken, setFocusToken] = useState(0);
+  const [fundSort, setFundSort] = useState<{ id: "name" | "cik"; desc: boolean }>({ id: "name", desc: false });
+  const [hasMore, setHasMore] = useState(false);
+  const [offset, setOffset] = useState(0);
+  const moreController = useRef<AbortController | null>(null);
+  const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+  const [loadingMore, setLoadingMore] = useState(false);
+  const focusSearch = useCallback(() => { setSearchFocused(true); setFocusToken(value => value + 1); }, []);
+  const [mineOnly, setMineOnly] = usePluginPaneState<boolean>("overlap:mine", false);
+  const [sort, setSort] = usePluginPaneState<{ id: "weight" | "comparedWeight"; desc: boolean }>("overlap:sort", { id: "weight", desc: true });
+  const mine = useMineTickers();
+  const { pinTicker } = usePluginTickerActions();
+  const [refresh, setRefresh] = useState(0);
+  const lastRefresh = useRef(0);
+  useEffect(() => {
+    const controller = new AbortController();
+    setError(null); setPeer(null); setFunds([]); setHasMore(false); setOffset(0); setLoadingMore(false); moreController.current?.abort();
+    if (!target && !query) { setLoading(false); return; }
+    setLoading(true);
+    const forceRefresh = refresh !== lastRefresh.current;
+    lastRefresh.current = refresh;
+    const work = target ? loadFundDetail(target.cik, target.name, controller.signal, { forceRefresh }).then(result => { if (!controller.signal.aborted) setPeer(result); })
+      : isCikQuery(query) ? Promise.resolve().then(() => setFunds([{ cik: normalizeCik(query), name: query }]))
+      : searchThirteenFFunds(query, 50, controller.signal).then(result => { if (!controller.signal.aborted) { setFunds(result.filter(fund => fund.cik !== data.cik)); setHasMore(result.length === 50); setOffset(result.length); } });
+    void work.catch(cause => { if (!controller.signal.aborted) setError(cause instanceof Error ? cause.message : String(cause)); }).finally(() => { if (!controller.signal.aborted) setLoading(false); });
+    return () => { controller.abort(); moreController.current?.abort(); };
+  }, [query, target, refresh, data.cik]);
+  const loadMore = useCallback(() => {
+    if (!hasMore || loadingMore || loading || target) return;
+    moreController.current?.abort(); const request = new AbortController(); moreController.current = request; setLoadingMore(true);
+    void searchThirteenFFunds(query, 50, request.signal, { offset }).then(result => {
+      if (request.signal.aborted) return;
+      setFunds(current => [...new Map([...current, ...result.filter(fund => fund.cik !== data.cik)].map(fund => [fund.cik, fund])).values()]);
+      setHasMore(result.length === 50); setOffset(offset + result.length);
+    }).catch(cause => { if (!request.signal.aborted) setError(cause instanceof Error ? cause.message : String(cause)); }).finally(() => { if (!request.signal.aborted) setLoadingMore(false); });
+  }, [hasMore, loadingMore, loading, target, query, offset, data.cik]);
+  const onScroll = useTableLoadMore(scrollRef, hasMore && !loadingMore && !loading && !target, loadMore);
+  const refreshData = useCallback(() => setRefresh(value => value + 1), []);
+  useShortcut(event => {
+    if (!focused || !target || event.targetEditable || !isDetailBackNavigationKey(event)) return;
+    event.preventDefault?.(); event.stopPropagation?.(); setTarget(null);
+  }, { phase: "before" });
+  useShortcut(event => {
+    if (!focused || event.targetEditable) return;
+    if (isPlainKey(event, "r")) { event.preventDefault?.(); event.stopPropagation?.(); refreshData(); }
+    if (isPlainKey(event, "/") && !target) { event.preventDefault?.(); focusSearch(); }
+    if (isPlainKey(event, "m") && target) { event.preventDefault?.(); setMineOnly(value => !value); }
+  });
+  const mismatch = peer && data.latestForm?.periodOfReport !== peer.latestForm?.periodOfReport;
+  usePaneStatusFooter({ registrationId: "13f-overlap", loading: loading || loadingMore, error, hints: target ? [{ id: "mine", key: "m", label: mineOnly ? "all tickers" : "mine", title: mineOnly ? "All Tickers" : "Mine Only", onPress: () => setMineOnly(value => !value) }] : [{ id: "search", key: "/", label: "search", onPress: focusSearch }] });
+  usePaneNoticeFooter({ registrationId: "13f-overlap-notice", focused, notices: [...(peer?.warnings ?? []), ...(mismatch ? ["The funds have different latest reporting quarters; overlap is unavailable."] : [])] });
+  const rows = useMemo(() => (peer ? buildFundOverlap(data, peer) : []).filter(row => !mineOnly || mine.has(row.ticker)).sort((a, b) => ((a[sort.id] ?? -1) - (b[sort.id] ?? -1)) * (sort.desc ? -1 : 1)), [peer, data, mineOnly, mine, sort]);
+  const positionColumns: DataTableColumn[] = [{ id: "mine", label: "MINE", width: 5, align: "left" }, { id: "ticker", label: "TICKER", width: 10, align: "left" }, { id: "type", label: "TYPE", width: 6, align: "left" }, { id: "issuer", label: "ISSUER", width: Math.max(18, width - 58), align: "left" }, { id: "weight", label: "FIRST %", width: 12, align: "right" }, { id: "comparedWeight", label: "SECOND %", width: 12, align: "right" }];
+  return <DataTableStackView<ThirteenFFund, DataTableColumn>
+    focused={focused && !searchFocused} detailOpen={!!target} onBack={() => setTarget(null)} detailTitle={target?.name}
+    detailContent={<Box flexDirection="column" flexGrow={1}>
+      <KeyValueRow label="First" value={data.name} detail={data.latestForm?.periodOfReport} />
+      <KeyValueRow label="Second" value={peer?.name ?? target?.name ?? ""} detail={peer?.latestForm?.periodOfReport} />
+      <QueryBar width={width} filters={[{ id: "mine", kind: "toggle", label: "Mine", value: mineOnly, onChange: setMineOnly }]} />
+      <DataTableView<FundOverlapRow, DataTableColumn> focused={focused} columns={positionColumns} items={rows} getItemKey={row => row.id}
+        selection={{ kind: "id", selectedId: selectedPositionId, getId: row => row.id, onChange: setSelectedPositionId }}
+        onActivate={row => { if (row.ticker) pinTicker(row.ticker, { floating: true }); }}
+        sortColumnId={sort.id} sortDirection={sort.desc ? "desc" : "asc"}
+        onHeaderClick={id => { if (id === "weight" || id === "comparedWeight") setSort(current => ({ id, desc: current.id === id ? !current.desc : true })); }}
+        renderCell={(row, column, _index, state) => ({ text: column.id === "mine" ? mine.has(row.ticker) ? "yes" : "" : column.id === "weight" ? formatWeightMaybe(row.weight) : column.id === "comparedWeight" ? formatWeightMaybe(row.comparedWeight) : String(row[column.id as keyof FundOverlapRow]), color: state.selected ? colors.selectedText : colors.text })}
+        emptyStateTitle={loading ? "Loading fund positions..." : mismatch ? "Matching reporting quarters unavailable." : "No shared positions."}
+      />
+    </Box>}
+    scrollRef={scrollRef} onBodyScrollActivity={onScroll} resetScrollKey={query}
+    sortColumnId={fundSort.id} sortDirection={fundSort.desc ? "desc" : "asc"} onHeaderClick={id => setFundSort(current => ({ id: id === "cik" ? "cik" : "name", desc: current.id === id ? !current.desc : false }))}
+    rootWidth={width} columns={[{ id: "name", label: "FUND", width: Math.max(20, width - 17), align: "left" }, { id: "cik", label: "CIK", width: 12, align: "left" }]}
+    items={[...funds].sort((a, b) => a[fundSort.id].localeCompare(b[fundSort.id]) * (fundSort.desc ? -1 : 1))} getItemKey={row => row.cik} selection={{ kind: "id", selectedId, getId: row => row.cik, onChange: setSelectedId }}
+    onActivate={fund => { setSearchFocused(false); setTarget(fund); }}
+    rootBefore={<QueryBar width={width} search={{ value: query, onChange: setQuery, placeholder: "Second fund name or CIK", focused, active: searchFocused,
+      onActiveChange: (active) => active ? focusSearch() : setSearchFocused(false), focusToken, inputRef: searchRef, debounceMs: 250,
+      onNavigateDown: () => setSearchFocused(false) }} />}
+    renderCell={(row, column, _index, state) => ({ text: column.id === "name" ? row.name : row.cik, color: state.selected ? colors.selectedText : colors.text })}
+    emptyStateTitle={loading ? "Searching funds..." : query ? "No matching funds." : "Search for a second fund."}
+  />;
+}

package/src/plugins/builtin/thirteenf/overlap.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from "bun:test";
+import { buildFundOverlap } from "./overlap";
+import type { FundDetailData, ThirteenFFormSummary, ThirteenFHoldingRecord } from "./types";
+const form: ThirteenFFormSummary = { url: "", accessionNumber: "current", submissionType: "13F-HR", periodOfReport: "2026-06-30", filedAsOfDate: "2026-08-14", cik: "1", companyName: "Fund", tableValueTotal: 100, tableEntryTotal: 1, isAmendment: false };
+const holding = (overrides: Partial<ThirteenFHoldingRecord> = {}): ThirteenFHoldingRecord => ({ accessionNumber: "current", cik: "1", cusip: "one", ticker: "AAA", issuer: "A", titleOfClass: "COM", putCall: "", shareType: "SH", value: 20, shares: 2, investmentDiscretion: "SOLE", votingAuthoritySole: 2, votingAuthorityShared: 0, votingAuthorityNone: 0, ...overrides });
+const detail = (rows: ThirteenFHoldingRecord[], overrides: Partial<FundDetailData> = {}): FundDetailData => ({ cik: "1", name: "Fund", forms: [form], latestForm: form, previousForm: null, latestHoldings: rows, previousHoldings: [], ...overrides });
+test("overlap matches security identity despite aliases and excludes options and exits from the shared equity", () => {
+  const first = detail([holding(), holding({ putCall: "CALL", value: 30 })], { previousForm: { ...form, periodOfReport: "2026-03-31" }, previousHoldings: [holding({ cusip: "exit", ticker: "BBB" })] });
+  const second = detail([holding({ ticker: "RENAMED", value: 40 }), holding({ cusip: "exit", ticker: "BBB" })], { latestForm: { ...form, tableValueTotal: 200 } });
+  expect(buildFundOverlap(first, second)).toEqual([{ id: "ONE||SH", ticker: "AAA", issuer: "A", type: "SH", weight: 0.2, comparedWeight: 0.2 }]);
+});
+test("overlap cannot mix quarter ends and incomplete reports do not acquire weights", () => {
+  const first = detail([holding()]);
+  expect(buildFundOverlap(first, detail([holding()], { latestForm: { ...form, periodOfReport: "2026-03-31" } }))).toEqual([]);
+  const partial = detail([holding()], { latestReport: { periodOfReport: form.periodOfReport, filings: [form], complete: false, tableValueTotal: null, tableEntryTotal: null } });
+  expect(buildFundOverlap(first, partial)[0]?.comparedWeight).toBeNull();
+});

package/src/plugins/builtin/thirteenf/overlap.ts

@@ -0,0 +1,20 @@
+import { buildFundHoldingRows } from "./model";
+import type { FundDetailData } from "./types";
+
+export interface FundOverlapRow {
+  id: string;
+  ticker: string;
+  issuer: string;
+  type: string;
+  weight: number | null;
+  comparedWeight: number | null;
+}
+export function buildFundOverlap(first: FundDetailData, second: FundDetailData): FundOverlapRow[] {
+  if (!first.latestForm || first.latestForm.periodOfReport !== second.latestForm?.periodOfReport) return [];
+  // Rows are keyed by CUSIP, option side and share type, including when ticker aliases change.
+  const peer = new Map(buildFundHoldingRows(second).filter(row => row.action !== "exit").map(row => [row.id, row]));
+  return buildFundHoldingRows(first).filter(row => row.action !== "exit" && peer.has(row.id)).map(row => ({
+    id: row.id, ticker: row.ticker, issuer: row.issuer, type: row.putCall || row.shareType,
+    weight: row.weight, comparedWeight: peer.get(row.id)!.weight,
+  })).sort((a, b) => (b.weight ?? -1) - (a.weight ?? -1));
+}