gloomberb 0.12.0 → 0.13.2

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

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import {
+  createEarningsEstimatesHeadless,
+  type EarningsEstimateSources,
+} from "./headless";
+
+const sources: EarningsEstimateSources = {
+  currency: "USD",
+  actions: {
+    symbol: "AMD",
+    currency: "USD",
+    dividends: [],
+    splits: [],
+    earnings: [{
+      date: "2026-07-28",
+      epsEstimate: 0.45,
+      epsActual: 0.48,
+      difference: 0.03,
+      surprisePercent: 6.67,
+    }],
+  },
+  estimates: {
+    symbol: "AMD",
+    currency: "USD",
+    recommendations: [],
+    ratings: [],
+    earningsEstimates: [
+      { date: "2026-09-30", period: "next_quarter", average: 1.2, analysts: 30 },
+      { date: "2026-12-31", period: "current_year", average: 4.8, analysts: 32 },
+    ],
+    revenueEstimates: [
+      { date: "2026-09-30", period: "next_quarter", average: 9_000_000_000, analysts: 28 },
+      { date: "2026-12-31", period: "current_year", average: 35_000_000_000, analysts: 29 },
+    ],
+  },
+  financials: {
+    annualStatements: [],
+    quarterlyStatements: [],
+    priceHistory: [],
+  },
+};
+
+function args(options: Record<string, string | number | boolean>): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AMD",
+    argument: "AMD",
+    symbols: ["AMD"],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+describe("earnings estimates headless", () => {
+  test("maps the shared event model into estimate rows", async () => {
+    const definition = createEarningsEstimatesHeadless({
+      loadSources: async () => sources,
+    });
+
+    const result = await definition.load(args({ kind: "all", limit: 50 }), context);
+
+    expect(result.rows).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        status: "Q Est",
+        period: "next qtr",
+        qEps: 1.2,
+        qRevenue: 9_000_000_000,
+        detail: "30E/28R",
+      }),
+      expect.objectContaining({
+        status: "FY Est",
+        annualEps: 4.8,
+        annualRevenue: 35_000_000_000,
+      }),
+      expect.objectContaining({
+        status: "Earnings",
+        qEps: 0.48,
+        value: "+6.67%",
+      }),
+    ]));
+  });
+
+  test("applies kind and limit options", async () => {
+    const definition = createEarningsEstimatesHeadless({ loadSources: async () => sources });
+
+    const result = await definition.load(args({ kind: "estimates", limit: 1 }), context);
+
+    expect(result.rows).toHaveLength(1);
+    expect(["Q Est", "FY Est"]).toContain(result.rows[0]?.status);
+    expect(result.metadata).toMatchObject({ kind: "estimates", total: 2, truncated: true });
+  });
+});

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

