@gloom-sh/terminal 0.19.1 → 0.19.3

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

@@ -15,6 +15,7 @@ import { isoDateDaysAgo, isoDateToday, isoDateYearsAgo } from "../../../utils/ca
 import { abortable, withDeadline } from "../../../utils/async-deadline";
 import { logFailure } from "../../../utils/log-failure";
 import {
+  amendmentKind,
   buildBrowserRows,
   filingGapFor,
   estimateFilingQuarterReturn,
@@ -33,6 +34,7 @@ import type {
   FundBrowserRow,
   FundDetailData,
   ThirteenFBrowserTab,
+  ThirteenFDetailLoading,
   ThirteenFFilingGap,
   ThirteenFFund,
   ThirteenFHoldingRecord,
@@ -106,6 +108,8 @@ export interface BrowserLoadResult {
   period?: string;
   quarter?: string;
   warning?: string;
+  /** A refresh failed and the oldest copy that answered instead was saved at this time (ms). */
+  savedAt?: number;
   hasMore?: boolean;
   nextOffset?: number;
   reportsLoaded?: Promise<void>;
@@ -118,11 +122,31 @@ export async function loadBrowserRows(
   options: Pick<Forms13FReadOptions, "forceRefresh" | "onSavedCopy"> & { offset?: number; limit?: number } = {},
 ): Promise<BrowserLoadResult> {
   const warnings: string[] = [];
-  const result = await loadBrowserPage(tab, query, signal, { ...options, onWarning: warning => warnings.push(warning) });
+  const page: { result?: BrowserLoadResult; savedAt?: number } = {};
+  const onSavedCopy = (savedAt: number) => {
+    page.savedAt = Math.min(page.savedAt ?? savedAt, savedAt);
+    // The rows' reports answer after the page does, and their copies date it too.
+    if (page.result) page.result.savedAt = page.savedAt;
+    options.onSavedCopy?.(savedAt);
+  };
+  const result = await loadBrowserPage(tab, query, signal, { ...options, onSavedCopy, onWarning: warning => warnings.push(warning) });
+  page.result = result;
+  if (page.savedAt != null) result.savedAt = page.savedAt;
   if (warnings.length) result.warning = [...new Set([result.warning, ...warnings].filter(Boolean))].join(" ") || undefined;
   return result;
 }
 
+/** The oldest saved copy a load answered from (`savedAt`), each also passed on to `onSavedCopy`. */
+function savedCopies(onSavedCopy?: (savedAt: number) => void) {
+  const copies: { savedAt?: number; note: (savedAt: number) => void } = {
+    note: (savedAt) => {
+      copies.savedAt = Math.min(copies.savedAt ?? savedAt, savedAt);
+      onSavedCopy?.(savedAt);
+    },
+  };
+  return copies;
+}
+
 async function loadBrowserPage(
   tab: ThirteenFBrowserTab,
   query: string,
@@ -140,9 +164,12 @@ async function loadBrowserPage(
   const pageApiOptions = { ...apiOptions, offset };
 
   if (tab === "performance") {
-    const topFunds = await listTopThirteenFFunds(quarter, browserLimit, signal, pageApiOptions);
     const quarters = priorQuarters(quarter);
-    const history = await loadRankingHistory(quarters, signal, apiOptions);
+    // The prior quarters' rankings do not depend on this page, so they are read beside it.
+    const [topFunds, history] = await Promise.all([
+      listTopThirteenFFunds(quarter, browserLimit, signal, pageApiOptions),
+      loadRankingHistory(quarters, signal, apiOptions),
+    ]);
     const funds: ThirteenFFund[] = topFunds.map((fund) => ({ cik: fund.cik, name: fund.name }));
     const rows = buildBrowserRows({ topFunds, source: "performance" }).map(row => ({ ...row, priorReturns: quarters.map((previous, index) => ({ quarter: previous, value: history[index]?.get(row.cik) ?? null })) }));
     const result: BrowserLoadResult = {
@@ -161,7 +188,10 @@ async function loadBrowserPage(
 
   if (tab === "latest") {
     const filings = await listThirteenFFilings(isoDateDaysAgo(21, now), to, latestLimit, signal, pageApiOptions);
-    const selected = dedupeLatestForms(filings);
+    // An original filing or a restatement is its period's whole report, and an
+    // amendment of unknown kind shows no totals either way: only one that adds
+    // NEW HOLDINGS needs the fund's earlier filing for its quarter's totals.
+    const selected = dedupeLatestForms(filings).filter((form) => amendmentKind(form) === "new-holdings");
     const rows = buildBrowserRows({ latestFilings: filings, source: "latest" });
     const result: BrowserLoadResult = {
       rows,
@@ -440,7 +470,8 @@ export async function loadFundPerformance(
   options: Pick<Forms13FReadOptions, "forceRefresh" | "onSavedCopy"> & { splitFactor?: SplitFactorLookup } = {},
 ): Promise<FundPerformanceResult> {
   const warnings: string[] = [];
-  const apiOptions = { forceRefresh: options.forceRefresh, onSavedCopy: options.onSavedCopy, onWarning: (warning: string) => warnings.push(warning) };
+  const saved = savedCopies(options.onSavedCopy);
+  const apiOptions = { forceRefresh: options.forceRefresh, onSavedCopy: saved.note, onWarning: (warning: string) => warnings.push(warning) };
   const detail = await loadFundDetail(cik, fallbackName, signal, options);
   const period = detail.latestForm?.periodOfReport;
   const quarter = period ? periodToQuarter(period) : null;
@@ -482,7 +513,9 @@ export async function loadFundPerformance(
         : filed?.skipped.length ? `No share position held through the quarter to ${period} that could be priced across it.`
           : `No share position held through the quarter to ${period}.`;
   const warning = [...new Set([...(detail.warnings ?? []), ...warnings])].join(" ") || undefined;
+  const savedAt = Math.min(detail.savedAt ?? Infinity, saved.savedAt ?? Infinity);
   return {
+    ...(Number.isFinite(savedAt) ? { savedAt } : {}),
     rows: [row], ...(quarter ? { quarter } : {}), ...(period ? { period } : {}), hasMore: false, basis, ranking,
     ...(filed?.splits.length ? { splits: filed.splits } : {}),
     ...(filed?.skipped.length ? { skipped: filed.skipped } : {}),
@@ -491,16 +524,71 @@ export async function loadFundPerformance(
   };
 }
 
+/** Rows a fund's two newest reports may hold together for their holdings to be read ahead. */
+const PREFETCH_HOLDINGS_MAX = 2_000;
+
+/**
+ * Reads ahead what opening a fund asks first, while the cursor rests on its
+ * row: its filing list, which every other request waits on, and the holdings
+ * of its two newest reports when they hold PREFETCH_HOLDINGS_MAX rows or fewer
+ * together. A large filer's holdings wait for Enter. These are loadFundDetail's
+ * own requests, so opening the fund reads them from cache or joins them.
+ */
+export async function prefetchFundDetail(cik: string, signal: AbortSignal): Promise<void> {
+  const now = new Date();
+  const forms = await listThirteenFForms(cik, isoDateYearsAgo(4, now), isoDateToday(now), 100, signal);
+  const filings = buildPeriodReports(forms).slice(0, 2).flatMap((report) => report.filings);
+  const rows = filings.reduce((sum, form) => sum + (form.tableEntryTotal ?? Infinity), 0);
+  if (!filings.length || rows > PREFETCH_HOLDINGS_MAX) return;
+  await Promise.all(filings.map((form) => listThirteenFFormHoldings(cik, form.accessionNumber, signal, { entries: form.tableEntryTotal })));
+}
+
+/**
+ * One fund read ahead at a time (prefetchFundDetail): resting on another row
+ * stops the last one's requests, and `cancel` stops it when the list goes.
+ */
+export function createFundPrefetcher(prefetch: (cik: string, signal: AbortSignal) => Promise<void> = prefetchFundDetail) {
+  let current: { cik: string; controller: AbortController } | null = null;
+  return {
+    prefetch(cik: string) {
+      if (current?.cik === cik) return;
+      current?.controller.abort();
+      const entry = { cik, controller: new AbortController() };
+      current = entry;
+      void prefetch(cik, entry.controller.signal).catch(() => {
+        // Intentional ignore: a fund read ahead that fails is read again, and the failure shown, when it opens.
+      }).finally(() => {
+        if (current === entry) current = null;
+      });
+    },
+    cancel() {
+      current?.controller.abort();
+      current = null;
+    },
+  };
+}
+
+/**
+ * A fund's latest report and the one before it, with their holdings. With
+ * `onProgress`, the fund as it fills in: the latest report's holdings as
+ * soon as they are read (a large filing's first rows before the rest), then
+ * the prior quarter they are compared with and EDGAR's filing list, each
+ * part still loading named in `loading`. The answer is the whole fund.
+ */
 export async function loadFundDetail(
   cik: string,
   fallbackName: string,
   signal?: AbortSignal,
   /** `filingGap: false` skips EDGAR's filing list, for a load that never shows it (an overlap). */
-  options: Pick<Forms13FReadOptions, "forceRefresh" | "onSavedCopy"> & { filingGap?: boolean } = {},
+  options: Pick<Forms13FReadOptions, "forceRefresh" | "onSavedCopy"> & {
+    filingGap?: boolean;
+    onProgress?: (detail: FundDetailData) => void;
+  } = {},
 ): Promise<FundDetailData> {
   const now = new Date();
   const warnings: string[] = [];
-  const apiOptions = { forceRefresh: options.forceRefresh, onSavedCopy: options.onSavedCopy, onWarning: (warning: string) => warnings.push(warning) };
+  const saved = savedCopies(options.onSavedCopy);
+  const apiOptions = { forceRefresh: options.forceRefresh, onSavedCopy: saved.note, onWarning: (warning: string) => warnings.push(warning) };
 
   const forms = await listThirteenFForms(
     cik,
@@ -515,46 +603,87 @@ export async function loadFundDetail(
   const previousReport = reports[1];
   const latestForm = latestReport?.filings.at(-1) ?? null;
   const previousForm = previousReport?.filings.at(-1) ?? null;
-  async function loadReport(report: ThirteenFPeriodReport | undefined): Promise<ThirteenFHoldingRecord[]> {
+  const checkGap = options.filingGap !== false;
+  const parts: Pick<FundDetailData, "latestHoldings" | "previousHoldings" | "filingGap"> & { loading: ThirteenFDetailLoading } = {
+    latestHoldings: [],
+    previousHoldings: [],
+    filingGap: null,
+    loading: { positions: true, ...(previousReport ? { comparison: true } : {}), ...(checkGap ? { filingGap: true } : {}) },
+  };
+  const detail = (): FundDetailData => {
+    const loading = Object.fromEntries(Object.entries(parts.loading).filter(([, value]) => value)) as ThirteenFDetailLoading;
+    return {
+      cik: normalizeCik(cik),
+      name: latestForm?.companyName || fallbackName,
+      forms,
+      latestForm,
+      previousForm,
+      latestHoldings: parts.latestHoldings,
+      previousHoldings: parts.previousHoldings,
+      latestReport,
+      previousReport,
+      warnings: [...warnings],
+      filingGap: parts.filingGap,
+      ...(saved.savedAt != null ? { savedAt: saved.savedAt } : {}),
+      ...(Object.keys(loading).length ? { loading } : {}),
+    };
+  };
+  let failed = false;
+  // The fund is shown once its latest holdings, or a large filing's first rows, are in.
+  const progress = () => {
+    if (!options.onProgress || failed || signal?.aborted || (parts.loading.positions && !parts.latestHoldings.length)) return;
+    options.onProgress(detail());
+  };
+  async function loadReport(report: ThirteenFPeriodReport | undefined, onFirstRows?: (rows: ThirteenFHoldingRecord[]) => void): Promise<ThirteenFHoldingRecord[]> {
     if (!report) return [];
-    const holdings: ThirteenFHoldingRecord[] = [];
-    for (const form of report.filings) {
-      const rows = await listThirteenFFormHoldings(cik, form.accessionNumber, signal, apiOptions);
-      holdings.push(...rows);
+    // An amended period's filings are read at once: the original and each of its additions.
+    const filings = await Promise.all(report.filings.map((form, index) => listThirteenFFormHoldings(cik, form.accessionNumber, signal, {
+      ...apiOptions,
+      entries: form.tableEntryTotal,
+      ...(index === 0 && onFirstRows ? { onFirstRows } : {}),
+    })));
+    report.filings.forEach((form, index) => {
+      const rows = filings[index]!;
       if (form.tableEntryTotal != null && rows.length !== form.tableEntryTotal) {
         report.complete = false;
         warnings.push(`${report.periodOfReport}: loaded ${rows.length} of ${form.tableEntryTotal} disclosed entries for ${form.accessionNumber}.`);
       }
-    }
+    });
     if (!report.complete && !warnings.some((warning) => warning.startsWith(report.periodOfReport))) {
       warnings.push(`${report.periodOfReport}: amendment type or original report unavailable; disclosed entries cannot be reconciled into a full report.`);
     }
-    return holdings;
+    return filings.flat();
   }
-  const [latestHoldings, previousHoldings, filingGap] = await Promise.all([
-    loadReport(latestReport),
+  await Promise.all([
+    loadReport(latestReport, options.onProgress ? (rows) => {
+      if (!parts.loading.positions) return;
+      parts.latestHoldings = rows;
+      progress();
+    } : undefined).then((rows) => {
+      parts.latestHoldings = rows;
+      parts.loading.positions = false;
+      progress();
+    }),
     loadReport(previousReport).catch((error) => {
       if (signal?.aborted) throw error;
       if (previousReport) previousReport.complete = false;
       warnings.push(`${previousReport?.periodOfReport ?? "Prior quarter"}: holdings unavailable; comparison unavailable.`);
       return [];
+    }).then((rows) => {
+      parts.previousHoldings = rows;
+      parts.loading.comparison = false;
+      progress();
     }),
-    options.filingGap === false ? null
-      : loadFilingGap(cik, latestForm?.periodOfReport, signal, now, { forceRefresh: options.forceRefresh }),
-  ]);
-  return {
-    cik: normalizeCik(cik),
-    name: latestForm?.companyName || fallbackName,
-    forms,
-    latestForm,
-    previousForm,
-    latestHoldings,
-    previousHoldings,
-    latestReport,
-    previousReport,
-    warnings,
-    filingGap,
-  };
+    (checkGap ? loadFilingGap(cik, latestForm?.periodOfReport, signal, now, { forceRefresh: options.forceRefresh }) : Promise.resolve(null)).then((gap) => {
+      parts.filingGap = gap;
+      parts.loading.filingGap = false;
+      progress();
+    }),
+  ]).catch((error: unknown) => {
+    failed = true;
+    throw error;
+  });
+  return detail();
 }
 
 export async function loadFilingPositions(
@@ -562,12 +691,13 @@ export async function loadFilingPositions(
   accessionNumber: string,
   signal?: AbortSignal,
   options: { forceRefresh?: boolean; offset?: number; limit?: number } = {},
-): Promise<{ rows: ThirteenFHoldingRecord[]; hasMore: boolean; warnings: string[] }> {
+): Promise<{ rows: ThirteenFHoldingRecord[]; hasMore: boolean; warnings: string[]; savedAt?: number }> {
   const warnings: string[] = [];
+  const saved = savedCopies();
   const result = await listThirteenFFormHoldingsPage(cik, accessionNumber, signal, {
-    ...options, onWarning: warning => warnings.push(warning),
+    ...options, onSavedCopy: saved.note, onWarning: warning => warnings.push(warning),
   });
-  return { ...result, warnings };
+  return { ...result, warnings, ...(saved.savedAt != null ? { savedAt: saved.savedAt } : {}) };
 }
 
 /** `2026Q2` for a quarter end such as 2026-06-30. */

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

@@ -6,13 +6,11 @@ import {
   inferBrowserTabFromQuery,
   isCikQuery,
 } from "./model";
-import { ThirteenFPane } from "./pane";
 import {
   attachThirteenFApiPersistence,
   resetThirteenFApiPersistence,
 } from "./api";
 import { thirteenFHeadless } from "./headless";
-import { ThirteenFTickerPane } from "./signals-pane";
 import { isKnownNonUsListing } from "../../../utils/sec";
 import { isKnownMutualFund } from "../../../tickers/instrument-kind";
 
@@ -32,7 +30,7 @@ export const thirteenFModule: PluginModule = {
       id: "thirteenf",
       name: "13F",
       order: 39,
-      component: ThirteenFTickerPane,
+      get component(): typeof import("./signals-pane").ThirteenFTickerPane { const { ThirteenFTickerPane } = require("./signals-pane"); return ThirteenFTickerPane; },
       instruments: ["equity", "fund"],
       isVisible: ({ ticker, financials }) => !isKnownNonUsListing(ticker) && !isKnownMutualFund(ticker, financials),
     });
@@ -47,7 +45,7 @@ export const thirteenFModule: PluginModule = {
       id: THIRTEENF_PANE_ID,
       name: "13F Funds",
       icon: "13F",
-      component: ThirteenFPane,
+      get component(): typeof import("./pane").ThirteenFPane { const { ThirteenFPane } = require("./pane"); return ThirteenFPane; },
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 112, height: 36 },

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

@@ -547,6 +547,8 @@ export function estimateFilingQuarterReturn(data: FundDetailData, splits: SplitF
 
 export function hasComparable13FQuarter(data: FundDetailData): boolean {
   if (data.latestReport?.complete === false || data.previousReport?.complete === false) return false;
+  // Until both quarters are in whole, a line one of them lacks is not a buy or a sale.
+  if (data.loading?.positions || data.loading?.comparison) return false;
   const current = data.latestForm?.periodOfReport;
   const previous = data.previousForm?.periodOfReport;
   return adjacentQuarterPeriods(current, previous);

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

@@ -10,6 +10,7 @@ import { usePluginPaneState, usePluginTickerActions } from "../../runtime";
 import { useMineTickers } from "../shared/mine-tickers";
 import { usePaneStatusFooter } from "../../../components/layout/pane/status-footer";
 import { handleRefreshKey } from "../../../components/data-table/table-pane";
+import { savedCopyFooterInfo } from "../../../components/layout/pane/footer";
 import { useAsyncResource } from "../../../react/async-resource";
 import { cachedFunds, cachedMembers, loadFunds, loadMembers } from "../members/client";
 import { coveredFund } from "../members/model";
@@ -115,7 +116,10 @@ export function FundOverlapView({ data, focused, width }: { data: FundDetailData
   const period = peer ? overlapPeriod(data, peer) : null;
   const mismatch = peer && !period;
   const listError = etf ? etfFile.error : error ?? paged.error?.message ?? paged.moreError?.message ?? null;
-  usePaneStatusFooter({ registrationId: "13f-overlap", loading: loading || loadingMore || paged.loading || (!!etf && etfFile.loading), error: listError, hints: open ? [{ 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 }] });
+  // Either side answered from a copy a failed refresh left says when it was saved.
+  const etfSavedAt = etf ? etfFile.data?.savedAt : null;
+  const savedInfo = useMemo(() => savedCopyFooterInfo([data.savedAt, peer?.savedAt, etfSavedAt]), [data.savedAt, peer?.savedAt, etfSavedAt]);
+  usePaneStatusFooter({ registrationId: "13f-overlap", loading: loading || loadingMore || paged.loading || (!!etf && etfFile.loading), error: listError, info: savedInfo, hints: open ? [{ 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 ? ["No reporting quarter is loaded for both funds; overlap is unavailable."] : []),

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

@@ -2,7 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   DataTableStackView,
   DataTableView,
-  EmptyState, PaneStatusBody, QueryBar, StatGrid, usePagedRows, usePaneNoticeFooter, usePaneTabs, useQueryBarSearch, useTableLoadMore, type DataTableKeyEvent,
+  EmptyState, PaneStatusBody, QueryBar, StatGrid, usePagedRows, usePaneFooter, usePaneNoticeFooter, usePaneTabs, useQueryBarSearch, useTableLoadMore, type DataTableKeyEvent,
   type DataTableRootKeyContext, type PageRequest, type PaneFooterSegment, type PaneHint, type StatItem
 } from "../../../components";
 import { useShortcut } from "../../../react/input";
@@ -23,10 +23,10 @@ import { nextHeaderSort } from "../../../utils/sort-values";
 import { useAssetData, usePluginPaneState, usePluginTickerActions } from "../../runtime";
 import { useMineTickers } from "../shared/mine-tickers";
 import { usePaneStatusFooter, usePaneStatusLinkFooter } from "../../../components/layout/pane/status-footer";
-import { corporateSplitFactor, loadBrowserRows, loadFilingPositions, loadFundDetail, loadSplitFactors } from "./data";
+import { corporateSplitFactor, createFundPrefetcher, loadBrowserRows, loadFilingPositions, loadFundDetail, loadSplitFactors } from "./data";
 import { FundOverlapView } from "./overlap-pane";
 import { ThirteenFCrowdingPane, ThirteenFTickerHoldingsView } from "./signals-pane";
-import { PaneFooterScope } from "../../../components/layout/pane/footer";
+import { PaneFooterScope, savedCopyFooterInfo } from "../../../components/layout/pane/footer";
 import { handleRefreshKey } from "../../../components/data-table/table-pane";
 import { useClaimResearchTabKeys } from "../ticker-detail/research-tab-keys";
 import {
@@ -129,6 +129,9 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
     const notes = [...(pagesSettled ? browser.pages.map((page) => page.warning) : []), browser.moreError?.message];
     return [...new Set(notes.filter(Boolean))].join(" ") || null;
   }, [browser.moreError, browser.pages, pagesSettled, reportPaint]);
+  // A page a failed refresh answered from a saved copy says when it was saved, as every pane does.
+  const savedInfo = useMemo(() => savedCopyFooterInfo(pagesSettled ? browser.pages.map((page) => page.savedAt) : []),
+    [browser.pages, pagesSettled, reportPaint]);
   const [detailSeed, setDetailSeed] = useState<FundSeed | null>(() => (
     initialCik ? { cik: String(initialCik), name: normalizedQuery || String(initialCik) } : null
   ));
@@ -166,7 +169,9 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
   }, { allowEditable: true });
 
   const browserSort = useMemo(() => browserSortFor(sortPreference, browserMode), [sortPreference, browserMode]);
-  const sortedRows = useMemo(() => sortBrowserRows(rows, browserSort), [rows, browserSort, reportPaint]);
+  // The rows' reports fill the rows in place after their page answers (from the network or a saved copy);
+  // a row the table drew before then is drawn again only as a new object.
+  const sortedRows = useMemo(() => sortBrowserRows(rows.map((row) => ({ ...row })), browserSort), [rows, browserSort, reportPaint]);
   const columns = useMemo(() => {
     if (browserMode !== "performance") return buildBrowserColumns(false);
     const history = rows[0]?.priorReturns ?? [];
@@ -191,18 +196,17 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
     blurSearch();
     setDetailSeed({ cik: row.cik, name: row.name });
   }, [blurSearch]);
-  // Every request behind a fund detail is cached per path, so warming it
-  // while the cursor rests on the row makes Enter read from cache.
-  const prefetchDetail = useCallback((row: FundBrowserRow) => {
-    void loadFundDetail(row.cik, row.name).catch(() => {
-      // Intentional ignore: speculative prefetch is retried and failures are shown when the fund opens.
-    });
-  }, []);
+  // The fund's first requests are read ahead while the cursor rests on its
+  // row, one fund at a time, and stopped when the cursor moves on.
+  const prefetcher = useMemo(() => createFundPrefetcher(), []);
+  useEffect(() => () => prefetcher.cancel(), [prefetcher]);
+  const prefetchDetail = useCallback((row: FundBrowserRow) => prefetcher.prefetch(row.cik), [prefetcher]);
 
   const browserStatusInfo = useMemo<PaneFooterSegment[]>(() => [
         ...(loadingMore ? [{ id: "loading-more", parts: [{ text: "loading more", tone: "muted" as const }] }] : []),
         ...(warning ? [{ id: "warning", parts: [{ text: warning, tone: "warning" as const }] }] : []),
-  ], [loadingMore, warning]);
+        ...savedInfo,
+  ], [loadingMore, warning, savedInfo]);
   const searchHints = useMemo(() => [{ id: "search", key: "/", label: "search", onPress: focusSearch }], [focusSearch]);
   usePaneStatusFooter({
     registrationId: THIRTEENF_PANE_ID,
@@ -366,7 +370,11 @@ export function FundDetailView({
     abortRef.current = controller;
     setStatus("loading");
     setError(null);
-    void loadFundDetail(seed.cik, seed.name, controller.signal, { forceRefresh: refresh })
+    void loadFundDetail(seed.cik, seed.name, controller.signal, {
+      forceRefresh: refresh,
+      // A first load shows the fund as it fills in; a refresh keeps what is on screen until it answers whole.
+      ...(refresh ? {} : { onProgress: (partial: FundDetailData) => { if (abortRef.current === controller) setData(partial); } }),
+    })
       .then((nextData) => {
         if (abortRef.current !== controller) return;
         setData(nextData);
@@ -386,6 +394,8 @@ export function FundDetailView({
       .catch((loadError) => {
         if (abortRef.current !== controller) return;
         if (loadError instanceof Error && loadError.name === "AbortError") return;
+        // A first load that failed after its first rows shows the error, not a part of the filing as the fund.
+        setData((current) => current?.loading ? null : current);
         setError(loadError instanceof Error ? loadError.message : String(loadError));
         setStatus("error");
       });
@@ -516,7 +526,10 @@ export function FundDetailView({
       ...(staleFiling ? { tone: "warning" as const } : {}) },
     data && hasComparable13FQuarter(data)
       ? { id: "compared", label: "Compared with", value: data.previousForm!.periodOfReport }
-      : { id: "compared", label: "Compared with", value: "No prior quarter", tone: "muted" },
+      // The quarter the changes will compare with, dim until both are in.
+      : data?.loading && hasComparable13FQuarter({ ...data, loading: undefined })
+        ? { id: "compared", label: "Compared with", value: data.previousForm!.periodOfReport, tone: "muted" }
+        : { id: "compared", label: "Compared with", value: "No prior quarter", tone: "muted" },
     ...(data?.latestReport && data.latestReport.filings.length > 1
       ? [{ id: "combined", label: "Combined", value: `${data.latestReport.filings.length} filings` }]
       : []),
@@ -544,6 +557,9 @@ export function FundDetailView({
   const detailHints = useMemo<PaneHint[]>(() => hasHoldingFiling
     ? [{ id: "filing", key: "f", label: "iling", title: "Open Filing", onPress: openSelectedFilingInPane }]
     : [], [hasHoldingFiling, openSelectedFilingInPane]);
+  // An open filing and the overlap tab say when their own saved copies are from.
+  const detailSavedInfo = useMemo(() => savedCopyFooterInfo(openFiling || activeTab === "overlap" ? [] : [data?.savedAt]),
+    [activeTab, data?.savedAt, openFiling]);
   usePaneStatusLinkFooter({
     registrationId: "thirteenf-detail",
     focused,
@@ -551,6 +567,7 @@ export function FundDetailView({
     source: openFiling ? "SEC 13F" : null,
     loading: activeTab !== "overlap" && status === "loading",
     error: activeTab === "overlap" ? null : error,
+    info: detailSavedInfo,
     showOpenHint: true,
     hints: detailHints,
   });
@@ -583,14 +600,16 @@ export function FundDetailView({
         ]}
         meta={data?.name && data.name !== seed.name ? data.name : undefined}
       />
-      {activeTab === "overlap" && data ? <FundOverlapView data={data} focused={focused} width={width} /> : activeTab === "filings" ? (
+      {activeTab === "overlap" && data ? data.loading?.positions || data.loading?.comparison ? (
+        <PaneStatusBody loading align="center" loadingLabel="Loading 13F filing..." />
+      ) : <FundOverlapView data={data} focused={focused} width={width} /> : activeTab === "filings" ? (
         <DataTableStackView<FundTimelineRow, FundTimelineColumn>
           focused={focused}
           detailOpen={!!openFiling}
           onBack={closeOpenFiling}
           detailTitle={openFiling ? `${openFiling.periodOfReport} filing` : "13F filing"}
           detailContent={openFiling ? (
-            <FilingDetailView focused={focused} filing={openFiling} width={width} sourceWarnings={data?.warnings ?? []} />
+            <FilingDetailView focused={focused} filing={openFiling} width={width} sourceWarnings={data?.warnings ?? []} sourceSavedAt={data?.savedAt} />
           ) : (
             <Box flexGrow={1} />
           )}
@@ -659,11 +678,14 @@ function FilingDetailView({
   filing,
   width,
   sourceWarnings,
+  sourceSavedAt,
 }: {
   focused: boolean;
   filing: FundTimelineRow;
   width: number;
   sourceWarnings: string[];
+  /** When the fund's saved copy was saved, when a failed refresh left it on screen. */
+  sourceSavedAt?: number;
 }) {
   const { pinTicker } = usePluginTickerActions();
   const [sortPreference, setSortPreference] = usePluginPaneState<FundSortPreference<FilingPositionColumnId>>(
@@ -711,6 +733,9 @@ function FilingDetailView({
   );
 
   usePaneNoticeFooter({ registrationId: "thirteenf-filing-notices", notices: [...new Set([...sourceWarnings, ...warnings])], focused });
+  const savedInfo = useMemo(() => savedCopyFooterInfo([sourceSavedAt, ...(pagesSettled ? positions.pages.map((page) => page.savedAt) : [])]),
+    [pagesSettled, positions.pages, sourceSavedAt]);
+  usePaneFooter("thirteenf-filing-saved", () => ({ info: savedInfo }), [savedInfo]);
 
   // An untyped amendment may replace or add to the report, so only it is a caveat.
   const kind = amendmentKind(filing);

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

@@ -99,6 +99,20 @@ export interface FundDetailData {
   warnings?: string[];
   /** Set when the latest report predates the newest quarter past its deadline. */
   filingGap?: ThirteenFFilingGap | null;
+  /** A refresh failed and the oldest copy that answered instead was saved at this time (ms). */
+  savedAt?: number;
+  /** The parts still loading, while the fund fills in (loadFundDetail's `onProgress`); absent once whole. */
+  loading?: ThirteenFDetailLoading;
+}
+
+/** Parts of a fund's detail still loading. */
+export interface ThirteenFDetailLoading {
+  /** The latest report's holdings are a large filing's first rows. */
+  positions?: boolean;
+  /** The prior quarter's holdings, which the latest are compared with. */
+  comparison?: boolean;
+  /** EDGAR's filing list, for a fund behind on its filings. */
+  filingGap?: boolean;
 }
 
 /** A manager a 13F-NT names as reporting its holdings. */

package/src/plugins/builtin/ticker-detail/data-panes/historical-prices.tsx

@@ -24,7 +24,8 @@ import {
   barPriceDecimals, formatBarPrice, historyAllStart, historyBarsAfterHole, historyChangeBaseNote, historyMissingPeriodsNote, quotedPriceDivisor,
 } from "../../../../cli/history-rows";
 import {
-  MISSING_VOLUME_TEXT, missingVolumeCount, missingVolumeNotice, pricePointValues, priceHistoryIntegrityNotice,
+  MISSING_VOLUME_TEXT, missingVolumeCount, missingVolumeNotice, pricePointValues, pricePointWickFlags, priceHistoryIntegrityNotice,
+  priceHistoryWickNotice,
 } from "../../../../utils/price-history-integrity";
 import {
   useAssetData,
@@ -130,7 +131,9 @@ function buildHistoricalPriceRows(points: PricePoint[], venue: string | undefine
   const sorted = points
     .flatMap((point, sourceIndex) => {
       const date = pricePointDate(point);
-      return date ? [{ point: pricePointValues(point), date, sourceIndex, partial: point.partial === true, filled: point.filled === true }] : [];
+      return date ? [{
+        point: pricePointValues(point), date, sourceIndex, partial: point.partial === true, filled: point.filled === true, contract: point.contract,
+      }] : [];
     })
     .sort((left, right) => left.date.getTime() - right.date.getTime());
   const size = historyBarSize(sorted.map((entry) => entry.date.getTime()));
@@ -141,10 +144,21 @@ function buildHistoricalPriceRows(points: PricePoint[], venue: string | undefine
   const times = sorted.map((entry) => entry.date.getTime());
   const interval = size === "intraday" ? null : size;
   const afterGap = historyBarsAfterHole(times, interval);
-  const gapNotices = [historyMissingPeriodsNote(times, interval), historyChangeBaseNote(times, interval)]
-    .filter((notice): notice is string => notice != null);
+  // A continuous future's bar on another contract than the bar before has no change: two months' prices are no move.
+  let held: string | undefined;
+  const rolled = sorted.map((entry) => {
+    const roll = !!entry.contract && !!held && held !== entry.contract;
+    held = entry.contract ?? held;
+    return roll;
+  });
+  const rolls = sorted.flatMap((entry, index) => rolled[index] ? [`${entry.date.toISOString().slice(0, 10)} (${entry.contract})`] : []);
+  const gapNotices = [
+    historyMissingPeriodsNote(times, interval),
+    historyChangeBaseNote(times, interval),
+    rolls.length > 0 ? `No CHG at ${rolls.length === 1 ? "the roll" : "each roll"} to a new contract: ${rolls.join(", ")}` : null,
+  ].filter((notice): notice is string => notice != null);
   const rows = sorted.map((entry, index) => {
-    const previous = sorted[index - 1]?.point;
+    const previous = rolled[index] ? undefined : sorted[index - 1]?.point;
     const { point, date, sourceIndex, filled } = entry;
     const newest = index === sorted.length - 1;
     const partial = newest && (!!forming || dayToDate);
@@ -257,6 +271,7 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
     [points, venue],
   );
   const integrityNotice = priceHistoryIntegrityNotice(rows.filter((row) => row.point.integrity).length);
+  const wickNotice = useMemo(() => priceHistoryWickNotice(points.filter((point) => pricePointWickFlags(point).length > 0).length), [points]);
   const volumeMissing = useMemo(() => missingVolumeCount(rows.map((row) => ({
     ...row.point, date: row.time, partial: row.partial, filled: row.filled,
   }))), [rows]);
@@ -356,7 +371,7 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
 
   usePaneNoticeFooter({
     registrationId: "historical-prices:integrity",
-    notices: [integrityNotice, volumeNotice, ...gapNotices].filter((notice): notice is string => !!notice),
+    notices: [integrityNotice, wickNotice, volumeNotice, ...gapNotices].filter((notice): notice is string => !!notice),
     focused,
     title: "Price history data",
   });
@@ -404,6 +419,7 @@ export function HistoricalPricesPane({ focused, width, height }: PaneProps) {
           : loading ? (rows.length ? "Refreshing" : "Loading") : rows.length ? "Available" : "Empty"],
         ...(allStart ? [["Source starts", allStart]] : []),
         ...(integrityNotice ? [["Warning", integrityNotice]] : []),
+        ...(wickNotice ? [["Warning", wickNotice]] : []),
         ...gapNotices.map((notice) => ["Gap note", notice]),
         ...(volumeNotice ? [["Volume note", volumeNotice]] : []),
         ...(error ? [["Error", error]] : []),