gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/portfolio-list/use-throttled-ticker-order.test.tsx

@@ -1,76 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { act, useState } from "react";
-import { testRender } from "../../../renderers/opentui/test-utils";
-import { useThrottledTickerOrder } from "./use-throttled-ticker-order";
-
-const TEST_THROTTLE_MS = 80;
-let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
-let updateCandidates: ((symbols: string[]) => void) | null = null;
-let updateResetKey: ((key: string) => void) | null = null;
-let latestOrder: string[] = [];
-
-function ThrottledOrderHarness() {
-  const [candidates, setCandidates] = useState(["AAPL", "MSFT", "NVDA"]);
-  const [resetKey, setResetKey] = useState("price:desc");
-  latestOrder = useThrottledTickerOrder(candidates, resetKey, TEST_THROTTLE_MS);
-  updateCandidates = setCandidates;
-  updateResetKey = setResetKey;
-  return <text>{latestOrder.join(",")}</text>;
-}
-
-afterEach(async () => {
-  if (testSetup) {
-    await act(async () => testSetup!.renderer.destroy());
-    testSetup = undefined;
-  }
-  updateCandidates = null;
-  updateResetKey = null;
-  latestOrder = [];
-});
-
-describe("useThrottledTickerOrder", () => {
-  test("coalesces rapid market-driven reorders into the latest trailing order", async () => {
-    testSetup = await testRender(<ThrottledOrderHarness />, { width: 32, height: 1 });
-    await act(async () => testSetup!.renderOnce());
-
-    await act(async () => {
-      updateCandidates?.(["MSFT", "AAPL", "NVDA"]);
-      await Promise.resolve();
-    });
-    await act(async () => testSetup!.renderOnce());
-    expect(latestOrder).toEqual(["MSFT", "AAPL", "NVDA"]);
-
-    await act(async () => {
-      updateCandidates?.(["NVDA", "MSFT", "AAPL"]);
-      await Promise.resolve();
-    });
-    await act(async () => testSetup!.renderOnce());
-    expect(latestOrder).toEqual(["MSFT", "AAPL", "NVDA"]);
-
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, TEST_THROTTLE_MS + 20));
-    });
-    await act(async () => testSetup!.renderOnce());
-    expect(latestOrder).toEqual(["NVDA", "MSFT", "AAPL"]);
-  });
-
-  test("applies user sort changes and ticker membership changes immediately", async () => {
-    testSetup = await testRender(<ThrottledOrderHarness />, { width: 32, height: 1 });
-    await act(async () => testSetup!.renderOnce());
-
-    await act(async () => {
-      updateCandidates?.(["NVDA", "MSFT", "AAPL"]);
-      updateResetKey?.("price:asc");
-      await Promise.resolve();
-    });
-    await act(async () => testSetup!.renderOnce());
-    expect(latestOrder).toEqual(["NVDA", "MSFT", "AAPL"]);
-
-    await act(async () => {
-      updateCandidates?.(["AMD", "NVDA", "MSFT", "AAPL"]);
-      await Promise.resolve();
-    });
-    await act(async () => testSetup!.renderOnce());
-    expect(latestOrder).toEqual(["AMD", "NVDA", "MSFT", "AAPL"]);
-  });
-});

