@gloom-sh/terminal 0.19.2 → 0.19.3

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

@@ -7,7 +7,6 @@ import {
   RESEARCH_SEARCH_PANE_ID,
   RESEARCH_SEARCH_TEMPLATE_ID,
 } from "./model";
-import { ResearchSearchPane } from "./pane";
 
 const description =
   "Full-text search across earnings call transcripts, news wires, and SEC filings, with saved searches and keyword alerts.";
@@ -40,7 +39,7 @@ export const researchSearchPlugin: GloomPlugin = {
       reportFreshness: { status: "not-a-feed", basis: "search results" },
       name: "Research Search",
       icon: "RS",
-      component: ResearchSearchPane,
+      get component(): typeof import("./pane").ResearchSearchPane { const { ResearchSearchPane } = require("./pane"); return ResearchSearchPane; },
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 118, height: 32 },

package/src/plugins/builtin/revenue-breakdown/headless.ts

@@ -1,13 +1,25 @@
 import type { RevenueBreakdownView } from "../../../api-client/revenue-breakdown";
 import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchRevenueBreakdown } from "./client";
-import { growthPercent, quarterLabel, reportedSpan, revenueAmount, sharePercent } from "./model";
+import { growthPercent, quarterLabel, reportedSpan, revenueScale, sharePercent } from "./model";
 import { SEC_FILINGS } from "../shared/report-freshness";
 import { resolveHeadlessIssuerListing } from "../shared/headless-market-data";
 
-/** Amounts compact and shares and growth in percent, as the pane prints them (15.97B, 83.7%, +10.8%); exports keep the whole number. */
+/** Shares and growth in percent, as the pane prints them (83.7%, +10.8%), amounts on the table's scale; exports keep the whole number. */
 const number = (format: (value: number | null) => string) => (value: unknown) => format(typeof value === "number" ? value : null);
-const amountColumn = (key: string, header: string): HeadlessPaneColumn => ({ key, header, align: "right", textFormat: number(revenueAmount) });
+
+/**
+ * A table's amounts on its one scale (`revenueScale`), named once in the text
+ * report's heading ("Total revenue, USD millions"). Exports keep the section
+ * name and the whole number.
+ */
+function amountScale(values: ReadonlyArray<number | null>, currency: string | null) {
+  const scale = revenueScale(values, currency);
+  return {
+    section: (title: string) => ({ title, ...scale.unit ? { textTitle: `${title}, ${scale.unit}` } : {} }),
+    column: (key: string, header: string): HeadlessPaneColumn => ({ key, header, align: "right", textFormat: number(scale.format) }),
+  };
+}
 
 export const revenueBreakdownHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
@@ -46,16 +58,18 @@ export const revenueBreakdownHeadless: HeadlessPaneDefinition<"bundle"> = {
       ctx.apiClient,
       await resolveHeadlessIssuerListing(ctx, symbol),
     ));
