gloomberb 0.15.2 → 0.15.3

package/src/plugins/builtin/econ/fred-cache.test.ts

@@ -1,188 +0,0 @@
-import { afterEach, beforeEach, describe, expect, setSystemTime, test } from "bun:test";
-import { MemoryPluginPersistence } from "../../../test-support/plugin-persistence";
-import {
-  attachFredSeriesPersistence,
-  hydrateFredSeries,
-  isFredPublicationPending,
-  loadCachedFredSeries,
-  resetFredSeriesPersistence,
-  type FredSeriesData,
-  type FredSeriesRequest,
-} from "../../../data/fred-series";
-
-const REQUEST: FredSeriesRequest = {
-  seriesId: "CPIAUCSL",
-  startDate: "2021-05-24",
-  sortOrder: "asc",
-};
-
-function makeSeries(value: number): FredSeriesData {
-  return {
-    observations: [
-      { date: "2026-05-01", value },
-    ],
-    info: {
-      id: "CPIAUCSL",
-      title: "Consumer Price Index",
-      units: "Index 1982-1984=100",
-      frequency: "Monthly",
-      seasonalAdjustment: "Seasonally Adjusted",
-      source: "FRED",
-      notes: "",
-    },
-  };
-}
-
-// Plugin activation in other test files attaches a live persistence to this
-// module and never detaches it, so the cache these tests exercise depends on
-// which file ran first. Establish the state instead of inheriting it.
-beforeEach(() => {
-  resetFredSeriesPersistence();
-});
-
-afterEach(() => {
-  resetFredSeriesPersistence();
-});
-
-describe("FRED series cache", () => {
-  test("refreshes legacy metadata and preserves coverage and source freshness through reopening", async () => {
-    const persistence = new MemoryPluginPersistence();
-    const request: FredSeriesRequest = { seriesId: "BAMLC0A0CM", startDate: "2007-01-01", sortOrder: "asc" };
-    const old = { ...makeSeries(0.8), info: { ...makeSeries(0.8).info!, id: request.seriesId } };
-    persistence.seedResource("fred-series", "BAMLC0A0CM:start=2007-01-01:sort=asc", old,
-      { sourceKey: "gloomberb-cloud", schemaVersion: 1 });
-    attachFredSeriesPersistence(persistence);
-    let calls = 0;
-    const fetchedAt = new Date(Date.now() - 60_000).toISOString();
-    const updated = { ...old, fetchedAt, info: { ...old.info, observationStart: "2023-09-12", observationEnd: "2026-09-10" } };
-    const loaded = await loadCachedFredSeries(request, async () => { calls++; return updated; });
-    expect(calls).toBe(1);
-    expect(loaded.data.info?.observationStart).toBe("2023-09-12");
-    resetFredSeriesPersistence();
-    attachFredSeriesPersistence(persistence);
-    const reopened = await loadCachedFredSeries(request, async () => { throw Error("Must reuse upgraded cache"); });
-    expect(reopened.data).toEqual(updated);
-    expect(reopened.fetchedAt).toBe(Date.parse(fetchedAt));
-    expect(reopened.stale).toBe(false);
-    const offline = await loadCachedFredSeries(request, async () => { throw Error("offline"); }, { force: true });
-    expect(offline.stale).toBe(true);
-    expect(offline.data.info?.observationEnd).toBe("2026-09-10");
-    expect(offline.fetchedAt).toBe(Date.parse(fetchedAt));
-  });
-
-  test("uses server-hydrated series without calling the network loader", async () => {
-    hydrateFredSeries([["cpiaucsl", {
-      data: makeSeries(321),
-      fetchedAt: 123,
-      stale: false,
-    }]]);
-    let calls = 0;
-
-    const result = await loadCachedFredSeries(REQUEST, async () => {
-      calls += 1;
-      return makeSeries(1);
-    });
-
-    expect(calls).toBe(0);
-    expect(result.source).toBe("cache");
-    expect(result.fetchedAt).toBe(123);
-    expect(result.data.observations[0]!.value).toBe(321);
-  });
-
-  test("rehydrates persisted series without refetching", async () => {
-    const persistence = new MemoryPluginPersistence();
-    attachFredSeriesPersistence(persistence);
-
-    await loadCachedFredSeries(REQUEST, async () => makeSeries(320));
-
-    resetFredSeriesPersistence();
-    attachFredSeriesPersistence(persistence);
-
-    let calls = 0;
-    const cached = await loadCachedFredSeries(REQUEST, async () => {
-      calls += 1;
-      return makeSeries(1);
-    });
-
-    expect(calls).toBe(0);
-    expect(cached.source).toBe("cache");
-    expect(cached.stale).toBe(false);
-    expect(cached.data.observations[0]!.value).toBe(320);
-    expect(cached.data.info?.id).toBe("CPIAUCSL");
-  });
-
-  test("reports stale cached data when a refresh fails", async () => {
-    const persistence = new MemoryPluginPersistence();
-    persistence.seedResource(
-      "fred-series",
-      "CPIAUCSL:start=2021-05-24:sort=asc",
-      makeSeries(319),
-      {
-        sourceKey: "gloomberb-cloud",
-        schemaVersion: 2,
-        stale: true,
-      },
-    );
-    attachFredSeriesPersistence(persistence);
-
-    const result = await loadCachedFredSeries(REQUEST, async () => {
-      throw new Error("network unavailable");
-    });
-
-    expect(result.source).toBe("stale-fallback");
-    expect(result.stale).toBe(true);
-    expect(result.refreshError).toBe("network unavailable");
-    expect(result.data.observations[0]!.value).toBe(319);
-  });
-});
-
-test("a daily series cached before its morning publication is re-read within the day", async () => {
-  const request: FredSeriesRequest = { seriesId: "VIXCLS", limit: 400, sortOrder: "desc" };
-  const series = (...dates: string[]): FredSeriesData => ({
-    observations: dates.map((date) => ({ date, value: 14.2 })), info: null,
-  });
-  const beforeRelease = series("2026-09-21", "2026-09-18", "2026-09-17", "2026-09-16");
-  const published = series("2026-09-22", ...beforeRelease.observations.map((point) => point.date));
-  const persistence = new MemoryPluginPersistence();
-  attachFredSeriesPersistence(persistence);
-  try {
-    // 06:00 New York on Wednesday 2026-09-23, before FRED posts the 09-22 close.
-    setSystemTime(new Date("2026-09-23T10:00:00Z"));
-    await loadCachedFredSeries(request, async () => beforeRelease);
-    let calls = 0;
-    const loader = async () => { calls++; return published; };
-    setSystemTime(new Date("2026-09-23T10:20:00Z"));
-    expect((await loadCachedFredSeries(request, loader)).data).toEqual(beforeRelease);
-    expect(calls).toBe(0);
-    setSystemTime(new Date("2026-09-23T10:45:00Z"));
-    expect((await loadCachedFredSeries(request, async () => { throw Error("offline"); })).stale).toBe(false);
-    const refreshed = await loadCachedFredSeries(request, loader);
-    expect(calls).toBe(1);
-    expect(refreshed.data.observations[0]!.date).toBe("2026-09-22");
-    setSystemTime(new Date("2026-09-23T20:00:00Z"));
-    await loadCachedFredSeries(request, loader);
-    expect(calls).toBe(1);
-  } finally {
-    setSystemTime();
-  }
-  const hour = 60 * 60_000;
-  // Weekends publish nothing; weekly series keep the nominal policy.
-  const saturday = Date.parse("2026-09-26T15:00:00Z");
-  expect(isFredPublicationPending(series("2026-09-24", "2026-09-23", "2026-09-22").observations, saturday - 2 * hour, saturday)).toBe(false);
-  const monday = Date.parse("2026-09-28T15:00:00Z");
-  expect(isFredPublicationPending(series("2026-09-24", "2026-09-23", "2026-09-22").observations, monday - hour, monday)).toBe(true);
-  expect(isFredPublicationPending(series("2026-09-16", "2026-09-09", "2026-09-02").observations, monday - hour, monday)).toBe(false);
-});
-
-test("a successful HTTP response cannot erase the source's stale flag or retrieval time", async () => {
-  const { withFredSourceFreshness } = await import("../../../data/fred-series");
-  const sourceTime = Date.parse("2026-09-08T12:00:00Z");
-  const entry = withFredSourceFreshness({
-    data: { observations: [{ date: "2026-09-04", value: 4.78 }], info: null, stale: true, fetchedAt: new Date(sourceTime).toISOString() },
-    fetchedAt: Date.parse("2026-09-10T12:00:00Z"),
-    stale: false,
-    source: "network" as const,
-  });
-  expect(entry.stale).toBe(true);
-  expect(entry.fetchedAt).toBe(sourceTime);
-});

