gloomberb 0.13.3 → 0.14.0

package/src/plugins/builtin/chart-composer/headless-schema.ts

@@ -0,0 +1,221 @@
+import type { HeadlessPaneDefinition } from "../../../types/headless";
+import { FINANCIAL_PERIOD_OPTION, FINANCIAL_PERIOD_COUNT_OPTION, HISTORY_RANGE_VALUES } from "../shared/headless-options";
+
+type PaneSchema = Pick<HeadlessPaneDefinition, "argument" | "options" | "discovery">;
+
+export const paneSchemas = {
+  "chart-composer-pane": {
+    argument: { kind: "free-text", optional: true },
+    options: [
+      {
+        key: "rangePreset",
+        description: "Chart history window.",
+        type: "enum",
+        aliases: ["range"],
+        values: HISTORY_RANGE_VALUES,
+      },
+      {
+        key: "chartResolution",
+        description: "Market-price sampling resolution.",
+        type: "enum",
+        aliases: ["resolution"],
+        values: [
+          { value: "auto" },
+          { value: "1m" },
+          { value: "5m" },
+          { value: "15m" },
+          { value: "30m" },
+          { value: "45m" },
+          { value: "1h" },
+          { value: "1d" },
+          { value: "1wk" },
+          { value: "1mo" },
+        ],
+      },
+    ],
+    discovery: {
+      id: "chart-composer",
+      aliases: ["custom chart", "mixed series chart", "chart composer", "economic chart"],
+      limitations: ["FRED observations do not include historical vintage availability dates."],
+      screenshotReadiness: "ready",
+    },
+  },
+  "graph-price-pane": {
+    argument: { kind: "ticker" },
+    options: [
+      {
+        key: "rangePreset",
+        settingKey: "chartRangePreset",
+        description: "Chart history window.",
+        type: "enum",
+        aliases: ["range"],
+        values: HISTORY_RANGE_VALUES,
+        defaultValue: "5Y",
+      },
+    ],
+    discovery: {
+      id: "price-chart",
+      aliases: ["price chart", "stock chart", "historical chart"],
+      screenshotReadiness: "ready",
+    },
+  },
+  "graph-intraday-price-pane": {
+    argument: { kind: "ticker" },
+    options: [
+      {
+        key: "rangePreset",
+        description: "Session window. 1D selects the latest session and 1W selects the latest five sessions.",
+        type: "enum",
+        aliases: ["range"],
+        values: [{ value: "1D", aliases: ["day", "daily"] }, { value: "1W", aliases: ["week", "weekly"] }],
+        defaultValue: "1D",
+      },
+      {
+        key: "chartResolution",
+        description: "Intraday sampling interval. Auto uses 1m for 1D and 5m for 1W.",
+        type: "enum",
+        aliases: ["resolution"],
+        values: [{ value: "auto" }, { value: "5m" }, { value: "15m" }, { value: "1h" }],
+        defaultValue: "auto",
+      },
+      {
+        key: "session",
+        description: "Specific exchange-local session in YYYY-MM-DD form. Overrides the session window.",
+        type: "string",
+      },
+    ],
+    discovery: {
+      id: "intraday-price-chart",
+      aliases: ["intraday chart", "intraday price", "one day chart"],
+      limitations: ["Intraday availability and historical retention depend on the selected market-data provider."],
+      screenshotReadiness: "ready",
+    },
+  },
+  "comparison-chart-pane": {
+    argument: { kind: "tickers", minimum: 2 },
+    options: [
+      {
+        key: "rangePreset",
+        description: "Price-history window.",
+        type: "enum",
+        aliases: ["range"],
+        values: HISTORY_RANGE_VALUES,
+        defaultValue: "1Y",
+      },
+      {
+        key: "axisMode",
+        description: "Display raw price or normalized percentage performance.",
+        type: "enum",
+        values: [
+          { value: "percent", aliases: ["return", "returns", "performance"] },
+          { value: "price", aliases: ["prices"] },
+        ],
+        defaultValue: "percent",
+      },
+      {
+        key: "chartResolution",
+        description: "Price sampling resolution.",
+        type: "enum",
+        aliases: ["resolution"],
+        values: [
+          { value: "1m" },
+          { value: "5m" },
+          { value: "15m" },
+          { value: "30m" },
+          { value: "45m" },
+          { value: "1h" },
+          { value: "1d" },
+          { value: "1wk" },
+          { value: "1mo" },
+        ],
+        defaultValue: "1d",
+      },
+    ],
+    discovery: {
+      id: "price-comparison",
+      aliases: ["stock comparison", "price performance comparison", "returns comparison", "compare stock prices"],
+      limitations: ["Compares closing-price changes in each listing's currency over shared observation dates. Cash distributions and FX conversion are excluded; these are not reinvested total returns."],
+      screenshotReadiness: "ready",
+    },
+  },
+  "fundamental-graph-pane": {
+    argument: { kind: "tickers" },
+    options: [
+      {
+        key: "metric",
+        description: "Fundamental metric to compare.",
+        type: "enum",
+        values: [
+          { value: "totalRevenue", aliases: ["revenue", "sales"] },
+          { value: "grossProfit", aliases: ["gross profit"] },
+          { value: "grossMargin", aliases: ["gross margin"] },
+          { value: "operatingIncome", aliases: ["operating income", "ebit"] },
+          { value: "operatingMargin", aliases: ["operating margin"] },
+          { value: "netIncome", aliases: ["net income", "profit", "earnings"] },
+          { value: "netMargin", aliases: ["net margin", "profit margin"] },
+          { value: "operatingCashFlow", aliases: ["operating cash flow", "cash flow", "ocf"] },
+          { value: "freeCashFlow", aliases: ["free cash flow", "fcf"] },
+          { value: "freeCashFlowMargin", aliases: ["free cash flow margin", "fcf margin"] },
+          { value: "totalAssets", aliases: ["assets", "total assets"] },
+          { value: "totalDebt", aliases: ["debt", "total debt"] },
+          { value: "totalEquity", aliases: ["equity", "book value"] },
+          { value: "eps", aliases: ["earnings per share"] },
+        ],
+        defaultValue: "totalRevenue",
+      },
+      FINANCIAL_PERIOD_OPTION,
+      FINANCIAL_PERIOD_COUNT_OPTION,
+    ],
+    discovery: {
+      id: "fundamental-series",
+      aliases: [
+        "fundamental comparison",
+        "financial metric comparison",
+        "cash flow comparison",
+        "revenue comparison",
+        "earnings comparison",
+        "operating cash flow",
+        "free cash flow",
+        "fcf",
+        "ocf",
+      ],
+      limitations: ["One metric per invocation; run twice when both operating and free cash flow are requested."],
+      screenshotReadiness: "ready",
+    },
+  },
+  "valuation-graph-pane": {
+    argument: { kind: "tickers" },
+    options: [
+      {
+        key: "metric",
+        description: "Valuation metric to compare.",
+        type: "enum",
+        values: [
+          { value: "trailingPE", aliases: ["pe", "p/e", "trailing pe"] },
+          { value: "forwardPE", aliases: ["forward pe", "forward p/e"] },
+          { value: "pegRatio", aliases: ["peg", "peg ratio"] },
+          { value: "priceSales", aliases: ["price sales", "price to sales", "p/s"] },
+          { value: "evSales", aliases: ["ev sales", "ev/sales"] },
+          { value: "evEbitda", aliases: ["ev ebitda", "ev/ebitda"] },
+          { value: "priceFcf", aliases: ["price fcf", "price to free cash flow", "p/fcf"] },
+        ],
+        // The same metric the GE template opens with in the app.
+        defaultValue: "trailingPE",
+      },
+      FINANCIAL_PERIOD_OPTION,
+      FINANCIAL_PERIOD_COUNT_OPTION,
+    ],
+    discovery: {
+      id: "valuation-series",
+      aliases: [
+        "valuation comparison",
+        "multiple comparison",
+        "pe comparison",
+        "price to sales comparison",
+        "ev ebitda",
+      ],
+      limitations: ["Historical multiples require usable prices and statement share counts."],
+      screenshotReadiness: "ready",
+    },
+  },
+} satisfies Record<string, PaneSchema>;