package/src/plugins/builtin/rate-path/model.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ApiRequestError } from "../../../api-client/errors";
-import type { RateMeeting, RatePathPayload } from "../../../api-client/rates";
-import { fetchRatePath, validateRatePath } from "./client";
-import { meetingProbability, ratePathCurves } from "./model";
-
-const metric = { value: 4, asOf: "2026-09-21", percentile: 50, samples: 250, source: "fred" as const };
-const meeting: RateMeeting = { date: "2026-10-28", impliedRate: 3.875, targetMidpoint: 3.875, changeBps: -12.5, percentile: 25, samples: 220, asOf: "2026-09-22T14:00:00Z", probabilities: [{ targetMidpoint: 3.75, probability: 0.5 }, { targetMidpoint: 4, probability: 0.5 }], method: "following-month", reason: null };
-function payload(): RatePathPayload {
-  return { asOf: meeting.asOf, fetchedAt: "2026-09-22T14:01:00Z", stale: false, status: "partial", current: { effr: metric, targetLower: metric, targetUpper: metric }, meetings: [meeting, { ...meeting, date: "2026-12-09", impliedRate: null, probabilities: [], reason: "Missing contract" }], fedFunds: [], sofr: [], ghosts: [{ label: "1W", requestedDate: "2026-09-15", asOf: "2026-09-15", points: [{ date: meeting.date, impliedRate: 4.1 }, { date: "2026-12-09", impliedRate: null }] }], dotPlot: { asOf: "2026-09-16", sourceUrl: "https://www.federalreserve.gov", points: [] }, schedule: { sourceUrl: "https://www.federalreserve.gov", verifiedAt: "2026-09-22", through: "2027-12-08" }, probabilityAssumption: "Two outcomes", slope: { valueBps: null, percentile: null, samples: 0, asOf: null }, gaps: ["Missing contract"] };
-}
-
-describe("rate-path integration boundary", () => {
-  test("preserves incomplete meeting nodes and historical dates without filling a gap", () => {
-    const result = validateRatePath(payload());
-    const curves = ratePathCurves(result);
-    expect(curves[0]!.points[1]!.value).toBeNull();
-    expect(curves[1]!.asOf).toBe("2026-09-15");
-    expect(curves[1]!.points[1]!.value).toBeNull();
-    expect(curves[0]!.points[0]!.x).toBe(Date.parse(meeting.date));
-    expect(meetingProbability(result.meetings[1]!, 4)).toBeNull();
-    expect(meetingProbability(result.meetings[0]!, 4)).toBe(0.5);
-    expect(meetingProbability(result.meetings[0]!, 4.25)).toBe(0);
-  });
-
-  test("charts only near ghosts and labels the SEP dot as a date on the meeting axis", () => {
-    const data = payload();
-    data.meetings.push({ ...meeting, date: "2027-01-27", impliedRate: 4.3 });
-    data.ghosts.push({ label: "1Y", requestedDate: "2025-09-22", asOf: "2025-09-22", points: [{ date: meeting.date, impliedRate: 2.9 }] });
-    data.dotPlot.points = [{ year: 2026, rate: 4.1 }, { year: 2028, rate: 3.9 }, { year: "longer-run", rate: 3.2 }];
-    const curves = ratePathCurves(validateRatePath(data));
-    expect(curves.map((entry) => entry.id)).toEqual(["implied", "1W", "targetLower", "targetUpper", "sep"]);
-    expect(curves.at(-1)!.points).toEqual([{ id: "sep-2026", label: "12-31", x: Date.parse("2026-12-31"), value: 4.1, asOf: "2026-09-16" }]);
-  });
-
-  test("rejects broken endpoint probabilities and impossible decision dates", () => {
-    const invalid = payload();
-    invalid.meetings = [{ ...meeting, probabilities: [{ targetMidpoint: 4, probability: 0.4 }] }];
-    expect(() => validateRatePath(invalid)).toThrow("invalid meeting probabilities");
-    invalid.meetings = [{ ...meeting, date: "2026-02-30" }];
-    expect(() => validateRatePath(invalid)).toThrow("invalid meeting probabilities");
-  });
-
-  test("absent endpoint reports unsupported deployment while access errors retain their status", async () => {
-    await expect(fetchRatePath({ getCloudRatePath: async () => { throw new ApiRequestError("Not found", 404); } })).rejects.toThrow("not available on this Gloom Cloud server yet");
-    const denied = new ApiRequestError("Forbidden", 403);
-    try { await fetchRatePath({ getCloudRatePath: async () => { throw denied; } }); throw new Error("Expected access rejection"); }
-    catch (error) { expect(error).toBe(denied); }
-  });
-});