package/src/plugins/builtin/econ/fred-client.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { resolveFredMapping, getRelatedTickers, projectFredHistory, fredHistoryUnits } from "./fred-series-map";
-
-describe("resolveFredMapping", () => {
-  test("maps exact US event titles", () => {
-    const m = resolveFredMapping("CPI m/m", "US");
-    expect(m).not.toBeNull();
-    expect(m!.seriesId).toBe("CPIAUCSL");
-    expect(m!.relatedTickers).toContain("TIP");
-  });
-
-  test("case insensitive matching", () => {
-    expect(resolveFredMapping("cpi m/m", "US")?.seriesId).toBe("CPIAUCSL");
-    expect(resolveFredMapping("CPI M/M", "US")?.seriesId).toBe("CPIAUCSL");
-  });
-
-  test("strips prefixes for fuzzy match", () => {
-    expect(resolveFredMapping("Final GDP q/q", "US")?.seriesId).toBe("GDPC1");
-    expect(resolveFredMapping("Prelim GDP q/q", "US")?.seriesId).toBe("GDPC1");
-    expect(resolveFredMapping("Advance GDP q/q", "US")?.seriesId).toBe("GDPC1");
-  });
-
-  test("returns null for non-US events", () => {
-    expect(resolveFredMapping("CPI m/m", "EU")).toBeNull();
-    expect(resolveFredMapping("CPI m/m", "GB")).toBeNull();
-  });
-
-  test("returns null for unmapped events", () => {
-    expect(resolveFredMapping("President Trump Speaks", "US")).toBeNull();
-    expect(resolveFredMapping("Bank Holiday", "US")).toBeNull();
-  });
-
-  test("maps FOMC and Fed events", () => {
-    expect(resolveFredMapping("Federal Funds Rate", "US")?.seriesId).toBe("DFEDTARU");
-  });
-
-  test("maps commodity indicators", () => {
-    expect(resolveFredMapping("Crude Oil Inventories", "US")).toBeNull();
-    expect(resolveFredMapping("Natural Gas Storage", "US")).toBeNull();
-  });
-});
-
-describe("getRelatedTickers", () => {
-  test("returns related tickers for known events", () => {
-    const tickers = getRelatedTickers("CPI m/m", "US");
-    expect(tickers).toContain("TIP");
-    expect(tickers).toContain("DX-Y.NYB");
-  });
-
-});
-
-
-test("calendar history shows inflation rates, payroll job changes, and annualized real GDP", () => {
-  const cpi = resolveFredMapping("CPI y/y", "US")!;
-  expect(cpi.seriesId).toBe("CPIAUCNS");
-  const observations = [
-    { date: "2025-07-01", value: 100 },
-    { date: "2025-08-01", value: 101 },
-    { date: "2026-06-01", value: 102 },
-    { date: "2026-07-01", value: 103.4 },
-  ];
-  expect(projectFredHistory(observations, cpi).at(-1)?.value).toBeCloseTo(3.4);
-  expect(fredHistoryUnits(cpi, "Index")).toBe("Percent change from year ago");
-  const payrolls = resolveFredMapping("Non-Farm Employment Change", "US")!;
-  expect(projectFredHistory([{ date: "2026-06-01", value: 160000 }, { date: "2026-07-01", value: 160120 }], payrolls)[0]?.value).toBe(120);
-  expect(fredHistoryUnits(payrolls, "Thousands of Persons")).toBe("Thousands of Persons change from previous period");
-  const gdp = resolveFredMapping("Advance GDP q/q", "US")!;
-  expect(gdp.seriesId).toBe("GDPC1");
-  expect(projectFredHistory([{ date: "2026-01-01", value: 100 }, { date: "2026-04-01", value: 101 }], gdp)[0]?.value).toBeCloseTo((1.01 ** 4 - 1) * 100);
-  expect(resolveFredMapping("CPI", "US")).toBeNull();
-});
-
-
-test("calendar headline PPI uses final demand and cannot alias Conference Board to OECD", () => {
-  expect(resolveFredMapping("PPI m/m", "US")?.seriesId).toBe("PPIFIS");
-  expect(resolveFredMapping("CB Consumer Confidence", "US")).toBeNull();
-  // ISM withdrew its PMI from FRED; NAPM no longer exists there.
-  expect(resolveFredMapping("ISM Manufacturing PMI", "US")).toBeNull();
-});

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

