gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/congress-trades/headless.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { CloudCongressHousePayload } from "../../../api-client";
-import { createTestDataProvider } from "../../../test-support/data-provider";
-import { createDefaultConfig } from "../../../types/config";
-import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
-import { createCongressHeadless } from "./headless";
-
-const payload: CloudCongressHousePayload = {
-  asOf: "2026-09-04T12:00:00.000Z",
-  chamber: "house",
-  source: "house-clerk",
-  year: 2026,
-  indexUpdatedAt: "2026-09-04T11:00:00.000Z",
-  filingsScanned: 2,
-  filingCount: 2,
-  trades: [
-    {
-      id: "trade-1",
-      chamber: "house",
-      filingId: "filing-1",
-      docId: "doc-1",
-      memberName: "Nancy Pelosi",
-      stateDistrict: "CA-11",
-      filingDate: "2026-09-03",
-      transactionDate: "2026-08-20",
-      notificationDate: null,
-      lagDays: 14,
-      side: "BUY",
-      transactionType: "Purchase",
-      ticker: "NVDA",
-      assetName: "NVIDIA Corporation",
-      assetType: "Stock",
-      owner: "SP",
-      rawOwner: "Spouse",
-      amount: "$1,000,001 - $5,000,000",
-      amountLow: 1_000_001,
-      amountHigh: 5_000_000,
-      capGainsOver200: null,
-      filingStatus: null,
-      subholdingOf: null,
-      description: null,
-      sourceUrl: "https://disclosures-clerk.house.gov/filing-1",
-    },
-  ],
-  members: [
-    {
-      id: "member-1",
-      memberName: "Nancy Pelosi",
-      stateDistrict: "CA-11",
-      tradeCount: 12,
-      buyCount: 8,
-      sellCount: 4,
-      exchangeCount: 0,
-      otherCount: 0,
-      estimatedLow: 2_000_000,
-      estimatedHigh: 8_000_000,
-      lastFilingDate: "2026-09-03",
-      avgLagDays: 18,
-    },
-  ],
-};
-
-function context(): HeadlessPaneContext {
-  return {
-    marketData: createTestDataProvider(),
-    apiClient: {} as HeadlessPaneContext["apiClient"],
-    config: createDefaultConfig("/tmp/gloomberb-headless-congress"),
-    signal: new AbortController().signal,
-  };
-}
-
-function args(tab: "trades" | "members", limit = 50): HeadlessPaneLoadArgs {
-  return { rawArgument: "", argument: null, symbols: [], options: { tab, year: 2026, limit } };
-}
-
-describe("congress headless model", () => {
-  test("passes ticker and both cursors to the server without hiding source gaps", async () => {
-    let requested: unknown;
-    const ctx = context();
-    ctx.apiClient = { getCloudCongressHouse: async (params: unknown) => {
-      requested = params;
-      return { ...payload, filingsPending: 3, hasMoreFilings: true, nextFilingOffset: 120 };
-    } } as HeadlessPaneContext["apiClient"];
-    const result = await createCongressHeadless().load({
-      ...args("trades"), argument: "NVDA", symbols: ["NVDA"],
-      options: { ...args("trades").options, offset: 20, filingOffset: 60 },
-    }, ctx);
-    expect(requested).toMatchObject({ ticker: "NVDA", offset: 20, filingOffset: 60 });
-    expect(result.metadata).toMatchObject({ filingsPending: 3, hasMoreFilings: true, nextFilingOffset: 120 });
-  });
-
-  test("projects the active tab and applies its row limit", async () => {
-    const headless = createCongressHeadless({ loadHouse: async () => payload });
-
-    const trades = await headless.load(args("trades", 1), context());
-    expect(trades.rows).toMatchObject([{
-      memberName: "Nancy Pelosi",
-      side: "BUY",
-      ticker: "NVDA",
-      amountLow: 1_000_001,
-      amountHigh: 5_000_000,
-    }]);
-    expect(trades.columns?.map((column) => column.key)).toContain("ticker");
-
-    const members = await headless.load(args("members", 1), context());
-    expect(members.rows).toMatchObject([{
-      memberName: "Nancy Pelosi",
-      tradeCount: 12,
-      buyCount: 8,
-    }]);
-    expect(members.columns?.map((column) => column.key)).toContain("tradeCount");
-  });
-});

