@gloom-sh/terminal 0.19.2 → 0.19.3

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

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

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

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

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

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

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

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

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

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

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

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

package/src/plugins/builtin/social-mentions/index.tsx

@@ -4,7 +4,6 @@ import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import { socialMentionPostsCache, socialMentionsCache } from "./client";
 import { socialMentionsHeadless } from "./headless";
 import { socialMentionsLockNote } from "./lock-note";
-import { SocialMentionsPane } from "./pane";
 
 const socialMentionsSettings = [
   { key: "socialRange", label: "History", type: "select" as const,
@@ -12,7 +11,7 @@ const socialMentionsSettings = [
 ];
 export const socialMentionsModule: PluginModule = {
   series: SOCIAL_MENTION_SERIES,
-  panes: [{ id: "social-mentions", reportLockNote: socialMentionsLockNote, name: "Social Mentions", icon: "B", component: SocialMentionsPane,
+  panes: [{ id: "social-mentions", reportLockNote: socialMentionsLockNote, name: "Social Mentions", icon: "B", get component(): typeof import("./pane").SocialMentionsPane { const { SocialMentionsPane } = require("./pane"); return SocialMentionsPane; },
     defaultPosition: "right", tickerFollower: true, defaultMode: "floating", defaultFloatingSize: { width: 96, height: 30 },
     tableExport: true, headless: socialMentionsHeadless, settings: { title: "Social Mentions", fields: socialMentionsSettings } }],
   paneTemplates: [{ ...createTickerSurfacePaneTemplate({ id: "social-mentions-pane", paneId: "social-mentions", label: "Social Mentions",

package/src/plugins/builtin/social-mentions/pane.tsx

@@ -3,6 +3,7 @@ import { listingIdentity } from "../shared/ticker-request";
 import { Box, ScrollBox, Text, useUiCapabilities } from "../../../ui";
 import { useAsyncResource, useAutoRefresh, usePaneSettingValue, usePluginPaneState, useShortcut, useUpdatedAgo } from "../../../public/react";
 import { CompositeChart, DataTableStackView, EmptyState, PaneStatusBody, usePaneNoticeFooter, usePaneStatusLinkFooter, type DataTableCell, StatGrid } from "../../../components";
+import { ageFooterSegment } from "../../../components/layout/pane/footer";
 import { colors } from "../../../theme/colors";
 import type { SocialMentionPost, SocialMentionsRange } from "../../../api-client/social-mentions";
 import { staticSeries } from "../../../components/chart/static/series";
@@ -117,7 +118,7 @@ export function SocialMentionsPane({ width, height, focused }: Pick<PaneProps, "
   usePaneStatusLinkFooter({ registrationId: "social-mentions", focused, loading: resource.loading || pending, error: signInWall ? null : resource.error,
     url: selected?.topPost?.url ?? (symbol ? `https://x.com/search?q=%24${symbol}` : null), showOpenHint: true,
     info: data ? [
-      ...(updatedAgo ? [{ id: "updated", parts: [{ text: updatedAgo, tone: "muted" as const }] }] : []),
+      ...(updatedAgo ? [ageFooterSegment(updatedAgo)] : []),
       ...(resource.data?.stale ? [{ id: "stale", parts: [{ text: "stale", tone: "warning" as const }] }] : []),
     ] : [],
   });

package/src/plugins/builtin/supply-chain/client.ts

@@ -1,7 +1,7 @@
 import { apiClient } from "../../../api-client";
 import type { SupplyChainPayload, SupplyEntity, SupplyEvidenceItem, SupplyOptions, SupplyRow } from "../../../api-client/supply-chain";
 import { createPluginCache } from "../../../data/plugin-cache";
-import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
+import { batchReplyItems, cachedCloudResource, createCloudBatchAhead, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import { activeRelationship, canShowQuote, isUnconfirmed, publicEvidence, supplyOptions, TIER_OPTIONS, trustTier } from "./trust";
 
 export const SUPPLY_UNAVAILABLE = "Supply chain disclosures are not available yet.";
@@ -111,3 +111,24 @@ export async function fetchSupplyChain(symbol: string, client: Pick<typeof apiCl
 const cacheKey = (symbol: string, access: string, options: SupplyOptions) => `${symbol.toUpperCase()}:${access}:${JSON.stringify(supplyOptions(options.tiers))}:${!!options.includeLeads}`;
 export const cachedSupplyChain = (symbol: string, access: string, options: SupplyOptions = {}) => cachedCloudResource(supplyChainCache, cacheKey(symbol, access, options), validateSupplyChain);
 export const loadSupplyChain = (symbol: string, access: string, force = false, options: SupplyOptions = {}) => loadCloudResource(supplyChainCache, cacheKey(symbol, access, options), () => fetchSupplyChain(symbol, apiClient, options), { force, validate: validateSupplyChain });
+/** Symbols per disclosures batch request: a ripple's sixty holdings are two, read sixteen at a time on the server. */
+const SUPPLY_BATCH_MAX = 30;
+const supplyChainsAheadByOptions = new Map<string, ReturnType<typeof createCloudBatchAhead<SupplyChainPayload>>>();
+/**
+ * Reads many symbols' disclosures ahead in a request per 30 (EARN ripple's
+ * holdings), into the cache loadSupplyChain reads. Answers the symbols stored.
+ */
+export function loadSupplyChainsAhead(symbols: readonly string[], access: string, force = false, options: SupplyOptions = {}): Promise<Set<string>> {
+  const optionsKey = JSON.stringify([supplyOptions(options.tiers), !!options.includeLeads]);
+  let ahead = supplyChainsAheadByOptions.get(optionsKey);
+  if (!ahead) {
+    ahead = createCloudBatchAhead(supplyChainCache, {
+      max: SUPPLY_BATCH_MAX,
+      validate: validateSupplyChain,
+      read: async (ids) => batchReplyItems(await apiClient.getCloudSupplyChains(ids, options))
+        .flatMap((item) => item.chain ? [{ id: item.symbol.toUpperCase(), payload: item.chain }] : []),
+    });
+    supplyChainsAheadByOptions.set(optionsKey, ahead);
+  }
+  return ahead(symbols.map((symbol) => ({ id: symbol.toUpperCase(), key: cacheKey(symbol, access, options) })), force);
+}

package/src/plugins/builtin/supply-chain/graph-client.ts

@@ -2,7 +2,7 @@ import { apiClient } from "../../../api-client";
 import { DEFAULT_GRAPH_OPTIONS, supplyGraphQuery, type GraphOptions, type GraphPayload, type GraphPath } from "../../../api-client/supply-chain-graph";
 import { createPluginCache } from "../../../data/plugin-cache";
 import { dateOptionError, readCalendarDate } from "../../../utils/calendar-date";
-import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
+import { batchReplyItems, cachedCloudResource, createCloudBatchAhead, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import { normalizeSupplyRow, validPeriodMonths, validSupplyEntity, validSupplyRow } from "./client";
 import { graphEvidenceRow } from "./graph-evidence";
 import { activeRelationship, isUnconfirmed } from "./trust";
@@ -84,3 +84,24 @@ export function graphOptions(input: Record<string, unknown>): GraphOptions {
     || options.tiers.some(value => !["structured", "primary", "secondary", "imported"].includes(value))) throw new Error("Invalid supply chain graph filters");
   return options;
 }
+/** Symbols per graphs batch request: a ripple's sixty holdings are two, read sixteen at a time on the server. */
+const GRAPH_BATCH_MAX = 30;
+const graphsAheadByOptions = new Map<string, ReturnType<typeof createCloudBatchAhead<GraphPayload>>>();
+/**
+ * Reads many symbols' graphs on one query ahead in a request per 30 (EARN
+ * ripple's two hops), into the cache loadGraph reads. Answers the symbols stored.
+ */
+export function loadGraphsAhead(symbols: readonly string[], options: GraphOptions, access: string, force = false): Promise<Set<string>> {
+  const query = supplyGraphQuery(options);
+  let ahead = graphsAheadByOptions.get(query);
+  if (!ahead) {
+    ahead = createCloudBatchAhead(graphCache, {
+      max: GRAPH_BATCH_MAX,
+      validate: validateGraph,
+      read: async (ids) => batchReplyItems(await apiClient.getCloudSupplyGraphs(ids, options))
+        .flatMap((item) => item.graph ? [{ id: item.symbol.toUpperCase(), payload: item.graph }] : []),
+    });
+    graphsAheadByOptions.set(query, ahead);
+  }
+  return ahead(symbols.map((symbol) => ({ id: symbol.toUpperCase(), key: key(symbol, "", options, access) })), force);
+}

package/src/plugins/builtin/supply-chain/index.tsx

@@ -3,7 +3,6 @@ import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import { graphCache } from "./graph-client";
 import { supplyChainCache } from "./client";
 import { supplyChainHeadless } from "./headless";
-import { SupplyChainPane } from "./pane";
 
 /** What another pane can open SPLC on: a Graph or Path view, its target and its query, as `graphOptions` reads them. */
 const OPENING_SETTINGS = ["tab", "to", "depth", "direction", "roles", "tiers"];
@@ -13,7 +12,7 @@ const openingSettings = (values: Record<string, string> = {}) =>
 export const supplyChainModule: PluginModule = {
   setup(ctx) { supplyChainCache.attach(ctx.persistence); graphCache.attach(ctx.persistence); },
   dispose() { supplyChainCache.reset(); graphCache.reset(); },
-  panes: [{ id: "supply-chain", name: "Supply Chain", icon: "S", component: SupplyChainPane,
+  panes: [{ id: "supply-chain", name: "Supply Chain", icon: "S", get component(): typeof import("./pane").SupplyChainPane { const { SupplyChainPane } = require("./pane"); return SupplyChainPane; },
     defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 130, height: 30 },
     tickerFollower: true, instruments: ["equity"], tableExport: true, headless: supplyChainHeadless }],
   paneTemplates: [{ ...createTickerSurfacePaneTemplate({ id: "supply-chain-pane", paneId: "supply-chain", label: "Supply Chain",

package/src/plugins/builtin/thirteenf/api.ts

@@ -12,15 +12,23 @@ import type { PluginPersistence } from "../../../types/plugin";
 import { apiClient } from "../../../api-client";
 import { ApiRequestError, isPermanentClientError, isTransientFailure } from "../../../api-client/errors";
 import { httpFetch } from "../../../utils/http-transport";
+import { isNetworkFailure } from "../../../utils/network-failure";
 import { asRecord, finiteOrNull } from "../../../utils/guards";
 import { logFailure } from "../../../utils/log-failure";
 
 const FORMS_13F_BASE_URL = "https://forms13f.com/api/v1";
 const FORM_PAGE_LIMIT = 100;
-// Large funds file well past 2,000 positions, and a silently clipped
-// list makes every weight, total, and buy/sell action wrong. Paging further is
-// slower but truthful; page in parallel if the wait becomes the problem.
-const MAX_FORM_ROWS = 20_000;
+/** The most rows the 13F source gives in one page. */
+const FILING_PAGE_ROWS = 250;
+/** Pages of one filing read at once where the service cannot send it whole. */
+const FILING_PAGE_CONCURRENCY = 4;
+// Large funds file tens of thousands of positions (BlackRock about 50,000), and
+// a silently clipped list makes every weight, total, and buy/sell action wrong.
+const MAX_FORM_ROWS = 100_000;
+/** Rows asked first of a large filing the service is still reading. */
+const FIRST_ROWS = 2_000;
+/** How long a large filing is waited for whole before its first rows are asked. */
+const FIRST_ROWS_AFTER_MS = 300;
 const CACHE_KIND = "forms13f-api";
 const CACHE_SOURCE = "forms13f";
 const CACHE_SCHEMA_VERSION = 1;
@@ -52,6 +60,8 @@ let forms13FPersistence: PluginPersistence | null = null;
 const failedRefreshes = new Set<string>();
 // The promise is the generation. A newer download replaces it, and the replaced one must not write.
 const activeRequests = new Map<string, Promise<unknown>>();
+/** The service answered a whole filing with 404: it is an older one, so filings are read a page at a time. */
+let wholeFilingsMissing = false;
 
 export function attachThirteenFApiPersistence(persistence: PluginPersistence) {
   if (forms13FPersistence !== persistence) resetThirteenFApiPersistence();
@@ -62,6 +72,7 @@ export function resetThirteenFApiPersistence() {
   forms13FPersistence = null;
   failedRefreshes.clear();
   activeRequests.clear();
+  wholeFilingsMissing = false;
 }
 
 function padCik(value: string): string {
@@ -122,7 +133,15 @@ async function fetchForms13F<T>(
 
   if (!options.forceRefresh) {
     const pending = activeRequests.get(key) as Promise<T> | undefined;
-    if (pending) return cached != null ? cached.value : pending;
+    if (pending) {
+      if (cached != null) return cached.value;
+      // Another reader's request, which that reader may stop (a fund read ahead
+      // while the cursor rested on it): this reader then asks again on its own.
+      return pending.catch((error: unknown) => {
+        if (options.signal?.aborted || !(error instanceof Error && error.name === "AbortError")) throw error;
+        return fetchForms13F<T>(path, params, options);
+      });
+    }
   }
 
   const slot: { promise?: Promise<T> } = {};
@@ -343,24 +362,108 @@ export async function listThirteenFFormHoldingsPage(
   return { rows, hasMore: rows.length >= limit && offset + rows.length < MAX_FORM_ROWS };
 }
 
+function mapHoldings(raw: unknown): ThirteenFHoldingRecord[] {
+  return arrayResponse(raw).map(mapHolding).filter((holding): holding is ThirteenFHoldingRecord => !!holding);
+}
+
+/** A filing's whole information table as Gloom Cloud sends it in one answer. */
+function filingRows(raw: unknown): ThirteenFHoldingRecord[] {
+  const rows = asRecord(raw).rows;
+  if (!Array.isArray(rows)) throw new Error("13F filing answer has no rows");
+  return mapHoldings(rows);
+}
+
+export interface FilingHoldingsOptions extends Forms13FReadOptions {
+  /** The rows the filing's summary counts, when known: a large filing's first rows come first. */
+  entries?: number | null;
+  /** The filing's first rows, while a large filing the service has not read yet is still loading. */
+  onFirstRows?: (rows: ThirteenFHoldingRecord[]) => void;
+}
+
+/**
+ * A filing's whole information table: one request to Gloom Cloud, which
+ * reads the source's pages itself and keeps the filing. An older service
+ * without that answer (a 404, remembered for the session) or one that cannot
+ * be reached is read a page at a time, a few pages at once, as before; a page
+ * Gloom Cloud cannot send comes from the public source. A busy or failing
+ * service (429, 5xx) is the error: paging it would only ask it more.
+ */
 export async function listThirteenFFormHoldings(
   cik: string,
   accessionNumber: string,
   signal?: AbortSignal,
-  options: Forms13FReadOptions = {},
+  options: FilingHoldingsOptions = {},
+): Promise<ThirteenFHoldingRecord[]> {
+  const { entries, onFirstRows, ...readOptions } = options;
+  if (wholeFilingsMissing) return listPagedHoldings(cik, accessionNumber, signal, readOptions);
+  // The count lets a filing the service has not stored yet be read in fewer requests.
+  const params = {
+    cik: normalizeCik(cik),
+    accession_number: accessionNumber,
+    ...(entries != null && entries > 0 ? { entries } : {}),
+  };
+  const whole = fetchForms13F<unknown>("/holdings", params, { ...readOptions, signal, cloudOnly: true });
+  let answered = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  if (onFirstRows && entries != null && entries > FIRST_ROWS) {
+    timer = setTimeout(() => {
+      if (answered) return;
+      void fetchForms13F<unknown>("/holdings", { ...params, limit: FIRST_ROWS }, { signal, cloudOnly: true, cache: false })
+        .then((raw) => { if (!answered) onFirstRows(filingRows(raw)); })
+        .catch(() => {
+          // Intentional ignore: the first rows only come ahead of the whole filing, which reports its own failure.
+        });
+    }, FIRST_ROWS_AFTER_MS);
+  }
+  try {
+    return filingRows(await whole);
+  } catch (error) {
+    signal?.throwIfAborted();
+    const missing = error instanceof ApiRequestError && error.status === 404;
+    if (!missing && !isNetworkFailure(error)) throw error;
+    if (missing) wholeFilingsMissing = true;
+    return listPagedHoldings(cik, accessionNumber, signal, readOptions);
+  } finally {
+    answered = true;
+    clearTimeout(timer);
+  }
+}
+
+/** A filing read a page at a time, a few pages at once, until a page comes back short. */
+async function listPagedHoldings(
+  cik: string,
+  accessionNumber: string,
+  signal: AbortSignal | undefined,
+  options: Forms13FReadOptions,
 ): Promise<ThirteenFHoldingRecord[]> {
-  const rows: ThirteenFHoldingRecord[] = [];
-  for (let offset = 0; offset < MAX_FORM_ROWS; offset += FORM_PAGE_LIMIT) {
+  const pages: ThirteenFHoldingRecord[][] = [];
+  const maxPages = Math.ceil(MAX_FORM_ROWS / FILING_PAGE_ROWS);
+  let next = 0;
+  let last: number | null = null;
+  let failed = false;
+  async function readPage() {
     signal?.throwIfAborted();
+    const index = next++;
     const page = await listThirteenFFormHoldingsPage(cik, accessionNumber, signal, {
       ...options,
-      offset,
-      limit: FORM_PAGE_LIMIT,
+      offset: index * FILING_PAGE_ROWS,
+      limit: FILING_PAGE_ROWS,
     });
-    rows.push(...page.rows);
-    if (!page.hasMore) break;
+    pages[index] = page.rows;
+    if (page.rows.length < FILING_PAGE_ROWS && (last === null || index < last)) last = index;
+  }
+  async function worker() {
+    try {
+      while (!failed && next < maxPages && (last === null || next <= last)) await readPage();
+    } catch (error) {
+      failed = true;
+      throw error;
+    }
   }
-  return rows;
+  // The first page alone says whether there is more: most filings fit in it.
+  await readPage();
+  await Promise.all(Array.from({ length: FILING_PAGE_CONCURRENCY }, worker));
+  return pages.slice(0, (last ?? maxPages - 1) + 1).flat();
 }
 
 export async function lookupThirteenFTickers(