gloomberb 0.19.1 → 0.19.3

package/src/plugins/builtin/social-mentions/client.ts

@@ -1,9 +1,10 @@
 import { unavailableText } from "../../../components/ui/status";
 import { apiClient } from "../../../api-client";
-import { ApiRequestError, isAccessDenied } from "../../../api-client/errors";
+import { isAccessDenied } from "../../../api-client/errors";
 import type { SocialMentionDayPosts, SocialMentionPost, SocialMentionsPayload, SocialMentionsRange } from "../../../api-client/social-mentions";
-import { createPluginCache } from "../../../data/plugin-cache";
+import { createPluginCache, savedCopyForTransientFailure } from "../../../data/plugin-cache";
 import { CLOUD_SESSION_REQUIRED } from "../shared/research-cloud-session";
+import { unavailableOnServer } from "../shared/cloud-resource";
 
 export const socialMentionsCache = createPluginCache<SocialMentionsPayload>({
   kind: "social-mentions", source: "gloom-cloud", schemaVersion: 1,
@@ -56,12 +57,15 @@ export function validateSocialMentions(payload: SocialMentionsPayload, symbol: s
 export async function fetchSocialMentions(symbol: string, range: SocialMentionsRange = "1y",
   client: Pick<typeof apiClient, "getCloudSocialMentions"> = apiClient): Promise<SocialMentionsPayload> {
   try { return validateSocialMentions(await client.getCloudSocialMentions(symbol, range), symbol, range); }
-  catch (error) {
-    if (error instanceof ApiRequestError && error.status === 404) throw new Error(unavailableText("social mentions"));
-    throw error;
-  }
+  catch (error) { throw unavailableOnServer(error, unavailableText("social mentions")); }
+}
+export interface SocialMentionsResource {
+  payload: SocialMentionsPayload;
+  stale: boolean;
+  refreshError: string | null;
+  /** When the copy shown was saved, when it is one because its refresh failed. */
+  savedAt?: number;
 }
-export interface SocialMentionsResource { payload: SocialMentionsPayload; stale: boolean; refreshError: string | null }
 const cacheKey = (symbol: string, range: SocialMentionsRange) => `${range}:${symbol}`;
 export function cachedSocialMentions(symbol: string, range: SocialMentionsRange): SocialMentionsResource | null {
   const cached = socialMentionsCache.get(cacheKey(symbol, range), { allowExpired: true });
@@ -70,9 +74,10 @@ export function cachedSocialMentions(symbol: string, range: SocialMentionsRange)
   catch { return null; }
 }
 export async function loadSocialMentions(symbol: string, range: SocialMentionsRange, force = false): Promise<SocialMentionsResource> {
-  const result = await socialMentionsCache.load(cacheKey(symbol, range), () => fetchSocialMentions(symbol, range), { force });
-  if (result.error instanceof ApiRequestError && [401, 403].includes(result.error.status ?? 0)) throw result.error;
-  return { payload: validateSocialMentions(result.data, symbol, range), stale: result.stale, refreshError: result.refreshError ?? null };
+  // A refusal (a signed-out session, any other 4xx but 408 and 429) or a reply that fails validation shows as itself.
+  const result = savedCopyForTransientFailure(await socialMentionsCache.load(cacheKey(symbol, range), () => fetchSocialMentions(symbol, range), { force }));
+  return { payload: validateSocialMentions(result.data, symbol, range), stale: result.stale, refreshError: result.refreshError ?? null,
+    ...(result.source === "stale-fallback" ? { savedAt: result.fetchedAt } : {}) };
 }
 
 /**

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/social-mentions/series.ts

@@ -1,5 +1,5 @@
 import type { SeriesDefinition } from "../../../series/types";
-import { cachedSeriesWarning } from "../shared/series-warning";
+import { cachedSeriesNote } from "../shared/series-warning";
 import { loadSocialMentions } from "./client";
 
 /** How often a ticker is posted about each day, over the last year. */
@@ -14,10 +14,9 @@ export const SOCIAL_MENTION_SERIES: readonly SeriesDefinition[] = [{
   style: "columns",
   load: async ({ ticker }) => {
     const resource = await loadSocialMentions(ticker!, "1y");
-    const warning = cachedSeriesWarning(resource);
     return {
       points: resource.payload.x.days.map((row) => ({ date: row.day, value: row.mentions })),
-      ...(warning ? { warning } : {}),
+      ...cachedSeriesNote(resource),
     };
   },
 }];

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

@@ -10,17 +10,25 @@ import type {
 } from "./types";
 import type { PluginPersistence } from "../../../types/plugin";
 import { apiClient } from "../../../api-client";
-import { ApiRequestError, isPermanentClientError } from "../../../api-client/errors";
+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;
@@ -30,11 +38,12 @@ const FORMS_13F_CACHE_POLICY = {
 } as const;
 
 export interface Forms13FReadOptions {
+  /** A part of the answer that could not be read, said beside what was. */
   onWarning?: (warning: string) => void;
   /**
    * A read answered from the copy saved at `savedAt` (ms) because its refresh
-   * failed, said by when it was saved (a command's closing line) instead of
-   * as an `onWarning` line.
+   * failed. Only a caller that says when its copy was saved (the footer's
+   * "saved copy from", a command's closing line) is answered from one.
    */
   onSavedCopy?: (savedAt: number) => void;
   forceRefresh?: boolean;
@@ -51,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();
@@ -61,6 +72,7 @@ export function resetThirteenFApiPersistence() {
   forms13FPersistence = null;
   failedRefreshes.clear();
   activeRequests.clear();
+  wholeFilingsMissing = false;
 }
 
 function padCik(value: string): string {
@@ -121,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> } = {};
@@ -156,23 +176,17 @@ async function fetchForms13F<T>(
     } catch (error) {
       options.signal?.throwIfAborted();
       if (current()) failedRefreshes.add(key);
-      if (isPermanentClientError(error)) {
-        if (current()) store?.deleteResource(CACHE_KIND, key, { sourceKey: CACHE_SOURCE });
+      // A saved copy answers only for a failure asking again may get past; a refusal or a reply that
+      // fails validation is the error, and a missing or denied resource also drops its copy.
+      if (!isTransientFailure(error)) {
+        if (isPermanentClientError(error) && current()) store?.deleteResource(CACHE_KIND, key, { sourceKey: CACHE_SOURCE });
         throw error;
       }
       const retained = options.cache !== false
         ? store?.getResource<T>(CACHE_KIND, key, { ...cacheOptions, allowExpired: true }) : null;
-      // A caller may retain old research only when it can surface its provenance.
-      if (!retained) throw error;
-      if (options.onSavedCopy && Number.isFinite(retained.fetchedAt)) {
-        options.onSavedCopy(retained.fetchedAt);
-        return retained.value;
-      }
-      if (!options.onWarning) throw error;
-      const retrieved = new Date(retained.fetchedAt);
-      const age = Number.isFinite(retrieved.getTime()) ? `retrieved ${retrieved.toISOString()}` : "with unavailable retrieval time";
-      const reason = (error instanceof Error ? error.message : String(error)).trim() || "Request failed";
-      options.onWarning(`${key}: refresh failed: ${reason}. Retained data ${age}.`);
+      // A caller may retain old research only when it can say when it was saved.
+      if (!retained || !options.onSavedCopy || !Number.isFinite(retained.fetchedAt)) throw error;
+      options.onSavedCopy(retained.fetchedAt);
       return retained.value;
     } finally {
       if (activeRequests.get(key) === slot.promise) activeRequests.delete(key);
@@ -348,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 rows: ThirteenFHoldingRecord[] = [];
-  for (let offset = 0; offset < MAX_FORM_ROWS; offset += FORM_PAGE_LIMIT) {
+  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 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(