gloomberb 0.12.0 → 0.13.2

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

@@ -0,0 +1,69 @@
+import type {
+  HeadlessPaneColumn,
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import type { SecFilingItem } from "../../../types/data-provider";
+import { loadSecFilings } from "./client";
+import { buildSecFilingRows } from "./model";
+
+const SEC_COLUMNS: HeadlessPaneColumn[] = [
+  {
+    key: "filedAt",
+    header: "Filed",
+    format: (value) => typeof value === "string" ? value.slice(0, 10) : "-",
+  },
+  { key: "form", header: "Form" },
+  { key: "filing", header: "Filing" },
+  { key: "items", header: "Items" },
+  { key: "accessionNumber", header: "Accession" },
+];
+
+export interface SecHeadlessDependencies {
+  loadFilings(
+    symbol: string,
+    limit: number,
+    args: HeadlessPaneLoadArgs,
+    ctx: HeadlessPaneContext,
+  ): Promise<SecFilingItem[]>;
+}
+
+const defaultDependencies: SecHeadlessDependencies = {
+  loadFilings: (symbol, limit, _args, ctx) => loadSecFilings(ctx.marketData, symbol, limit),
+};
+
+export function createSecHeadless(
+  dependencies: SecHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "US equity ticker.",
+    },
+    options: [{
+      key: "limit",
+      aliases: ["count", "rows"],
+      description: "Maximum recent filings.",
+      type: "integer",
+      defaultValue: 50,
+      minimum: 1,
+      maximum: 200,
+    }],
+    columns: SEC_COLUMNS,
+    describe: (args) => `SEC Filings | ${args.symbols[0]}`,
+    async load(args, ctx) {
+      const symbol = args.symbols[0]!;
+      const limit = Number(args.options.limit);
+      const filings = await dependencies.loadFilings(symbol, limit, args, ctx);
+      return {
+        rows: buildSecFilingRows(filings).slice(0, limit),
+        metadata: { symbol, returned: Math.min(filings.length, limit) },
+      };
+    },
+  };
+}
+
+export const secHeadless = createSecHeadless();

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

@@ -27,54 +27,19 @@ import {
   useSecFilingContentCache,
 } from "./filing-content";
 import { usePaneStatusLinkFooter } from "../shared/pane-footer";
+import { secHeadless } from "./headless";
+import {
+  getFilingDisplayTitle,
+  getFormDescription,
+  getMeaningfulPrimaryDescription,
+} from "./model";
+
+export { secHeadless } from "./headless";
 
 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 {
-  const trimmed = form.trim();
-  return /^\d+(?:\/[A-Z])?$/i.test(trimmed)
-    ? `FORM ${trimmed}`
-    : trimmed;
-}
-
-function normalizeComparableText(value: string): string {
-  return value
-    .toUpperCase()
-    .replace(/\bFORM\b/g, "")
-    .replace(/[^A-Z0-9]+/g, "");
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function stripRedundantFormPrefix(form: string, description: string): string {
-  const pattern = escapeRegExp(form.trim()).replace(/\s+/g, "\\s+");
-  return description
-    .trim()
-    .replace(new RegExp(`^(?:FORM\\s+)?${pattern}(?:\\s*[:|-]\\s*|\\s+)`, "i"), "")
-    .trim();
-}
-
-function getMeaningfulPrimaryDescription(filing: SecFilingItem): string | undefined {
-  const description = filing.primaryDocDescription?.trim();
-  if (!description) return undefined;
-  if (normalizeComparableText(description) === normalizeComparableText(filing.form)) return undefined;
-
-  const stripped = stripRedundantFormPrefix(filing.form, description);
-  if (!stripped) return undefined;
-  if (normalizeComparableText(stripped) === normalizeComparableText(filing.form)) return undefined;
-  return stripped;
-}
-
-function getFilingDisplayTitle(filing: SecFilingItem): string {
-  const description = getMeaningfulPrimaryDescription(filing);
-  const formLabel = getDisplayFormLabel(filing.form);
-  return description ? `${formLabel} | ${description}` : formLabel;
-}
-
 function formatFiledAt(filing: SecFilingItem): string {
   return formatFilingMetaDate(filing.filingDate);
 }
@@ -161,29 +126,6 @@ function buildForm4Detail(content: string | null, filing: SecFilingItem): string
   return lines.join("\n");
 }
 
