gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/ticker-detail/fund-profile.test.tsx

@@ -0,0 +1,118 @@
+import { afterEach, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender, settleFrame } from "../../../renderers/opentui/test-utils";
+import { AppContext, createInitialState } from "../../../state/app/context";
+import { createDefaultConfig } from "../../../types/config";
+import { createTestTicker } from "../../../test-support/pane";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { buildTickerReport, ticker as runTickerCommand } from "../../../cli/commands/ticker";
+import type { MarketContext } from "../../../cli/types";
+import type { TickerFinancials } from "../../../types/financials";
+import { OverviewTab } from "./overview-tab";
+
+const config = createDefaultConfig("/tmp/gloom-fund-profile-test-unused");
+const ticker = createTestTicker("CLASSA", "Controlled accumulating fund", { assetCategory: "STK", exchange: "XETRA", currency: "EUR" });
+const quote = { symbol: "CLASSA", instrumentType: "ETF", currency: "EUR", price: 100, change: 0, changePercent: 0, lastUpdated: Date.parse("2026-09-11") };
+const profile = { description: "Controlled accumulating share class follows a published index." };
+let setup: Awaited<ReturnType<typeof testRender>> | undefined;
+afterEach(async () => {
+  if (setup) await act(async () => setup!.renderer.destroy());
+  setup = undefined;
+});
+
+for (const quoted of [true, false]) test(`fund classification and profile survive ${quoted ? "generic saved broker type" : "missing quote"} across consumers`, async () => {
+  const financials: TickerFinancials = {
+    ...(quoted ? { quote } : { quoteMetadata: { symbol: "CLASSA", instrumentType: "ETF", currency: "EUR", source: { stale: true, lastUpdated: quote.lastUpdated } } }),
+    profile, fundamentals: { dividendYield: 0 }, priceHistory: [], annualStatements: [], quarterlyStatements: [],
+  };
+  await act(async () => {
+    setup = await testRender(<AppContext value={{ state: createInitialState(config), dispatch: () => {} }}>
+      <OverviewTab ticker={ticker} financials={financials} width={80} />
+    </AppContext>, { width: 80, height: 24 });
+  });
+  await settleFrame(setup!, 10);
+  const frame = setup!.captureCharFrame();
+  expect(frame).toMatch(/Type:\s*ETF/);
+  expect(frame).toContain(profile.description);
+  expect(frame).toMatch(/Div Yield\s+0.00%/);
+  const text = await buildTickerReport({ symbol: "CLASSA", tickerFile: ticker, financials, config, toBase: async v => v });
+  expect(text).toContain("Type ETF");
+  expect(text).toContain(profile.description);
+  expect(text).toContain("0.00%");
+  let captured: any;
+  let warnings: string[] | undefined;
+  let closed = 0;
+  await runTickerCommand("CLASSA", {
+    initMarketData: async () => ({
+      config, dataDir: "/tmp/gloom-fund-profile-test-unused", store: { loadTicker: async () => ticker }, persistence: { close: () => { closed++; } },
+      dataProvider: { ...createTestDataProvider({ getTickerFinancials: async () => financials }), getNews: async () => [] },
+    }) as unknown as MarketContext,
+    fail: message => { throw new Error(message); }, printResult: result => { captured = result.data; warnings = result.warnings; },
+  });
+  expect(closed).toBe(1);
+  expect(captured.profile).toEqual(profile);
+  expect(captured.fundamentals.dividendYield).toBe(0);
+  expect(captured.quote?.instrumentType ?? captured.quoteMetadata?.instrumentType).toBe("ETF");
+  expect(ticker.metadata.assetCategory).toBe("STK");
+  if (!quoted) {
+    expect(captured.quote).toBeNull();
+    expect(warnings).toEqual(["Quote unavailable."]);
+    expect(text).toContain("Quote unavailable.");
+    expect(text).not.toContain("Last:");
+  }
+});
+
+for (const scenario of ["zero", "nonfinite", "empty", "legacy-return", "covered-return"] as const) test(`quote-free ticker report availability: ${scenario}`, async () => {
+  const valid = scenario === "zero" || scenario === "covered-return";
+  const financials: TickerFinancials = {
+    fundamentals: scenario === "zero" ? { dividendYield: 0 }
+      : scenario === "nonfinite" ? { dividendYield: Number.NaN }
+        : scenario === "legacy-return" ? { return1Y: .05, return3Y: .05 } : undefined,
+    annualStatements: [], quarterlyStatements: [],
+    priceHistory: scenario === "covered-return" ? [{ date: new Date("2025-09-10"), close: 100 }, { date: new Date("2026-09-11"), close: 100 }] : [],
+  };
+  let captured: any;
+  let closed = 0;
+  const command = runTickerCommand("CLASSA", {
+    initMarketData: async () => ({
+      config, dataDir: "/tmp/gloom-fund-profile-test-unused", store: { loadTicker: async () => ticker }, persistence: { close: () => { closed++; } },
+      dataProvider: { ...createTestDataProvider({ getTickerFinancials: async () => financials }), getNews: async () => [] },
+    }) as unknown as MarketContext,
+    fail: message => { throw new Error(message); }, printResult: result => { captured = result.data; },
+  });
+  if (valid) { await command; expect(scenario === "zero" ? captured.fundamentals.dividendYield : captured.fundamentals.return1Y).toBe(0); }
+  else { await expect(command).rejects.toThrow("No research data available"); expect(captured).toBeUndefined(); }
+  expect(closed).toBe(1);
+});
+
+
+test("blank source type cannot hide retained fund classification while reports skip blanks", async () => {
+  const savedFund = createTestTicker("CLASSA", "Controlled fund", { assetCategory: "ETF" });
+  for (const quoted of [true, false]) {
+    const financials: TickerFinancials = {
+      ...(quoted ? { quote: { ...quote, instrumentType: " " } } : {}),
+      quoteMetadata: { symbol: "CLASSA", instrumentType: quoted ? "ETF" : " ", source: {} },
+      profile, annualStatements: [], quarterlyStatements: [], priceHistory: [],
+    };
+    expect(await buildTickerReport({ symbol: "CLASSA", tickerFile: savedFund, financials, config, toBase: async v => v })).toContain("Type ETF");
+    expect(financials.quote?.instrumentType).toBe(quoted ? " " : undefined);
+    expect(financials.quoteMetadata?.instrumentType).toBe(quoted ? "ETF" : " ");
+  }
+});
+
+
+test("quote-free reported capitalization retains source units, zero, and provenance without borrowing unknown units", async () => {
+  for (const [marketCap, currency] of [[200_000_000, "GBP"], [0, "USD"], [200_000_000, undefined]] as const) {
+    const financials: TickerFinancials = { annualStatements: [], quarterlyStatements: [], priceHistory: [],
+      fundamentals: { marketCap, marketCapCurrency: currency, source: "yahoo", fetchedAt: "2026-09-11T14:00:00Z", stale: true },
+    };
+    const text = await buildTickerReport({ symbol: "CLASSA", tickerFile: ticker, financials, config, toBase: async () => Number.NaN });
+    if (currency) {
+      expect(text).toContain(currency === "GBP" ? "200M GBP" : "0 USD");
+      expect(text).toContain("yahoo fundamentals");
+      expect(text).toContain("stale; valuation date unavailable");
+    } else expect(text).not.toContain("Market Cap");
+    expect(text).toContain("Quote unavailable.");
+    expect(financials.fundamentals?.marketCap).toBe(marketCap);
+  }
+});

