@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/plugins/builtin/ticker-detail/overview-tab.tsx

@@ -62,6 +62,8 @@ import { describeFundamentalMarketCap } from "../../../utils/market-capitalizati
 import { liveFiftyTwoWeekRange, liveMarketCapitalization } from "../../../market-data/quotes/live-valuation";
 import { instrumentTypeLabel } from "../../../tickers/instrument-kind";
 import { ClippedText } from "../../../components/ui/display";
+import { DelayedMark, delayedMarkWidth } from "../../../components/ui/delayed-mark";
+import { useFreeQuoteDelay } from "../../../api-client/plan-access";
 import { safeExternalUrl } from "../../../utils/external-url";
 import { cashRunway, SHORT_RUNWAY_HISTORY } from "../../../utils/cash-runway";
 import { useOfferingNote } from "./financials/offerings";
@@ -126,6 +128,7 @@ function ResolvedOverviewTab({ width, height, focused = false, ticker, financial
   const figureCells = useFigureCells();
 
   const quote = financials?.quote;
+  const quoteDelayMinutes = useFreeQuoteDelay(quote);
   const fundamentals = financials?.fundamentals;
   const capitalization = liveMarketCapitalization(quote, fundamentals);
   const profile = financials?.profile;
@@ -195,8 +198,7 @@ function ResolvedOverviewTab({ width, height, focused = false, ticker, financial
     id: `${ticker.metadata.ticker}:price`,
     label: `${ticker.metadata.ticker} Price`,
     color: priceColor(chartDelta),
-    // An index's axis reads in points: ^VIX at 20, never $20.
-    unit: unknownHistoryBasis ? "unknown" : priceSeriesUnit(quoteCurrency, instrumentType),
+    unit: unknownHistoryBasis ? "unknown" : priceSeriesUnit(quoteCurrency, instrumentType, quote?.priceBasis),
     style: "area",
     axis: "right",
     panelId: "price",
@@ -251,7 +253,10 @@ function ResolvedOverviewTab({ width, height, focused = false, ticker, financial
   const venueText = listingVenue ? (companyName ? ` (${listingVenue})` : listingVenue) : "";
   const sessionLabel = quoteSessionLabel(quote);
   const marketStateText = sessionLabel ? t(sessionLabel) : "";
-  const hasIdentityLine = Boolean(companyName || venueText || marketStateText);
+  // Signed out or free, the headline price is the delayed one: the mark says so after the session.
+  const delayMinutes = sessionQuote ? quoteDelayMinutes : null;
+  const delayCells = delayMinutes != null ? delayedMarkWidth(delayMinutes, nativePaneChrome === true) + 1 : 0;
+  const hasIdentityLine = Boolean(companyName || venueText || marketStateText || delayMinutes != null);
   // The desktop logo is a square from the top of the company name's capitals down to the
   // price's baseline, so its edges meet the text's and the three read as one block. The
   // extended-hours line hangs below, as it comes and goes with the session. Without a
@@ -290,7 +295,8 @@ function ResolvedOverviewTab({ width, height, focused = false, ticker, financial
     + quoteChangeCells + 1 + displayWidth(changeBasisText) <= quoteTextWidth;
   const companyNameWidth = Math.max(8, quoteTextWidth
     - displayWidth(venueText)
-    - (marketStateText ? displayWidth(marketStateText) + 1 : 0));
+    - (marketStateText ? displayWidth(marketStateText) + 1 : 0)
+    - delayCells);
   // A listing that no longer trades keeps its delisting date whole on a narrow pane: the venue gives way, then the name.
   const delistedRoom = quote?.delisting && marketStateText ? quoteTextWidth - displayWidth(marketStateText) - 1 : null;
   const identityVenue = delistedRoom !== null && delistedRoom - displayWidth(venueText) < 8 ? "" : venueText;
@@ -401,7 +407,7 @@ function ResolvedOverviewTab({ width, height, focused = false, ticker, financial
             />
             <Box flexDirection="column" flexGrow={1} flexShrink={1} minWidth={0}>
             {hasIdentityLine && (
-              <Box flexDirection="row" minWidth={0} overflow="hidden">
+              <Box flexDirection="row" alignItems="center" minWidth={0} overflow="hidden">
                 {identityName && (
                   <ClippedText fg={colors.textDim} text={identityName} width={identityNameWidth} />
                 )}
@@ -411,6 +417,11 @@ function ResolvedOverviewTab({ width, height, focused = false, ticker, financial
                     {identityName || identityVenue ? " " : ""}{marketStateText}
                   </Text>
                 )}
+                {delayMinutes != null && (
+                  <Box flexShrink={0} paddingLeft={identityName || identityVenue || marketStateText ? 1 : 0}>
+                    <DelayedMark minutes={delayMinutes} />
+                  </Box>
+                )}
               </Box>
             )}
 
@@ -546,7 +557,6 @@ function ResolvedOverviewTab({ width, height, focused = false, ticker, financial
               series={[priceSeries]}
               panels={[{ id: "price" }]}
               levels={trade && researchTradeMatches(trade, instrumentFromTicker(ticker)) ? { seriesId: priceSeries.id, items: trade.levels } : undefined}
-              axisWidth={8}
               showLegend={false}
             />
           </Box>

package/src/plugins/builtin/time-sales/index.tsx

@@ -1,9 +1,8 @@
 import type { PluginModule } from "../plugin-module";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import { timeSalesHeadless } from "./headless";
-import { TimeSalesPane } from "./pane";
 export const timeSalesModule: PluginModule = {
-  panes: [{ id: "time-sales", name: "Time and Sales", icon: "T", component: TimeSalesPane,
+  panes: [{ id: "time-sales", name: "Time and Sales", icon: "T", get component(): typeof import("./pane").TimeSalesPane { const { TimeSalesPane } = require("./pane"); return TimeSalesPane; },
     defaultPosition: "right", tickerFollower: true, defaultMode: "floating", defaultFloatingSize: { width: 104, height: 28 },
     tableExport: true, headless: timeSalesHeadless, settings: { title: "Time and Sales", fields: [{ key: "tab", label: "View", type: "select", options: [{ value: "trades", label: "Trades" }, { value: "quotes", label: "NBBO" }] }] } }],
   paneTemplates: [

package/src/plugins/builtin/time-sales/pane.tsx

@@ -100,8 +100,10 @@ function TimeSalesView({ width, height, focused, symbol, exchange }: PaneProps &
   }, [data]);
   const tradeDecision = useRef<TapeDigits | null>(null);
   const quoteDecision = useRef<TapeDigits | null>(null);
+  // Decimals come from the prints alone: a session extreme can sit a fraction of a cent off a tick (NVDA's 200.9199 low)
+  // and must not turn every trade into four decimals. The session range reads at the prints' decimals instead.
   const tradeDigits = useMemo(() => (tradeDecision.current = stickyTapePriceDigits(tradeDecision.current, symbol,
-    [...(data?.trades.map((trade) => trade.price) ?? []), data?.session.low ?? null, data?.session.high ?? null]))?.digits ?? 2, [data, symbol]);
+    data?.trades.map((trade) => trade.price) ?? []))?.digits ?? 2, [data, symbol]);
   const quoteDigits = useMemo(() => (quoteDecision.current = stickyTapePriceDigits(quoteDecision.current, symbol,
     data?.quotes.flatMap((quote) => [quote.bid, quote.ask]) ?? []))?.digits ?? 2, [data, symbol]);
   // The session range stands beside the tab's own prices, so it reads at their decimals: the quote tab's bid and ask, not the trades'.

package/src/plugins/builtin/trace-bonds/headless.ts

@@ -8,7 +8,7 @@ import {
   quotedCompanyName,
   type CorporateBond,
 } from "./client";
-import { bondStackPriority, formatBondChange, formatBondDecimal, type BondColumnId } from "./model";
+import { bondStackPriority, formatBondChange, formatBondDecimal, sharesOneIssuer, type BondColumnId } from "./model";
 
 const decimal = (digits: number) => (value: unknown) => (
   typeof value === "number" ? formatBondDecimal(value, digits) : "—"
@@ -33,6 +33,15 @@ const COLUMNS: HeadlessPaneColumn[] = [
   column("grade", { key: "traceGradeCode", header: "Grade" }),
 ];
 
+/**
+ * One issuer's tape (`sharesOneIssuer`) leaves the issuer column out of the
+ * text table, as the pane does; exports and piped output keep it.
+ */
+function reportColumns(bonds: readonly CorporateBond[]): HeadlessPaneColumn[] {
+  if (!sharesOneIssuer(bonds)) return COLUMNS;
+  return COLUMNS.map((spec) => spec.key === "issuerName" ? { ...spec, minTableWidth: Number.MAX_SAFE_INTEGER } : spec);
+}
+
 function reportRow(bond: CorporateBond) {
   return {
     id: bond.id,
@@ -85,7 +94,7 @@ export const traceBondsHeadless: HeadlessPaneDefinition<"bundle"> = {
       sections: [{
         // An empty answer is its message alone, dated in its own words.
         title: bonds.length > 0 ? (tradeDate ? `Last sales ${tradeDate}` : "Last sales") : query ? "" : "Last sales",
-        columns: COLUMNS,
+        columns: reportColumns(bonds),
         rows: bonds.map(reportRow),
         ...(query ? { empty: noPrintsText(query, tradeDate, issuer) } : {}),
       }],

package/src/plugins/builtin/trace-bonds/model.ts

@@ -85,26 +85,32 @@ export function sortBonds(bonds: readonly CorporateBond[], sort: BondSort): Corp
   });
 }
 
+/**
+ * What a sale says leads: its price, yield and CUSIP, after the issuer when
+ * the rows are several issuers', before what describes the bond (coupon,
+ * maturity) and the rest of the sale.
+ */
 const BOND_COLUMNS: readonly BondColumn[] = [
   { id: "issuer", label: "Issuer", width: 18, align: "left", flexGrow: 1 },
+  { id: "price", label: "Price", width: 9, align: "right" },
+  { id: "yield", label: "Yield", width: 8, align: "right" },
   { id: "cusip", label: "CUSIP", width: 10, align: "left" },
   { id: "coupon", label: "Coupon", width: 7, align: "right" },
   { id: "maturity", label: "Maturity", width: 11, align: "left" },
-  { id: "price", label: "Price", width: 9, align: "right" },
-  { id: "yield", label: "Yield", width: 8, align: "right" },
   { id: "change", label: "Chg", width: 8, align: "right" },
   { id: "traded", label: "Traded", width: 11, align: "left" },
   { id: "grade", label: "Grade", width: 6, align: "left" },
 ];
 
 /**
- * What a narrow tape gives up first. The issuer, coupon and maturity name a
- * bond, so two of one issuer's issues stay told apart, and its price is
- * what was printed; they never go. The trade date, the default sort and
- * how old a last sale is, outlasts the CUSIP and yield. The headless report
- * moves its columns under the rows in the same order (`bondStackPriority`).
+ * What a narrow tape gives up first. The price and yield are what was printed
+ * and the CUSIP tells two issues with one coupon and maturity apart, so they
+ * never go, nor does the issuer while it names the row; the descriptive
+ * columns go before them, the coupon last as it is the narrowest. The
+ * headless report moves its columns under the rows in the same order
+ * (`bondStackPriority`).
  */
-const BOND_NARROW_DROP_ORDER: readonly BondColumnId[] = ["grade", "change", "cusip", "yield", "traded"];
+const BOND_NARROW_DROP_ORDER: readonly BondColumnId[] = ["grade", "change", "traded", "maturity", "coupon"];
 
 /** `stackPriority` of each column in the text report: the higher, the sooner it moves under its row. */
 export function bondStackPriority(columnId: BondColumnId): number {
@@ -112,6 +118,34 @@ export function bondStackPriority(columnId: BondColumnId): number {
   return index < 0 ? 0 : BOND_NARROW_DROP_ORDER.length - index;
 }
 
-export function buildBondColumns(width: number): BondColumn[] {
-  return fitChartTableColumns(BOND_COLUMNS, width, BOND_NARROW_DROP_ORDER);
+/** The tape's symbol root of an issue (`WHR` of `WHR4800338` and `WHR.GM`), or null without one. */
+function symbolRoot(symbol: string | null): string | null {
+  return symbol?.match(/^[A-Z]+/)?.[0] ?? null;
+}
+
+/**
+ * Whether every row is the same issuer's, so an issuer column would only
+ * repeat it: more than one row, all under one symbol root, or all one name
+ * where a row has no symbol. One row keeps the name, the only thing naming it.
+ */
+export function sharesOneIssuer(bonds: readonly Pick<CorporateBond, "issuerName" | "symbol">[]): boolean {
+  if (bonds.length < 2) return false;
+  const roots = bonds.map((bond) => symbolRoot(bond.symbol));
+  if (roots.every((root) => root != null)) return new Set(roots).size === 1;
+  return new Set(bonds.map((bond) => bond.issuerName.trim().toUpperCase())).size === 1;
+}
+
+/**
+ * The sort the tape shows: a saved issuer sort, while one issuer's tape leaves
+ * the issuer column out, sorts as the default, which the header can show; the
+ * saved sort comes back with the column.
+ */
+export function shownBondSort(sort: BondSort, sharedIssuer: boolean): BondSort {
+  return sharedIssuer && sort.columnId === "issuer" ? DEFAULT_BOND_SORT : sort;
+}
+
+/** The columns at `width`, without the issuer's when every row shares it (`sharesOneIssuer`). */
+export function buildBondColumns(width: number, { sharedIssuer = false }: { sharedIssuer?: boolean } = {}): BondColumn[] {
+  const columns = sharedIssuer ? BOND_COLUMNS.filter((column) => column.id !== "issuer") : BOND_COLUMNS;
+  return fitChartTableColumns(columns, width, BOND_NARROW_DROP_ORDER);
 }

package/src/plugins/builtin/trace-bonds/pane.tsx

@@ -40,6 +40,8 @@ import {
   formatBondChange,
   formatBondDecimal,
   isBondColumnId,
+  sharesOneIssuer,
+  shownBondSort,
   sortBonds,
   type BondColumn,
   type BondSort,
@@ -73,8 +75,11 @@ export function TraceBondsPane({ focused, width, height }: PaneProps) {
   useAutoRefresh(updatedAt, load);
   usePaneRefreshKey(() => void reload(), { focused, enabled: !searchActive });
 
-  const rows = useMemo(() => sortBonds(bonds, sort), [bonds, sort]);
-  const columns = useMemo(() => buildBondColumns(width), [width]);
+  // One issuer's tape says its name once, in what was asked, not on every row.
+  const sharedIssuer = useMemo(() => sharesOneIssuer(bonds), [bonds]);
+  const columns = useMemo(() => buildBondColumns(width, { sharedIssuer }), [sharedIssuer, width]);
+  const shownSort = shownBondSort(sort, sharedIssuer);
+  const rows = useMemo(() => sortBonds(bonds, shownSort), [bonds, shownSort]);
   const tradeDate = answered ? data.tradeDate : null;
   const footerInfo = useMemo(
     () => (tradeDate ? [{ id: "trade-date", parts: [{ text: tradeDate }] }] : []),
@@ -96,11 +101,11 @@ export function TraceBondsPane({ focused, width, height }: PaneProps) {
 
   const onHeaderClick = useCallback((columnId: string) => {
     if (!isBondColumnId(columnId)) return;
-    setSort((current) => nextHeaderSort(current, columnId, {
+    setSort((current) => nextHeaderSort(shownBondSort(current, sharedIssuer), columnId, {
       firstDirection: firstBondSortDirection,
       resetTo: DEFAULT_BOND_SORT,
     }));
-  }, [setSort]);
+  }, [setSort, sharedIssuer]);
 
   const handleRootKeyDown = useCallback((
     event: DataTableKeyEvent,
@@ -190,13 +195,13 @@ export function TraceBondsPane({ focused, width, height }: PaneProps) {
       }}
       columns={columns}
       items={rows}
-      sortColumnId={sort.columnId}
-      sortDirection={sort.direction}
+      sortColumnId={shownSort.columnId}
+      sortDirection={shownSort.direction}
       onHeaderClick={onHeaderClick}
       onSortChange={(columnId, direction) => {
         if (isBondColumnId(columnId)) setSort({ columnId, direction });
       }}
-      resetScrollKey={`${needle}:${sort.columnId ?? ""}:${sort.direction}`}
+      resetScrollKey={`${needle}:${shownSort.columnId ?? ""}:${shownSort.direction}`}
       getItemKey={(row) => row.id}
       renderCell={renderCell}
       selectedTextOverridesCellColor

package/src/plugins/builtin/treasury-auctions/cache.ts

@@ -1,4 +1,5 @@
-import { createPluginCache } from "../../../data/plugin-cache";
+import { createPluginCache, savedCopyForTransientFailure } from "../../../data/plugin-cache";
+import { servedFromSavedCopy } from "../../../data/saved-copies";
 import type { ConnectionHealthRegistry } from "../../../core/connection-health";
 import type { PluginPersistence } from "../../../types/plugin";
 import {
@@ -37,6 +38,8 @@ export interface TreasuryAuctionsResult {
   fetchedAt: number;
   /** True when the network failed and expired cache was served instead. */
   stale: boolean;
+  /** The refresh failed and the copy saved at this time (ms) answered instead. */
+  savedAt?: number;
   refreshError?: string;
 }
 
@@ -84,11 +87,18 @@ export async function loadTreasuryAuctions(
   window: AuctionHistoryWindow = AUCTION_HISTORY_DAYS,
 ): Promise<TreasuryAuctionsResult> {
   if (window === AUCTION_HISTORY_ALL) return loadAllTreasuryAuctions(force, loader);
-  const result = await cache.load(`recent:${window}`, walk(loader, () => auctionWindowQuery(window)), { force });
-  return {
+  // A saved board answers only for a failure asking again may get past; a refusal or an invalid page is the error.
+  const result = savedCopyForTransientFailure(await cache.load(`recent:${window}`, walk(loader, () => auctionWindowQuery(window)), { force }));
+  return answered({
     auctions: result.data, fetchedAt: result.fetchedAt, stale: result.stale,
+    ...(result.source === "stale-fallback" ? { savedAt: result.fetchedAt } : {}),
     ...(result.refreshError ? { refreshError: result.refreshError } : {}),
-  };
+  });
+}
+
+/** A board a saved copy answered: marked as one, so a command ends by saying when it was saved, not with its failure. */
+function answered(result: TreasuryAuctionsResult): TreasuryAuctionsResult {
+  return result.savedAt != null ? servedFromSavedCopy(result, result.savedAt) : result;
 }
 
 /**
@@ -100,16 +110,18 @@ export async function loadTreasuryAuctions(
 async function loadAllTreasuryAuctions(force: boolean, loader: AuctionLoader): Promise<TreasuryAuctionsResult> {
   const boundary = auctionArchiveBoundary();
   const [recent, archive] = await Promise.all([
-    cache.load(`since:${boundary}`, walk(loader, () => ({ from: boundary })), { force }),
+    cache.load(`since:${boundary}`, walk(loader, () => ({ from: boundary })), { force }).then(savedCopyForTransientFailure),
     archiveCache.load(`archive:${boundary}`, walk(loader, () => ({
       from: AUCTION_HISTORY_START, before: boundary, pageSize: AUCTION_ARCHIVE_PAGE_SIZE,
-    }))),
+    }))).then(savedCopyForTransientFailure),
   ]);
   const seen = new Set<string>();
   const auctions = [...recent.data, ...archive.data].filter((auction) => !seen.has(auction.id) && Boolean(seen.add(auction.id)));
   const refreshError = recent.refreshError ?? archive.refreshError;
-  return {
+  const savedAt = Math.min(...[recent, archive].map((part) => part.source === "stale-fallback" ? part.fetchedAt : Infinity));
+  return answered({
     auctions, fetchedAt: recent.fetchedAt, stale: recent.stale || archive.stale,
+    ...(Number.isFinite(savedAt) ? { savedAt } : {}),
     ...(refreshError ? { refreshError } : {}),
-  };
+  });
 }

package/src/plugins/builtin/treasury-auctions/client.ts

@@ -1,3 +1,4 @@
+import { ApiRequestError } from "../../../api-client/errors";
 import { createThrottledFetch } from "../../../utils/throttled-fetch";
 import type { TreasuryAuction, TreasuryAuctionRaw } from "./types";
 
@@ -222,9 +223,8 @@ export async function fetchTreasuryAuctions(
 ): Promise<TreasuryAuction[]> {
   return fetchAuctionPages(async (page) => {
     const response = await TREASURY_FETCH.fetch(buildAuctionsUrl(query, page));
-    if (!response.ok) {
-      throw new Error(`Treasury Fiscal Data request failed (${response.status})`);
-    }
+    // The status stays: an overloaded server is a failure a saved board may answer for, a refusal is not.
+    if (!response.ok) throw new ApiRequestError(`Treasury Fiscal Data request failed (${response.status})`, response.status);
     return response.json();
   });
 }

package/src/plugins/builtin/treasury-auctions/headless.ts

@@ -5,6 +5,7 @@ import type {
 import { formatCompact } from "../../../utils/format";
 import { AUCTION_HISTORY_ALL, AUCTION_HISTORY_START, fetchTreasuryAuctions, type AuctionHistoryWindow } from "./client";
 import { loadTreasuryAuctions, type TreasuryAuctionsResult } from "./cache";
+import { unansweredRefreshError } from "../../../data/saved-copies";
 import type { TreasuryAuction } from "./types";
 import { FIXED_INCOME_VIEW_STATE } from "../fixed-income/model";
 import {
@@ -156,7 +157,8 @@ function createTreasuryAuctionsHeadless(
       ];
       return {
         complete: !result.refreshError,
-        errors: result.refreshError ? [result.refreshError] : [],
+        // A saved copy answering the failed refresh ends the report by saying when it was saved instead.
+        errors: [unansweredRefreshError(result)].filter((error): error is string => !!error),
         notes,
         rows: auctions.map((auction) => ({
           ...auction,

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 { ageFooterSegment, 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";
@@ -208,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");
@@ -302,9 +306,10 @@ 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) {
-      info.push({ id: "updated", parts: [{ text: formatRelativeAge(fetchedAt), tone: "muted" }] });
+    if (savedAt != null) info.push(...savedCopyFooterInfo([savedAt]));
+    else if (stale) info.push(STALE_SEGMENT);
+    if (fetchedAt && savedAt == null) {
+      info.push(ageFooterSegment(formatRelativeAge(fetchedAt)));
     }
     return {
       info,
@@ -323,6 +328,7 @@ export function TreasuryAuctionsPane({ focused, width, height }: PaneProps) {
     fetchedAt,
     focusSearch,
     loading,
+    savedAt,
     stale,
   ]);
 

package/src/plugins/builtin/vol-surface/client.ts

@@ -17,7 +17,14 @@ import { expiredExpiryText, findListedExpiry, isLiveOptionExpiry, liveOptionExpi
 import { optionModelSpot } from "../options/model-spot";
 
 const DEFAULT_SURFACE_EXPIRY_LIMIT = 18;
+/** Expiries read at a time from a source that takes them one by one. */
 const SURFACE_LOAD_CONCURRENCY = 4;
+/**
+ * Expiries asked at once from a source that batches them (`batchesExpiries`):
+ * the API client sends one listing's expiries asked in one moment in batch
+ * requests of six, side by side.
+ */
+const SURFACE_BATCHED_CONCURRENCY = 48;
 /** Each kept expiry must be at least this much further out than the previous one. */
 const SURFACE_TENOR_RATIO = 1.35;
 
@@ -43,8 +50,10 @@ export function selectSurfaceExpiries(catalogue: readonly number[], limit: numbe
 }
 
 export interface SurfaceLoaderDependencies {
-  loadOptions(request: OptionsRequest, options?: { forceRefresh?: boolean }): Promise<QueryEntry<OptionsChain>>;
+  loadOptions(request: OptionsRequest, options?: { forceRefresh?: boolean; batch?: boolean }): Promise<QueryEntry<OptionsChain>>;
   loadYieldCurve(): Promise<YieldPoint[]>;
+  /** Whether `loadOptions` reaches a source that batches expiries asked together; absent, four are read at a time. */
+  batchesExpiries?(): boolean | Promise<boolean>;
   now?: () => number;
 }
 
@@ -58,6 +67,7 @@ export function createSurfaceDependencies(
     loadOptions: (request, options) => coordinator
       ? coordinator.loadOptions(request, options)
       : Promise.reject(new Error("Market data coordinator unavailable")),
+    batchesExpiries: () => coordinator?.batchesOptions() ?? false,
     loadYieldCurve: () => cloudApi.getCloudYieldCurve(),
   };
 }
@@ -179,6 +189,8 @@ export async function loadVolatilitySurface(
   };
   checkAbort();
   publish();
+  // Asked while the catalogue loads, so it costs the expiries no wait.
+  const batched = Promise.resolve().then(() => dependencies.batchesExpiries?.()).then((answer) => answer === true, () => false);
   const treasury = Promise.resolve().then(() => dependencies.loadYieldCurve()).then((value) => {
     if (request.signal?.aborted) return;
     curve = value;
@@ -233,6 +245,9 @@ export async function loadVolatilitySurface(
     publish();
   }
 
+  // A source that takes expiries one by one is asked four at a time, and a cancelled load asks for no more.
+  const batch = await abortable(batched, request.signal, CANCELLED);
+  const concurrency = batch ? SURFACE_BATCHED_CONCURRENCY : SURFACE_LOAD_CONCURRENCY;
   let next = 0;
   const worker = async () => {
     while (!request.signal?.aborted && next < selected.length) {
@@ -240,7 +255,7 @@ export async function loadVolatilitySurface(
       try {
         // The catalogue response already refreshed its own slice, unless it came from cache.
         const entry = await dependencies.loadOptions({ instrument: request.instrument, expirationDate: expiration },
-          { forceRefresh: !!request.forceRefresh && (!!request.expiries || expiration !== catalogueExpiration) });
+          { forceRefresh: !!request.forceRefresh && (!!request.expiries || expiration !== catalogueExpiration), ...(batch ? { batch } : {}) });
         if (request.signal?.aborted) return;
         entries.set(expiration, entry);
         if (!resolveEntryValue(entry) && !entry.error) errors.set(expiration, "Options chain unavailable");
@@ -251,7 +266,7 @@ export async function loadVolatilitySurface(
       publish();
     }
   };
-  await abortable(Promise.all([treasury, ...Array.from({ length: Math.min(SURFACE_LOAD_CONCURRENCY, selected.length) }, worker)]), request.signal, CANCELLED);
+  await abortable(Promise.all([treasury, ...Array.from({ length: Math.min(concurrency, selected.length) }, worker)]), request.signal, CANCELLED);
   checkAbort();
   finished = true;
   const result = snapshot();

package/src/plugins/builtin/vol-surface/index.tsx

@@ -1,11 +1,10 @@
 import type { PluginModule } from "../plugin-module";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
-import { VolSurfacePane } from "./pane";
 import { volSurfaceHeadless } from "./headless";
 
 export const volSurfaceModule: PluginModule = {
   panes: [{
-    id: "vol-surface", name: "Volatility Surface", icon: "V", component: VolSurfacePane,
+    id: "vol-surface", name: "Volatility Surface", icon: "V", get component(): typeof import("./pane").VolSurfacePane { const { VolSurfacePane } = require("./pane"); return VolSurfacePane; },
     defaultPosition: "right", tickerFollower: true, defaultMode: "floating", defaultFloatingSize: { width: 126, height: 36 },
     tableExport: true, headless: volSurfaceHeadless,
     settings: {

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());