gloomberb 0.13.1 → 0.13.2

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

@@ -45,35 +45,37 @@ export async function loadBrowserRows(
   tab: ThirteenFBrowserTab,
   query: string,
   signal?: AbortSignal,
-  options: { forceRefresh?: boolean; offset?: number } = {},
+  options: { forceRefresh?: boolean; offset?: number; limit?: number } = {},
 ): Promise<BrowserLoadResult> {
   const now = new Date();
   const from = dateYearsAgo(2, now);
   const to = todayIso(now);
   const quarter = latestLikely13FQuarter(now);
   const offset = Math.max(0, options.offset ?? 0);
+  const browserLimit = Math.max(1, options.limit ?? BROWSER_PAGE_LIMIT);
+  const latestLimit = Math.max(1, options.limit ?? LATEST_FILINGS_PAGE_LIMIT);
   const apiOptions = { forceRefresh: options.forceRefresh };
   const pageApiOptions = { forceRefresh: options.forceRefresh, offset };
 
   if (tab === "performance") {
-    const topFunds = await listTopThirteenFFunds(quarter, BROWSER_PAGE_LIMIT, signal, pageApiOptions);
+    const topFunds = await listTopThirteenFFunds(quarter, browserLimit, signal, pageApiOptions);
     const funds: ThirteenFFund[] = topFunds.map((fund) => ({ cik: fund.cik, name: fund.name }));
-    const forms = await loadLatestFormsForFunds(funds.slice(0, FORM_ENRICHMENT_LIMIT), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh });
+    const forms = await loadLatestFormsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh });
     return {
       rows: buildBrowserRows({ topFunds, forms, source: "performance" }),
       quarter,
       period: topFunds[0]?.periodOfReport,
-      hasMore: topFunds.length >= BROWSER_PAGE_LIMIT,
+      hasMore: topFunds.length >= browserLimit,
       nextOffset: offset + topFunds.length,
     };
   }
 
   if (tab === "latest") {
-    const filings = await listThirteenFFilings(recentIso(21, now), to, LATEST_FILINGS_PAGE_LIMIT, signal, pageApiOptions);
+    const filings = await listThirteenFFilings(recentIso(21, now), to, latestLimit, signal, pageApiOptions);
     return {
       rows: buildBrowserRows({ latestFilings: filings, source: "latest" }),
       period: filings[0]?.periodOfReport,
-      hasMore: filings.length >= LATEST_FILINGS_PAGE_LIMIT,
+      hasMore: filings.length >= latestLimit,
       nextOffset: offset + filings.length,
     };
   }
@@ -97,7 +99,7 @@ export async function loadBrowserRows(
     try {
       const holders = await lookupThirteenFHoldersByCusip(cusip, periodOfReport, signal, apiOptions);
       const forms = new Map<string, ThirteenFFormSummary>();
-      const pageCiks = holders.ciks.slice(offset, offset + BROWSER_PAGE_LIMIT);
+      const pageCiks = holders.ciks.slice(offset, offset + browserLimit);
       const funds = await Promise.all(pageCiks.map(async (cik): Promise<ThirteenFFund> => {
         const fundForms = await listThirteenFForms(cik, from, to, 1, signal, apiOptions);
         if (fundForms[0]) forms.set(cik, fundForms[0]);
@@ -136,10 +138,10 @@ export async function loadBrowserRows(
       nextOffset: offset + 1,
     };
   }
-  const funds = await searchThirteenFFunds(trimmed, BROWSER_PAGE_LIMIT, signal, pageApiOptions);
+  const funds = await searchThirteenFFunds(trimmed, browserLimit, signal, pageApiOptions);
   const [forms, topFunds] = await Promise.all([
-    loadLatestFormsForFunds(funds.slice(0, FORM_ENRICHMENT_LIMIT), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh }),
-    listTopThirteenFFunds(quarter, BROWSER_PAGE_LIMIT, signal, { forceRefresh: options.forceRefresh }).catch(() => []),
+    loadLatestFormsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh }),
+    listTopThirteenFFunds(quarter, browserLimit, signal, { forceRefresh: options.forceRefresh }).catch(() => []),
   ]);
   const topByCik = new Map(topFunds.map((fund) => [fund.cik, fund]));
   const matchedTopFunds = funds
@@ -153,7 +155,7 @@ export async function loadBrowserRows(
       source: "funds",
     }),
     quarter,