package/src/plugins/builtin/chart-composer/headless.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, test } from "bun:test";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { HeadlessPaneContext } from "../../../types/headless";
+import { chartHeadless, type ChartPaneModel } from "./headless";
+import { buildCustomChartPreset, buildIntradayPriceChartPreset, setPairStudies } from "./presets";
+
+const history = ["2026-08-27", "2026-08-28", "2026-08-31", "2026-09-01", "2026-09-02", "2026-09-03"]
+  .flatMap((date, day) => [0, 1].map((bar) => ({
+    date: new Date(`${date}T13:${bar ? "35" : "30"}:00Z`),
+    open: 100 + day, high: 102 + day, low: 99 + day, close: 101 + day, volume: 100,
+  })));
+
+function fixture() {
+  const calls: Array<{ kind: string; start?: Date; end?: Date; range?: string; resolution?: string }> = [];
+  const spec = buildIntradayPriceChartPreset("AAPL:NASDAQ");
+  const context: HeadlessPaneContext = {
+    marketData: createTestDataProvider({
+      getTickerFinancials: async () => ({ annualStatements: [], quarterlyStatements: [], priceHistory: [] }),
+      getQuote: async () => ({ symbol: "AAPL", price: 106, change: 0, changePercent: 0, currency: "USD", lastUpdated: Date.now() }),
+      getPriceHistoryForResolution: async (_symbol, _exchange, range, resolution) => {
+        calls.push({ kind: "trailing", range, resolution });
+        return history;
+      },
+      getDetailedPriceHistory: async (_symbol, _exchange, start, end, resolution) => {
+        calls.push({ kind: "detailed", start, end, resolution });
+        return history.filter((point) => point.date >= start && point.date < end);
+      },
+    }),
+    apiClient: {} as HeadlessPaneContext["apiClient"],
+    config: createDefaultConfig("/tmp/gloom-headless-chart"),
+    signal: new AbortController().signal,
+    settings: { chartSpec: spec },
+  };
+  return { spec, context, calls, load: async (options = {}) => await chartHeadless("graph-intraday-price-pane").load({
+    argument: "AAPL:NASDAQ", rawArgument: "AAPL:NASDAQ", symbols: ["AAPL:NASDAQ"], options,
+  }, context) as ChartPaneModel };
+}
+
+test("an unavailable currency spread reaches headless errors even with normalized chart presentation", async () => {
+  for (const currency of ["EUR", ""]) for (const transform of ["raw", "percent"] as const) {
+    const quote = (symbol: string) => ({ symbol, price: 100, change: 0, changePercent: 0,
+      currency: symbol === "TARGET" ? "USD" : currency, instrumentType: "EQUITY" as const,
+      lastUpdated: Date.parse("2026-09-03T13:35:00Z") });
+    const provider = createTestDataProvider({
+      getTickerFinancials: async (symbol) => ({ quote: quote(symbol), annualStatements: [], quarterlyStatements: [], priceHistory: [] }),
+      getQuote: async (symbol) => quote(symbol),
+      getQuoteMetadata: async (symbol) => ({ symbol, currency: quote(symbol).currency, instrumentType: "EQUITY" }),
+      getDetailedPriceHistory: async () => history,
+      getPriceHistoryForResolution: async () => history,
+    });
+    const spec = setPairStudies(buildCustomChartPreset("TARGET:NASDAQ:market.close,ACQUIRER:NASDAQ:market.close"), ["spread", "ratio"]);
+    spec.viewport.dateWindow = { start: "2026-08-27", end: "2026-09-04" };
+    spec.series = spec.series.map((series) => ({ ...series, transform }));
+    const result = await chartHeadless("chart-composer-pane").load({
+      argument: "TARGET:NASDAQ,ACQUIRER:NASDAQ", rawArgument: "TARGET:NASDAQ,ACQUIRER:NASDAQ", symbols: ["TARGET:NASDAQ", "ACQUIRER:NASDAQ"], options: {},
+    }, { ...fixture().context, marketData: provider, settings: { chartSpec: spec } });
+    expect(result.errors).toEqual([expect.stringContaining("pair:spread: spread cannot subtract")]);
+    expect(result.unavailableSymbols).toEqual([]);
+    expect(result.series.map(({ id }) => id)).toEqual([...spec.series.map(({ id }) => id), "pair:ratio"]);
+    expect(result.series.every(({ points }) => points.length > 0)).toBe(true);
+  }
+});
+
+describe("GIP headless sessions", () => {
+  test("selects the latest one/five sessions or a historical session, retaining its last bar without another history fetch", async () => {
+    for (const [range, session, days] of [["1D", undefined, 1], ["1W", undefined, 5], ["1W", "2026-09-01", 1]] as const) {
+      const { spec, calls, load } = fixture();
+      spec.viewport.range = range;
+      spec.viewport.resolution = "auto";
+      const result = await load(session ? { session } : {});
+      const points = result.chart.series[0]!.points;
+      expect(result.errors).toEqual([]);
+      expect(points).toHaveLength(days * 2);
+      expect(points.at(-1)?.date.toISOString()).toBe(`${session ?? "2026-09-03"}T13:35:00.000Z`);
+      expect(calls).toHaveLength(1);
+      if (session) expect(calls[0]).toEqual({ kind: "detailed", start: new Date("2026-09-01T04:00:00Z"), end: new Date("2026-09-02T04:00:00Z"), resolution: "1m" });
+    }
+  });
+
+  test("retains explicit chart windows and reports unavailable sessions instead of substituting daily data", async () => {
+    const { spec, calls, load } = fixture();
+    spec.viewport.dateWindow = { start: "2026-08-28T13:30:00Z", end: "2026-08-31T13:35:00Z" };
+    const explicit = await load();
+    expect(explicit.chart.series[0]!.points).toHaveLength(4);
+    expect(explicit.metadata?.viewport).toEqual(spec.viewport);
+    expect(calls.every((call) => call.kind === "detailed")).toBe(true);
+
+    const missing = await fixture().load({ session: "2020-01-02" });
+    expect(missing.chart.series[0]?.points ?? []).toEqual([]);
+    expect(missing.errors?.some((error) => error.includes("No intraday price history is available for AAPL for session 2020-01-02."))).toBe(true);
+    expect(missing.unavailableSymbols).toEqual(["AAPL:XNAS"]);
+  });
+});
+
+test("chart reports retain raw comparison endpoints and growth preceding a financial observation limit", async () => {
+  const { buildComparisonChartPreset, buildFundamentalChartPreset } = await import("./presets");
+  const { applyChartComposerCapabilityOptions } = await import("./cli-options");
+  const provider = createTestDataProvider({
+    getTickerFinancials: async () => ({
+      annualStatements: [{ date: "2024-12-31", totalRevenue: 100 }, { date: "2025-12-31", totalRevenue: 150 }],
+      quarterlyStatements: [], priceHistory: [],
+    }),
+    getPriceHistoryForResolution: async () => [
+      { date: new Date("2026-08-01"), close: 100 },
+      { date: new Date("2026-09-01"), close: 120 },
+    ],
+  });
+  const context = { ...fixture().context, marketData: provider };
+  const comparison = buildComparisonChartPreset(["AAPL:NASDAQ", "MSFT:NASDAQ"]);
+  const args = { argument: ["AAPL:NASDAQ", "MSFT:NASDAQ"], rawArgument: "AAPL:NASDAQ,MSFT:NASDAQ", symbols: ["AAPL:NASDAQ", "MSFT:NASDAQ"], options: {} };
+  const result = await chartHeadless("comparison-chart-pane").load(args, { ...context, settings: { chartSpec: comparison } });
+  expect(result.series[0]!.points.map(({ value }) => value)).toEqual([0, 20]);
+  expect(result.series[0]!.points.map(({ rawValue }) => rawValue)).toEqual([100, 120]);
+  expect(result.metadata?.summaries).toEqual(expect.arrayContaining([
+    expect.objectContaining({ startValue: 100, endValue: 120, return: 0.2 }),
+  ]));
+
+  const options = { metric: "totalRevenue", period: "annual", periods: 1 };
+  const spec = applyChartComposerCapabilityOptions(buildFundamentalChartPreset(["AAPL:NASDAQ"]), "fundamental-series", options);
+  const financial = await chartHeadless("fundamental-graph-pane").load({ ...args, options }, { ...context, settings: { chartSpec: spec } });
+  expect(financial.series[0]!.points).toHaveLength(1);
+  expect(financial.series[0]!.points[0]).toMatchObject({ value: 150, growth: 0.5 });
+});
+
+test("explicit financial periods replay available SEC history and expose actual cloud depth deficits", async () => {
+  const actual = await import("./financial-periods.fixture.json");
+  const { buildFundamentalChartPreset } = await import("./presets");
+  const { applyChartComposerCapabilityOptions } = await import("./cli-options");
+  const options = { metric: "operatingMargin", period: "annual", periods: 10 };
+  const spec = applyChartComposerCapabilityOptions(buildFundamentalChartPreset(["MSFT"]), "fundamental-series", options);
+  const context = { ...fixture().context, settings: { chartSpec: spec }, marketData: createTestDataProvider({
+    getTickerFinancials: async () => ({ annualStatements: actual.secAnnual, quarterlyStatements: [], priceHistory: [] }),
+  }) };
+  const args = { argument: ["MSFT"], rawArgument: "MSFT", symbols: ["MSFT"], options };
+  const full = await chartHeadless("fundamental-graph-pane").load(args, context);
+  expect(spec.viewport.range).toBe("ALL");
+  expect(full.series[0]!.points).toHaveLength(10);
+  expect(full.series[0]!.points[0]!.observedAt.toISOString()).toBe("2017-06-30T00:00:00.000Z");
+  expect(full.complete).toBe(true);
+  expect(full.metadata?.periodCoverage).toEqual([expect.objectContaining({ requested: 10, returned: 10, complete: true })]);
+  const partial = await chartHeadless("fundamental-graph-pane").load(args, { ...context, marketData: createTestDataProvider({
+    getTickerFinancials: async () => ({ annualStatements: actual.cloudAnnual, quarterlyStatements: [], priceHistory: [] }),
+  }) });
+  expect(partial.series[0]!.points).toHaveLength(5);
+  expect(partial.series[0]!.points.filter((point) => point.value !== null)).toHaveLength(4);
+  expect(partial.complete).toBe(false);
+  expect(partial.unavailableSymbols).toEqual([]);
+  expect(partial.metadata?.periodCoverage).toEqual([expect.objectContaining({ requested: 10, returned: 4, complete: false })]);
+  expect((partial as ChartPaneModel).chart.warnings.join(" ")).toContain("4 of 10 requested annual observations");
+  const constrained = applyChartComposerCapabilityOptions({ ...spec, viewport: { ...spec.viewport,
+    dateWindow: { start: "2024-01-01", end: "2025-12-31" } } }, "fundamental-series", options);
+  const windowed = await chartHeadless("fundamental-graph-pane").load(args, { ...context, settings: { chartSpec: constrained } });
+  expect(windowed.series[0]!.points).toHaveLength(2);
+  expect(windowed.complete).toBe(false);
+  const explicitRange = applyChartComposerCapabilityOptions(spec, "fundamental-series", { ...options, rangePreset: "1Y" });
+  expect(explicitRange.viewport.range).toBe("1Y");
+});