package/src/plugins/builtin/congress-trades/model.test.ts

@@ -1,129 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { cloudCongressHousePath } from "../../../api-client/paths";
-import type { CloudCongressHousePayload } from "../../../api-client";
-import {
-  canLoadMoreCongress,
-  congressScanNotice,
-  mergeCongressPages,
-  nextCongressPage,
-  previousCongressYearPage,
-  tradeAssetLabel,
-} from "./model";
-
-function payload(overrides: Partial<CloudCongressHousePayload> = {}): CloudCongressHousePayload {
-  return {
-    asOf: "2026-01-01T00:00:00.000Z",
-    chamber: "house",
-    source: "house-clerk",
-    year: 2026,
-    indexUpdatedAt: null,
-    filingsScanned: 20,
-    filingCount: 80,
-    filingOffset: 0,
-    hasMore: false,
-    hasMoreFilings: true,
-    nextOffset: 20,
-    nextFilingOffset: 20,
-    trades: [],
-    members: [],
-    ...overrides,
-  };
-}
-
-describe("congress paging", () => {
-  test("walks remaining trades, then more filings, then stops", () => {
-    expect(nextCongressPage(payload({ hasMore: true, nextOffset: 40 }))).toEqual({
-      year: 2026,
-      offset: 40,
-      filingOffset: 0,
-    });
-    expect(nextCongressPage(payload({ hasMore: false, hasMoreFilings: true, nextFilingOffset: 20 }))).toEqual({
-      year: 2026,
-      offset: 0,
-      filingOffset: 20,
-    });
-    expect(nextCongressPage(payload({
-      hasMore: false,
-      hasMoreFilings: undefined,
-      filingOffset: 0,
-      filingsScanned: 20,
-      filingCount: 80,
-    }))).toEqual({
-      year: 2026,
-      offset: 0,
-      filingOffset: 20,
-    });
-  });
-
-  test("never crosses into an earlier year on its own", () => {
-    // Each earlier year is a fresh set of source documents to read.
-    expect(nextCongressPage(payload({ hasMore: false, hasMoreFilings: false }))).toBeNull();
-    expect(canLoadMoreCongress(payload({ hasMore: false, hasMoreFilings: false }))).toBe(false);
-    // A filtered filing window can be empty while a later window has matches.
-    expect(nextCongressPage(mergeCongressPages(payload(), payload({
-      filingOffset: 20, nextFilingOffset: 40, trades: [],
-    })))).toEqual({ year: 2026, offset: 0, filingOffset: 40 });
-  });
-
-  test("offers the earlier year only when asked, and only back to 2008", () => {
-    expect(previousCongressYearPage(payload({ year: 2026 }))).toEqual({
-      year: 2025,
-      offset: 0,
-      filingOffset: 0,
-    });
-    expect(previousCongressYearPage(payload({ year: 2008 }))).toBeNull();
-  });
-
-  test("names the filings missing from an incomplete window", () => {
-    expect(congressScanNotice(payload())).toBeNull();
-    expect(congressScanNotice(payload({ filingsFailed: 2 }))).toBe("2 filings unavailable");
-    expect(congressScanNotice(payload({ filingsFailed: 1, filingsPending: 3 }))).toBe(
-      "4 filings not read yet, retrying later",
-    );
-    expect(congressScanNotice(payload({ filingsFailed: 1, filingsPaper: 2, senateUnavailable: true }))).toBe(
-      "1 filings unavailable · 2 Senate paper filings not read · Senate filings unavailable, showing House only",
-    );
-    expect(congressScanNotice(payload({ filingsPaper: 1 }))).toBe("1 Senate paper filing not read");
-  });
-
-  test("pages keep the chamber they were asked for", () => {
-    expect(cloudCongressHousePath({ year: 2026 })).toBe("/cloud/congress/house?year=2026");
-    expect(cloudCongressHousePath({ chamber: "all", ...nextCongressPage(payload({ hasMore: true, nextOffset: 5 }))! }))
-      .toStartWith("/cloud/congress/all?");
-    expect(cloudCongressHousePath({ chamber: "senate", ticker: "NVDA" })).toBe("/cloud/congress/senate?ticker=NVDA");
-  });
-
-  test("appends unique trades and members from the next page", () => {
-    const merged = mergeCongressPages(
-      payload({
-        trades: [{ id: "t1" } as CloudCongressHousePayload["trades"][number]],
-        members: [{ id: "m1" } as CloudCongressHousePayload["members"][number]],
-      }),
-      payload({
-        year: 2025,
-        trades: [
-          { id: "t1" } as CloudCongressHousePayload["trades"][number],
-          { id: "t2" } as CloudCongressHousePayload["trades"][number],
-        ],
-        members: [{ id: "m2" } as CloudCongressHousePayload["members"][number]],
-      }),
-    );
-    expect(merged.year).toBe(2025);
-    expect(merged.trades.map((trade) => trade.id)).toEqual(["t1", "t2"]);
-    expect(merged.members.map((member) => member.id)).toEqual(["m1", "m2"]);
-  });
-});
-
-describe("congress trade asset label", () => {
-  test("reads option terms from Senate and House descriptions", () => {
-    const label = (assetName: string, description: string | null, assetType: string | null = "OP") => tradeAssetLabel({ assetName, assetType, description });
-    expect(label("Williams Companies, Inc. (The) Common Stock", "Option Type: Call Strike price: $75.00 Expires: 2026-08-21 · All transactions notified to Filer on September 1, 2026"))
-      .toBe("CALL $75 exp 2026-08-21 · Williams Companies, Inc. (The)");
-    expect(label("Microsoft Corporation - Common Stock", "Call options; Strike price $340; Expires 10/16/2026"))
-      .toBe("CALL $340 exp 2026-10-16 · Microsoft Corporation");
-    expect(label("Bloom Energy Corporation Class A Common Stock", "Purchased 100 put options with a strike price of $1,100.50 and an expiration date of 6/7/27."))
-      .toBe("PUT $1100.5 exp 2027-06-07 · Bloom Energy Corporation Class A");
-    expect(label("Apple Inc. - Common Stock", null)).toBe("OPTION · Apple Inc.");
-    expect(label("Apple Inc. - Common Stock", "Call options", "ST")).toBe("Apple Inc. - Common Stock");
-  });
-});