-    hasMore: funds.length >= BROWSER_PAGE_LIMIT,
+    hasMore: funds.length >= browserLimit,
     nextOffset: offset + funds.length,
   };
 }

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

@@ -0,0 +1,112 @@
+import { describe, expect, test } from "bun:test";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createThirteenFHeadless } from "./headless";
+import type { FundDetailData } from "./types";
+
+const detail: FundDetailData = {
+  cik: "0001067983",
+  name: "Berkshire Hathaway",
+  forms: [
+    {
+      url: "https://www.sec.gov/latest",
+      accessionNumber: "latest",
+      submissionType: "13F-HR",
+      periodOfReport: "2026-06-30",
+      filedAsOfDate: "2026-08-14",
+      cik: "0001067983",
+      companyName: "Berkshire Hathaway",
+      tableValueTotal: 300,
+      tableEntryTotal: 2,
+      isAmendment: false,
+    },
+    {
+      url: "https://www.sec.gov/previous",
+      accessionNumber: "previous",
+      submissionType: "13F-HR",
+      periodOfReport: "2026-03-31",
+      filedAsOfDate: "2026-05-15",
+      cik: "0001067983",
+      companyName: "Berkshire Hathaway",
+      tableValueTotal: 200,
+      tableEntryTotal: 1,
+      isAmendment: false,
+    },
+  ],
+  latestForm: null,
+  previousForm: null,
+  latestHoldings: [],
+  previousHoldings: [],
+};
+detail.latestForm = detail.forms[0]!;
+detail.previousForm = detail.forms[1]!;
+detail.latestHoldings = [
+  {
+    accessionNumber: "latest",
+    cik: detail.cik,
+    issuer: "Apple Inc",
+    titleOfClass: "COM",
+    cusip: "037833100",
+    ticker: "AAPL",
+    value: 300,
+    shares: 3,
+    shareType: "SH",
+    investmentDiscretion: "DFND",
+    votingAuthoritySole: 3,
+    votingAuthorityShared: 0,
+    votingAuthorityNone: 0,
+    putCall: "",
+  },
+];
+detail.previousHoldings = [{ ...detail.latestHoldings[0]!, accessionNumber: "previous", value: 200, shares: 2 }];
+
+function context(): HeadlessPaneContext {
+  return {
+    marketData: createTestDataProvider(),
+    apiClient: {} as HeadlessPaneContext["apiClient"],
+    config: createDefaultConfig("/tmp/gloomberb-headless-thirteenf"),
+    signal: new AbortController().signal,
+  };
+}
+
+function args(view: string, limit = 50): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "1067983",
+    argument: "1067983",
+    symbols: [],
+    options: { view, limit },
+  };
+}
+
+describe("13F headless model", () => {
+  test("projects browser rows and switches to fund holdings", async () => {
+    const headless = createThirteenFHeadless({
+      loadBrowser: async () => ({
+        rows: [
+          { id: "one", cik: detail.cik, name: detail.name, estQuarterReturn: 8.2, source: "performance" },
+          { id: "two", cik: "0000000002", name: "Second Fund", estQuarterReturn: 4.1, source: "performance" },
+        ],
+        quarter: "2026Q2",
+      }),
+      loadDetail: async () => detail,
+    });
+
+    const browser = await headless.load(args("performance", 1), context());
+    expect(browser.rows).toEqual([expect.objectContaining({
+      cik: detail.cik,
+      name: detail.name,
+      estQuarterReturn: 8.2,
+    })]);
+
+    const holdings = await headless.load(args("holdings", 5), context());
+    expect(holdings.rows).toEqual([expect.objectContaining({
+      ticker: "AAPL",
+      value: 300,
+      sharesChange: 1,
+      action: "add",
+      actionLabel: "Add",
+    })]);
+    expect(holdings.metadata).toMatchObject({ view: "holdings", fund: detail.name });
+  });
+});

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