@@ -0,0 +1,161 @@
+import type {
+  AnalystResearchData,
+  CorporateActionsData,
+  TickerFinancials,
+} from "../../../types/financials";
+import type {
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessRowsResult,
+} from "../../../types/plugin";
+import { buildEventRows, type EventRow } from "./event-model";
+
+const ESTIMATE_COLUMNS = [
+  { key: "date", header: "Date" },
+  { key: "status", header: "Event" },
+  { key: "period", header: "Period" },
+  { key: "qEps", header: "Q EPS", align: "right" as const },
+  { key: "qRevenue", header: "Q revenue", align: "right" as const },
+  { key: "annualEps", header: "Annual EPS", align: "right" as const },
+  { key: "annualRevenue", header: "Annual revenue", align: "right" as const },
+  { key: "value", header: "Value", align: "right" as const },
+  { key: "detail", header: "Detail" },
+];
+
+export interface EarningsEstimateSources {
+  actions: CorporateActionsData | null;
+  estimates: AnalystResearchData | null;
+  financials: TickerFinancials | null;
+  currency: string;
+  errors?: string[];
+}
+
+export interface EarningsEstimatesHeadlessDependencies {
+  loadSources(
+    symbol: string,
+    context: HeadlessPaneContext,
+  ): Promise<EarningsEstimateSources>;
+}
+
+async function settledValue<T>(
+  promise: Promise<T> | null,
+  errors: string[],
+  label: string,
+): Promise<T | null> {
+  if (!promise) return null;
+  try {
+    return await promise;
+  } catch (error) {
+    errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+
+const defaultDependencies: EarningsEstimatesHeadlessDependencies = {
+  async loadSources(symbol, context) {
+    const errors: string[] = [];
+    const provider = context.marketData;
+    const [actions, estimates, financials] = await Promise.all([
+      settledValue(
+        provider.getCorporateActions?.(symbol, "") ?? null,
+        errors,
+        "corporate actions",
+      ),
+      settledValue(
+        provider.getAnalystResearch?.(symbol, "") ?? null,
+        errors,
+        "analyst estimates",
+      ),
+      settledValue(provider.getTickerFinancials(symbol, ""), errors, "financials"),
+    ]);
+    if (!actions && !estimates && !financials && errors.length > 0) {
+      throw new Error(errors.join("; "));
+    }
+    return {
+      actions,
+      estimates,
+      financials,
+      currency: actions?.currency ?? estimates?.currency ?? financials?.quote?.currency ?? "USD",
+      errors,
+    };
+  },
+};
+
+function matchesKind(row: EventRow, kind: string): boolean {
+  if (kind === "all") return true;
+  if (kind === "estimates") return row.status === "Q Est" || row.status === "FY Est";
+  return row.status === "Earnings" || row.status === "TTM";
+}
+
+export function projectEarningsEstimatesHeadless(
+  sources: EarningsEstimateSources,
+  args: HeadlessPaneLoadArgs,
+): HeadlessRowsResult {
+  const kind = String(args.options.kind ?? "all");
+  const limit = Number(args.options.limit ?? 50);
+  const matching = buildEventRows(
+    sources.actions,
+    sources.estimates,
+    sources.financials,
+    sources.currency,
+  ).filter((row) => matchesKind(row, kind));
+  const rows = matching.slice(0, limit).map((row) => ({ ...row }));
+
+  return {
+    columns: ESTIMATE_COLUMNS,
+    rows,
+    errors: sources.errors?.length ? sources.errors : undefined,
+    metadata: {
+      currency: sources.currency,
+      kind,
+      total: matching.length,
+      returned: rows.length,
+      truncated: rows.length < matching.length,
+    },
+  };
+}
+
+export function createEarningsEstimatesHeadless(
+  dependencies: EarningsEstimatesHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "Company symbol.",
+    },
+    options: [
+      {
+        key: "kind",
+        description: "Estimate or reported rows to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "estimates" },
+          { value: "reported" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "limit",
+        description: "Maximum rows to return.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    columns: ESTIMATE_COLUMNS,
+    describe: (args) => `Earnings Estimates | ${String(args.argument)}`,
+    async load(args, context) {
+      return projectEarningsEstimatesHeadless(
+        await dependencies.loadSources(String(args.argument), context),
+        args,
+      );
+    },
+  };
+}
+
+export const earningsEstimatesHeadless = createEarningsEstimatesHeadless();

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

@@ -5,6 +5,13 @@ import { AnalystResearchView } from "./analyst-pane";
 import { CorporateActionsView } from "./corporate-actions-pane";
 import { EquityDiagnosticView } from "./equity-diagnostic-pane";
 import { RelativeValuationPane } from "./relative-valuation-pane";
+import { analystResearchHeadless } from "./analyst-headless";
+import { eventsHeadless } from "./events-headless";
+import { earningsEstimatesHeadless } from "./headless";
+
+export { analystResearchHeadless } from "./analyst-headless";
+export { eventsHeadless } from "./events-headless";
+export { earningsEstimatesHeadless } from "./headless";
 
 function EarningsEstimatesPane(props: { focused: boolean; width: number; height: number }) {
   return (
@@ -70,6 +77,7 @@ export const researchModule: PluginModule = {
       defaultMode: "floating",
       defaultFloatingSize: { width: 104, height: 24 },
       tableExport: true,
+      headless: eventsHeadless,
     },
     {
       id: "relative-valuation",
@@ -94,15 +102,18 @@ export const researchModule: PluginModule = {
   ],
 
   paneTemplates: [
-    createTickerSurfacePaneTemplate({
-      id: "analyst-research-pane",
-      paneId: "analyst-research",
-      label: "Analyst Research",
-      description: "Price targets, recommendations, and recent analyst actions.",
-      keywords: ["analyst", "research", "ratings", "target", "anr"],
-      shortcut: "ANR",
-      publicShare: true,
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "analyst-research-pane",
+        paneId: "analyst-research",
+        label: "Analyst Research",
+        description: "Price targets, recommendations, and recent analyst actions.",
+        keywords: ["analyst", "research", "ratings", "target", "anr"],
+        shortcut: "ANR",
+        publicShare: true,
+      }),
+      headless: analystResearchHeadless,
+    },
     createTickerSurfacePaneTemplate({
       id: "equity-diagnostic-pane",
       paneId: "equity-diagnostic",
@@ -121,15 +132,18 @@ export const researchModule: PluginModule = {
       shortcut: "EVT",
       publicShare: true,
     }),
-    createTickerSurfacePaneTemplate({
-      id: "earnings-estimates-pane",
-      paneId: "earnings-estimates",
-      label: "Earnings Estimates",
-      description: "EPS and revenue estimates with reported earnings.",
-      keywords: ["earnings", "estimates", "ee", "analyst", "eps", "revenue", "events"],
-      shortcut: "EE",
-      publicShare: true,
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "earnings-estimates-pane",
+        paneId: "earnings-estimates",
+        label: "Earnings Estimates",
+        description: "EPS and revenue estimates with reported earnings.",
+        keywords: ["earnings", "estimates", "ee", "analyst", "eps", "revenue", "events"],
+        shortcut: "EE",
+        publicShare: true,
+      }),
+      headless: earningsEstimatesHeadless,
+    },
     {
       id: "relative-valuation-pane",
       paneId: "relative-valuation",

package/src/plugins/builtin/research-search/pane.tsx

@@ -1,3 +1,4 @@
+import { recordResearchActivity } from "../../../api-client/research-activity";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   Button,
@@ -416,6 +417,9 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
   // Search is free and uncapped, so nothing is gated up front: the upsell only
   // appears if the server itself refuses the query.
   const proRequired = failure?.status === 402;
+  useEffect(() => {
+    if (focused && status === "loaded") recordResearchActivity("research_viewed", "search");
+  }, [focused, status]);
   const signInRequired = !access.signedIn || failure?.status === 401 || savedFailure?.status === 401;
   const verificationRequired = !signInRequired
     && (!access.emailVerified || failure?.status === 403);

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

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import type { ScannerHiloPayload } from "../../../api-client";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createHiloHeadless, loadHiloSnapshot } from "./headless";
+
+const payload: ScannerHiloPayload = {
+  status: "live",
+  asOf: 123,
+  access: "realtime",
+  delayMinutes: 0,
+  windows: { s30: { highs: 1, lows: 1 }, m1: { highs: 2, lows: 2 }, m5: { highs: 3, lows: 3 } },
+  lows: [
+    { symbol: "PENNY", price: 0.5, count: 10, at: 10 },
+    { symbol: "LOW", price: 10, count: 2, at: 20 },
+  ],
+  highs: [{ symbol: "HIGH", price: 20, count: 5, at: 30 }],
+};
+
+function args(minPrice: string, sort: string): HeadlessPaneLoadArgs {
+  return { rawArgument: "", argument: null, symbols: [], options: { minPrice, sort } };
+}
+
+describe("highs and lows headless model", () => {
+  test("waits for scanner data beyond the connecting snapshot", async () => {
+    let unsubscribed = 0;
+    const result = await loadHiloSnapshot({
+      subscribeScanner(_scanner, listener) {
+        listener({ type: "data", payload: { ...payload, status: "starting" } });
+        listener({ type: "data", payload });
+        return () => { unsubscribed += 1; };
+      },
+    }, new AbortController().signal);
+
+    expect(result.status).toBe("live");
+    expect(unsubscribed).toBe(1);
+  });
+
+  test("reports a degraded stream as partial data", async () => {
+    const headless = createHiloHeadless({
+      load: async () => ({ ...payload, status: "degraded" }),
+    });
+
+    const result = await headless.load(args("1", "recent"), {} as HeadlessPaneContext);
+
+    expect(result.errors).toEqual(["Scanner feed degraded"]);
+  });
+
+  test("applies the pane price and sort options to a stream snapshot", async () => {
+    const headless = createHiloHeadless({ load: async () => payload });
+    const filtered = await headless.load(args("1", "recent"), {} as HeadlessPaneContext);
+    const unfiltered = await headless.load(args("off", "count"), {} as HeadlessPaneContext);
+
+    expect(filtered.items.map((row) => row.symbol)).toEqual(["LOW", "HIGH"]);
+    expect(unfiltered.items.map((row) => row.symbol)).toEqual(["PENNY", "LOW", "HIGH"]);
+    expect((filtered.metadata?.windows as Array<Record<string, unknown>>)[0]).toMatchObject({
+      key: "m5", highs: 3, lows: 3,
+    });
+  });
+});

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

@@ -0,0 +1,125 @@
+import type { ScannerFeedEvent, ScannerHiloPayload } from "../../../api-client";
+import type {
+  HeadlessPaneApiClient,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessSnapshotResult,
+} from "../../../types/plugin";
+import { buildHiloBarRows, filterHiloRows, type HiloMinPrice, type HiloSort } from "./hilo-model";
+
+export function loadHiloSnapshot(
+  client: Pick<HeadlessPaneApiClient, "subscribeScanner">,
+  signal: AbortSignal,
+  timeoutMs = 10_000,
+): Promise<ScannerHiloPayload> {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let unsubscribe: (() => void) | null = null;
+    const finish = (callback: () => void) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      unsubscribe?.();
+      callback();
+    };
+    const onAbort = () => finish(() => reject(signal.reason instanceof Error
+      ? signal.reason
+      : new Error("Highs and lows snapshot aborted")));
+    const timer = setTimeout(() => finish(() => reject(new Error("Highs and lows snapshot timed out"))), timeoutMs);
+    signal.addEventListener("abort", onAbort, { once: true });
+    unsubscribe = client.subscribeScanner("hilo", (event: ScannerFeedEvent) => {
+      if (event.type === "denied") {
+        finish(() => reject(new Error(event.reason === "pro_required" ? "Pro access required" : "Sign in required")));
+        return;
+      }
+      if (event.payload.status === "starting") return;
+      finish(() => resolve(event.payload as ScannerHiloPayload));
+    });
+    if (settled) unsubscribe();
+  });
+}
+
+export function projectHiloSnapshot(
+  payload: ScannerHiloPayload,
+  minPrice: HiloMinPrice,
+  sort: HiloSort,
+): HeadlessSnapshotResult {
+  const lows = filterHiloRows(payload.lows, minPrice, sort).map((row) => ({ side: "low", ...row }));
+  const highs = filterHiloRows(payload.highs, minPrice, sort).map((row) => ({ side: "high", ...row }));
+  return {
+    asOf: new Date(payload.asOf).toISOString(),
+    items: [...lows, ...highs],
+    ...(payload.status === "degraded" ? { errors: ["Scanner feed degraded"] } : {}),
+    metadata: {
+      status: payload.status,
+      access: payload.access,
+      delayMinutes: payload.delayMinutes,
+      windows: buildHiloBarRows(payload.windows),
+      minPrice,
+      sort,
+    },
+  };
+}
+
+export interface HiloHeadlessDependencies {
+  load(
+    args: HeadlessPaneLoadArgs,
+    client: Pick<HeadlessPaneApiClient, "subscribeScanner">,
+    signal: AbortSignal,
+  ): Promise<ScannerHiloPayload>;
+}
+
+const defaultDependencies: HiloHeadlessDependencies = {
+  load: (_args, client, signal) => loadHiloSnapshot(client, signal),
+};
+
+export function createHiloHeadless(
+  dependencies: HiloHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"snapshot"> {
+  return {
+    shape: "snapshot",
+    argument: { kind: "none" },
+    options: [
+      {
+        key: "minPrice",
+        aliases: ["min-price"],
+        settingKey: "minPrice",
+        description: "Minimum stock price.",
+        type: "enum",
+        values: [{ value: "off" }, { value: "1" }, { value: "5" }],
+        defaultValue: "1",
+      },
+      {
+        key: "sort",
+        settingKey: "sort",
+        description: "Extreme ordering.",
+        type: "enum",
+        values: [{ value: "recent" }, { value: "count" }],
+        defaultValue: "recent",
+      },
+    ],
+    columns: [
+      { key: "side", header: "Side" },
+      { key: "symbol", header: "Symbol" },
+      { key: "price", header: "Price", align: "right" },
+      { key: "count", header: "Count", align: "right" },
+      {
+        key: "at",
+        header: "Observed at",
+        format: (value: unknown) => new Date(Number(value)).toISOString(),
+      },
+    ],
+    describe: "New Highs / Lows",
+    async load(args, ctx) {
+      const payload = await dependencies.load(args, ctx.apiClient, ctx.signal);
+      return projectHiloSnapshot(
+        payload,
+        args.options.minPrice as HiloMinPrice,
+        args.options.sort as HiloSort,
+      );
+    },
+  };
+}
+
+export const hiloHeadless = createHiloHeadless();

package/src/plugins/builtin/scanner/index.ts

@@ -3,6 +3,9 @@ import type { PluginModule } from "../plugin-module";
 import { DEFAULT_FLOW_FILTERS, FLOW_FILTER_OPTIONS } from "./flow-model";
 import FlowPane from "./flow-pane";
 import HiloPane from "./hilo-pane";
+import { hiloHeadless } from "./headless";
+
+export { hiloHeadless } from "./headless";
 
 export const HILO_PANE_ID = "scanner-hilo";
 export const FLOW_PANE_ID = "scanner-flow";
@@ -96,6 +99,7 @@ export const scannerModule: PluginModule = {
       description: "Session new-high and new-low momentum with 30s/1m/5m counts.",
       keywords: ["hilo", "highs", "lows", "new", "momentum", "breakout", "scanner"],
       shortcut: { prefix: "HILO" },
+      headless: hiloHeadless,
       createInstance: () => ({ settings: { minPrice: "1", sort: "recent" } }),
     },
     {

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

@@ -0,0 +1,16 @@
+import type {
+  DataProvider,
+  MarketDataRequestContext,
+  SecFilingItem,
+} from "../../../types/data-provider";
+
+export async function loadSecFilings(
+  provider: DataProvider,
+  symbol: string,
+  count: number,
+  exchange = "",
+  context?: MarketDataRequestContext,
+): Promise<SecFilingItem[]> {
+  if (!provider.getSecFilings) throw new Error("SEC filing data unavailable");
+  return provider.getSecFilings(symbol, count, exchange, context);
+}

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

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { SecFilingItem } from "../../../types/data-provider";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createSecHeadless } from "./headless";
+
+const filings: SecFilingItem[] = [
+  {
+    accessionNumber: "0000320193-26-000100",
+    form: "8-K",
+    filingDate: new Date("2026-08-25T00:00:00.000Z"),
+    primaryDocDescription: "8-K Results of Operations",
+    items: "2.02,9.01",
+    cik: "0000320193",
+    filingUrl: "https://www.sec.gov/filing/one",
+  },
+  {
+    accessionNumber: "0000320193-26-000099",
+    form: "10-Q",
+    filingDate: new Date("2026-08-20T00:00:00.000Z"),
+    cik: "0000320193",
+    filingUrl: "https://www.sec.gov/filing/two",
+  },
+];
+
+function context(): HeadlessPaneContext {
+  return {
+    marketData: createTestDataProvider(),
+    apiClient: {} as HeadlessPaneContext["apiClient"],
+    config: createDefaultConfig("/tmp/gloomberb-headless-sec"),
+    signal: new AbortController().signal,
+  };
+}
+
+function args(limit: number): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AAPL",
+    argument: "AAPL",
+    symbols: ["AAPL"],
+    options: { limit },
+  };
+}
+
+describe("SEC headless model", () => {
+  test("projects filing rows and honors the page limit", async () => {
+    const requestedLimits: number[] = [];
+    const headless = createSecHeadless({
+      loadFilings: async (_symbol, limit) => {
+        requestedLimits.push(limit);
+        return filings;
+      },
+    });
+
+    const first = await headless.load(args(1), context());
+    expect(first.rows).toEqual([{
+      filedAt: "2026-08-25T00:00:00.000Z",
+      acceptedAt: null,
+      form: "8-K",
+      filing: "8-K | Results of Operations | Current Report",
+      items: "2.02,9.01",
+      accessionNumber: "0000320193-26-000100",
+      primaryDocument: null,
+      cik: "0000320193",
+      url: "https://www.sec.gov/filing/one",
+    }]);
+
+    const both = await headless.load(args(2), context());
+    expect(both.rows).toHaveLength(2);
+    expect(requestedLimits).toEqual([1, 2]);
+  });
+});