@@ -1,144 +0,0 @@
-import { afterEach, beforeEach, describe, expect, setSystemTime, test } from "bun:test";
-import { act } from "react";
-import { testRender } from "../../../renderers/opentui/test-utils";
-import { PaneFooterProvider } from "../../../components/layout/pane/footer";
-import { createInitialState } from "../../../state/app/context";
-import { createDefaultConfig } from "../../../types/config";
-import { MemoryPluginPersistence } from "../../../test-support/plugin-persistence";
-import type { PluginRuntimeAccess } from "../../runtime";
-import { attachEconCalendarPersistence, resetEconCalendarPersistence } from "./calendar-model";
-import { economicCalendarModule } from "./index";
-import { TestPaneProvider } from "../../../test-support/pane";
-
-const EconPane = economicCalendarModule.panes![0]!.component as (props: {
-  paneId: string;
-  paneType: string;
-  focused: boolean;
-  width: number;
-  height: number;
-}) => React.ReactNode;
-
-let setup: Awaited<ReturnType<typeof testRender>> | undefined;
-
-function seedCalendar(): void {
-  const persistence = new MemoryPluginPersistence();
-  const now = Date.now();
-  persistence.seedResource("calendar", "global", [
-    {
-      id: "a",
-      date: new Date(now + 3_600_000).toISOString(),
-      time: "23:00",
-      country: "US",
-      event: "CPI m/m",
-      impact: "high",
-      actual: null,
-      forecast: "0.3%",
-      prior: "0.2%",
-    },
-    {
-      id: "b",
-      date: new Date(now - 90_000_000).toISOString(),
-      time: "14:00",
-      country: "FR",
-      event: "Retail Sales",
-      impact: "low",
-      actual: "1.1%",
-      forecast: "0.9%",
-      prior: "0.8%",
-    },
-  ], { sourceKey: "gloomberb-cloud", schemaVersion: 1 });
-  attachEconCalendarPersistence(persistence);
-}
-
-beforeEach(() => {
-  setSystemTime(new Date("2026-08-21T12:00:00.000Z"));
-});
-
-afterEach(async () => {
-  setSystemTime();
-  if (setup) {
-    await act(async () => setup?.renderer.destroy());
-    setup = undefined;
-  }
-  resetEconCalendarPersistence();
-});
-
-async function renderPane(width: number) {
-  const state = createInitialState(createDefaultConfig("/tmp/gloomberb-econ-test"));
-  setup = await testRender(
-    <TestPaneProvider state={state} paneId="econ-calendar" runtime={{} as unknown as PluginRuntimeAccess} pluginId="econ">
-      <PaneFooterProvider>
-        {() => (
-          <EconPane paneId="econ-calendar" paneType="econ-calendar" focused width={width} height={24} />
-        )}
-      </PaneFooterProvider>
-    </TestPaneProvider>,
-    { width, height: 24 },
-  );
-  await act(async () => {
-    for (let index = 0; index < 6; index += 1) {
-      await Promise.resolve();
-      await setup!.renderOnce();
-    }
-  });
-  return setup.captureCharFrame();
-}
-
-describe("EconCalendarPane", () => {
-  // The column math has to leave room for gaps, padding, and the scrollbar
-  // lane; one column short silently clipped the last value of every row.
-  test("fits the last column instead of clipping released values", async () => {
-    seedCalendar();
-    const frame = await renderPane(110);
-
-    expect(frame).toContain("PRIOR");
-    expect(frame).toContain("0.2%");
-    expect(frame).toContain("0.8%");
-  });
-
-  test("separates days so a row's date is never ambiguous", async () => {
-    seedCalendar();
-    const frame = await renderPane(110);
-
-    expect(frame).toContain("TODAY");
-    expect(frame).toContain("YESTERDAY");
-    expect(frame).toContain("NOW");
-  });
-
-  // The payload's `time` is the UTC clock; rows group by local day. The test
-  // runs in whatever zone the process has, so it places the release on the far
-  // side of local midnight from its UTC day: 00:30 tomorrow east of UTC, 23:30
-  // today west of it. Changing process.env.TZ here would leak into later files.
-  test("shows a release at its local time under its local day", async () => {
-    const now = new Date();
-    const eastOfUtc = now.getTimezoneOffset() <= 0;
-    const at = eastOfUtc
-      ? new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 30)
-      : new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 30);
-    const iso = at.toISOString();
-    const utcClock = iso.slice(11, 16);
-    const localClock = `${String(at.getHours()).padStart(2, "0")}:${String(at.getMinutes()).padStart(2, "0")}`;
-    const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-    const separator = `${eastOfUtc ? "TOMORROW" : "TODAY"} · ${days[at.getDay()]} ${months[at.getMonth()]} ${at.getDate()}`;
-
-    const persistence = new MemoryPluginPersistence();
-    persistence.seedResource("calendar", "global", [{
-      id: "au",
-      date: iso,
-      time: utcClock,
-      country: "AU",
-      event: "Flash Manufacturing PMI",
-      impact: "medium",
-      actual: null,
-      forecast: null,
-      prior: "52.0",
-    }], { sourceKey: "gloomberb-cloud", schemaVersion: 1 });
-    attachEconCalendarPersistence(persistence);
-    const frame = await renderPane(110);
-
-    expect(frame).toContain(separator);
-    expect(frame).toContain(localClock);
-    if (utcClock !== localClock) expect(frame).not.toContain(utcClock);
-  });
-});