package/src/plugins/builtin/chart-composer/headless.ts

@@ -0,0 +1,225 @@
+import { financialPeriodCoverage } from "../../../time-series/financial-period-coverage";
+import { FINANCIAL_VINTAGE_NOTICE, SEC_EPS_BASIS_NOTICE } from "../../../utils/financial-statements";
+import { graphRowsForFinancials, summarizeResolvedSeries } from "../../../time-series/reporting";
+import { priceHistoryIntegrityNotices, chartPriceHistoryIntegrityNotices } from "../../../time-series/market";
+import type { HeadlessPaneContext, HeadlessPaneDefinition, HeadlessSeriesResult } from "../../../types/headless";
+import type { ChartResolutionResult, ChartSeriesSpec, ChartSpec } from "../../../time-series/types";
+import { mergePriceHistoryWindows, resolveChartSpecData } from "../../../time-series/resolve";
+import { intradaySessionDates, loadIntradayWindow, resolveIntradayRequest, type IntradayRequest, type IntradayWindow, type LoadedIntradayWindow } from "../../../time-series/session-history";
+import { createSnapshotDataProvider, snapshotInstrumentKey, type SnapshotMarketData } from "../../../market-data/snapshot-provider";
+import type { InstrumentRef } from "../../../market-data/request-types";
+import type { TickerFinancials, PricePoint } from "../../../types/financials";
+import { createChartSeriesResolver } from "../../../capabilities";
+import { parsePublicTickerKey, publicTickerKey, resolveExchangeTimeZone } from "../../../utils/exchanges";
+import { parseChartSpec } from "./chart-spec";
+import { paneSchemas } from "./headless-schema";
+
+export interface ChartPaneModel extends HeadlessSeriesResult {
+  /** The renderer consumes the full model; generic reports project series and metadata. */
+  chart: ChartResolutionResult;
+  spec: ChartSpec;
+  snapshot: {
+    financials: Array<[string, TickerFinancials]>;
+    instrumentFinancials?: SnapshotMarketData["instrumentFinancials"];
+    intradayHistories: Array<IntradayWindow & Pick<LoadedIntradayWindow, "quote" | "priceDomainFailure"> & {
+      symbol: string;
+      exchange: string;
+      target?: InstrumentRef;
+      rangePreset: IntradayRequest["rangePreset"];
+      resolution: IntradayRequest["resolution"];
+      requestedSession: string | null;
+      unavailableReason: string | null;
+    }>;
+  };
+}
+
+export async function loadChartPaneModel(
+  spec: ChartSpec,
+  context: HeadlessPaneContext,
+): Promise<ChartPaneModel> {
+  const financials = new Map<string, TickerFinancials>();
+  const histories = new Map<string, PricePoint[]>();
+  const instruments = new Map<string, InstrumentRef>();
+  const resolvedSeries = new Map<string, ChartSeriesSpec>();
+  const chart = await resolveChartSpecData(spec, {
+    dataProvider: context.marketData,
+    onSecurityData(series, data, includesHistory) {
+      const { source } = series;
+      if (source.kind !== "security") return;
+      resolvedSeries.set(series.id, series);
+      const key = snapshotInstrumentKey(source.instrument);
+      instruments.set(key, source.instrument);
+      const previous = financials.get(key);
+      financials.set(key, {
+        ...previous, ...data,
+        quote: data.quote ?? previous?.quote,
+        fundamentals: data.fundamentals ?? previous?.fundamentals,
+        profile: data.profile ?? previous?.profile,
+        quoteContributions: data.quoteContributions ?? previous?.quoteContributions,
+        annualStatements: data.annualStatements.length ? data.annualStatements : previous?.annualStatements ?? [],
+        quarterlyStatements: data.quarterlyStatements.length ? data.quarterlyStatements : previous?.quarterlyStatements ?? [],
+      });
+      if (includesHistory) histories.set(key, mergePriceHistoryWindows(histories.get(key) ?? [], data.priceHistory, "1m"));
+    },
+    ...(context.capabilities ? { resolveCapabilitySeries: createChartSeriesResolver(context.capabilities) } : {}),
+    loadFredSeries: async (request) => ({
+      data: await context.apiClient.getCloudFredSeries(request.seriesId, {
+        startDate: request.startDate,
+        sortOrder: request.sortOrder,
+      }),
+      fetchedAt: Date.now(),
+      stale: false,
+      source: "network",
+    }),
+  });
+  spec = { ...spec, series: spec.series.map((series) => resolvedSeries.get(series.id) ?? series) };
+  const ids = new Set(spec.series.map((series) => series.id));
+  const periodCoverage = financialPeriodCoverage(spec, chart.series);
+  const integrityNotices = chart.priceHistoryIntegrity
+    ? chartPriceHistoryIntegrityNotices(chart.priceHistoryIntegrity) : priceHistoryIntegrityNotices(chart.series);
+  const valuationPriceIssues = chart.series.flatMap((series) => series.valuationPriceIssues?.length
+    ? [{ seriesId: series.id, label: series.label, issues: series.valuationPriceIssues }] : []);
+  return {
+    chart,
+    spec,
+    ...(periodCoverage.length ? {
+      complete: periodCoverage.every((entry) => entry.complete),
+      stats: periodCoverage.map((entry) => ({ label: `${entry.label} observations`, value: `${entry.returned}/${entry.requested} ${entry.period}${entry.complete ? "" : " (partial)"}` })),
+    } : {}),
+    ...(integrityNotices.length || valuationPriceIssues.length ? { complete: false } : {}),
+    snapshot: {
+      financials: [...financials].filter(([key]) => !instruments.get(key)?.instrument).map(([key, data]) => [
+        publicTickerKey(instruments.get(key)!.symbol, instruments.get(key)!.exchange), { ...data, priceHistory: histories.get(key) ?? data.priceHistory },
+      ]),
+      instrumentFinancials: [...financials].filter(([key]) => instruments.get(key)?.instrument).map(([key, data]) => ({
+        instrument: instruments.get(key)!, financials: { ...data, priceHistory: histories.get(key) ?? data.priceHistory },
+      })),
+      intradayHistories: [],
+    },
+    symbols: [...new Set(spec.series.flatMap(({ source }) => source.kind === "security"
+      ? [publicTickerKey(source.instrument.symbol, source.instrument.exchange)] : []))],
+    series: chart.series.map((series) => {
+      const source = spec.series.find((entry) => entry.id === series.id)?.source;
+      const kind = source?.kind === "security" && source.fieldId.startsWith("fundamental.") ? "fundamental"
+        : source?.kind === "security" && source.fieldId.startsWith("valuation.") ? "valuation" : null;
+      const growth = kind && source?.kind === "security" ? new Map(graphRowsForFinancials(
+        financials.get(snapshotInstrumentKey(source.instrument)) ?? null,
+        kind, source.fieldId.split(".")[1]!, source.period === "quarterly" ? "quarterly" : "annual",
+        source.instrument.symbol,
+      ).map((row) => [row.date, row.growth])) : null;
+      return {
+        ...series,
+        derived: !ids.has(series.id),
+        points: series.points.map((point) => ({
+          ...point,
+          ...(growth ? { growth: growth.get(point.periodLabel === "Current" ? "Current" : point.observedAt.toISOString().slice(0, 10)) ?? null } : {}),
+        })),
+      };
+    }),
+    errors: chart.errors,
+    unavailableSymbols: spec.series.filter((series) => series.visible !== false).flatMap((series) => {
+      if (chart.series.some((output) => output.id === series.id && output.points.some((point) => point.value !== null && Number.isFinite(point.value)))) return [];
+      const source = series.source;
+      return [source.kind === "security"
+        ? publicTickerKey(source.instrument.symbol, source.instrument.exchange)
+        : source.kind === "economic" ? `FRED:${source.seriesId}`
+          : `CAP:${source.capabilityId}:${source.seriesId}`];
+    }),
+    metadata: {
+      viewport: spec.viewport, panels: spec.panels, warnings: chart.warnings,
+      ...(chart.priceHistoryIntegrity?.length ? { priceHistoryIntegrity: chart.priceHistoryIntegrity } : {}),
+      ...(valuationPriceIssues.length ? { valuationPriceIssues } : {}),
+      ...(periodCoverage.length ? { periodCoverage } : {}),
+      notices: [...chart.warnings.filter((warning) => warning === FINANCIAL_VINTAGE_NOTICE || warning === SEC_EPS_BASIS_NOTICE || warning === chart.priceComparison?.notice), ...integrityNotices],
+      priceComparison: chart.priceComparison ?? null,
+      summaries: chart.series.map((series) => ({ id: series.id, ...summarizeResolvedSeries(series) })),
+    },
+  };
+}
+
+export function chartHeadless(template: keyof typeof paneSchemas): HeadlessPaneDefinition<"series"> {
+  return {
+    ...paneSchemas[template],
+    shape: "series",
+    async load(args, context) {
+      const intradayHistories: ChartPaneModel["snapshot"]["intradayHistories"] = [];
+      const parsed = parseChartSpec(context.settings?.chartSpec);
+      if (!parsed) throw new Error("The chart specification is invalid.");
+      let spec = context.resolveInstrument ? {
+        ...parsed,
+        series: await Promise.all(parsed.series.map(async (series) => {
+          if (series.source.kind !== "security" || series.source.instrument.exchange) return series;
+          const instrument = await context.resolveInstrument!(series.source.instrument.symbol);
+          return { ...series, source: { ...series.source, instrument: { ...series.source.instrument, ...instrument } } };
+        })),
+      } : parsed;
+      if (template === "graph-intraday-price-pane" && !spec.viewport.dateWindow) {
+        const request = resolveIntradayRequest({
+          rangePreset: spec.viewport.range,
+          chartResolution: spec.viewport.resolution,
+          session: args.options.session,
+        });
+        const instruments = new Map(spec.series.flatMap(({ source }) => source.kind === "security"
+          ? [[snapshotInstrumentKey(source.instrument), source.instrument] as const] : []));
+        const histories = await Promise.all([...instruments.values()].map(async (target) => ({
+          target, symbol: target.symbol, exchange: target.exchange ?? "", resolution: request.resolution, rangePreset: request.rangePreset, requestedSession: request.session,
+          ...await loadIntradayWindow({ provider: context.marketData, symbol: target.symbol, exchange: target.exchange ?? "", request, context: { brokerId: target.brokerId, brokerInstanceId: target.brokerInstanceId, instrument: target.instrument } }),
+        })));
+        context.signal.throwIfAborted();
+        intradayHistories.push(...histories.map(({ bufferedPoints: _buffer, ...history }) => history));
+        const starts = histories.flatMap(({ start }) => start ? [start.getTime()] : []);
+        const ends = histories.flatMap(({ end }) => end ? [end.getTime()] : []);
+        spec = { ...spec, viewport: {
+          ...spec.viewport, range: request.rangePreset, resolution: request.resolution,
+          ...(starts.length && ends.length ? { dateWindow: {
+            start: new Date(Math.min(...starts)).toISOString(),
+            end: new Date(Math.max(...ends)).toISOString(),
+          } } : {}),
+        } };
+        context = { ...context, marketData: createSnapshotDataProvider({
+          financials: [],
+          intradayHistories: histories.map((history) => ({ ...history, points: history.bufferedPoints })),
+        }, context.marketData) };
+      }
+      const model = await loadChartPaneModel(spec, context);
+      if (template === "graph-intraday-price-pane" && !intradayHistories.length && model.chart.viewport) {
+        const { start, end } = model.chart.viewport;
+        for (const { target, data } of [
+          ...model.snapshot.financials.map(([key, data]) => ({ target: { ...parsePublicTickerKey(key), instrument: null } as InstrumentRef, data })),
+          ...(model.snapshot.instrumentFinancials ?? []).map(({ instrument, financials }) => ({ target: instrument, data: financials })),
+        ]) {
+          const { symbol, exchange = "" } = target;
+          const points = data.priceHistory.filter(({ date }) => date >= start && date <= end);
+          intradayHistories.push({
+            target, symbol, exchange, points, start, end,
+            rangePreset: spec.viewport.range === "1W" ? "1W" : "1D",
+            resolution: model.chart.resolution!, requestedSession: null,
+            sessionDates: intradaySessionDates(points, resolveExchangeTimeZone(exchange) ?? "UTC"),
+            unavailableReason: points.length ? null : model.chart.errors[0] ?? `No intraday price history is available for ${symbol} for the requested window.`,
+          });
+        }
+      }
+      model.snapshot.intradayHistories = intradayHistories;
+      const priceDomainFailures = intradayHistories.flatMap(({ symbol, exchange, priceDomainFailure }) =>
+        priceDomainFailure ? [{ symbol, exchange, ...priceDomainFailure }] : []);
+      if (priceDomainFailures.length) {
+        model.complete = false;
+        model.metadata = { ...model.metadata, intradayPriceDomainFailures: priceDomainFailures };
+      }
+      for (const { symbol, exchange, target, points, unavailableReason } of intradayHistories) {
+        const key = publicTickerKey(symbol, exchange);
+        if (target?.instrument) {
+          if (!model.snapshot.instrumentFinancials?.some(entry => snapshotInstrumentKey(entry.instrument) === snapshotInstrumentKey(target))) {
+            model.snapshot.instrumentFinancials = [...model.snapshot.instrumentFinancials ?? [], { instrument: target, financials: { annualStatements: [], quarterlyStatements: [], priceHistory: points } }];
+          }
+        } else if (!model.snapshot.financials.some(([candidate]) => candidate === key)) {
+          model.snapshot.financials.push([key, { annualStatements: [], quarterlyStatements: [], priceHistory: points }]);
+        }
+        if (unavailableReason && !model.chart.errors.some((error) => error === unavailableReason || error.endsWith(`: ${unavailableReason}`))) {
+          model.chart.errors.push(unavailableReason);
+        }
+      }
+      return model;
+    },
+  };
+}