@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/plugins/builtin/scanner/lock-note.ts

@@ -1,12 +1,34 @@
 import type { PaneLock } from "../../../types/plugin";
-import { proLockNote } from "../shared/pro-lock-note";
+import { isOptionsUnavailableError } from "../../../market-data/options-alternatives";
+import { resolveHeadlessInstrument } from "../shared/headless-market-data";
+import { proLockNote, type FreeRoute } from "../shared/pro-lock-note";
+
+/**
+ * The listing's option chain, which needs no account, where options are
+ * served for it: LHA:XETRA has none, and `options LHA:XETRA` says so.
+ */
+const OPTIONS_ROUTE: FreeRoute = {
+  text: (ticker, company) => `gloom options ${ticker} lists ${company}'s option chain, each contract with its volume and open interest.`,
+  answers: async (symbol, context) => {
+    const { symbol: ticker, exchange } = await resolveHeadlessInstrument(context, symbol);
+    if (!context.marketData.getOptionsChain) return false;
+    try {
+      const chain = await context.marketData.getOptionsChain(ticker, exchange ?? "");
+      return chain.expirationDates.length + chain.calls.length + chain.puts.length > 0;
+    } catch (error) {
+      if (isOptionsUnavailableError(error)) return false;
+      throw error;
+    }
+  },
+};
 
 /**
  * FLOW is Pro whole: the one scanner with no delayed tier to fall back to.
  * The options chain needs no account and lists each contract's day volume and
  * open interest, the raw counts behind a sweep or a block, without the prints.
  * FLOW takes a ticker only to narrow the market to one name, so the note
- * repeats it only when the reader gave one.
+ * repeats it only when the reader gave one, and only when the listing has
+ * options served: FLOW's prints are of the same US options.
  */
 export function flowLockNote(lock: PaneLock): Promise<string> {
   return proLockNote(lock, {
@@ -14,6 +36,7 @@ export function flowLockNote(lock: PaneLock): Promise<string> {
     argument: "optional",
     does: "it streams real-time sweeps, blocks and large premium prints across US options exchanges",
     shows: "it",
-    free: [{ text: (ticker, company) => `gloom options ${ticker} lists ${company}'s option chain, each contract with its volume and open interest.` }],
+    free: [OPTIONS_ROUTE],
+    noneFor: (ticker) => `Options are not available for ${ticker}, so FLOW has no prints of it.`,
   });
 }

package/src/plugins/builtin/sec/filing-content.ts

@@ -3,6 +3,7 @@ import { useSecFilingContent } from "../../../market-data/hooks";
 import { getSharedMarketDataCoordinator, resolveEntryValue } from "../../../market-data/coordinator";
 import type { QueryEntry } from "../../../market-data/result-types";
 import type { SecFilingDocument, SecFilingItem } from "../../../types/data-provider";
+import { logFailure } from "../../../utils/log-failure";
 import { documentContentTarget, isInlineExhibitDocument } from "./filing-documents";
 
 interface ScopedFilingContentCache {
@@ -41,18 +42,32 @@ export function buildInlineFilingContentTargets(
     .map((document) => documentContentTarget(filing, document));
 }
 
-export function nextUncachedFilingContentTarget(
+/** Filings whose content is read at once: the queue's head and the next ones read ahead. */
+const CONTENT_READS_AT_ONCE = 4;
+
+/** The first `count` targets not cached yet, once each, in the caller's priority order. */
+export function nextUncachedFilingContentTargets(
   targets: readonly SecFilingItem[],
   cache: ReadonlyMap<string, string | null>,
-): SecFilingItem | null {
+  count: number,
+): SecFilingItem[] {
   const seen = new Set<string>();
+  const next: SecFilingItem[] = [];
   for (const target of targets) {
+    if (next.length >= count) break;
     const key = target.accessionNumber;
     if (seen.has(key)) continue;
     seen.add(key);
-    if (!cache.has(key)) return target;
+    if (!cache.has(key)) next.push(target);
   }
-  return null;
+  return next;
+}
+
+export function nextUncachedFilingContentTarget(
+  targets: readonly SecFilingItem[],
+  cache: ReadonlyMap<string, string | null>,
+): SecFilingItem | null {
+  return nextUncachedFilingContentTargets(targets, cache, 1)[0] ?? null;
 }
 
 export function useSecFilingContentCache({
@@ -81,12 +96,29 @@ export function useSecFilingContentCache({
     return () => { retryGeneration.current += 1; };
   }, [scopeKey]);
 
-  const nextTarget = useMemo(
-    () => nextUncachedFilingContentTarget(targets, contentCache),
+  const upcoming = useMemo(
+    () => nextUncachedFilingContentTargets(targets, contentCache, CONTENT_READS_AT_ONCE),
     [contentCache, targets],
   );
+  const nextTarget = upcoming[0] ?? null;
   const contentEntry = useSecFilingContent(nextTarget);
 
+  // The queue takes one filing at a time; the next few are read beside it, and
+  // taken from the coordinator once the head settles (below). Each is asked
+  // once per scope: the coordinator shares a read in flight and keeps it.
+  const readAhead = useRef<{ scopeKey: string; keys: Set<string> }>({ scopeKey, keys: new Set() });
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator) return;
+    if (readAhead.current.scopeKey !== scopeKey) readAhead.current = { scopeKey, keys: new Set() };
+    const asked = readAhead.current.keys;
+    for (const target of upcoming.slice(1)) {
+      if (asked.has(target.accessionNumber)) continue;
+      asked.add(target.accessionNumber);
+      void coordinator.loadSecFilingContent(target).catch(logFailure("sec.filing-content", "Reading filing content ahead failed"));
+    }
+  }, [scopeKey, upcoming]);
+
   useEffect(() => {
     if (!nextTarget) return;
     const first = settledFilingContent(contentEntry);

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

@@ -39,8 +39,12 @@ const SEC_COLUMNS: HeadlessPaneColumn[] = [
 /** Some row has 8-K item codes; a column every row leaves `-` takes no room in the text table (exports keep it). */
 const hasItems = (rows: readonly HeadlessPaneRow[]) => rows.some((row) => typeof row.items === "string" && row.items !== "");
 
+/** A current report's press release exhibit, printed only when some row has one; exports keep it with the filing's link. */
+const PRESS_RELEASE_COLUMN: HeadlessPaneColumn = { key: "pressReleaseUrl", header: "Press release" };
+
 function secTextColumns(rows: readonly HeadlessPaneRow[]): HeadlessPaneColumn[] {
-  return hasItems(rows) ? SEC_COLUMNS : SEC_COLUMNS.filter((column) => column.key !== "items");
+  const columns = hasItems(rows) ? SEC_COLUMNS : SEC_COLUMNS.filter((column) => column.key !== "items");
+  return rows.some((row) => typeof row.pressReleaseUrl === "string" && row.pressReleaseUrl) ? [...columns, PRESS_RELEASE_COLUMN] : columns;
 }
 
 /**

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

@@ -457,9 +457,11 @@ function SecView({ width, height, focused, paneType }: { width: number; height:
   usePaneStatusLinkFooter({
     registrationId: "sec",
     focused,
-    url: openFiling ? openFiling.filingUrl : factsUrl ?? abroadPage ?? announcements?.url,
+    // A current report links its press release, where its figures are, when its index names one.
+    url: openFiling ? openFiling.pressReleaseUrl ?? openFiling.filingUrl : factsUrl ?? abroadPage ?? announcements?.url,
     source: openFiling ? openFiling.form : facts?.covered ? listNames(fundFactPublishers(facts)) : announcements?.name ?? null,
-    label: openFiling ? "filing" : factsUrl ? "source" : abroadPage ? "issuer page" : announcements ? "announcements" : "filing",
+    label: openFiling ? openFiling.pressReleaseUrl ? "press release" : "filing"
+      : factsUrl ? "source" : abroadPage ? "issuer page" : announcements ? "announcements" : "filing",
     // Rows read in the background for their insiders do not hold up the pane.
     loading: loading || loadingDocuments || (!!loadingKey && viewedTargets.some((target) => target.accessionNumber === loadingKey)),
     error: authWall ? null : error ?? detailError,

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

@@ -227,6 +227,8 @@ export function buildSecFilingRows(filings: readonly SecFilingItem[]) {
       cik: filing.cik,
       companyName: filing.companyName ?? null,
       url: filing.filingUrl,
+      // A current report's press release exhibit, where its index names one: the page its figures are on.
+      ...(filing.pressReleaseUrl ? { pressReleaseUrl: filing.pressReleaseUrl } : {}),
     };
   });
 }

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

@@ -16,6 +16,7 @@ import type { ExtendedSession } from "../../../market-data/market/status";
 import { useAutoRefresh, useUpdatedAgo } from "../../../react/auto-refresh";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
 import { isStreamCarryingQuote, useVisibleBoardSymbols } from "../shared/use-quote-board";
+import { useQuoteDelayFooter } from "../shared/cloud-upgrade";
 import { SectorMoveBar } from "./move-bar";
 import {
   SECTOR_COLLECTIONS,
@@ -345,16 +346,21 @@ function EtfBoard({ collectionId, focused, width, height, rootBefore }: EtfBoard
     .map((row) => `${row.etf}: ${sectorRowIssues(row).join(" · ")}`);
   usePaneNoticeFooter({ registrationId: "sectors:row-issues", notices: rowIssueNotices, focused });
 
+  // Signed out or free, the ETFs' quotes are delayed ones.
+  const quoteDelay = useQuoteDelayFooter(rows.map((row) => (row.loading ? null : { dataSource: row.quoteDataSource })), "sectors-delay");
   usePaneFooter("sectors", () => {
     const info = loadingErrorFooterInfo(loading, loadError);
     if (returnAsOfDate) info.push({ id: "return-as-of", parts: [{ text: `returns as of ${returnAsOfDate}`, tone: "muted" }] });
     if (updatedAgo) info.push({ id: "updated", parts: [{ text: `checked ${updatedAgo}`, tone: "muted" }] });
     // Keep the leading current failure readable when the pane is narrow; separate
     // flex children would each shrink it to a few characters beside routine status.
-    return { info: info.length > 0 ? [{ id: "status", parts: info.flatMap((segment, index) => [
-      ...(index > 0 ? [{ text: "·", tone: "muted" as const }] : []), ...segment.parts,
-    ]) }] : [] };
-  }, [loadError, loading, returnAsOfDate, updatedAgo]);
+    return { info: [
+      ...(info.length > 0 ? [{ id: "status", parts: info.flatMap((segment, index) => [
+        ...(index > 0 ? [{ text: "·", tone: "muted" as const }] : []), ...segment.parts,
+      ]) }] : []),
+      ...(quoteDelay ? [quoteDelay] : []),
+    ] };
+  }, [loadError, loading, quoteDelay, returnAsOfDate, updatedAgo]);
 
   return (
     <DataTableView<SectorRow, SectorColumn>
@@ -442,7 +448,7 @@ export const sectorsModule: PluginModule = {
       paneId: "sectors",
       label: "Thematic Baskets",
       description: "Curated themes with equal-weight returns, breadth and member leaders and laggards.",
-      keywords: ["themes", "thematic", "baskets", "AI compute", "datacenters", "electrification", "power grid", "nuclear", "uranium", "defense", "aerospace", "cybersecurity", "robotics", "automation", "critical minerals", "crypto", "bitcoin", "solar", "clean energy", "gold", "silver", "homebuilders", "memory", "chip equipment", "cloud software"],
+      keywords: ["themes", "thematic", "baskets", "AI compute", "datacenters", "electrification", "power grid", "nuclear", "uranium", "defense", "aerospace", "cybersecurity", "robotics", "automation", "critical minerals", "crypto", "bitcoin", "bitcoin miners", "miners", "bitcoin mining", "solar", "clean energy", "gold", "silver", "homebuilders", "memory", "chip equipment", "cloud software"],
       shortcut: { prefix: "THEM", argKind: "text", argPlaceholder: "theme", argOptional: true },
       headless: themesHeadless,
       // The theme param opens the Themes tab, and the named theme's members.

package/src/plugins/builtin/series-inventory.ts

@@ -61,6 +61,7 @@ export const SERIES_INVENTORY: readonly SeriesInventoryEntry[] = [
   { module: "futures", chart: "Front-month futures board, charted from the board", series: ["fut:*"] },
   { module: "futures-curve", chart: "Futures curve by contract month", notInCatalog: "not-a-time-series", reason: "Plotted by delivery month; each front month is in the catalog as FUT:code." },
   { module: "crypto-board", chart: "Price sparklines for the large coins", series: ["crypto:*"] },
+  { module: "crypto-board", chart: "Bitcoin network hash rate, difficulty, next retarget estimate and hashprice", series: ["bitcoin:*"] },
   { module: "perps", chart: "Perpetual funding, open interest, premium and long/short account share", series: ["perps:*"] },
   { module: "crypto-etf-flows", chart: "The running net flow of the US spot bitcoin or ether ETFs since launch", notInCatalog: "not-yet", reason: "Daily and dated: the running total and each fund's daily flow could be crypto ETF series, and none is registered for the composer yet." },
   { module: "perps", chart: "Perpetual mark price", notInCatalog: "not-yet", reason: "The pair's price is in the catalog; the perpetual's own mark price could be a crypto series." },
@@ -96,6 +97,7 @@ export const SERIES_INVENTORY: readonly SeriesInventoryEntry[] = [
   { module: "analytics", chart: "Portfolio value, drawdown and factor exposure", notInCatalog: "account", reason: "Built from the user's own portfolio; the factor legs are tickers in the catalog." },
   { module: "holders", chart: "Holders treemap", notInCatalog: "not-a-time-series", reason: "A treemap of one filing date." },
   { module: "market-heatmap", chart: "Market heat map", notInCatalog: "not-a-time-series", reason: "A treemap of today's moves." },
+  { module: "buildout", chart: "TheBuildout's theme board", notInCatalog: "not-a-time-series", reason: "A treemap of the themes' market caps, coloured by their median 1Y return today." },
   { module: "portfolio-list", chart: "Portfolio treemap", notInCatalog: "not-a-time-series", reason: "A treemap of current positions." },
   { module: "world-venue-map", chart: "Chokepoint transits and the map's place series", series: ["geo:*"] },
 ];

package/src/plugins/builtin/shared/cloud-resource.ts

@@ -1,6 +1,7 @@
 import { logFailure } from "../../../utils/log-failure";
-import { ApiRequestError, isPermanentClientError } from "../../../api-client/errors";
-import type { PluginCacheResult } from "../../../data/plugin-cache";
+import { ApiRequestError } from "../../../api-client/errors";
+import { createMissingRouteLatch } from "../../../api-client/coalesce";
+import { savedCopyForTransientFailure, type PluginCacheResult } from "../../../data/plugin-cache";
 
 interface CloudCache<T> {
   get(key: string, options?: { allowExpired?: boolean }): PluginCacheResult<T> | null;
@@ -38,9 +39,11 @@ const isAbort = (error: unknown) => !!error && typeof error === "object" && (err
 
 /**
  * Loads through the cache, falling back to the cached copy when a refresh
- * fails. A refusal asking again will not change still throws: a refused
- * session, so the pane shows its sign-in wall instead of data the account can
- * no longer see, and any other permanent client error (an unknown series).
+ * fails for a reason asking again may get past (`isTransientFailure`). A
+ * refusal still throws: a refused session, so the pane shows its sign-in wall
+ * instead of data the account can no longer see, any other permanent client
+ * error (an unknown series, a route not served), and a reply that fails
+ * validation.
  *
  * Callers of one key share the request in flight, which runs on the first
  * caller's `signal`. When that caller goes away (a tab left while it loads,
@@ -60,8 +63,7 @@ export async function loadCloudResource<T>(
     throw error;
   });
   if (!result || cancelledByOther(result.error)) result = await cache.load(key, fetch, { force });
-  const saved = result.source === "stale-fallback";
-  if (saved && isPermanentClientError(result.error)) throw result.error;
+  const saved = savedCopyForTransientFailure(result).source === "stale-fallback";
   // A copy served because its refresh failed is one by where it came from, whatever the failure said (or did not).
   return {
     payload: validate(result.data), stale: result.stale, refreshError: result.refreshError ?? null,
@@ -72,7 +74,70 @@ export async function loadCloudResource<T>(
 /**
  * Turns a route the server does not serve yet (404, or the given statuses)
  * into a message that says what is unavailable; other errors pass through.
+ * The status stays, so a 404 is still a refusal no saved copy answers for and
+ * a 503 still a failure one may.
  */
 export function unavailableOnServer(error: unknown, message: string, statuses: readonly number[] = [404]): unknown {
-  return error instanceof ApiRequestError && statuses.includes(error.status ?? 0) ? new Error(message) : error;
+  return error instanceof ApiRequestError && statuses.includes(error.status ?? 0)
+    ? new ApiRequestError(message, error.status, error.retryAfterMs, error.code, error.details)
+    : error;
+}
+
+/**
+ * Reads ahead many items' payloads in batch requests (`read`, at most `max`
+ * ids each, sent side by side) into the cache their own loads read under
+ * `key`, skipping an item cached fresh unless `force`. Answers the ids stored, which a forced load can
+ * take as fresh; an item the batch failed or left out stays for its own load
+ * to ask, which says why. A batch route the server does not serve (404) is
+ * left alone until it is asked again (BATCH_ROUTE_REPROBE_MS).
+ */
+export function createCloudBatchAhead<T>(
+  cache: CloudCache<T>,
+  options: {
+    max: number;
+    validate: (payload: T) => T;
+    read: (ids: string[]) => Promise<Array<{ id: string; payload: T }>>;
+  },
+): (items: ReadonlyArray<{ id: string; key: string }>, force?: boolean) => Promise<Set<string>> {
+  const route = createMissingRouteLatch();
+  return async (items, force = false) => {
+    const stored = new Set<string>();
+    const keys = new Map<string, string>();
+    for (const { id, key } of items) {
+      const cached = cache.get(key);
+      if (force || !cached || cached.stale) keys.set(id, key);
+    }
+    const ids = [...keys.keys()];
+    if (route.missing() || ids.length < 2) return stored;
+    const chunks = Array.from({ length: Math.ceil(ids.length / options.max) }, (_, index) => ids.slice(index * options.max, (index + 1) * options.max));
+    await Promise.all(chunks.map(async (chunk) => {
+      const read = await options.read(chunk).catch((error: unknown) => {
+        route.refused(error);
+        if (!(error instanceof ApiRequestError && error.status === 404)) logFailure("shared.cloud-resource", "Read a batch of cloud payloads ahead failed")(error);
+        return [];
+      });
+      await Promise.all(read.map(async ({ id, payload }) => {
+        const key = keys.get(id);
+        if (!key) return;
+        try {
+          const valid = options.validate(payload);
+          await cache.load(key, async () => valid, { force: true });
+          stored.add(id);
+        } catch (error) {
+          logFailure("shared.cloud-resource", "Store a batched cloud payload failed")(error);
+        }
+      }));
+    }));
+    return stored;
+  };
+}
+
+/**
+ * A batch reply's items. A reply without them is a service that read the
+ * batch path as something else (an older one's `/:symbol` route, for a symbol
+ * named "batch"), which is a service without the route: a 404.
+ */
+export function batchReplyItems<T>(reply: { items?: T[] } | null | undefined): T[] {
+  if (!Array.isArray(reply?.items)) throw new ApiRequestError("This service does not read these in batches", 404);
+  return reply.items;
 }

package/src/plugins/builtin/shared/cloud-upgrade.ts

@@ -11,7 +11,7 @@ import { useRendererHost } from "../../../ui";
 import type { RendererHost } from "../../../ui";
 import { getSharedRegistry } from "../../registry";
 import { requestAccountManagementTab } from "../account-management/navigation";
-import { resolvePlanAccess, usePlanAccess, type PlanAccess } from "../../../api-client/plan-access";
+import { freeQuotesDelayMinutes, resolvePlanAccess, usePlanAccess, type PlanAccess, type QuoteDelayFacts } from "../../../api-client/plan-access";
 import { useViewport } from "../../../react/input";
 import { type DialogApi, useOptionalDialog } from "../../../ui/dialog";
 import { promptCloudUpgrade } from "../../../account/upgrade-dialog";
@@ -365,3 +365,26 @@ export function useCloudAccessFooter({
 
   return { access, hint, openUpgrade, segment };
 }
+
+/**
+ * The footer's clock for a pane whose prices this account sees late: the free
+ * tier's delay (`freeQuotesDelayMinutes`) on any of `quotes`, pressed for the
+ * upgrade, as the quote footer's clock is. Null with Pro or a trial, and while
+ * every price shown is live, so those accounts see nothing new. A pane whose
+ * data comes as one board says so with one `{ dataSource }` for the board.
+ */
+export function useQuoteDelayFooter(
+  quotes: Iterable<QuoteDelayFacts | null | undefined>,
+  placement: string,
+): PaneFooterSegment | null {
+  const language = useAppLanguage();
+  const minutes = freeQuotesDelayMinutes(usePlanAccess(), quotes);
+  const openUpgrade = useCloudUpgradeAction(placement);
+  return useMemo(() => (minutes == null ? null : delayedFooterSegment({
+    id: "quote-delay",
+    detail: tf("{delay} delayed · try Pro live", { delay: `${minutes}m` }),
+    delay: `${minutes}m`,
+    onPress: openUpgrade,
+    quoteStatus: true,
+  })), [language, minutes, openUpgrade]);
+}

package/src/plugins/builtin/shared/forming-bars.ts

@@ -0,0 +1,29 @@
+/**
+ * The step a daily study takes before it reads closes (BT's run, HVG's
+ * estimates): the newest session is left out while it is not final, and the
+ * report says so. Not final is a session still trading (`partial`: its close
+ * is the latest price) or a future's closed session whose settlement is not
+ * in yet (`unsettled`: its close is the last trade). Either close moves
+ * before the day is done, so a study that kept it would give another answer
+ * read again.
+ */
+interface DatedBar {
+  partial?: boolean;
+  unsettled?: boolean;
+}
+
+export function isFormingBar(bar: DatedBar): boolean {
+  return bar.partial === true || bar.unsettled === true;
+}
+
+/**
+ * What the bars left out are, after their dates: "is still forming
+ * (partial)", "is not settled yet (unsettled)", or for several of both kinds
+ * "are still forming or not settled yet".
+ */
+export function formingBarsState(bars: readonly DatedBar[]): string {
+  const verb = bars.length === 1 ? "is" : "are";
+  if (bars.every((bar) => bar.partial === true)) return `${verb} still forming (partial)`;
+  if (bars.every((bar) => bar.unsettled === true && bar.partial !== true)) return `${verb} not settled yet (unsettled)`;
+  return `${verb} still forming or not settled yet`;
+}

package/src/plugins/builtin/shared/fred-points.ts

@@ -1,11 +1,15 @@
 import { apiClient } from "../../../api-client";
 import { loadCachedFredSeries } from "../../../sources/gloomberb-cloud/fred-series";
 
-/** A FRED series from `start` on, oldest first, through the shared FRED cache. */
+/**
+ * A FRED series from `start` on, oldest first, through the shared FRED cache;
+ * `savedAt` when a failed refresh left the copy saved then answering.
+ */
 export async function loadFredPoints(seriesId: string, start?: Date): Promise<{
   points: Array<{ date: string; value: number | null }>;
   stale: boolean;
   refreshError?: string;
+  savedAt?: number;
 }> {
   const startDate = start ? start.toISOString().slice(0, 10) : "1900-01-01";
   const result = await loadCachedFredSeries(
@@ -16,5 +20,6 @@ export async function loadFredPoints(seriesId: string, start?: Date): Promise<{
     points: (result.data.observations ?? []).map((row) => ({ date: row.date, value: row.value })),
     stale: result.stale,
     ...(result.refreshError ? { refreshError: result.refreshError } : {}),
+    ...(result.source === "stale-fallback" ? { savedAt: result.fetchedAt } : {}),
   };
 }

package/src/plugins/builtin/shared/fx-rate-freshness.ts

@@ -2,6 +2,7 @@ import { intradayBarText } from "../../../market-data/quotes/intraday-bar";
 import type { Quote, QuoteIntradayBar } from "../../../types/financials";
 import { isFxMarketOpen } from "../../../utils/fx-market-hours";
 import { quoteFreshnessFields } from "./report-freshness";
+import { formatUtcDayTime } from "../../../utils/utc-time";
 
 /** The venue FX pairs trade on, so a report can place the FX market. */
 const FX_VENUE = "CCY";
@@ -56,6 +57,22 @@ export function fxRateNotes(legs: ReadonlyMap<string, FxRateTiming>, now = Date.
   });
 }
 
+/**
+ * What `fx --refresh` says of a rate it read again and found still stale with
+ * no reason given (`ZAR/USD: --refresh found no newer rate than Tue 27 Oct
+ * 14:00 UTC.`): the refresh did run, and the data service has nothing newer.
+ * A rate whose refresh failed says that instead, and one with a stated reason
+ * says the reason (fxRateNotes).
+ */
+export function refreshedFxRateNotes(legs: ReadonlyMap<string, FxRateTiming>, now = Date.now()): string[] {
+  return [...legs].flatMap(([currency, timing]) => {
+    if (currency === "USD" || timing.error != null || timing.staleReason || timing.staleAt == null || timing.staleAt > now) return [];
+    const since = timing.asOf != null && Number.isFinite(timing.asOf)
+      ? ` than ${formatUtcDayTime({ time: timing.asOf, dateOnly: false }, now)} UTC` : "";
+    return [`${currency}/USD: --refresh found no newer rate${since}.`];
+  });
+}
+
 function isoTime(time: number | undefined | null): string | undefined {
   return time != null && Number.isFinite(time) ? new Date(time).toISOString() : undefined;
 }

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

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

package/src/plugins/builtin/shared/series-detail-chart.tsx

@@ -111,7 +111,9 @@ export function SeriesDetailChart({
 }) {
   const [userViewport, setUserViewport] = useState<{ start: Date; end: Date } | null>(null);
   const chartWidth = Math.max(24, width);
-  const statRows = statGridRows(stats, width);
+  // A figure wraps only into rows the chart's least leaves, so the pane never spills.
+  const statMaxLines = height - MIN_CHART_ROWS - aboveChartRows - belowChartRows;
+  const statRows = statGridRows(stats, width, undefined, { maxLines: statMaxLines });
   const chartHeight = Math.max(MIN_CHART_ROWS, height - statRows - aboveChartRows - belowChartRows);
   const { unit, unitGroup, nativeFrequency } = axis;
 
@@ -139,7 +141,7 @@ export function SeriesDetailChart({
 
   return (
     <Box flexDirection="column" width={width}>
-      <StatGrid items={stats} width={width} />
+      <StatGrid items={stats} width={width} maxLines={statMaxLines} />
       {drawable ? (
         <>
           {aboveChart?.(chartWidth)}

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

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

package/src/plugins/builtin/shared/use-quote-board.ts

@@ -520,6 +520,11 @@ export function quoteBoardStatus(quotes: BoardQuoteMap): QuoteBoardStatus {
   return { loading, stale, unavailable, latestTs, savedAt: oldestSavedCopyAt(Array.from(quotes.values(), (state) => state.quote)) };
 }
 
+/** The quotes a board shows, for the footer's delayed clock (`useQuoteDelayFooter`). */
+export function* boardQuotes(quotes: BoardQuoteMap): Generator<Quote | null> {
+  for (const state of quotes.values()) yield state.quote;
+}
+
 /** Board footer status: everything here changes as loads succeed or fail. */
 export function quoteBoardFooterInfo(status: QuoteBoardStatus): PaneFooterSegment[] {
   const info: PaneFooterSegment[] = [];

package/src/plugins/builtin/short-interest/publications-pane.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useMemo } from "react";
 import { DataTableStackView, EmptyState, PaneStatusBody, usePaneNoticeFooter, usePaneStatusLinkFooter, type DataTableCell } from "../../../components";
+import { ageFooterSegment } from "../../../components/layout/pane/footer";
 import { DetailReader } from "../../../components/reader/detail-reader";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { useAsyncResource, useAutoRefresh, usePluginPaneState, useUpdatedAgo } from "../../../public/react";
@@ -40,7 +41,7 @@ export function ShortSidePublicationPane({ kind, width, height, focused }: Pick<
     notices: [...(data?.warnings ?? []), ...(resource.data?.refreshError ? [resource.data.refreshError] : [])] });
   usePaneStatusLinkFooter({ registrationId: kind, focused, loading: resource.loading, error: resource.error,
     url: selected?.sourceUrl ?? data?.source.url ?? null, showOpenHint: true,
-    info: data && updatedAgo ? [{ id: "updated", parts: [{ text: updatedAgo, tone: "muted" as const }] }] : [],
+    info: data && updatedAgo ? [ageFooterSegment(updatedAgo)] : [],
     stale: !!data && resource.data?.stale,
   });
   if (!symbol) return <EmptyState title="No ticker selected." message={`Select a US stock to view ${subject}.`} />;

package/src/plugins/builtin/short-volume/pane.tsx

@@ -3,6 +3,7 @@ import { listingIdentity } from "../shared/ticker-request";
 import { Box, ScrollBox, useUiCapabilities } from "../../../ui";
 import { useAsyncResource, useAutoRefresh, usePaneSettingValue, usePluginPaneState, useUpdatedAgo } from "../../../public/react";
 import { ChartTableHeader, DataTableStackView, EmptyState, formatPercentAxis, KeyValueRow, PaneStatusBody, useChartTableSelection, usePaneNoticeFooter, usePaneStatusLinkFooter, type DataTableCell, type StatItem } from "../../../components";
+import { ageFooterSegment } from "../../../components/layout/pane/footer";
 import { colors } from "../../../theme/colors";
 import type { ShortVolumeObservation } from "../../../api-client/short-volume";
 import { isAccessDenied } from "../../../api-client/errors";
@@ -83,7 +84,7 @@ export function ShortVolumePane({ width, height, focused }: Pick<PaneProps, "wid
     notices: [...(data?.warnings ?? []), ...(resource.data?.refreshError ? [resource.data.refreshError] : [])] });
   usePaneStatusLinkFooter({ registrationId: "short-volume", focused, loading: resource.loading, error: resource.error,
     url: selected?.sourceUrl ?? data?.source.url ?? null, showOpenHint: true,
-    info: data && updatedAgo ? [{ id: "updated", parts: [{ text: updatedAgo, tone: "muted" as const }] }] : [],
+    info: data && updatedAgo ? [ageFooterSegment(updatedAgo)] : [],
     stale: !!data && resource.data?.stale,
   });
   if (!data && isCloudSessionRequired(resource.error)) return <SignInWall placement="short-volume-signin" action="view daily short volume" needsVerification={session.needsVerification} />;

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

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