package/src/plugins/builtin/econ-statistics/client.test.ts

@@ -1,122 +0,0 @@
-import { afterEach, expect, spyOn, test } from "bun:test";
-import { MemoryPluginPersistence } from "../../../test-support/plugin-persistence";
-import { statsCache } from "./cache";
-import { createStatSeriesLoader, getCachedStatsBundle, loadStatsBundle } from "./client";
-import { projectStatsHeadlessBundle } from "./headless";
-import { findStat } from "./stats";
-
-const cpi = findStat("cpi-yoy");
-const unemployment = findStat("unemployment");
-const now = Date.parse("2026-02-20T12:00:00Z");
-let clock: ReturnType<typeof spyOn> | undefined;
-afterEach(() => { clock?.mockRestore(); statsCache.reset(); });
-
-function observations(revised = false) {
-  return Array.from({ length: 26 }, (_, index) => ({
-    date: new Date(Date.UTC(2023, 11 + index, 1)).toISOString().slice(0, 10),
-    value: index === 25 ? 110 : revised && index === 13 ? 105 : 100,
-  }));
-}
-
-function rows(bundle: Awaited<ReturnType<typeof loadStatsBundle>>) {
-  return projectStatsHeadlessBundle(bundle, "ALL", cpi.id).sections.flatMap((section) => section.rows ?? []);
-}
-
-test("explicit refresh retrieves a same-period revision while normal loads retain source time", async () => {
-  let time = now;
-  clock = spyOn(Date, "now").mockImplementation(() => time);
-  statsCache.attach(new MemoryPluginPersistence());
-  let revised = false;
-  let calls = 0;
-  const loader = createStatSeriesLoader({ getCloudFredSeries: async (seriesId) => {
-    calls += 1;
-    return { seriesId, observations: observations(revised) };
-  } });
-  const initial = await loadStatsBundle({ loader, stats: [cpi] });
-  expect(rows(initial)[0]).toMatchObject({ latest: 10.000000000000009, asOf: "2026-01-01", fetchedAt: now, stale: false });
-  revised = true;
-  time += 60_000;
-  const cached = await loadStatsBundle({ loader, stats: [cpi] });
-  expect(calls).toBe(1);
-  expect(cached.fetchedAt).toBe(now);
-  expect(getCachedStatsBundle([cpi])?.fetchedAt).toBe(now);
-  const refreshed = await loadStatsBundle({ loader, stats: [cpi], force: true });
-  expect(calls).toBe(2);
-  expect(rows(refreshed)[0]!.latest).toBeCloseTo(4.7619047619);
-  expect(rows(refreshed)[0]).toMatchObject({ asOf: "2026-01-01", fetchedAt: time, stale: false });
-  expect(refreshed.fetchedAtComplete).toBe(true);
-  expect(getCachedStatsBundle([cpi])?.fetchedAt).toBe(time);
-});
-
-test("failed forced refresh keeps cached CPI, independently updates unemployment, and remains stale until recovery", async () => {
-  let time = now;
-  clock = spyOn(Date, "now").mockImplementation(() => time);
-  statsCache.attach(new MemoryPluginPersistence());
-  let fail = false;
-  let calls = 0;
-  const loader = createStatSeriesLoader({ getCloudFredSeries: async (seriesId) => {
-    calls += 1;
-    if (seriesId === cpi.seriesId && fail) throw new Error("Controlled CPI failure");
-    return { seriesId, observations: observations(true).map((entry) => ({
-      ...entry, value: seriesId === cpi.seriesId ? entry.value : fail ? 4.6 : 4.2,
-    })) };
-  } });
-  await loadStatsBundle({ loader, stats: [cpi, unemployment] });
-  time += 60_000;
-  fail = true;
-  const failed = await loadStatsBundle({ loader, stats: [cpi, unemployment], force: true });
-  expect(failed.errors).toEqual(["CPIAUCNS: Controlled CPI failure"]);
-  expect(failed.fetchedAt).toBe(now);
-  expect(failed.fetchedAtComplete).toBe(true);
-  expect(rows(failed).find((row) => row.id === cpi.id)).toMatchObject({ fetchedAt: now, stale: true, cacheSource: "stale-fallback", refreshError: "Controlled CPI failure" });
-  expect(rows(failed).find((row) => row.id === unemployment.id)).toMatchObject({ latest: 4.6, fetchedAt: time, stale: false });
-  const cached = await loadStatsBundle({ loader, stats: [cpi, unemployment] });
-  expect(calls).toBe(4);
-  expect(cached.errors).toEqual(failed.errors);
-  expect(getCachedStatsBundle([cpi, unemployment])?.errors).toEqual(failed.errors);
-  expect(rows(cached).find((row) => row.id === cpi.id)?.stale).toBe(true);
-  fail = false;
-  const recovered = await loadStatsBundle({ loader, stats: [cpi, unemployment], force: true });
-  expect(recovered.errors).toEqual([]);
-  expect(rows(recovered).every((row) => row.stale === false)).toBe(true);
-});
-
-test("a cold failed series does not remove an independent series", async () => {
-  const bundle = await loadStatsBundle({ stats: [cpi, unemployment], loader: async (def) => {
-    if (def === cpi) throw new Error("Controlled cold failure");
-    return observations().map((entry) => ({ ...entry, value: 4.6 }));
-  } });
-  expect(bundle.builds.map(({ stat }) => stat.id)).toEqual([unemployment.id]);
-  expect(bundle.errors).toEqual(["CPIAUCNS: Controlled cold failure"]);
-  expect(bundle.fetchedAt).toBeNull();
-  expect(bundle.fetchedAtComplete).toBe(false);
-});
-
-test("mixed known and unprovenanced observations retain explicit partial retrieval coverage", async () => {
-  clock = spyOn(Date, "now").mockReturnValue(now);
-  const bundle = await loadStatsBundle({ stats: [cpi, unemployment], loader: async (def) => def === cpi
-    ? { observations: observations(), fetchedAt: now - 1000, stale: false, source: "cache" }
-    : observations().map((entry) => ({ ...entry, value: 4.2 })) });
-  const report = projectStatsHeadlessBundle(bundle, "ALL", cpi.id);
-  expect(report.metadata).toMatchObject({ fetchedAt: now - 1000, fetchedAtComplete: false });
-  expect(rows(bundle).find((row) => row.id === unemployment.id)).toMatchObject({ fetchedAt: null, cacheStale: null, stale: null });
-  statsCache.hydrate([[cpi.seriesId, observations()]]);
-  const hydrated = await loadStatsBundle({ stats: [cpi] });
-  expect(hydrated.fetchedAt).toBeNull();
-  expect(hydrated.fetchedAtComplete).toBe(false);
-  expect(rows(hydrated)[0]).toMatchObject({ fetchedAt: null, cacheStale: null, stale: null, cacheSource: "hydrated" });
-});
-
-test("2s10s never runs ahead of the 2Y and 10Y rows it is computed from", async () => {
-  const days = (last: string, value: number) => ["2026-09-17", "2026-09-18", "2026-09-21", "2026-09-22"]
-    .filter((date) => date <= last).map((date) => ({ date, value }));
-  const series: Record<string, Array<{ date: string; value: number }>> = {
-    DGS10: days("2026-09-21", 4.96), DGS2: days("2026-09-21", 4.76), T10Y2Y: days("2026-09-22", 0.25),
-  };
-  const stats = [findStat("ten-year"), findStat("two-year"), findStat("curve-spread")];
-  const bundle = await loadStatsBundle({ loader: async (def) => series[def.seriesId]!, stats });
-  expect(bundle.builds.map((build) => build.points.at(-1)?.date)).toEqual(["2026-09-21", "2026-09-21", "2026-09-21"]);
-  // Alone, the spread keeps its newest print.
-  const alone = await loadStatsBundle({ loader: async (def) => series[def.seriesId]!, stats: [findStat("curve-spread")] });
-  expect(alone.builds[0]!.points.at(-1)?.date).toBe("2026-09-22");
-});