package/src/plugins/builtin/realized-vol/chart-model.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { coneChartSeries, realizedChartSeries } from "./chart-model";
-
-describe("realized-vol chart inputs", () => {
-  test("preserves rejected windows as gaps and dates current IV exactly once", () => {
-    const dates = [1, 2, 3].map((day) => new Date(Date.UTC(2026, 8, day)));
-    const ivDate = new Date("2026-09-04T14:30:00Z");
-    const result = realizedChartSeries({ history: [], rolling: dates.map((date, i) => ({ date, values: { 30: i === 1 ? null : 0.2 } })),
-      windows: [30], currency: "USD", iv: { value: 0.3, date: ivDate, label: "ATM 30d" } }, ["#123456"]);
-    expect(result[0]!.points.map((point) => point.value)).toEqual([20, null, 20]);
-    expect(result[1]!.points).toEqual([{ date: ivDate, observedAt: ivDate, value: 30 }]);
-    expect(result[1]!.style).toBe("points");
-    expect(result[0]!.panelId).not.toBe(result[2]!.panelId);
-  });
-
-  test("cone spacing follows session windows and unavailable statistics stay gaps", () => {
-    const rows = [10, 30, 260].map((window) => ({ window, min: 0.1, max: 0.4, mean: 0.2,
-      current: window === 30 ? null : 0.25, median: 0.2, percentile: 60, sampleSize: 200 }));
-    const series = coneChartSeries(rows, ["a", "b", "c", "d"]);
-    expect(series[3]!.points.map((point) => point.value)).toEqual([25, null, 25]);
-    expect(series[0]!.timeBasis).toBeUndefined();
-    expect(series[0]!.points[2]!.date.getTime() - series[0]!.points[1]!.date.getTime()).toBe(230 * 86_400_000);
-  });
-});

package/src/plugins/builtin/realized-vol/client.test.ts