-function getFormDescription(form: string): string {
-  const f = form.trim().toUpperCase();
-  switch (f) {
-    case "10-K": return "Annual Report";
-    case "10-K/A": return "Annual Report (Amended)";
-    case "10-Q": return "Quarterly Report";
-    case "10-Q/A": return "Quarterly Report (Amended)";
-    case "8-K": return "Current Report";
-    case "8-K/A": return "Current Report (Amended)";
-    case "4": return "Insider Transaction";
-    case "3": return "Initial Insider Ownership";
-    case "5": return "Annual Insider Ownership";
-    case "SC 13G": return "Beneficial Ownership (Passive)";
-    case "SC 13G/A": return "Beneficial Ownership (Amended)";
-    case "SC 13D": return "Beneficial Ownership (Active)";
-    case "SC 13D/A": return "Beneficial Ownership (Amended)";
-    case "DEF 14A": return "Proxy Statement";
-    case "S-1": return "Registration Statement";
-    case "20-F": return "Annual Report (Foreign)";
-    default: return "";
-  }
-}
-
 function toFeedItems(
   filings: SecFilingItem[],
   selectedAccessionNumber: string | undefined,
@@ -360,15 +302,18 @@ export const secModule: PluginModule = {
   ],
 
   paneTemplates: [
-    createTickerSurfacePaneTemplate({
-      id: "sec-pane",
-      paneId: "sec",
-      label: "SEC",
-      description: "Recent SEC filings for the selected ticker.",
-      keywords: ["sec", "filings", "10-k", "10-q", "8-k"],
-      shortcut: "SEC",
-      canCreate: (_context, options) => !options?.ticker || isUsEquityTicker(options.ticker),
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "sec-pane",
+        paneId: "sec",
+        label: "SEC",
+        description: "Recent SEC filings for the selected ticker.",
+        keywords: ["sec", "filings", "10-k", "10-q", "8-k"],
+        shortcut: "SEC",
+        canCreate: (_context, options) => !options?.ticker || isUsEquityTicker(options.ticker),
+      }),
+      headless: secHeadless,
+    },
   ],
 
   setup(ctx) {

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

@@ -0,0 +1,89 @@
+import type { SecFilingItem } from "../../../types/data-provider";
+
+export function getDisplayFormLabel(form: string): string {
+  const trimmed = form.trim();
+  return /^\d+(?:\/[A-Z])?$/i.test(trimmed)
+    ? `FORM ${trimmed}`
+    : trimmed;
+}
+
+function normalizeComparableText(value: string): string {
+  return value
+    .toUpperCase()
+    .replace(/\bFORM\b/g, "")
+    .replace(/[^A-Z0-9]+/g, "");
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function stripRedundantFormPrefix(form: string, description: string): string {
+  const pattern = escapeRegExp(form.trim()).replace(/\s+/g, "\\s+");
+  return description
+    .trim()
+    .replace(new RegExp(`^(?:FORM\\s+)?${pattern}(?:\\s*[:|-]\\s*|\\s+)`, "i"), "")
+    .trim();
+}
+
+export function getMeaningfulPrimaryDescription(filing: SecFilingItem): string | undefined {
+  const description = filing.primaryDocDescription?.trim();
+  if (!description) return undefined;
+  if (normalizeComparableText(description) === normalizeComparableText(filing.form)) return undefined;
+
+  const stripped = stripRedundantFormPrefix(filing.form, description);
+  if (!stripped) return undefined;
+  if (normalizeComparableText(stripped) === normalizeComparableText(filing.form)) return undefined;
+  return stripped;
+}
+
+export function getFilingDisplayTitle(filing: SecFilingItem): string {
+  const description = getMeaningfulPrimaryDescription(filing);
+  const formLabel = getDisplayFormLabel(filing.form);
+  return description ? `${formLabel} | ${description}` : formLabel;
+}
+
+export function getFormDescription(form: string): string {
+  const normalized = form.trim().toUpperCase();
+  switch (normalized) {
+    case "10-K": return "Annual Report";
+    case "10-K/A": return "Annual Report (Amended)";
+    case "10-Q": return "Quarterly Report";
+    case "10-Q/A": return "Quarterly Report (Amended)";
+    case "8-K": return "Current Report";
+    case "8-K/A": return "Current Report (Amended)";
+    case "4": return "Insider Transaction";
+    case "3": return "Initial Insider Ownership";
+    case "5": return "Annual Insider Ownership";
+    case "SC 13G": return "Beneficial Ownership (Passive)";
+    case "SC 13G/A": return "Beneficial Ownership (Amended)";
+    case "SC 13D": return "Beneficial Ownership (Active)";
+    case "SC 13D/A": return "Beneficial Ownership (Amended)";
+    case "DEF 14A": return "Proxy Statement";
+    case "S-1": return "Registration Statement";
+    case "20-F": return "Annual Report (Foreign)";
+    default: return "";
+  }
+}
+
+export function buildSecFilingRows(filings: readonly SecFilingItem[]) {
+  return filings.map((filing) => {
+    const displayTitle = getFilingDisplayTitle(filing);
+    const formDescription = getFormDescription(filing.form);
+    return {
+      filedAt: filing.filingDate instanceof Date
+        ? filing.filingDate.toISOString()
+        : String(filing.filingDate),
+      acceptedAt: filing.acceptedAt instanceof Date
+        ? filing.acceptedAt.toISOString()
+        : filing.acceptedAt ? String(filing.acceptedAt) : null,
+      form: filing.form,
+      filing: formDescription ? `${displayTitle} | ${formDescription}` : displayTitle,
+      items: filing.items ?? null,
+      accessionNumber: filing.accessionNumber,
+      primaryDocument: filing.primaryDocument ?? null,
+      cik: filing.cik,
+      url: filing.filingUrl,
+    };
+  });
+}

package/src/plugins/builtin/sectors/client.ts

@@ -0,0 +1,54 @@
+import type { DataProvider } from "../../../types/data-provider";
+import type { PricePoint, Quote } from "../../../types/financials";
+import type { SectorDef } from "./sector-data";
+import {
+  computeTrailingReturn,
+  latestHistoryClose,
+  ONE_MONTH_DAYS,
+  ONE_YEAR_DAYS,
+  type SectorRow,
+} from "./sector-model";
+
+export interface SectorRowOutcome {
+  etf: string;
+  row: Partial<SectorRow> | null;
+}
+
+export async function loadSectorRows(
+  sectors: readonly SectorDef[],
+  provider: DataProvider,
+): Promise<SectorRowOutcome[]> {
+  const quotes = new Map<string, Quote | null>();
+  if (provider.getQuotesBatch) {
+    const results = await provider.getQuotesBatch(
+      sectors.map((sector) => ({ symbol: sector.etf, exchange: "" })),
+    ).catch(() => []);
+    for (const result of results) quotes.set(result.target.symbol, result.quote ?? null);
+  } else {
+    await Promise.all(sectors.map(async (sector) => {
+      try {
+        quotes.set(sector.etf, await provider.getQuote(sector.etf, ""));
+      } catch {
+        quotes.set(sector.etf, null);
+      }
+    }));
+  }
+
+  return Promise.all(sectors.map(async (sector) => {
+    const history: PricePoint[] = await provider.getPriceHistory(sector.etf, "", "1Y")
+      .catch(() => []);
+    const quote = quotes.get(sector.etf) ?? null;
+    if (!quote && history.length === 0) return { etf: sector.etf, row: null };
+    const price = quote?.price ?? latestHistoryClose(history);
+    return {
+      etf: sector.etf,
+      row: {
+        price,
+        changePercent: quote?.changePercent ?? null,
+        return1M: computeTrailingReturn(history, ONE_MONTH_DAYS, price),
+        return1Y: computeTrailingReturn(history, ONE_YEAR_DAYS, price),
+        currency: quote?.currency ?? "USD",
+      },
+    };
+  }));
+}

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

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createSectorsHeadless } from "./headless";
+
+function args(collection: string): HeadlessPaneLoadArgs {
+  return { rawArgument: "", argument: null, symbols: [], options: { collection } };
+}
+
+describe("sectors headless model", () => {
+  test("changes the loaded ETF universe with the collection option", async () => {
+    const requested: string[][] = [];
+    const headless = createSectorsHeadless({
+      load: async (_args, definitions) => {
+        requested.push(definitions.map(({ etf }) => etf));
+        return definitions.map((definition, index) => ({
+          etf: definition.etf,
+          row: { price: 100, changePercent: index, return1M: index + 1, return1Y: index + 2, currency: "USD" },
+        }));
+      },
+    });
+
+    const sectors = await headless.load(args("sectors"), {} as HeadlessPaneContext);
+    const industries = await headless.load(args("industries"), {} as HeadlessPaneContext);
+    expect(sectors.rows.some((row) => row.etf === "XLK")).toBe(true);
+    expect(industries.rows.some((row) => row.etf === "SMH")).toBe(true);
+    expect(requested[0]).not.toEqual(requested[1]);
+  });
+});

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

@@ -0,0 +1,80 @@
+import type { DataProvider } from "../../../types/data-provider";
+import type {
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { formatCurrency, formatPercentRaw } from "../../../utils/format";
+import { loadSectorRows, type SectorRowOutcome } from "./client";
+import { getSectorCollection, type SectorCollectionId, type SectorDef } from "./sector-data";
+import { DEFAULT_SORT_PREFERENCE, sortRows, type SectorRow } from "./sector-model";
+
+const COLUMNS = [
+  { key: "name", header: "Sector" },
+  { key: "etf", header: "ETF" },
+  { key: "price", header: "Last", align: "right" as const, format: (value: unknown, row: Record<string, unknown>) => value == null ? "-" : formatCurrency(Number(value), String(row.currency)) },
+  { key: "changePercent", header: "1D", align: "right" as const, format: (value: unknown) => value == null ? "-" : formatPercentRaw(Number(value)) },
+  { key: "return1M", header: "1M", align: "right" as const, format: (value: unknown) => value == null ? "-" : formatPercentRaw(Number(value)) },
+  { key: "return1Y", header: "1Y", align: "right" as const, format: (value: unknown) => value == null ? "-" : formatPercentRaw(Number(value)) },
+];
+
+export function projectSectorRows(
+  definitions: readonly SectorDef[],
+  outcomes: readonly SectorRowOutcome[],
+): SectorRow[] {
+  const byEtf = new Map(outcomes.map((outcome) => [outcome.etf, outcome.row]));
+  return sortRows(definitions.map((definition) => ({
+    ...definition,
+    price: byEtf.get(definition.etf)?.price ?? null,
+    changePercent: byEtf.get(definition.etf)?.changePercent ?? null,
+    return1M: byEtf.get(definition.etf)?.return1M ?? null,
+    return1Y: byEtf.get(definition.etf)?.return1Y ?? null,
+    currency: byEtf.get(definition.etf)?.currency ?? "USD",
+    loading: false,
+  })), DEFAULT_SORT_PREFERENCE);
+}
+
+export interface SectorsHeadlessDependencies {
+  load(
+    args: HeadlessPaneLoadArgs,
+    definitions: readonly SectorDef[],
+    provider: DataProvider,
+  ): Promise<SectorRowOutcome[]>;
+}
+
+const defaultDependencies: SectorsHeadlessDependencies = {
+  load: (_args, definitions, provider) => loadSectorRows(definitions, provider),
+};
+
+export function createSectorsHeadless(
+  dependencies: SectorsHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: { kind: "none" },
+    options: [{
+      key: "collection",
+      description: "Sector or industry ETF collection.",
+      type: "enum",
+      values: [{ value: "sectors" }, { value: "industries" }],
+      defaultValue: "sectors",
+    }],
+    columns: COLUMNS,
+    describe: (args) => `Sector Performance | ${String(args.options.collection)}`,
+    async load(args, ctx) {
+      const collectionId = args.options.collection as SectorCollectionId;
+      const definitions = getSectorCollection(collectionId).items;
+      const outcomes = await dependencies.load(args, definitions, ctx.marketData);
+      const rows = projectSectorRows(definitions, outcomes);
+      return {
+        rows: rows.map((row) => ({ ...row })),
+        metadata: {
+          collection: collectionId,
+          available: outcomes.filter((outcome) => outcome.row).length,
+          requested: definitions.length,
+        },
+      };
+    },
+  };
+}
+
+export const sectorsHeadless = createSectorsHeadless();

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

@@ -3,7 +3,6 @@ import { Box } from "../../../ui";
 import { DataTableView, Tabs, usePaneFooter, type DataTableCell, type DataTableKeyEvent, type PaneFooterSegment } from "../../../components";
 import type { PaneProps } from "../../../types/plugin";
 import type { PluginModule } from "../plugin-module";
-import type { PricePoint, Quote } from "../../../types/financials";
 import { usePaneSettingValue } from "../../../state/app/context";
 import { colors, priceColor } from "../../../theme/colors";
 import { formatCurrency, formatPercentRaw } from "../../../utils/format";
@@ -22,11 +21,7 @@ import {
   DEFAULT_SORT_PREFERENCE,
   INITIAL_REFRESH_BY_COLLECTION,
   INITIAL_ROWS_BY_COLLECTION,
-  ONE_MONTH_DAYS,
-  ONE_YEAR_DAYS,
   buildSectorColumns,
-  computeTrailingReturn,
-  latestHistoryClose,
   nextSortPreference,
   normalizeRowsForCollection,
   sortRows,
@@ -37,6 +32,10 @@ import {
   type SectorRowsByCollection,
   type SectorSortPreference,
 } from "./sector-model";
+import { loadSectorRows } from "./client";
+import { sectorsHeadless } from "./headless";
+
+export { sectorsHeadless } from "./headless";
 
 /** Stable identity: a fresh literal here would refetch the board every render. */
 const NO_SAVED_ETFS: string[] = [];
@@ -105,52 +104,7 @@ function SectorPerformancePane({ focused, width, height }: PaneProps) {
       rows.map((row) => ({ ...row, loading: true }))
     )));
 
