gloomberb 0.19.0 → 0.19.2

package/src/plugins/builtin/risk-factors/pane.tsx

@@ -8,6 +8,7 @@ import {
   type PaneFooterSegment,
   type PaneHint,
 } from "../../../components";
+import { savedCopyFooterInfo } from "../../../components/layout/pane/footer";
 import { useAsyncResource } from "../../../react/async-resource";
 import { colors } from "../../../theme/colors";
 import {
@@ -119,8 +120,9 @@ function RiskFactorsReader({
   const reportLoader = useCallback((force: boolean) => guard(loadRiskReport(ticker!, year!, { force, listing })), [guard, listing, ticker, year]);
   const detail = useAsyncResource(ticker && year !== null ? reportLoader : null, { clearOnError: isPermanentClientError });
   const report = detail.data;
-  const listError = list.error ?? list.data?.refreshError ?? null;
-  const reportError = detail.error ?? report?.refreshError ?? null;
+  // A copy saved earlier answering a failed refresh says when it was saved, in the footer every pane uses, not as an error.
+  const listError = list.error ?? (list.data?.savedAt == null ? list.data?.refreshError : null) ?? null;
+  const reportError = detail.error ?? (report?.savedAt == null ? report?.refreshError : null) ?? null;
   const refresh = useCallback(() => {
     void list.reload();
     if (year !== null) void detail.reload();
@@ -151,12 +153,7 @@ function RiskFactorsReader({
       info.push({ id: "loading", parts: [{ text: "loading", tone: "muted" }] });
     if (listError) info.push({ id: "list-error", parts: [{ text: `Report list: ${listError}`, tone: "warning" }] });
     if (reportError) info.push({ id: "report-error", parts: [{ text: `${year} report: ${reportError}`, tone: "warning" }] });
-    if ((listError || list.data?.stale) && list.data) {
-      info.push({ id: "list-stale", parts: [{ text: `List cached ${new Date(list.data.fetchedAt).toISOString()}`, tone: "muted" }] });
-    }
-    if ((reportError || report?.stale) && report) {
-      info.push({ id: "report-stale", parts: [{ text: `Report cached ${new Date(report.fetchedAt).toISOString()}`, tone: "muted" }] });
-    }
+    info.push(...savedCopyFooterInfo([list.data?.savedAt, report?.savedAt]));
     const hints: PaneHint[] = report?.docUrl
       ? [{ id: "open", key: "o", label: "pen filing", onPress: openFiling }]
       : [];

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

@@ -0,0 +1,28 @@
+import type { PluginModule } from "../plugin-module";
+import { RoadmapPane } from "./pane";
+
+export const roadmapModule: PluginModule = {
+  panes: [
+    {
+      id: "roadmap",
+      name: "Roadmap",
+      icon: "R",
+      component: RoadmapPane,
+      reportFreshness: { status: "not-a-feed", basis: "curated list" },
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 100, height: 30 },
+    },
+  ],
+
+  paneTemplates: [
+    {
+      id: "roadmap-pane",
+      paneId: "roadmap",
+      label: "Roadmap",
+      description: "What is being built, what is planned and what shipped. Pro members vote on what comes next.",
+      keywords: ["roadmap", "planned", "building", "shipped", "upcoming", "features", "vote", "votes", "request"],
+      shortcut: { prefix: "ROADMAP", aliases: ["RMAP"] },
+    },
+  ],
+};

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

@@ -0,0 +1,67 @@
+import type { RoadmapItem, RoadmapPayload, RoadmapStatus, RoadmapVote } from "../../../api-client/roadmap";
+import type { TableSection } from "../../../components";
+
+export const ROADMAP_STATUS_LABELS: Record<RoadmapStatus, string> = {
+  building: "Building",
+  planned: "Planned",
+  shipped: "Shipped",
+};
+
+const SECTION_ORDER: readonly RoadmapStatus[] = ["building", "planned", "shipped"];
+
+/** Building, then Planned, then Shipped, each in the order the service sent; an empty group is left out. */
+export function roadmapSections(items: readonly RoadmapItem[]): TableSection<RoadmapItem>[] {
+  return SECTION_ORDER.map((status) => ({
+    label: ROADMAP_STATUS_LABELS[status],
+    key: status,
+    items: items.filter((item) => item.status === status),
+  }));
+}
+
+/** Votes are taken on what is not shipped yet; a shipped item's count is final. */
+export function isVotable(item: RoadmapItem): boolean {
+  return item.status !== "shipped";
+}
+
+/**
+ * The items with this session's own votes on top: the count and mark a vote
+ * changed, held until the next read of the list replaces them.
+ */
+export function withLocalVotes(
+  payload: RoadmapPayload | null,
+  local: Readonly<Record<string, RoadmapVote>>,
+): RoadmapItem[] {
+  if (!payload) return [];
+  return payload.items.map((item) => {
+    const vote = local[item.id];
+    return vote ? { ...item, votes: vote.votes, voted: vote.voted } : item;
+  });
+}
+
+/** What the row shows while a vote is on its way: the mark flipped and the count moved by one. */
+export function optimisticVote(item: RoadmapItem, voted: boolean): RoadmapVote {
+  const step = voted === item.voted ? 0 : voted ? 1 : -1;
+  return { id: item.id, votes: Math.max(0, item.votes + step), voted };
+}
+
+/** The votes cell: the count, with a check before it when this account voted. */
+export function votesText(item: RoadmapItem): string {
+  return item.voted ? `✓ ${item.votes}` : String(item.votes);
+}
+
+/** What one vote that failed is called on its row, and the reason the detail gives. */
+export interface VoteFailure {
+  status: string;
+  reason: string;
+}
+
+export function voteFailure(error: unknown, voted: boolean): VoteFailure {
+  const status = typeof error === "object" && error && "status" in error ? (error as { status?: unknown }).status : undefined;
+  const action = voted ? "The vote" : "Taking the vote back";
+  if (status === 401) return { status: "sign in", reason: `${action} did not go through: sign in again to vote.` };
+  if (status === 402 || status === 403) return { status: "Pro only", reason: `${action} did not go through: voting is for verified Pro members.` };
+  if (status === 404) return { status: "removed", reason: "This item is no longer on the roadmap." };
+  if (status === 409) return { status: "closed", reason: "This item shipped, so its votes are final." };
+  const message = error instanceof Error && error.message.trim() ? error.message.trim() : "the request failed";
+  return { status: "failed", reason: `${action} did not go through: ${message.replace(/\.$/, "")}.` };
+}

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

@@ -0,0 +1,244 @@
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type RefObject } from "react";
+import { apiClient } from "../../../api-client";
+import { usePlanAccess } from "../../../api-client/plan-access";
+import type { RoadmapItem, RoadmapVote } from "../../../api-client/roadmap";
+import {
+  buildSectionedRows,
+  DataTableStackView,
+  EMPTY_TABLE_CELL,
+  isSectionedItemRow,
+  renderSectionedRowHeader,
+  usePaneStatusFooter,
+  useRowNotes,
+  type DataTableCell,
+  type DataTableColumn,
+  type PaneFooterSegment,
+  type PaneHint,
+  type SectionedRow,
+} from "../../../components";
+import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { DetailReader, type DetailFact } from "../../../components/reader/detail-reader";
+import { useAsyncResource, usePluginPaneState } from "../../../public/react";
+import { useThemeColors } from "../../../theme/theme-context";
+import type { PaneProps } from "../../../types/plugin";
+import { Box, TextAttributes, type ScrollBoxRenderable } from "../../../ui";
+import { formatShortDate } from "../../../utils/datetime-format";
+import {
+  isVotable,
+  optimisticVote,
+  ROADMAP_STATUS_LABELS,
+  roadmapSections,
+  voteFailure,
+  votesText,
+  withLocalVotes,
+  type VoteFailure,
+} from "./model";
+
+/** The roadmap calls the pane makes; tests hand it their own. */
+export type RoadmapClient = Pick<typeof apiClient, "getRoadmap" | "setRoadmapVote">;
+export const RoadmapClientContext = createContext<RoadmapClient | null>(null);
+
+type Row = SectionedRow<RoadmapItem>;
+type ColumnId = "title" | "blurb" | "votes" | "shipped";
+type Column = DataTableColumn & { id: ColumnId };
+
+const rowKey = (row: Row) => row.key;
+const itemKey = (item: RoadmapItem) => item.id;
+const voteSignature = (item: RoadmapItem) => `${item.votes}:${item.voted}`;
+
+/** Said once, quietly, to everyone who cannot vote: no upgrade pitch. */
+const PRO_VOTES_SEGMENT: PaneFooterSegment = { id: "pro-votes", parts: [{ text: "Pro members vote", tone: "muted" }] };
+const NO_SEGMENTS: PaneFooterSegment[] = [];
+
+function shippedDate(item: RoadmapItem): string {
+  return item.shippedAt ? formatShortDate(item.shippedAt, { fallback: "" }) : "";
+}
+
+/** `votesCell` is what the votes cell says: the count, or a vote's failure on that row. */
+function buildColumns(items: readonly RoadmapItem[], width: number, votesCell: (item: RoadmapItem) => string): Column[] {
+  const longest = Math.max(8, ...items.map((item) => item.title.length));
+  const narrow = width < 64;
+  const columns: Column[] = narrow
+    ? [{ id: "title", label: "Feature", width: Math.min(longest, 24), flexGrow: 1, align: "left" }]
+    : [
+      { id: "title", label: "Feature", width: Math.min(longest, width >= 120 ? 36 : 26), align: "left" },
+      { id: "blurb", label: "Summary", width: 16, flexGrow: 1, align: "left" },
+    ];
+  columns.push({ id: "votes", label: "Votes", width: Math.max(5, ...items.map((item) => votesCell(item).length)), align: "right" });
+  if (!narrow && items.some((item) => item.shippedAt)) {
+    columns.push({ id: "shipped", label: "Shipped", width: 12, align: "left" });
+  }
+  return columns;
+}
+
+function RoadmapDetail({ item, failure, width, scrollRef }: {
+  item: RoadmapItem;
+  failure: VoteFailure | null;
+  width: number;
+  scrollRef: RefObject<ScrollBoxRenderable | null>;
+}) {
+  const colors = useThemeColors();
+  // The stack title names the item; the facts and the blurb follow.
+  const facts: DetailFact[] = [
+    { label: "Status", value: ROADMAP_STATUS_LABELS[item.status] },
+    { label: "Votes", value: item.voted ? `${item.votes}, yours included` : String(item.votes) },
+    ...(item.shippedAt ? [{ label: "Shipped", value: shippedDate(item) }] : []),
+    ...(failure ? [{ label: "Vote", value: failure.reason, color: colors.negative }] : []),
+  ];
+  return (
+    <DetailReader
+      ref={scrollRef}
+      resetScrollKey={item.id}
+      width={width}
+      facts={facts}
+      body={item.blurb || null}
+      bodyFormat="text"
+    />
+  );
+}
+
+export function RoadmapPane({ focused, width, height }: PaneProps) {
+  const colors = useThemeColors();
+  const client = useContext(RoadmapClientContext) ?? apiClient;
+  const access = usePlanAccess();
+  // A sign-in, a sign-out or a new plan asks again: the votes and the right to
+  // cast one are the account's. The new loader starts from no list, so the
+  // last account's marks and vote hint go at once, not when (or if) the new
+  // read lands. A refresh of the same session keeps its list.
+  const sessionKey = JSON.stringify([apiClient.getCurrentUser()?.id ?? null, access.emailVerified, access.hasProAccess]);
+  const loader = useCallback((_force: boolean) => client.getRoadmap(), [client, sessionKey]);
+  const resource = useAsyncResource(loader);
+  const sessionRef = useRef(sessionKey);
+  sessionRef.current = sessionKey;
+  const payload = resource.data;
+  const canVote = payload?.canVote === true;
+
+  // This session's votes, over the list until the next read replaces it.
+  const [localVotes, setLocalVotes] = useState<Record<string, RoadmapVote>>({});
+  useEffect(() => setLocalVotes({}), [resource.updatedAt]);
+  const items = useMemo(() => withLocalVotes(payload, localVotes), [payload, localVotes]);
+  const rows = useMemo(() => buildSectionedRows(roadmapSections(items), itemKey), [items]);
+  const { noteFor, setNote, clearNotes } = useRowNotes<RoadmapItem, VoteFailure>(items, { key: itemKey, signature: voteSignature });
+  // Another account's votes and refusals are not this one's.
+  useEffect(() => {
+    setLocalVotes({});
+    clearNotes();
+  }, [sessionKey, clearNotes]);
+
+  const [selectedId, setSelectedId] = usePluginPaneState<string | null>("selectedItemId", null);
+  const [openId, setOpenId] = usePluginPaneState<string | null>("openItemId", null);
+  const selected = items.find((item) => item.id === selectedId) ?? rows.find(isSectionedItemRow)?.item ?? null;
+  const open = openId ? items.find((item) => item.id === openId) ?? null : null;
+  useEffect(() => {
+    // An item that left the roadmap closes once the list that dropped it is in.
+    if (openId && payload && !open) setOpenId(null);
+  }, [open, openId, payload]);
+  const detailScrollRef = useRef<ScrollBoxRenderable>(null);
+
+  const inFlight = useRef(new Set<string>());
+  const reload = resource.reload;
+  const toggleVote = useCallback(async (item: RoadmapItem) => {
+    if (!canVote || !isVotable(item) || inFlight.current.has(item.id)) return;
+    const voted = !item.voted;
+    const session = sessionRef.current;
+    inFlight.current.add(item.id);
+    setNote(item.id, null);
+    setLocalVotes((current) => ({ ...current, [item.id]: optimisticVote(item, voted) }));
+    try {
+      const answer = await client.setRoadmapVote(item.id, voted);
+      // An answer for the account that just left changes nothing on screen.
+      if (sessionRef.current !== session) return;
+      setLocalVotes((current) => ({ ...current, [item.id]: answer }));
+    } catch (error) {
+      if (sessionRef.current !== session) return;
+      setLocalVotes((current) => ({ ...current, [item.id]: { id: item.id, votes: item.votes, voted: item.voted } }));
+      setNote(item.id, voteFailure(error, voted));
+    } finally {
+      inFlight.current.delete(item.id);
+    }
+  }, [canVote, client, setNote]);
+
+  usePaneRefreshKey(() => void reload(), { focused });
+
+  const target = open ?? selected;
+  const hints = useMemo<PaneHint[]>(() => (
+    canVote && target && isVotable(target)
+      ? [{ id: "vote", key: "v", label: target.voted ? " unvote" : "ote", title: target.voted ? "Take vote back" : "Vote", onPress: () => void toggleVote(target) }]
+      : []
+  ), [canVote, target, toggleVote]);
+  usePaneStatusFooter({
+    registrationId: "roadmap",
+    // A failed refresh keeps the list; the failure goes in the footer.
+    loading: resource.loading && !!payload,
+    error: payload ? resource.error : null,
+    info: !canVote && items.length > 0 ? [PRO_VOTES_SEGMENT] : NO_SEGMENTS,
+    hints,
+  });
+
+  const columns = useMemo(
+    () => buildColumns(items, width, (item) => noteFor(item)?.status ?? votesText(item)),
+    [items, noteFor, width],
+  );
+  const renderCell = useCallback((row: Row, column: Column): DataTableCell => {
+    if (!isSectionedItemRow(row)) return EMPTY_TABLE_CELL;
+    const item = row.item;
+    switch (column.id) {
+      case "title":
+        return { text: item.title, color: colors.textBright };
+      case "blurb":
+        return { text: item.blurb, color: colors.textDim };
+      case "votes": {
+        const failure = noteFor(item);
+        if (failure) return { text: failure.status, color: colors.negative };
+        return {
+          text: votesText(item),
+          value: item.votes,
+          color: item.voted ? colors.positive : isVotable(item) ? colors.text : colors.textDim,
+          ...(item.voted ? { attributes: TextAttributes.BOLD } : {}),
+        };
+      }
+      case "shipped":
+        return { text: shippedDate(item), color: colors.textDim };
+    }
+  }, [colors, noteFor]);
+
+  return (
+    <DataTableStackView<Row, Column>
+      focused={focused}
+      detailOpen={!!open}
+      onBack={() => setOpenId(null)}
+      detailTitle={open?.title}
+      detailContent={open ? (
+        <RoadmapDetail item={open} failure={noteFor(open)} width={width} scrollRef={detailScrollRef} />
+      ) : <Box flexGrow={1} />}
+      detailScrollRef={detailScrollRef}
+      rootWidth={width}
+      rootHeight={height}
+      // A refresh keeps the list on screen; only a first read waits or fails in the body.
+      status={payload ? undefined : {
+        loading: resource.loading,
+        error: resource.error,
+        subject: "Roadmap",
+        retry: { onRetry: reload, pending: resource.loading },
+      }}
+      emptyStateTitle="Nothing on the roadmap yet."
+      columns={columns}
+      items={rows}
+      getItemKey={rowKey}
+      isNavigable={isSectionedItemRow}
+      renderSectionHeader={renderSectionedRowHeader}
+      selection={{
+        kind: "id",
+        selectedId: selected?.id ?? null,
+        getId: rowKey,
+        onChange: (id) => setSelectedId(String(id)),
+      }}
+      onActivate={(row) => { if (isSectionedItemRow(row)) setOpenId(row.item.id); }}
+      sortColumnId={null}
+      sortDirection="asc"
+      renderCell={renderCell}
+      selectedTextOverridesCellColor
+      showHorizontalScrollbar={false}
+    />
+  );
+}

package/src/plugins/builtin/scanner/live-headless.ts

@@ -17,6 +17,7 @@ import {
   type LiveScan,
 } from "./live-model";
 import { LIVE_SCAN_INDEXES } from "../../../api-client/live-scan";
+import { formatHiloPrice } from "./hilo-model";
 
 /** `all`, an index (`sp500`) or a sector (`Energy`), as `--universe` takes it. */
 function parseHeadlessUniverse(value: string): LiveScan["universe"] {
@@ -61,7 +62,24 @@ function emptyText(payload: LiveScanPayload): string {
 
 const number = (value: unknown) => (typeof value === "number" ? value : undefined);
 
+/** `2026-10-27 19:59 UTC`: when the scan last ran, to the minute. */
+const utcMinute = (at: number) => `${new Date(at).toISOString().slice(0, 16).replace("T", " ")} UTC`;
+
+/**
+ * What the report says above the matches: outside the session that the
+ * market is closed and when the scan last ran, since a delay means nothing
+ * then; in the session a delayed feed's delay.
+ */
+function headerNotice(payload: LiveScanPayload): string | null {
+  if (payload.status === "closed") {
+    const last = payload.asOf ?? payload.takenAt;
+    return last != null && Number.isFinite(last) ? `Market closed; last scan ${utcMinute(last)}` : "Market closed";
+  }
+  return payload.access === "delayed" ? `Delayed ${payload.delayMinutes} minutes` : null;
+}
+
 function projectLiveScan(payload: LiveScanPayload, scan: LiveScan): HeadlessSnapshotResult {
+  const notice = headerNotice(payload);
   return {
     asOf: new Date(payload.asOf ?? payload.takenAt ?? Date.now()).toISOString(),
     empty: emptyText(payload),
@@ -80,7 +98,7 @@ function projectLiveScan(payload: LiveScanPayload, scan: LiveScan): HeadlessSnap
     ...(payload.status === "degraded" ? { errors: ["Live scanner degraded"] } : {}),
     freshness: freshness(payload),
     metadata: {
-      ...(payload.access === "delayed" ? { notices: [`Delayed ${payload.delayMinutes} minutes`] } : {}),
+      ...(notice ? { notices: [notice] } : {}),
       ...(payload.warnings.length ? { warnings: payload.warnings } : {}),
       status: payload.status,
       access: payload.access,
@@ -117,7 +135,8 @@ export const liveScanHeadless: HeadlessPaneDefinition<"snapshot"> = {
   columns: [
     { key: "symbol", header: "Symbol" },
     { key: "name", header: "Name" },
-    { key: "price", header: "Price", align: "right" },
+    // At the pane's precision: cents, or four decimals under a dollar; the JSON keeps the feed's digits.
+    { key: "price", header: "Price", align: "right", format: (value) => typeof value === "number" ? formatHiloPrice(value) : "--" },
     { key: "changePercent", header: "Chg %", align: "right", format: (value) => formatPercentRaw(number(value)) },
     { key: "relativeVolume", header: "RVol", align: "right", format: (value) => formatMultiple(number(value)) },
     { key: "volume", header: "Volume", align: "right" },

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/headless.ts

@@ -20,6 +20,7 @@ import { fetchFundFacts, fundFactEntries, fundFactPublishers, fundFactsEmpty, fu
 import { REPORT_ROWS } from "../shared/headless-options";
 import { fundAbroadProfile, venueAbroad, type FundAbroadProfile } from "./fund-abroad";
 import { listingAnnouncementsPage } from "../../../utils/exchange-announcements";
+import { companyDataNotes } from "../../../types/company-from";
 
 const SEC_COLUMNS: HeadlessPaneColumn[] = [
   {
@@ -140,7 +141,7 @@ export function createSecHeadless(dependencies: SecHeadlessDependencies = defaul
       return {
         rows,
         textColumns: secTextColumns(rows),
-        ...(note ? { notes: [note] } : {}),
+        ...(note || filings[0]?.companyFrom ? { notes: [...(note ? [note] : []), ...companyDataNotes(filings[0]?.companyFrom)] } : {}),
         ...(form ? { empty: `No ${form} filings found for ${symbol}.` }
           : page ? { empty: `${symbol} files no SEC reports. ${page.name}: ${page.url}` } : {}),
         metadata: {

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

@@ -12,6 +12,7 @@ import { Box, Text, useUiCapabilities, type ScrollBoxRenderable } from "../../..
 import { FILL_REST } from "../../../components/ui/fill";
 import { t, tf } from "../../../i18n";
 import { EmptyState, ExternalLinkText, FeedDataTableStackView, PaneLinkMenu, QueryBar, Spinner, TickerBadgeList, usePaneNoticeFooter, useTableLoadMore, type FeedDataTableItem, type PaneHint, type QueryBarFilter } from "../../../components";
+import { useCompanyDataFooter } from "../../../components/layout/pane/status-footer";
 import { displayWidth } from "../../../utils/format";
 import type { DetailFact } from "../../../components/reader/detail-reader";
 import type { ThemeColors } from "../../../theme/colors";
@@ -466,6 +467,8 @@ function SecView({ width, height, focused, paneType }: { width: number; height:
     showOpenHint: !!(openFiling ? openFiling.filingUrl : factsUrl ?? abroadPage ?? announcements),
   });
 
+  // A foreign line's filings are its company's, read from the home line.
+  useCompanyDataFooter(issuerFilings[0]?.companyFrom, !openFiling);
   usePaneNoticeFooter({
     registrationId: "sec:form-filter",
     notices: filterHistoryCapped

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

@@ -1,6 +1,6 @@
 import { logFailure } from "../../../utils/log-failure";
-import { ApiRequestError, isAccessDenied } from "../../../api-client/errors";
-import type { PluginCacheResult } from "../../../data/plugin-cache";
+import { ApiRequestError } from "../../../api-client/errors";
+import { savedCopyForTransientFailure, type PluginCacheResult } from "../../../data/plugin-cache";
 
 interface CloudCache<T> {
   get(key: string, options?: { allowExpired?: boolean }): PluginCacheResult<T> | null;
@@ -12,6 +12,8 @@ export interface CloudResource<T> {
   payload: T;
   stale: boolean;
   refreshError: string | null;
+  /** When the copy shown was saved, when it is one because its refresh failed. */
+  savedAt?: number;
 }
 
 /**
@@ -36,8 +38,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 refused session still throws, so the pane shows its sign-in wall
- * instead of data the account can no longer see.
+ * 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,
@@ -57,14 +62,22 @@ export async function loadCloudResource<T>(
     throw error;
   });
   if (!result || cancelledByOther(result.error)) result = await cache.load(key, fetch, { force });
-  if (isAccessDenied(result.error)) throw result.error;
-  return { payload: validate(result.data), stale: result.stale, refreshError: result.refreshError ?? null };
+  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,
+    ...(saved ? { savedAt: result.fetchedAt } : {}),
+  };
 }
 
 /**
  * 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;
 }

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/headless-market-data.ts

@@ -6,7 +6,7 @@ import { clipPriceHistoryToRange } from "../../../time-series/history-window";
 import { canonicalExchange, parsePublicTickerKey } from "../../../utils/exchanges";
 import { nonUsSecListingVenue } from "../../../utils/sec";
 
-export async function resolveHeadlessInstrument(ctx: HeadlessPaneContext, symbol: string) {
+export async function resolveHeadlessInstrument(ctx: Pick<HeadlessPaneContext, "resolveInstrument">, symbol: string) {
   return ctx.resolveInstrument ? ctx.resolveInstrument(symbol) : parsePublicTickerKey(symbol);
 }
 
@@ -39,7 +39,7 @@ export async function resolveHeadlessIssuerListing(ctx: HeadlessPaneContext, key
   return resolveIssuerListing(key, exchange, ctx.marketData);
 }
 
-export async function loadHeadlessFinancials(ctx: HeadlessPaneContext, key: string) {
+export async function loadHeadlessFinancials(ctx: Pick<HeadlessPaneContext, "marketData" | "resolveInstrument">, key: string) {
   const { symbol, exchange } = await resolveHeadlessInstrument(ctx, key);
   return ctx.marketData.getTickerFinancials(symbol, exchange ?? "");
 }