@@ -1,193 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { MarketDataCoordinator } from "../../../market-data/coordinator";
-import type { ChartRequest } from "../../../market-data/request-types";
-import type { QueryEntry } from "../../../market-data/result-types";
-import type { DataProvider } from "../../../types/data-provider";
-import type { OptionsChain, PricePoint } from "../../../types/financials";
-import { DEFAULT_OPTION_CALC_DRAFT, daysToExpiryFrom, valueOption } from "../options-calculator/model";
-import { createSurfaceDependencies } from "../vol-surface/client";
-import { createRealizedVolatilityDependencies, loadCurrentAtmIv, loadRealizedVolatilityHistory, refreshCurrentAtmIv } from "./client";
-
-const now = Date.UTC(2026, 8, 22, 14);
-const points: PricePoint[] = [{ date: new Date(now - 86400000), close: 100 }, { date: new Date(now), close: 101 }];
-function ready<T>(data: T): QueryEntry<T> {
-  return { phase: "ready", data, lastGoodData: data, source: "test", fetchedAt: now - 1000,
-    staleAt: now + 60000, error: null, attempts: [] };
-}
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((done) => { resolve = done; });
-  return { promise, resolve };
-}
-
-describe("daily realized-volatility history", () => {
-  test("requests explicit daily 5Y warmup with scoped identity and retains cached partial data", async () => {
-    const instrument = { symbol: "AAPL", exchange: "NASDAQ", brokerId: "ibkr", brokerInstanceId: "account" };
-    let seen: ChartRequest | undefined;
-    let forced = false;
-    const result = await loadRealizedVolatilityHistory({ instrument, forceRefresh: true }, {
-      now: () => now, loadChart: async (request, options) => {
-        seen = request; forced = !!options?.forceRefresh;
-        return { ...ready(points), data: null, phase: "error", error: { reasonCode: "UPSTREAM_ERROR", message: "refresh offline" } };
-      },
-    });
-    expect(seen).toEqual({ instrument, bufferRange: "5Y", granularity: "resolution", resolution: "1d" });
-    expect(forced).toBe(true);
-    expect(result.history).toEqual(points);
-    expect(result.source).toBe("test");
-    expect(result.stale).toBe(true);
-    expect(result.error).toBe("refresh offline");
-    expect(result.fetchedAt).toBe(now - 1000);
-  });
-
-  test("daily headless adapter uses coordinator refresh/cache context and preserves the full buffer", async () => {
-    const requests: unknown[][] = [];
-    const provider = { id: "test", getPriceHistoryForResolution: async (...args: unknown[]) => { requests.push(args); return points; },
-      getPriceHistory: async () => { throw new Error("range fallback must not replace daily history"); },
-    } as unknown as DataProvider;
-    const dependencies = createRealizedVolatilityDependencies(provider);
-    const instrument = { symbol: "AAPL", exchange: "NASDAQ", brokerId: "ibkr", brokerInstanceId: "account" };
-    await loadRealizedVolatilityHistory({ instrument, forceRefresh: true }, dependencies);
-    expect(requests).toHaveLength(1);
-    expect(requests[0]!.slice(0, 4)).toEqual(["AAPL", "NASDAQ", "5Y", "1d"]);
-    expect(requests[0]![4]).toMatchObject({ brokerId: "ibkr", brokerInstanceId: "account", cacheMode: "refresh" });
-    const cached = await loadRealizedVolatilityHistory({ instrument }, dependencies);
-    expect(cached.history).toHaveLength(2);
-    expect(requests).toHaveLength(1);
-  });
-
-  test("distinguishes hard failure, empty success and expired cached data", async () => {
-    const request = { instrument: { symbol: "AAPL" } };
-    const failed = await loadRealizedVolatilityHistory(request, { loadChart: async () => { throw new Error("history offline"); } });
-    expect(failed.error).toBe("history offline");
-    expect(failed.history).toHaveLength(0);
-    const empty = await loadRealizedVolatilityHistory(request, { loadChart: async () => ready([]) });
-    expect(empty.error).toBeTruthy();
-    expect(empty.history).toHaveLength(0);
-    const stale = await loadRealizedVolatilityHistory(request, { now: () => now,
-      loadChart: async () => ({ ...ready(points), staleAt: now - 1 }) });
-    expect(stale.stale).toBe(true);
-    expect(stale.history).toEqual(points);
-  });
-
-  test("consumer cancellation rejects promptly without poisoning a shared daily request", async () => {
-    const gate = deferred<PricePoint[]>();
-    let calls = 0;
-    const provider = { id: "test", getPriceHistoryForResolution: async () => { calls += 1; return gate.promise; } } as unknown as DataProvider;
-    const coordinator = new MarketDataCoordinator(provider);
-    const dependencies = { loadChart: coordinator.loadChart.bind(coordinator) };
-    const controller = new AbortController();
-    const cancelled = loadRealizedVolatilityHistory({ instrument: { symbol: "AAPL" }, signal: controller.signal }, dependencies);
-    const retained = loadRealizedVolatilityHistory({ instrument: { symbol: "AAPL" } }, dependencies);
-    controller.abort();
-    await expect(cancelled).rejects.toMatchObject({ name: "AbortError" });
-    gate.resolve(points);
-    expect((await retained).history).toHaveLength(2);
-    expect(calls).toBe(1);
-    await expect(loadRealizedVolatilityHistory({ instrument: { symbol: "AAPL" }, signal: controller.signal }, dependencies))
-      .rejects.toMatchObject({ name: "AbortError" });
-    expect(calls).toBe(1);
-  });
-});
-
-describe("independent current-IV loading", () => {
-  test("loads shared surface quotes and recomputes ATM IV while retaining the actual source date", async () => {
-    const expiration = now / 1000 + 31 * 86400;
-    const daysToExpiry = daysToExpiryFrom(expiration, now);
-    const contract = (strike: number, side: "call" | "put") => {
-      const price = valueOption({ ...DEFAULT_OPTION_CALC_DRAFT, side, spot: 100, strike,
-        daysToExpiry, rate: 0.04, dividendYield: 0.01, volatility: 0.3 }).price;
-      return { contractSymbol: `${side}-${strike}`, strike, expiration, currency: "USD", bid: price * 0.99,
-        ask: price * 1.01, lastPrice: price, openInterest: 100, volume: 1, lastTradeDate: now / 1000,
-        impliedVolatility: 0.5, change: 0, percentChange: 0, inTheMoney: false };
-    };
-    const strikes = [80, 90, 95, 100, 105, 110, 120];
-    const chain: OptionsChain = { underlyingSymbol: "AAPL", expirationDates: [expiration],
-      calls: strikes.map((strike) => contract(strike, "call")), puts: strikes.map((strike) => contract(strike, "put")),
-      asOf: "2026-09-22T13:45:00Z", providerId: "test" };
-    const provider = { id: "test", getOptionsChain: async () => chain } as unknown as DataProvider;
-    const dependencies = createSurfaceDependencies(provider, { getCloudYieldCurve: async () => [
-      { maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: "2026-09-21" },
-    ] });
-    const result = await loadCurrentAtmIv({ instrument: { symbol: "AAPL" }, spot: 100,
-      spotAsOf: "2026-09-22T13:59:00Z" }, { ...dependencies, now: () => now });
-    expect(result.reference!.value).toBeCloseTo(0.3, 4);
-    expect(result.reference!.daysToExpiry).toBeCloseTo(daysToExpiry, 12);
-    expect(result.reference!.expiration).toBe(expiration);
-    expect(result.reference!.date.toISOString()).toBe("2026-09-22T13:45:00.000Z");
-    expect(result.reference!.ivSource).toBe("recomputed");
-    expect(result.error).toBeNull();
-  });
-
-  test("the in-session refresh refetches only the reference's own expiry at the new spot", async () => {
-    const near = now / 1000 + 31 * 86400, far = now / 1000 + 200 * 86400;
-    const chain = (expiration: number, volatility: number): OptionsChain => {
-      const days = daysToExpiryFrom(expiration, now);
-      const contract = (strike: number, side: "call" | "put") => {
-        const price = valueOption({ ...DEFAULT_OPTION_CALC_DRAFT, side, spot: 100, strike,
-          daysToExpiry: days, rate: 0.04, dividendYield: 0.01, volatility }).price;
-        return { contractSymbol: `${expiration}-${side}-${strike}`, strike, expiration, currency: "USD", bid: price * 0.99,
-          ask: price * 1.01, lastPrice: price, openInterest: 100, volume: 1, lastTradeDate: now / 1000,
-          impliedVolatility: volatility, change: 0, percentChange: 0, inTheMoney: false };
-      };
-      const strikes = [80, 90, 95, 100, 105, 110, 120];
-      return { underlyingSymbol: "AAPL", expirationDates: [near, far], calls: strikes.map((strike) => contract(strike, "call")),
-        puts: strikes.map((strike) => contract(strike, "put")), asOf: new Date(now).toISOString(), providerId: "test" };
-    };
-    let volatility = 0.3;
-    const requests: Array<{ expiration?: number; force: boolean }> = [];
-    const dependencies = { now: () => now, loadYieldCurve: async () => [{ maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: "2026-09-21" }],
-      loadOptions: async (request: { expirationDate?: number }, options?: { forceRefresh?: boolean }) => {
-        requests.push({ expiration: request.expirationDate, force: !!options?.forceRefresh });
-        return ready(chain(request.expirationDate ?? near, volatility));
-      } };
-    const loaded = await loadCurrentAtmIv({ instrument: { symbol: "AAPL" }, spot: 100 }, dependencies);
-    expect(loaded.reference!.expiration).toBe(near);
-    requests.length = 0;
-    volatility = 0.36;
-    const refreshed = await refreshCurrentAtmIv({ instrument: { symbol: "AAPL" }, spot: 100 }, loaded, dependencies);
-    expect(requests).toEqual([{ expiration: undefined, force: false }, { expiration: near, force: true }]);
-    expect(refreshed.reference!.value).toBeCloseTo(0.36, 3);
-    expect(refreshed.warnings).toBe(loaded.warnings);
-    // A slice that cannot price an ATM level keeps the dated reference already shown.
-    const failed = await refreshCurrentAtmIv({ instrument: { symbol: "AAPL" }, spot: 100 }, loaded,
-      { ...dependencies, loadOptions: async () => { throw new Error("offline"); } });
-    expect(failed).toBe(loaded);
-  });
-
-  test("option failures and missing spot leave daily history independently available", async () => {
-    const request = { instrument: { symbol: "AAPL" } };
-    let calls = 0;
-    const dependencies = { now: () => now, loadYieldCurve: async () => [],
-      loadOptions: async () => { calls += 1; throw new Error("options unavailable"); } };
-    const [history, options] = await Promise.all([
-      loadRealizedVolatilityHistory(request, { loadChart: async () => ready(points) }),
-      loadCurrentAtmIv({ ...request, spot: 100 }, dependencies),
-    ]);
-    expect(history.history).toHaveLength(2);
-    expect(history.error).toBeNull();
-    expect(options.reference).toBeNull();
-    expect(options.error).toContain("options unavailable");
-    const missingSpot = await loadCurrentAtmIv({ ...request, spot: NaN }, dependencies);
-    expect(missingSpot.reference).toBeNull();
-    expect(calls).toBe(1);
-  });
-
-  test("an underlying with no option chain has no IV line and no error", async () => {
-    const empty: OptionsChain = { underlyingSymbol: "7203.T", expirationDates: [], calls: [], puts: [] };
-    const result = await loadCurrentAtmIv({ instrument: { symbol: "7203.T" }, spot: 100 }, { now: () => now, loadYieldCurve: async () => [],
-      loadOptions: async () => ({ ...ready(empty), error: { reasonCode: "NO_DATA", message: "No data available" } }) });
-    expect(result).toEqual({ reference: null, error: null, warnings: [], noOptionChain: true });
-  });
-
-  test("surface cancellation remains cancellation rather than a missing-IV result", async () => {
-    const gate = deferred<QueryEntry<OptionsChain>>();
-    const controller = new AbortController();
-    const loading = loadCurrentAtmIv({ instrument: { symbol: "AAPL" }, spot: 100, signal: controller.signal }, {
-      loadYieldCurve: async () => [], loadOptions: async () => gate.promise,
-    });
-    controller.abort();
-    await expect(loading).rejects.toMatchObject({ name: "AbortError" });
-    gate.resolve(ready({ underlyingSymbol: "AAPL", expirationDates: [], calls: [], puts: [] }));
-  });
-});