-    const loadQuotes = async (): Promise<Map<string, Quote | null>> => {
-      const quotes = new Map<string, Quote | null>();
-      if (dataProvider.getQuotesBatch) {
-        // A failed batch leaves every quote missing, which the row outcome below
-        // reports as unavailable instead of stamping the pane as fresh.
-        const results = await dataProvider.getQuotesBatch(
-          sectorDefs.map((sector) => ({ symbol: sector.etf, exchange: "" })),
-        ).catch(() => []);
-        for (const result of results) {
-          quotes.set(result.target.symbol, result.quote ?? null);
-        }
-        return quotes;
-      }
-
-      await Promise.all(sectorDefs.map(async (sector) => {
-        try {
-          quotes.set(sector.etf, await dataProvider.getQuote(sector.etf, ""));
-        } catch {
-          quotes.set(sector.etf, null);
-        }
-      }));
-      return quotes;
-    };
-
-    const loadRows = async (): Promise<Array<{ etf: string; row: Partial<SectorRow> | null }>> => {
-      const quotesByEtf = await loadQuotes();
-      return Promise.all(sectorDefs.map(async (sector) => {
-        const history: PricePoint[] = await dataProvider.getPriceHistory(sector.etf, "", "1Y")
-          .catch(() => []);
-        const quote = quotesByEtf.get(sector.etf) ?? null;
-        if (!quote && history.length === 0) return { etf: sector.etf, row: null };
-        const price = quote?.price ?? latestHistoryClose(history);
-        return {
-          etf: sector.etf,
-          row: {
-            price,
-            changePercent: quote?.changePercent ?? null,
-            return1M: computeTrailingReturn(history, ONE_MONTH_DAYS, price),
-            return1Y: computeTrailingReturn(history, ONE_YEAR_DAYS, price),
-            currency: quote?.currency ?? "USD",
-          },
-        };
-      }));
-    };
-
-    loadRows().then((outcomes) => {
+    loadSectorRows(sectorDefs, dataProvider).then((outcomes) => {
       if (fetchGenRef.current !== gen) return;
       const loadedByEtf = new Map(outcomes.map((outcome) => [outcome.etf, outcome.row]));
       setRowsByCollection((prev) => updateRowsForCollection(prev, collectionId, sectorDefs, (rows) => (
@@ -365,6 +319,7 @@ export const sectorsModule: PluginModule = {
       description: "S&P 500 sector and industry performance sorted by daily change.",
       keywords: ["sector", "sectors", "industry", "semis", "defense", "food", "leisure", "etf", "xlk", "xlv", "xlf", "performance", "spdr"],
       shortcut: { prefix: "BI" },
+      headless: sectorsHeadless,
     },
   ],
 };

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

@@ -1,5 +1,7 @@
 import { useCallback, useEffect, useMemo } from "react";
 import { apiClient } from "../../../api-client";
+import { recordResearchActivity, researchUpgradeUrl } from "../../../api-client/research-activity";
+import { getCurrentPluginTarget } from "../../current-target";
 import type { PaneFooterSegment } from "../../../components";
 import { tf } from "../../../i18n";
 import { useAppLanguage } from "../../../i18n/react";
@@ -25,10 +27,12 @@ let cloudUpgradeOpener: (() => void) | null = null;
  * already hold. Both URLs are account-bound, so no session handoff is needed.
  */
 export async function resolveCloudUpgradeUrl(): Promise<string> {
-  if (!apiClient.isSignedIn()) return CLOUD_UPGRADE_URL;
+  recordResearchActivity("upgrade_intent");
+  const returnTo = getCurrentPluginTarget() === "web" ? window.location.href : undefined;
+  if (!apiClient.isSignedIn() || !apiClient.getCurrentUser()?.emailVerified) return researchUpgradeUrl(returnTo);
   const { url } = resolvePlanAccess(apiClient.getCurrentUser()).hasProAccess
     ? await apiClient.createBillingPortal()
-    : await apiClient.createCloudCheckout();
+    : await apiClient.createCloudCheckout(returnTo);
   return url;
 }
 
@@ -142,8 +146,8 @@ export function useCloudAccessFooter({
       onPress: openUpgrade,
       parts: [{
         text: shortcutScope
-          ? tf("{delay} delayed · u upgrade", { delay: delayLabel })
-          : tf("{delay} delayed · upgrade", { delay: delayLabel }),
+          ? tf("{delay} delayed · u try Pro live", { delay: delayLabel })
+          : tf("{delay} delayed · try Pro live", { delay: delayLabel }),
         tone: "warning",
       }],
     };

package/src/plugins/builtin/short-interest/client.ts

@@ -110,9 +110,12 @@ function normalizeCloudRecords(payload: CloudShortInterestPayload): ShortInteres
  * Yahoo carries the current and prior settlement plus percent of float, so it
  * stays as the fallback when the cloud route is unavailable.
  */
-export async function fetchShortInterest(symbol: string): Promise<ShortInterestRecord[]> {
+export async function fetchShortInterest(
+  symbol: string,
+  cloudClient: Pick<typeof apiClient, "getCloudShortInterest"> = apiClient,
+): Promise<ShortInterestRecord[]> {
   try {
-    const response = await apiClient.getCloudShortInterest(symbol);
+    const response = await cloudClient.getCloudShortInterest(symbol);
     const records = response.status === "success" && response.data
       ? normalizeCloudRecords(response.data)
       : [];

package/src/plugins/builtin/short-interest/headless.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+import { CloudDataApi } from "../../../api-client/data";
+import type { CloudMarketResponse, CloudShortInterestPayload } from "../../../api-client/types";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { fetchShortInterest } from "./client";
+import { createShortInterestHeadless } from "./headless";
+
+const records = [
+  {
+    settlementDate: new Date("2026-08-15T00:00:00.000Z"),
+    sharesShort: 12_000_000,
+    shortRatio: 2.5,
+    averageDailyVolume: 4_800_000,
+    shortPercentFloat: 3.2,
+  },
+  {
+    settlementDate: new Date("2026-08-31T00:00:00.000Z"),
+    sharesShort: 15_000_000,
+    shortRatio: 3,
+    averageDailyVolume: 5_000_000,
+    shortPercentFloat: 4.1,
+  },
+];
+
+function context(): HeadlessPaneContext {
+  return {
+    marketData: createTestDataProvider(),
+    apiClient: {} as HeadlessPaneContext["apiClient"],
+    config: createDefaultConfig("/tmp/gloomberb-headless-short-interest"),
+    signal: new AbortController().signal,
+  };
+}
+
+function args(overrides: Partial<HeadlessPaneLoadArgs["options"]> = {}): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AMD",
+    argument: "AMD",
+    symbols: ["AMD"],
+    options: { order: "newest", limit: 24, ...overrides },
+  };
+}
+
+describe("short interest client", () => {
+  test("uses the served market route for FINRA history", async () => {
+    const paths: string[] = [];
+    const dataApi = new CloudDataApi(async <T>(path: string): Promise<T> => {
+      paths.push(path);
+      return {
+        status: "success",
+        data: {
+          symbol: "AAPL",
+          issueName: "Apple Inc.",
+          points: [{
+            settlementDate: "2026-08-31",
+            sharesShort: 15_000_000,
+            previousSharesShort: 12_000_000,
+            averageDailyVolume: 5_000_000,
+            daysToCover: 3,
+            changePercent: 25,
+            revised: false,
+          }],
+        },
+      } as CloudMarketResponse<CloudShortInterestPayload> as T;
+    });
+
+    const result = await fetchShortInterest("aapl", dataApi);
+
+    expect(paths).toEqual(["/market/short-interest?symbol=AAPL"]);
+    expect(result[0]).toMatchObject({ sharesShort: 15_000_000, shortRatio: 3 });
+  });
+});
+
+describe("short interest headless model", () => {
+  test("projects raw settlement values and applies order and limit", async () => {
+    const headless = createShortInterestHeadless({
+      loadRecords: async () => records,
+    });
+
+    const newest = await headless.load(args({ limit: 1 }), context());
+    expect(newest.rows).toEqual([{
+      settlementDate: "2026-08-31",
+      sharesShort: 15_000_000,
+      daysToCover: 3,
+      averageDailyVolume: 5_000_000,
+      shortPercentFloat: 4.1,
+    }]);
+
+    const oldest = await headless.load(args({ order: "oldest", limit: 1 }), context());
+    expect(oldest.rows[0]).toMatchObject({
+      settlementDate: "2026-08-15",
+      sharesShort: 12_000_000,
+    });
+  });
+});