gloomberb 0.11.0 → 0.11.2

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

@@ -1,11 +1,12 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import type { PluginModule } from "../plugin-module";
 import type { SecFilingDocument, SecFilingItem } from "../../../types/data-provider";
 import { useResolvedEntryValue, useSecFilingDocuments, useSecFilingsQuery } from "../../../market-data/hooks";
 import { instrumentFromTicker } from "../../../market-data/request-types";
 import { useDebouncedPluginPaneState } from "../../runtime";
 import { usePaneTicker } from "../../../state/app/context";
-import { EmptyState, FeedDataTableStackView, Spinner, type FeedDataTableItem } from "../../../components";
+import type { ScrollBoxRenderable } from "../../../ui";
+import { EmptyState, FeedDataTableStackView, Spinner, useTableLoadMore, type FeedDataTableItem } from "../../../components";
 import { isUsEquityTicker } from "../../../utils/sec";
 import { parseForm4Xml, transactionTypeLabel } from "../insider/insider-data";
 import { formatCompact, formatCurrency } from "../../../utils/format";
@@ -27,7 +28,8 @@ import {
 } from "./filing-content";
 import { usePaneStatusLinkFooter } from "../shared/pane-footer";
 
-const SEC_FILING_LIMIT = 50;
+const SEC_FILING_FETCH_LIMIT = 20_000;
+const SEC_FILING_PAGE_SIZE = 50;
 const OWNERSHIP_FORMS = new Set(["3", "4", "5"]);
 
 function getDisplayFormLabel(form: string): string {
@@ -250,10 +252,21 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
   const instrument = instrumentFromTicker(ticker, ticker?.metadata.ticker ?? null);
   const filingsEntry = useSecFilingsQuery(
     instrument && eligibleTicker
-      ? { instrument, count: SEC_FILING_LIMIT }
+      ? { instrument, count: SEC_FILING_FETCH_LIMIT }
       : null,
   );
   const filings = useResolvedEntryValue(filingsEntry) ?? [];
+  const [visibleCount, setVisibleCount] = useState(SEC_FILING_PAGE_SIZE);
+  const visibleFilings = useMemo(() => filings.slice(0, visibleCount), [filings, visibleCount]);
+  const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+  const loadMore = useTableLoadMore(
+    scrollRef,
+    visibleCount < filings.length,
+    () => setVisibleCount((current) => Math.min(filings.length, current + SEC_FILING_PAGE_SIZE)),
+  );
+  useEffect(() => {
+    setVisibleCount(SEC_FILING_PAGE_SIZE);
+  }, [ticker?.metadata.ticker, ticker?.metadata.exchange]);
   const loading = filingsEntry?.phase === "loading" || (filingsEntry?.phase === "refreshing" && filings.length === 0);
   const error = filingsEntry?.phase === "error" ? filingsEntry.error?.message ?? "Failed to load SEC filings" : null;
 
@@ -270,7 +283,7 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
 
   // Only the filing in view needs its content; queueing every ownership form in
   // the list fires dozens of SEC requests the user never looks at.
-  const selectedFiling = filings[selectedIdx];
+  const selectedFiling = visibleFilings[selectedIdx];
   const contentTargets = useMemo(() => [
     ...(openFiling ? [openFiling] : []),
     ...buildInlineFilingContentTargets(openFiling, openDocuments),
@@ -283,10 +296,10 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
   const loadingContent = !!openFiling && !contentCache.has(openFiling.accessionNumber);
 
   useEffect(() => {
-    if (filings.length > 0 && selectedIdx >= filings.length) {
-      setSelectedIdx(Math.max(0, filings.length - 1));
+    if (visibleFilings.length > 0 && selectedIdx >= visibleFilings.length) {
+      setSelectedIdx(Math.max(0, visibleFilings.length - 1));
     }
-  }, [filings.length, selectedIdx, setSelectedIdx]);
+  }, [selectedIdx, setSelectedIdx, visibleFilings.length]);
 
   usePaneStatusLinkFooter({
     registrationId: "sec",
@@ -313,7 +326,7 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
       height={height}
       focused={focused}
       items={toFeedItems(
-        filings,
+        visibleFilings,
         openFiling?.accessionNumber,
         contentCache,
         loadingContent,
@@ -326,6 +339,8 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
       sourceLabel="Form"
       titleLabel="Filing"
       emptyStateTitle="No SEC filings."
+      scrollRef={scrollRef}
+      onBodyScrollActivity={loadMore}
     />
   );
 }

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

@@ -342,6 +342,20 @@ export const sectorsModule: PluginModule = {
     },
   ],
 
+  setup(ctx) {
+    ctx.registerCommand({
+      id: "sectors-sp",
+      label: "Sector Performance",
+      description: "S&P 500 sector and industry performance sorted by daily change.",
+      keywords: ["sector", "sectors", "sp", "performance"],
+      category: "data",
+      shortcut: "SP",
+      execute: () => {
+        ctx.createPaneFromTemplate("sectors-pane");
+      },
+    });
+  },
+
   paneTemplates: [
     {
       id: "sectors-pane",

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

@@ -8,7 +8,7 @@ import { useRendererHost } from "../../../ui";
 import type { RendererHost } from "../../../ui";
 import { getSharedRegistry } from "../../registry";
 import { requestAccountManagementTab } from "../account-management/navigation";
-import { usePlanAccess, type PlanAccess } from "./plan-access";
+import { resolvePlanAccess, usePlanAccess, type PlanAccess } from "./plan-access";
 
 export const CLOUD_UPGRADE_URL = "https://gloom.sh/cloud?upgrade=pro";
 
@@ -19,17 +19,20 @@ export const CLOUD_UPGRADE_URL = "https://gloom.sh/cloud?upgrade=pro";
 let cloudUpgradeOpener: (() => void) | null = null;
 
 /**
- * Resolves a safe handoff URL for a captured native session. Signed-out users
- * still use the public Cloud page, while signed-in users never expose their
- * session cookie to the external browser.
+ * Signed-out users get the public Cloud page. Signed-in free accounts go
+ * straight to Stripe checkout, and accounts that already have Pro (paying or
+ * trialing) get the billing portal, so nobody re-buys a subscription they
+ * already hold. Both URLs are account-bound, so no session handoff is needed.
  */
 export async function resolveCloudUpgradeUrl(): Promise<string> {
-  if (!apiClient.getSessionToken()) return CLOUD_UPGRADE_URL;
-  const handoff = await apiClient.createBrowserHandoff();
-  return handoff.url;
+  if (!apiClient.isSignedIn()) return CLOUD_UPGRADE_URL;
+  const { url } = resolvePlanAccess(apiClient.getCurrentUser()).hasProAccess
+    ? await apiClient.createBillingPortal()
+    : await apiClient.createCloudCheckout();
+  return url;
 }
 
-/** Opens Cloud Pro, transferring a native session with the server's one-time handoff. */
+/** Opens checkout or the billing portal in the user's browser. */
 export async function openCloudUpgrade(rendererHost: Pick<RendererHost, "openExternal">): Promise<void> {
   await rendererHost.openExternal(await resolveCloudUpgradeUrl());
 }
@@ -45,9 +48,13 @@ export function openCloudUpgradeUrl(): boolean {
 export function useCloudUpgradeAction(): () => void {
   const rendererHost = useRendererHost();
   const openUpgrade = useCallback(() => {
-    void openCloudUpgrade(rendererHost).catch(() => {
-      // Keep the public pricing page reachable if the short-lived handoff cannot be created.
-      void rendererHost.openExternal(CLOUD_UPGRADE_URL);
+    void openCloudUpgrade(rendererHost).catch(async () => {
+      // Keep the Cloud page reachable when checkout cannot be created; a native
+      // session still rides along on the server's one-time handoff URL.
+      const url = await apiClient.createBrowserHandoff()
+        .then((handoff) => handoff.url)
+        .catch(() => CLOUD_UPGRADE_URL);
+      void rendererHost.openExternal(url);
     });
   }, [rendererHost]);
   useEffect(() => {

package/src/plugins/builtin/shared/public-pane.test.ts

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test";
+import { createPublicPaneShare } from "./public-pane";
+
+test("default public pane shares restore no user-owned state", () => {
+  const adapter = createPublicPaneShare("World Equity Indices");
+  expect(adapter.serialize({
+    pane: { instanceId: "world", paneId: "world-indices", settings: { symbols: ["private"] } },
+    paneState: { selectedIndex: 2 },
+  })).toEqual({ title: "World Equity Indices", data: {} });
+  expect(adapter.restore({})).toEqual({});
+  expect(adapter.restore({ token: "secret" })).toBeNull();
+});

package/src/plugins/builtin/shared/public-pane.ts

@@ -0,0 +1,9 @@
+import type { PaneTemplatePublicShareDef } from "../../../types/plugin";
+
+/** Shares a public pane whose default template needs no user-owned input. */
+export function createPublicPaneShare(defaultTitle: string): PaneTemplatePublicShareDef {
+  return {
+    serialize: ({ pane }) => ({ title: pane.title?.trim() || defaultTitle, data: {} }),
+    restore: (data) => Object.keys(data).length === 0 ? {} : null,
+  };
+}

package/src/plugins/builtin/shared/public-share.ts

@@ -0,0 +1,23 @@
+import { useCallback } from "react";
+import { useRendererHost } from "../../../ui";
+import { createShare, publicShareUrl } from "../../../shares/api";
+import type { SharePayload } from "../../../shares/payload";
+import { usePluginAppActions } from "../../runtime";
+
+export function usePublicShare(): (payload: SharePayload) => Promise<void> {
+  const renderer = useRendererHost();
+  const { notify } = usePluginAppActions();
+
+  return useCallback(async (payload: SharePayload) => {
+    try {
+      const { id } = await createShare(payload);
+      await renderer.copyText(publicShareUrl(id));
+      notify({ body: "Share link copied to clipboard", type: "success" });
+    } catch (error) {
+      notify({
+        body: error instanceof Error ? error.message : "Could not create share.",
+        type: "error",
+      });
+    }
+  }, [notify, renderer]);
+}

package/src/plugins/builtin/shared/ticker-source.ts

@@ -0,0 +1,32 @@
+import { useCallback } from "react";
+import { useAppStateRef, usePaneInstanceId } from "../../../state/app/context";
+import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
+import { resolveTickerActivation } from "../../ticker-navigation";
+import { usePluginAppActions, usePluginTickerActions } from "../../runtime";
+
+/**
+ * Shared Enter routing for panes that publish a cursor symbol: reuse the Ticker Research pane
+ * already bound to this one instead of stacking another pane on top of it.
+ */
+export function useTickerSourceActivate(): (
+  symbol: string,
+  options?: { newPane?: boolean; floating?: boolean },
+) => void {
+  const paneId = usePaneInstanceId();
+  const stateRef = useAppStateRef();
+  const { pinTicker } = usePluginTickerActions();
+  const { focusPane } = usePluginAppActions();
+
+  return useCallback((symbol: string, options?: { newPane?: boolean; floating?: boolean }) => {
+    const activation = resolveTickerActivation(stateRef.current.config.layout, paneId, options);
+    if (activation.kind === "focus") {
+      focusPane(activation.paneId);
+      return;
+    }
+    pinTicker(symbol, {
+      floating: options?.floating ?? true,
+      forceNewPane: options?.newPane,
+      paneType: TICKER_RESEARCH_PANE_ID,
+    });
+  }, [focusPane, paneId, pinTicker, stateRef]);
+}

package/src/plugins/builtin/shared/ticker-surface.test.ts

@@ -31,6 +31,33 @@ describe("createTickerSurfacePaneTemplate", () => {
     }));
   });
 
+  test("shares only the public ticker binding and restores it through the template", () => {
+    const template = createTickerSurfacePaneTemplate({
+      id: "financial-analysis-pane",
+      paneId: "financial-analysis",
+      label: "Financial Analysis",
+      description: "Open financial statements.",
+      keywords: ["fa"],
+      shortcut: "FA",
+      publicShare: true,
+    });
+
+    const shared = template.publicShare?.serialize({
+      pane: {
+        instanceId: "financial-analysis:AAPL",
+        paneId: "financial-analysis",
+        title: "FA AAPL",
+        binding: { kind: "fixed", symbol: "AAPL" },
+        settings: { cachedPrivateValue: "not shared" },
+      },
+      paneState: { selectedRow: 4 },
+    });
+
+    expect(shared).toEqual({ title: "FA AAPL", data: { symbol: "AAPL" } });
+    expect(template.publicShare?.restore(shared!.data)).toEqual({ symbol: "AAPL" });
+    expect(template.publicShare?.restore({ symbol: "AAPL", token: "secret" })).toBeNull();
+  });
+
   test("keeps chart shortcut variants separate with view keys", () => {
     const price = createTickerSurfacePaneTemplate({
       id: "graph-price-pane",

package/src/plugins/builtin/shared/ticker-surface.ts

@@ -13,6 +13,8 @@ export interface TickerSurfacePaneTemplateOptions {
   description: string;
   keywords: string[];
   shortcut: string;
+  /** Opt in only when this template is available in the hosted browser catalog. */
+  publicShare?: boolean;
   titlePrefix?: string;
   viewKey?: string | ((
     symbol: string,
@@ -109,5 +111,20 @@ export function createTickerSurfacePaneTemplate(
         resolveViewKey(templateOptions.viewKey, symbol, context, createOptions),
       );
     },
+    ...(templateOptions.publicShare ? {
+      publicShare: {
+        serialize: ({ pane }) => pane.binding?.kind === "fixed" && pane.binding.symbol.trim()
+          ? {
+            title: pane.title?.trim() || `${titlePrefix} ${pane.binding.symbol}`,
+            data: { symbol: pane.binding.symbol.trim().toUpperCase() },
+          }
+          : null,
+        restore: (data) => {
+          if (Object.keys(data).length !== 1 || typeof data.symbol !== "string") return null;
+          const symbol = data.symbol.trim().toUpperCase();
+          return symbol ? { symbol } : null;
+        },
+      },
+    } : {}),
   };
 }

package/src/plugins/builtin/substack/api/cache.ts

@@ -27,13 +27,17 @@ function cachedDataFromResource<T>(entry: PersistedResourceValue<T> | null): Sub
 
 export function getCachedSubstackHome(): SubstackHomeData | null {
   const subscriptionsEntry = readResource<SubstackPublication[]>("subscriptions", "me", false);
-  const feedEntry = readResource<SubstackArticleSummary[]>("feed", "subscribed", false);
+  const feedEntry = readResource<SubstackArticleSummary[] | { items: SubstackArticleSummary[]; nextCursor?: string | null }>("feed", "subscribed", false);
   if (!subscriptionsEntry || !feedEntry) return null;
+  const feed = Array.isArray(feedEntry.value) ? feedEntry.value : feedEntry.value.items;
+  const nextCursor = Array.isArray(feedEntry.value) ? null : feedEntry.value.nextCursor ?? null;
   return {
-    subscriptions: sortSubscriptionsByLatest(subscriptionsEntry.value, feedEntry.value),
-    feed: feedEntry.value,
+    subscriptions: sortSubscriptionsByLatest(subscriptionsEntry.value, feed),
+    feed,
     fetchedAt: Math.max(subscriptionsEntry.fetchedAt, feedEntry.fetchedAt),
     stale: Boolean(subscriptionsEntry.stale) || Boolean(feedEntry.stale),
+    hasMore: !!nextCursor,
+    nextCursor,
   };
 }
 

package/src/plugins/builtin/substack/api/loaders.ts

@@ -33,13 +33,19 @@ export async function loadSubstackHome(force = false): Promise<SubstackHomeData>
     }),
   ]);
   return {
-    subscriptions: sortSubscriptionsByLatest(subscriptionsEntry.data, feedEntry.data),
-    feed: feedEntry.data,
+    subscriptions: sortSubscriptionsByLatest(subscriptionsEntry.data, feedEntry.data.items),
+    feed: feedEntry.data.items,
     fetchedAt: Math.max(subscriptionsEntry.fetchedAt, feedEntry.fetchedAt),
     stale: subscriptionsEntry.stale || feedEntry.stale,
+    hasMore: !!feedEntry.data.nextCursor,
+    nextCursor: feedEntry.data.nextCursor,
   };
 }
 
+export async function loadSubstackHomeMore(cursor: string): Promise<{ items: SubstackArticleSummary[]; nextCursor: string | null }> {
+  return fetchReaderFeedPage(requireAuth(), "subscribed", cursor);
+}
+
 function payloadCursor(payload: unknown): string | null {
   const record = payload && typeof payload === "object" && !Array.isArray(payload)
     ? payload as Record<string, unknown>
@@ -48,23 +54,41 @@ function payloadCursor(payload: unknown): string | null {
   return typeof cursor === "string" && cursor.trim() ? cursor : null;
 }
 
-async function fetchReaderFeedItems(auth: ReturnType<typeof requireAuth>, tab: string): Promise<SubstackArticleSummary[]> {
+async function fetchReaderFeedPage(
+  auth: ReturnType<typeof requireAuth>,
+  tab: string,
+  cursor: string | null = null,
+): Promise<{ items: SubstackArticleSummary[]; nextCursor: string | null }> {
+  const url = new URL(`${SUBSTACK_ORIGIN}/api/v1/reader/feed`);
+  url.searchParams.set("tab", tab);
+  if (cursor) url.searchParams.set("cursor", cursor);
+  const payload = await fetchJsonAuthenticated<unknown>(url.toString(), auth);
+  const nextCursor = payloadCursor(payload);
+  return {
+    items: normalizeFeedItems(payload),
+    nextCursor: nextCursor && nextCursor !== cursor ? nextCursor : null,
+  };
+}
+
+async function fetchReaderFeedItems(
+  auth: ReturnType<typeof requireAuth>,
+  tab: string,
+): Promise<{ items: SubstackArticleSummary[]; nextCursor: string | null }> {
   const collected = new Map<string, SubstackArticleSummary>();
   let cursor: string | null = null;
   for (let page = 0; page < READER_FEED_MAX_PAGES && collected.size < READER_FEED_TARGET_ITEMS; page += 1) {
-    const url = new URL(`${SUBSTACK_ORIGIN}/api/v1/reader/feed`);
-    url.searchParams.set("tab", tab);
-    if (cursor) url.searchParams.set("cursor", cursor);
-    const payload = await fetchJsonAuthenticated<unknown>(url.toString(), auth);
-    for (const article of normalizeFeedItems(payload)) {
+    const result = await fetchReaderFeedPage(auth, tab, cursor);
+    for (const article of result.items) {
       collected.set(article.id, article);
       if (collected.size >= READER_FEED_TARGET_ITEMS) break;
     }
-    const nextCursor = payloadCursor(payload);
-    if (!nextCursor || nextCursor === cursor) break;
-    cursor = nextCursor;
+    if (!result.nextCursor) {
+      cursor = null;
+      break;
+    }
+    cursor = result.nextCursor;
   }
-  return [...collected.values()];
+  return { items: [...collected.values()], nextCursor: cursor };
 }
 
 export async function loadSubstackPublicationFeed(

package/src/plugins/builtin/substack/api/types.ts

@@ -16,6 +16,8 @@ export interface SubstackHomeData {
   feed: SubstackArticleSummary[];
   fetchedAt: number;
   stale: boolean;
+  hasMore?: boolean;
+  nextCursor?: string | null;
 }
 
 export interface SubstackPublicationFeedPage {

package/src/plugins/builtin/substack/pane-state.ts

@@ -137,7 +137,7 @@ export function activeFeedStateFromSources({
       fetchedAt: home.fetchedAt,
       stale: home.stale,
       loadingMore: false,
-      hasMore: false,
+      hasMore: home.data?.hasMore === true,
       nextOffset: null,
     };
   }

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

@@ -3,6 +3,7 @@ import { Box, useRendererHost, type ScrollBoxRenderable } from "../../../ui";
 import {
   EmptyState,
   Spinner,
+  useTableLoadMore,
   type DataTableKeyEvent,
 } from "../../../components";
 import type { PaneProps } from "../../../types/plugin";
@@ -15,6 +16,7 @@ import {
 import {
   loadSubstackArticleDetail,
   loadSubstackHome,
+  loadSubstackHomeMore,
   loadSubstackPublicationFeed,
 } from "./api/loaders";
 import {
@@ -126,6 +128,33 @@ export function SubstackPane({ focused, width, height }: PaneProps) {
       });
   }, [auth, handleAuthFailure]);
 
+  const loadHomeMore = useCallback((cursor: string) => {
+    if (!auth) return;
+    const gen = homeFetchGenRef.current;
+    loadSubstackHomeMore(cursor)
+      .then((page) => {
+        if (homeFetchGenRef.current !== gen) return;
+        setHome((current) => {
+          if (!current.data) return current;
+          const itemsById = new Map(current.data.feed.map((article) => [article.id, article]));
+          for (const article of page.items) itemsById.set(article.id, article);
+          return {
+            ...current,
+            data: {
+              ...current.data,
+              feed: [...itemsById.values()],
+              hasMore: !!page.nextCursor,
+              nextCursor: page.nextCursor,
+            },
+          };
+        });
+      })
+      .catch((loadError) => {
+        if (homeFetchGenRef.current !== gen) return;
+        handleAuthFailure(loadError);
+      });
+  }, [auth, handleAuthFailure]);
+
   useEffect(() => {
     if (!auth) return;
     loadHome(false);
@@ -215,18 +244,32 @@ export function SubstackPane({ focused, width, height }: PaneProps) {
     home,
   }), [activePublication, activePublicationTabId, home, publicationFeeds]);
 
-  const loadMoreActivePublicationRows = useCallback(() => {
-    if (!activePublication || !activePublicationTabId || detailOpen) return;
-    const entry = publicationFeeds[activePublicationTabId];
-    const page = entry?.data;
-    if (!page || entry.loading || entry.loadingMore || entry.error || !page.hasMore || page.nextOffset == null) return;
-    const scrollBox = tableScrollRef.current;
-    if (!scrollBox?.viewport) return;
-    const visibleBottom = scrollBox.scrollTop + scrollBox.viewport.height;
-    const remainingRows = page.items.length - visibleBottom;
-    if (remainingRows > PUBLICATION_LOAD_MORE_THRESHOLD_ROWS) return;
-    loadPublication(activePublication, false, page.nextOffset);
-  }, [activePublication, activePublicationTabId, detailOpen, loadPublication, publicationFeeds]);
+  const loadMoreHome = useCallback(() => {
+    if (!auth || home.loading || detailOpen || !home.data?.hasMore || !home.data.nextCursor) return;
+    loadHomeMore(home.data.nextCursor);
+  }, [auth, detailOpen, home.data?.hasMore, home.data?.nextCursor, home.loading, loadHomeMore]);
+
+  const loadMoreActivePublicationRows = useTableLoadMore(
+    tableScrollRef,
+    !detailOpen && (
+      activePublication
+        ? !!(publicationFeeds[activePublicationTabId ?? ""]?.data?.hasMore
+          && publicationFeeds[activePublicationTabId ?? ""]?.data?.nextOffset != null
+          && !publicationFeeds[activePublicationTabId ?? ""]?.loading
+          && !publicationFeeds[activePublicationTabId ?? ""]?.loadingMore
+          && !publicationFeeds[activePublicationTabId ?? ""]?.error)
+        : !!(home.data?.hasMore && home.data.nextCursor && !home.loading)
+    ),
+    () => {
+      if (activePublication) {
+        const page = publicationFeeds[activePublicationTabId ?? ""]?.data;
+        if (page?.nextOffset != null) loadPublication(activePublication, false, page.nextOffset);
+        return;
+      }
+      loadMoreHome();
+    },
+    PUBLICATION_LOAD_MORE_THRESHOLD_ROWS,
+  );
 
   const sortedRows = useMemo(() => (
     sortedSubstackArticles(activeFeedState.data ?? [], sort)

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

@@ -26,7 +26,7 @@ describe("13F API", () => {
 
     const funds = await searchThirteenFFunds("transport-smoke", 1);
 
-    expect(urls[0]).toContain("https://forms13f.com/api/v1/funds");
+    expect(urls[0]).toContain("/cloud/sec/13f/funds");
     expect(funds).toEqual([{ cik: "0001067983", name: "BERKSHIRE HATHAWAY INC" }]);
   });
 

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

@@ -7,6 +7,7 @@ import type {
   ThirteenFTopFund,
 } from "./types";
 import type { PluginPersistence } from "../../../types/plugin";
+import { apiClient } from "../../../api-client";
 import { httpFetch } from "../../../utils/http-transport";
 
 const FORMS_13F_BASE_URL = "https://forms13f.com/api/v1";
@@ -124,17 +125,22 @@ async function fetchForms13F<T>(
     if (cached) return cached;
   }
 
-  const url = `${FORMS_13F_BASE_URL}${path}?${searchParams.toString()}`;
-  const response = await httpFetch(url, {
-    headers: { Accept: "application/json" },
-    signal: options.signal,
-  });
-  if (!response.ok) {
-    const stale = options.cache !== false ? readApiCache<T>(key, { allowExpired: true }) : null;
-    if (stale) return stale;
-    throw new Error(`Forms13F ${response.status} for ${path}`);
+  let value: T;
+  try {
+    value = await apiClient.getCloudSec13F(path, params) as T;
+  } catch {
+    const url = `${FORMS_13F_BASE_URL}${path}?${searchParams.toString()}`;
+    const response = await httpFetch(url, {
+      headers: { Accept: "application/json" },
+      signal: options.signal,
+    });
+    if (!response.ok) {
+      const stale = options.cache !== false ? readApiCache<T>(key, { allowExpired: true }) : null;
+      if (stale) return stale;
+      throw new Error(`Forms13F ${response.status} for ${path}`);
+    }
+    value = await response.json() as T;
   }
-  const value = await response.json() as T;
   if (value != null && options.cache !== false) {
     writeApiCache(key, value);
   }
@@ -277,6 +283,24 @@ export async function listThirteenFForms(
   return arrayResponse(raw).map(mapForm).filter((form): form is ThirteenFFormSummary => !!form);
 }
 
+export async function listThirteenFFormHoldingsPage(
+  cik: string,
+  accessionNumber: string,
+  signal?: AbortSignal,
+  options: { forceRefresh?: boolean; offset?: number; limit?: number } = {},
+): Promise<{ rows: ThirteenFHoldingRecord[]; hasMore: boolean }> {
+  const offset = Math.max(0, options.offset ?? 0);
+  const limit = Math.max(1, options.limit ?? FORM_PAGE_LIMIT);
+  const raw = await fetchForms13F<unknown>("/form", {
+    cik: normalizeCik(cik),
+    accession_number: accessionNumber,
+    limit,
+    offset,
+  }, { signal, forceRefresh: options.forceRefresh });
+  const rows = arrayResponse(raw).map(mapHolding).filter((holding): holding is ThirteenFHoldingRecord => !!holding);
+  return { rows, hasMore: rows.length >= limit && offset + rows.length < MAX_FORM_ROWS };
+}
+
 export async function listThirteenFFormHoldings(
   cik: string,
   accessionNumber: string,
@@ -285,15 +309,13 @@ export async function listThirteenFFormHoldings(
 ): Promise<ThirteenFHoldingRecord[]> {
   const rows: ThirteenFHoldingRecord[] = [];
   for (let offset = 0; offset < MAX_FORM_ROWS; offset += FORM_PAGE_LIMIT) {
-    const raw = await fetchForms13F<unknown>("/form", {
-      cik: normalizeCik(cik),
-      accession_number: accessionNumber,
-      limit: FORM_PAGE_LIMIT,
+    const page = await listThirteenFFormHoldingsPage(cik, accessionNumber, signal, {
+      ...options,
       offset,
-    }, { signal, forceRefresh: options.forceRefresh });
-    const page = arrayResponse(raw).map(mapHolding).filter((holding): holding is ThirteenFHoldingRecord => !!holding);
-    rows.push(...page);
-    if (page.length < FORM_PAGE_LIMIT) break;
+      limit: FORM_PAGE_LIMIT,
+    });
+    rows.push(...page.rows);
+    if (!page.hasMore) break;
   }
   return rows;
 }