@gloom-sh/terminal 0.18.5 → 0.19.1

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

@@ -1,4 +1,5 @@
 import { apiClient } from "../../../api-client";
+import { createTtlCache } from "../../../data/ttl-cache";
 import { getSharedMarketDataCoordinator, MarketDataCoordinator, resolveEntryValue } from "../../../market-data/coordinator";
 import type { InstrumentRef, OptionsRequest } from "../../../market-data/request-types";
 import type { QueryEntry } from "../../../market-data/result-types";
@@ -73,19 +74,8 @@ export function withReusedYieldCurve(
   dependencies: SurfaceLoaderDependencies,
   reuseMs = TREASURY_CURVE_REUSE_MS,
 ): SurfaceLoaderDependencies {
-  let held: { at: number; curve: Promise<YieldPoint[]> } | null = null;
-  return {
-    ...dependencies,
-    loadYieldCurve: () => {
-      const now = Date.now();
-      if (held && now - held.at < reuseMs) return held.curve;
-      const curve = dependencies.loadYieldCurve();
-      const entry = { at: now, curve };
-      held = entry;
-      curve.catch(() => { if (held === entry) held = null; });
-      return curve;
-    },
-  };
+  const curves = createTtlCache<YieldPoint[]>({ ttlMs: reuseMs });
+  return { ...dependencies, loadYieldCurve: () => curves.load("curve", () => dependencies.loadYieldCurve()) };
 }
 
 export interface SurfaceLoadRequest {

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

@@ -12,7 +12,7 @@ import { createSurfaceDependencies, loadVolatilitySurface } from "./client";
 import { buildSurfaceGrid, type SurfaceGridOptions, type SurfaceSettings, type SurfaceSnapshot } from "./model";
 import { atCapturePrecision, formatCaptureTime, loadDatedSurface, storedSurfaceDate, type DatedSurfaceSnapshot } from "./stored";
 import { listingFateEmpty, loadListingFate } from "../../../tickers/listing-fate";
-import { coinOptionsAlias, coinWithoutOptionsRefusal } from "../../../market-data/options-alternatives";
+import { coinOptionsAlias, coinWithoutOptionsRefusal, fxVolatilityRefusal } from "../../../market-data/options-alternatives";
 import { formatUtcTime } from "../../../utils/utc-time";
 import { dvolCurrency, dvolGap, dvolSeriesId, loadDvol, type DvolPayload } from "../volatility/dvol";
 import {
@@ -118,7 +118,7 @@ function skewSection(snapshot: SurfaceSnapshot): HeadlessBundleSection {
   return { title: "Skew", columns: [
     { key: "expiry", header: "Expiry" }, { key: "days", header: "Days", format: days },
     { key: "put25", header: "25D put IV", format: iv }, { key: "call25", header: "25D call IV", format: iv },
-    // Each difference names its sign: the risk reversal is call minus put, unlike HIVG and VCA's put-minus-call skew.
+    // Each difference names its sign: the risk reversal is call minus put here and in VCA and HIVG's rr25d.
     { key: "riskReversal", header: skewHeader("RR", "call-put"), format: gap }, { key: "butterfly", header: skewHeader("BF", "wings-ATM"), format: gap },
     { key: "moneynessSkew", header: skewHeader("90/110", "90%-110%"), format: (value, row) => typeof value === "number" ? points(value)
       : (row as unknown as SurfaceSkewRow).moneynessGap ?? "--" },
@@ -169,7 +169,7 @@ export const volSurfaceHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Underlying ticker" },
   usListingsOnly: "Options data",
   symbolAlias: coinOptionsAlias("OVDV"),
-  refuseSymbol: coinWithoutOptionsRefusal("OVDV"),
+  refuseSymbol: (key) => coinWithoutOptionsRefusal("OVDV")(key) ?? fxVolatilityRefusal("OVDV")(key),
   discovery: { suggestFor: IMPLIED_VOL_WORDS },
   describe: (args) => `OVDV ${args.symbols[0] ?? ""}`,
   options: [

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

@@ -39,7 +39,7 @@ export const volSurfaceModule: PluginModule = {
   paneTemplates: [createTickerSurfacePaneTemplate({
     id: "vol-surface-pane", paneId: "vol-surface", label: "Volatility Surface",
     description: "Implied volatility surface, smiles, term structure, skew (25-delta risk reversal and butterfly) and forwards; DVOL beside BTC-USD and ETH-USD.",
-    keywords: ["ovdv", "volatility", "surface", "smile", "skew", "options", "risk reversal", "butterfly", "25 delta", "dvol", "deribit", "implied volatility index"],
+    keywords: ["ovdv", "volatility", "vol", "surface", "smile", "skew", "options", "risk reversal", "butterfly", "25 delta", "dvol", "deribit", "implied volatility index"],
     shortcut: "OVDV", publicShare: true,
     settings: (_symbol, _context, options) => options?.values?.expiration
       ? { expiration: Number(options.values.expiration) } : {},

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

@@ -43,7 +43,7 @@ import { expiryLabel, formatIv, formatPrice, formatVolPoints, HIDDEN_SLOPE_TEXT,
   surfaceSkewRow, surfaceSpotBasisLabel } from "./tables";
 import { findListedExpiry, unlistedExpiryText } from "../../../utils/option-expiry";
 import { dvolCurrency, dvolGap, loadDvol, type DvolPayload } from "../volatility/dvol";
-import { COIN_OPTIONS_HINT, isCoinWithoutOptions, optionsUnavailableTitle } from "../../../market-data/options-alternatives";
+import { COIN_OPTIONS_HINT, fxVolatilityNote, isCoinWithoutOptions, optionsUnavailableTitle } from "../../../market-data/options-alternatives";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
 import { surfaceThirtyDayAtm } from "./tables";
 
@@ -191,9 +191,10 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
   const fateExchange = target?.effectiveExchange ?? "";
   const fateLoader = useCallback(async () => (await getSharedMarketDataCoordinator()
     ?.loadListingFate({ symbol: underlying, exchange: fateExchange }))?.note ?? null, [underlying, fateExchange]);
-  // A coin nothing lists options on (SOL-USD) says which coins have them.
+  // A coin nothing lists options on (SOL-USD) says which coins have them, and an FX pair which funds stand in.
   const coinNote = underlying && isCoinWithoutOptions(underlying)
-    ? `${optionsUnavailableTitle(parsePublicTickerKey(underlying).symbol)} ${COIN_OPTIONS_HINT}` : null;
+    ? `${optionsUnavailableTitle(parsePublicTickerKey(underlying).symbol)} ${COIN_OPTIONS_HINT}`
+    : underlying ? fxVolatilityNote(underlying, target?.effectiveExchange) : null;
   const fateNote = useAsyncResource(underlying && noChain && !coinNote ? fateLoader : null).data ?? coinNote;
   const ivRank = useIvRank(underlying || null);
   // A coin's options (BTC-USD, ETH-USD) come with Deribit's volatility index.
@@ -224,9 +225,10 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
   // visible; the upstream chain cache dedupes the requests across users. A
   // delayed surface keeps the configured refresh.
   const realtimeSurface = !!settledSnapshot?.expiries.some((entry) => entry.dataSource === "live" || entry.realtimeEligible === true);
-  const liveActive = useLiveSessionRefresh(reloadLive, SURFACE_LIVE_RELOAD_MS,
+  const liveRefresh = useLiveSessionRefresh(reloadLive, SURFACE_LIVE_RELOAD_MS,
     !!symbol && spotAvailable && !historyDate && !fallbackDate && liveStreaming && realtimeSurface && !resource.loading,
     resource.updatedAt);
+  const liveActive = liveRefresh.live;
   useAutoRefresh(resource.updatedAt, liveActive ? noRefresh : resource.load);
   const shownDate = historyDate ?? fallbackDate;
   const storedLoader = useCallback(async () => storedSurfaceSnapshot(await loadStoredSurface(underlying, shownDate!)), [underlying, shownDate]);
@@ -396,7 +398,7 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
     ...(pinned != null && snapshot && !resource.loading && !snapshot.catalogue.includes(pinned)
       && !snapshot.failures.some((failure) => failure.expiration === pinned)
       ? [`${expiryLabel(pinned)}: ${unlistedExpiryText(pinned, snapshot.catalogue)}`] : []),
-    ...(active.error ? [active.error] : [])];
+    ...(active.error ? [active.error] : []), ...(liveRefresh.error ? [liveRefresh.error] : [])];
   const spotBasis = snapshot && !snapshot.stored ? surfaceSpotBasisLabel(snapshot) : null;
   // What the quotes are and when they were observed; a reload moves the time.
   const freshness = !snapshot ? null : snapshot.stored ? `stored close ${snapshot.stored.sessionDate}`

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

@@ -14,13 +14,13 @@ export const volatilityModule: PluginModule = {
   paneTemplates: [{
     id: "volatility-term-structure-pane", paneId: "volatility-term-structure",
     label: "VIX Curve", description: "Dated VIX tenor closes, the 3M/30D ratio history and the cross-asset volatility board.",
-    keywords: ["vix", "volatility", "curve", "contango", "backwardation", "vvix", "skew", "move"],
+    keywords: ["vix", "volatility", "vol", "curve", "contango", "backwardation", "vvix", "skew", "move"],
     shortcut: { prefix: "VIX" }, headless: volatilityHeadless,
     createInstance: () => ({ instanceId: "volatility:curve", title: "VIX", placement: "floating", settings: { initialTab: "curve" } }),
   }, {
     id: "volatility-board-pane", paneId: "volatility-term-structure",
     label: "Cross-asset Volatility", description: "Volatility index closes, daily changes and one-year percentiles.",
-    keywords: ["volatility", "cross asset", "vols", "vxn", "ovx", "gvz"],
+    keywords: ["volatility", "vol", "cross asset", "vols", "vxn", "ovx", "gvz"],
     shortcut: { prefix: "VOLS" }, headless: volatilityHeadless,
     createInstance: () => ({ instanceId: "volatility:board", title: "VOLS", placement: "floating", settings: { initialTab: "board" } }),
   }],

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

@@ -107,7 +107,7 @@ export function VolatilityPane({ focused, width, height }: PaneProps) {
     await coordinator.loadQuotesBatch(quiet.map((target) => ({ symbol: target.symbol, exchange: "" })), { forceRefresh: true });
   }, [liveTargets]);
   // With streaming off the quote layer already polls every minute.
-  useLiveSessionRefresh(refreshIndexLevels, INDEX_LEVEL_REFRESH_MS, liveStreaming && liveTargets.length > 0);
+  const levelRefresh = useLiveSessionRefresh(refreshIndexLevels, INDEX_LEVEL_REFRESH_MS, liveStreaming && liveTargets.length > 0);
   const liveLevels = useThrottledValue(useMemo(() => {
     const levels = new Map<VolatilityIndexId, VolatilityLiveLevel>();
     for (const definition of VOLATILITY_INDICES) {
@@ -139,7 +139,7 @@ export function VolatilityPane({ focused, width, height }: PaneProps) {
   }, [data?.board, sort, loading]);
   const selected = rows.find((row) => row.id === selectedId) ?? rows[0] ?? null;
   useVolatilityEvidence(result, tab, selected, resource.loading);
-  const notices = [resource.error, ...(result?.errors ?? []), ...(data?.warnings ?? []),
+  const notices = [resource.error, levelRefresh.error, ...(result?.errors ?? []), ...(data?.warnings ?? []),
     ...(selected?.warnings ?? [])].filter((notice): notice is string => !!notice);
   usePaneNoticeFooter({ registrationId: "volatility-notices", notices, focused });
   // From the tab the press finds, so the footer's hint never holds an old one.
@@ -171,8 +171,11 @@ export function VolatilityPane({ focused, width, height }: PaneProps) {
   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 }] }] : []),
+    // 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, 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);

package/src/plugins/builtin/world-venue-map/headless.ts

@@ -84,15 +84,15 @@ function layerColumns(layer: GeoLayerInfo): HeadlessPaneColumn[] {
 /**
  * What a search that finds nothing says. A search outside a one-country layer
  * finds nothing because the layer has nothing there; ships are found by name,
- * not by the ticker of the company that runs them, so a ticker that links no
- * fleet (or a server that links none) gets a name to try.
+ * or by the name or ticker of an operator whose fleet is linked, so anything
+ * else (or a server that links no fleet) gets a name to try.
  */
 function emptySearchNote(layer: GeoLayerInfo, query: string): string | null {
   const typed = query.trim();
   if (!typed) return null;
   const coverage = layerCoverageNote(layer);
   if (coverage) return `No ${layer.name.toLowerCase()} match "${typed}". ${coverage}`;
-  if (layer.id === "vessels") return `No ${layer.name.toLowerCase()} match "${typed}"; try a ship-name prefix, such as --query Norwegian.`;
+  if (layer.id === "vessels") return `No ${layer.name.toLowerCase()} match "${typed}"; try a ship-name prefix or an operator, such as --query Norwegian or --query "Royal Caribbean".`;
   return null;
 }
 

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

@@ -1,8 +1,11 @@
 import { apiClient } from "../../../api-client";
 import type { SwapCurvePayload, SwapTenor } from "../../../api-client/swap-curve";
-import { createPluginCache } from "../../../data/plugin-cache";
+import { isPermanentClientError } from "../../../api-client/errors";
+import { createPluginCache, 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 +26,60 @@ 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 asking again will not change (access denied, an unknown curve) is
+ * said rather than covered by the copy, as `loadCloudResource` does.
+ */
+function answer<T>(result: PluginCacheResult<T>): SavedCopyAnswer<T> {
+  const saved = result.source === "stale-fallback";
+  if (saved && isPermanentClientError(result.error)) throw result.error;
+  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 ? [

package/src/plugins/catalog-browser.ts

@@ -45,6 +45,7 @@ import { commentLettersPlugin } from "./builtin/comment-letters";
 import { openFdaPlugin } from "./builtin/openfda";
 import { browserGloomberbCloudPlugin } from "./builtin/cloud/browser";
 import { changelogModule } from "./builtin/changelog";
+import { roadmapModule } from "./builtin/roadmap";
 import { chartComposerModule } from "./builtin/chart-composer";
 import { connectionsModule } from "./builtin/connections";
 import { relativeRotationModule } from "./builtin/relative-rotation";
@@ -126,7 +127,7 @@ import { FIXED_INCOME_HOSTS } from "./builtin/fixed-income/model";
 
 const browserApplicationPlugin = composeBuiltinPlugin({
   ...applicationPluginMeta,
-  modules: [layoutManagerModule, helpModule, changelogModule, connectionsModule, docsModule],
+  modules: [layoutManagerModule, helpModule, changelogModule, connectionsModule, docsModule, roadmapModule],
 });
 
 const runtimeOnly = (module: PluginModule): PluginModule => {

package/src/plugins/catalog-manifest.ts

@@ -75,7 +75,8 @@ const NATIVE_TARGETS: PluginTarget[] = ["cli", "tui", "desktop"];
  */
 function functionsOf(plugin: GloomPlugin) {
   return pluginFunctions({
-    templates: (plugin.paneTemplates ?? []).map((template) => ({
+    // An unlisted function (`listed: false`) is not published.
+    templates: (plugin.paneTemplates ?? []).filter((template) => template.listed !== false).map((template) => ({
       label: template.label,
       prefix: template.shortcut?.prefix,
       description: template.description,

package/src/plugins/host-link.ts

@@ -32,7 +32,7 @@ const LINKED_PACKAGES = ["gloomberb", "react"] as const;
 
 /**
  * The names the host is published under: `gloomberb`, which plugins import
- * as, and `@gloom-sh/terminal` once releases are also published under it.
+ * as, and `@gloom-sh/terminal`.
  */
 const HOST_PACKAGE_NAMES: ReadonlySet<string> = new Set(["gloomberb", "@gloom-sh/terminal"]);
 

package/src/plugins/marketplace/model.ts

@@ -186,6 +186,19 @@ function repoDirectory(repo: string | undefined): string | null {
   return name ? name.toLowerCase() : null;
 }
 
+/**
+ * Built-ins write their copy as sentences and registry plugins as labels, so a
+ * row's short line is read without its closing period, whoever wrote it, and
+ * the detail's paragraph always has one. An ellipsis stays as written.
+ */
+function rowLine(text: string | undefined): string {
+  return (text ?? "").trim().replace(/(?<!\.)\.$/, "");
+}
+function detailParagraph(text: string | undefined): string | undefined {
+  const paragraph = text?.trim();
+  return paragraph ? /[\p{L}\p{N}]$/u.test(paragraph) ? `${paragraph}.` : paragraph : undefined;
+}
+
 /** The short line a built-in's row reads: its editorial tagline, else its description. */
 function builtinTagline(local: InstalledPlugin): string {
   return BUILTIN_EDITORIAL[local.id]?.tagline ?? local.description ?? "";
@@ -257,8 +270,8 @@ export function mergeCatalog(options: {
     entries.push({
       id: plugin.id,
       name: builtin?.name ?? plugin.name,
-      tagline: builtin ? builtinTagline(builtin) : plugin.tagline,
-      description: builtin?.description ?? plugin.description,
+      tagline: rowLine(builtin ? builtinTagline(builtin) : plugin.tagline),
+      description: detailParagraph(builtin?.description ?? plugin.description),
       categories: builtin ? BUILTIN_EDITORIAL[plugin.id]?.categories ?? plugin.categories : plugin.categories,
       tier: plugin.tier,
       targets: plugin.targets,
@@ -309,10 +322,10 @@ export function mergeCatalog(options: {
     entries.push({
       id: local.id,
       name: local.name,
-      tagline: local.source === "builtin"
+      tagline: rowLine(local.source === "builtin"
         ? builtinTagline(local)
-        : local.description ?? (local.linked ? "Linked from a local checkout" : "Installed outside the registry"),
-      description: local.description,
+        : local.description ?? (local.linked ? "Linked from a local checkout" : "Installed outside the registry")),
+      description: detailParagraph(local.description),
       categories: local.source === "builtin" ? [...BUILTIN_EDITORIAL[local.id]?.categories ?? []] : ["unlisted"],
       // Shipped by Gloom like every built-in, whether or not the feed lists it.
       tier: local.source === "builtin" ? "official" : "community",

package/src/portfolio/column-values.ts

@@ -185,15 +185,19 @@ function positionSideLabel(ticker: TickerRecord, activeTab: string | undefined):
   return "MIX";
 }
 
-/** The currency a row is listed in: its position's, else its quote's; an index's level is in points and has none. */
+/**
+ * The currency a row is listed in: its position's, else its quote's or the one saved with it. An index's level is in
+ * points and has none, and a row whose currency no source gave (a coin pair before its quote) shows none, never the
+ * dollars it is valued in meanwhile: a row not held has no position currency, only that fallback.
+ */
 function listedCurrency(
-  positionCurrency: string | undefined,
-  quoteCurrency: string,
+  metrics: Pick<PortfolioPositionMetrics, "positionCount" | "positionCurrency">,
   ticker: TickerRecord,
   quote: TickerFinancials["quote"],
 ): string {
-  if (!positionCurrency && isIndexLevel(quote?.instrumentType || ticker.metadata.assetCategory)) return "";
-  return (positionCurrency || quoteCurrency || ticker.metadata.currency || "").toUpperCase();
+  const held = metrics.positionCount > 0 ? metrics.positionCurrency : "";
+  if (!held && isIndexLevel(quote?.instrumentType || ticker.metadata.assetCategory)) return "";
+  return (held || quote?.currency || ticker.metadata.currency || "").toUpperCase();
 }
 
 function compactText(value: string | null | undefined): string {
@@ -458,7 +462,7 @@ export function getColumnValue(
         ),
       };
     case "currency":
-      return { text: compactText(currencyCodeLabel(listedCurrency(positionCurrency, quoteCurrency, ticker, quote))) };
+      return { text: compactText(currencyCodeLabel(listedCurrency(positionMetrics, ticker, quote))) };
     case "sector":
       return { text: compactText(ticker.metadata.sector || financials?.profile?.sector) };
     case "industry":
@@ -713,7 +717,7 @@ export function getSortValue(
         ?? ticker.metadata.exchange
         ?? null;
     case "currency":
-      return listedCurrency(positionCurrency, quoteCurrency, ticker, quote) || null;
+      return listedCurrency(positionMetrics, ticker, quote) || null;
     case "sector":
       return ticker.metadata.sector || financials?.profile?.sector || null;
     case "industry":

package/src/portfolio/futures-positions.ts

@@ -36,10 +36,12 @@ export interface FuturesSettlement {
   previous: number | null;
 }
 
-/** What a portfolio reads from a future's terms: its contract size and its settlement. */
+/** A future's contract size, settlement and front reference for collection rows. */
 export interface PortfolioFuturesTerms {
   size: FuturesContractSize | null;
   settlement: FuturesSettlement | null;
+  /** A different contract that is currently front, when the terms name one. */
+  front?: Pick<NonNullable<FuturesContractTermsPayload["front"]>, "contract" | "contractSymbol">;
 }
 
 /** A grain or a soft quotes in US cents, so a dollar point value is a hundred of its price units. */
@@ -167,7 +169,7 @@ export function previousFuturesSettlement(
 
 /** What a portfolio reads from a future's terms, with the settlement before the latest when the history has it. */
 export function portfolioFuturesTerms(
-  terms: Pick<FuturesContractTermsPayload, "spec" | "settlement"> | null | undefined,
+  terms: (Pick<FuturesContractTermsPayload, "spec" | "settlement"> & Partial<Pick<FuturesContractTermsPayload, "front" | "contract">>) | null | undefined,
   history?: readonly PricePoint[] | null,
 ): PortfolioFuturesTerms {
   const settlement = terms?.settlement && Number.isFinite(terms.settlement.price) && terms.settlement.price > 0
@@ -177,7 +179,8 @@ export function portfolioFuturesTerms(
       previous: previousFuturesSettlement(history, terms.settlement.date, terms.settlement.price),
     }
     : null;
-  return { size: futuresContractSize(terms?.spec), settlement };
+  const front = terms?.front && terms.front.contract !== terms.contract ? terms.front : undefined;
+  return { size: futuresContractSize(terms?.spec), settlement, ...(front ? { front } : {}) };
 }
 
 /**