@@ -0,0 +1,286 @@
+import type {
+  HeadlessPaneColumn,
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { normalizeCik } from "./api";
+import {
+  loadBrowserRows,
+  loadFundDetail,
+  type BrowserLoadResult,
+} from "./data";
+import {
+  DEFAULT_BROWSER_SORT,
+  DEFAULT_HOLDING_SORT,
+  DEFAULT_TIMELINE_SORT,
+  buildFundHoldingRows,
+  buildTimelineRows,
+  inferBrowserTabFromQuery,
+  isCikQuery,
+  positionType,
+  sortBrowserRows,
+  sortHoldingRows,
+  sortTimelineRows,
+} from "./model";
+import {
+  actionLabel,
+  formatChangeShares,
+  formatMoneyCompact,
+  formatPercentMaybe,
+  formatRawPercentMaybe,
+  formatShares,
+  formatShortDate,
+} from "./format";
+import type {
+  FundDetailData,
+  ThirteenFBrowserTab,
+} from "./types";
+
+const BROWSER_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "name", header: "Fund" },
+  { key: "cik", header: "CIK" },
+  { key: "periodOfReport", header: "Period" },
+  {
+    key: "estQuarterReturn",
+    header: "Est 13F",
+    align: "right",
+    format: (value) => formatRawPercentMaybe(value == null ? null : Number(value)),
+  },
+  {
+    key: "tableValueTotal",
+    header: "Value",
+    align: "right",
+    format: (value) => formatMoneyCompact(value == null ? null : Number(value)),
+  },
+  { key: "tableEntryTotal", header: "Rows", align: "right" },
+  {
+    key: "filedAsOfDate",
+    header: "Filed",
+    format: (value) => formatShortDate(typeof value === "string" ? value : null),
+  },
+];
+
+const HOLDING_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "ticker", header: "Ticker" },
+  { key: "type", header: "Type" },
+  { key: "issuer", header: "Issuer" },
+  {
+    key: "value",
+    header: "Value",
+    align: "right",
+    format: (value) => formatMoneyCompact(value == null ? null : Number(value)),
+  },
+  {
+    key: "estimatedPnl",
+    header: "Est P&L",
+    align: "right",
+    format: (value) => formatMoneyCompact(value == null ? null : Number(value)),
+  },
+  {
+    key: "weight",
+    header: "Weight",
+    align: "right",
+    format: (value) => formatPercentMaybe(value == null ? null : Number(value)),
+  },
+  {
+    key: "shares",
+    header: "Shares",
+    align: "right",
+    format: (value) => formatShares(value == null ? null : Number(value)),
+  },
+  {
+    key: "sharesChange",
+    header: "QoQ",
+    align: "right",
+    format: (value) => formatChangeShares(value == null ? null : Number(value)),
+  },
+  { key: "actionLabel", header: "Action" },
+];
+
+const FILING_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "periodOfReport", header: "Period" },
+  {
+    key: "filedAsOfDate",
+    header: "Filed",
+    format: (value) => formatShortDate(typeof value === "string" ? value : null),
+  },
+  {
+    key: "tableValueTotal",
+    header: "Value",
+    align: "right",
+    format: (value) => formatMoneyCompact(value == null ? null : Number(value)),
+  },
+  { key: "tableEntryTotal", header: "Rows", align: "right" },
+  {
+    key: "valueChangePercent",
+    header: "Value%",
+    align: "right",
+    format: (value) => formatPercentMaybe(value == null ? null : Number(value)),
+  },
+  { key: "submissionType", header: "Form" },
+];
+
+type HeadlessThirteenFView =
+  | "auto"
+  | "performance"
+  | "funds"
+  | "by-ticker"
+  | "latest"
+  | "holdings"
+  | "filings";
+
+export interface ThirteenFHeadlessDependencies {
+  loadBrowser(
+    tab: ThirteenFBrowserTab,
+    query: string,
+    limit: number,
+    args: HeadlessPaneLoadArgs,
+    ctx: HeadlessPaneContext,
+  ): Promise<BrowserLoadResult>;
+  loadDetail(
+    cik: string,
+    name: string,
+    args: HeadlessPaneLoadArgs,
+    ctx: HeadlessPaneContext,
+  ): Promise<FundDetailData>;
+}
+
+const defaultDependencies: ThirteenFHeadlessDependencies = {
+  loadBrowser: (tab, query, limit, _args, ctx) => loadBrowserRows(
+    tab,
+    query,
+    ctx.signal,
+    { limit },
+  ),
+  loadDetail: (cik, name, _args, ctx) => loadFundDetail(cik, name, ctx.signal),
+};
+
+function browserTab(view: HeadlessThirteenFView, query: string): ThirteenFBrowserTab {
+  if (view === "performance" || view === "funds" || view === "latest") return view;
+  if (view === "by-ticker") return "byTicker";
+  return inferBrowserTabFromQuery(query);
+}
+
+async function resolveFund(
+  query: string,
+  limit: number,
+  args: HeadlessPaneLoadArgs,
+  ctx: HeadlessPaneContext,
+  dependencies: ThirteenFHeadlessDependencies,
+): Promise<{ cik: string; name: string }> {
+  if (!query) throw new Error("13F holdings and filings require a fund name or CIK.");
+  if (isCikQuery(query)) return { cik: normalizeCik(query), name: query };
+  const result = await dependencies.loadBrowser("funds", query, Math.min(limit, 25), args, ctx);
+  const exact = result.rows.find((row) => row.name.toLocaleLowerCase() === query.toLocaleLowerCase());
+  const fund = exact ?? result.rows[0];
+  if (!fund) throw new Error(`No 13F fund found for "${query}".`);
+  return { cik: fund.cik, name: fund.name };
+}
+
+export function createThirteenFHeadless(
+  dependencies: ThirteenFHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "free-text",
+      placeholder: "fund, ticker, or CIK",
+      description: "Optional fund name, ticker, CIK, or latest keyword.",
+      optional: true,
+    },
+    options: [
+      {
+        key: "view",
+        description: "Fund browser mode or detail tab.",
+        type: "enum",
+        values: [
+          { value: "auto" },
+          { value: "performance" },
+          { value: "funds" },
+          { value: "by-ticker", aliases: ["ticker", "byTicker"] },
+          { value: "latest" },
+          { value: "holdings" },
+          { value: "filings" },
+        ],
+        defaultValue: "auto",
+      },
+      {
+        key: "limit",
+        aliases: ["count", "rows"],
+        description: "Maximum rows.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    describe: (args) => `13F Funds | ${String(args.options.view)}`,
+    async load(args, ctx) {
+      const query = typeof args.argument === "string" ? args.argument.trim() : "";
+      const requestedView = String(args.options.view) as HeadlessThirteenFView;
+      const view = requestedView === "auto" && isCikQuery(query) ? "holdings" : requestedView;
+      const limit = Number(args.options.limit);
+
+      if (view === "holdings" || view === "filings") {
+        const fund = await resolveFund(query, limit, args, ctx, dependencies);
+        const detail = await dependencies.loadDetail(fund.cik, fund.name, args, ctx);
+        if (view === "filings") {
+          const rows = sortTimelineRows(buildTimelineRows(detail.forms), DEFAULT_TIMELINE_SORT)
+            .slice(0, limit)
+            .map((row) => ({ ...row }));
+          return {
+            columns: FILING_COLUMNS,
+            rows,
+            metadata: {
+              view,
+              cik: detail.cik,
+              fund: detail.name,
+              latestPeriod: detail.latestForm?.periodOfReport ?? null,
+            },
+          };
+        }
+        const rows = sortHoldingRows(
+          buildFundHoldingRows(detail).filter((row) => row.value != null),
+          DEFAULT_HOLDING_SORT,
+        )
+          .slice(0, limit)
+          .map((row) => ({
+            ...row,
+            type: positionType(row),
+            actionLabel: actionLabel(row.action),
+          }));
+        return {
+          columns: HOLDING_COLUMNS,
+          rows,
+          metadata: {
+            view,
+            cik: detail.cik,
+            fund: detail.name,
+            latestPeriod: detail.latestForm?.periodOfReport ?? null,
+            previousPeriod: detail.previousForm?.periodOfReport ?? null,
+          },
+        };
+      }
+
+      const tab = browserTab(view, query);
+      const result = await dependencies.loadBrowser(tab, query, limit, args, ctx);
+      return {
+        columns: BROWSER_COLUMNS,
+        rows: sortBrowserRows(result.rows, DEFAULT_BROWSER_SORT)
+          .slice(0, limit)
+          .map((row) => ({ ...row })),
+        ...(result.warning ? { errors: [result.warning] } : {}),
+        metadata: {
+          view: tab,
+          query: query || null,
+          period: result.period ?? null,
+          quarter: result.quarter ?? null,
+          hasMore: result.hasMore ?? false,
+        },
+      };
+    },
+  };
+}
+
+export const thirteenFHeadless = createThirteenFHeadless();

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

