gloomberb 0.19.0 → 0.19.2

package/src/plugins/builtin/treasury-auctions/pane.tsx

@@ -13,6 +13,8 @@ import {
   type DataTableRootKeyContext,
 } from "../../../components";
 import { loadingErrorFooterInfo, usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { savedCopyFooterInfo } from "../../../components/layout/pane/footer";
+import { STALE_SEGMENT } from "../../../components/layout/pane/status-footer";
 import { usePaneInstance } from "../../../state/app/context";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
@@ -105,6 +107,9 @@ function secTypeColor(secType: string, selected: boolean): string {
   }
 }
 
+/** An announced auction's Rate in the table, the word other panes use for a figure not out yet (KPI's Later actual). */
+const RESULTS_PENDING = "Pending";
+
 // Stable table adapter so memoized rows survive pane re-renders.
 const auctionKey = (auction: TreasuryAuction) => auction.id;
 
@@ -119,8 +124,8 @@ function renderAuctionCell(
 
   switch (column.id) {
     case "date":
-      // Announced auctions have no results yet; every metric cell reads "—",
-      // so the date carries the distinction instead of a second placeholder.
+      // Announced auctions have no results yet: Rate reads Pending, the other
+      // metric cells "—", and the date is bright.
       return {
         text: showYear ? auction.auctionDate : formatShortDate(auction.auctionDate, { year: false, utc: true, fallback: "\u2014" }),
         color: rowState.selected ? colors.selectedText : isPendingAuction(auction) ? colors.textBright : colors.textDim,
@@ -134,7 +139,10 @@ function renderAuctionCell(
     case "term":
       return { text: auction.securityTerm, color: selected ?? colors.text };
     case "rate":
-      return { text: formatAuctionRate(auction, rateValue(auction), "—"), color: selected ?? colors.textBright };
+      // An announced auction says its results are pending, as its detail does; other metric cells stay "—".
+      return isPendingAuction(auction)
+        ? { text: RESULTS_PENDING, color: dimmed }
+        : { text: formatAuctionRate(auction, rateValue(auction), "—"), color: selected ?? colors.textBright };
     case "stopOut":
       return { text: formatBp(stopOutVsAverageBp(auction)), color: selected ?? colors.text };
     case "btc":
@@ -202,8 +210,10 @@ export function TreasuryAuctionsPane({ focused, width, height }: PaneProps) {
   const auctions = resource.data?.auctions ?? NO_AUCTIONS;
   const stale = resource.data?.stale ?? false;
   const fetchedAt = resource.data?.fetchedAt ?? null;
+  // A refresh that failed shows the auctions an earlier read saved, and says when that copy is from.
+  const savedAt = resource.data?.savedAt ?? null;
   // A cache that could not be refreshed arrives as a result, not a failure.
-  const error = resource.error ?? (resource.loading ? null : resource.data?.refreshError ?? null);
+  const error = resource.error ?? (resource.loading || savedAt != null ? null : resource.data?.refreshError ?? null);
   // Once auctions have loaded, a refresh runs without a loading state.
   const loading = resource.loading && !resource.data;
   const [filter, setFilter] = usePluginPaneState<AuctionFilter>("activeTab", "all");
@@ -296,8 +306,9 @@ export function TreasuryAuctionsPane({ focused, width, height }: PaneProps) {
 
   usePaneFooter(TREASURY_AUCTIONS_PANE_ID, () => {
     const info = loadingErrorFooterInfo(loading, error);
-    if (stale) info.push({ id: "stale", parts: [{ text: "stale cache", tone: "warning" }] });
-    if (fetchedAt) {
+    if (savedAt != null) info.push(...savedCopyFooterInfo([savedAt]));
+    else if (stale) info.push(STALE_SEGMENT);
+    if (fetchedAt && savedAt == null) {
       info.push({ id: "updated", parts: [{ text: formatRelativeAge(fetchedAt), tone: "muted" }] });
     }
     return {
@@ -317,6 +328,7 @@ export function TreasuryAuctionsPane({ focused, width, height }: PaneProps) {
     fetchedAt,
     focusSearch,
     loading,
+    savedAt,
     stale,
   ]);
 

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

@@ -14,6 +14,7 @@ import { buildVolatilityData, buildVolatilityTermHistory, IMPLIED_CORRELATION_RO
   type VolatilitySeriesId, type VolatilitySeriesInput, type VolatilityTermHistory } from "./model";
 import { abortable, abortError } from "../../../utils/async-deadline";
 import { errorMessage } from "../../../utils/errors";
+import { savedCopyAt } from "../../../data/saved-copies";
 
 const VOLATILITY_LOAD_CONCURRENCY = 4;
 const VOLATILITY_HISTORY_LIMIT = 400;
@@ -22,6 +23,8 @@ export interface VolatilityLoadResult {
   /** The daily inputs the data was built from, so live index levels can be laid over them. */
   inputs: VolatilityInputs;
   stale: boolean;
+  /** The oldest copy a failed refresh left answering, by when it was saved (ms); its failure is not in `errors`. */
+  savedAt?: number;
   errors: string[];
   phase: "loading" | "partial" | "ready" | "error";
   loaded: number;
@@ -76,14 +79,16 @@ const legError = (legs: ReadonlyArray<{ error?: string | null } | undefined>) =>
  * The 3M/30D ratio's history as the board builds it: the board's own VIX and
  * VIX 3M daily closes (one year, the same request and cache), FRED's
  * republished closes from `start` on the dates those lack. When Cboe's closes
- * fail FRED stands in, a day behind, and the warning says so; a ratio read
- * from cached closes names whose. With neither publisher's pair it rejects
- * with both reasons rather than return an empty history.
+ * fail FRED stands in, a day behind, and the warning says so. A ratio read
+ * from closes a failed refresh left in place carries when they were saved
+ * (`savedAt`), which the chart dates as every pane does; other cached closes
+ * name whose. With neither publisher's pair it rejects with both reasons
+ * rather than return an empty history.
  */
 export async function loadVolatilityTermHistory(
   { start, signal }: { start?: Date; signal?: AbortSignal } = {},
   dependencies: VolatilityLoaderDependencies & { loadFredPoints?: typeof loadFredPoints } = termDependencies(),
-): Promise<{ term: VolatilityTermHistory; warning?: string }> {
+): Promise<{ term: VolatilityTermHistory; warning?: string; savedAt?: number }> {
   const loadFred = dependencies.loadFredPoints ?? loadFredPoints;
   const now = dependencies.now?.() ?? Date.now();
   const history: NonNullable<VolatilityInputs["history"]> = {};
@@ -101,7 +106,7 @@ export async function loadVolatilityTermHistory(
       try {
         const loaded = await loadFred(seriesId, start);
         fred[seriesId] = { observations: loaded.points, info: null, stale: loaded.points.length > 0 && loaded.stale,
-          error: loaded.refreshError ?? null };
+          error: loaded.refreshError ?? null, ...(loaded.savedAt != null && loaded.points.length ? { savedAt: loaded.savedAt } : {}) };
       } catch (error) {
         fred[seriesId] = { observations: [], info: null, error: errorMessage(error) };
       }
@@ -119,12 +124,14 @@ export async function loadVolatilityTermHistory(
   } else if (fredError && !term.ratioHistory.some((point) => point.publisher === "FRED")) {
     notes.push(`FRED closes unavailable (${fredError}); showing Cboe's from ${term.ratioHistory[0]!.date}.`);
   }
-  if (term.stale) {
+  const legs = term.publisher === "FRED" ? VOLATILITY_SERIES.map(({ seriesId }) => fred[seriesId]) : [history.vix, history.vix3m];
+  const savedAt = term.stale ? oldestSavedAt(legs) : undefined;
+  if (term.stale && savedAt == null) {
     const error = term.publisher === "FRED" ? fredError : cboeError;
     notes.push(error ? `Refresh failed (${error}); showing cached ${term.publisher} closes.`
       : `Showing cached ${term.publisher} closes; the source has not updated since.`);
   }
-  return notes.length ? { term, warning: notes.join(" ") } : { term };
+  return { term, ...(notes.length ? { warning: notes.join(" ") } : {}), ...(savedAt != null ? { savedAt } : {}) };
 }
 
 /** A CBOE daily close as a daily bar dated at the 16:15 New York settlement. */
@@ -141,23 +148,39 @@ function validateFredData(seriesId: VolatilitySeriesId, data: FredSeriesData): F
   }
   return data;
 }
-function fredInput(result: Pick<FredSeriesLoadResult, "data" | "stale" | "fetchedAt"> & { refreshError?: string }): VolatilitySeriesInput {
+function fredInput(result: Pick<FredSeriesLoadResult, "data" | "stale" | "fetchedAt"> & Partial<Pick<FredSeriesLoadResult, "source">>
+  & { refreshError?: string }): VolatilitySeriesInput {
+  const saved = result.source === "stale-fallback" && result.data.observations.length > 0;
   return { observations: result.data.observations, info: result.data.info, fetchedAt: result.fetchedAt,
     stale: result.data.observations.length > 0 && result.stale,
-    error: result.refreshError ?? (result.data.observations.length ? null : "Daily FRED observations unavailable") };
+    error: result.refreshError ?? (result.data.observations.length ? null : "Daily FRED observations unavailable"),
+    ...(saved ? { savedAt: result.fetchedAt } : {}) };
 }
+/**
+ * A history answered from the copy saved before its refetch failed is one only
+ * when the router says so (its saved-copy mark, which a command's answers
+ * carry): closes kept from an earlier answer, or a fresh answer with no data,
+ * say their error instead.
+ */
 function historyInput(entry: QueryEntry<PricePoint[]>, now: number): VolatilityHistoryInput {
   const history = resolveEntryValue(entry) ?? [];
+  const savedAt = history.length > 0 ? savedCopyAt(entry.history) : null;
   return { history, source: entry.source, fetchedAt: entry.fetchedAt,
-    stale: history.length > 0 && (!!entry.error || (entry.staleAt != null && entry.staleAt <= now)),
-    error: entry.error?.message ?? (history.length ? null : "Daily index history unavailable") };
+    stale: history.length > 0 && (savedAt != null || !!entry.error || (entry.staleAt != null && entry.staleAt <= now)),
+    error: entry.error?.message ?? (history.length ? null : "Daily index history unavailable"),
+    ...(savedAt != null ? { savedAt } : {}) };
+}
+/** The oldest of `inputs`' saved copies, by when each was saved. */
+function oldestSavedAt(inputs: ReadonlyArray<{ savedAt?: number | null } | undefined>): number | undefined {
+  const saved = inputs.flatMap((input) => input?.savedAt != null ? [input.savedAt] : []);
+  return saved.length ? Math.min(...saved) : undefined;
 }
 /** Seeds the first paint; the load that replaces each input settles its freshness, so cache age is not stale. */
 function cachedInputs(dependencies: VolatilityLoaderDependencies, now: number): VolatilityInputs {
   const inputs: VolatilityInputs = { history: {}, fred: {} };
   for (const definition of VOLATILITY_INDICES) {
     const entry = dependencies.getChartEntry?.(volatilityHistoryRequest(definition.symbol));
-    if (entry && resolveEntryValue(entry) != null) inputs.history![definition.id] = { ...historyInput(entry, now), stale: false };
+    if (entry && resolveEntryValue(entry) != null) inputs.history![definition.id] = { ...historyInput(entry, now), stale: false, savedAt: null };
   }
   for (const { seriesId } of VOLATILITY_SERIES) {
     const cached = getCachedFredSeries(requestFor(seriesId), { allowExpired: true });
@@ -176,12 +199,16 @@ function historyError(id: string, error: string): string {
 }
 function project(inputs: VolatilityInputs, loaded: number, total: number, pending: boolean): VolatilityLoadResult {
   const data = buildVolatilityData(inputs);
-  const errors = [...Object.entries(inputs.history ?? {}).flatMap(([id, value]) => value.error ? [historyError(id, value.error)] : []),
-    ...Object.entries(inputs.fred ?? {}).flatMap(([id, value]) => value.error ? [`${id}: ${value.error}`] : [])];
-  const stale = [...Object.values(inputs.history ?? {}), ...Object.values(inputs.fred ?? {})].some((value) => value.stale);
+  // A saved copy answering a failed refresh says when it was saved (`savedAt`) instead of the failure.
+  const errors = [...Object.entries(inputs.history ?? {}).flatMap(([id, value]) => value.error && value.savedAt == null ? [historyError(id, value.error)] : []),
+    ...Object.entries(inputs.fred ?? {}).flatMap(([id, value]) => value.error && value.savedAt == null ? [`${id}: ${value.error}`] : [])];
+  const all = [...Object.values(inputs.history ?? {}), ...Object.values(inputs.fred ?? {})];
+  const stale = all.some((value) => value.stale);
+  const savedAt = oldestSavedAt(all);
   const phase = pending ? hasValues(data) ? "partial" : "loading" : !hasValues(data) ? "error"
     : errors.length || stale || data.warnings.length || data.board.some((row) => row.status !== "available") ? "partial" : "ready";
-  return { data, inputs: { history: { ...inputs.history }, fred: { ...inputs.fred } }, stale, errors, phase, loaded, total };
+  return { data, inputs: { history: { ...inputs.history }, fred: { ...inputs.fred } }, stale, ...(savedAt != null ? { savedAt } : {}),
+    errors, phase, loaded, total };
 }
 export function getCachedVolatilityData(dependencies: VolatilityLoaderDependencies = createVolatilityDependencies()): VolatilityLoadResult | null {
   const inputs = cachedInputs(dependencies, dependencies.now?.() ?? Date.now());

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

@@ -2,6 +2,7 @@ import type { HeadlessBundleResult, HeadlessPaneContext, HeadlessPaneDefinition,
 import { createVolatilityDependencies, loadVolatilityData, type VolatilityLoadResult } from "./client";
 import { termStateLabel, type VolatilityData } from "./model";
 import { newestReportTime, oldestReportTime } from "../../../utils/utc-time";
+import { servedFromSavedCopy } from "../../../data/saved-copies";
 
 function formattedValue(value: unknown): string { return typeof value === "number" && Number.isFinite(value) ? value.toFixed(2) : "--"; }
 function formattedPercentile(value: unknown): string { return typeof value === "number" && Number.isFinite(value) ? value.toFixed(0) : "--"; }
@@ -60,6 +61,8 @@ export function createVolatilityHeadless(dependencies: VolatilityHeadlessDepende
     async load(args, context) {
       const result = await dependencies.load(args, context);
       context.signal.throwIfAborted();
+      // A saved copy answering a failed refresh ends the report with when it was saved.
+      const savedCopy = <T>(value: T) => result.savedAt != null ? servedFromSavedCopy(value, result.savedAt) : value;
       // Daily index closes, dated by the newest index on the board; a sparse index shows as the oldest.
       const boardDates = result.data.board.filter((row) => row.value != null).map((row) => row.date);
       const freshness = { source: "Cboe and FRED", status: "not-a-feed" as const, basis: "daily index closes", cadence: "daily" as const,
@@ -67,10 +70,10 @@ export function createVolatilityHeadless(dependencies: VolatilityHeadlessDepende
       return { ...projectVolatilityHeadless(result.data), freshness, errors: result.errors,
         complete: result.phase === "ready" && !result.stale && result.data.warnings.length === 0,
         unavailableSymbols: result.data.board.filter((row) => row.value == null).map((row) => row.symbol),
-        metadata: { stale: result.stale, phase: result.phase, loaded: result.loaded, total: result.total,
+        metadata: savedCopy({ stale: result.stale, phase: result.phase, loaded: result.loaded, total: result.total,
           data: result.data, unit: "index points", observations: "daily history or isolated index observation",
           percentile: "Midrank within last calendar year; at least 200 observations spanning 300 days",
-          vixFuturesAvailable: false, methodology: "docs/research-data.md#vix-curve-and-cross-asset-volatility-board" },
+          vixFuturesAvailable: false, methodology: "docs/research-data.md#vix-curve-and-cross-asset-volatility-board" }),
       };
     },
   };

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

@@ -30,6 +30,11 @@ export interface VolatilityHistoryInput {
   stale?: boolean;
   error?: string | null;
   fetchedAt?: number | null;
+  /**
+   * When the copy shown was saved, when a failed refresh left it answering:
+   * the pane's footer says "saved copy from …" instead of the failure.
+   */
+  savedAt?: number | null;
 }
 export interface VolatilitySeriesInput {
   observations: CloudFredObservationPayload[];
@@ -37,6 +42,8 @@ export interface VolatilitySeriesInput {
   stale?: boolean;
   error?: string | null;
   fetchedAt?: number | null;
+  /** As `VolatilityHistoryInput.savedAt`. */
+  savedAt?: number | null;
 }
 export interface VolatilityInputs {
   history?: Partial<Record<VolatilityIndexId, VolatilityHistoryInput>>;
@@ -131,6 +138,8 @@ export interface VolatilityBoardRow {
   status: "available" | "limited" | "unavailable";
   stale: boolean;
   error: string | null;
+  /** When the copy shown was saved, when a failed refresh left it answering. */
+  savedAt?: number;
   warnings: string[];
 }
 export interface VolatilityData {
@@ -233,8 +242,9 @@ function fredHistory(inputs: VolatilityInputs["fred"]): FredVolatilityHistory {
     const input = inputs?.[definition.seriesId];
     const normalized = normalizeHistory(input?.observations ?? [], true);
     warnings.push(...normalized.warnings.map((warning) => `${definition.seriesId}: ${warning}`));
-    if (input?.error) warnings.push(`${definition.seriesId}: ${input.error}`);
-    if (input?.stale) warnings.push(`${definition.seriesId}: cached source is stale`);
+    // A saved copy is dated in the footer; its failed refresh is not repeated here.
+    if (input?.error && input.savedAt == null) warnings.push(`${definition.seriesId}: ${input.error}`);
+    if (input?.stale && input.savedAt == null) warnings.push(`${definition.seriesId}: cached source is stale`);
     const latest = normalized.history.at(-1);
     return { ...definition, title: input?.info?.title ?? definition.label, value: latest?.value ?? null,
       date: latest?.date ?? null, history: normalized.history,
@@ -300,15 +310,16 @@ function boardRow(definition: typeof VOLATILITY_INDICES[number], input: Volatili
   if (latest && latest.date !== normalized.rows.at(-1)?.date) warnings.push("Latest supplied close unavailable; showing last valid observation");
   if (latest && !adjacent) warnings.push("1D change unavailable: previous daily close missing or too far apart");
   if (latest && !broadCoverage) warnings.push(`1Y percentile unavailable: ${history.length} observations across ${coverageDays} days`);
-  if (input?.stale) warnings.push("Cached daily history is stale");
-  if (input?.error) warnings.push(input.error);
+  // A saved copy is dated in the footer; its failed refresh is not repeated here.
+  if (input?.stale && input.savedAt == null) warnings.push("Cached daily history is stale");
+  if (input?.error && input.savedAt == null) warnings.push(input.error);
   return { ...definition, unit: "index points", value: latest?.value ?? null, date: latest?.date ?? null,
     source: input?.source ?? null, previousDate: previous?.date ?? null, change1d,
     change1dPercent: change1d != null ? change1d / previous!.value! * 100 : null,
     percentile1y, sampleSize: history.length, coverageDays, history,
     missingDates: normalized.rows.filter((row) => row.value == null && Date.parse(row.date) > cutoff).map((row) => row.date),
     status: !latest ? "unavailable" : warnings.length > 0 ? "limited" : "available",
-    stale: input?.stale ?? false, error: input?.error ?? null, warnings };
+    stale: input?.stale ?? false, error: input?.error ?? null, ...(input?.savedAt != null ? { savedAt: input.savedAt } : {}), warnings };
 }
 function alignedCurve(board: readonly VolatilityBoardRow[], fred: FredVolatilityHistory, term: VolatilityTermHistory): VolatilityCurve {
   const rows = VOLATILITY_CURVE_INDICES.map((definition) => board.find((row) => row.id === definition.id)!);
@@ -337,7 +348,7 @@ function alignedCurve(board: readonly VolatilityBoardRow[], fred: FredVolatility
   const spot = points[1]!.value, threeMonth = points[2]!.value;
   const warnings = points.flatMap((point, index) => [
     ...(point.value == null ? [`${point.label}: no close aligned to ${date ?? "a common date"}`] : []),
-    ...(point.value != null && rows[index]!.stale ? [`${point.label}: aligned close is from stale cached history`] : []),
+    ...(point.value != null && rows[index]!.stale && rows[index]!.savedAt == null ? [`${point.label}: aligned close is from stale cached history`] : []),
   ]);
   const ratio = spot != null && threeMonth != null ? threeMonth / spot : null;
   const context = ratioPercentile(term, ratio, date);

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

@@ -2,6 +2,8 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { ChartTableHeader, CurveSurface, curveGhostColors, DataTableView, formatPercentAxis, PaneStatusBody, useChartTableSelection,
   usePaneFooter, usePaneNoticeFooter, usePaneTabs, type DataTableColumn, type StatItem } from "../../../components";
 import { curveStrip, curveSurfaceMinRows } from "../../../components/chart/curve";
+import { savedCopyFooterInfo } from "../../../components/layout/pane/footer";
+import { STALE_SEGMENT } from "../../../components/layout/pane/status-footer";
 import { dropColumnsToFit } from "../../../components/ui/table-layout";
 import { useAsyncResource } from "../../../react/async-resource";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
@@ -170,10 +172,15 @@ export function VolatilityPane({ focused, width, height }: PaneProps) {
   const observationBasis = intraday ? "intraday" : sparse ? "observation" : settled ? "close" : DAY_SO_FAR_TEXT;
   usePaneFooter("volatility", () => ({ info: [
     ...(resource.loading ? [{ id: "loading", parts: [{ text: "loading volatility", tone: "muted" as const }] }] : []),
-    ...(result?.stale ? [{ id: "stale", parts: [{ text: "stale", tone: "warning" as const }] }] : []),
-    ...(data ? [{ id: "basis", parts: [{ text: observationBasis, tone: "muted" as const }] }] : []),
-    ...(asOf ? [{ id: "date", parts: [{ text: observationTime ? `${observationTime.slice(0, 16).replace("T", " ")} UTC` : asOf, tone: "muted" as const }] }] : []),
-  ], hints: [{ id: "view", key: "v", label: "iew", onPress: cycleTab }] }), [resource.loading, result?.stale, data, asOf, observationTime, observationBasis, cycleTab]);
+    // A saved copy answering a failed refresh says when it was saved; other stale closes say only that.
+    ...savedCopyFooterInfo([result?.savedAt]),
+    ...(result?.stale && result.savedAt == null ? [STALE_SEGMENT] : []),
+    // One fact, "close 2026-09-25": the basis and its date read as one segment.
+    ...(data || asOf ? [{ id: "basis", parts: [
+      ...(data ? [{ text: observationBasis, tone: "muted" as const }] : []),
+      ...(asOf ? [{ text: observationTime ? `${observationTime.slice(0, 16).replace("T", " ")} UTC` : asOf, tone: "muted" as const }] : []),
+    ] }] : []),
+  ], hints: [{ id: "view", key: "v", label: "iew", onPress: cycleTab }] }), [resource.loading, result?.stale, result?.savedAt, data, asOf, observationTime, observationBasis, cycleTab]);
   const { strip: tabStrip, rows: tabRows } = usePaneTabs({ tabs: TABS, activeValue: tab, onSelect: setTab, focused, dense: true });
   const contentHeight = Math.max(5, height - tabRows);
   // The board needs only its rows; the selected index history takes the rest.

package/src/plugins/builtin/volatility/series.ts

@@ -105,11 +105,12 @@ export const VOLATILITY_SERIES: readonly SeriesDefinition[] = [
     tags: ["term structure", "contango", "backwardation", "VIX"],
     description: "VIX 3M over VIX on each date both closed, from Cboe's daily closes and FRED's before them; above 1 is contango.",
     load: async ({ start, signal }) => {
-      const { term, warning } = await loadVolatilityTermHistory({ ...(start ? { start } : {}), ...(signal ? { signal } : {}) });
+      const { term, warning, savedAt } = await loadVolatilityTermHistory({ ...(start ? { start } : {}), ...(signal ? { signal } : {}) });
       const attribution = termAttribution(term);
       return {
         points: term.ratioHistory.map((point) => ({ date: point.date, value: point.value })),
         ...(warning ? { warning } : {}),
+        ...(savedAt != null ? { savedAt } : {}),
         ...(attribution ? { attribution } : {}),
       };
     },

package/src/plugins/builtin/yield-curve/client.ts

@@ -1,8 +1,10 @@
 import { apiClient } from "../../../api-client";
 import type { SwapCurvePayload, SwapTenor } from "../../../api-client/swap-curve";
-import { createPluginCache } from "../../../data/plugin-cache";
+import { createPluginCache, savedCopyForTransientFailure, type PluginCacheResult } from "../../../data/plugin-cache";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import { validateSwapCurve } from "./swaps-model";
+import { loadCurveData, type CurveData, type CurveId } from "./curves";
+import { loadWorldRows, type WorldRow } from "./world";
 
 export const swapCurveCache = createPluginCache<SwapCurvePayload>({
   kind: "sofr-swap-curve", source: "gloom-cloud", schemaVersion: 1,
@@ -23,3 +25,59 @@ export async function fetchSwapCurve(tenor: SwapTenor,
 export const getCachedSwapCurve = (tenor: SwapTenor) => cachedCloudResource(swapCurveCache, tenor, validateSwapCurve);
 export const loadSwapCurve = (tenor: SwapTenor, force = false) =>
   loadCloudResource(swapCurveCache, tenor, () => fetchSwapCurve(tenor), { force, validate: validateSwapCurve });
+
+const DAY_MS = 24 * 60 * 60_000;
+
+/**
+ * The Curve and World tabs' curves as last read, so a refresh that fails
+ * (offline, a service error) shows the copy an earlier read saved instead of
+ * an empty tab. Every load still asks the server; the copy is the fallback.
+ */
+export const curveViewCache = createPluginCache<CurveData>({
+  kind: "yield-curve-view", source: "gloom-cloud", schemaVersion: 1,
+  policy: { staleMs: 15 * 60_000, expireMs: 30 * DAY_MS },
+});
+export const worldCurvesCache = createPluginCache<WorldRow[]>({
+  kind: "world-curves", source: "gloom-cloud", schemaVersion: 1,
+  policy: { staleMs: 15 * 60_000, expireMs: 30 * DAY_MS },
+});
+
+/** What a tab shows, and when the copy shown was saved when it is one, its refresh having failed. */
+export interface SavedCopyAnswer<T> {
+  data: T;
+  savedAt: number | null;
+}
+
+const curveKey = (curve: CurveId, requestedDate: string) => `${curve}:${requestedDate || "latest"}`;
+/**
+ * A copy is the saved one by where it came from, whatever its failure said. A
+ * refusal (access denied, an unknown curve) or a reply that fails validation
+ * is said rather than covered by the copy, as `loadCloudResource` does.
+ */
+function answer<T>(result: PluginCacheResult<T>): SavedCopyAnswer<T> {
+  const saved = savedCopyForTransientFailure(result).source === "stale-fallback";
+  return { data: result.data, savedAt: saved ? result.fetchedAt : null };
+}
+
+/** The curve on the date (its latest without one), or the copy an earlier read saved when it cannot be read. */
+export async function loadSavedCurve(curve: CurveId, requestedDate: string,
+  client?: Parameters<typeof loadCurveData>[2]): Promise<SavedCopyAnswer<CurveData>> {
+  return answer(await curveViewCache.load(curveKey(curve, requestedDate), () => loadCurveData(curve, requestedDate, client), { force: true }));
+}
+
+/** The saved curve, for the tab's first paint while it is read again. */
+export function cachedCurve(curve: CurveId, requestedDate: string): SavedCopyAnswer<CurveData> | null {
+  const cached = curveViewCache.get(curveKey(curve, requestedDate), { allowExpired: true });
+  return cached ? { data: cached.data, savedAt: null } : null;
+}
+
+/** Each market's latest curve, or the copy an earlier read saved when they cannot be read. */
+export async function loadSavedWorldRows(client?: Parameters<typeof loadWorldRows>[0]): Promise<SavedCopyAnswer<WorldRow[]>> {
+  return answer(await worldCurvesCache.load("latest", () => loadWorldRows(client), { force: true }));
+}
+
+/** The saved world board, for the tab's first paint while it is read again. */
+export function cachedWorldRows(): SavedCopyAnswer<WorldRow[]> | null {
+  const cached = worldCurvesCache.get("latest", { allowExpired: true });
+  return cached ? { data: cached.data, savedAt: null } : null;
+}

package/src/plugins/builtin/yield-curve/headless.ts

@@ -4,16 +4,17 @@ import type {
 } from "../../../types/plugin";
 import {
   compareDate, curveCutoff, CURVE_OPTIONS, curveIdOf, curveOption, curveSpreadFigures, curveTenorMove, loadComparePoints,
-  loadCurveData, parseCompareInput, parseCurveArgument, type CurveData, type CurveId,
+  parseCompareInput, parseCurveArgument, type CurveData, type CurveId,
 } from "./curves";
 import { yieldTenorRows, type YieldLookbackCurves } from "./chart";
 import { curveAsOf, type YieldPoint, yieldCurveErrors } from "./treasury-data";
 import { loadYieldCurveLookbacks, yieldCurveDate } from "./history";
-import { loadWorldRows, type WorldRow } from "./world";
+import type { WorldRow } from "./world";
 import { formatBasisPoints, toBasisPoints } from "../../../utils/basis-points";
 import { DATE_OPTION_EXAMPLES } from "../../../utils/calendar-date";
 import { SWAP_TENORS, type SwapCurvePayload, type SwapTenor } from "../../../api-client/swap-curve";
-import { fetchSwapCurve } from "./client";
+import { fetchSwapCurve, loadSavedCurve, loadSavedWorldRows } from "./client";
+import { savedCopyMark } from "../../../data/saved-copies";
 import { formatSwapBp, selectedSwapTenor } from "./swaps-model";
 
 const percent = (value: unknown) => value == null ? "-" : `${Number(value).toFixed(2)}%`;
@@ -87,13 +88,14 @@ export interface YieldCurveHeadlessDependencies {
 }
 
 const defaultDependencies: Required<YieldCurveHeadlessDependencies> = {
-  load: (curve, requestedDate, context) => loadCurveData(curve, requestedDate, context.apiClient),
+  // A curve that cannot be read is the copy an earlier read saved, marked so the report says so.
+  load: async (curve, requestedDate, context) => (await loadSavedCurve(curve, requestedDate, context.apiClient)).data,
   compare: (curve, date, context) => loadComparePoints(curve, date, context.apiClient),
   lookbacks: async (session, context) => Object.fromEntries(
     (await loadYieldCurveLookbacks(session, (id, options) => context.apiClient.getCloudFredSeries(id, options)))
       .map((lookback) => [lookback.id, lookback.points]),
   ),
-  world: (context) => loadWorldRows(context.apiClient),
+  world: async (context) => (await loadSavedWorldRows(context.apiClient)).data,
   swaps: (tenor, context) => fetchSwapCurve(tenor, context.apiClient),
 };
 
@@ -184,7 +186,7 @@ export function createYieldCurveHeadless(
         return {
           freshness: { source: "Government bond publishers", status: "not-a-feed", basis: "daily curves" },
           columns: WORLD_COLUMNS,
-          rows: rows.map((row) => ({ market: row.market, twoYear: row.twoYear, tenYear: row.tenYear, thirtyYear: row.thirtyYear,
+          rows: rows.map((row) => ({ ...savedCopyMark(row), market: row.market, twoYear: row.twoYear, tenYear: row.tenYear, thirtyYear: row.thirtyYear,
             twosTensBasisPoints: bp(row.twosTens), tenYearChangeBasisPoints: bp(row.tenYearChange), asOf: row.asOf })),
           metadata: { units: "Percent" },
         };
@@ -244,6 +246,7 @@ export function createYieldCurveHeadless(
           const day = ranked ? curveTenorMove(data, point.maturity, "1D") : null;
           const week = ranked ? curveTenorMove(data, point.maturity, "1W") : null;
           return {
+            ...savedCopyMark(data),
             ...point,
             change1dBasisPoints: change == null ? null : toBasisPoints(change, 1),
             ...(ranked ? {

package/src/plugins/builtin/yield-curve/index.tsx

@@ -8,6 +8,7 @@ import { curveStrip, curveSurfaceMinRows } from "../../../components/chart/curve
 import { curveLookbackLabel } from "../../../components/chart/curve/model";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { useAsyncResource } from "../../../react/async-resource";
+import { isPermanentClientError } from "../../../api-client/errors";
 import { usePaneSettingValue } from "../../../state/app/context";
 import { usePluginPaneState } from "../../../public/react";
 import { priceColor } from "../../../theme/colors";
@@ -18,6 +19,7 @@ import type { PluginModule } from "../plugin-module";
 import { GOVERNMENT_BOND_SERIES, TREASURY_SERIES } from "./series";
 import { useAutoRefresh } from "../../../react/auto-refresh";
 import { usePaneStatusFooter } from "../../../components/layout/pane/status-footer";
+import { savedCopyFooterSegment, type PaneFooterSegment } from "../../../components/layout/pane/footer";
 import { formatPercentileRank } from "../../../utils/format";
 import { SERIES_COLORS } from "../../../theme/series-colors";
 import type { CurveSeries } from "../../../components/chart/curve";
@@ -27,20 +29,28 @@ import {
   type YieldTenorRow,
 } from "./chart";
 import {
-  compareDate, curveCutoff, curveIdOf, CURVE_OPTIONS, curveSpreadFigures, curveTenorMove, loadComparePoints, loadCurveData,
+  compareDate, curveCutoff, curveIdOf, CURVE_OPTIONS, curveSpreadFigures, curveTenorMove, loadComparePoints,
   parseCompareInput, parseCurveArgument, type CurveId,
 } from "./curves";
 import { formatMoveRank, MOVE_HORIZONS } from "../shared/move-rank";
 import { forwardCurve, type CurveBasis } from "./forward";
 import { loadYieldCurveLookbacks, yieldCurveDate } from "./history";
 import { curveAsOf, isYieldObservationDate, type YieldPoint, yieldCurveErrors } from "./treasury-data";
-import { loadWorldRows, type WorldRow } from "./world";
+import type { WorldRow } from "./world";
 import { SwapsTab } from "./swaps";
-import { swapCurveCache } from "./client";
+import {
+  cachedCurve, cachedWorldRows, curveViewCache, loadSavedCurve, loadSavedWorldRows, swapCurveCache, worldCurvesCache,
+} from "./client";
 
 type GcTab = "curve" | "world" | "swaps";
 const TABS = [{ label: "Curve", value: "curve" }, { label: "World", value: "world" }, { label: "Swaps", value: "swaps" }];
 const EMPTY_POINTS: YieldPoint[] = [];
+
+/** A tab showing the copy an earlier read saved, its refresh having failed, says when that copy is from. */
+function useSavedCopyInfo(savedAt: number | null | undefined): PaneFooterSegment[] | undefined {
+  return useMemo(() => savedAt != null ? [savedCopyFooterSegment("saved-copy", savedAt)] : undefined, [savedAt]);
+}
+
 /** Axis word for the loaded curve's basis. */
 const BASIS_LABEL: Record<CurveBasis, string> = {
   par: "Par yield",
@@ -165,8 +175,14 @@ function CurveTab({ curve, onCurveChange, focused, width, height }: {
   const compareField = useDraftField(compareInput);
   const editing = dateField.active || compareField.active;
 
-  const loadCurve = useCallback(async () => loadCurveData(curve, requestedDate), [curve, requestedDate]);
-  const { data, loading, error, updatedAt: lastUpdated, load } = useAsyncResource(loadCurve);
+  // The saved copy paints first and answers when a refresh fails; a failed refresh never empties the tab, unless
+  // asking again cannot help (access denied), which is said instead.
+  const loadCurve = useCallback(async () => loadSavedCurve(curve, requestedDate), [curve, requestedDate]);
+  const { data: answer, loading, error, updatedAt: lastUpdated, load } = useAsyncResource(loadCurve, {
+    initialData: () => cachedCurve(curve, requestedDate), clearOnError: isPermanentClientError,
+  });
+  const data = answer?.data ?? null;
+  const savedInfo = useSavedCopyInfo(answer?.savedAt);
   // A pending curve or date change must never relabel the previous curve as the new one.
   const current = data?.curve === curve && data.requestedDate === requestedDate ? data : null;
   const points = current?.points ?? EMPTY_POINTS;
@@ -260,6 +276,7 @@ function CurveTab({ curve, onCurveChange, focused, width, height }: {
     registrationId: "yield-curve",
     loading: loading || (compareKey != null && compareResource.loading && !comparePoints),
     error: error || sourceError || null,
+    info: savedInfo,
     hints: [
       { id: "date", key: "d", label: "ate", onPress: dateField.focus },
       { id: "compare", key: "v", label: "s", title: "Compare with a date", onPress: compareField.focus },
@@ -413,11 +430,14 @@ function WorldTab({ onOpen, focused, width, height }: {
 }) {
   const colors = useThemeColors();
   const [selected, setSelected] = usePluginPaneState<string | null>("yield-curve:market", null);
-  const loadWorld = useCallback(() => loadWorldRows(), []);
-  const { data, loading, error, updatedAt, load } = useAsyncResource(loadWorld);
+  const loadWorld = useCallback(() => loadSavedWorldRows(), []);
+  const { data: answer, loading, error, updatedAt, load } = useAsyncResource(loadWorld, {
+    initialData: cachedWorldRows, clearOnError: isPermanentClientError,
+  });
+  const data = answer?.data ?? null;
   useAutoRefresh(updatedAt, load);
   usePaneRefreshKey(() => void load(), { focused });
-  usePaneStatusFooter({ registrationId: "yield-curve:world", loading, error: error || null });
+  usePaneStatusFooter({ registrationId: "yield-curve:world", loading, error: error || null, info: useSavedCopyInfo(answer?.savedAt) });
   const rows = data ?? [];
   const selectedId = rows.some((row) => row.id === selected) ? selected! : rows[0]?.id ?? null;
   // Every market's latest curve, each in its own colour; the selected row is
@@ -465,8 +485,12 @@ function WorldTab({ onOpen, focused, width, height }: {
 }
 
 export const yieldCurveModule: PluginModule = {
-  setup(ctx) { swapCurveCache.attach(ctx.persistence); },
-  dispose() { swapCurveCache.reset(); },
+  setup(ctx) {
+    for (const cache of [swapCurveCache, curveViewCache, worldCurvesCache]) cache.attach(ctx.persistence);
+  },
+  dispose() {
+    for (const cache of [swapCurveCache, curveViewCache, worldCurvesCache]) cache.reset();
+  },
   series: [...TREASURY_SERIES, ...GOVERNMENT_BOND_SERIES],
   panes: [{
     id: "yield-curve",

package/src/plugins/builtin/yield-curve/swaps.tsx

@@ -7,8 +7,9 @@ import {
 import { curveStrip, curveSurfaceMinRows } from "../../../components/chart/curve";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { usePaneStatusFooter } from "../../../components/layout/pane/status-footer";
+import { savedCopyFooterSegment } from "../../../components/layout/pane/footer";
 import { FILL_REST } from "../../../components/ui/fill";
-import { isAccessDenied } from "../../../api-client/errors";
+import { isPermanentClientError } from "../../../api-client/errors";
 import { usePluginPaneState } from "../../../public/react";
 import { useAsyncResource } from "../../../react/async-resource";
 import { useAutoRefresh } from "../../../react/auto-refresh";
@@ -37,17 +38,20 @@ export function SwapsTab({ focused, width, height }: { focused: boolean; width:
   const tenor = selectedSwapTenor(selected);
   const loader = useCallback((force: boolean) => loadSwapCurve(tenor, force), [tenor]);
   const resource = useAsyncResource(loader, {
-    initialData: () => getCachedSwapCurve(tenor), keepPreviousData: true, clearOnError: isAccessDenied,
+    initialData: () => getCachedSwapCurve(tenor), keepPreviousData: true, clearOnError: isPermanentClientError,
   });
   const payload = resource.data?.payload;
   const rows = payload?.asOf ? payload.points : EMPTY_ROWS;
   // A new tenor keeps the curve/table in place, but never relabels the old tenor's history.
   const history = payload?.history.tenor === tenor ? payload.history : null;
-  const stale = !!payload?.asOf && (payload.stale || resource.data?.stale || false);
-  const error = resource.error || resource.data?.refreshError || null;
+  // A refresh that failed shows the copy an earlier read saved, and says when that copy is from.
+  const savedAt = resource.data?.savedAt ?? null;
+  const savedInfo = useMemo(() => savedAt != null ? [savedCopyFooterSegment("saved-copy", savedAt)] : undefined, [savedAt]);
+  const stale = !!payload?.asOf && (payload.stale || (savedAt == null && resource.data?.stale) || false);
+  const error = resource.error || (savedAt == null ? resource.data?.refreshError : null) || null;
   useAutoRefresh(stale ? null : resource.updatedAt, resource.load);
   usePaneRefreshKey(resource.reload, { focused });
-  usePaneStatusFooter({ registrationId: "yield-curve:swaps", loading: resource.loading, error, stale });
+  usePaneStatusFooter({ registrationId: "yield-curve:swaps", loading: resource.loading, error, stale, info: savedInfo });
   usePaneNoticeFooter({
     registrationId: "yield-curve:swaps:notices", focused,
     notices: payload?.asOf ? [