package/src/plugins/builtin/connections/pane.test.tsx

@@ -1,84 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { act, useState } from "react";
-import { PaneFooterBar, PaneFooterProvider } from "../../../components/layout/pane/footer";
-import { ConnectionHealthRegistry } from "../../../core/connection-health";
-import { testRender } from "../../../renderers/opentui/test-utils";
-import { appReducer, createInitialState, type AppAction, type AppState } from "../../../state/app/context";
-import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import { createDefaultConfig } from "../../../types/config";
-import { Box } from "../../../ui";
-import { ConnectionsPane } from "./pane";
-import { TestPaneProvider } from "../../../test-support/pane";
-
-let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
-
-afterEach(async () => {
-  if (!testSetup) return;
-  await act(async () => testSetup!.renderer.destroy());
-  testSetup = undefined;
-});
-
-function harness() {
-  const health = new ConnectionHealthRegistry();
-  health.registerSource({ id: "quotes", name: "Quotes", kind: "asset-data" });
-  health.reportRequest("quotes", { operation: "getQuote", success: true, latencyMs: 12 });
-  const runtime = createTestPluginRuntime({ getConnectionHealth: () => health });
-  const state = createInitialState(createDefaultConfig("/tmp/gloomberb-connections-pane-test"));
-
-  function Harness() {
-    // The selected source and the open detail are pane state, so the harness
-    // needs a reducer.
-    const [paneState, setPaneState] = useState<AppState["paneState"]>({});
-    state.paneState = paneState;
-    const dispatch = (action: AppAction) => setPaneState(appReducer(state, action).paneState);
-    return (
-      <TestPaneProvider state={state} dispatch={dispatch} paneId="connections:test" pluginId="application" runtime={runtime}>
-        <PaneFooterProvider>
-          {(footer) => (
-            <Box flexDirection="column" width={80} height={12}>
-              <ConnectionsPane paneId="connections:test" paneType="connections" focused width={80} height={11} />
-              <PaneFooterBar footer={footer} focused width={80} />
-            </Box>
-          )}
-        </PaneFooterProvider>
-      </TestPaneProvider>
-    );
-  }
-
-  return <Harness />;
-}
-
-async function renderSettled() {
-  await act(async () => {
-    await testSetup!.renderOnce();
-    await testSetup!.renderOnce();
-  });
-}
-
-describe("ConnectionsPane", () => {
-  test("hides the clickable sort hint while detail blocks the sort key", async () => {
-    testSetup = await testRender(harness(), { width: 80, height: 12 });
-    await renderSettled();
-    expect(testSetup.captureCharFrame()).toContain("[s]ort");
-
-    await act(async () => {
-      testSetup!.renderer.keyInput.emit("keypress", {
-        name: "enter",
-        sequence: "\r",
-        ctrl: false,
-        meta: false,
-        option: false,
-        shift: false,
-        eventType: "press",
-        repeated: false,
-        preventDefault: () => {},
-        stopPropagation: () => {},
-      } as any);
-      await testSetup!.renderOnce();
-    });
-    await renderSettled();
-
-    expect(testSetup.captureCharFrame()).toContain("← Back Quotes");
-    expect(testSetup.captureCharFrame()).not.toContain("[s]ort");
-  });
-});

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