package/src/plugins/builtin/ticker-detail/headless-schema.ts

@@ -0,0 +1,59 @@
+import type { HeadlessPaneDefinition } from "../../../types/headless";
+import { FINANCIAL_PERIOD_OPTION, HISTORY_RANGE_VALUES } from "../shared/headless-options";
+
+type PaneSchema = Pick<HeadlessPaneDefinition, "argument" | "options" | "discovery">;
+
+export const paneSchemas = {
+  "financial-analysis-pane": {
+    argument: { kind: "ticker" },
+    options: [
+      FINANCIAL_PERIOD_OPTION,
+      {
+        key: "statement",
+        description: "Statement to display.",
+        type: "enum",
+        aliases: ["tab", "financialStatement"],
+        values: [
+          { value: "income", aliases: ["income statement", "is"] },
+          { value: "balance", aliases: ["balance sheet", "bs"] },
+          { value: "cashflow", aliases: ["cash flow", "cash flow statement", "cf", "cashflows"] },
+        ],
+        defaultValue: "income",
+      },
+    ],
+    discovery: {
+      id: "financial-statements",
+      aliases: ["financials", "financial statement", "income statement", "balance sheet", "cash flow statement"],
+      limitations: ["One company per invocation; use GF for cross-company metric comparisons."],
+      screenshotReadiness: "ready",
+    },
+  },
+  "quote-monitor-pane": {
+    argument: { kind: "tickers" },
+    options: [],
+    discovery: {
+      id: "quote-comparison",
+      aliases: ["quotes", "stock prices", "market snapshot", "price comparison"],
+      screenshotReadiness: "ready",
+    },
+  },
+  "historical-prices-pane": {
+    argument: { kind: "ticker" },
+    options: [
+      {
+        key: "range",
+        description: "Price-history window.",
+        type: "enum",
+        aliases: ["rangePreset"],
+        values: HISTORY_RANGE_VALUES,
+        defaultValue: "ALL",
+        pluginState: { pluginId: "ticker-research" },
+      },
+    ],
+    discovery: {
+      id: "historical-prices",
+      aliases: ["historical prices", "price history", "ohlcv", "daily prices"],
+      screenshotReadiness: "partial",
+    },
+  },
+} satisfies Record<string, PaneSchema>;

