gloomberb 0.17.2 → 0.17.4

package/src/plugins/builtin/research/relative-valuation-pane.tsx

@@ -159,7 +159,10 @@ export function RelativeValuationPane({ focused, width, height }: PaneProps) {
   const error = symbols.length > 0 ? peerSnapshot.error : "No tickers selected";
   const [selectedIdx, setSelectedIdx] = useState(0);
   const [sortPreference, setSortPreference] = useState<RelativeSortPreference>(DEFAULT_RELATIVE_SORT);
-  const baseCurrency = useAppSelector((state) => state.config.baseCurrency);
+  const appBaseCurrency = useAppSelector((state) => state.config.baseCurrency);
+  // `--currency` on a capture asks for another currency than the app's.
+  const capCurrency = typeof pane?.settings?.capCurrency === "string" ? pane.settings.capCurrency : null;
+  const baseCurrency = capCurrency ?? appBaseCurrency;
   const quoteTargets = useMemo<QuoteSubscriptionTarget[]>(() => symbols.map((peer) => ({
     symbol: peer,
     exchange: "",
@@ -209,8 +212,11 @@ export function RelativeValuationPane({ focused, width, height }: PaneProps) {
 
   usePaneNoticeFooter({
     registrationId: "relative-valuation-notices",
-    notices: rows.filter((row) => row.fundamentalsProvenance?.stale)
-      .map((row) => `${row.symbol}: ${RELATIVE_VALUATION_STALE_FUNDAMENTALS_NOTICE}.`),
+    notices: [
+      ...rows.filter((row) => row.fundamentalsProvenance?.stale)
+        .map((row) => `${row.symbol}: ${RELATIVE_VALUATION_STALE_FUNDAMENTALS_NOTICE}.`),
+      ...rows.flatMap((row) => row.evSalesUnavailable ? [`${row.symbol}: ${row.evSalesUnavailable}`] : []),
+    ],
     focused,
   });
 
@@ -237,7 +243,10 @@ export function RelativeValuationPane({ focused, width, height }: PaneProps) {
       case "forwardPE":
         return { text: formatPriceEarnings(row.notMeaningful.forwardPE ? NOT_MEANINGFUL : row.reportedMultiples.forwardPE), color: colors.text };
       case "evSales":
-        return { text: formatNumber(row.evSales ?? undefined, 1), color: colors.text };
+        // A withdrawn EV says so; the footer says why.
+        return row.evSales == null && row.evSalesUnavailable
+          ? { text: "EV n/a", color: colors.textDim }
+          : { text: formatNumber(row.evSales ?? undefined, 1), color: colors.text };
       case "fcfYield":
         return { text: formatLevelPercent(row.fcfYield ?? undefined), color: priceColor(row.fcfYield ?? 0) };
       case "revenueGrowth":

package/src/plugins/builtin/research/relative-valuation-peers.ts

@@ -0,0 +1,302 @@
+import type { ScreenDefinition, ScreenRow } from "../../../api-client/equity-screener";
+import type { HeadlessPaneContext } from "../../../types/headless";
+import type { TickerFinancials } from "../../../types/financials";
+import { isUsListingExchange, parsePublicTickerKey } from "../../../utils/exchanges";
+import { errorMessage } from "../../../utils/errors";
+import { selectMarketCapitalization } from "../../../utils/market-capitalization";
+import { fetchScreen } from "../equity-screener/client";
+import { loadFxLegs } from "./relative-valuation-currency";
+
+/** How many peers `--peers` adds at most, and the fewest it settles for before it falls back. */
+const MOST_PEERS = 6;
+const FEWEST_PEERS = 4;
+
+/**
+ * How the peers were picked: the subject's own industry, the industry its
+ * business belongs to when its profile files it under another, a curated
+ * group's core first (the subject is one of that core) and its industry
+ * after, or a curated list when too few covered equities can be read.
+ */
+type PeerMethod = "industry" | "related-industry" | "curated-core" | "curated";
+
+/** The peers `--peers` added to one symbol, and how; the pane and the report both read it. */
+export interface PeerSelection {
+  subject: string;
+  peers: string[];
+  method: PeerMethod;
+  /** The industry the peers come from, as the screener names it. */
+  industry: string | null;
+  /** The subject's own industry, as its profile names it. */
+  subjectIndustry: string | null;
+  /** The peers taken from a curated group's core, first in `peers`; the rest came from `industry`. */
+  curatedPeers?: string[];
+  /** The curated group, as the header and the note name it (`online learning`). */
+  curatedGroup?: string;
+  /** How the peers were chosen, read after "Peers chosen automatically: ". */
+  basis: string;
+}
+
+/**
+ * An industry whose companies are often filed under another: a subject
+ * filed under one of `filedUnder` whose profile opens on this business takes
+ * its peers from `industry` instead. Its curated `core` are the companies
+ * that compete head on: one of them is compared with the rest of the core
+ * first and the industry after, and they join every other subject's
+ * candidates.
+ */
+interface RelatedIndustry {
+  /** The business, as the note names it (`its education business`). */
+  label: string;
+  industry: string;
+  filedUnder: readonly string[];
+  /** What the first sentence of the profile says when the company is in this business. */
+  business: RegExp;
+  /** The curated group the core forms, as the header and the note name it. */
+  coreLabel: string;
+  /** The curated core; also the peers used when the screener cannot answer, or covers fewer than four. */
+  core: readonly string[];
+}
+
+/** Kept small on purpose: an entry earns its place when an industry label hides who the competitors are. */
+const RELATED_INDUSTRIES: readonly RelatedIndustry[] = [{
+  label: "education",
+  industry: "Education & Training Services",
+  filedUnder: ["Software - Application", "Software - Infrastructure", "Internet Content & Information"],
+  business: /\b(?:education|educational|e-?learning|online learning|language learning|learning platform|tutoring)\b/i,
+  coreLabel: "online learning",
+  core: ["DUOL", "COUR", "CHGG", "NRDY", "LRN", "UDMY"],
+}];
+
+/** The company `--peers` was given: its industry and business from its profile, and its market cap in US dollars. */
+export interface PeerSubject {
+  symbol: string;
+  industry: string | null;
+  description: string | null;
+  marketCapUsd: number | null;
+}
+
+/** A covered equity the screener returned, with what the ranking reads. */
+export interface PeerCandidate {
+  symbol: string;
+  marketCapUsd: number | null;
+  /** It reports revenue figures (growth or a margin): a shell or a treasury vehicle filed in an industry does not. */
+  reportsOperations: boolean;
+}
+
+/** Where the subject's peers come from: its own industry, or the related one its business belongs to. */
+interface PeerGroup {
+  industry: string;
+  related: RelatedIndustry | null;
+  /** The subject is one of the related industry's curated core, which it is compared with first. */
+  inCore: boolean;
+}
+
+function bareSymbol(symbol: string): string {
+  return parsePublicTickerKey(symbol).symbol.toUpperCase();
+}
+
+/** A period that ends an abbreviation or an initial (`Inc.`, `N.V.`, `U.S.`), not a sentence. */
+const ABBREVIATION_END = /(?:\b(?:inc|corp|co|ltd|plc|llc|lp|ag|se|nv|sa|no|st|mr|mrs|dr|jr|sr|vs|etc)|\b[a-z])\.$/i;
+
+/**
+ * What a profile says the company does, before who it serves: its first
+ * sentence, read past the name's `Inc.` (`Duolingo, Inc. Class A Common Stock
+ * represents ownership in Duolingo, a technology company focused on...`).
+ */
+function firstSentence(text: string | null): string {
+  const source = text ?? "";
+  for (const match of source.matchAll(/[.!?](?=\s+[A-Z])/g)) {
+    const head = source.slice(0, match.index + 1);
+    if (!ABBREVIATION_END.test(head)) return head;
+  }
+  return source;
+}
+
+export function peerGroupOf(subject: Pick<PeerSubject, "symbol" | "industry" | "description">): PeerGroup | null {
+  const symbol = bareSymbol(subject.symbol);
+  // A member of a curated core is placed by its symbol, whatever its profile says.
+  const core = RELATED_INDUSTRIES.find((group) => group.core.includes(symbol));
+  if (core) return { industry: core.industry, related: core, inCore: true };
+  const industry = subject.industry?.trim();
+  if (!industry) return null;
+  const related = RELATED_INDUSTRIES.find((group) => group.industry === industry
+    || (group.filedUnder.includes(industry) && group.business.test(firstSentence(subject.description))));
+  return related ? { industry: related.industry, related, inCore: false } : { industry, related: null, inCore: false };
+}
+
+/**
+ * The candidates closest to the subject in market cap, measured as a ratio
+ * (half its size and twice its size are as close), at most six. A candidate
+ * that reports no revenue figures is left out, and the subject itself.
+ * Without the subject's cap the largest come first.
+ */
+export function rankPeerCandidates(
+  subject: Pick<PeerSubject, "symbol" | "marketCapUsd">,
+  candidates: readonly PeerCandidate[],
+  { limit = MOST_PEERS, exclude = [] }: { limit?: number; exclude?: readonly string[] } = {},
+): string[] {
+  const seen = new Set([bareSymbol(subject.symbol), ...exclude.map(bareSymbol)]);
+  const usable = candidates.filter((candidate) => {
+    const key = bareSymbol(candidate.symbol);
+    if (!candidate.reportsOperations || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const base = subject.marketCapUsd != null && subject.marketCapUsd > 0 ? subject.marketCapUsd : null;
+  const distance = (cap: number | null) => (base && cap != null && cap > 0 ? Math.abs(Math.log(cap / base)) : Number.POSITIVE_INFINITY);
+  return usable
+    .sort((left, right) => distance(left.marketCapUsd) - distance(right.marketCapUsd)
+      || (right.marketCapUsd ?? 0) - (left.marketCapUsd ?? 0)
+      || left.symbol.localeCompare(right.symbol))
+    .slice(0, limit)
+    .map((candidate) => candidate.symbol);
+}
+
+/** `A`, `A and B`, `A, B and C`. */
+function listText(items: readonly string[]): string {
+  return items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+}
+
+/** The covered equities the screener returned for a subject's group: its industry's, and its curated core's. */
+export interface PeerCandidates {
+  industry: readonly PeerCandidate[];
+  core: readonly PeerCandidate[];
+}
+
+/**
+ * The peers of the subject, from the covered equities of its group. One of a
+ * curated core is compared with the rest of that core first, closest in
+ * market cap, and the industry's closest fill the table to six. Any other
+ * subject takes the closest of its own industry, or of the related industry
+ * its business belongs to with that core among the candidates. Fewer than
+ * four, or no candidates at all (`candidates` null: the screener did not
+ * answer), falls back to the related industry's curated core when it has
+ * one; otherwise what was found, or null when nothing was.
+ */
+export function selectPeers(subject: PeerSubject, group: PeerGroup, candidates: PeerCandidates | null): PeerSelection | null {
+  const symbol = subject.symbol;
+  const related = group.related;
+  const curatedCore = group.inCore && related ? (candidates ? rankPeerCandidates(subject, candidates.core) : []) : [];
+  const fill = candidates
+    ? group.inCore
+      ? rankPeerCandidates(subject, candidates.industry, { limit: MOST_PEERS - curatedCore.length, exclude: curatedCore })
+      : rankPeerCandidates(subject, [...candidates.industry, ...related ? candidates.core : []])
+    : [];
+  const peers = [...curatedCore, ...fill];
+  if (peers.length < FEWEST_PEERS && related) {
+    const curated = related.core.filter((peer) => peer !== bareSymbol(symbol)).slice(0, MOST_PEERS);
+    return {
+      subject: symbol, peers: curated, method: "curated", industry: related.industry, subjectIndustry: subject.industry,
+      curatedPeers: curated, curatedGroup: related.coreLabel,
+      basis: `the ${related.coreLabel} curated list (${listText(curated)}), as ${candidates ? `fewer than ${FEWEST_PEERS}` : "no"} covered equities in ${related.industry} could be read`,
+    };
+  }
+  if (peers.length === 0) return null;
+  // `the 6 covered equities in X closest to DUOL in market cap`, the fill after a core naming its own.
+  const closest = (names: readonly string[]) => {
+    const count = names.length === 1 ? "the covered equity" : `the ${names.length} covered equities`;
+    return `${names === peers ? "" : `${listText(names)}, `}${count} in ${group.industry} closest to ${symbol} in market cap`;
+  };
+  if (related && group.inCore && curatedCore.length > 0) {
+    return {
+      subject: symbol, peers, method: "curated-core", industry: group.industry, subjectIndustry: subject.industry,
+      curatedPeers: curatedCore, curatedGroup: related.coreLabel,
+      basis: `${listText(curatedCore)} from the ${related.coreLabel} curated core${fill.length > 0 ? `; ${closest(fill)}` : ""}`,
+    };
+  }
+  if (related && group.industry !== subject.industry) {
+    return {
+      subject: symbol, peers, method: "related-industry", industry: group.industry, subjectIndustry: subject.industry,
+      basis: `${closest(peers)}, where its ${related.label} business sits though its profile files it under ${subject.industry ?? "another industry"}`,
+    };
+  }
+  return { subject: symbol, peers, method: "industry", industry: group.industry, subjectIndustry: subject.industry, basis: closest(peers) };
+}
+
+/**
+ * The header's words for the peers: `peers by industry: Airlines`; a pane
+ * title, which has no note under it, says they were chosen for the reader
+ * (`auto peers by industry: Airlines`).
+ */
+export function peerMethodTitle(selection: PeerSelection, { automatic = false }: { automatic?: boolean } = {}): string {
+  const peers = automatic ? "auto peers" : "peers";
+  switch (selection.method) {
+    case "industry":
+      return `${peers} by industry: ${selection.industry}`;
+    case "related-industry":
+      return `${peers} by related industry: ${selection.industry}`;
+    case "curated-core":
+      return selection.peers.length > (selection.curatedPeers?.length ?? 0)
+        ? `${peers}: ${selection.curatedGroup} curated core, then ${selection.industry}`
+        : `${peers}: ${selection.curatedGroup} curated core`;
+    case "curated":
+      return `${peers} from a curated list`;
+  }
+}
+
+function screenSymbol(row: ScreenRow): string {
+  return isUsListingExchange(row.exchange) ? row.symbol : `${row.symbol}:${row.exchange}`;
+}
+
+function candidateOf(row: ScreenRow): PeerCandidate {
+  const metric = (field: keyof ScreenRow["metrics"]) => row.metrics[field]?.value ?? null;
+  return {
+    symbol: screenSymbol(row),
+    marketCapUsd: metric("marketCap"),
+    reportsOperations: metric("revenueGrowthPercent") != null || metric("grossMarginPercent") != null
+      || metric("operatingMarginPercent") != null,
+  };
+}
+
+async function screenRows(criterion: ScreenDefinition["criteria"][number], ctx: HeadlessPaneContext): Promise<ScreenRow[]> {
+  const definition: ScreenDefinition = { version: 1, criteria: [criterion], sort: { field: "marketCap", direction: "desc" }, currency: "USD" };
+  return (await fetchScreen(definition, null, ctx.signal, ctx.apiClient)).rows;
+}
+
+/** The subject's market cap in US dollars, through the app's FX rates when it is quoted in another currency. */
+async function subjectCapUsd(financials: TickerFinancials | null, ctx: HeadlessPaneContext): Promise<number | null> {
+  const cap = selectMarketCapitalization(financials?.quote, financials?.fundamentals);
+  if (!cap) return null;
+  if (cap.currency === "USD") return cap.value;
+  const { legs } = await loadFxLegs([cap.currency], ctx);
+  const rate = legs.get(cap.currency)?.rate;
+  return rate != null ? cap.value * rate : null;
+}
+
+/**
+ * Picks the peers of `symbol` for `--peers`: its group from its symbol or
+ * profile, the group's covered equities from the screener (its industry, and
+ * a related industry's curated core), ranked as `selectPeers` says. Throws
+ * when nothing places the subject, or nothing can be found, saying how to
+ * list peers instead.
+ */
+export async function pickPeers(symbol: string, financials: TickerFinancials | null, ctx: HeadlessPaneContext): Promise<PeerSelection> {
+  const subject: PeerSubject = {
+    symbol,
+    industry: financials?.profile?.industry?.trim() || null,
+    description: financials?.profile?.description ?? null,
+    marketCapUsd: null,
+  };
+  const listYourOwn = `List them yourself: gloomberb fn RV ${symbol} <tickers>.`;
+  const group = peerGroupOf(subject);
+  if (!group) throw new Error(`${symbol}'s profile names no industry, so --peers cannot pick its peers. ${listYourOwn}`);
+  let candidates: PeerCandidates | null = null;
+  let failure: string | null = null;
+  try {
+    const [capUsd, industryRows, coreRows] = await Promise.all([
+      subjectCapUsd(financials, ctx).catch(() => null),
+      screenRows({ field: "industry", op: "in", value: [group.industry] }, ctx),
+      group.related ? screenRows({ field: "symbol", op: "in", value: [...group.related.core] }, ctx) : Promise.resolve([]),
+    ]);
+    subject.marketCapUsd = capUsd;
+    candidates = { industry: industryRows.map(candidateOf), core: coreRows.map(candidateOf) };
+  } catch (error) {
+    ctx.signal.throwIfAborted();
+    failure = errorMessage(error);
+  }
+  const selection = selectPeers(subject, group, candidates);
+  if (selection) return selection;
+  throw new Error(failure
+    ? `--peers could not read the covered equities in ${group.industry}: ${failure} ${listYourOwn}`
+    : `No other covered equity is in ${group.industry}, so --peers found no peers for ${symbol}. ${listYourOwn}`);
+}

package/src/plugins/builtin/research-search/data.ts

@@ -52,6 +52,17 @@ function documentKey(docType: CloudSearchDocType, sourceId: string): string {
   return `${docType}:${sourceId}`;
 }
 
+export function cachedSearchDocument(
+  docType: CloudSearchDocType,
+  sourceId: string,
+): CloudSearchDocument | null {
+  return persistence?.getResource<CloudSearchDocument>(DOCUMENT_KIND, documentKey(docType, sourceId), {
+    sourceKey: CACHE_SOURCE,
+    schemaVersion: CACHE_SCHEMA_VERSION,
+    allowExpired: true,
+  })?.value ?? null;
+}
+
 export async function loadSearchDocument(
   docType: CloudSearchDocType,
   sourceId: string,

package/src/plugins/builtin/research-search/pane.tsx

@@ -41,6 +41,7 @@ import { usePlanAccess } from "../../../api-client/plan-access";
 import {
   createSavedSearch,
   deleteSavedSearch,
+  cachedSearchDocument,
   isAbortError,
   loadSavedSearches,
   loadSearchDocument,
@@ -147,6 +148,14 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
     [hits, openHitId],
   );
   const openHit = openHitIndex >= 0 ? hits[openHitIndex]! : null;
+  // The document the cache holds paints at once; another document never
+  // shows under this hit's title while its own loads.
+  const [seededDocumentKey, setSeededDocumentKey] = useState<string | null>(null);
+  const openDocumentKey = openHit ? hitDocumentKey(openHit) : null;
+  if (seededDocumentKey !== openDocumentKey) {
+    setSeededDocumentKey(openDocumentKey);
+    setDocument(openHit ? cachedSearchDocument(openHit.docType, openHit.sourceId) : null);
+  }
 
   const focusField = useCallback((field: Exclude<ActiveField, null>) => {
     setActiveField(field);
@@ -165,7 +174,6 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
     const controller = new AbortController();
     setDocumentLoading(true);
     setDocumentFailure(null);
-    setDocument(null);
     void loadSearchDocument(openHit.docType, openHit.sourceId, controller.signal)
       .then((loaded) => {
         if (controller.signal.aborted) return;
@@ -173,7 +181,10 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
       })
       .catch((error: unknown) => {
         if (controller.signal.aborted || isAbortError(error)) return;
-        setDocumentFailure({ message: errorMessage(error), status: statusOf(error) });
+        const status = statusOf(error);
+        // Losing entitlement re-gates the document, not the copy the cache seeded.
+        if (status === 401 || status === 402 || status === 403) setDocument(null);
+        setDocumentFailure({ message: errorMessage(error), status });
       })
       .finally(() => {
         if (!controller.signal.aborted) setDocumentLoading(false);

package/src/plugins/builtin/scanner/hilo-pane.tsx

@@ -4,7 +4,6 @@ import {
   DataTableView,
   PaneStatusBody,
   QueryBar,
-  Tabs,
   type DataTableCell,
   type DataTableColumn,
   type DataTableKeyEvent,
@@ -125,9 +124,7 @@ function HiloPane({ focused, width, height }: PaneProps) {
   const showBars = !!feed.payload && height >= BARS_MIN_HEIGHT;
   // One cell of gutter keeps the two cursors from reading as a single wide row.
   const tableWidth = split ? Math.max(12, Math.floor((width - 1) / 2)) : Math.max(12, width);
-  // A single table gets a strip naming its side, so the other side is visibly there.
-  const sideStripRows = split ? 0 : 1;
-  const tableHeight = Math.max(2, height - QUERY_BAR_HEIGHT - (showBars ? BARS_HEIGHT : 0) - sideStripRows);
+  const tableHeight = Math.max(2, height - QUERY_BAR_HEIGHT - (showBars ? BARS_HEIGHT : 0));
   const columns = useMemo(() => ({ lows: buildColumns(tableWidth, "lows"), highs: buildColumns(tableWidth, "highs") }), [tableWidth]);
 
   const handleSelect = useCallback((side: Side, row: ScannerHiloExtreme, index: number) => {
@@ -184,21 +181,14 @@ function HiloPane({ focused, width, height }: PaneProps) {
             options: MIN_PRICE_OPTIONS, onChange: setMinPrice },
           { id: "sort", label: "Sort", inline: true, value: sort, options: SORT_OPTIONS, onChange: setSort },
         ]}
+        view={split ? undefined : {
+          value: activeSide,
+          options: SIDE_TABS,
+          onChange: (value) => setActiveSide(value),
+          focused,
+        }}
       />
       {showBars && <HiloBars windows={feed.payload?.windows} width={width} />}
-      {!split && (
-        // Left and right (and h/l) switch sides, as they do between the split tables.
-        <Box height={1} paddingX={1} flexShrink={0}>
-          <Tabs
-            tabs={SIDE_TABS}
-            activeValue={activeSide}
-            onSelect={(value) => setActiveSide(value as Side)}
-            compact
-            dense
-            focused={focused}
-          />
-        </Box>
-      )}
       <Box flexDirection="row" flexGrow={1} overflow="hidden">
         {split ? (
           <>

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

@@ -22,6 +22,29 @@ export const SEASONALITY_HISTORY_RESOLUTION: Record<SeasonalityCadence, ManualCh
 /** Daily history is served to five years; a longer request can come back as weekly bars. */
 const BUFFER_RANGE = { monthly: "ALL", daily: "5Y" } as const;
 
+export function cachedSeasonalityHistory(
+  request: { instrument: InstrumentRef; cadence?: SeasonalityCadence },
+): SeasonalityHistory | null {
+  const coordinator = getSharedMarketDataCoordinator();
+  if (!coordinator) return null;
+  const cadence = request.cadence ?? "monthly";
+  const entry = coordinator.getChartEntry({
+    instrument: request.instrument,
+    bufferRange: BUFFER_RANGE[cadence],
+    granularity: "resolution",
+    resolution: SEASONALITY_HISTORY_RESOLUTION[cadence],
+  });
+  const history = resolveEntryValue(entry);
+  if (!history?.length) return null;
+  const now = Date.now();
+  return {
+    history,
+    stale: !!entry.error || (entry.staleAt != null && entry.staleAt <= now),
+    error: entry.error?.message ?? null,
+    fetchedAt: entry.fetchedAt ?? now,
+  };
+}
+
 /**
  * Every month on record: the lookback is cut in the model, so changing it never
  * refetches. Monthly bars, because daily history is only served to 5Y where

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

@@ -14,7 +14,7 @@ import { useThemeColors } from "../../../theme/theme-context";
 import type { ResolvedSeries } from "../../../time-series/types";
 import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
-import { loadSeasonalityHistory } from "./client";
+import { cachedSeasonalityHistory, loadSeasonalityHistory } from "./client";
 import { type DailyReturnStat, MONTH_LABELS, OVERLAY_YEAR, projectSeasonality, projectWeekdays, type SeasonalityModel,
   TURN_OF_MONTH_LABELS, type WeekdayModel } from "./model";
 
@@ -156,7 +156,9 @@ export function SeasonalityPane({ width, height, focused }: PaneProps) {
     if (!snapshot.history.length && snapshot.error) throw new Error(snapshot.error);
     return snapshot;
   }, [instrumentKey, cadence]);
-  const history = useAsyncResource(instrument ? loader : null);
+  const history = useAsyncResource(instrument ? loader : null, {
+    initialData: () => instrument ? cachedSeasonalityHistory({ instrument, cadence }) : null,
+  });
   useEffect(() => () => controller.current?.abort(), [loader]);
   useAutoRefresh(history.updatedAt, history.load);
   usePaneRefreshKey(() => { void history.reload(); }, { focused });

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

@@ -323,11 +323,15 @@ function EtfBoard({ collectionId, focused, width, height, rootBefore }: EtfBoard
           text: row.loading && row.return1Y === null ? "…" : row.return1Y !== null ? formatPercentRaw(shownPercent(row.return1Y)) : "—",
           color: row.return1Y !== null ? priceColor(shownPercent(row.return1Y)) : colors.textDim,
         };
-      case "bar":
+      case "bar": {
+        const signed = row.changePercent !== null ? formatPercentRaw(shownPercent(row.changePercent)) : "—";
         return {
-          text: "",
-          content: <SectorMoveBar changePercent={row.changePercent} width={column.width} />,
+          text: signed,
+          content: <Box flexDirection="row" width={column.width} overflow="hidden" aria-label={signed}>
+            <SectorMoveBar changePercent={row.changePercent} width={column.width} />
+          </Box>,
         };
+      }
     }
   }, []);
 

package/src/plugins/builtin/shared/report-freshness.ts

@@ -1,7 +1,7 @@
 import type { HeadlessPaneFreshness } from "../../../types/headless";
-import type { Quote } from "../../../types/financials";
+import type { Quote, QuoteIndexSession } from "../../../types/financials";
 import { isQuoteStaleForCurrentSession } from "../../../market-data/quotes/freshness";
-import { delayedFeedLagMs } from "../../../market-data/market/freshness";
+import { delayedFeedLagMs, readIndexSession } from "../../../market-data/market/freshness";
 import { apiClient } from "../../../api-client";
 import { isPerpetualExchange } from "../../../tickers/perpetual-listing";
 import { CLOUD_NEWS_DELAY_HOURS, hasProAccess } from "../../../api-client/plan-rules";
@@ -56,6 +56,8 @@ interface QuoteFreshnessFields {
   /** The venue whose sessions the quote follows, so the report can say whether its market is open. */
   sessionExchange?: string;
   marketState?: Quote["marketState"];
+  /** An index's own regular sessions, for the open and the close its publisher's name does not place. */
+  sessionCalendar?: QuoteIndexSession;
 }
 
 /**
@@ -71,12 +73,14 @@ export function quoteFreshnessFields(
   const exchange = quote.listingExchangeName || quote.exchangeName;
   // A perpetual's venue is read about once a minute, not held back by a feed lag.
   const delayed = quote.dataSource === "delayed" && quote.providerId === CLOUD_QUOTE_PROVIDER_ID && !isPerpetualExchange(exchange);
+  const sessionCalendar = readIndexSession(quote.indexSession);
   return {
     ...(quote.dataSource === "live" || quote.dataSource === "delayed" ? { dataSource: quote.dataSource } : {}),
     stale: isQuoteStaleForCurrentSession(quote, now),
     ...(delayed ? { delayMinutes: delayedFeedLagMs(exchange) / 60_000 } : {}),
     ...(exchange ? { sessionExchange: exchange } : {}),
     ...(quote.marketState ? { marketState: quote.marketState } : {}),
+    ...(sessionCalendar ? { sessionCalendar } : {}),
   };
 }
 

package/src/plugins/builtin/short-interest/headless.ts

@@ -5,13 +5,15 @@ import type {
   HeadlessPaneLoadArgs,
 } from "../../../types/plugin";
 import { formatCompact, formatNumber } from "../../../utils/format";
-import { loadShortInterest, type ShortInterestResult } from "./client";
+import type { ShortInterestResult } from "./client";
 import {
   buildRows,
   sortRows,
   type SortPreference,
 } from "./model";
+import { shortInterestFreshness } from "./schedule";
 import type { ShortInterestRecord } from "./types";
+import { loadShortInterestWithFloat } from "./watch-client";
 
 const SHORT_INTEREST_COLUMNS: HeadlessPaneColumn[] = [
   { key: "settlementDate", header: "Date" },
@@ -23,7 +25,7 @@ const SHORT_INTEREST_COLUMNS: HeadlessPaneColumn[] = [
   },
   {
     key: "daysToCover",
-    header: "Days to Cover",
+    header: "Days to cover",
     align: "right",
     format: (value) => value == null ? "-" : formatNumber(Number(value), 2),
   },
@@ -50,7 +52,7 @@ export interface ShortInterestHeadlessDependencies {
 }
 
 const defaultDependencies: ShortInterestHeadlessDependencies = {
-  loadRecords: (symbol, _args, ctx) => loadShortInterest(symbol, ctx.apiClient),
+  loadRecords: (symbol, _args, ctx) => loadShortInterestWithFloat(symbol, { marketData: ctx.marketData, client: ctx.apiClient }),
 };
 
 export function createShortInterestHeadless(
@@ -65,6 +67,12 @@ export function createShortInterestHeadless(
       placeholder: "ticker",
       description: "US equity ticker.",
     },
+    discovery: {
+      limitations: [
+        "Borrow fee, utilization and locate availability are not available: FINRA short interest counts shares short, not what they cost to borrow.",
+        "Percent of float is the latest settlement's shares short over the current float; earlier settlements stay blank.",
+      ],
+    },
     usListingsOnly: "FINRA short interest",
     options: [
       {
@@ -107,8 +115,10 @@ export function createShortInterestHeadless(
           averageDailyVolume: row.record.averageDailyVolume,
           shortPercentFloat: row.record.shortPercentFloat,
         }));
+      const freshness = shortInterestFreshness(rows.map((row) => row.settlementDate).sort().at(-1));
       return {
         rows,
+        ...(freshness ? { freshness } : {}),
         ...(latestSettlements ? {
           complete: false,
           errors: [cloudSessionRequired

package/src/plugins/builtin/short-interest/index.tsx

@@ -85,7 +85,7 @@ export const shortInterestModule: PluginModule = {
         label: "Short Interest",
         // The current snapshot only carries the current and prior settlement dates.
         description: "Bi-monthly short interest settlements from FINRA with days to cover and average daily volume. Daily volume is the other tab.",
-        keywords: ["short", "interest", "si", "shorts", "borrow", "days", "cover"],
+        keywords: ["short", "interest", "si", "shorts", "days", "cover"],
         shortcut: "SI",
       }), "interest"),
       headless: shortInterestHeadless,