@@ -1,39 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { applyTheme } from "../../../theme/colors";
-import { contrastRatio } from "../../../theme/color-utils";
-import { DEFAULT_THEME, themes } from "../../../theme/themes";
-import { resolveCorrelationHeatmapCellColors } from "./colors";
-
-const CORRELATION_VALUES = [-1, -0.75, -0.5, -0.25, 0, 0.13, 0.24, 0.39, 0.49, 0.75, 1] as const;
-const CELL_TEXT_MIN_CONTRAST = 4.5;
-const MUTED_TEXT_MIN_CONTRAST = 3.6;
-
-afterEach(() => {
-  applyTheme(DEFAULT_THEME);
-});
-
-describe("correlation heatmap colors", () => {
-  test("keeps populated cells readable in every theme", () => {
-    for (const themeId of Object.keys(themes)) {
-      applyTheme(themeId);
-      for (const correlation of CORRELATION_VALUES) {
-        const cell = resolveCorrelationHeatmapCellColors(correlation);
-        expect(
-          contrastRatio(cell.foreground, cell.background),
-          `${themeId} correlation ${correlation}`,
-        ).toBeGreaterThanOrEqual(CELL_TEXT_MIN_CONTRAST);
-      }
-    }
-  });
-
-  test("keeps empty cells readable in every theme", () => {
-    for (const themeId of Object.keys(themes)) {
-      applyTheme(themeId);
-      const cell = resolveCorrelationHeatmapCellColors(null);
-      expect(
-        contrastRatio(cell.foreground, cell.background),
-        `${themeId} empty cell`,
-      ).toBeGreaterThanOrEqual(MUTED_TEXT_MIN_CONTRAST);
-    }
-  });
-});

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

