gloomberb 0.12.0 → 0.13.2

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/builtin/ticker-detail/pane.tsx

@@ -1,4 +1,6 @@
 import { Box } from "../../../ui";
+import { getCurrentPluginTarget } from "../../current-target";
+import { recordResearchActivity } from "../../../api-client/research-activity";
 import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import type { PaneProps, TickerResearchTabDef } from "../../../types/plugin";
 import { t, tf } from "../../../i18n";
@@ -98,7 +100,19 @@ export function TickerResearchPane({ focused, width, height }: PaneProps) {
     TICKER_RESEARCH_TAB_COMMIT_DELAY_MS,
     { commitPendingOnUnmount: true },
   );
+  useEffect(() => {
+    if (!focused || !ticker || getCurrentPluginTarget() !== "web") return;
+    const url = new URL(window.location.href);
+    url.searchParams.set("ticker", ticker.metadata.ticker);
+    url.searchParams.set("tab", activeTabId);
+    window.history.replaceState(window.history.state, "", url.href);
+  }, [focused, ticker?.metadata.ticker, activeTabId]);
   const [pluginCaptured, setPluginCaptured] = useState(false);
+  useEffect(() => {
+    if (focused && Number.isFinite(financials?.quote?.price) && (financials?.quote?.price ?? 0) > 0) {
+      recordResearchActivity("research_viewed", "research");
+    }
+  }, [focused, financials?.quote?.price]);
   const [mountedTabIds, setMountedTabIds] = useState<Set<string>>(() => new Set());
   const paneSettings = getTickerResearchPaneSettings(paneInstance?.settings);
   const hasOptionsChain = !!resolveOptionsTarget(ticker)?.effectiveTicker;

package/src/plugins/builtin/treasury-auctions/headless.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createTreasuryAuctionsHeadless } from "./headless";
+import type { TreasuryAuction } from "./types";
+
+const bill: TreasuryAuction = {
+  id: "bill", cusip: "A", secType: "Bill", securityTerm: "4-Week", auctionDate: "2026-09-03",
+  highInvestmentRate: 4.1, highYield: null, avgMedYield: null, highPrice: null, lowPrice: null,
+  avgMedPrice: null, bidToCoverRatio: 2.8, competitiveAccepted: 80, indirectAccepted: 20,
+  primaryDealerAccepted: 10, totalAccepted: 100, offeringAmount: 100,
+};
+const bond: TreasuryAuction = { ...bill, id: "bond", cusip: "B", secType: "Bond", securityTerm: "30-Year" };
+
+function args(filter: string): HeadlessPaneLoadArgs {
+  return { rawArgument: "", argument: null, symbols: [], options: { historyDays: "90", filter } };
+}
+
+describe("treasury auctions headless model", () => {
+  test("applies history and security filters to derived auction rows", async () => {
+    const requested: number[] = [];
+    const headless = createTreasuryAuctionsHeadless({
+      load: async (_args, historyDays) => {
+        requested.push(historyDays);
+        return { auctions: [bill, bond], fetchedAt: 123, stale: false };
+      },
+    });
+
+    const all = await headless.load(args("all"), {} as HeadlessPaneContext);
+    const bonds = await headless.load(args("bond"), {} as HeadlessPaneContext);
+    expect(all.rows).toHaveLength(2);
+    expect(bonds.rows).toEqual([expect.objectContaining({ id: "bond", rate: 4.1, indirectPercent: 20 })]);
+    expect(requested).toEqual([90, 90]);
+  });
+});

package/src/plugins/builtin/treasury-auctions/headless.ts

