gloomberb 0.15.2 → 0.15.3

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

@@ -1,243 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { OptionContract, OptionsChain } from "../../../types/financials";
-import { DEFAULT_OPTION_CALC_DRAFT, daysToExpiryFrom, valueOption } from "../options-calculator/model";
-import { optionDelta } from "../shared/volatility";
-import {
-  buildSurfaceExpiry, buildSurfaceGrid, cleanSurfaceQuotes, DEFAULT_SURFACE_SETTINGS,
-  evaluateSurfaceSmile, surfaceSheetSnapshot, surfaceTreasuryRate, windowSurfaceGrid, type SurfaceSnapshot,
-} from "./model";
-
-const now = Date.UTC(2026, 8, 22, 14);
-const expiration = Date.UTC(2026, 11, 18) / 1000;
-const curve = [{ maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: "2026-09-21" },
-  { maturity: "1Y", maturityYears: 1, yield: 4, asOf: "2026-09-21" }];
-
-function chain(expiry = expiration, volatility = 0.3, strikes = [70, 80, 90, 95, 100, 105, 110, 120, 130]): OptionsChain {
-  const contract = (strike: number, side: "call" | "put"): OptionContract => {
-    const price = valueOption({ ...DEFAULT_OPTION_CALC_DRAFT, side, spot: 100, strike,
-      daysToExpiry: daysToExpiryFrom(expiry, now), rate: 0.04, dividendYield: 0.01, volatility }).price;
-    return { contractSymbol: `${side}-${strike}-${expiry}`, strike, currency: "USD", expiration: expiry,
-      bid: price * 0.99, ask: price * 1.01, lastPrice: price * 2, impliedVolatility: 0.44,
-      openInterest: 10, volume: 2, lastTradeDate: now / 1000 - 1000,
-      change: 0, percentChange: 0, inTheMoney: side === "call" ? strike < 100 : strike > 100 };
-  };
-  return { underlyingSymbol: "AAPL", expirationDates: [expiry], calls: strikes.map((strike) => contract(strike, "call")),
-    puts: strikes.map((strike) => contract(strike, "put")), providerId: "test", dataSource: "delayed", delayMinutes: 15,
-    asOf: "2026-09-22T13:45:00Z" };
-}
-
-describe("surface cleaning and midpoint model", () => {
-  test("closing quotes are valued at the time they were observed, not at the current clock", () => {
-    // Priced at 30% at the quote time; read 16 hours later, before the next open.
-    const quoted = { ...chain(), asOf: new Date(now).toISOString() };
-    const result = buildSurfaceExpiry({ chain: quoted, expiration, spot: 100, curve, now: now + 16 * 3_600_000 });
-    expect(result.years).toBeCloseTo(daysToExpiryFrom(expiration, now) / 365, 10);
-    expect(result.atmIV).toBeCloseTo(0.3, 5);
-  });
-
-  test("keeps executable OTM quotes, recovers the parity forward and uses the shared IV solver", () => {
-    const result = buildSurfaceExpiry({ chain: chain(), expiration, spot: 100, curve, now });
-    const years = daysToExpiryFrom(expiration, now) / 365;
-    expect(result.state).toBe("ready");
-    expect(result.rate).toBeCloseTo(0.04, 12);
-    expect(result.forward).toBeCloseTo(100 * Math.exp(0.03 * years), 6);
-    expect(result.dividendYield).toBeCloseTo(0.01, 8);
-    expect(result.atmIV).toBeCloseTo(0.3, 5);
-    expect(result.points.length).toBeGreaterThan(5);
-    for (const point of result.points) {
-      expect(point.side === "call" ? point.strike >= result.forward! : point.strike < result.forward!).toBe(true);
-      expect(point.volatility).toBeCloseTo(0.3, 4);
-      expect(point.providerIV).toBe(0.44);
-      expect(point.price).toBeCloseTo((point.contract.bid + point.contract.ask) / 2, 10);
-    }
-    expect(result.expectedMove.sigma).toBeCloseTo(100 * 0.3 * Math.sqrt(years), 4);
-    expect(result.asOf).toBe("2026-09-22T13:45:00Z");
-    expect(result.rateAsOf).toEqual(["2026-09-21"]);
-  });
-
-  test("provider mode never converts zero-bid placeholders or last trades into observations", () => {
-    const input = chain();
-    input.calls = input.calls.map((contract) => ({ ...contract, bid: 0, ask: 0, impliedVolatility: 0.12500875 }));
-    input.puts = input.puts.map((contract) => ({ ...contract, bid: 0, ask: 0, impliedVolatility: 0.500005 }));
-    for (const ivSource of ["recomputed", "provider"] as const) {
-      const result = buildSurfaceExpiry({ chain: input, expiration, spot: 100, curve, now, settings: { ivSource } });
-      expect(result.points).toHaveLength(0);
-      expect(result.fit).toBeNull();
-      expect(result.forward).toBeNull();
-      expect(result.filterCounts["zero-bid"]).toBe(18);
-    }
-  });
-
-  test("does not fit a smile whose near-the-money quotes are all missing", () => {
-    // Yahoo's post-close LEAPS: the wings keep quotes while every strike near
-    // the forward is zero-bid. A fit bridging the wings invented a 12% ATM.
-    const input = chain(expiration, 0.3, Array.from({ length: 33 }, (_, index) => 60 + index * 2.5));
-    const unquoted = (contract: OptionContract) => contract.strike > 80 && contract.strike < 120 ? { ...contract, bid: 0, ask: 0 } : contract;
-    const gapped = { ...input, calls: input.calls.map(unquoted), puts: input.puts.map(unquoted) };
-    const result = buildSurfaceExpiry({ chain: gapped, expiration, spot: 100, curve, now });
-    expect(result.points.length).toBeGreaterThan(0);
-    expect(result.fit).toBeNull();
-    expect(result.atmIV).toBeNull();
-    expect(result.state).not.toBe("ready");
-  });
-
-  test("records cleaning reasons, rejects mismatched expiries and prefers fresh duplicate quotes", () => {
-    const template = chain().calls[4]!;
-    const quote = (strike: number, patch: Partial<OptionContract> = {}): OptionContract => ({ ...template, strike, bid: 2, ask: 2.1, ...patch });
-    const old = now / 1000 - 30 * 86400;
-    const input: OptionsChain = { underlyingSymbol: "AAPL", expirationDates: [expiration], puts: [], calls: [
-      quote(1, { bid: 0 }), quote(2, { bid: 3, ask: 2 }), quote(3, { bid: 1, ask: 4 }),
-      quote(4, { openInterest: 0 }), quote(5, { openInterest: undefined }), quote(6, { expiration: expiration + 86400 }),
-      quote(7, { lastTradeDate: old }), quote(7), quote(8, { lastTradeDate: old }), quote(9), quote(9, { ask: 2.05 }),
-    ] };
-    const result = cleanSurfaceQuotes(input, expiration, DEFAULT_SURFACE_SETTINGS, now);
-    expect(result.calls.map((contract) => contract.strike)).toEqual([7, 8, 9]);
-    expect(result.calls.at(-1)!.ask).toBe(2.05);
-    expect(result.filterCounts["zero-bid"]).toBe(1);
-    expect(result.filterCounts.crossed).toBe(1);
-    expect(result.filterCounts["wide-spread"]).toBe(1);
-    expect(result.filterCounts["no-interest"]).toBe(2);
-    expect(result.filterCounts["expiry-mismatch"]).toBe(1);
-    expect(result.filterCounts["stale-duplicate"]).toBe(1);
-    expect(result.filterCounts.duplicate).toBe(1);
-  });
-
-  test("keeps quote side and provider comparison distinct and exposes absent rates/parity", () => {
-    const input = chain();
-    const mid = buildSurfaceExpiry({ chain: input, expiration, spot: 100, curve, now });
-    const bid = buildSurfaceExpiry({ chain: input, expiration, spot: 100, curve, now, settings: { priceSide: "bid" } });
-    const ask = buildSurfaceExpiry({ chain: input, expiration, spot: 100, curve, now, settings: { priceSide: "ask" } });
-    expect(bid.atmIV!).toBeLessThan(mid.atmIV!);
-    expect(ask.atmIV!).toBeGreaterThan(mid.atmIV!);
-    const provider = buildSurfaceExpiry({ chain: input, expiration, spot: 100, curve, now, settings: { ivSource: "provider" } });
-    expect(provider.atmIV).toBeCloseTo(0.44, 8);
-    expect(buildSurfaceExpiry({ chain: input, expiration, spot: 100, curve: [], now }).rate).toBeNull();
-    const unpaired = buildSurfaceExpiry({ chain: { ...input, puts: [] }, expiration, spot: 100, curve, now });
-    expect(unpaired.fit).toBeNull();
-    expect(unpaired.parity.method).toBe("unavailable");
-  });
-
-  test("does not extrapolate old far-wing observations into a near-ATM surface", () => {
-    const result = buildSurfaceExpiry({ chain: chain(), expiration, spot: 100, curve, now });
-    result.points = result.points.filter((point) => point.strike >= 110);
-    expect(evaluateSurfaceSmile(result, 100)).toBeNull();
-    expect(evaluateSurfaceSmile(result, 115)).not.toBeNull();
-  });
-
-  test("preserves quoted ATM straddle when Treasury is unavailable without inventing modeled IV", () => {
-    const result = buildSurfaceExpiry({ chain: chain(), expiration, spot: 100, curve: [], now });
-    const complete = buildSurfaceExpiry({ chain: chain(), expiration, spot: 100, curve, now });
-    expect(result.expectedMove.straddle).toBe(complete.expectedMove.straddle);
-    expect(result.expectedMove.straddle).toBeGreaterThan(0);
-    expect(result.expectedMove.sigma).toBeNull();
-    expect(result.atmIV).toBeNull();
-    expect(result.fit).toBeNull();
-    expect(result.warnings).toContain("Treasury rate unavailable");
-  });
-});
-
-test("Treasury rates use percent conversion, explicit boundaries, dates and valid negative yields", () => {
-  const points = [{ maturity: "1M", maturityYears: 1 / 12, yield: 3, asOf: "2026-09-21" },
-    { maturity: "1Y", maturityYears: 1, yield: 5, asOf: "2026-09-18", stale: true }];
-  const middle = surfaceTreasuryRate(points, (1 / 12 + 1) / 2);
-  expect(middle.rate).toBeCloseTo(0.04, 12);
-  expect(middle.method).toBe("treasury-interpolated");
-  expect(middle.asOf).toEqual(["2026-09-21", "2026-09-18"]);
-  expect(middle.warnings).toHaveLength(2);
-  expect(surfaceTreasuryRate(points, 7 / 365)).toMatchObject({ method: "treasury-boundary", rate: 0.03, warnings: [] });
-  // A long-end hold, or a short-end hold on a curve missing its 1M point, is still flagged.
-  expect(surfaceTreasuryRate(points, 2).warnings).toContain("Treasury 1Y rate held outside the published tenor range");
-  expect(surfaceTreasuryRate(points.slice(1), 7 / 365).warnings).toContain("Treasury 1Y rate held outside the published tenor range");
-  expect(surfaceTreasuryRate([{ maturity: "1Y", maturityYears: 1, yield: -0.5 }], 1).rate).toBe(-0.005);
-  expect(surfaceTreasuryRate([{ maturity: "1Y", maturityYears: 1, yield: null }], 1).rate).toBeNull();
-});
-
-describe("surface grids", () => {
-  function snapshot(): SurfaceSnapshot {
-    const expirations = [Date.UTC(2027, 0, 15) / 1000, Date.UTC(2027, 5, 18) / 1000];
-    return { symbol: "AAPL", spot: 100, phase: "ready", settings: DEFAULT_SURFACE_SETTINGS, catalogue: expirations,
-      requested: 2, loaded: 2, failed: 0, failures: [], warnings: [], rateAsOf: "2026-09-21", fetchedAt: now,
-      expiries: expirations.map((expiry, index) => buildSurfaceExpiry({ chain: chain(expiry, index ? 0.4 : 0.3),
-        expiration: expiry, spot: 100, curve, now })) };
-  }
-
-  test("preserves missing observed strike coverage and keeps raster rows aligned", () => {
-    const data = snapshot();
-    const grid = buildSurfaceGrid(data, { coordinates: [0.5, 0.9, 1, 1.1, 2] });
-    expect(grid.tenors).toEqual(data.expiries.map((expiry) => expiry.years));
-    expect(grid.volatilities[0]![0]).toBeNull();
-    expect(grid.volatilities[0]![4]).toBeNull();
-    expect(grid.rows[0]!.cells[2]!.strike).toBe(100);
-    expect(grid.rows[0]!.cells[2]!.point?.contract.contractSymbol).toContain("100");
-    expect(grid.volatilities[0]![2]).toBeCloseTo(0.3, 5);
-    expect(grid.volatilities[1]![2]).toBeCloseTo(0.4, 5);
-  });
-
-  test("the sigma window widens with tenor and leaves rows without an ATM IV alone", () => {
-    const data = snapshot();
-    const coordinates = Array.from({ length: 41 }, (_, i) => 0.8 + i * 0.01);
-    const grid = buildSurfaceGrid(data, { axis: "forward", coordinates });
-    const windowed = windowSurfaceGrid(grid, data, 1);
-    const count = (row: (number | null)[]) => row.filter((value) => value != null).length;
-    // One standard deviation at 30% and 40% IV: roughly +/-17% and +/-35% of the forward.
-    expect(count(windowed.volatilities[0]!)).toBeLessThan(count(grid.volatilities[0]!));
-    expect(count(windowed.volatilities[1]!)).toBeGreaterThan(count(windowed.volatilities[0]!));
-    expect(windowed.volatilities[0]![20]).toBe(grid.volatilities[0]![20]);
-    expect(windowed.rows[0]!.cells[0]!.strike).toBe(grid.rows[0]!.cells[0]!.strike);
-    const blind = { ...data, expiries: data.expiries.map((expiry) => ({ ...expiry, atmIV: null })) };
-    expect(windowSurfaceGrid(buildSurfaceGrid(blind, { axis: "forward", coordinates }), blind).volatilities)
-      .toEqual(buildSurfaceGrid(blind, { axis: "forward", coordinates }).volatilities);
-  });
-
-  test("fixed tenors interpolate total variance at common forward moneyness", () => {
-    const data = snapshot();
-    const grid = buildSurfaceGrid(data, { axis: "forward", tenors: "fixed", coordinates: [1] });
-    const row = grid.rows.find((value) => value.label === "6M")!;
-    const first = data.expiries[0]!, last = data.expiries[1]!;
-    const weight = (row.years - first.years) / (last.years - first.years);
-    const expected = Math.sqrt(((1 - weight) * 0.3 ** 2 * first.years + weight * 0.4 ** 2 * last.years) / row.years);
-    expect(row.cells[0]!.volatility).toBeCloseTo(expected, 5);
-    expect(row.interpolated).toBe(true);
-    expect(row.extrapolated).toBe(false);
-    expect(row.rate).toBeCloseTo(0.04, 12);
-    expect(row.dividendYield).toBeCloseTo(0.01, 8);
-    expect(row.forward).toBeCloseTo(data.spot * Math.exp((row.rate! - row.dividendYield!) * row.years), 10);
-    expect(grid.rows[0]!.extrapolated).toBe(true);
-  });
-
-  test("delta coordinates solve against each displayed tenor and fitted smile", () => {
-    const data = snapshot();
-    for (const tenors of ["listed", "fixed"] as const) {
-      const grid = buildSurfaceGrid(data, { axis: "delta", tenors, coordinates: [-0.25, 0, 0.25] });
-      const row = tenors === "fixed" ? grid.rows.find((value) => value.label === "6M")! : grid.rows[0]!;
-      for (const [index, side] of [[0, "put"], [2, "call"]] as const) {
-        const cell = row.cells[index]!;
-        expect(cell.strike).not.toBeNull();
-        expect(optionDelta({ spot: 100, years: row.years, rate: 0.04, dividendYield: 0.01,
-          volatility: cell.volatility! }, cell.strike!, side)).toBeCloseTo(index ? 0.25 : -0.25, 6);
-      }
-    }
-  });
-});
-
-test("the 3D sheet drops interpolation-fallback expiries only when four SVI slices remain", () => {
-  const slice = (expiration: number, method: "svi" | "monotone-cubic") => ({ expiration, fit: { method } }) as unknown as SurfaceSnapshot["expiries"][number];
-  const snapshot = (methods: ("svi" | "monotone-cubic")[]) => ({ expiries: methods.map((method, index) => slice(index + 1, method)) }) as unknown as SurfaceSnapshot;
-  const mixed = surfaceSheetSnapshot(snapshot(["svi", "svi", "svi", "svi", "monotone-cubic"]));
-  expect(mixed.snapshot.expiries.map((entry) => entry.expiration)).toEqual([1, 2, 3, 4]);
-  expect(mixed.omitted.map((entry) => entry.expiration)).toEqual([5]);
-  const thin = surfaceSheetSnapshot(snapshot(["svi", "svi", "monotone-cubic"]));
-  expect(thin.snapshot.expiries).toHaveLength(3);
-  expect(thin.omitted).toEqual([]);
-});
-
-test("the delta axis centres ATM on the delta-neutral straddle strike, between 45P and 45C", () => {
-  const expiry = buildSurfaceExpiry({ chain: chain(), expiration, spot: 100, curve, now });
-  const snapshot = { symbol: "AAPL", spot: 100, phase: "ready", settings: DEFAULT_SURFACE_SETTINGS, catalogue: [expiration], requested: 1, loaded: 1,
-    failed: 0, expiries: [expiry], failures: [], warnings: [], rateAsOf: null, fetchedAt: now } as SurfaceSnapshot;
-  const row = buildSurfaceGrid(snapshot, { axis: "delta", coordinates: [-0.45, 0, 0.45] }).rows[0]!;
-  const [put45, atm, call45] = row.cells.map((cell) => cell.strike!);
-  expect(atm).toBeCloseTo(expiry.forward! * Math.exp(0.3 * 0.3 * expiry.years / 2), 1);
-  expect(put45).toBeLessThan(atm);
-  expect(call45).toBeGreaterThan(atm);
-});