+    const rowScale = amountScale(data.rows.flatMap((row) => [...row.values, row.ttm]), data.currency);
+    const totalScale = amountScale(data.total, data.currency);
     return {
       complete: data.access === "full",
       errors: data.lockedRows > 0 ? [`${data.lockedRows} more rows need Gloom Pro`] : [],
       sections: [
         {
-          title: `Quarterly revenue by ${data.view}`,
+          ...rowScale.section(`Quarterly revenue by ${data.view}`),
           columns: [
             { key: data.view, header: data.view[0]!.toUpperCase() + data.view.slice(1) },
-            ...data.periods.map((period) => amountColumn(quarterLabel(period), quarterLabel(period))),
-            amountColumn("ttm", "TTM"),
+            ...data.periods.map((period) => rowScale.column(quarterLabel(period), quarterLabel(period))),
+            rowScale.column("ttm", "TTM"),
             { key: "share", header: "Share", align: "right", textFormat: number(sharePercent) },
             { key: "yoy", header: "YoY", align: "right", textFormat: number(growthPercent) },
           ],
@@ -68,8 +82,8 @@ export const revenueBreakdownHeadless: HeadlessPaneDefinition<"bundle"> = {
           })),
         },
         {
-          title: "Total revenue",
-          columns: [{ key: "quarter", header: "Quarter" }, { key: "end", header: "End" }, amountColumn("revenue", "Revenue")],
+          ...totalScale.section("Total revenue"),
+          columns: [{ key: "quarter", header: "Quarter" }, { key: "end", header: "End" }, totalScale.column("revenue", "Revenue")],
           rows: data.periods.map((period, index) => ({
             quarter: quarterLabel(period),
             end: period.end,

package/src/plugins/builtin/revenue-breakdown/model.ts

@@ -1,4 +1,5 @@
 import type { DataTableColumn } from "../../../components";
+import { pickUnit } from "../../../utils/format";
 import type {
   RevenueBreakdownPayload,
   RevenueBreakdownPeriod,
@@ -83,6 +84,28 @@ export function revenueAmount(value: number | null): string {
   return `${value < 0 ? "-" : ""}${scaled.toFixed(digits)}${suffix}`;
 }
 
+const SCALE_WORDS: Record<string, string> = { K: "thousands", M: "millions", B: "billions", T: "trillions" };
+
+/**
+ * One scale for a report table's amounts, its largest one's, so a 0.0 never sits beside a 5.52M: `unit`
+ * names it once ("USD millions") and `format` prints each amount in it, with one count of decimals down the
+ * table (179.3 and 0.0, or 54.32 and 7.88). An amount too small for that many decimals keeps two significant
+ * digits (0.030), so only a true zero reads 0.0. The pane keeps each amount's own suffix (`revenueAmount`).
+ */
+export function revenueScale(values: ReadonlyArray<number | null>, currency: string | null): { unit: string; format: (value: number | null) => string } {
+  const amounts = values.filter((value): value is number => value !== null && Number.isFinite(value));
+  const { suffix, divisor } = pickUnit(amounts);
+  const digits = Math.max(0, ...amounts.map((value) => Math.abs(value) / divisor)) >= 100 ? 1 : 2;
+  const format = (value: number | null) => {
+    if (value === null || !Number.isFinite(value)) return revenueAmount(null);
+    const scaled = value / divisor;
+    if (scaled === 0 || Number(scaled.toFixed(digits)) !== 0) return scaled.toFixed(digits);
+    // Two significant digits: as many decimals as the first one's place, and one more.
+    return scaled.toFixed(Math.min(20, 1 - Math.floor(Math.log10(Math.abs(scaled)))));
+  };
+  return { unit: [currency?.trim(), SCALE_WORDS[suffix]].filter(Boolean).join(" "), format };
+}
+
 export const sharePercent = (value: number | null) =>
   value === null ? "--" : `${(value * 100).toFixed(1)}%`;
 

package/src/plugins/builtin/reverse-dcf/pane.tsx

@@ -110,7 +110,9 @@ export function ReverseDcfPane({ width, height, focused }: PaneProps) {
   }, [model]);
 
   const selectedId = String(discountRate);
-  const contentHeight = Math.max(4, height - 1 - statGridRows(stats, width));
+  // A figure wraps only into rows the table's least leaves, so the pane never spills.
+  const statMaxLines = height - 1 - 4;
+  const contentHeight = Math.max(4, height - 1 - statGridRows(stats, width, undefined, { maxLines: statMaxLines }));
 
   return <Box width={width} height={height} flexDirection="column" overflow="hidden">
     <QueryBar width={width} filters={[
@@ -120,7 +122,7 @@ export function ReverseDcfPane({ width, height, focused }: PaneProps) {
     {!symbol ? <EmptyState title="Select a ticker." /> : <PaneStatusBody subject="reverse DCF" loading={inputs.loading && !model}
       error={!model ? inputs.error ?? identityError ?? null : model.error} empty={false}>
       {model && !model.error ? <>
-        <StatGrid items={stats} width={width} />
+        <StatGrid items={stats} width={width} maxLines={statMaxLines} />
         <DataTableView<Row> focused={focused} columns={COLUMNS} items={model.sensitivity} rootWidth={width} rootHeight={contentHeight}
           getItemKey={(row) => String(row.discountRate)} emptyStateTitle="No implied growth." sortColumnId={null} sortDirection="desc"
           selection={{ kind: "id", selectedId, getId: (row) => String(row.discountRate),

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

@@ -1,5 +1,4 @@
 import type { PluginModule } from "../plugin-module";
-import { RoadmapPane } from "./pane";
 
 export const roadmapModule: PluginModule = {
   panes: [
@@ -7,8 +6,8 @@ export const roadmapModule: PluginModule = {
       id: "roadmap",
       name: "Roadmap",
       icon: "R",
-      component: RoadmapPane,
-      reportFreshness: { status: "not-a-feed", basis: "curated list" },
+      get component(): typeof import("./pane").RoadmapPane { const { RoadmapPane } = require("./pane"); return RoadmapPane; },
+      reportFreshness: { status: "not-a-feed", basis: "curated list", local: true },
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 100, height: 30 },

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

@@ -1,4 +1,4 @@
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type RefObject } from "react";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type ReactNode, type RefObject } from "react";
 import { apiClient } from "../../../api-client";
 import { usePlanAccess } from "../../../api-client/plan-access";
 import type { RoadmapItem, RoadmapVote } from "../../../api-client/roadmap";
@@ -7,7 +7,9 @@ import {
   DataTableStackView,
   EMPTY_TABLE_CELL,
   isSectionedItemRow,
+  PaneFooterScope,
   renderSectionedRowHeader,
+  usePaneTabs,
   usePaneStatusFooter,
   useRowNotes,
   type DataTableCell,
@@ -23,6 +25,7 @@ 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 { ChangelogPane } from "../changelog";
 import {
   isVotable,
   optimisticVote,
@@ -97,7 +100,7 @@ function RoadmapDetail({ item, failure, width, scrollRef }: {
   );
 }
 
-export function RoadmapPane({ focused, width, height }: PaneProps) {
+function RoadmapView({ focused, width, height }: PaneProps) {
   const colors = useThemeColors();
   const client = useContext(RoadmapClientContext) ?? apiClient;
   const access = usePlanAccess();
@@ -242,3 +245,47 @@ export function RoadmapPane({ focused, width, height }: PaneProps) {
     />
   );
 }
+
+/**
+ * What is coming and what came: the roadmap's features, and the Changelog as
+ * CHG shows it. The first tab is not "Roadmap", which the title already says.
+ */
+const VIEWS = [
+  { value: "roadmap", label: "Features" },
+  { value: "changelog", label: "Changelog" },
+] as const;
+type ViewId = (typeof VIEWS)[number]["value"];
+const VIEW_PANES: Record<ViewId, (props: PaneProps) => ReactNode> = {
+  roadmap: RoadmapView,
+  changelog: ChangelogPane,
+};
+
+export function RoadmapPane(props: PaneProps) {
+  const [storedView, setView] = usePluginPaneState<string>("view", "roadmap");
+  const view: ViewId = storedView === "changelog" ? "changelog" : "roadmap";
+  // A view stays mounted once shown, so coming back to it keeps its place.
+  const [mounted, setMounted] = useState<ReadonlySet<ViewId>>(() => new Set([view]));
+  useEffect(() => {
+    setMounted((current) => (current.has(view) ? current : new Set([...current, view])));
+  }, [view]);
+  const { strip, rows } = usePaneTabs({ tabs: [...VIEWS], activeValue: view, onSelect: setView, focused: props.focused, dense: true });
+  const bodyHeight = Math.max(1, props.height - rows);
+
+  return (
+    <Box width={props.width} height={props.height} flexDirection="column" overflow="hidden">
+      {strip}
+      {VIEWS.map(({ value }) => {
+        if (!mounted.has(value) && value !== view) return null;
+        const View = VIEW_PANES[value];
+        const active = value === view;
+        return (
+          <Box key={value} visible={active} height={bodyHeight} flexGrow={1} flexBasis={0} overflow="hidden" data-gloom-role="nested-pane-content">
+            <PaneFooterScope active={active}>
+              <View {...props} height={bodyHeight} focused={props.focused && active} />
+            </PaneFooterScope>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}

package/src/plugins/builtin/scanner/hilo-model.ts

@@ -1,4 +1,5 @@
-import type { ScannerHiloExtreme, ScannerHiloPayload } from "../../../api-client";
+import type { ScannerHiloExtreme, ScannerHiloPayload, ScannerStatus } from "../../../api-client";
+import { venueMarketLine } from "../../../cli/pane-functions/freshness";
 
 type HiloWindowKey = keyof ScannerHiloPayload["windows"];
 export type HiloMinPrice = "off" | "1" | "5";
@@ -94,3 +95,19 @@ export function filterHiloRows(
     ? [...filtered].sort((left, right) => right.count - left.count || right.at - left.at)
     : [...filtered].sort((left, right) => right.at - left.at);
 }
+
+/**
+ * What an empty table says. The price filter when rows came in and it hid them all, or when the market is open and
+ * nothing has printed a new extreme yet. A closed market says so and when it reopens, in the status line's words
+ * (`Markets closed until Mon.`), as SCAN says its own close: its session has no new highs or lows to count.
+ */
+export function hiloEmptyState(
+  { filtered, status, now }: { filtered: boolean; status: ScannerStatus | undefined; now: number },
+): { title: string; hint?: string } {
+  if (filtered || status !== "closed") return { title: "Nothing above the price filter yet." };
+  const line = venueMarketLine("NYSE", now);
+  return {
+    title: line?.state === "closed" ? `${line.text[0]!.toUpperCase()}${line.text.slice(1)}.` : "Market closed.",
+    hint: "New highs and lows resume at the open.",
+  };
+}

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

@@ -18,7 +18,7 @@ import { usePluginTickerActions } from "../../runtime";
 import { ScannerDeniedState } from "./denied";
 import { useHiloFeed, useScannerStatusFooter } from "./feed";
 import { HiloBars } from "./hilo-bars";
-import { filterHiloRows, formatHiloPrice, type HiloMinPrice, type HiloSort } from "./hilo-model";
+import { filterHiloRows, formatHiloPrice, hiloEmptyState, type HiloMinPrice, type HiloSort } from "./hilo-model";
 
 type Side = "lows" | "highs";
 
@@ -118,6 +118,15 @@ function HiloPane({ focused, width, height }: PaneProps) {
   );
 
   useScannerStatusFooter("hilo", feed, focused);
+  // Read when the feed moves, not each render: the clock only matters once a closed session's text is shown.
+  const status = feed.payload?.status;
+  const emptyStates = useMemo<Record<Side, { title: string; hint?: string }>>(() => {
+    const now = Date.now();
+    return {
+      lows: hiloEmptyState({ filtered: !!feed.payload?.lows.length, status, now }),
+      highs: hiloEmptyState({ filtered: !!feed.payload?.highs.length, status, now }),
+    };
+  }, [feed.payload?.lows.length, feed.payload?.highs.length, status]);
 
   const split = width >= SPLIT_MIN_WIDTH;
   // Zero counts before the first payload would read as a dead market, not a loading one.
@@ -168,7 +177,8 @@ function HiloPane({ focused, width, height }: PaneProps) {
       renderCell={RENDER_ROW[side]}
       selectedTextOverridesCellColor
       emptyContent={feed.payload ? undefined : <PaneStatusBody loading loadingLabel="Waiting for the scanner..." />}
-      emptyStateTitle="Nothing above the price filter yet."
+      emptyStateTitle={emptyStates[side].title}
+      emptyStateHint={emptyStates[side].hint}
     />
   );
 

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

@@ -100,9 +100,11 @@ const DISPLAY_ORDER = ["symbol", "name", "price", "change", "conditions", "rvol"
 /**
  * Symbol, name, price and change, then one column per condition with the
  * figure it matched on, then context as the width allows: a column is added
- * only when it fits whole, the row's status first.
+ * only when it fits whole, the row's status first, and only when a row has
+ * one (after the close none does, and an empty column would take the room of
+ * the figures).
  */
-function liveScanColumns(width: number, conditions: readonly LiveScanCondition[]): DataTableColumn[] {
+export function liveScanColumns(width: number, conditions: readonly LiveScanCondition[], withStatus: boolean): DataTableColumn[] {
   const own = conditions.map((condition, index): DataTableColumn => {
     const label = conditionColumnLabel(condition);
     return { id: `c:${index}`, label, width: Math.max(8, label.length), align: "right" };
@@ -121,7 +123,7 @@ function liveScanColumns(width: number, conditions: readonly LiveScanCondition[]
   ));
   let columns = order([...base, ...own]);
   for (const column of OPTIONAL_COLUMNS) {
-    if (repeats.has(column.id)) continue;
+    if (repeats.has(column.id) || (column.id === "status" && !withStatus)) continue;
     const next = order([...columns, column]);
     if (getTableWidth(next) > width) break;
     columns = next;
@@ -349,7 +351,8 @@ export default function LiveScanPane({ focused, width, height }: PaneProps) {
     [payload, track],
   );
   const matches = useMemo(() => sortMatches(payload?.matches ?? [], sort, noteOf), [noteOf, payload?.matches, sort]);
-  const columns = useMemo(() => liveScanColumns(width, scan.conditions), [scan.conditions, width]);
+  const withStatus = useMemo(() => matches.some((match) => noteOf(match) != null), [matches, noteOf]);
+  const columns = useMemo(() => liveScanColumns(width, scan.conditions, withStatus), [scan.conditions, width, withStatus]);
 
   const apply = (next: LiveScan) => {
     setStoredScan(next);

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,5 +1,6 @@
 import { logFailure } from "../../../utils/log-failure";
 import { ApiRequestError } from "../../../api-client/errors";
+import { createMissingRouteLatch } from "../../../api-client/coalesce";
 import { savedCopyForTransientFailure, type PluginCacheResult } from "../../../data/plugin-cache";
 
 interface CloudCache<T> {
@@ -81,3 +82,62 @@ export function unavailableOnServer(error: unknown, message: string, statuses: r
     ? 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]);
+}