@@ -0,0 +1,95 @@
+import type {
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { formatCompact } from "../../../utils/format";
+import { fetchTreasuryAuctions } from "./client";
+import { loadTreasuryAuctions, type TreasuryAuctionsResult } from "./cache";
+import {
+  auctionSize,
+  DEFAULT_AUCTION_SORT,
+  indirectPct,
+  rateValue,
+  visibleAuctions,
+  type AuctionFilter,
+} from "./model";
+
+const COLUMNS = [
+  { key: "auctionDate", header: "Date" },
+  { key: "secType", header: "Type" },
+  { key: "securityTerm", header: "Term" },
+  { key: "rate", header: "Rate", align: "right" as const, format: (value: unknown) => value == null ? "-" : `${Number(value).toFixed(3)}%` },
+  { key: "bidToCoverRatio", header: "B/C", align: "right" as const, format: (value: unknown) => value == null ? "-" : Number(value).toFixed(2) },
+  { key: "indirectPercent", header: "Indirect", align: "right" as const, format: (value: unknown) => value == null ? "-" : `${Number(value).toFixed(1)}%` },
+  { key: "size", header: "Size", align: "right" as const, format: (value: unknown) => value == null ? "-" : `$${formatCompact(Number(value))}` },
+  { key: "cusip", header: "CUSIP" },
+];
+
+export interface TreasuryAuctionsHeadlessDependencies {
+  load(args: HeadlessPaneLoadArgs, historyDays: number): Promise<TreasuryAuctionsResult>;
+}
+
+const defaultDependencies: TreasuryAuctionsHeadlessDependencies = {
+  load: (_args, historyDays) => loadTreasuryAuctions(false, fetchTreasuryAuctions, historyDays),
+};
+
+export function createTreasuryAuctionsHeadless(
+  dependencies: TreasuryAuctionsHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "free-text",
+      placeholder: "search",
+      description: "Optional security type, term, or auction date filter.",
+      optional: true,
+    },
+    options: [
+      {
+        key: "historyDays",
+        aliases: ["history"],
+        settingKey: "historyDays",
+        description: "Auction history window in days.",
+        type: "enum",
+        values: [{ value: "30" }, { value: "90" }, { value: "120" }, { value: "365" }],
+        defaultValue: "120",
+      },
+      {
+        key: "filter",
+        description: "Security type group.",
+        type: "enum",
+        values: [{ value: "all" }, { value: "bill" }, { value: "note" }, { value: "bond" }],
+        defaultValue: "all",
+      },
+    ],
+    columns: COLUMNS,
+    describe: (args) => `Treasury Auctions | ${String(args.options.historyDays)} days | ${String(args.options.filter)}`,
+    async load(args) {
+      const historyDays = Number(args.options.historyDays);
+      const filter = args.options.filter as AuctionFilter;
+      const result = await dependencies.load(args, historyDays);
+      const query = typeof args.argument === "string" ? args.argument : "";
+      const auctions = visibleAuctions(result.auctions, {
+        filter,
+        query,
+        sort: DEFAULT_AUCTION_SORT,
+      });
+      return {
+        rows: auctions.map((auction) => ({
+          ...auction,
+          rate: rateValue(auction),
+          indirectPercent: indirectPct(auction),
+          size: auctionSize(auction),
+        })),
+        metadata: {
+          fetchedAt: result.fetchedAt,
+          stale: result.stale,
+          historyDays,
+          filter,
+        },
+      };
+    },
+  };
+}
+
+export const treasuryAuctionsHeadless = createTreasuryAuctionsHeadless();

package/src/plugins/builtin/treasury-auctions/index.tsx

@@ -8,6 +8,9 @@ import {
 import { TreasuryAuctionsPane } from "./pane";
 import { TREASURY_AUCTIONS_PANE_ID } from "./types";
 import { createPublicPaneShare } from "../shared/public-pane";
+import { treasuryAuctionsHeadless } from "./headless";
+
+export { treasuryAuctionsHeadless } from "./headless";
 
 let disposeConnection: (() => void) | null = null;
 
@@ -86,6 +89,7 @@ export const treasuryAuctionsModule: PluginModule = {
         "issuance",
       ],
       shortcut: { prefix: "AUCT" },
+      headless: treasuryAuctionsHeadless,
       createInstance: () => ({ placement: "floating" }),
       publicShare: createPublicPaneShare("Treasury Auctions"),
     },

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