package/src/plugins/builtin/vol-surface/pane.test.tsx

@@ -1,265 +0,0 @@
-import { afterEach, expect, spyOn, test } from "bun:test";
-import { act, Profiler, useReducer } from "react";
-import { apiClient } from "../../../api-client";
-import { PaneFooterProvider } from "../../../components/layout/pane/footer";
-import { MarketDataCoordinator, getSharedMarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../market-data/coordinator";
-import { emitKeypress, testRender } from "../../../renderers/opentui/test-utils";
-import { appReducer, createInitialState, type AppState } from "../../../state/app/context";
-import { createTestDataProvider } from "../../../test-support/data-provider";
-import { createTestPaneConfig, createTestTicker, TestPaneProvider } from "../../../test-support/pane";
-import { createStatefulTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import type { OptionContract, OptionsChain, TickerFinancials } from "../../../types/financials";
-import type { PaneTemplateCreateOptions } from "../../../types/plugin";
-import { DEFAULT_OPTION_CALC_DRAFT, daysToExpiryFrom, valueOption } from "../options-calculator/model";
-import { VolSurfacePane } from "./pane";
-import { selectSurfaceExpiries } from "./client";
-import { buildSurfaceExpiry } from "./model";
-
-const PANE_ID = "vol-surface:interaction-test";
-const SYMBOL = "VOLTEST";
-const WIDTH = 112, HEIGHT = 26;
-let setup: Awaited<ReturnType<typeof testRender>> | undefined;
-let coordinator: MarketDataCoordinator | undefined;
-let previousCoordinator: ReturnType<typeof getSharedMarketDataCoordinator>;
-let treasury: ReturnType<typeof spyOn<typeof apiClient, "getCloudYieldCurve">> | undefined;
-let impliedVolatility: ReturnType<typeof spyOn<typeof apiClient, "impliedVolatility">> | undefined;
-
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((done) => { resolve = done; });
-  return { promise, resolve };
-}
-
-function quotedChain(expirations: number[], expiration: number, now: number, zeroBids = false): OptionsChain {
-  const quote = (strike: number, side: "call" | "put"): OptionContract => {
-    const price = valueOption({ ...DEFAULT_OPTION_CALC_DRAFT, spot: 100, strike, side,
-      daysToExpiry: daysToExpiryFrom(expiration, now), rate: 0.04, dividendYield: 0.01, volatility: 0.32 }).price;
-    return { contractSymbol: `${SYMBOL}-${expiration}-${side}-${strike}`, expiration, strike, currency: "USD",
-      // Outside regular hours the delayed feed publishes zero bids and asks.
-      bid: zeroBids ? 0 : price * 0.99, ask: zeroBids ? 0 : price * 1.01, lastPrice: price, impliedVolatility: 0.32, openInterest: 100,
-      volume: 10, lastTradeDate: now / 1000 - 60, change: 0, percentChange: 0,
-      inTheMoney: side === "call" ? strike < 100 : strike > 100 };
-  };
-  // No 105 strike: selecting the interpolated 105 cell must not borrow the
-  // nearest 100 or 110 contract's market price when opening the pricer.
-  const strikes = [75, 85, 95, 100, 110, 120, 130];
-  return { underlyingSymbol: SYMBOL, expirationDates: expirations,
-    calls: strikes.map((strike) => quote(strike, "call")), puts: strikes.map((strike) => quote(strike, "put")),
-    dataSource: "delayed", delayMinutes: 15, asOf: new Date(now).toISOString() };
-}
-
-async function settle(frames = 7) {
-  for (let frame = 0; frame < frames; frame += 1) {
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      await setup!.renderOnce();
-    });
-  }
-}
-
-/** A stored close surface of the quoted chain, compacted the way the platform capture stores it. */
-function storedPayload(expirations: number[], now: number) {
-  const curve = [{ maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: "2026-09-21" }, { maturity: "1Y", maturityYears: 1, yield: 4, asOf: "2026-09-21" }];
-  const expiries = expirations.map((expiration) => buildSurfaceExpiry({ chain: quotedChain(expirations, expiration, now), expiration, spot: 100, curve, now }));
-  const capturedAt = new Date(now).toISOString();
-  return { version: 1, symbol: SYMBOL, sessionDate: "2026-09-22", capturedAt, spot: 100, surface: { version: 1, symbol: SYMBOL, spot: 100,
-    spotAsOf: capturedAt, capturedAt, source: null, failures: [], expiries: JSON.parse(JSON.stringify(expiries.map((expiry) => ({
-      ...expiry, points: expiry.points.map((point) => [point.strike, point.side === "call" ? 1 : 0, point.volatility, point.mid,
-        point.contract.bid, point.contract.ask, point.openInterest, point.contract.contractSymbol]) })))) } };
-}
-
-async function mount({ missingSelection = false, holdSecond = false, pinnedSelection = false, optionTicker = false, zeroBids = false, storedDates = false } = {}) {
-  const now = Date.now();
-  const date = new Date(now);
-  const expirations = (pinnedSelection ? Array.from({ length: 40 }, (_, index) => index + 1) : [45, 120])
-    .map((days) => Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + days) / 1000);
-  const sample = selectSurfaceExpiries(expirations, 18, now);
-  const pins = expirations.filter((expiration) => !sample.includes(expiration));
-  const paneSymbol = optionTicker ? `${SYMBOL} ${new Date(expirations[0]! * 1000).toISOString().slice(2, 10).replaceAll("-", "")}C00100000` : SYMBOL;
-  const held = deferred<OptionsChain>();
-  const calls: (number | undefined)[] = [];
-  const opened: { id: string; options: PaneTemplateCreateOptions | undefined }[] = [];
-  let currentState!: AppState;
-  let changeExpiration: (expiration: number) => void = () => {};
-  let commits = 0;
-  const financials: TickerFinancials = { quote: { symbol: SYMBOL, price: 100, currency: "USD",
-    change: 0, changePercent: 0, lastUpdated: now, stale: false },
-    annualStatements: [], quarterlyStatements: [], priceHistory: [] };
-  const paneFinancials = optionTicker ? { ...financials, quote: { ...financials.quote!, symbol: paneSymbol, price: 5 } } : financials;
-  const provider = createTestDataProvider({ id: "surface-pane-fixture",
-    getTickerFinancials: async (symbol) => symbol === paneSymbol ? paneFinancials : financials,
-    getQuote: async (symbol) => symbol === paneSymbol ? paneFinancials.quote! : financials.quote!,
-    getOptionsChain: async (_symbol, _exchange, expiration) => {
-      calls.push(expiration);
-      return holdSecond && expiration === expirations[1] ? held.promise
-        : quotedChain(expirations, expiration ?? expirations[0]!, now, zeroBids);
-    },
-  });
-  previousCoordinator = getSharedMarketDataCoordinator();
-  coordinator = new MarketDataCoordinator(provider);
-  setSharedMarketDataCoordinator(coordinator);
-  await coordinator.loadSnapshot({ symbol: SYMBOL, exchange: optionTicker ? "" : "NASDAQ" });
-  // Cloud IV history (stored dates, IV rank) stays offline; the live surface is under test.
-  impliedVolatility = storedDates
-    ? spyOn(apiClient, "impliedVolatility").mockImplementation((async (path: string) => path.startsWith("surface-dates")
-      ? { version: 1, symbol: SYMBOL, dates: ["2026-09-22"] }
-      : path.startsWith("surface?") ? storedPayload(expirations, now) : Promise.reject(new Error("offline"))) as never)
-    : spyOn(apiClient, "impliedVolatility").mockRejectedValue(new Error("Cloud IV offline in tests"));
-  treasury = spyOn(apiClient, "getCloudYieldCurve").mockResolvedValue([
-    { maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: date.toISOString().slice(0, 10) },
-    { maturity: "1Y", maturityYears: 1, yield: 4, asOf: date.toISOString().slice(0, 10) },
-  ]);
-  const absentExpiry = expirations[1]! + 7 * 86400;
-  const config = createTestPaneConfig("/tmp/gloom-vol-surface-interaction-test", {
-    instanceId: PANE_ID, paneId: "vol-surface", binding: { kind: "fixed", symbol: paneSymbol },
-    ...(missingSelection || pinnedSelection ? { settings: { expiration: missingSelection ? absentExpiry : pins[0] } } : {}),
-  });
-  config.chartPreferences.renderer = "braille";
-  config.refreshIntervalMinutes = 0;
-  const initial = createInitialState(config);
-  initial.tickers.set(paneSymbol, createTestTicker(paneSymbol, paneSymbol, {
-    exchange: "NASDAQ", currency: "USD", assetCategory: optionTicker ? "OPT" : "STK",
-  }));
-  initial.financials.set(paneSymbol, paneFinancials);
-  initial.focusedPaneId = PANE_ID;
-  const runtime = createStatefulTestPluginRuntime({ getMarketData: () => provider,
-    createPaneFromTemplate: (id, options) => { opened.push({ id, options }); },
-  });
-  function Harness() {
-    const [state, dispatch] = useReducer(appReducer, initial);
-    currentState = state;
-    changeExpiration = (expiration) => dispatch({ type: "UPDATE_LAYOUT", layout: { ...state.config.layout,
-      instances: state.config.layout.instances.map((instance) => instance.instanceId === PANE_ID
-        ? { ...instance, settings: { ...instance.settings, expiration } } : instance) } });
-    return <TestPaneProvider state={state} dispatch={dispatch} paneId={PANE_ID} pluginId="ticker-research" runtime={runtime}>
-      <Profiler id="surface" onRender={() => { commits += 1; }}>
-        <PaneFooterProvider>{() => <VolSurfacePane focused width={WIDTH} height={HEIGHT} />}</PaneFooterProvider>
-      </Profiler>
-    </TestPaneProvider>;
-  }
-  await act(async () => { setup = await testRender(<Harness />, { width: WIDTH, height: HEIGHT }); });
-  await settle();
-  return { now, expirations, absentExpiry, pins, paneSymbol, calls, opened, changeExpiration: (value: number) => changeExpiration(value), get state() { return currentState; },
-    get commits() { return commits; }, finishSecond: () => held.resolve(quotedChain(expirations, expirations[1]!, now)) };
-}
-
-afterEach(async () => {
-  if (setup) await act(async () => setup!.renderer.destroy());
-  setup = undefined;
-  coordinator?.destroy(); coordinator = undefined;
-  setSharedMarketDataCoordinator(previousCoordinator ?? null);
-  treasury?.mockRestore(); treasury = undefined;
-  impliedVolatility?.mockRestore(); impliedVolatility = undefined;
-});
-
-test("a pinned unsampled expiry survives handback and loaded selections do not restart the surface", async () => {
-  const context = await mount({ pinnedSelection: true });
-  await emitKeypress(setup!, { name: "c", sequence: "c" }, { trackPropagation: true });
-  expect(context.opened.at(-1)).toMatchObject({ id: "options-pane", options: {
-    symbol: SYMBOL, values: { expiration: String(context.pins[0]) }, listing: { exchange: "NASDAQ", currency: "USD" },
-    ticker: { metadata: { ticker: SYMBOL } },
-  } });
-  expect(context.calls.filter((value) => value === context.pins[0])).toHaveLength(1);
-  expect(treasury).toHaveBeenCalledTimes(1);
-  await act(async () => { context.changeExpiration(context.pins[1]!); });
-  await settle();
-  expect(context.calls.filter((value) => value === context.pins[1])).toHaveLength(1);
-  expect(treasury).toHaveBeenCalledTimes(2);
-  await act(async () => { context.changeExpiration(context.expirations[0]!); });
-  await settle();
-  expect(treasury).toHaveBeenCalledTimes(2);
-  const completedCommits = context.commits;
-  await settle();
-  expect(context.commits).toBe(completedCommits);
-  await emitKeypress(setup!, { name: "c", sequence: "c" }, { trackPropagation: true });
-  expect(context.opened.at(-1)!.options!.values!.expiration).toBe(String(context.expirations[0]));
-});
-
-test("an option holding uses its underlying spot and retains its original scope on handback", async () => {
-  const context = await mount({ optionTicker: true });
-  await emitKeypress(setup!, { name: "p", sequence: "p" }, { trackPropagation: true });
-  expect(context.opened.at(-1)!.options!.values!.spot).toBe("100");
-  await emitKeypress(setup!, { name: "c", sequence: "c" }, { trackPropagation: true });
-  expect(context.opened.at(-1)!.options).toMatchObject({ symbol: context.paneSymbol,
-    ticker: { metadata: { ticker: context.paneSymbol, assetCategory: "OPT" } },
-    values: { expiration: String(context.expirations[0]) },
-  });
-});
-
-test("surface text fallback navigates cells and expiries and seeds the selected fitted contract", async () => {
-  const context = await mount();
-  await emitKeypress(setup!, { name: "right", sequence: "\u001b[C" }, { trackPropagation: true });
-  await emitKeypress(setup!, { name: "down", sequence: "\u001b[B" }, { trackPropagation: true });
-  await emitKeypress(setup!, { name: "p", sequence: "p" }, { trackPropagation: true });
-  expect(context.opened).toHaveLength(1);
-  const seed = context.opened[0]!;
-  expect(seed.id).toBe("options-calculator-pane");
-  const values = seed.options!.values!;
-  expect(Number(values.strike)).toBe(105);
-  expect(Number(values.days)).toBeCloseTo(daysToExpiryFrom(context.expirations[1]!, context.now), 3);
-  expect(Number(values.rate)).toBeCloseTo(0.04, 9);
-  expect(Number(values.dividendYield)).toBeCloseTo(0.01, 6);
-  expect(Number(values.volatility)).toBeCloseTo(0.32, 4);
-  expect(values.marketPrice).toBeUndefined();
-  expect(context.calls).toHaveLength(2);
-});
-
-test("an explicitly saved missing expiry cannot silently seed a different expiry", async () => {
-  const context = await mount({ missingSelection: true });
-  await emitKeypress(setup!, { name: "p", sequence: "p" }, { trackPropagation: true });
-  expect(context.opened).toEqual([]);
-  expect(context.state.config.layout.instances[0]!.settings?.expiration).toBe(context.absentExpiry);
-  // An explicit navigation choice restores a valid contract and enables pricing.
-  await emitKeypress(setup!, { name: "]", sequence: "]" }, { trackPropagation: true });
-  await emitKeypress(setup!, { name: "p", sequence: "p" }, { trackPropagation: true });
-  expect(context.opened).toHaveLength(1);
-  expect(Number(context.opened[0]!.options!.values!.days)).toBeCloseTo(daysToExpiryFrom(context.expirations[0]!, context.now), 3);
-});
-
-test("a missing handoff after loading warns and cannot reuse the previous selected contract", async () => {
-  const context = await mount();
-  await act(async () => context.changeExpiration(context.absentExpiry));
-  await settle();
-  expect(treasury).toHaveBeenCalledTimes(1);
-  await emitKeypress(setup!, { name: "p", sequence: "p" }, { trackPropagation: true });
-  expect(context.opened).toEqual([]);
-  await emitKeypress(setup!, { name: "c", sequence: "c" }, { trackPropagation: true });
-  expect(context.opened.at(-1)!.options!.values!.expiration).toBe(String(context.absentExpiry));
-  await emitKeypress(setup!, { name: "!", sequence: "!" }, { trackPropagation: true });
-  await settle();
-  expect(setup!.captureCharFrame()).toContain("selected expiration unavailable");
-});
-
-test("partial expiry progress settles without reloading or rendering indefinitely", async () => {
-  const context = await mount({ holdSecond: true });
-  expect(context.calls).toHaveLength(2);
-  await emitKeypress(setup!, { name: "p", sequence: "p" }, { trackPropagation: true });
-  expect(context.opened).toHaveLength(1);
-  expect(Number(context.opened[0]!.options!.values!.days)).toBeCloseTo(daysToExpiryFrom(context.expirations[0]!, context.now), 3);
-  const partialCommits = context.commits;
-  await settle();
-  expect(context.commits).toBe(partialCommits);
-  await act(async () => { context.finishSecond(); });
-  await settle();
-  const completedCommits = context.commits;
-  expect(completedCommits).toBeGreaterThan(partialCommits);
-  await settle();
-  expect(context.commits).toBe(completedCommits);
-  expect(context.calls).toHaveLength(2);
-});
-
-test("a chain with no two-sided quote explains itself instead of drawing an empty surface", async () => {
-  await mount({ zeroBids: true });
-  const frame = setup!.captureCharFrame();
-  expect(frame).toContain("No two-sided option quotes");
-  expect(frame).toContain("have a zero bid");
-});
-
-test("with no live quote the latest stored close stands in, labelled as such", async () => {
-  await mount({ zeroBids: true, storedDates: true });
-  await settle();
-  const frame = setup!.captureCharFrame();
-  expect(frame).not.toContain("No two-sided option quotes");
-  expect(frame).toContain("Stored close");
-  expect(frame).toContain("2026-09-22");
-});