@@ -1,97 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  computeReturns,
-  correlateDailyCloses,
-  dailyCloses,
-  pearsonCorrelation,
-} from "./compute";
-
-describe("cross-market return alignment", () => {
-  test("uses matching return intervals across weekends, exchange holidays, and missing sessions", () => {
-    const history = (dates: string[], closes: number[]) => dates.map((date, i) => ({ date: new Date(date), close: closes[i]! }));
-    const equity = history(
-      ["2026-01-02", "2026-01-05", "2026-01-06", "2026-01-07", "2026-01-09", "2026-01-12"],
-      [100, 110, 105, 115, 111, 118],
-    );
-    const crypto = [...history(
-      ["2026-01-02", "2026-01-05", "2026-01-06", "2026-01-07", "2026-01-09", "2026-01-12"],
-      [200, 220, 210, 230, 222, 236],
-    ), ...history(["2026-01-04", "2026-01-08", "2026-01-11"], [250, 190, 270])];
-
-    // Both assets have identical moves between shared closes. Weekend-only
-    // prices must not change the intervals used for either side.
-    expect(correlateDailyCloses(dailyCloses(equity), dailyCloses(crypto))).toEqual({ correlation: 1, sampleSize: 5 });
-    expect(correlateDailyCloses(dailyCloses(crypto), dailyCloses(equity))).toEqual({ correlation: 1, sampleSize: 5 });
-  });
-
-  test("uses the final valid observation for a date without inventing intraday daily returns", () => {
-    expect(dailyCloses([
-      { date: new Date("2026-01-03T22:00:00Z"), close: 121 },
-      { date: new Date("2026-01-02T20:00:00Z"), close: 105 },
-      { date: new Date("2026-01-01"), close: 100 },
-      { date: new Date("2026-01-02T22:00:00Z"), close: 110 },
-      { date: new Date("2026-01-02T23:00:00Z"), close: Number.NaN },
-    ])).toEqual([
-      { dateKey: "2026-01-01", close: 100 },
-      { dateKey: "2026-01-02", close: 110 },
-      { dateKey: "2026-01-03", close: 121 },
-    ]);
-  });
-});
-
-describe("computeReturns", () => {
-  test("computes simple returns", () => {
-    const returns = computeReturns([100, 110, 105, 115]);
-    expect(returns).toHaveLength(3);
-    expect(returns[0]).toBeCloseTo(0.1, 5);
-    expect(returns[1]).toBeCloseTo(-0.0455, 3);
-    expect(returns[2]).toBeCloseTo(0.0952, 3);
-  });
-
-  test("skips zero or invalid previous closes", () => {
-    expect(computeReturns([0, 10, 20, Number.NaN, 30])).toEqual([1]);
-  });
-});
-
-describe("pearsonCorrelation", () => {
-  test("perfect positive correlation", () => {
-    const x = [1, 2, 3, 4, 5];
-    const y = [2, 4, 6, 8, 10];
-    expect(pearsonCorrelation(x, y)).toBeCloseTo(1.0, 5);
-  });
-
-  test("perfect negative correlation", () => {
-    const x = [1, 2, 3, 4, 5];
-    const y = [10, 8, 6, 4, 2];
-    expect(pearsonCorrelation(x, y)).toBeCloseTo(-1.0, 5);
-  });
-
-  test("returns null for insufficient data", () => {
-    expect(pearsonCorrelation([1, 2], [3, 4])).toBeNull();
-  });
-
-  test("returns null for zero variance", () => {
-    expect(pearsonCorrelation([5, 5, 5, 5, 5], [1, 2, 3, 4, 5])).toBeNull();
-  });
-
-  test("keeps nearly constant return series finite and correlations bounded", () => {
-    const x = [1, 2, 3, 4, 5].map((value) => 0.001 + value * 1e-12);
-    expect(pearsonCorrelation(x, x)).toBeCloseTo(1);
-    expect(pearsonCorrelation(x, x.map((value) => -value))).toBeCloseTo(-1);
-    expect(pearsonCorrelation(x, [1, 2, Number.NaN, 4, 5])).toBeNull();
-  });
-});
-
-test("matrix calculations clip buffered history and retain loading/error provenance without removing usable pairs", async () => {
-  const { getSeriesForEntry, buildStatusSummary } = await import("./matrix/model");
-  const { createIdleEntry } = await import("../../../market-data/result-types");
-  const prices = [100, 110, 105, 112, 104, 115, 120].map((close, i) => ({ date: new Date(Date.UTC(2026, 8, i + 1)), close }));
-  const buffered = [{ date: new Date("2025-01-01"), close: 2 }, ...prices];
-  const entry = { ...createIdleEntry<typeof buffered>(), data: buffered, lastGoodData: buffered, fetchedAt: 123, phase: "refreshing" as const };
-  const series = getSeriesForEntry("SPY", entry, "1M");
-  expect(series).toMatchObject({ status: "ready", loading: true, observationCount: 6, fetchedAt: 123 });
-  expect(buildStatusSummary(["SPY"], new Map([["SPY", series]]), 6, 6)).toContain("Loading: SPY");
-  const retained = getSeriesForEntry("SPY", { ...entry, phase: "error", error: { reasonCode: "TIMEOUT", message: "Provider timed out" } }, "1M");
-  expect(retained).toMatchObject({ status: "ready", loading: false, refreshError: "Provider timed out", fetchedAt: 123 });
-  expect(retained.prices).toEqual(series.prices);
-});

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

@@ -1,147 +0,0 @@
-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 });
-});