@@ -11,6 +11,9 @@ import {
   attachThirteenFApiPersistence,
   resetThirteenFApiPersistence,
 } from "./api";
+import { thirteenFHeadless } from "./headless";
+
+export { thirteenFHeadless } from "./headless";
 
 function queryFromOptions(options?: PaneTemplateCreateOptions): string {
   return (options?.arg ?? options?.values?.query ?? "").trim();
@@ -55,6 +58,7 @@ export const thirteenFModule: PluginModule = {
         argKind: "text",
         argOptional: true,
       },
+      headless: thirteenFHeadless,
       createInstance(_context: PaneTemplateContext, options?: PaneTemplateCreateOptions) {
         const query = queryFromOptions(options);
         const browserMode = inferBrowserTabFromQuery(query);

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

@@ -615,6 +615,19 @@ export function selectedIndexById<T extends { id: string }>(rows: T[], selectedI
   return index >= 0 ? index : rows.length > 0 ? 0 : -1;
 }
 
+export function positionType(row: {
+  putCall: string;
+  titleOfClass: string;
+  shareType: string;
+}): string {
+  const putCall = row.putCall.trim().toUpperCase();
+  if (putCall === "PUT" || putCall === "CALL") return putCall;
+  const title = row.titleOfClass.trim().toUpperCase();
+  if (title) return title;
+  const shareType = row.shareType.trim().toUpperCase();
+  return shareType || "--";
+}
+
 export function isCikQuery(query: string): boolean {
   return CIK_RE.test(query.trim());
 }

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

@@ -12,6 +12,7 @@ import {
   formatShares,
   formatShortDate,
 } from "./format";
+import { positionType } from "./model";
 import type {
   FilingPositionColumn,
   FilingPositionRow,
@@ -82,7 +83,7 @@ export function renderHoldingCell(
         attributes: TextAttributes.BOLD,
       };
     case "type":
-      return { text: formatPositionType(row), color: selectedColor ?? colors.textDim };
+      return { text: positionType(row), color: selectedColor ?? colors.textDim };
     case "issuer":
       return { text: row.issuer, color: selectedColor ?? colors.text };
     case "value":
@@ -136,7 +137,7 @@ export function renderFilingPositionCell(
         attributes: TextAttributes.BOLD,
       };
     case "type":
-      return { text: formatPositionType(row), color: selectedColor ?? colors.textDim };
+      return { text: positionType(row), color: selectedColor ?? colors.textDim };
     case "issuer":
       return { text: row.issuer, color: selectedColor ?? colors.text };
     case "value":
@@ -185,19 +186,6 @@ export function renderTimelineCell(
   }
 }
 
-function formatPositionType(row: {
-  putCall: string;
-  titleOfClass: string;
-  shareType: string;
-}): string {
-  const putCall = row.putCall.trim().toUpperCase();
-  if (putCall === "PUT" || putCall === "CALL") return putCall;
-  const title = row.titleOfClass.trim().toUpperCase();
-  if (title) return title;
-  const shareType = row.shareType.trim().toUpperCase();
-  return shareType || "--";
-}
-
 function actionColor(action: FundHoldingRow["action"]): string {
   switch (action) {
     case "new":

package/src/plugins/prediction-markets/headless.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../types/plugin";
+import {
+  createPredictionMarketsHeadless,
+  type PredictionMarketsHeadlessDependencies,
+} from "./headless";
+import type { PredictionMarketSummary, PredictionVenue } from "./types";
+
+function market(
+  key: string,
+  venue: PredictionVenue,
+  title: string,
+  volume24h: number,
+  endsAt: string,
+): PredictionMarketSummary {
+  return {
+    key,
+    venue,
+    marketId: `${key}-id`,
+    title,
+    marketLabel: "Yes",
+    eventLabel: title,
+    category: title.includes("Fed") ? "Economics" : "Politics",
+    tags: [],
+    status: "open",
+    url: `https://example.com/${key}`,
+    description: `${title} market`,
+    endsAt,
+    updatedAt: "2026-09-04T20:00:00.000Z",
+    yesPrice: 0.62,
+    noPrice: 0.38,
+    yesBid: 0.61,
+    yesAsk: 0.63,
+    noBid: 0.37,
+    noAsk: 0.39,
+    spread: 0.02,
+    lastTradePrice: 0.62,
+    volume24h,
+    volume24hUnit: "usd",
+    totalVolume: volume24h * 10,
+    totalVolumeUnit: "usd",
+    openInterest: volume24h / 2,
+    openInterestUnit: venue === "kalshi" ? "contracts" : "usd",
+    liquidity: volume24h / 4,
+    liquidityUnit: "usd",
+  };
+}
+
+const markets = [
+  market("poly-fed", "polymarket", "Will the Fed cut rates?", 2_000_000, "2026-10-01T00:00:00.000Z"),
+  market("kalshi-election", "kalshi", "Will the incumbent win?", 500_000, "2026-11-01T00:00:00.000Z"),
+];
+
+function args(
+  argument: string | null,
+  options: Record<string, string | number | boolean>,
+): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: argument ?? "",
+    argument,
+    symbols: [],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+function dependencies(seen: string[]): PredictionMarketsHeadlessDependencies {
+  return {
+    loadPolymarket: async (query) => {
+      seen.push(`polymarket:${query}`);
+      return markets.filter((entry) => entry.venue === "polymarket");
+    },
+    loadKalshi: async (query) => {
+      seen.push(`kalshi:${query}`);
+      return markets.filter((entry) => entry.venue === "kalshi");
+    },
+    now: () => new Date("2026-09-04T21:00:00.000Z"),
+  };
+}
+
+describe("prediction markets headless", () => {
+  test("projects venue data through the pane's shared row ordering", async () => {
+    const definition = createPredictionMarketsHeadless(dependencies([]));
+
+    const result = await definition.load(args(null, {
+      venue: "all",
+      category: "all",
+      tab: "top",
+      limit: 1,
+    }), context);
+
+    expect(result.rows).toEqual([
+      expect.objectContaining({
+        key: "poly-fed",
+        venue: "polymarket",
+        yesProbability: 0.62,
+        volume24h: 2_000_000,
+      }),
+    ]);
+    expect(result.metadata).toMatchObject({ total: 2, returned: 1, truncated: true });
+  });
+
+  test("uses the shortcut venue prefix without querying the other venue", async () => {
+    const seen: string[] = [];
+    const definition = createPredictionMarketsHeadless(dependencies(seen));
+
+    const result = await definition.load(args("polymarket:fed", {
+      venue: "all",
+      category: "macro",
+      tab: "ending",
+      limit: 20,
+    }), context);
+
+    expect(seen).toEqual(["polymarket:fed"]);
+    expect(result.rows.map((row) => row.key)).toEqual(["poly-fed"]);
+    expect(result.metadata).toMatchObject({ venue: "polymarket", query: "fed" });
+  });
+});