package/src/plugins/builtin/vol-surface/raster.test.ts

@@ -1,28 +0,0 @@
-import { expect, test } from "bun:test";
-import { SURFACE_3D_DELTAS } from "./model";
-import { deltaLabel, tenorLabel, volatilitySurfaceInput, volatilityTicks } from "./raster";
-
-test("delta surfaces label 10P, 25P, ATM, 25C and 10C, ridge the ATM column and span the bulk of the vols", () => {
-  const volatilities = [0.02, 0.1, 0.5].map((years) => SURFACE_3D_DELTAS.map((delta) => 0.2 + (delta < 0 ? 0.3 + delta : 0) + years * 0.05));
-  volatilities[0]![0] = 3; // one wild front wing cell
-  const input = volatilitySurfaceInput({ tenors: [0.02, 0.1, 0.5], moneyness: SURFACE_3D_DELTAS, volatilities, axis: "delta" }, { tenorIndex: 1, moneynessIndex: 8 });
-  expect(input.xTicks.map((tick) => tick.label)).toEqual(["10P", "25P", "ATM", "25C", "10C"]);
-  expect(input.xTicks.map((tick) => tick.position)).toEqual([0, 3 / 16, 0.5, 13 / 16, 1]);
-  expect(input.ridgeColumn).toBe(8);
-  expect(input.zMax).toBeLessThan(1);
-  expect(input.selected).toEqual({ row: 1, column: 8 });
-  expect(input.titles.x).toBe("DELTA");
-});
-
-test("moneyness surfaces place ticks by value and ridge K/F = 1 between columns", () => {
-  const input = volatilitySurfaceInput({ tenors: [0.1, 0.5], moneyness: [0.8, 0.95, 1.05, 1.2], volatilities: [[0.3, 0.22, 0.2, 0.21], [0.28, 0.23, 0.21, 0.22]] }, null);
-  expect(input.xTicks.map((tick) => tick.label)).toEqual(["80%", "90%", "100%", "110%", "120%"]);
-  expect(input.ridgeColumn).toBeCloseTo(1.5, 9);
-  expect(input.titles.x).toBe("FORWARD MONEYNESS");
-});
-
-test("labels and vol ticks", () => {
-  expect([deltaLabel(-0.1), deltaLabel(0), deltaLabel(0.25)]).toEqual(["10P", "ATM", "25C"]);
-  expect([tenorLabel(2 / 365), tenorLabel(90 / 365), tenorLabel(1), tenorLabel(2.3)]).toEqual(["2D", "3M", "1Y", "2.3Y"]);
-  expect(volatilityTicks(0.11, 0.26)).toEqual([0.15, 0.2, 0.25]);
-});

