gloomberb 0.12.0 → 0.13.2

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

@@ -0,0 +1,72 @@
+import type { SecFilingItem } from "../../../types/data-provider";
+import { formatCompact, formatCurrency } from "../../../utils/format";
+import {
+  transactionTypeLabel,
+  type InsiderTransaction,
+} from "./insider-data";
+
+const NINETY_DAYS_MS = 90 * 24 * 60 * 60 * 1000;
+
+export interface ParsedInsiderFiling {
+  filing: SecFilingItem;
+  transaction: InsiderTransaction | null;
+  isLoading: boolean;
+}
+
+/** Null while filings are still parsing, so the pane never claims no activity early. */
+export function buildInsiderSummary(
+  parsed: ParsedInsiderFiling[],
+  now = Date.now(),
+): string | null {
+  if (parsed.some(({ isLoading }) => isLoading)) return null;
+  const cutoff = new Date(now - NINETY_DAYS_MS);
+  let buyShares = 0;
+  let sellShares = 0;
+  let buyValue = 0;
+  let sellValue = 0;
+
+  for (const { transaction } of parsed) {
+    if (!transaction) continue;
+    const txDate = transaction.filingDate instanceof Date
+      ? transaction.filingDate
+      : new Date(transaction.filingDate);
+    if (Number.isNaN(txDate.getTime()) || txDate < cutoff) continue;
+    if (transaction.transactionType === "P") {
+      buyShares += transaction.shares;
+      buyValue += transaction.totalValue ?? 0;
+    } else if (transaction.transactionType === "S") {
+      sellShares += transaction.shares;
+      sellValue += transaction.totalValue ?? 0;
+    }
+  }
+
+  if (buyShares === 0 && sellShares === 0) return "No buy/sell activity in last 90 days.";
+
+  const parts: string[] = [];
+  if (buyShares > 0) parts.push(`Bought ${formatCompact(buyShares)} shares (${formatCurrency(buyValue)})`);
+  if (sellShares > 0) parts.push(`Sold ${formatCompact(sellShares)} shares (${formatCurrency(sellValue)})`);
+  return parts.join("  |  ");
+}
+
+export function buildInsiderRows(parsed: readonly ParsedInsiderFiling[]) {
+  return parsed.map(({ filing, transaction, isLoading }) => ({
+    filingDate: filing.filingDate instanceof Date
+      ? filing.filingDate.toISOString()
+      : String(filing.filingDate),
+    transactionDate: transaction?.filingDate instanceof Date
+      ? transaction.filingDate.toISOString()
+      : transaction?.filingDate ? String(transaction.filingDate) : null,
+    insider: transaction?.reportedName ?? null,
+    title: transaction?.title ?? null,
+    side: transaction ? transactionTypeLabel(transaction.transactionType) : null,
+    transactionCode: transaction?.transactionType ?? null,
+    shares: transaction?.shares ?? null,
+    pricePerShare: transaction?.pricePerShare ?? null,
+    totalValue: transaction?.totalValue ?? null,
+    sharesOwnedAfter: transaction?.sharesOwned ?? null,
+    form: filing.form,
+    accessionNumber: filing.accessionNumber,
+    url: filing.filingUrl,
+    status: isLoading ? "loading" : transaction ? "parsed" : "unavailable",
+  }));
+}

package/src/plugins/builtin/ipo-calendar/client.ts

@@ -256,6 +256,21 @@ async function fetchUpcomingIpos(): Promise<IPORecord[]> {
   return parseCalendarRecords(flat);
 }
 
