gloomberb 0.13.2 → 0.14.0

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

@@ -1,6 +1,6 @@
 import { Box, ScrollBox, Text, type InputRenderable } from "../../../ui";
 import { useCallback, useMemo, useRef, useState } from "react";
-import { InputSearchBar, SegmentedControl, usePaneFooter } from "../../../components";
+import { InputSearchBar, SegmentedControl, usePaneFooter, usePaneNoticeFooter } from "../../../components";
 import type { PaneProps } from "../../../types/plugin";
 import type { PluginModule } from "../plugin-module";
 import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
@@ -8,6 +8,8 @@ import { colors } from "../../../theme/colors";
 import { usePluginTickerActions } from "../../runtime";
 import { useAppSelector, usePaneInstance, usePaneSettingValue } from "../../../state/app/context";
 import { useChartQueries } from "../../../market-data/hooks";
+import { getSharedMarketDataCoordinator } from "../../../market-data/coordinator";
+import { useShortcut } from "../../../react/input";
 import { buildChartKey } from "../../../market-data/selectors";
 import { formatTickerListInput } from "../../../tickers/list";
 import { formatCorrelation } from "./compute";
@@ -40,6 +42,7 @@ import {
   rowHeaderColor,
 } from "./matrix/model";
 import { SymbolLabelCell } from "./matrix/symbol-cell";
+import { correlationHeadless, relationshipHeadless } from "./headless";
 
 function CorrelationMatrixPane({ focused, width, height }: PaneProps) {
   const pane = usePaneInstance();
@@ -88,10 +91,10 @@ function CorrelationMatrixPane({ focused, width, height }: PaneProps) {
       const request = chartRequests[i]!;
       const key = buildChartKey(request);
       const entry = chartEntries.get(key);
-      map.set(instrument.symbol, getSeriesForEntry(instrument.symbol, entry));
+      map.set(instrument.symbol, getSeriesForEntry(instrument.symbol, entry, settings.rangePreset));
     }
     return map;
-  }, [chartEntries, chartRequests, instruments]);
+  }, [chartEntries, chartRequests, instruments, settings.rangePreset]);
 
   const symbols = instruments.map((instrument) => instrument.symbol);
   const symbolsKey = symbols.join(",");
@@ -105,6 +108,23 @@ function CorrelationMatrixPane({ focused, width, height }: PaneProps) {
     [symbolsKey, seriesBySymbol, matrix.sampleMin, matrix.sampleMax, matrix.hasThinPair],
   );
 