package/src/plugins/builtin/econ-statistics/headless.test.ts

@@ -1,54 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { createTestDataProvider } from "../../../test-support/data-provider";
-import { createDefaultConfig } from "../../../types/config";
-import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
-import { statsCache } from "./cache";
-import { econStatisticsHeadless } from "./headless";
-
-beforeEach(() => statsCache.reset());
-afterEach(() => statsCache.reset());
-
-function monthlyCpi() {
-  return Array.from({ length: 25 }, (_, index) => {
-    const year = 2024 + Math.floor(index / 12);
-    const month = (index % 12) + 1;
-    return {
-      date: `${year}-${String(month).padStart(2, "0")}-01`,
-      value: 300 + index,
-    };
-  });
-}
-
-const args: HeadlessPaneLoadArgs = {
-  rawArgument: "cpi",
-  argument: "cpi",
-  symbols: [],
-  options: { range: "5Y" },
-};
-
-describe("economic statistics headless model", () => {
-  test("loads through the injected cloud client and produces category sections", async () => {
-    const requested: string[] = [];
-    const apiClient = {
-      getCloudFredSeries: async (seriesId: string) => {
-        requested.push(seriesId);
-        return { seriesId, observations: monthlyCpi() };
-      },
-    } as unknown as HeadlessPaneContext["apiClient"];
-    const context: HeadlessPaneContext = {
-      marketData: createTestDataProvider(),
-      apiClient,
-      config: createDefaultConfig("/tmp/gloomberb-headless-econ"),
-      signal: new AbortController().signal,
-    };
-
-    const result = await econStatisticsHeadless.load(args, context);
-
-    expect(requested).toEqual(["CPIAUCNS"]);
-    expect(result.sections.map(({ title }) => title)).toEqual(["Inflation", "CPI"]);
-    expect(result.sections[0]).toMatchObject({
-      rows: [{ id: "cpi-yoy", indicator: "CPI y/y" }],
-    });
-    expect(result.metadata).toMatchObject({ range: "5Y", selected: "cpi-yoy" });
-  });
-});