package/src/plugins/builtin/ticker-detail/headless.test.ts

@@ -0,0 +1,165 @@
+import { resolveCanonicalQuote } from "../../../market-data/quotes/resolution";
+import { expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/headless";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { renderHeadlessPaneText } from "../../../cli/pane-functions/headless";
+import { financialStatementsHeadless, historicalPricesHeadless, quoteComparisonHeadless } from "./headless";
+
+function args(symbols: string[], options: HeadlessPaneLoadArgs["options"] = {}): HeadlessPaneLoadArgs {
+  return { symbols, options, argument: symbols, rawArgument: symbols.join(",") };
+}
+
+test("financial statements keep raw values, dated growth cells, and formatted columns without requiring a quote", async () => {
+  const requested: string[] = [];
+  const ctx = {
+    marketData: createTestDataProvider({
+      async getTickerFinancials(symbol, exchange) {
+        requested.push(`${symbol}:${exchange}`);
+        return {
+          financialCurrency: "USD",
+          annualStatements: [
+            { date: "2024-12-31", totalRevenue: 100, dilutedShares: 10 },
+            { date: "2025-12-31", totalRevenue: 150, dilutedShares: 12 },
+          ],
+          quarterlyStatements: [], priceHistory: [],
+        };
+      },
+    }),
+  } as HeadlessPaneContext;
+  const result = await financialStatementsHeadless.load(args(["AAPL:NASDAQ"], { period: "annual", statement: "income" }), ctx);
+  const revenue = result.rows.find((row) => String(row.metric).includes("Revenue"))!;
+  const cells = revenue.cells as Array<{ date: string; value: number; growth: number; formatted: string }>;
+  expect(requested).toEqual(["AAPL:NASDAQ"]);
+  expect(result.metadata).toMatchObject({ symbol: "AAPL:NASDAQ", period: "annual", statement: "income" });
+  expect(revenue["2025-12-31"]).toBe(150);
+  expect(cells[0]).toMatchObject({ date: "2025-12-31", value: 150, growth: 0.5 });
+  const column = result.columns!.find((column) => column.key === "2025-12-31")!;
+  expect(column.format!(150, revenue)).toContain(cells[0]!.formatted);
+  expect(column.format!(150, revenue)).toContain("50");
+  // Exports have no expansion controls: nested dilution data must remain accessible.
+  const shares = result.rows.find((row) => String(row.id) === "dilutedShares:1")!;
+  expect(shares["2025-12-31"]).toBe(12);
+  expect((shares.cells as Array<{ growth: number }>)[0]!.growth).toBeCloseTo(0.2);
+});
+
+test("financial exports distinguish provider dates from SEC period evidence and derived TTM", async () => {
+  const dateEvidence = { accessionNumber: "0000909832-24-000049", filed: "2024-10-09", startDate: "2023-09-04" };
+  const ctx = { marketData: createTestDataProvider({ async getTickerFinancials() {
+    return { annualStatements: [
+      { date: "2023-08-31", currency: "USD", dateSource: "provider" as const, totalRevenue: 100 },
+      { date: "2024-09-01", currency: "USD", dateSource: "sec" as const, providerDate: "2024-08-31", dateEvidence, totalRevenue: 120 },
+    ], quarterlyStatements: ["2025-03-31", "2025-06-30", "2025-09-30", "2025-12-31"].map((date) => ({
+      date, currency: "USD", dateSource: "sec" as const, dateEvidence, totalRevenue: 40,
+    })), priceHistory: [] };
+  } }) } as HeadlessPaneContext;
+  const result = await financialStatementsHeadless.load(args(["COST"], { period: "annual", statement: "income" }), ctx);
+  const columns = result.metadata!.columns as Array<Record<string, unknown>>;
+  expect(columns.find(({ date }) => date === "2024-09-01")).toMatchObject({ dateSource: "sec", providerDate: "2024-08-31", dateEvidence, label: "2024-09-01 USD (SEC date)" });
+  expect(columns.find(({ date }) => date === "2023-08-31")).toMatchObject({ dateSource: "provider", dateEvidence: null, label: "2023-08-31 USD (provider date)" });
+  expect(columns.find(({ date }) => date === "TTM")).toMatchObject({ dateSource: "derived", dateEvidence: null, providerDate: null });
+  expect(columns.every((column) => column.availableAt === null && column.fieldAvailability === null)).toBe(true);
+  expect(result.columns?.find(({ key }) => key === "2023-08-31")?.header).toContain("provider date");
+});
+
+test("quote comparison retains successful exchange-qualified inputs when a peer fails", async () => {
+  const ctx = {
+    signal: new AbortController().signal,
+    resolveInstrument: async (symbol: string) => ({ symbol, exchange: "NYSE" }),
+    marketData: createTestDataProvider({
+      async getQuote(symbol, exchange) {
+        if (symbol === "MISSING") throw new Error("No quote");
+        expect(exchange).toBe("NYSE");
+        return { symbol, name: "Company", price: 105, change: 5, changePercent: 5, currency: "USD", lastUpdated: 123 };
+      },
+    }),
+  } as HeadlessPaneContext;
+  const result = await quoteComparisonHeadless.load(args(["ABC", "MISSING"]), ctx);
+  expect(result.rows).toEqual([{ symbol: "ABC", name: "Company", price: 105, change: 5, changePercent: 5, currency: "USD", marketCap: null, updatedAt: 123 }]);
+  expect(result.unavailableSymbols).toEqual(["MISSING"]);
+  expect(result.errors).toEqual(["MISSING: No quote"]);
+});
+
+test("quote monitor exports retain FX precision and small changes without altering raw values", async () => {
+  // Retained public EUR/USD quote fields; provider retrieval is not replayed here.
+  const quote = { symbol: "EURUSD=X", name: "EUR/USD", instrumentType: "CURRENCY",
+    price: 1.1602274179458618, change: -0.0010778820541381684,
+    changePercent: -0.09281642425451501, currency: "USD", lastUpdated: 1789162140000 };
+  const ctx = { signal: new AbortController().signal, marketData: createTestDataProvider({ getQuote: async () => quote }) } as HeadlessPaneContext;
+  const input = args([quote.symbol]);
+  const result = await quoteComparisonHeadless.load(input, ctx);
+  expect(result.rows[0]).toMatchObject({ price: quote.price, change: quote.change, instrumentType: "CURRENCY" });
+  const text = renderHeadlessPaneText(quoteComparisonHeadless, result, input, "Quote Monitor");
+  expect(text).toContain("$1.160227");
+  expect(text).toContain("-$0.001078");
+  expect(text).not.toContain("-$0.00 ");
+  const priceColumn = quoteComparisonHeadless.columns!.find(({ key }) => key === "price")!;
+  expect(priceColumn.format!(0.00651236716657877, { instrumentType: "CURRENCY", currency: "USD" })).toBe("$0.006512");
+  expect(priceColumn.format!(null, { currency: "USD" })).toBe("—");
+});
+
+test("historical prices use remembered exchanges and clip and sort the full OHLCV history", async () => {
+  const requests: unknown[] = [];
+  const ctx = {
+    resolveInstrument: async () => ({ symbol: "ABC", exchange: "LSE" }),
+    marketData: createTestDataProvider({
+      async getPriceHistory(...request) {
+        requests.push(request);
+        return [
+          { date: new Date("2026-03-09"), open: 20, high: 23, low: 19, close: 22, volume: 100 },
+          { date: new Date("2026-01-01"), close: 10 },
+          { date: new Date("2026-03-01"), close: 18 },
+        ];
+      },
+    }),
+  } as HeadlessPaneContext;
+  const result = await historicalPricesHeadless.load(args(["ABC"], { range: "1M" }), ctx);
+  expect(requests).toEqual([["ABC", "LSE", "1M"]]);
+  expect(result.rows.map((row) => row.close)).toEqual([18, 22]);
+  expect(result.rows[1]).toEqual({ date: "2026-03-09T00:00:00.000Z", open: 20, high: 23, low: 19, close: 22, volume: 100 });
+});
+
+test("historical price exports preserve tiny OHLC values without changing raw data", async () => {
+  const point = { date: new Date("2026-09-10"), open: 0.00000531, high: 0.00000542, low: 0.00000501, close: 0.00000532, volume: 123456 };
+  const ctx = { marketData: createTestDataProvider({ getPriceHistory: async () => [point] }) } as HeadlessPaneContext;
+  const result = await historicalPricesHeadless.load(args(["SHIB-USD:CCC"]), ctx);
+  const row = result.rows[0]!;
+  for (const key of ["open", "high", "low", "close"] as const) {
+    const column = historicalPricesHeadless.columns!.find((column) => column.key === key)!;
+    expect(row[key]).toBe(point[key]);
+    expect(Number(column.format!(row[key], row))).toBe(point[key]);
+    expect(column.format!(0, row)).toBe("0.00");
+    expect(column.format!(null, row)).toBe("-");
+    expect(column.format!(123.45, row)).toBe("123.45");
+  }
+});
+
+test("financial JSON exports preserve selected metric availability separately from fiscal-period evidence", async () => {
+  const fieldAvailability = { totalRevenue: "2018-08-03", netIncome: "2018-08-03", capitalExpenditure: "2017-08-02" };
+  const dateEvidence = { accessionNumber: "0001564590-17-014900", filed: "2017-08-02", startDate: "2016-07-01" };
+  const ctx = { marketData: createTestDataProvider({ getTickerFinancials: async () => ({
+    annualStatements: [{ date: "2017-06-30", currency: "USD", dateSource: "sec", dateEvidence, availableAt: "2018-08-03", fieldAvailability, totalRevenue: 96_571_000_000, netIncome: 25_489_000_000 }],
+    quarterlyStatements: [], priceHistory: [],
+  }) }) } as HeadlessPaneContext;
+  const result = await financialStatementsHeadless.load(args(["MSFT"], { period: "annual", statement: "income" }), ctx);
+  const restored = JSON.parse(JSON.stringify(result));
+  expect(restored.metadata.columns[0]).toMatchObject({ date: "2017-06-30", dateEvidence, availableAt: "2018-08-03", fieldAvailability });
+  expect(restored.rows.find((row: { metric: string }) => row.metric.includes("Revenue"))["2017-06-30"]).toBe(96_571_000_000);
+});
+
+
+test("canonical missing changes survive JSON roundtrip into default Quote Monitor text beside zero and derived change", async () => {
+  const base = { symbol: "MISSING", price: 12, currency: "USD", lastUpdated: Date.now(), marketState: "CLOSED" };
+  const inputs = [base, { ...base, symbol: "ZERO", change: 0, changePercent: 0 }, { ...base, symbol: "DERIVED", previousClose: 10 }];
+  const quotes = inputs.map(quote => resolveCanonicalQuote({ quote }).quote!);
+  expect(quotes[0]!.change).toBeNaN();
+  expect(quotes[0]!.changePercent).toBeNaN();
+  const ctx = { signal: new AbortController().signal, marketData: createTestDataProvider({ getQuote: async symbol => quotes.find(quote => quote.symbol === symbol)! }) } as HeadlessPaneContext;
+  const input = args(["MISSING", "ZERO", "DERIVED"]);
+  const model = await quoteComparisonHeadless.load(input, ctx);
+  const transported = JSON.parse(JSON.stringify(model));
+  expect(transported.rows[0]).toMatchObject({ change: null, changePercent: null });
+  const text = renderHeadlessPaneText(quoteComparisonHeadless, transported, input, "Quote Monitor");
+  expect(text.split("\n").find(line => line.trim().startsWith("MISSING "))).not.toContain("0.00%");
+  expect(text.split("\n").find(line => line.trim().startsWith("ZERO "))).toContain("0.00%");
+  expect(text.split("\n").find(line => line.trim().startsWith("DERIVED "))).toContain("+20.00%");
+});

package/src/plugins/builtin/ticker-detail/headless.ts

@@ -0,0 +1,150 @@
+import { FINANCIAL_VINTAGE_NOTICE } from "../../../utils/financial-statements";
+import { hasValidQuoteObservationTime } from "../../../market-data/quotes/freshness";
+import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/headless";
+import type { TimeRange } from "../../../time-series/range";
+import { formatNumber, formatPercentRaw } from "../../../utils/format";
+import { formatMarketPrice, formatMarketPriceWithCurrency, formatPriceObservation } from "../../../market-data/market/format";
+import { pricePointValues, priceHistoryIntegrityNotice } from "../../../utils/price-history-integrity";
+import { buildFinancialTableModel, financialStatementCurrency, financialStatementDateNotice, financialStatementLimitations, formatFinancialHeader } from "./financials/model";
+import { paneSchemas } from "./headless-schema";
+import {
+  loadHeadlessFinancials, loadHeadlessPriceHistory, loadHeadlessSymbols, resolveHeadlessInstrument,
+} from "../shared/headless-market-data";
+
+export const financialStatementsHeadless: HeadlessPaneDefinition<"rows"> = {
+  ...paneSchemas["financial-analysis-pane"],
+  shape: "rows",
+  describe: ({ symbols, options }) => `Financial Statements | ${symbols[0]} | ${options.period} | ${options.statement}`,
+  async load({ symbols, options }, ctx) {
+    const symbol = symbols[0]!;
+    const financials = await loadHeadlessFinancials(ctx, symbol);
+    const requestedPeriod = options.period === "quarterly" ? "quarterly" : "annual";
+    const hasRequestedStatements = (requestedPeriod === "quarterly"
+      ? financials.quarterlyStatements : financials.annualStatements).length > 0;
+    // The interactive tabs visibly select their fallback. A headless request
+    // has no such selection change, so it must keep the requested period.
+    const table = hasRequestedStatements ? buildFinancialTableModel(financials, {
+      period: requestedPeriod,
+      statement: String(options.statement ?? "income"),
+      expandAll: true,
+    }) : null;
+    const statementCurrency = financialStatementCurrency(financials, [
+      ...financials.annualStatements, ...financials.quarterlyStatements,
+    ]);
+    const dates = table?.statements.map(({ date, currency, dateSource, providerDate, dateEvidence, availableAt, fieldAvailability, fieldSources, unavailableFields, withdrawnObservations, epsBasis, aggregation }) => ({
+      date, currency: currency ?? statementCurrency ?? null,
+      availableAt: availableAt ?? null,
+      fieldAvailability: fieldAvailability ? { ...fieldAvailability } : null,
+      ...(fieldSources ? { fieldSources } : {}),
+      ...(unavailableFields ? { unavailableFields } : {}),
+      ...(withdrawnObservations ? { withdrawnObservations } : {}),
+      ...(epsBasis ? { epsBasis } : {}),
+      ...(aggregation ? { aggregation } : {}),
+      dateSource: date === "TTM" ? "derived" : dateSource ?? "provider",
+      providerDate: date === "TTM" ? null : providerDate ?? null,
+      dateEvidence: date === "TTM" || dateSource !== "sec" ? null : dateEvidence ?? null,
+      label: formatFinancialHeader(date, currency ?? statementCurrency, dateSource, false, aggregation?.periodEnd).trim(),
+    })) ?? [];
+    const rows = table?.rows.map((row) => ({
+      id: row.id, kind: row.kind, metric: row.unitLabel,
+      cells: row.cells.map((cell, index) => ({
+        date: dates[index]?.date ?? "", value: cell.value ?? null,
+        growth: cell.growth ?? null, formatted: cell.valueText.trim(), growthFormatted: cell.growthText.trim(),
+      })),
+      ...Object.fromEntries(row.cells.map((cell, index) => [dates[index]!.date, cell.value ?? null])),
+    })) ?? [];
+    const columns: HeadlessPaneColumn[] = [
+      { key: "metric", header: "Metric" },
+      ...dates.map(({ date, label }, index) => ({
+        key: date, header: label, align: "right" as const,
+        format: (_value: unknown, row: Record<string, unknown>) => {
+          const cell = (row.cells as Array<{ formatted: string; growthFormatted: string }>)[index]!;
+          return [cell.formatted, cell.growthFormatted].filter(Boolean).join(" ");
+        },
+      })),
+    ];
+    return {
+      rows, columns, unavailableSymbols: rows.length ? [] : [symbol],
+      ...(!hasRequestedStatements ? { errors: [`${symbol}: No ${requestedPeriod} financial statement coverage.`] } : {}),
+      metadata: {
+        symbol, name: financials.quote?.name ?? symbol, currency: statementCurrency ?? null, quoteCurrency: financials.quote?.currency ?? null,
+        statement: table?.subTab.key ?? options.statement, statementLabel: table?.subTab.name ?? null,
+        period: requestedPeriod, growthBasis: requestedPeriod === "quarterly" ? "QoQ" : "YoY", columns: dates,
+        notices: rows.length ? [FINANCIAL_VINTAGE_NOTICE] : [],
+        limitations: financialStatementLimitations(financials),
+        dateProvenance: financialStatementDateNotice(table?.statements ?? []),
+      },
+    };
+  },
+};
+
+function quoteAmount(value: unknown, row: Record<string, unknown>, signed = false): string {
+  if (typeof value !== "number" || !Number.isFinite(value)) return "—";
+  const options = { assetCategory: typeof row.instrumentType === "string" ? row.instrumentType : undefined,
+    priceBasis: row.priceBasis === "per-unit" || row.priceBasis === "percent-of-par" ? row.priceBasis : undefined, minimumFractionDigits: 2 } as const;
+  const amount = typeof row.currency === "string" && row.currency.trim()
+    ? formatMarketPriceWithCurrency(value, row.currency, options)
+    : formatMarketPrice(value, options);
+  return amount === "—" ? amount : `${signed && value >= 0 ? "+" : ""}${amount}`;
+}
+
+export const quoteComparisonHeadless: HeadlessPaneDefinition<"rows"> = {
+  ...paneSchemas["quote-monitor-pane"],
+  shape: "rows",
+  describe: ({ symbols }) => `Quote Monitor | ${symbols.join(", ")}`,
+  columns: [
+    { key: "symbol", header: "Ticker" },
+    { key: "name", header: "Name" },
+    { key: "price", header: "Last", align: "right", format: (value, row) => quoteAmount(value, row) },
+    { key: "change", header: "Change", align: "right", format: (value, row) => quoteAmount(value, row, true) },
+    { key: "changePercent", header: "Change %", align: "right", format: (value) => formatPercentRaw(typeof value === "number" && Number.isFinite(value) ? value : undefined) },
+  ],
+  async load({ symbols }, ctx) {
+    const loaded = await loadHeadlessSymbols(symbols, ctx, async (key) => {
+      const { symbol, exchange } = await resolveHeadlessInstrument(ctx, key);
+      const quote = await ctx.marketData.getQuote(symbol, exchange);
+      if (!quote) throw new Error(`Quote is unavailable for ${key}`);
+      if (!hasValidQuoteObservationTime(quote)) throw new Error(`Quote observation time is unavailable for ${key}`);
+      return quote;
+    });
+    return {
+      rows: loaded.entries.map(({ symbol, data: quote }) => ({
+        symbol, name: quote.name ?? "", price: quote.price, currency: quote.currency,
+        ...(quote.instrumentType ? { instrumentType: quote.instrumentType } : {}),
+        ...(quote.priceBasis ? { priceBasis: quote.priceBasis } : {}),
+        change: quote.change, changePercent: quote.changePercent,
+        marketCap: quote.marketCap ?? null, updatedAt: quote.lastUpdated,
+      })),
+      unavailableSymbols: loaded.unavailableSymbols, errors: loaded.errors,
+    };
+  },
+};
+
+export const historicalPricesHeadless: HeadlessPaneDefinition<"rows"> = {
+  ...paneSchemas["historical-prices-pane"],
+  shape: "rows",
+  describe: ({ symbols, options }) => `Historical Prices | ${symbols[0]} | ${options.range ?? "ALL"}`,
+  columns: [
+    { key: "date", header: "Date", format: (value) => String(value).slice(0, 10) },
+    ...["open", "high", "low", "close", "volume"].map((key) => ({
+      key, header: key, align: "right" as const,
+      format: (value: unknown) => value == null || !Number.isFinite(Number(value)) ? "-"
+        : key === "volume" ? formatNumber(Number(value), 0)
+        : formatPriceObservation(Number(value), { minimumFractionDigits: 2 }),
+    })),
+  ],
+  async load({ symbols, options }, ctx) {
+    const symbol = symbols[0]!;
+    const range = (options.range ?? "ALL") as TimeRange;
+    const points = await loadHeadlessPriceHistory(ctx, symbol, range);
+    const rows = points.map((point) => {
+      const date = new Date(point.date);
+      return {
+        date: Number.isFinite(date.getTime()) ? date.toISOString() : String(point.date),
+        ...pricePointValues(point),
+      };
+    }).sort((left, right) => left.date.localeCompare(right.date));
+    const notice = priceHistoryIntegrityNotice(rows.filter((row) => row.integrity).length);
+    return { rows, ...(notice ? { complete: false } : {}), unavailableSymbols: rows.some((row) => row.close !== null) ? [] : [symbol], metadata: { symbol, range, ...(notice ? { notices: [notice] } : {}) } };
+  },
+};

package/src/plugins/builtin/ticker-detail/index.tsx

@@ -1,3 +1,4 @@
+import { publicTickerBindingSymbol } from "../../../tickers/selection";
 import type { PluginModule } from "../plugin-module";
 import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
 import { normalizeTickerInput } from "../../../tickers/search";
@@ -7,6 +8,7 @@ import { HistoricalPricesPane } from "./data-panes/historical-prices";
 import { TickerResearchPane } from "./pane";
 import { TICKER_RESEARCH_BUILTIN_TABS } from "./research-tabs";
 import { QuoteMonitorPane } from "./quote-monitor";
+import { financialStatementsHeadless, historicalPricesHeadless, quoteComparisonHeadless } from "./headless";
 import {
   buildQuoteMonitorSettingsDef,
   buildQuoteMonitorPaneTitle,
@@ -45,6 +47,7 @@ export const tickerDetailModule: PluginModule = {
       name: "Financials",
       icon: "F",
       component: FinancialAnalysisPane,
+      headless: financialStatementsHeadless,
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 98, height: 30 },
@@ -55,6 +58,7 @@ export const tickerDetailModule: PluginModule = {
       name: "Quote Monitor",
       icon: "Q",
       component: QuoteMonitorPane,
+      headless: quoteComparisonHeadless,
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 72, height: 10 },
@@ -66,6 +70,7 @@ export const tickerDetailModule: PluginModule = {
       name: "Historical Prices",
       icon: "H",
       component: HistoricalPricesPane,
+      headless: historicalPricesHeadless,
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 92, height: 26 },
@@ -90,16 +95,17 @@ export const tickerDetailModule: PluginModule = {
           : {}
       ),
       publicShare: {
-        serialize: ({ pane }) => pane.binding?.kind === "fixed" && pane.binding.symbol.trim()
-          ? { title: pane.title?.trim() || pane.binding.symbol, data: { symbol: pane.binding.symbol.trim().toUpperCase() } }
+        serialize: ({ pane }) => pane.binding?.kind === "fixed" && publicTickerBindingSymbol(pane.binding)
+          ? { title: pane.title?.trim() || pane.binding.symbol, data: { symbol: publicTickerBindingSymbol(pane.binding)! } }
           : null,
         restore: (data) => Object.keys(data).length === 1 && typeof data.symbol === "string" && data.symbol.trim()
-          ? { symbol: data.symbol.trim().toUpperCase() }
+          ? { symbol: data.symbol.trim().toUpperCase(), instrument: null }
           : null,
       },
     },
     {
       id: "quote-monitor-pane",
+      headless: quoteComparisonHeadless,
       paneId: "quote-monitor",
       label: "Quote Monitor",
       description: "Open a compact quote monitor for one or more tickers",
@@ -137,24 +143,30 @@ export const tickerDetailModule: PluginModule = {
           : null;
       },
     },
-    createTickerSurfacePaneTemplate({
-      id: "historical-prices-pane",
-      paneId: "historical-prices",
-      label: "Historical Prices",
-      description: "Open a historical OHLCV table for a ticker.",
-      keywords: ["historical", "prices", "hp", "ohlc", "volume"],
-      shortcut: "HP",
-      publicShare: true,
-    }),
-    createTickerSurfacePaneTemplate({
-      id: "financial-analysis-pane",
-      paneId: "financial-analysis",
-      label: "Financial Analysis",
-      description: "Open financial statements for a ticker.",
-      keywords: ["fa", "financial", "analysis", "statements"],
-      shortcut: "FA",
-      publicShare: true,
-      titlePrefix: "FA",
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "historical-prices-pane",
+        paneId: "historical-prices",
+        label: "Historical Prices",
+        description: "Open a historical OHLCV table for a ticker.",
+        keywords: ["historical", "prices", "hp", "ohlc", "volume"],
+        shortcut: "HP",
+        publicShare: true,
+      }),
+      headless: historicalPricesHeadless,
+    },
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "financial-analysis-pane",
+        paneId: "financial-analysis",
+        label: "Financial Analysis",
+        description: "Open financial statements for a ticker.",
+        keywords: ["fa", "financial", "analysis", "statements"],
+        shortcut: "FA",
+        publicShare: true,
+        titlePrefix: "FA",
+      }),
+      headless: financialStatementsHeadless,
+    },
   ],
 };