package/src/plugins/builtin/realized-vol/model.test.ts

@@ -1,155 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { PricePoint } from "../../../types/financials";
-import { realizedVolatility, REALIZED_VOLATILITY_WINDOWS } from "../shared/volatility";
-import { DEFAULT_SURFACE_SETTINGS, pendingSurfaceExpiry, type SurfaceExpiry, type SurfaceSnapshot } from "../vol-surface/model";
-import { projectCurrentAtmIv, projectRealizedVolatility } from "./model";
-
-function history(length = 1400, end = Date.UTC(2026, 8, 22)): PricePoint[] {
-  return Array.from({ length }, (_, index) => {
-    const close = 100 * Math.exp(index * 0.0001 + Math.sin(index) * 0.02);
-    return { date: new Date(end - (length - 1 - index) * 86400000), close,
-      open: close * 0.99, high: close * 1.02, low: close * 0.98 };
-  });
-}
-const now = Date.UTC(2026, 8, 22, 14);
-function expiry(days: number, overrides: Partial<SurfaceExpiry> = {}): SurfaceExpiry {
-  return { ...pendingSurfaceExpiry(now / 1000 + days * 86400, now), years: days / 365, state: "ready", atmIV: 0.3,
-    asOf: "2026-09-22T13:45:00Z", source: "test", ...overrides };
-}
-function surface(expiries: SurfaceExpiry[], overrides: Partial<SurfaceSnapshot> = {}): SurfaceSnapshot {
-  return { symbol: "AAPL", spot: 100, spotAsOf: "2026-09-22T13:59:00Z", phase: "ready",
-    settings: DEFAULT_SURFACE_SETTINGS, catalogue: expiries.map((value) => value.expiration), requested: expiries.length,
-    loaded: expiries.length, failed: 0, expiries, failures: [], warnings: [], rateAsOf: "2026-09-21", fetchedAt: now, ...overrides };
-}
-
-describe("realized-volatility projection", () => {
-  test("computes all cone windows with pre-lookback warmup before clipping selected chart series", () => {
-    const points = history();
-    const result = projectRealizedVolatility(points, { symbol: "aapl", windows: [10, 30], lookbackYears: 2 });
-    expect(result.symbol).toBe("AAPL");
-    expect(result.history).toHaveLength(730);
-    expect(result.series).toHaveLength(730);
-    expect(result.cone.map((row) => row.window)).toEqual([...REALIZED_VOLATILITY_WINDOWS]);
-    expect(Object.keys(result.series[0]!.values)).toEqual(["10", "30"]);
-    expect(result.cone.every((row) => row.sampleSize === 730)).toBe(true);
-    expect(result.warnings).toHaveLength(0);
-    for (const row of result.cone) expect(row.current).toBeCloseTo(realizedVolatility(points, row.window)!, 12);
-    expect(result.series[0]!.values[30]).toBeCloseTo(realizedVolatility(points.slice(0, 671), 30)!, 12);
-  });
-
-  test("applies estimator and leap-year cutoff, and anchors on the source's last date", () => {
-    const points = history(1200, Date.UTC(2024, 1, 29));
-    const result = projectRealizedVolatility(points, { symbol: "AAPL", estimator: "yang-zhang", windows: [30] });
-    expect(result.history[0]!.date.toISOString()).toBe("2023-03-01T00:00:00.000Z");
-    expect(result.history).toHaveLength(366);
-    expect(result.asOf!.toISOString()).toBe("2024-02-29T00:00:00.000Z");
-    expect(result.series.at(-1)!.values[30]).toBeCloseTo(realizedVolatility(points, 30, "yang-zhang")!, 12);
-  });
-
-  test("retains rejected bars as gaps and deduplicates later corrections without mutating input", () => {
-    const points = history(100);
-    const bad = { ...points[80]!, high: 1 };
-    const result = projectRealizedVolatility([...points, bad], { symbol: "AAPL", windows: [10] });
-    expect(result.history).toHaveLength(100);
-    expect(result.series[80]!.values[10]).toBeNull();
-    expect(result.series[90]!.values[10]).toBeNull();
-    expect(result.series[91]!.values[10]).toBeNumber();
-    expect(result.cone.find((row) => row.window === 30)!.current).toBeNull();
-    expect(result.warnings.some((warning) => warning.includes("inconsistent ohlc"))).toBe(true);
-    expect(points[80]!.high).toBeGreaterThan(100);
-    const corrected = projectRealizedVolatility([...points].reverse(), { symbol: "AAPL", windows: [10] });
-    expect(corrected.series.at(-1)!.values[10]).toBeCloseTo(realizedVolatility(points, 10)!, 12);
-    expect(result.warnings.some((warning) => warning.includes("complete lookback"))).toBe(true);
-  });
-
-  test("reports incomplete cone coverage after latest estimates recover from an old rejected bar", () => {
-    const points = history();
-    const baseline = projectRealizedVolatility(points, { symbol: "AAPL", lookbackYears: 2 });
-    // Inside the displayed lookback, but more than 260 observations before the latest bar.
-    const broken = points.map((point, index) => index === 750 ? { ...point, high: 1 } : point);
-    const result = projectRealizedVolatility(broken, { symbol: "AAPL", lookbackYears: 2 });
-    expect(result.history).toHaveLength(baseline.history.length);
-    expect(result.series.at(-1)!.values).toEqual(baseline.series.at(-1)!.values);
-    for (const row of result.cone) {
-      expect(row.current).toBeNumber();
-      expect(row.sampleSize).toBeLessThan(result.history.length);
-      expect(row.sampleSize).toBe(result.history.length - row.window - 1);
-    }
-    expect(baseline.warnings).toHaveLength(0);
-    expect(result.warnings).toHaveLength(1);
-    expect(result.warnings[0]).toContain("cone sample coverage");
-  });
-
-  test("does not infer chronology from a history containing invalid dates or substitute OHLC", () => {
-    const points = history(50).map(({ date, close }) => ({ date, close }));
-    const range = projectRealizedVolatility(points, { symbol: "AAPL", estimator: "parkinson" });
-    expect(range.cone.every((row) => row.current === null)).toBe(true);
-    expect(range.warnings.some((warning) => warning.includes("missing ohlc"))).toBe(true);
-    const invalid = projectRealizedVolatility([...points, { date: new Date(NaN), close: 100 }], { symbol: "AAPL" });
-    expect(invalid.history).toHaveLength(0);
-    expect(invalid.series).toHaveLength(0);
-    expect(invalid.asOf).toBeNull();
-    expect(invalid.warnings.some((warning) => warning.includes("invalid history date"))).toBe(true);
-  });
-
-  test("withholds annualized daily estimates on weekly or intraday fallback bars but retains price", () => {
-    for (const interval of [7 * 86400000, 3600000]) {
-      const points = history(100).map((point, index) => ({ ...point, date: new Date(now - (99 - index) * interval) }));
-      const result = projectRealizedVolatility(points, { symbol: "AAPL", windows: [30] });
-      expect(result.history.length).toBeGreaterThan(0);
-      expect(result.series.length).toBe(result.history.length);
-      expect(result.series.every((point) => point.values[30] === null)).toBe(true);
-      expect(result.cone.every((row) => row.current === null && row.sampleSize === 0)).toBe(true);
-      expect(result.warnings.some((warning) => warning.includes("Daily history unavailable"))).toBe(true);
-    }
-    // Corrections at exactly the same timestamp remain one daily observation.
-    const daily = history(100);
-    const corrected = projectRealizedVolatility([...daily, daily[50]!], { symbol: "AAPL", windows: [30] });
-    expect(corrected.series.at(-1)!.values[30]).toBeNumber();
-    expect(corrected.warnings.some((warning) => warning.includes("Daily history unavailable"))).toBe(false);
-  });
-});
-
-describe("current ATM IV reference", () => {
-  test("selects the listed tenor nearest 30 days and keeps only its own and surface-wide caveats", () => {
-    const selected = expiry(31, { atmIV: 0.27, warnings: ["9 butterfly arbitrage warnings"] });
-    const leaps = expiry(800, { warnings: ["SVI did not converge"] });
-    const result = projectCurrentAtmIv(surface([expiry(7), selected, expiry(60), leaps], {
-      phase: "partial", failures: [{ expiration: 100, message: "unrelated expiry offline" }],
-      warnings: ["SVI did not converge", "9 butterfly arbitrage warnings", "2 calendar arbitrage warnings"],
-    }));
-    expect(result.reference!.value).toBe(0.27);
-    expect(result.reference!.expiration).toBe(selected.expiration);
-    expect(result.reference!.daysToExpiry).toBeCloseTo(31, 12);
-    expect(result.reference!.date.toISOString()).toBe(new Date(selected.asOf!).toISOString());
-    expect(result.reference!.source).toBe("test");
-    expect(result.reference!.ivSource).toBe("recomputed");
-    expect(result.error).toBeNull();
-    expect(result.warnings).toEqual(["9 butterfly arbitrage warnings"]);
-    const offline = projectCurrentAtmIv(surface([selected], { failures: [{ expiration: null, message: "Treasury: offline" }] }));
-    expect(offline.error).toBe("Treasury: offline");
-  });
-
-  test("says when nearer expiries without usable quotes pushed the reference to a farther tenor", () => {
-    const result = projectCurrentAtmIv(surface([expiry(1), expiry(29, { atmIV: null, state: "empty" }), expiry(60, { atmIV: null, state: "error" })]));
-    expect(result.reference!.daysToExpiry).toBeCloseTo(1, 12);
-    expect(result.warnings).toContain("Expiries nearer 30 days have no usable ATM quotes; reference uses the 1d expiry");
-    expect(projectCurrentAtmIv(surface([expiry(29), expiry(60, { atmIV: null, state: "empty" })])).warnings).toEqual([]);
-  });
-
-  test("withholds stale, failed and undated observations and chooses the next eligible expiry", () => {
-    const stale = expiry(30, { stale: true });
-    const failed = expiry(29, { error: "refresh failed" });
-    const undated = expiry(31, { asOf: null });
-    const result = projectCurrentAtmIv(surface([stale, failed, undated, expiry(40)]));
-    expect(result.reference!.daysToExpiry).toBeCloseTo(40, 12);
-    expect(result.reference!.stale).toBe(false);
-    expect(result.warnings).toHaveLength(2);
-    const missing = projectCurrentAtmIv(surface([stale, failed, undated]));
-    expect(missing.reference).toBeNull();
-    expect(missing.error).toBeTruthy();
-    expect(projectCurrentAtmIv(surface([expiry(30, { atmIV: NaN })])).reference).toBeNull();
-    // With every short expiry withheld, a LEAPS was the nearest to 30 days.
-    expect(projectCurrentAtmIv(surface([stale, expiry(451)])).reference).toBeNull();
-  });
-});