package/src/plugins/builtin/econ-statistics/pane.test.tsx

@@ -1,69 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { act } from "react";
-import { PaneFooterProvider } from "../../../components/layout/pane/footer";
-import { emitKeypress, testRender } from "../../../renderers/opentui/test-utils";
-import { createInitialState } from "../../../state/app/context";
-import { createTestPaneConfig, TestPaneProvider } from "../../../test-support/pane";
-import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import { Box } from "../../../ui";
-import { statsCache } from "./cache";
-import { EconStatisticsPane } from "./pane";
-import { STATS } from "./stats";
-
-let setup: Awaited<ReturnType<typeof testRender>> | undefined;
-afterEach(async () => {
-  if (setup) await act(async () => { setup!.renderer.destroy(); });
-  setup = undefined;
-  statsCache.reset();
-});
-
-test.each([
-  { width: 48, partial: false },
-  { width: 120, partial: false },
-  { width: 48, partial: true },
-])("selected source and basis remain reachable at $width columns with partial=$partial", async ({ width, partial }) => {
-  // Hydrate the actual catalog loader without contacting a provider. Quarter and
-  // month series need enough calendar observations for their real transforms.
-  statsCache.hydrate(STATS.map((stat) => [stat.seriesId, partial && stat.seriesId === "CPIAUCNS" ? [] : Array.from({ length: 25 }, (_, index) => ({
-    date: new Date(Date.UTC(2019, index * (stat.transform === "qoq-annualized" ? 3 : 1), 1)).toISOString().slice(0, 10),
-    value: 100 + index,
-  }))] as const));
-  const state = createInitialState(createTestPaneConfig("/tmp/gloom-ecst-scroll", {
-    instanceId: "ecst:test", paneId: "econ-statistics", settings: { stat: "curve-spread" },
-  }));
-  await act(async () => {
-    setup = await testRender(
-      <TestPaneProvider state={state} paneId="ecst:test" pluginId="market-overview" runtime={createTestPluginRuntime()}>
-        <PaneFooterProvider>{() => <Box width={width} height={36}>
-          <EconStatisticsPane paneId="ecst:test" paneType="econ-statistics" width={width} height={36} focused />
-        </Box>}</PaneFooterProvider>
-      </TestPaneProvider>,
-      { width, height: 36 },
-    );
-  });
-  for (let frame = 0; frame < 4; frame++) await act(async () => {
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    await setup!.renderOnce();
-  });
-  expect(setup!.captureCharFrame()).toContain("2s10s");
-  await act(async () => {
-    for (let tick = 0; tick < 8; tick++) await setup!.mockMouse.scroll(width - 1, 34, "down");
-    await setup!.renderOnce();
-  });
-  const scrolled = setup!.captureCharFrame();
-  expect(scrolled).toContain("FRED T10Y2Y");
-  expect(scrolled).toContain("10Y minus 2Y");
-  expect(scrolled).toMatch(/High\s+124\.00%\s+2021-01-01/);
-  expect(scrolled).toMatch(/Low\s+100\.00%\s+2019-01-01/);
-  expect(scrolled).toContain("20Y");
-  expect(scrolled).toContain("All");
-  if (partial) {
-    expect(scrolled).not.toContain("CPIAUCNS");
-    await emitKeypress(setup!, { name: "!", sequence: "!", shift: true }, { trackPropagation: true });
-    await act(async () => { await setup!.renderOnce(); });
-    expect(setup!.captureCharFrame()).toContain("CPIAUCNS");
-    await emitKeypress(setup!, { name: "escape" }, { trackPropagation: true });
-    await act(async () => { await setup!.renderOnce(); });
-    expect(setup!.captureCharFrame()).toContain("FRED T10Y2Y");
-  }
-});