package/src/plugins/builtin/vol-surface/stored.test.ts

@@ -1,62 +0,0 @@
-import { expect, test } from "bun:test";
-import type { OptionContract, OptionsChain } from "../../../types/financials";
-import { DEFAULT_OPTION_CALC_DRAFT, daysToExpiryFrom, valueOption } from "../options-calculator/model";
-import { buildSurfaceExpiry, buildSurfaceGrid, normalizeSurfaceSettings, type SurfaceExpiry, type SurfaceSnapshot } from "./model";
-import { storedSurfaceSnapshot } from "./stored";
-
-const now = Date.UTC(2026, 8, 22, 19, 50);
-const curve = [{ maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: "2026-09-21" }, { maturity: "1Y", maturityYears: 1, yield: 4, asOf: "2026-09-21" }];
-const expiries = [Date.UTC(2026, 9, 16) / 1000, Date.UTC(2026, 11, 18) / 1000];
-
-function chain(expiry: number, volatility: number): OptionsChain {
-  const contract = (strike: number, side: "call" | "put"): OptionContract => {
-    const price = valueOption({ ...DEFAULT_OPTION_CALC_DRAFT, side, spot: 100, strike, daysToExpiry: daysToExpiryFrom(expiry, now),
-      rate: 0.04, dividendYield: 0.01, volatility: volatility + Math.abs(strike - 100) / 400 }).price;
-    return { contractSymbol: `AAPL-${side}-${strike}`, strike, currency: "USD", expiration: expiry, bid: price * 0.99, ask: price * 1.01,
-      lastPrice: price, impliedVolatility: 0.3, openInterest: 20, volume: 3, lastTradeDate: now / 1000 - 600, change: 0, percentChange: 0,
-      inTheMoney: side === "call" ? strike < 100 : strike > 100 };
-  };
-  const strikes = [70, 80, 90, 95, 100, 105, 110, 120, 130];
-  return { underlyingSymbol: "AAPL", expirationDates: expiries, calls: strikes.map((strike) => contract(strike, "call")),
-    puts: strikes.map((strike) => contract(strike, "put")), providerId: "test", dataSource: "live", asOf: new Date(now).toISOString() };
-}
-
-/** The platform's compaction (server/src/services/implied-vol/capture.ts), including its rounding. */
-const round = (value: number | null | undefined, digits: number) => value == null || !Number.isFinite(value) ? null : Number(value.toFixed(digits));
-const compact = (expiry: SurfaceExpiry) => ({
-  expiration: expiry.expiration, years: round(expiry.years, 8), rate: round(expiry.rate, 6), rateMethod: expiry.rateMethod,
-  rateAsOf: expiry.rateAsOf, forward: round(expiry.forward, 4), dividendYield: round(expiry.dividendYield, 6),
-  atmIV: round(expiry.atmIV, 6), termSlope: round(expiry.termSlope, 6), skew: expiry.skew, expectedMove: expiry.expectedMove,
-  fit: expiry.fit, filterCounts: expiry.filterCounts, warnings: expiry.warnings, asOf: expiry.asOf,
-  points: expiry.points.map((point) => [point.strike, point.side === "call" ? 1 : 0, round(point.volatility, 6), round(point.mid, 4),
-    round(point.contract.bid, 4), round(point.contract.ask, 4), point.openInterest, point.contract.contractSymbol]),
-});
-
-test("a stored close surface rebuilds the live grid", () => {
-  const live = expiries.map((expiration, index) => buildSurfaceExpiry({ chain: chain(expiration, 0.25 + index * 0.03), expiration, spot: 100, curve, now }));
-  const liveSnapshot: SurfaceSnapshot = { symbol: "AAPL", spot: 100, phase: "ready", settings: normalizeSurfaceSettings({}), catalogue: expiries,
-    requested: 2, loaded: 2, failed: 0, expiries: live, failures: [], warnings: [], rateAsOf: "2026-09-21", fetchedAt: now };
-  const stored = storedSurfaceSnapshot({ version: 1, symbol: "AAPL", sessionDate: "2026-09-22", capturedAt: new Date(now).toISOString(), spot: 100,
-    surface: { version: 1, symbol: "AAPL", spot: 100, spotAsOf: new Date(now).toISOString(), capturedAt: new Date(now).toISOString(), source: null,
-      expiries: JSON.parse(JSON.stringify(live.map(compact))), failures: ["2027-01-15: no clean quotes"] } });
-  expect(stored.stored).toEqual({ sessionDate: "2026-09-22", capturedAt: new Date(now).toISOString() });
-  expect(stored.catalogue).toEqual(expiries);
-  expect(stored.failures).toEqual([{ expiration: null, message: "2027-01-15: no clean quotes" }]);
-  expect(stored.expiries[0]!.points.length).toBe(live[0]!.points.length);
-  expect(stored.expiries[0]!.parity.pairs).toEqual([]);
-  for (const axis of ["forward", "delta", "strike"] as const) {
-    const a = buildSurfaceGrid(liveSnapshot, { axis }), b = buildSurfaceGrid(stored, { axis });
-    expect(b.rows.length).toBe(a.rows.length);
-    a.rows.forEach((row, r) => row.cells.forEach((cell, c) => {
-      const other = b.rows[r]!.cells[c]!.volatility;
-      if (cell.volatility == null) expect(other).toBeNull();
-      else expect(other!).toBeCloseTo(cell.volatility, 4);
-    }));
-  }
-  const residuals = stored.expiries[1]!.points.map((point) => point.fitResidual!);
-  live[1]!.points.forEach((point, index) => expect(residuals[index]!).toBeCloseTo(point.fitResidual!, 4));
-});
-
-test("an unknown stored format is rejected", () => {
-  expect(() => storedSurfaceSnapshot({ version: 1, symbol: "AAPL", sessionDate: "2026-09-22", capturedAt: "", spot: 100, surface: { version: 2 } })).toThrow();
-});