@@ -21,6 +21,11 @@ export interface VolatilityLoadResult {
 
 const HISTORY_LIMIT = 120;
 
+export type VolatilitySeriesLoader = (
+  seriesId: VolatilitySeriesId,
+  options: { limit?: number; sortOrder?: "asc" | "desc" },
+) => Promise<VolatilitySeriesInput>;
+
 function requestFor(seriesId: VolatilitySeriesId): FredSeriesRequest {
   return { seriesId, limit: HISTORY_LIMIT, sortOrder: "desc" };
 }
@@ -48,11 +53,12 @@ export function getCachedVolatilityData(): VolatilityLoadResult | null {
 async function loadSeries(
   seriesId: VolatilitySeriesId,
   force: boolean,
+  loader: VolatilitySeriesLoader,
 ): Promise<FredSeriesLoadResult> {
   const request = requestFor(seriesId);
   return loadCachedFredSeries(
     request,
-    async () => toInput({ data: await apiClient.getCloudFredSeries(seriesId, {
+    async () => toInput({ data: await loader(seriesId, {
       limit: request.limit,
       sortOrder: request.sortOrder,
     }) }),
@@ -60,9 +66,16 @@ async function loadSeries(
   );
 }
 
-export async function loadVolatilityData(force = false): Promise<VolatilityLoadResult> {
+const defaultSeriesLoader: VolatilitySeriesLoader = (seriesId, options) => (
+  apiClient.getCloudFredSeries(seriesId, options)
+);
+
+export async function loadVolatilityData(
+  force = false,
+  loader: VolatilitySeriesLoader = defaultSeriesLoader,
+): Promise<VolatilityLoadResult> {
   const settled = await Promise.allSettled(
-    VOLATILITY_SERIES.map(({ seriesId }) => loadSeries(seriesId, force)),
+    VOLATILITY_SERIES.map(({ seriesId }) => loadSeries(seriesId, force, loader)),
   );
   const inputs: Partial<Record<VolatilitySeriesId, VolatilitySeriesInput>> = {};
   const errors: string[] = [];

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

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createVolatilityHeadless } from "./headless";
+
+const args: HeadlessPaneLoadArgs = { rawArgument: "", argument: null, symbols: [], options: {} };
+
+describe("volatility headless model", () => {
+  test("projects aligned tenors and the derived curve state", async () => {
+    const headless = createVolatilityHeadless({
+      load: async () => ({
+        data: {
+          metrics: [
+            { seriesId: "VIXCLS", label: "VIX", tenor: "30D", title: "VIX", value: 18, date: "2026-09-03", history: [] },
+            { seriesId: "VXVCLS", label: "VIX 3M", tenor: "3M", title: "VIX 3M", value: 21, date: "2026-09-03", history: [] },
+          ],
+          termPoints: [],
+          termDate: "2026-09-03",
+          ratio: 21 / 18,
+          slope: 3,
+          ratioHistory: [],
+          termState: "normal",
+        },
+        stale: false,
+        errors: [],
+      }),
+    });
+    const result = await headless.load(args, {} as HeadlessPaneContext);
+
+    expect(result.sections[0]?.entries?.slice(0, 2)).toEqual([
+      { label: "State", value: "normal" },
+      { label: "As of", value: "2026-09-03" },
+    ]);
+    expect(result.sections[1]?.rows?.[0]).toMatchObject({ label: "VIX", value: 18 });
+  });
+});

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

@@ -0,0 +1,75 @@
+import type {
+  HeadlessBundleResult,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import {
+  loadVolatilityData,
+  type VolatilityLoadResult,
+  type VolatilitySeriesLoader,
+} from "./client";
+import type { VolatilityData } from "./model";
+
+function formattedValue(value: number | null, digits = 2): string {
+  return value == null ? "-" : value.toFixed(digits);
+}
+
+export function projectVolatilityHeadless(data: VolatilityData): HeadlessBundleResult {
+  return {
+    sections: [
+      {
+        title: "Term structure",
+        entries: [
+          { label: "State", value: data.termState },
+          { label: "As of", value: data.termDate },
+          { label: "3M / 30D", value: data.ratio, formatted: formattedValue(data.ratio) },
+          { label: "3M spread", value: data.slope, formatted: data.slope == null ? "-" : `${data.slope > 0 ? "+" : ""}${data.slope.toFixed(2)} pts` },
+        ],
+      },
+      {
+        title: "Volatility tenors",
+        columns: [
+          { key: "label", header: "Index" },
+          { key: "tenor", header: "Tenor" },
+          { key: "value", header: "Close", align: "right", format: (value) => formattedValue(value as number | null) },
+          { key: "date", header: "As of" },
+          { key: "title", header: "Series" },
+        ],
+        rows: data.metrics.map((metric) => ({ ...metric })),
+      },
+    ],
+  };
+}
+
+export interface VolatilityHeadlessDependencies {
+  load(args: HeadlessPaneLoadArgs, loader: VolatilitySeriesLoader): Promise<VolatilityLoadResult>;
+}
+
+const defaultDependencies: VolatilityHeadlessDependencies = {
+  load: (_args, loader) => loadVolatilityData(false, loader),
+};
+
+export function createVolatilityHeadless(
+  dependencies: VolatilityHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle",
+    argument: { kind: "none" },
+    options: [],
+    describe: "VIX 30D/3M Curve",
+    async load(args, ctx) {
+      const result = await dependencies.load(
+        args,
+        (seriesId, options) => ctx.apiClient.getCloudFredSeries(seriesId, options),
+      );
+      const projected = projectVolatilityHeadless(result.data);
+      return {
+        ...projected,
+        errors: result.errors,
+        metadata: { stale: result.stale },
+      };
+    },
+  };
+}
+
+export const volatilityHeadless = createVolatilityHeadless();

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

@@ -18,6 +18,9 @@ import { colors } from "../../../theme/colors";
 import type { PluginModule } from "../plugin-module";
 import { getCachedVolatilityData, loadVolatilityData } from "./client";
 import type { TermState, VolatilityData } from "./model";
+import { volatilityHeadless } from "./headless";
+
+export { volatilityHeadless } from "./headless";
 
 function formatValue(value: number | null, suffix = ""): string {
   return value == null || !Number.isFinite(value) ? "--" : `${value.toFixed(2)}${suffix}`;
@@ -189,5 +192,6 @@ export const volatilityModule: PluginModule = {
     description: "Aligned daily 30-day and three-month VIX implied-volatility closes from FRED.",
     keywords: ["vix", "volatility", "implied volatility", "curve", "slope", "normal", "inverted", "macro"],
     shortcut: { prefix: "VIX" },
+    headless: volatilityHeadless,
   }],
 };

package/src/plugins/builtin/world-indices/client.ts

@@ -0,0 +1,43 @@
+import type { DataProvider } from "../../../types/data-provider";
+import type { Quote } from "../../../types/financials";
+import type { IndexEntry } from "./indices";
+
+export interface WorldIndexQuoteResult {
+  quotes: Map<string, Quote | null>;
+  errors: string[];
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export async function loadWorldIndexQuotes(
+  entries: readonly IndexEntry[],
+  provider: DataProvider,
+): Promise<WorldIndexQuoteResult> {
+  const quotes = new Map<string, Quote | null>();
+  const errors: string[] = [];
+  if (provider.getQuotesBatch) {
+    const results = await provider.getQuotesBatch(
+      entries.map((entry) => ({ symbol: entry.symbol, exchange: "" })),
+    );
+    const bySymbol = new Map(results.map((result) => [result.target.symbol, result]));
+    for (const entry of entries) {
+      const result = bySymbol.get(entry.symbol);
+      quotes.set(entry.symbol, result?.quote ?? null);
+      if (result?.error) errors.push(`${entry.symbol}: ${errorMessage(result.error)}`);
+      else if (!result?.quote) errors.push(`${entry.symbol}: quote unavailable`);
+    }
+    return { quotes, errors };
+  }
+
+  await Promise.all(entries.map(async (entry) => {
+    try {
+      quotes.set(entry.symbol, await provider.getQuote(entry.symbol, ""));
+    } catch (error) {
+      quotes.set(entry.symbol, null);
+      errors.push(`${entry.symbol}: ${errorMessage(error)}`);
+    }
+  }));
+  return { quotes, errors };
+}

package/src/plugins/builtin/world-indices/headless.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createWorldIndicesHeadless } from "./headless";
+
+const args: HeadlessPaneLoadArgs = { rawArgument: "", argument: null, symbols: [], options: {} };
+
+describe("world indices headless model", () => {
+  test("groups quote rows by the same world regions as the pane", async () => {
+    const headless = createWorldIndicesHeadless({
+      load: async (_args, entries) => ({
+        quotes: new Map(entries.map((entry) => [entry.symbol, {
+          symbol: entry.symbol,
+          price: entry.symbol === "^GSPC" ? 6_800 : 100,
+          currency: "USD",
+          change: 10,
+          changePercent: 0.5,
+          lastUpdated: 1_700_000_000_000,
+          marketState: "REGULAR" as const,
+        }])),
+        errors: [],
+      }),
+    });
+    const result = await headless.load(args, {} as HeadlessPaneContext);
+
+    expect(result.sections.map((section) => section.title)).toEqual([
+      "Americas", "Europe", "Asia-Pacific", "Other",
+    ]);
+    expect(result.sections[0]?.rows?.[0]).toMatchObject({
+      symbol: "^GSPC", shortName: "SPX", price: 6_800,
+    });
+  });
+});

package/src/plugins/builtin/world-indices/headless.ts

@@ -0,0 +1,109 @@
+import type { DataProvider } from "../../../types/data-provider";
+import type {
+  HeadlessBundleResult,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { formatCurrency, formatNumber, formatPercentRaw } from "../../../utils/format";
+import { loadWorldIndexQuotes, type WorldIndexQuoteResult } from "./client";
+import {
+  getIndicesByRegion,
+  REGION_LABELS,
+  REGION_ORDER,
+  WORLD_INDICES,
+  type IndexEntry,
+} from "./indices";
+
+const COLUMNS = [
+  { key: "shortName", header: "Index" },
+  { key: "name", header: "Name" },
+  {
+    key: "price",
+    header: "Last",
+    align: "right" as const,
+    format: (value: unknown, row: Record<string, unknown>) => value == null
+      ? "-"
+      : formatCurrency(Number(value), String(row.currency ?? "USD")),
+  },
+  {
+    key: "change",
+    header: "Change",
+    align: "right" as const,
+    format: (value: unknown) => value == null ? "-" : `${Number(value) >= 0 ? "+" : ""}${formatNumber(Number(value), 2)}`,
+  },
+  {
+    key: "changePercent",
+    header: "Change %",
+    align: "right" as const,
+    format: (value: unknown) => value == null ? "-" : formatPercentRaw(Number(value)),
+  },
+  { key: "marketState", header: "Session" },
+  {
+    key: "lastUpdated",
+    header: "Updated",
+    format: (value: unknown) => value == null ? "-" : new Date(Number(value)).toISOString(),
+  },
+];
+
+export function projectWorldIndicesHeadless(
+  entries: readonly IndexEntry[],
+  loaded: WorldIndexQuoteResult,
+): HeadlessBundleResult {
+  const grouped = getIndicesByRegion(entries);
+  return {
+    sections: REGION_ORDER.flatMap((region) => {
+      const regionEntries = grouped.get(region) ?? [];
+      if (regionEntries.length === 0) return [];
+      return [{
+        title: REGION_LABELS[region],
+        columns: COLUMNS,
+        rows: regionEntries.map((entry) => {
+          const quote = loaded.quotes.get(entry.symbol);
+          return {
+            ...entry,
+            price: quote?.price ?? null,
+            currency: quote?.currency ?? null,
+            change: quote?.change ?? null,
+            changePercent: quote?.changePercent ?? null,
+            marketState: quote?.marketState ?? null,
+            lastUpdated: quote?.lastUpdated ?? null,
+          };
+        }),
+      }];
+    }),
+    errors: loaded.errors,
+    metadata: {
+      requested: entries.length,
+      available: [...loaded.quotes.values()].filter(Boolean).length,
+    },
+  };
+}
+
+export interface WorldIndicesHeadlessDependencies {
+  load(
+    args: HeadlessPaneLoadArgs,
+    entries: readonly IndexEntry[],
+    provider: DataProvider,
+  ): Promise<WorldIndexQuoteResult>;
+}
+
+const defaultDependencies: WorldIndicesHeadlessDependencies = {
+  load: (_args, entries, provider) => loadWorldIndexQuotes(entries, provider),
+};
+
+export function createWorldIndicesHeadless(
+  dependencies: WorldIndicesHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle",
+    argument: { kind: "none" },
+    options: [],
+    describe: "World Equity Indices",
+    async load(args, ctx) {
+      const loaded = await dependencies.load(args, WORLD_INDICES, ctx.marketData);
+      return projectWorldIndicesHeadless(WORLD_INDICES, loaded);
+    },
+  };
+}
+
+export const worldIndicesHeadless = createWorldIndicesHeadless();

package/src/plugins/builtin/world-indices/index.tsx

@@ -9,6 +9,7 @@ import { useQuoteBoard } from "../shared/use-quote-board";
 import { WORLD_INDICES, REGION_LABELS, getIndicesByRegion, resolveIndexEntries } from "./indices";
 import { useWorldIndicesFooter } from "./footer";
 import { createPublicPaneShare } from "../shared/public-pane";
+import { worldIndicesHeadless } from "./headless";
 import {
   buildFlatRows,
   DEFAULT_SORT_PREFERENCE,
@@ -23,6 +24,8 @@ import {
   type WorldIndexColumn,
 } from "./table";
 
+export { worldIndicesHeadless } from "./headless";
+
 /** Stable identity: a fresh literal here would remount the board every render. */
 const NO_SAVED_SYMBOLS: string[] = [];
 
@@ -160,6 +163,7 @@ export const worldIndicesModule: PluginModule = {
       description: "Monitor global equity indices grouped by region.",
       keywords: ["world", "indices", "global", "equity", "markets", "international"],
       shortcut: { prefix: "WEI" },
+      headless: worldIndicesHeadless,
       publicShare: createPublicPaneShare("World Equity Indices"),
     },
   ],

package/src/plugins/builtin/yield-curve/headless.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createYieldCurveHeadless } from "./headless";
+
+const args: HeadlessPaneLoadArgs = { rawArgument: "", argument: null, symbols: [], options: {} };
+
+describe("yield curve headless model", () => {
+  test("returns ordered maturities and the shared 2Y to 10Y spread", async () => {
+    const headless = createYieldCurveHeadless({
+      load: async () => [
+        { maturity: "10Y", maturityYears: 10, yield: 4.1, asOf: "2026-09-03" },
+        { maturity: "2Y", maturityYears: 2, yield: 4.35, asOf: "2026-09-04" },
+      ],
+    });
+    const result = await headless.load(args, {} as HeadlessPaneContext);
+
+    expect(result.rows.map((row) => row.maturity)).toEqual(["2Y", "10Y"]);
+    expect(result.metadata).toEqual({
+      asOf: "2026-09-04",
+      inverted: true,
+      spread2Y10YBasisPoints: -25,
+    });
+  });
+});