gloomberb 0.19.0 → 0.19.2

package/src/plugins/builtin/shared/pro-lock-note.ts

@@ -70,19 +70,23 @@ async function routeAnswers(route: FreeRoute, check: NonNullable<FreeRoute["answ
  * symbol the routes read `<ticker>` and the first is named; without a way to
  * read data, only a route that answers for every symbol is.
  */
-async function answeringFreeRoute(lock: PaneLock, routes: readonly FreeRoute[]): Promise<FreeRoute | null> {
+async function answeringFreeRoute(lock: PaneLock, routes: readonly FreeRoute[]): Promise<{ route: FreeRoute | null; noneHasData: boolean }> {
   const { symbol, context } = lock;
-  if (!symbol) return routes[0] ?? null;
+  if (!symbol) return { route: routes[0] ?? null, noneHasData: false };
   // Routes past the first that needs no check are never named, so they are not checked.
   const unchecked = routes.findIndex((route) => !route.answers);
   const candidates = unchecked < 0 ? routes : routes.slice(0, unchecked + 1);
   const deadline = Date.now() + ROUTE_CHECK_WAIT_MS;
   const checks = candidates.map((route) => !route.answers ? Promise.resolve(true)
-    : context ? routeAnswers(route, route.answers, symbol, context, deadline) : Promise.resolve(false));
+    : context ? routeAnswers(route, route.answers, symbol, context, deadline) : Promise.resolve(null));
+  const answered: Array<boolean | null> = [];
   for (const [index, check] of checks.entries()) {
-    if (await check) return candidates[index]!;
+    const answer = await check;
+    if (answer) return { route: candidates[index]!, noneHasData: false };
+    answered.push(answer);
   }
-  return null;
+  // Every check answered no: a failed or stalled one is not known to.
+  return { route: null, noneHasData: candidates.length > 0 && answered.every((answer) => answer === false) };
 }
 
 /**
@@ -114,6 +118,14 @@ export async function proLockNote(
      * command repeats the ticker only when the reader gave one. Default `ticker`.
      */
     argument?: "ticker" | "optional" | "none";
+    /**
+     * For a function that reads what its free routes read (RISK the SEC's
+     * 10-Ks and 20-Fs, FLOW the listing's options): the sentence the note
+     * says when every route answered that the symbol has none. The note then
+     * names no command for the symbol, which would read nothing once unlocked
+     * either: IAG:LSE files neither form, and LHA:XETRA has no options served.
+     */
+    noneFor?: (ticker: string) => string;
   },
 ): Promise<string> {
   const { gate, symbol, token: typed, verifyEmail } = lock;
@@ -129,12 +141,15 @@ export async function proLockNote(
   const unlock = gate === "pro"
     ? `To read ${pane.shows} in ${token}, upgrade in the app (gloom, then Ctrl+P, UPGRADE)`
     : `To read ${pane.shows} in ${token}, open the app (gloom), ${account}${pro ? ", then upgrade (Ctrl+P, UPGRADE)" : ""}`;
-  const bare = pane.argument === "none" || (pane.argument === "optional" && !symbol);
-  const command = bare ? `gloom fn ${token}` : `gloom fn ${token} ${ticker}`;
-  const free = pane.free ? await answeringFreeRoute(lock, pane.free) : null;
+  const { route: free, noneHasData } = pane.free ? await answeringFreeRoute(lock, pane.free) : { route: null, noneHasData: false };
+  // Unlocking reads nothing for a symbol none of the function's own data covers: it is named only where it has some.
+  const uncovered = noneHasData && !!pane.noneFor;
+  const bare = pane.argument === "none" || (pane.argument === "optional" && (!symbol || uncovered));
+  const command = bare ? `gloom fn ${token}` : `gloom fn ${token} ${uncovered ? "<ticker>" : ticker}`;
   return [
     `${token} ${what}: ${pane.does}. ${without} it shows none of ${pane.shows}.`,
     ...free ? [`Free, with no sign-in: ${free.text(ticker, symbol ?? "the company")}`] : [],
+    ...uncovered ? [pane.noneFor!(ticker)] : [],
     `${unlock}; ${command} then reads with that session.`,
   ].join("\n");
 }

package/src/plugins/builtin/shared/report-freshness.ts

@@ -47,6 +47,14 @@ export function barResolutionFromDates(dates: readonly (string | number | Date)[
 /** Company filings read from EDGAR. Old filings are not stale; there is no schedule to miss. */
 export const SEC_FILINGS: HeadlessPaneFreshness = { source: "SEC EDGAR", status: "not-a-feed", basis: "filed data", oldest: null };
 
+/**
+ * A list of filings, dated by its newest one's filing date and by when it was
+ * read: `newest filing Tue 27 Oct 2026 · retrieved Wed 28 Oct 2026 19:07 UTC`.
+ */
+export const SEC_FILING_ROWS: HeadlessPaneFreshness = {
+  ...SEC_FILINGS, observedKey: "filingDate", asOfLabel: "newest filing", retrievedToo: true,
+};
+
 /**
  * What a filings view opened inside a pane that hosts others (Issuer Debt in
  * Fixed Income) declares as its template's `reportFreshness`, so a capture

package/src/plugins/builtin/shared/research-cells.tsx

@@ -14,7 +14,7 @@ import { displayWidth } from "../../../utils/format";
  */
 
 /** The one placeholder for a value the source does not give. */
-const NO_VALUE = "--";
+export const NO_VALUE = "--";
 
 export const missingCell = (colors: ThemeColors): DataTableCell => ({ text: NO_VALUE, value: null, color: colors.textMuted });
 

package/src/plugins/builtin/shared/series-cache.ts

@@ -74,9 +74,9 @@ export function createSeriesCache(kind: string, staleMs: number): SeriesCache {
   let generation = 0;
   let persistence: PluginPersistence | null = null;
   const withFailure = <T extends SeriesCacheLoadResult>(key: string, result: T): T => {
-    const failure = failures.get(key);
-    return failure
-      ? { ...result, stale: true, source: "stale-fallback", refreshError: failure }
+    // A failure is one whatever it said: an Error without a message still leaves the copy a saved one.
+    return failures.has(key)
+      ? { ...result, stale: true, source: "stale-fallback", refreshError: failures.get(key) }
       : result;
   };
   const loadEntry: SeriesCache["loadEntry"] = async (key, loader, options) => {
@@ -103,7 +103,7 @@ export function createSeriesCache(kind: string, staleMs: number): SeriesCache {
         if (owner === generation && requests.get(key) === request) requests.delete(key);
       }
     }, options);
-    return withFailure(key, { ...data, fetchedAt, stale, source, ...(refreshError ? { refreshError } : {}) });
+    return withFailure(key, { ...data, fetchedAt, stale, source, ...(source === "stale-fallback" ? { refreshError } : {}) });
   };
   const reset = () => {
     generation += 1;

package/src/plugins/builtin/shared/series-warning.ts

@@ -1,5 +1,14 @@
-/** The note a loaded catalog series carries when it is drawn from an old copy. */
-export function cachedSeriesWarning(resource: { stale?: boolean; refreshError?: string | null }): string | undefined {
-  if (resource.refreshError) return `Refresh failed (${resource.refreshError}); showing cached data.`;
-  return resource.stale ? "Showing cached data; the source has not updated since." : undefined;
+/**
+ * What a loaded catalog series says of an old copy. A copy that answered
+ * because its refresh failed carries when it was saved (`savedAt`), which the
+ * chart's footer shows as "saved copy from …", the note every pane gives it.
+ * A cached copy the source has not updated since is a note on the chart.
+ */
+export function cachedSeriesNote(resource: { stale?: boolean; refreshError?: string | null; savedAt?: number | null }): {
+  warning?: string;
+  savedAt?: number;
+} {
+  if (resource.savedAt != null && Number.isFinite(resource.savedAt)) return { savedAt: resource.savedAt };
+  if (resource.refreshError) return { warning: `Refresh failed (${resource.refreshError}); showing cached data.` };
+  return resource.stale ? { warning: "Showing cached data; the source has not updated since." } : {};
 }

package/src/plugins/builtin/short-volume/series.ts

@@ -1,5 +1,5 @@
 import type { SeriesDefinition } from "../../../series/types";
-import { cachedSeriesWarning } from "../shared/series-warning";
+import { cachedSeriesNote } from "../shared/series-warning";
 import { loadShortVolume } from "./client";
 
 /** The share of a ticker's daily on-exchange volume reported as short sales. */
@@ -14,10 +14,9 @@ export const SHORT_VOLUME_SERIES: readonly SeriesDefinition[] = [{
   input: "ticker",
   load: async ({ ticker }) => {
     const resource = await loadShortVolume(ticker!, "nms");
-    const warning = cachedSeriesWarning(resource);
     return {
       points: resource.payload.history.map((point) => ({ date: point.date, value: point.ratioPercent })),
-      ...(warning ? { warning } : {}),
+      ...cachedSeriesNote(resource),
     };
   },
 }];

package/src/plugins/builtin/social-mentions/client.ts

@@ -1,9 +1,10 @@
 import { unavailableText } from "../../../components/ui/status";
 import { apiClient } from "../../../api-client";
-import { ApiRequestError, isAccessDenied } from "../../../api-client/errors";
+import { isAccessDenied } from "../../../api-client/errors";
 import type { SocialMentionDayPosts, SocialMentionPost, SocialMentionsPayload, SocialMentionsRange } from "../../../api-client/social-mentions";
-import { createPluginCache } from "../../../data/plugin-cache";
+import { createPluginCache, savedCopyForTransientFailure } from "../../../data/plugin-cache";
 import { CLOUD_SESSION_REQUIRED } from "../shared/research-cloud-session";
+import { unavailableOnServer } from "../shared/cloud-resource";
 
 export const socialMentionsCache = createPluginCache<SocialMentionsPayload>({
   kind: "social-mentions", source: "gloom-cloud", schemaVersion: 1,
@@ -56,12 +57,15 @@ export function validateSocialMentions(payload: SocialMentionsPayload, symbol: s
 export async function fetchSocialMentions(symbol: string, range: SocialMentionsRange = "1y",
   client: Pick<typeof apiClient, "getCloudSocialMentions"> = apiClient): Promise<SocialMentionsPayload> {
   try { return validateSocialMentions(await client.getCloudSocialMentions(symbol, range), symbol, range); }
-  catch (error) {
-    if (error instanceof ApiRequestError && error.status === 404) throw new Error(unavailableText("social mentions"));
-    throw error;
-  }
+  catch (error) { throw unavailableOnServer(error, unavailableText("social mentions")); }
+}
+export interface SocialMentionsResource {
+  payload: SocialMentionsPayload;
+  stale: boolean;
+  refreshError: string | null;
+  /** When the copy shown was saved, when it is one because its refresh failed. */
+  savedAt?: number;
 }
-export interface SocialMentionsResource { payload: SocialMentionsPayload; stale: boolean; refreshError: string | null }
 const cacheKey = (symbol: string, range: SocialMentionsRange) => `${range}:${symbol}`;
 export function cachedSocialMentions(symbol: string, range: SocialMentionsRange): SocialMentionsResource | null {
   const cached = socialMentionsCache.get(cacheKey(symbol, range), { allowExpired: true });
@@ -70,9 +74,10 @@ export function cachedSocialMentions(symbol: string, range: SocialMentionsRange)
   catch { return null; }
 }
 export async function loadSocialMentions(symbol: string, range: SocialMentionsRange, force = false): Promise<SocialMentionsResource> {
-  const result = await socialMentionsCache.load(cacheKey(symbol, range), () => fetchSocialMentions(symbol, range), { force });
-  if (result.error instanceof ApiRequestError && [401, 403].includes(result.error.status ?? 0)) throw result.error;
-  return { payload: validateSocialMentions(result.data, symbol, range), stale: result.stale, refreshError: result.refreshError ?? null };
+  // A refusal (a signed-out session, any other 4xx but 408 and 429) or a reply that fails validation shows as itself.
+  const result = savedCopyForTransientFailure(await socialMentionsCache.load(cacheKey(symbol, range), () => fetchSocialMentions(symbol, range), { force }));
+  return { payload: validateSocialMentions(result.data, symbol, range), stale: result.stale, refreshError: result.refreshError ?? null,
+    ...(result.source === "stale-fallback" ? { savedAt: result.fetchedAt } : {}) };
 }
 
 /**

package/src/plugins/builtin/social-mentions/series.ts

@@ -1,5 +1,5 @@
 import type { SeriesDefinition } from "../../../series/types";
-import { cachedSeriesWarning } from "../shared/series-warning";
+import { cachedSeriesNote } from "../shared/series-warning";
 import { loadSocialMentions } from "./client";
 
 /** How often a ticker is posted about each day, over the last year. */
@@ -14,10 +14,9 @@ export const SOCIAL_MENTION_SERIES: readonly SeriesDefinition[] = [{
   style: "columns",
   load: async ({ ticker }) => {
     const resource = await loadSocialMentions(ticker!, "1y");
-    const warning = cachedSeriesWarning(resource);
     return {
       points: resource.payload.x.days.map((row) => ({ date: row.day, value: row.mentions })),
-      ...(warning ? { warning } : {}),
+      ...cachedSeriesNote(resource),
     };
   },
 }];

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

@@ -10,7 +10,7 @@ import type {
 } from "./types";
 import type { PluginPersistence } from "../../../types/plugin";
 import { apiClient } from "../../../api-client";
-import { ApiRequestError, isPermanentClientError } from "../../../api-client/errors";
+import { ApiRequestError, isPermanentClientError, isTransientFailure } from "../../../api-client/errors";
 import { httpFetch } from "../../../utils/http-transport";
 import { asRecord, finiteOrNull } from "../../../utils/guards";
 import { logFailure } from "../../../utils/log-failure";
@@ -30,7 +30,14 @@ const FORMS_13F_CACHE_POLICY = {
 } as const;
 
 export interface Forms13FReadOptions {
+  /** A part of the answer that could not be read, said beside what was. */
   onWarning?: (warning: string) => void;
+  /**
+   * A read answered from the copy saved at `savedAt` (ms) because its refresh
+   * failed. Only a caller that says when its copy was saved (the footer's
+   * "saved copy from", a command's closing line) is answered from one.
+   */
+  onSavedCopy?: (savedAt: number) => void;
   forceRefresh?: boolean;
 }
 
@@ -150,18 +157,17 @@ async function fetchForms13F<T>(
     } catch (error) {
       options.signal?.throwIfAborted();
       if (current()) failedRefreshes.add(key);
-      if (isPermanentClientError(error)) {
-        if (current()) store?.deleteResource(CACHE_KIND, key, { sourceKey: CACHE_SOURCE });
+      // A saved copy answers only for a failure asking again may get past; a refusal or a reply that
+      // fails validation is the error, and a missing or denied resource also drops its copy.
+      if (!isTransientFailure(error)) {
+        if (isPermanentClientError(error) && current()) store?.deleteResource(CACHE_KIND, key, { sourceKey: CACHE_SOURCE });
         throw error;
       }
       const retained = options.cache !== false
         ? store?.getResource<T>(CACHE_KIND, key, { ...cacheOptions, allowExpired: true }) : null;
-      // A caller may retain old research only when it can surface its provenance.
-      if (!retained || !options.onWarning) throw error;
-      const retrieved = new Date(retained.fetchedAt);
-      const age = Number.isFinite(retrieved.getTime()) ? `retrieved ${retrieved.toISOString()}` : "with unavailable retrieval time";
-      const reason = (error instanceof Error ? error.message : String(error)).trim() || "Request failed";
-      options.onWarning(`${key}: refresh failed: ${reason}. Retained data ${age}.`);
+      // A caller may retain old research only when it can say when it was saved.
+      if (!retained || !options.onSavedCopy || !Number.isFinite(retained.fetchedAt)) throw error;
+      options.onSavedCopy(retained.fetchedAt);
       return retained.value;
     } finally {
       if (activeRequests.get(key) === slot.promise) activeRequests.delete(key);

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

@@ -106,6 +106,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>;
@@ -115,14 +117,34 @@ export async function loadBrowserRows(
   tab: ThirteenFBrowserTab,
   query: string,
   signal?: AbortSignal,
-  options: { forceRefresh?: boolean; offset?: number; limit?: number } = {},
+  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,
@@ -136,13 +158,13 @@ async function loadBrowserPage(
   const offset = Math.max(0, options.offset ?? 0);
   const browserLimit = Math.max(1, options.limit ?? BROWSER_PAGE_LIMIT);
   const latestLimit = Math.max(1, options.limit ?? LATEST_FILINGS_PAGE_LIMIT);
-  const apiOptions = { forceRefresh: options.forceRefresh, onWarning: options.onWarning };
+  const apiOptions = { forceRefresh: options.forceRefresh, onWarning: options.onWarning, onSavedCopy: options.onSavedCopy };
   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, onWarning: options.onWarning });
+    const history = await 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 = {
@@ -437,10 +459,11 @@ export async function loadFundPerformance(
   cik: string,
   fallbackName: string,
   signal?: AbortSignal,
-  options: { forceRefresh?: boolean; splitFactor?: SplitFactorLookup } = {},
+  options: Pick<Forms13FReadOptions, "forceRefresh" | "onSavedCopy"> & { splitFactor?: SplitFactorLookup } = {},
 ): Promise<FundPerformanceResult> {
   const warnings: string[] = [];
-  const apiOptions = { forceRefresh: options.forceRefresh, 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 +505,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 } : {}),
@@ -496,11 +521,12 @@ export async function loadFundDetail(
   fallbackName: string,
   signal?: AbortSignal,
   /** `filingGap: false` skips EDGAR's filing list, for a load that never shows it (an overlap). */
-  options: { forceRefresh?: boolean; filingGap?: boolean } = {},
+  options: Pick<Forms13FReadOptions, "forceRefresh" | "onSavedCopy"> & { filingGap?: boolean } = {},
 ): Promise<FundDetailData> {
   const now = new Date();
   const warnings: string[] = [];
-  const apiOptions = { forceRefresh: options.forceRefresh, 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,
@@ -554,6 +580,7 @@ export async function loadFundDetail(
     previousReport,
     warnings,
     filingGap,
+    ...(saved.savedAt != null ? { savedAt: saved.savedAt } : {}),
   };
 }
 
@@ -562,12 +589,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/headless.ts

@@ -6,6 +6,7 @@ import type {
   HeadlessShotState,
 } from "../../../types/plugin";
 import { formatShortDate } from "../../../utils/datetime-format";
+import { servedFromSavedCopy } from "../../../data/saved-copies";
 import { normalizeCik, searchThirteenFFunds, TOP_FUNDS_MAX_LIMIT } from "./api";
 import { ApiRequestError } from "../../../api-client/errors";
 import { REPORT_PAGE, REPORT_ROWS } from "../shared/headless-options";
@@ -229,15 +230,40 @@ export interface ThirteenFHeadlessDependencies {
   loadEtfHoldings?(ticker: string, ctx: HeadlessPaneContext): Promise<FundMembersPayload>;
 }
 
+/** The oldest copy a load's 13F reads answered from because their refresh failed, by the load's context. */
+const savedCopies = new WeakMap<HeadlessPaneContext, { savedAt: number | null }>();
+
+/** How a 13F read for the load `ctx` says it answered from the copy saved at `savedAt`. */
+const noteSavedCopy = (ctx: HeadlessPaneContext) => (savedAt: number) => {
+  const entry = savedCopies.get(ctx);
+  if (entry) entry.savedAt = Math.min(entry.savedAt ?? savedAt, savedAt);
+};
+
+/**
+ * One load, whose report ends with when the oldest saved copy it answered
+ * from was saved (`couldn't refresh; saved copy from <time>`), as every
+ * command says it, instead of listing each failed refresh as an error.
+ */
+async function readingSavedCopies<T extends object>(ctx: HeadlessPaneContext, run: () => Promise<T>): Promise<T> {
+  const entry: { savedAt: number | null } = { savedAt: null };
+  savedCopies.set(ctx, entry);
+  try {
+    const result = await run();
+    return entry.savedAt == null ? result : servedFromSavedCopy(result, entry.savedAt);
+  } finally {
+    if (savedCopies.get(ctx) === entry) savedCopies.delete(ctx);
+  }
+}
+
 const defaultDependencies: Required<ThirteenFHeadlessDependencies> = {
   loadBrowser: (tab, query, limit, _args, ctx) => loadBrowserRows(
     tab,
     query,
     ctx.signal,
-    { limit },
+    { limit, onSavedCopy: noteSavedCopy(ctx) },
   ),
   // An overlap never shows a fund's missed quarter, so it does not ask EDGAR.
-  loadDetail: (cik, name, args, ctx) => loadFundDetail(cik, name, ctx.signal, { filingGap: !isOverlapLoad(args) }),
+  loadDetail: (cik, name, args, ctx) => loadFundDetail(cik, name, ctx.signal, { filingGap: !isOverlapLoad(args), onSavedCopy: noteSavedCopy(ctx) }),
   loadSplitFactors: (detail, ctx) => loadSplitFactors(
     detail,
     (ticker, after, through) => corporateSplitFactor(ctx.marketData, ticker, after, through),
@@ -247,6 +273,7 @@ const defaultDependencies: Required<ThirteenFHeadlessDependencies> = {
   searchFunds: (query, ctx) => searchThirteenFFunds(query, THIRTEENF_MAX_LIMIT, ctx.signal),
   loadPerformance: (cik, name, ctx) => loadFundPerformance(cik, name, ctx.signal, {
     splitFactor: (ticker, after, through) => corporateSplitFactor(ctx.marketData, ticker, after, through),
+    onSavedCopy: noteSavedCopy(ctx),
   }),
   loadEtfFunds: async (ctx) => (await fetchFunds(ctx.apiClient)).funds,
   loadEtfHoldings: (ticker, ctx) => fetchMembers(ticker, ctx.apiClient),
@@ -541,7 +568,7 @@ export function createThirteenFHeadless(
     ],
     describe: (args, result) => thirteenFTitle(args, result?.metadata),
     shotState: async (args, load) => thirteenFShotState(args, (await load()).metadata ?? {}),
-    async load(args, ctx) {
+    load: (args, ctx) => readingSavedCopies(ctx, async () => {
       const query = typeof args.argument === "string" ? args.argument.trim() : "";
       const requestedView = String(args.options.view) as HeadlessThirteenFView;
       const compare = typeof args.options.compare === "string" ? args.options.compare.trim() : "";
@@ -920,7 +947,7 @@ export function createThirteenFHeadless(
           ],
         },
       };
-    },
+    }),
   };
 }
 

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";
@@ -26,7 +26,7 @@ import { usePaneStatusFooter, usePaneStatusLinkFooter } from "../../../component
 import { corporateSplitFactor, 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 ?? [];
@@ -202,7 +207,8 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
   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,
@@ -544,6 +550,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 +560,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,
   });
@@ -590,7 +600,7 @@ export function FundDetailView({
           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 +669,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 +724,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,8 @@ 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;
 }
 
 /** A manager a 13F-NT names as reporting its holdings. */