+  const refresh = useCallback(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    for (const request of chartRequests) void coordinator?.loadChart(request, { forceRefresh: true });
+  }, [chartRequests]);
+  useShortcut((event) => {
+    if (!focused || symbolsEditing || event.ctrl || event.alt || event.meta || event.super || event.shift || event.name !== "r") return;
+    event.preventDefault();
+    event.stopPropagation();
+    refresh();
+  });
+  usePaneNoticeFooter({
+    registrationId: "correlation-warnings", focused,
+    notices: [...seriesBySymbol.values()].flatMap((series) => series.refreshError
+      ? [`${series.symbol}: ${series.refreshError}${series.fetchedAt ? ` Retained history retrieved ${new Date(series.fetchedAt).toISOString()}.` : ""}`]
+      : []),
+  });
+
   // The ticker set and range are visible in-pane, so the footer only carries
   // load state and errors.
   usePaneFooter("correlation", () => ({
@@ -113,7 +133,8 @@ function CorrelationMatrixPane({ focused, width, height }: PaneProps) {
       : statusSummary
         ? [{ id: "status", parts: [{ text: statusSummary, tone: "muted" as const }] }]
         : [],
-  }), [settings.symbolsError, statusSummary]);
+    hints: [{ id: "refresh", key: "r", label: "efresh", onPress: refresh }],
+  }), [settings.symbolsError, statusSummary, refresh]);
 
   const openSymbol = useCallback((symbol: string) => {
     if (tickers.has(symbol)) {
@@ -227,15 +248,9 @@ function CorrelationMatrixPane({ focused, width, height }: PaneProps) {
               </Box>
               {/* Cells */}
               {symbols.map((colSym) => {
-                const isDiag = rowSym === colSym;
-                let r: number | null = null;
-                if (isDiag) {
-                  r = 1;
-                } else {
-                  r = matrix.results.get(pairKey(rowSym, colSym))?.correlation ?? null;
-                }
+                const r = matrix.results.get(pairKey(rowSym, colSym))?.correlation ?? null;
                 const cellColors = resolveCorrelationHeatmapCellColors(r);
-                const text = isDiag ? " 1.00" : formatCorrelation(r);
+                const text = formatCorrelation(r);
                 return (
                   <Box
                     key={colSym}
@@ -264,6 +279,7 @@ export const correlationModule: PluginModule = {
       name: "Correlation Matrix",
       icon: "C",
       component: CorrelationMatrixPane,
+      headless: correlationHeadless,
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 90, height: 18 },
@@ -274,6 +290,7 @@ export const correlationModule: PluginModule = {
       name: "Relationship Graph",
       icon: "R",
       component: RelationshipGraphPane,
+      headless: relationshipHeadless,
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 100, height: 30 },
@@ -284,6 +301,7 @@ export const correlationModule: PluginModule = {
   paneTemplates: [
     {
       id: "correlation-pane",
+      headless: correlationHeadless,
       paneId: "correlation",
       label: "Correlation Matrix",
       description: "Date-aligned Pearson correlation matrix for ticker returns.",
@@ -316,6 +334,6 @@ export const correlationModule: PluginModule = {
         };
       },
     },
-    createRelationshipPaneTemplate(),
+    { ...createRelationshipPaneTemplate(), headless: relationshipHeadless },
   ],
 };

package/src/plugins/builtin/correlation/matrix/model.ts

@@ -1,21 +1,27 @@
+import { pricePointIntegrity, type PriceHistoryIntegrity } from "../../../../utils/price-history-integrity";
 import type { QueryEntry } from "../../../../market-data/result-types";
 import { colors } from "../../../../theme/colors";
 import type { PricePoint } from "../../../../types/financials";
-import { computeDatedReturns, correlateDatedReturns, type CorrelationResult, type DatedReturn } from "../compute";
+import { dailyCloses, correlateDailyCloses, type CorrelationResult, type DailyClose } from "../compute";
 import type { CorrelationRangePreset } from "../settings";
+import { clipPriceHistoryToRange } from "../../../../time-series/history-window";
 
 export const ROW_HEADER_WIDTH = 7;
 export const MATRIX_CELL_WIDTH = 10;
 export const MIN_MATRIX_CELL_WIDTH = 7;
 const MIN_CORRELATION_OBSERVATIONS = 5;
 
-export type SeriesStatus = "loading" | "ready" | "insufficient" | "empty" | "error";
+export type SeriesStatus = "loading" | "ready" | "insufficient" | "empty" | "error" | "invalid";
 
 export interface CorrelationSeries {
   symbol: string;
-  returns: DatedReturn[];
+  prices: DailyClose[];
   status: SeriesStatus;
   observationCount: number;
+  integrity?: PriceHistoryIntegrity[];
+  loading?: boolean;
+  refreshError?: string;
+  fetchedAt?: number | null;
 }
 
 export function displaySymbol(symbol: string): string {
@@ -41,41 +47,50 @@ function formatSeriesSymbolList(symbols: string[], seriesBySymbol: Map<string, C
 export function getSeriesForEntry(
   symbol: string,
   entry: QueryEntry<PricePoint[]> | undefined,
+  range?: CorrelationRangePreset,
 ): CorrelationSeries {
   const priceHistory = entry?.data ?? entry?.lastGoodData ?? null;
 
   if (!priceHistory || priceHistory.length === 0) {
     if (entry?.error?.reasonCode === "NO_DATA") {
-      return { symbol, returns: [], status: "empty", observationCount: 0 };
+      return { symbol, prices: [], status: "empty", observationCount: 0 };
     }
     if (entry?.phase === "error" || entry?.error) {
       return {
         symbol,
-        returns: [],
+        prices: [],
         status: "error",
         observationCount: 0,
+        refreshError: entry.error?.message,
       };
     }
-    return { symbol, returns: [], status: "loading", observationCount: 0 };
+    return { symbol, prices: [], status: "loading", observationCount: 0 };
   }
 
-  const returns = computeDatedReturns(priceHistory);
-  if (returns.length < MIN_CORRELATION_OBSERVATIONS) {
-    return {
-      symbol,
-      returns,
-      status: "insufficient",
-      observationCount: returns.length,
-    };
-  }
+  return {
+    ...buildCorrelationSeries(symbol, range ? clipPriceHistoryToRange(priceHistory, range) : priceHistory),
+    loading: entry?.phase === "loading" || entry?.phase === "refreshing",
+    refreshError: entry?.error?.message,
+    fetchedAt: entry?.fetchedAt,
+  };
+}
 
-  return { symbol, returns, status: "ready", observationCount: returns.length };
+export function buildCorrelationSeries(symbol: string, history: readonly PricePoint[]): CorrelationSeries {
+  const integrity = history.flatMap((point) => { const issue = pricePointIntegrity(point); return issue ? [issue] : []; });
+  if (integrity.length) return { symbol, prices: [], observationCount: 0, status: "invalid", integrity };
+  const prices = dailyCloses(history);
+  const observationCount = Math.max(0, prices.length - 1);
+  return {
+    symbol, prices, observationCount,
+    status: observationCount < MIN_CORRELATION_OBSERVATIONS ? "insufficient" : "ready",
+  };
 }
 
 export function rowHeaderColor(status: SeriesStatus): string {
   switch (status) {
     case "loading":
       return colors.textDim;
+    case "invalid":
     case "error":
     case "empty":
       return colors.negative;
@@ -101,18 +116,18 @@ export function buildCorrelationMatrix(
 
   for (let rowIndex = 0; rowIndex < symbols.length; rowIndex++) {
     for (let colIndex = 0; colIndex < symbols.length; colIndex++) {
-      if (rowIndex === colIndex) continue;
       const rowSym = symbols[rowIndex]!;
       const colSym = symbols[colIndex]!;
       const rowSeries = seriesBySymbol.get(rowSym);
       const colSeries = seriesBySymbol.get(colSym);
       const result = rowSeries && colSeries
-        ? correlateDatedReturns(rowSeries.returns, colSeries.returns, MIN_CORRELATION_OBSERVATIONS)
+        ? correlateDailyCloses(rowSeries.prices, colSeries.prices, MIN_CORRELATION_OBSERVATIONS)
         : { correlation: null, sampleSize: 0 };
       results.set(pairKey(rowSym, colSym), result);
       if (rowIndex < colIndex) {
         if (result.sampleSize > 0) sampleSizes.push(result.sampleSize);
-        if (result.correlation == null && result.sampleSize < MIN_CORRELATION_OBSERVATIONS) {
+        if (rowSeries?.status !== "invalid" && colSeries?.status !== "invalid"
+          && result.correlation == null && result.sampleSize < MIN_CORRELATION_OBSERVATIONS) {
           hasThinPair = true;
         }
       }
@@ -137,17 +152,19 @@ export function buildStatusSummary(
   const parts: string[] = [];
   const byStatus = (status: SeriesStatus) => symbols.filter((symbol) => seriesBySymbol.get(symbol)?.status === status);
 
-  const loading = byStatus("loading");
+  const loading = symbols.filter((symbol) => seriesBySymbol.get(symbol)?.status === "loading" || seriesBySymbol.get(symbol)?.loading);
   const errors = [...byStatus("error"), ...byStatus("empty")];
   const insufficient = byStatus("insufficient");
+  const invalid = byStatus("invalid");
 
+  if (invalid.length > 0) parts.push(`Inconsistent OHLC: ${formatSeriesSymbolList(invalid, seriesBySymbol)}`);
   if (loading.length > 0) parts.push(`Loading: ${formatSeriesSymbolList(loading, seriesBySymbol)}`);
   if (errors.length > 0) parts.push(`No data: ${formatSeriesSymbolList(errors, seriesBySymbol)}`);
   if (insufficient.length > 0) parts.push(`Need history: ${formatSeriesSymbolList(insufficient, seriesBySymbol, true)}`);
 
   if (sampleMin != null && sampleMax != null) {
     parts.push(sampleMin === sampleMax ? `obs ${sampleMin}` : `obs ${sampleMin}-${sampleMax}`);
-  } else if (symbols.length >= 2) {
+  } else if (symbols.length >= 2 && invalid.length === 0) {
     parts.push("No paired dates yet");
   }
 

package/src/plugins/builtin/correlation/relationship/controls.tsx

@@ -1,6 +1,5 @@
 import { Box, Text } from "../../../../ui";
 import { colors } from "../../../../theme/colors";
-import { Checkbox } from "../../../../components/ui/checkbox";
 
 export function RelationshipMetricsTable({
   rows,
@@ -28,32 +27,3 @@ export function RelationshipMetricsTable({
     </Box>
   );
 }
-
-export function RelationshipToggle({
-  checked,
-  label,
-  onPress,
-}: {
-  checked: boolean;
-  label: string;
-  onPress: () => void;
-}) {
-  return (
-    <Box
-      width={label.length + 6}
-      height={1}
-      onMouseDown={(event: { preventDefault?: () => void; stopPropagation?: () => void }) => {
-        event.preventDefault?.();
-        event.stopPropagation?.();
-        onPress();
-      }}
-    >
-      <Checkbox
-        label={label}
-        checked={checked}
-        width={label.length + 6}
-        onChange={onPress}
-      />
-    </Box>
-  );
-}

package/src/plugins/builtin/correlation/relationship/history.test.tsx

@@ -0,0 +1,62 @@
+import { afterEach, expect, test } from "bun:test";
+import { act, useState } from "react";
+import { ApiRequestError } from "../../../../api-client/errors";
+import { testRender } from "../../../../renderers/opentui/test-utils";
+import { createInitialState } from "../../../../state/app/context";
+import { createTestDataProvider } from "../../../../test-support/data-provider";
+import { createTestPaneConfig, TestPaneProvider } from "../../../../test-support/pane";
+import { createTestPluginRuntime } from "../../../../test-support/plugin-runtime";
+import type { PricePoint } from "../../../../types/financials";
+import { useRelationshipHistories } from "./history";
+import type { RelationshipRange } from "./model";
+
+let setup: Awaited<ReturnType<typeof testRender>>;
+afterEach(async () => { await act(async () => { setup?.renderer.destroy(); }); });
+
+test("relationship refresh retains a coherent dated pair on outages, discards denied data, and isolates new windows", async () => {
+  const values = [100, 110, 105, 112, 104, 115, 120].map((close, i) => ({ date: new Date(Date.UTC(2026, 8, i + 1)), close }));
+  let failure: Error | null = null;
+  let peerFailure: Error | null = null;
+  let pending: ReturnType<typeof Promise.withResolvers<PricePoint[]>> | null = null;
+  const calls: unknown[][] = [];
+  const provider = createTestDataProvider({
+    getPriceHistory: async () => { throw new Error("Automatic chart resolution is not daily history"); },
+    getPriceHistoryForResolution: async (...args) => {
+      calls.push(args);
+      if (args[0] === "SPY:ARCX" && peerFailure) throw peerFailure;
+      if (failure) throw failure;
+      return pending ? pending.promise : values;
+    },
+  });
+  const state = createInitialState(createTestPaneConfig("/tmp/relationship-history", { instanceId: "pair", paneId: "relationship-graph" }));
+  const runtime = createTestPluginRuntime({ getMarketData: () => provider });
+  let resource!: ReturnType<typeof useRelationshipHistories>;
+  let changeRange!: (value: RelationshipRange) => void;
+  function Probe() {
+    const [range, setRange] = useState<RelationshipRange>("1Y");
+    changeRange = setRange;
+    resource = useRelationshipHistories(["BTC-USD", "SPY:ARCX"], range, "");
+    return null;
+  }
+  await act(async () => {
+    setup = await testRender(<TestPaneProvider state={state} paneId="pair" pluginId="market-overview" runtime={runtime}><Probe /></TestPaneProvider>, { width: 20, height: 5 });
+  });
+  const first = resource.data;
+  const retrieved = resource.updatedAt;
+  expect(first).toHaveLength(2);
+  expect(calls.map(call => call.slice(2, 4))).toEqual([["1Y", "1d"], ["1Y", "1d"]]);
+  failure = new Error("Provider timed out");
+  await act(async () => { await resource.reload(); });
+  expect(resource).toMatchObject({ data: first, updatedAt: retrieved, error: "BTC-USD: Provider timed out", loading: false });
+  expect(calls.at(-1)?.[4]).toEqual({ cacheMode: "refresh" });
+  failure = null;
+  pending = Promise.withResolvers<PricePoint[]>();
+  await act(async () => { changeRange("1M"); });
+  expect(resource).toMatchObject({ data: null, loading: true, error: null });
+  await act(async () => { pending!.resolve(values.slice(1)); });
+  expect(resource.data?.[0]?.points).toHaveLength(6);
+  failure = new Error("Provider timed out");
+  peerFailure = new ApiRequestError("Listing removed", 404);
+  await act(async () => { await resource.reload(); });
+  expect(resource).toMatchObject({ data: null, updatedAt: null, error: "SPY:ARCX: Listing removed" });
+});

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

@@ -1,72 +1,46 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import type { PricePoint } from "../../../../types/financials";
+import { useCallback } from "react";
+import { ApiRequestError } from "../../../../api-client/errors";
+import { useAsyncResource } from "../../../../react/async-resource";
 import { useAppSelector } from "../../../../state/app/context";
 import { useAssetData } from "../../../runtime";
-import type { LoadState } from "../../shared/ticker-request";
 import type { RelationshipRange } from "./model";
+import { loadCorrelationHistory } from "../history";
 
-type RelationshipHistoryEntry = {
-  symbol: string;
-  points: PricePoint[];
-  error: string | null;
-};
+function discardUnavailableHistory(error: unknown) {
+  return error instanceof ApiRequestError && [401, 402, 403, 404, 410].includes(error.status ?? 0);
+}
 
 export function useRelationshipHistories(pair: [string, string] | null, range: RelationshipRange, forceExchange: string) {
   const dataProvider = useAssetData();
   const tickers = useAppSelector((state) => state.tickers);
-  const [state, setState] = useState<LoadState<RelationshipHistoryEntry[]>>({
-    data: null,
-    loading: false,
-    error: null,
-  });
-  const fetchGenRef = useRef(0);
   const leftSymbol = pair?.[0] ?? null;
   const rightSymbol = pair?.[1] ?? null;
 
-  const load = useCallback((forceRefresh = false) => {
-    if (!leftSymbol || !rightSymbol) {
-      setState({ data: [], loading: false, error: null });
-      return;
-    }
-    if (!dataProvider) {
-      setState({ data: null, loading: false, error: "Market data unavailable" });
-      return;
-    }
-
-    fetchGenRef.current += 1;
-    const gen = fetchGenRef.current;
-    setState((current) => ({ ...current, loading: true, error: null }));
-
-    Promise.all([leftSymbol, rightSymbol].map(async (symbol) => {
+  const request = useCallback(async (forceRefresh = false) => {
+    const results = await Promise.allSettled([leftSymbol!, rightSymbol!].map(async (symbol) => {
       const exchange = tickers.get(symbol)?.metadata.exchange ?? (symbol === leftSymbol ? forceExchange : "");
-      try {
-        return {
-          symbol,
-          points: await dataProvider.getPriceHistory(
-            symbol,
-            exchange,
-            range,
-            forceRefresh ? { cacheMode: "refresh" } : undefined,
-          ),
-          error: null,
-        };
-      } catch (error) {
-        return {
-          symbol,
-          points: [],
-          error: error instanceof Error ? error.message : String(error),
-        };
-      }
-    })).then((data) => {
-      if (fetchGenRef.current !== gen) return;
-      const firstError = data.find((entry) => entry.error)?.error ?? null;
-      setState({ data, loading: false, error: firstError });
-    });
+      return {
+        symbol,
+        points: await loadCorrelationHistory(dataProvider!, symbol, exchange, range,
+          forceRefresh ? { cacheMode: "refresh" } : undefined),
+      };
+    }));
+    // A fast transient failure cannot mask a later authoritative denial on the peer.
+    const failureIndex = results.findIndex((result) => result.status === "rejected" && discardUnavailableHistory(result.reason));
+    const index = failureIndex >= 0 ? failureIndex : results.findIndex((result) => result.status === "rejected");
+    const failure = results[index];
+    if (failure?.status === "rejected") {
+      const symbol = index === 0 ? leftSymbol : rightSymbol;
+      const error = failure.reason;
+      const message = `${symbol}: ${error instanceof Error ? error.message : String(error)}`;
+      throw error instanceof ApiRequestError ? new ApiRequestError(message, error.status, error.retryAfterMs) : new Error(message);
+    }
+    return results.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
   }, [dataProvider, forceExchange, leftSymbol, range, rightSymbol, tickers]);
 
-  useEffect(() => {
-    load(false);
-  }, [load]);
-
-  return { ...state, reload: () => load(true) };
+  const resource = useAsyncResource(leftSymbol && rightSymbol && dataProvider ? request : null, { clearOnError: discardUnavailableHistory });
+  const error = leftSymbol && rightSymbol && !dataProvider
+    ? "Market data unavailable"
+    : resource.error;
+  return { data: resource.data, loading: resource.loading, error, reload: resource.reload, updatedAt: resource.updatedAt };
 }

package/src/plugins/builtin/correlation/relationship/model.ts

@@ -1,9 +1,11 @@
+import { pricePointIntegrity, type PriceHistoryIntegrity } from "../../../../utils/price-history-integrity";
 import type { ProjectedChartPoint } from "../../../../components/chart/core/data";
 import type { TimeRange } from "../../../../components/chart/core/types";
 import type { ScatterChartPoint } from "../../../../components/chart/static";
 import type { PaneSettingsDef, PaneTemplateCreateOptions } from "../../../../types/plugin";
 import type { PricePoint } from "../../../../types/financials";
 import { formatTickerListInput, parseTickerListInput } from "../../../../tickers/list";
+import { alignDailyCloses, dailyCloses, pearsonCorrelation } from "../compute";
 
 export type RelationshipRange = Extract<TimeRange, "1M" | "3M" | "6M" | "1Y" | "5Y" | "ALL">;
 
@@ -38,6 +40,9 @@ export interface RelationshipRegressionStats {
 }
 
 export interface RelationshipAnalysis {
+  unavailableReason?: string;
+  correlationUnavailableReason?: string;
+  integrity?: { left: PriceHistoryIntegrity[]; right: PriceHistoryIntegrity[] };
   aligned: RelationshipAlignedPoint[];
   returns: RelationshipReturnPoint[];
   ratioPoints: ProjectedChartPoint[];
@@ -48,17 +53,6 @@ export interface RelationshipAnalysis {
   latestCorrelation: number | null;
 }
 
-function pricePointTime(point: PricePoint): number {
-  const value = point.date as Date | string | number;
-  return value instanceof Date ? value.getTime() : new Date(value).getTime();
-}
-
-function pricePointDateKey(point: PricePoint): string | null {
-  const timestamp = pricePointTime(point);
-  if (!Number.isFinite(timestamp)) return null;
-  return new Date(timestamp).toISOString().slice(0, 10);
-}
-
 function syntheticChartPoint(date: Date, value: number): ProjectedChartPoint {
   return {
     date,
@@ -71,29 +65,11 @@ function syntheticChartPoint(date: Date, value: number): ProjectedChartPoint {
 }
 
 function alignRelationshipPrices(leftPoints: PricePoint[], rightPoints: PricePoint[]): RelationshipAlignedPoint[] {
-  const rightByDate = new Map<string, PricePoint>();
-  for (const point of rightPoints) {
-    const dateKey = pricePointDateKey(point);
-    if (!dateKey || !Number.isFinite(point.close) || point.close <= 0) continue;
-    rightByDate.set(dateKey, point);
-  }
-
-  return [...leftPoints]
-    .sort((left, right) => pricePointTime(left) - pricePointTime(right))
-    .flatMap((leftPoint): RelationshipAlignedPoint[] => {
-      const dateKey = pricePointDateKey(leftPoint);
-      if (!dateKey || !Number.isFinite(leftPoint.close) || leftPoint.close <= 0) return [];
-      const rightPoint = rightByDate.get(dateKey);
-      if (!rightPoint || !Number.isFinite(rightPoint.close) || rightPoint.close <= 0) return [];
-      const timestamp = pricePointTime(leftPoint);
-      return [{
-        date: new Date(timestamp),
-        dateKey,
-        leftClose: leftPoint.close,
-        rightClose: rightPoint.close,
-        ratio: leftPoint.close / rightPoint.close,
-      }];
-    });
+  return alignDailyCloses(dailyCloses(leftPoints), dailyCloses(rightPoints)).map((point) => ({
+    ...point,
+    date: new Date(`${point.dateKey}T00:00:00Z`),
+    ratio: point.leftClose / point.rightClose,
+  }));
 }
 
 function buildRelationshipReturns(aligned: RelationshipAlignedPoint[]): RelationshipReturnPoint[] {
@@ -115,37 +91,14 @@ function buildRelationshipReturns(aligned: RelationshipAlignedPoint[]): Relation
   return returns;
 }
 
-function pearson(x: number[], y: number[], minObservations = 5): number | null {
-  const n = Math.min(x.length, y.length);
-  if (n < minObservations) return null;
-
-  let sumX = 0;
-  let sumY = 0;
-  let sumXY = 0;
-  let sumX2 = 0;
-  let sumY2 = 0;
-  for (let i = 0; i < n; i++) {
-    const xValue = x[i]!;
-    const yValue = y[i]!;
-    sumX += xValue;
-    sumY += yValue;
-    sumXY += xValue * yValue;
-    sumX2 += xValue * xValue;
-    sumY2 += yValue * yValue;
-  }
-
-  const denominator = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
-  return denominator === 0 ? null : (n * sumXY - sumX * sumY) / denominator;
-}
-
 function buildRollingCorrelationPoints(
   returns: RelationshipReturnPoint[],
   windowSize: number,
 ): ProjectedChartPoint[] {
   const points: ProjectedChartPoint[] = [];
-  for (let index = 0; index < returns.length; index++) {
-    const window = returns.slice(Math.max(0, index - windowSize + 1), index + 1);
-    const correlation = pearson(
+  for (let index = windowSize - 1; index < returns.length; index++) {
+    const window = returns.slice(index - windowSize + 1, index + 1);
+    const correlation = pearsonCorrelation(
       window.map((entry) => entry.rightReturn),
       window.map((entry) => entry.leftReturn),
       5,
@@ -175,7 +128,7 @@ function computeRelationshipRegression(returns: RelationshipReturnPoint[]): Rela
 
   const beta = numerator / denominator;
   const alpha = meanY - beta * meanX;
-  const r = pearson(x, y, 5);
+  const r = pearsonCorrelation(x, y, 5);
   if (r === null) return null;
 
   let residualSumSquares = 0;
@@ -200,6 +153,15 @@ export function buildRelationshipAnalysis(
   rightPoints: PricePoint[],
   correlationWindow = DEFAULT_RELATIONSHIP_CORRELATION_WINDOW,
 ): RelationshipAnalysis {
+  const issues = (points: PricePoint[]) => points.flatMap((point) => {
+    const issue = pricePointIntegrity(point); return issue ? [issue] : [];
+  });
+  const integrity = { left: issues(leftPoints), right: issues(rightPoints) };
+  if (integrity.left.length || integrity.right.length) return {
+    aligned: [], returns: [], ratioPoints: [], correlationPoints: [], scatterPoints: [],
+    stats: null, latestRatio: null, latestCorrelation: null, integrity,
+    unavailableReason: "Inconsistent OHLC history; relationship calculations are unavailable for this window.",
+  };
   const aligned = alignRelationshipPrices(leftPoints, rightPoints);
   const returns = buildRelationshipReturns(aligned);
   const correlationPoints = buildRollingCorrelationPoints(returns, correlationWindow);
@@ -209,6 +171,10 @@ export function buildRelationshipAnalysis(
     highlight: index === returns.length - 1,
   }));
   const stats = computeRelationshipRegression(returns);
+  const latestCorrelation = correlationPoints.findLast((point) => point.date.getTime() === returns.at(-1)?.date.getTime())?.close ?? null;
+  const correlationUnavailableReason = returns.length < correlationWindow
+    ? `Rolling correlation needs ${correlationWindow} shared returns; ${returns.length} available.`
+    : latestCorrelation === null ? `Rolling correlation is unavailable: zero return variance in the latest ${correlationWindow} shared returns.` : undefined;
 
   return {
     aligned,
@@ -218,7 +184,8 @@ export function buildRelationshipAnalysis(
     scatterPoints,
     stats,
     latestRatio: aligned.at(-1)?.ratio ?? null,
-    latestCorrelation: correlationPoints.at(-1)?.close ?? null,
+    latestCorrelation,
+    ...(correlationUnavailableReason ? { correlationUnavailableReason } : {}),
   };
 }