gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/correlation/compute.ts

@@ -1,16 +1,53 @@
 import type { PricePoint } from "../../../types/financials";
 import { getPricePointTimestamp } from "../../../utils/price-history";
 
-export interface DatedReturn {
-  dateKey: string;
-  value: number;
-}
-
 export interface CorrelationResult {
   correlation: number | null;
   sampleSize: number;
 }
 
+export interface DailyClose {
+  dateKey: string;
+  close: number;
+}
+
+/** Keep the final valid close for each UTC trading date, in chronological order. */
+export function dailyCloses(points: readonly PricePoint[]): DailyClose[] {
+  const byDate = new Map<string, number>();
+  for (const point of [...points].sort(comparePricePointsByDate)) {
+    const dateKey = toDateKey(point);
+    if (!dateKey || !Number.isFinite(point.close) || point.close <= 0) continue;
+    byDate.set(dateKey, point.close);
+  }
+  return [...byDate].map(([dateKey, close]) => ({ dateKey, close }));
+}
+
+export interface AlignedDailyClose {
+  dateKey: string;
+  leftClose: number;
+  rightClose: number;
+}
+
+/**
+ * Align prices before computing returns. Aligning return end dates alone pairs
+ * a stock's Friday-to-Monday move with crypto's Sunday-to-Monday move, and does
+ * the same across different exchange holidays or missing observations.
+ */
+export function alignDailyCloses(left: readonly DailyClose[], right: readonly DailyClose[]): AlignedDailyClose[] {
+  const rightByDate = new Map(right.map((point) => [point.dateKey, point.close]));
+  return left.flatMap((point) => {
+    const rightClose = rightByDate.get(point.dateKey);
+    return rightClose === undefined ? [] : [{ dateKey: point.dateKey, leftClose: point.close, rightClose }];
+  });
+}
+
+export function correlateDailyCloses(left: readonly DailyClose[], right: readonly DailyClose[], minObservations = 5): CorrelationResult {
+  const aligned = alignDailyCloses(left, right);
+  const x = computeReturns(aligned.map((point) => point.leftClose));
+  const y = computeReturns(aligned.map((point) => point.rightClose));
+  return { correlation: pearsonCorrelation(x, y, minObservations), sampleSize: x.length };
+}
+
 function toDateKey(point: PricePoint): string | null {
   const timestamp = getPricePointTimestamp(point);
   if (!Number.isFinite(timestamp)) return null;
@@ -32,68 +69,25 @@ export function computeReturns(closes: number[]): number[] {
   return returns;
 }
 
-export function computeDatedReturns(points: PricePoint[]): DatedReturn[] {
-  const sorted = [...points]
-    .filter((point) => Number.isFinite(getPricePointTimestamp(point)) && Number.isFinite(point.close))
-    .sort(comparePricePointsByDate);
-  const byDate = new Map<string, number>();
-
-  for (let i = 1; i < sorted.length; i++) {
-    const previous = sorted[i - 1]!;
-    const current = sorted[i]!;
-    if (previous.close === 0) continue;
-    const value = (current.close - previous.close) / previous.close;
-    const dateKey = toDateKey(current);
-    if (!dateKey || !Number.isFinite(value)) continue;
-    byDate.set(dateKey, value);
-  }
-
-  return [...byDate.entries()].map(([dateKey, value]) => ({ dateKey, value }));
-}
-
-export function alignDatedReturns(x: DatedReturn[], y: DatedReturn[]): { x: number[]; y: number[]; sampleSize: number } {
-  const yByDate = new Map(y.map((entry) => [entry.dateKey, entry.value] as const));
-  const alignedX: number[] = [];
-  const alignedY: number[] = [];
-
-  for (const left of x) {
-    const rightValue = yByDate.get(left.dateKey);
-    if (rightValue === undefined) continue;
-    alignedX.push(left.value);
-    alignedY.push(rightValue);
-  }
-
-  return {
-    x: alignedX,
-    y: alignedY,
-    sampleSize: alignedX.length,
-  };
-}
-
 export function pearsonCorrelation(x: number[], y: number[], minObservations = 5): number | null {
   const n = Math.min(x.length, y.length);
   if (n < minObservations) return null;
 
-  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
+  if (!x.slice(0, n).every(Number.isFinite) || !y.slice(0, n).every(Number.isFinite)) return null;
+  const meanX = x.slice(0, n).reduce((sum, value) => sum + value, 0) / n;
+  const meanY = y.slice(0, n).reduce((sum, value) => sum + value, 0) / n;
+  let covariance = 0, varianceX = 0, varianceY = 0;
   for (let i = 0; i < n; i++) {
-    sumX += x[i]!;
-    sumY += y[i]!;
-    sumXY += x[i]! * y[i]!;
-    sumX2 += x[i]! * x[i]!;
-    sumY2 += y[i]! * y[i]!;
+    const dx = x[i]! - meanX;
+    const dy = y[i]! - meanY;
+    covariance += dx * dy;
+    varianceX += dx * dx;
+    varianceY += dy * dy;
   }
 
-  const denom = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
-  if (denom === 0) return null;
-  return (n * sumXY - sumX * sumY) / denom;
-}
-
-export function correlateDatedReturns(x: DatedReturn[], y: DatedReturn[], minObservations = 5): CorrelationResult {
-  const aligned = alignDatedReturns(x, y);
-  return {
-    correlation: pearsonCorrelation(aligned.x, aligned.y, minObservations),
-    sampleSize: aligned.sampleSize,
-  };
+  const denom = Math.sqrt(varianceX * varianceY);
+  if (!Number.isFinite(denom) || denom === 0) return null;
+  return Math.max(-1, Math.min(1, covariance / denom));
 }
 
 export function formatCorrelation(r: number | null): string {

package/src/plugins/builtin/correlation/headless-schema.ts

@@ -0,0 +1,69 @@
+import type { HeadlessPaneDefinition } from "../../../types/headless";
+
+type PaneSchema = Pick<HeadlessPaneDefinition, "argument" | "options" | "discovery">;
+
+export const paneSchemas = {
+  "correlation-pane": {
+    argument: { kind: "tickers", minimum: 2 },
+    options: [
+      {
+        key: "rangePreset",
+        description: "Correlation history window.",
+        type: "enum",
+        aliases: ["range"],
+        values: [
+          { value: "1M", aliases: ["month", "monthly"] },
+          { value: "3M" },
+          { value: "6M" },
+          { value: "1Y", aliases: ["year"] },
+          { value: "5Y", aliases: ["five-years", "five years"] },
+        ],
+        defaultValue: "1Y",
+        settingKey: "rangePreset",
+      },
+    ],
+    discovery: {
+      id: "return-correlation",
+      aliases: ["correlation", "return correlation", "correlation matrix", "pearson correlation"],
+      limitations: ["Correlation is computed from daily returns with at least five shared observations."],
+      screenshotReadiness: "partial",
+    },
+  },
+  "relationship-graph-pane": {
+    argument: { kind: "tickers", maximum: 2 },
+    options: [
+      {
+        key: "range",
+        description: "Relationship history window.",
+        type: "enum",
+        aliases: ["rangePreset"],
+        values: [
+          { value: "1M", aliases: ["month", "monthly"] },
+          { value: "3M" },
+          { value: "6M" },
+          { value: "1Y", aliases: ["year"] },
+          { value: "5Y", aliases: ["five-years", "five years"] },
+          { value: "ALL", aliases: ["max", "maximum"] },
+        ],
+        defaultValue: "1Y",
+        pluginState: { pluginId: "market-overview" },
+      },
+      {
+        key: "correlationWindow",
+        description: "Rolling-correlation window in observations.",
+        type: "integer",
+        aliases: ["window"],
+        defaultValue: 120,
+        minimum: 5,
+        maximum: 1000,
+        pluginState: { pluginId: "market-overview" },
+      },
+    ],
+    discovery: {
+      id: "security-relationship",
+      aliases: ["relationship", "ratio", "beta", "regression", "rolling correlation"],
+      limitations: ["A single ticker is compared with SPY."],
+      screenshotReadiness: "partial",
+    },
+  },
+} satisfies Record<string, PaneSchema>;

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

@@ -0,0 +1,147 @@
+import { expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/headless";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { correlationHeadless, relationshipHeadless } from "./headless";
+import { buildCorrelationMatrix, buildCorrelationSeries, buildStatusSummary, pairKey } from "./matrix/model";
+
+function args(symbols: string[]): HeadlessPaneLoadArgs {
+  return { symbols, argument: symbols, rawArgument: symbols.join(","), options: { range: "ALL", rangePreset: "1Y", correlationWindow: 5 } };
+}
+
+function context(missing = "", disjoint = false): HeadlessPaneContext {
+  return {
+    signal: new AbortController().signal,
+    marketData: createTestDataProvider({
+      async getPriceHistory(symbol) {
+        if (symbol === missing) throw new Error("No history");
+        return [100, 110, 105, 115, 111, 118, 130].map((close, index) => ({
+          date: new Date(Date.UTC(2026, disjoint && symbol === "SPY" ? 5 : 0, index + 1)),
+          close: close * (symbol === "SPY" ? 2 : 1),
+        }));
+      },
+    }),
+  } as HeadlessPaneContext;
+}
+
+test("correlation retains usable pairs and marks failed histories without discarding their peers", async () => {
+  const result = await correlationHeadless.load(args(["ABC", "SPY", "MISSING"]), context("MISSING"));
+  expect(result.rows[0]).toMatchObject({ left: "ABC", right: "SPY", sampleSize: 6 });
+  expect(result.rows[0]!.correlation).toBeCloseTo(1);
+  expect(result.rows[1]).toMatchObject({ right: "MISSING", correlation: null, sampleSize: 0 });
+  expect(result.unavailableSymbols).toEqual(["MISSING"]);
+});
+
+test("relationship supplies the default benchmark, ratio history, rolling correlation, and regression", async () => {
+  const result = await relationshipHeadless.load(args(["ABC"]), context());
+  expect(result.symbols).toEqual(["ABC", "SPY"]);
+  expect(result.series[0]!.points).toHaveLength(7);
+  expect(result.series[0]!.points.at(-1)?.value).toBe(0.5);
+  expect(result.series[1]!.points.at(-1)?.value).toBeCloseTo(1);
+  expect(result.metadata).toMatchObject({ right: "SPY", alignedPriceCount: 7, returnCount: 6, regression: { beta: 1, rSquared: 1, sampleSize: 6 } });
+  expect(result.unavailableSymbols).toEqual([]);
+});
+
+test("one usable pair cannot make a matrix with disjoint histories look complete", async () => {
+  const result = await correlationHeadless.load(args(["ABC", "DEF", "SPY"]), context("", true));
+  expect(result.rows[0]!.correlation).toBeCloseTo(1);
+  expect(result.rows.slice(1).every((row) => row.correlation == null)).toBe(true);
+  expect(result.errors).toHaveLength(2);
+  expect(result.metadata?.unavailablePairs).toEqual([
+    { left: "ABC", right: "SPY", sampleSize: 0, reason: "Insufficient shared return observations" },
+    { left: "DEF", right: "SPY", sampleSize: 0, reason: "Insufficient shared return observations" },
+  ]);
+});
+
+test("relationship identifies just the missing benchmark, and both inputs when dates do not overlap", async () => {
+  const partial = await relationshipHeadless.load(args(["ABC"]), context("SPY"));
+  expect(partial.unavailableSymbols).toEqual(["SPY"]);
+  expect(partial.series.every((series) => series.points.length === 0)).toBe(true);
+  const disjoint = await relationshipHeadless.load(args(["ABC"]), context("", true));
+  expect(disjoint.unavailableSymbols).toEqual(["ABC", "SPY"]);
+  expect(disjoint.metadata).toMatchObject({ alignedPriceCount: 0, returnCount: 0, regression: null });
+});
+
+test("rolling correlation waits for the entire selected observation window", async () => {
+  const request = args(["ABC"]);
+  request.options.correlationWindow = 30;
+  const result = await relationshipHeadless.load(request, context());
+  expect(result.series[0]!.points).toHaveLength(7);
+  expect(result.series[1]!.points).toHaveLength(0);
+  expect(result.metadata).toMatchObject({ latestCorrelation: null, returnCount: 6 });
+  expect(result.stats?.find((stat) => stat.key === "beta")?.value).toBeCloseTo(1);
+});
+
+
+test("inconsistent OHLC quarantines risk windows, retains original diagnostics and leaves independent pairs usable", async () => {
+  const ctx = context();
+  const cleanHistory = await ctx.marketData.getPriceHistory("SPY", "", "1Y");
+  // Captured SPY contradiction: reported open exceeds reported high.
+  const corrupt = { ...cleanHistory[3]!, open: 764.0800, high: 758.555, low: 757.570, close: 758.150, volume: 3461376 };
+  const history = cleanHistory.map((point, index) => index === 3 ? corrupt : point);
+  ctx.marketData = createTestDataProvider({ getPriceHistory: async (symbol) => symbol === "SPY" ? history : cleanHistory });
+  const bySymbol = new Map([
+    ["ABC", buildCorrelationSeries("ABC", cleanHistory)],
+    ["SPY", buildCorrelationSeries("SPY", history)],
+    ["CONSTANT", buildCorrelationSeries("CONSTANT", cleanHistory.map(point => ({ ...point, close: 100 })))],
+  ]);
+  const matrix = buildCorrelationMatrix([...bySymbol.keys()], bySymbol);
+  expect(matrix.results.get(pairKey("ABC", "ABC"))?.correlation).toBeCloseTo(1);
+  expect(matrix.results.get(pairKey("SPY", "SPY"))?.correlation).toBeNull();
+  expect(matrix.results.get(pairKey("CONSTANT", "CONSTANT"))?.correlation).toBeNull();
+  expect(matrix.hasThinPair).toBe(false);
+  expect(buildStatusSummary([...bySymbol.keys()], bySymbol, matrix.sampleMin, matrix.sampleMax, matrix.hasThinPair)).toContain("Inconsistent OHLC: SPY");
+  const result = await correlationHeadless.load(args(["ABC", "DEF", "SPY"]), ctx);
+  expect(result.rows[0]!.correlation).toBeCloseTo(1);
+  expect(result.rows.slice(1).every((row) => row.correlation === null && row.sampleSize === 0)).toBe(true);
+  expect(result.unavailableSymbols).toEqual(["SPY"]);
+  expect(result.errors?.every((error) => error.includes("Inconsistent OHLC"))).toBe(true);
+  expect(result.metadata?.availability).toEqual(expect.arrayContaining([expect.objectContaining({
+    symbol: "SPY", status: "invalid", integrity: [expect.objectContaining({ sourcePoints: [expect.objectContaining({ open: 764.0800, high: 758.555, close: 758.150 })] })],
+  })]));
+  const relationship = await relationshipHeadless.load(args(["ABC", "SPY"]), ctx);
+  expect(relationship.series.every((series) => series.points.length === 0)).toBe(true);
+  expect(relationship.stats?.filter((stat) => stat.key !== "returnCount").every((stat) => stat.value === null)).toBe(true);
+  expect(relationship.unavailableSymbols).toEqual(["SPY"]);
+  expect(relationship.errors).toEqual([expect.stringContaining("Inconsistent OHLC")]);
+  expect(relationship.metadata?.integrity).toMatchObject({ right: [{ sourcePoints: [expect.objectContaining({ close: corrupt.close })] }] });
+  expect(history[3]).toBe(corrupt);
+  expect(history[3]!.open).toBe(764.0800);
+  ctx.marketData = createTestDataProvider({ getPriceHistory: async () => cleanHistory });
+  const recovered = await relationshipHeadless.load(args(["ABC", "SPY"]), ctx);
+  expect(recovered.stats?.find((stat) => stat.key === "rSquared")?.value).toBeCloseTo(1);
+  expect(recovered.errors).toEqual([]);
+});
+
+test("risk consumers request daily bars, clip oversized buffers, and disclose incomplete rolling windows", async () => {
+  const ctx = context();
+  const source = await ctx.marketData.getPriceHistory("ABC", "", "1Y");
+  const calls: unknown[][] = [];
+  ctx.marketData = createTestDataProvider({
+    getPriceHistory: async () => { throw new Error("Automatic resolution must not be used"); },
+    getPriceHistoryForResolution: async (...request) => {
+      calls.push(request);
+      return [{ date: new Date("2025-01-01"), close: 1 }, ...source];
+    },
+  });
+  const request = args(["ABC", "SPY"]);
+  request.options = { range: "1M", rangePreset: "1M", correlationWindow: 30 };
+  const correlation = await correlationHeadless.load(request, ctx);
+  const relationship = await relationshipHeadless.load(request, ctx);
+  expect(calls.map(call => call.slice(2, 4))).toEqual(Array.from({ length: 4 }, () => ["1M", "1d"]));
+  expect(correlation.rows[0]?.sampleSize).toBe(6);
+  expect(relationship.metadata).toMatchObject({ firstDate: "2026-01-01", lastDate: "2026-01-07", returnCount: 6 });
+  expect(relationship.errors).toEqual(["Rolling correlation needs 30 shared returns; 6 available."]);
+  expect(relationship.metadata?.returnAlignment).toContain("cash distributions and FX conversion are excluded");
+});
+
+test("a zero-variance latest rolling window never publishes an older correlation as current", async () => {
+  const ctx = context();
+  ctx.marketData = createTestDataProvider({ getPriceHistory: async () => [100, 110, 105, 120, 115, 130, 130, 130, 130, 130, 130].map((close, i) => ({ date: new Date(Date.UTC(2026, 8, i + 1)), close })) });
+  const result = await relationshipHeadless.load(args(["ABC", "SPY"]), ctx);
+  expect(result.series[1]?.points.length).toBeGreaterThan(0);
+  expect(result.series[1]?.points.at(-1)).toEqual({ date: "2026-09-11T00:00:00.000Z", value: null });
+  expect(result.stats?.find(stat => stat.key === "latestCorrelation")?.value).toBeNull();
+  expect(result.metadata?.latestCorrelation).toBeNull();
+  expect(result.errors).toEqual([expect.stringContaining("zero return variance in the latest 5 shared returns")]);
+  expect(result.metadata?.regression).toMatchObject({ rSquared: 1, sampleSize: 10 });
+});

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

@@ -0,0 +1,110 @@
+import type { HeadlessPaneDefinition } from "../../../types/headless";
+import type { TimeRange } from "../../../time-series/range";
+import { formatNumber } from "../../../utils/format";
+import { resolveHeadlessInstrument, loadHeadlessSymbols } from "../shared/headless-market-data";
+import { buildCorrelationMatrix, buildCorrelationSeries, pairKey } from "./matrix/model";
+import { buildRelationshipAnalysis, DEFAULT_RELATIONSHIP_SECOND_SYMBOL } from "./relationship/model";
+import { paneSchemas } from "./headless-schema";
+import { CORRELATION_RETURN_BASIS, loadCorrelationHistory } from "./history";
+import type { HeadlessPaneContext } from "../../../types/headless";
+
+async function loadHistory(ctx: HeadlessPaneContext, key: string, range: TimeRange) {
+  const { symbol, exchange } = await resolveHeadlessInstrument(ctx, key);
+  return loadCorrelationHistory(ctx.marketData, symbol, exchange ?? "", range);
+}
+
+export const correlationHeadless: HeadlessPaneDefinition<"rows"> = {
+  ...paneSchemas["correlation-pane"],
+  shape: "rows",
+  describe: ({ symbols, options }) => `Correlation Matrix | Daily returns | ${options.rangePreset ?? "1Y"} | ${symbols.join(", ")}`,
+  columns: [
+    { key: "pair", header: "Pair", format: (_value, row) => `${row.left}/${row.right}` },
+    { key: "correlation", header: "Correlation", align: "right", format: (value) => value == null ? "-" : formatNumber(Number(value), 3) },
+    { key: "sampleSize", header: "Shared obs", align: "right" },
+  ],
+  async load({ symbols, options }, ctx) {
+    const range = (options.rangePreset ?? "1Y") as TimeRange;
+    const loaded = await loadHeadlessSymbols(symbols, ctx, (symbol) => loadHistory(ctx, symbol, range));
+    const bySymbol = new Map(loaded.entries.map(({ symbol, data }) => [symbol, buildCorrelationSeries(symbol, data)]));
+    const matrix = buildCorrelationMatrix(symbols, bySymbol);
+    const rows = symbols.flatMap((left, index) => symbols.slice(index + 1).map((right) => {
+      const result = matrix.results.get(pairKey(left, right));
+      return { left, right, correlation: result?.correlation ?? null, sampleSize: result?.sampleSize ?? 0 };
+    }));
+    const unavailableSymbols = symbols.filter((symbol) => bySymbol.get(symbol)?.status !== "ready");
+    if (!unavailableSymbols.length && rows.every((row) => row.correlation == null)) unavailableSymbols.push(...symbols);
+    const unavailablePairs = rows.filter((row) => row.correlation == null).map((row) => ({
+      left: row.left, right: row.right, sampleSize: row.sampleSize,
+      reason: bySymbol.get(row.left as string)?.status === "invalid" || bySymbol.get(row.right as string)?.status === "invalid"
+        ? "Inconsistent OHLC history"
+        : row.sampleSize < 5 ? "Insufficient shared return observations" : "Zero return variance",
+    }));
+    return {
+      rows, unavailableSymbols,
+      errors: [
+        ...loaded.errors,
+        ...unavailablePairs.map((pair) => `${pair.left}/${pair.right}: ${pair.reason} (${pair.sampleSize} shared observations).`),
+      ],
+      metadata: {
+        range,
+        unavailablePairs,
+        returnAlignment: CORRELATION_RETURN_BASIS,
+        availability: symbols.map((symbol) => ({
+          symbol, status: bySymbol.get(symbol)?.status ?? "error", observationCount: bySymbol.get(symbol)?.observationCount ?? 0,
+          ...(bySymbol.get(symbol)?.integrity ? { integrity: bySymbol.get(symbol)!.integrity } : {}),
+          firstDate: bySymbol.get(symbol)?.prices.at(0)?.dateKey ?? null,
+          lastDate: bySymbol.get(symbol)?.prices.at(-1)?.dateKey ?? null,
+        })),
+      },
+    };
+  },
+};
+
+export const relationshipHeadless: HeadlessPaneDefinition<"series"> = {
+  ...paneSchemas["relationship-graph-pane"],
+  shape: "series",
+  describe: ({ symbols, options }) => `Relationship Graph | ${symbols[0]}/${symbols[1] ?? DEFAULT_RELATIONSHIP_SECOND_SYMBOL} | ${options.range ?? "1Y"}`,
+  async load(args, ctx) {
+    const symbols = [args.symbols[0]!, args.symbols[1] ?? DEFAULT_RELATIONSHIP_SECOND_SYMBOL];
+    const range = (args.options.range ?? "1Y") as TimeRange;
+    const correlationWindow = Number(args.options.correlationWindow ?? 120);
+    const loaded = await loadHeadlessSymbols(symbols, ctx, (symbol) => loadHistory(ctx, symbol, range));
+    const histories = new Map(loaded.entries.map(({ symbol, data }) => [symbol, data]));
+    const analysis = buildRelationshipAnalysis(histories.get(symbols[0]!) ?? [], histories.get(symbols[1]!) ?? [], correlationWindow);
+    const unavailableSymbols = symbols.filter((symbol) => (histories.get(symbol) ?? []).filter((point) => (
+      Number.isFinite(point.close) && point.close > 0 && Number.isFinite(new Date(point.date).getTime())
+    )).length < 2);
+    if (analysis.integrity?.left.length) unavailableSymbols.push(symbols[0]!);
+    if (analysis.integrity?.right.length) unavailableSymbols.push(symbols[1]!);
+    if (!unavailableSymbols.length && !analysis.returns.length) unavailableSymbols.push(...symbols);
+    const correlations = new Map(analysis.correlationPoints.map(({ date, close }) => [date.getTime(), close]));
+    return {
+      symbols,
+      series: [
+        { id: "ratio", label: `${symbols[0]}/${symbols[1]}`, points: analysis.ratioPoints.map(({ date, close }) => ({ date: date.toISOString(), value: close })) },
+        { id: "correlation", label: `Rolling correlation (${correlationWindow})`, points: analysis.returns.slice(correlationWindow - 1).map(({ date }) => ({ date: date.toISOString(), value: correlations.get(date.getTime()) ?? null })) },
+      ],
+      stats: [
+        { key: "latestRatio", label: "Latest ratio", value: analysis.latestRatio, formatted: formatNumber(analysis.latestRatio ?? undefined, 4) },
+        { key: "latestCorrelation", label: `Rolling correlation (${correlationWindow})`, value: analysis.latestCorrelation, formatted: formatNumber(analysis.latestCorrelation ?? undefined, 3) },
+        ...(["beta", "alpha", "rSquared"] as const).map((key) => ({
+          key, label: { beta: "Beta", alpha: "Alpha", rSquared: "R squared" }[key],
+          value: analysis.stats?.[key] ?? null, formatted: formatNumber(analysis.stats?.[key], 3),
+        })),
+        { key: "returnCount", label: "Shared returns", value: analysis.stats?.sampleSize ?? analysis.returns.length },
+      ],
+      unavailableSymbols: [...new Set(unavailableSymbols)],
+      errors: [...loaded.errors, ...(analysis.unavailableReason ? [analysis.unavailableReason] : []),
+        ...(analysis.correlationUnavailableReason ? [analysis.correlationUnavailableReason] : [])],
+      metadata: {
+        left: symbols[0], right: symbols[1], range, correlationWindow,
+        returnAlignment: CORRELATION_RETURN_BASIS,
+        firstDate: analysis.aligned.at(0)?.dateKey ?? null,
+        lastDate: analysis.aligned.at(-1)?.dateKey ?? null,
+        ...(analysis.integrity ? { integrity: analysis.integrity } : {}),
+        latestRatio: analysis.latestRatio, latestCorrelation: analysis.latestCorrelation,
+        regression: analysis.stats, alignedPriceCount: analysis.aligned.length, returnCount: analysis.returns.length,
+      },
+    };
+  },
+};

package/src/plugins/builtin/correlation/history.ts

@@ -0,0 +1,16 @@
+import type { AssetDataProvider, MarketDataRequestContext } from "../../../types/data-provider";
+import type { TimeRange } from "../../../time-series/range";
+import { clipPriceHistoryToRange } from "../../../time-series/history-window";
+
+/** Risk views need daily closes even when a chart preset defaults to intraday or weekly bars. */
+export async function loadCorrelationHistory(
+  provider: AssetDataProvider, symbol: string, exchange: string, range: TimeRange,
+  context?: MarketDataRequestContext,
+) {
+  const points = provider.getPriceHistoryForResolution
+    ? await provider.getPriceHistoryForResolution(symbol, exchange, range, "1d", context)
+    : await provider.getPriceHistory(symbol, exchange, range, context);
+  return clipPriceHistoryToRange(points, range);
+}
+
+export const CORRELATION_RETURN_BASIS = "Local-price close-to-close returns between shared UTC dates; cash distributions and FX conversion are excluded, and exchange closing times may differ.";

package/src/plugins/builtin/correlation/index.test.tsx

@@ -2,58 +2,34 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { act, type ReactElement } from "react";
 import { Box } from "../../../ui";
 import { testRender } from "../../../renderers/opentui/test-utils";
-import {
-  AppContext,
-  createInitialState,
-  PaneInstanceProvider,
-} from "../../../state/app/context";
-import { cloneLayout, createDefaultConfig, TICKER_RESEARCH_PANE_ID } from "../../../types/config";
+import { createInitialState } from "../../../state/app/context";
+import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
 import type { TickerRecord } from "../../../types/ticker";
 import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import { PluginRenderProvider, type PluginRuntimeAccess } from "../../runtime";
+import type { PluginRuntimeAccess } from "../../runtime";
 import { correlationModule } from ".";
+import { TestPaneProvider, createTestTicker, createTestPaneConfig } from "../../../test-support/pane";
 
 const TEST_PANE_ID = "correlation:test";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
 function makeTicker(symbol: string): TickerRecord {
-  return {
-    metadata: {
-      ticker: symbol,
-      exchange: "NASDAQ",
-      currency: "USD",
-      name: symbol,
-      portfolios: [],
-      watchlists: [],
-      positions: [],
-      broker_contracts: [],
-      custom: {},
-      tags: [],
-    },
-  };
+  return createTestTicker(symbol, symbol, {
+    broker_contracts: []
+  });
 }
 
 function CorrelationHarness({ runtime }: { runtime: PluginRuntimeAccess }) {
-  const layout = {
-    dockRoot: { kind: "pane" as const, instanceId: TEST_PANE_ID },
-    instances: [{
-      instanceId: TEST_PANE_ID,
-      paneId: "correlation",
-      settings: {
-        rangePreset: "1Y",
-        symbols: ["AAPL", "MSFT"],
-        symbolsText: "AAPL, MSFT",
-      },
-    }],
-    floating: [],
-    detached: [],
-  };
-  const config = {
-    ...createDefaultConfig("/tmp/gloomberb-correlation-test"),
-    layout,
-    layouts: [{ name: "Default", layout: cloneLayout(layout) }],
-  };
+  const config = createTestPaneConfig("/tmp/gloomberb-correlation-test", {
+    instanceId: TEST_PANE_ID,
+    paneId: "correlation",
+    settings: {
+      rangePreset: "1Y",
+      symbols: ["AAPL", "MSFT"],
+      symbolsText: "AAPL, MSFT",
+    },
+  });
   const state = createInitialState(config);
   state.focusedPaneId = TEST_PANE_ID;
   state.tickers = new Map([
@@ -70,21 +46,17 @@ function CorrelationHarness({ runtime }: { runtime: PluginRuntimeAccess }) {
   }) => ReactElement;
 
   return (
-    <AppContext value={{ state, dispatch: () => {} }}>
-      <PaneInstanceProvider paneId={TEST_PANE_ID}>
-        <PluginRenderProvider pluginId="market-overview" runtime={runtime}>
-          <Box width={60} height={8}>
-            <CorrelationPane
-              paneId={TEST_PANE_ID}
-              paneType="correlation"
-              focused
-              width={60}
-              height={8}
-            />
-          </Box>
-        </PluginRenderProvider>
-      </PaneInstanceProvider>
-    </AppContext>
+    <TestPaneProvider state={state} paneId={TEST_PANE_ID} pluginId="market-overview" runtime={runtime}>
+      <Box width={60} height={8}>
+        <CorrelationPane
+          paneId={TEST_PANE_ID}
+          paneType="correlation"
+          focused
+          width={60}
+          height={8}
+        />
+      </Box>
+    </TestPaneProvider>
   );
 }