+export function formatIpoDate(date: Date): string {
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${date.getUTCFullYear()}-${month}-${day}`;
+}
+
+export function matchesIpoRecord(record: IPORecord, query: string): boolean {
+  if (!query) return true;
+  const normalized = query.toLowerCase();
+  return record.ticker.toLowerCase().includes(normalized)
+    || record.companyName.toLowerCase().includes(normalized)
+    || (record.exchange?.toLowerCase().includes(normalized) ?? false)
+    || record.status.includes(normalized);
+}
+
 function dedupeAndSort(records: IPORecord[]): IPORecord[] {
   const byTicker = new Map<string, IPORecord>();
   const statusOrder: Record<IPOStatus, number> = { upcoming: 0, priced: 1, trading: 2 };

package/src/plugins/builtin/ipo-calendar/headless.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createIpoCalendarHeadless } from "./headless";
+import type { IPORecord } from "./types";
+
+const records: IPORecord[] = [
+  {
+    ticker: "ALFA",
+    companyName: "Alpha Labs",
+    date: new Date("2026-09-10T00:00:00.000Z"),
+    status: "upcoming",
+    exchange: "NASDAQ",
+    offerSize: 120_000_000,
+    priceRange: [18, 20],
+    pricedPrice: null,
+    shares: 6_000_000,
+    closePrice: null,
+    change1D: null,
+  },
+  {
+    ticker: "BETA",
+    companyName: "Beta Systems",
+    date: new Date("2026-09-03T00:00:00.000Z"),
+    status: "trading",
+    exchange: "NYSE",
+    offerSize: null,
+    priceRange: null,
+    pricedPrice: 24,
+    shares: null,
+    closePrice: 30,
+    change1D: 25,
+  },
+];
+
+function args(
+  argument: string | null = null,
+  options: Record<string, string | number | boolean> = { status: "all", limit: 50 },
+): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: argument ?? "",
+    argument,
+    symbols: [],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+describe("IPO calendar headless", () => {
+  test("maps IPO records into structured rows", async () => {
+    const definition = createIpoCalendarHeadless({
+      loadCalendar: async () => ({
+        records,
+        fetchedAt: 123,
+        stale: false,
+        errors: [],
+      }),
+    });
+
+    const result = await definition.load(args("alpha"), context);
+
+    expect(result.rows).toEqual([{
+      ticker: "ALFA",
+      company: "Alpha Labs",
+      date: "2026-09-10",
+      status: "upcoming",
+      exchange: "NASDAQ",
+      offerSize: 120_000_000,
+      priceLow: 18,
+      priceHigh: 20,
+      pricedPrice: null,
+      shares: 6_000_000,
+      closePrice: null,
+      change1D: null,
+    }]);
+    expect(result.metadata).toMatchObject({ total: 1, returned: 1, truncated: false });
+  });
+
+  test("applies status and limit options", async () => {
+    const definition = createIpoCalendarHeadless({
+      loadCalendar: async () => ({ records, fetchedAt: 123, stale: false, errors: [] }),
+    });
+
+    const result = await definition.load(args(null, { status: "trading", limit: 1 }), context);
+
+    expect(result.rows.map((row) => row.ticker)).toEqual(["BETA"]);
+    expect(result.metadata).toMatchObject({ status: "trading", returned: 1 });
+  });
+});

package/src/plugins/builtin/ipo-calendar/headless.ts

@@ -0,0 +1,127 @@
+import type {
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessRowsResult,
+} from "../../../types/plugin";
+import { formatIpoDate, matchesIpoRecord } from "./client";
+import { loadIpoCalendar, type IpoCalendarResult } from "./cache";
+import type { IPORecord, IPOStatus } from "./types";
+
+const IPO_COLUMNS = [
+  { key: "ticker", header: "Ticker" },
+  { key: "company", header: "Company" },
+  { key: "date", header: "Date" },
+  { key: "status", header: "Status" },
+  { key: "exchange", header: "Exchange" },
+  { key: "offerSize", header: "Offer", align: "right" as const },
+  { key: "priceLow", header: "Price low", align: "right" as const },
+  { key: "priceHigh", header: "Price high", align: "right" as const },
+  { key: "pricedPrice", header: "Priced", align: "right" as const },
+  { key: "shares", header: "Shares", align: "right" as const },
+  { key: "closePrice", header: "Close", align: "right" as const },
+  { key: "change1D", header: "1D %", align: "right" as const },
+];
+
+export interface IpoCalendarHeadlessDependencies {
+  loadCalendar(): Promise<IpoCalendarResult>;
+}
+
+const defaultDependencies: IpoCalendarHeadlessDependencies = {
+  loadCalendar: () => loadIpoCalendar(false),
+};
+
+function statusOption(args: HeadlessPaneLoadArgs): IPOStatus | "all" {
+  return String(args.options.status ?? "all") as IPOStatus | "all";
+}
+
+function toHeadlessRow(record: IPORecord) {
+  return {
+    ticker: record.ticker,
+    company: record.companyName,
+    date: formatIpoDate(record.date),
+    status: record.status,
+    exchange: record.exchange,
+    offerSize: record.offerSize,
+    priceLow: record.priceRange?.[0] ?? null,
+    priceHigh: record.priceRange?.[1] ?? null,
+    pricedPrice: record.pricedPrice,
+    shares: record.shares,
+    closePrice: record.closePrice,
+    change1D: record.change1D,
+  };
+}
+
+export function projectIpoCalendarHeadless(
+  result: IpoCalendarResult,
+  args: HeadlessPaneLoadArgs,
+): HeadlessRowsResult {
+  const query = typeof args.argument === "string" ? args.argument.trim() : "";
+  const status = statusOption(args);
+  const limit = Number(args.options.limit ?? 50);
+  const matching = result.records.filter((record) => (
+    matchesIpoRecord(record, query)
+    && (status === "all" || record.status === status)
+  ));
+  const rows = matching.slice(0, limit).map(toHeadlessRow);
+
+  return {
+    columns: IPO_COLUMNS,
+    rows,
+    errors: result.errors.length > 0 ? result.errors : undefined,
+    metadata: {
+      fetchedAt: result.fetchedAt,
+      stale: result.stale,
+      total: matching.length,
+      returned: rows.length,
+      truncated: rows.length < matching.length,
+      query: query || null,
+      status,
+    },
+  };
+}
+
+export function createIpoCalendarHeadless(
+  dependencies: IpoCalendarHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "free-text",
+      placeholder: "company or ticker",
+      description: "Optional company, ticker, exchange, or status filter.",
+      optional: true,
+    },
+    options: [
+      {
+        key: "status",
+        description: "IPO stage to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "upcoming" },
+          { value: "priced" },
+          { value: "trading" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "limit",
+        description: "Maximum IPO rows to return.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    columns: IPO_COLUMNS,
+    describe: (args) => {
+      const status = statusOption(args);
+      return status === "all" ? "IPO Calendar" : `IPO Calendar | ${status}`;
+    },
+    async load(args) {
+      return projectIpoCalendarHeadless(await dependencies.loadCalendar(), args);
+    },
+  };
+}
+
+export const ipoCalendarHeadless = createIpoCalendarHeadless();

package/src/plugins/builtin/ipo-calendar/index.tsx

@@ -6,6 +6,7 @@ import {
 } from "./client";
 import { attachIpoCalendarPersistence, resetIpoCalendarPersistence } from "./cache";
 import { IPOCalendarPane } from "./pane";
+import { ipoCalendarHeadless } from "./headless";
 import { IPO_CALENDAR_PANE_ID } from "./types";
 
 let disposeConnection: (() => void) | null = null;
@@ -60,6 +61,7 @@ export const ipoCalendarModule: PluginModule = {
         "debut",
       ],
       shortcut: { prefix: "IPO" },
+      headless: ipoCalendarHeadless,
       createInstance: () => ({ placement: "floating" }),
     },
   ],

package/src/plugins/builtin/ipo-calendar/model.ts

@@ -2,6 +2,7 @@ import type { DataTableColumn } from "../../../components";
 import { colors } from "../../../theme/colors";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
 import type { IPORecord, IPOStatus } from "./types";
+import { formatIpoDate, matchesIpoRecord } from "./client";
 
 type IPOColumnId =
   | "ticker"
@@ -37,11 +38,7 @@ export function statusColor(status: IPOStatus): string {
   }
 }
 
-export function formatDate(date: Date): string {
-  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(date.getUTCDate()).padStart(2, "0");
-  return `${date.getUTCFullYear()}-${month}-${day}`;
-}
+export const formatDate = formatIpoDate;
 
 export function formatOfferSize(value: number | null): string {
   if (value == null) return "—";
@@ -133,13 +130,4 @@ export function nextSortPreference(current: IPOSortPreference, columnId: string)
   return DEFAULT_SORT_PREFERENCE;
 }
 
-export function matchesSearch(record: IPORecord, query: string): boolean {
-  if (!query) return true;
-  const q = query.toLowerCase();
-  return (
-    record.ticker.toLowerCase().includes(q)
-    || record.companyName.toLowerCase().includes(q)
-    || (record.exchange?.toLowerCase().includes(q) ?? false)
-    || record.status.includes(q)
-  );
-}
+export const matchesSearch = matchesIpoRecord;

package/src/plugins/builtin/market-movers/client.ts

@@ -0,0 +1,76 @@
+import type { DataProvider } from "../../../types/data-provider";
+import { CATEGORY_MAP, screenerQuoteFromQuote, type TabId } from "./model";
+import {
+  fetchPreferredMarketMovers,
+  fetchTrending,
+  type MarketMoversResult,
+  type ScreenerQuote,
+  type TrendingSymbol,
+} from "./screener";
+
+export interface MarketMoverTabResult extends MarketMoversResult {
+  tab: TabId;
+}
+
+export interface MarketMoverTabDependencies {
+  fetchPreferred(
+    category: "day_gainers" | "day_losers" | "most_actives",
+    count: number,
+    options?: { forceRefresh?: boolean },
+  ): Promise<MarketMoversResult>;
+  fetchTrending(count: number, options?: { forceRefresh?: boolean }): Promise<TrendingSymbol[]>;
+}
+
+const defaultDependencies: MarketMoverTabDependencies = {
+  fetchPreferred: (category, count, options) => fetchPreferredMarketMovers(category, count, options),
+  fetchTrending: (count, options) => fetchTrending(count, undefined, options),
+};
+
+async function hydrateTrending(
+  trending: readonly TrendingSymbol[],
+  provider: DataProvider | null,
+): Promise<ScreenerQuote[]> {
+  const symbols = trending.slice(0, 25).map(({ symbol }) => symbol);
+  const bySymbol = new Map<string, ScreenerQuote>();
+  if (!provider) return [];
+  if (provider.getQuotesBatch) {
+    const results = await provider.getQuotesBatch(
+      symbols.map((symbol) => ({ symbol, exchange: "" })),
+    ).catch(() => []);
+    for (const result of results) {
+      if (result.quote) bySymbol.set(result.target.symbol, screenerQuoteFromQuote(result.target.symbol, result.quote));
+    }
+  } else {
+    await Promise.all(symbols.map(async (symbol) => {
+      try {
+        const quote = await provider.getQuote(symbol, "");
+        bySymbol.set(symbol, screenerQuoteFromQuote(symbol, quote));
+      } catch {
+        // Missing quotes are omitted from a ranked list.
+      }
+    }));
+  }
+  return symbols.flatMap((symbol) => {
+    const quote = bySymbol.get(symbol);
+    return quote ? [quote] : [];
+  });
+}
+
+export async function loadMarketMoverTab(
+  tab: TabId,
+  provider: DataProvider | null,
+  options?: { forceRefresh?: boolean },
+  dependencies: MarketMoverTabDependencies = defaultDependencies,
+): Promise<MarketMoverTabResult> {
+  if (tab === "trending") {
+    const trending = await dependencies.fetchTrending(25, options);
+    return {
+      tab,
+      quotes: await hydrateTrending(trending, provider),
+      source: "yahoo",
+      stale: false,
+    };
+  }
+  const result = await dependencies.fetchPreferred(CATEGORY_MAP[tab], 25, options);
+  return { ...result, tab };
+}

package/src/plugins/builtin/market-movers/headless.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createMarketMoversHeadless } from "./headless";
+
+function args(list: string): HeadlessPaneLoadArgs {
+  return { rawArgument: "", argument: null, symbols: [], options: { list } };
+}
+
+describe("market movers headless model", () => {
+  test("loads the selected list and computes each quote's 52-week position", async () => {
+    const loaded: string[] = [];
+    const headless = createMarketMoversHeadless({
+      load: async (_args, tab) => {
+        loaded.push(tab);
+        return {
+          tab,
+          source: "cloud",
+          stale: false,
+          quotes: [{
+            symbol: "NVDA", name: "NVIDIA", price: 150, change: 5, changePercent: 3.4,
+            volume: 100, avgVolume: 50, volumeRatio: 2, marketCap: 1_000,
+            currency: "USD", fiftyTwoWeekHigh: 200, fiftyTwoWeekLow: 100,
+            dayHigh: 151, dayLow: 142, exchange: "NASDAQ",
+          }],
+        };
+      },
+    });
+
+    const gainers = await headless.load(args("gainers"), {} as HeadlessPaneContext);
+    await headless.load(args("actives"), {} as HeadlessPaneContext);
+    expect(loaded).toEqual(["gainers", "actives"]);
+    expect(gainers.rows).toEqual([expect.objectContaining({ rank: 1, rangePositionPercent: 50 })]);
+  });
+});

package/src/plugins/builtin/market-movers/headless.ts

@@ -0,0 +1,73 @@
+import type { DataProvider } from "../../../types/data-provider";
+import type {
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { formatCompact, formatCurrency, formatNumber, formatPercentRaw } from "../../../utils/format";
+import { loadMarketMoverTab, type MarketMoverTabResult } from "./client";
+import { createRows, fiftyTwoWeekPositionPercent, type TabId } from "./model";
+
+const COLUMNS = [
+  { key: "rank", header: "Rank", align: "right" as const },
+  { key: "symbol", header: "Symbol" },
+  { key: "name", header: "Name" },
+  { key: "price", header: "Last", align: "right" as const, format: (value: unknown, row: Record<string, unknown>) => formatCurrency(Number(value), String(row.currency)) },
+  { key: "changePercent", header: "Change %", align: "right" as const, format: (value: unknown) => formatPercentRaw(Number(value)) },
+  { key: "volume", header: "Volume", align: "right" as const, format: (value: unknown) => formatCompact(Number(value)) },
+  { key: "volumeRatio", header: "Vol / Avg", align: "right" as const, format: (value: unknown) => formatNumber(Number(value), 1) },
+  { key: "rangePositionPercent", header: "52W pos", align: "right" as const, format: (value: unknown) => value == null ? "-" : formatPercentRaw(Number(value)) },
+  { key: "marketCap", header: "Market cap", align: "right" as const, format: (value: unknown) => value == null ? "-" : formatCompact(Number(value)) },
+];
+
+export interface MarketMoversHeadlessDependencies {
+  load(
+    args: HeadlessPaneLoadArgs,
+    tab: TabId,
+    provider: DataProvider,
+  ): Promise<MarketMoverTabResult>;
+}
+
+const defaultDependencies: MarketMoversHeadlessDependencies = {
+  load: (_args, tab, provider) => loadMarketMoverTab(tab, provider),
+};
+
+export function createMarketMoversHeadless(
+  dependencies: MarketMoversHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: { kind: "none" },
+    options: [{
+      key: "list",
+      description: "Market movers list.",
+      type: "enum",
+      values: [
+        { value: "gainers" },
+        { value: "losers" },
+        { value: "actives", aliases: ["active", "most-active"] },
+        { value: "trending" },
+      ],
+      defaultValue: "actives",
+    }],
+    columns: COLUMNS,
+    describe: (args) => `Market Movers | ${String(args.options.list)}`,
+    async load(args, ctx) {
+      const tab = args.options.list as TabId;
+      const result = await dependencies.load(args, tab, ctx.marketData);
+      const rows = createRows(result.quotes).map((row) => ({
+        ...row,
+        rangePositionPercent: fiftyTwoWeekPositionPercent(
+          row.price,
+          row.fiftyTwoWeekLow,
+          row.fiftyTwoWeekHigh,
+        ),
+      }));
+      return {
+        rows,
+        metadata: { list: tab, source: result.source, stale: result.stale },
+      };
+    },
+  };
+}
+
+export const marketMoversHeadless = createMarketMoversHeadless();

package/src/plugins/builtin/market-movers/index.tsx

@@ -13,15 +13,12 @@ import { useAutoRefresh } from "../shared/auto-refresh";
 import { useQuoteBoard } from "../shared/use-quote-board";
 import {
   attachMarketMoversPersistence,
-  fetchPreferredMarketMovers,
-  fetchTrending,
   MARKET_SUMMARY_SYMBOLS,
   resetMarketMoversPersistence,
   type ScreenerQuote,
   type MarketSummaryQuote,
 } from "./screener";
 import {
-  CATEGORY_MAP,
   DEFAULT_SORT_PREFERENCE,
   INDEX_SHORT,
   TABS,
@@ -29,7 +26,6 @@ import {
   nextSortPreference,
   resolveSummarySymbols,
   resolveTabs,
-  screenerQuoteFromQuote,
   sortRows,
   summaryQuoteFromQuote,
   type MarketMoverColumn,
@@ -37,6 +33,8 @@ import {
   type MarketMoverSortPreference,
   type TabId,
 } from "./model";
+import { loadMarketMoverTab } from "./client";
+import { marketMoversHeadless } from "./headless";
 import { buildMarketMoverColumns, renderMarketMoverCell } from "./table";
 import {
   LIVE_STREAMING_QUICK_SETTING,
@@ -49,6 +47,8 @@ import {
   resolveScreenerQuoteFeedStatus,
 } from "../shared/screener-live-quotes";
 
+export { marketMoversHeadless } from "./headless";
+
 /** Stable identity: a fresh literal here would reload the board every render. */
 const NO_SAVED_SELECTION: string[] = [];
 
@@ -138,54 +138,13 @@ function MarketMoversPane({ focused, width, height }: PaneProps) {
     }
 
     try {
-      let data: ScreenerQuote[];
-
-      if (tab === "trending") {
-        const trending = await fetchTrending(25, undefined, {
-          forceRefresh: options?.forceRefresh,
-        });
-        if (fetchGenRef.current !== gen) return;
-
-        const resolved: ScreenerQuote[] = [];
-
-        if (dataProvider) {
-          const targets = trending.slice(0, 25).map(({ symbol }) => ({ symbol, exchange: "" }));
-          if (dataProvider.getQuotesBatch) {
-            const batchResults = await dataProvider.getQuotesBatch(targets).catch(() => []);
-            for (const result of batchResults) {
-              if (fetchGenRef.current !== gen) return;
-              if (result.quote) {
-                resolved.push(screenerQuoteFromQuote(result.target.symbol, result.quote));
-              }
-            }
-          } else {
-            await Promise.allSettled(targets.map(async ({ symbol }) => {
-              try {
-                const q = await dataProvider.getQuote(symbol, "");
-                if (fetchGenRef.current !== gen) return;
-                if (q) {
-                  resolved.push(screenerQuoteFromQuote(symbol, q));
-                }
-              } catch { /* skip */ }
-            }));
-          }
-        }
-
-        if (fetchGenRef.current !== gen) return;
-        data = trending
-          .map((t) => resolved.find((r) => r.symbol === t.symbol))
-          .filter((r): r is ScreenerQuote => r !== undefined);
-        setMoversStale(false);
-      } else {
-        const result = await fetchPreferredMarketMovers(CATEGORY_MAP[tab], 25, {
-          forceRefresh: options?.forceRefresh,
-        });
-        if (fetchGenRef.current !== gen) return;
-        data = result.quotes;
-        setMoversStale(result.stale);
-      }
+      const result = await loadMarketMoverTab(tab, dataProvider, {
+        forceRefresh: options?.forceRefresh,
+      });
+      if (fetchGenRef.current !== gen) return;
 
-      setQuotes(data);
+      setQuotes(result.quotes);
+      setMoversStale(result.stale);
       if (!options?.background) setSelectedSymbol(null);
       setLoadError(null);
       setLastLoadedAt(Date.now());
@@ -361,6 +320,7 @@ export const marketMoversModule: PluginModule = {
       description: "Top gainers, losers, most active, and trending tickers.",
       keywords: ["movers", "gainers", "losers", "active", "trending", "screener", "top"],
       shortcut: { prefix: "MOST" },
+      headless: marketMoversHeadless,
     },
   ],
 };