gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/options/enrichment.test.ts

@@ -1,257 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { MarketDataCoordinator } from "../../../market-data/coordinator";
-import type { QueryEntry } from "../../../market-data/result-types";
-import { buildOptionsKey } from "../../../market-data/selectors";
-import type { DataProvider } from "../../../types/data-provider";
-import type { OptionsChain } from "../../../types/financials";
-import { DEFAULT_OPTION_CALC_DRAFT, daysToExpiryFrom, valueOption } from "../options-calculator/model";
-import { selectSurfaceExpiries } from "../vol-surface/client";
-import { loadOptionsEnrichment } from "./enrichment-client";
-import { optionsEnrichmentNeighbour, optionsEnrichmentTermSlope, projectOptionsEnrichment, type OptionsEnrichmentSelection,
-  type OptionsEnrichmentSnapshot } from "./enrichment-model";
-
-const now = Date.UTC(2026, 8, 22, 14);
-const expiry = (days: number) => (now + days * 86400000) / 1000;
-const selected = expiry(60);
-const next = expiry(90);
-const curve = [{ maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: "2026-09-21" },
-  { maturity: "1Y", maturityYears: 1, yield: 4, asOf: "2026-09-21" }];
-const instrument = { symbol: "AAPL", exchange: "NASDAQ", brokerId: "ibkr", brokerInstanceId: "account" };
-
-function chain(expiration = selected, volatility: number | ((strike: number) => number) = 0.3): OptionsChain {
-  const contract = (strike: number, side: "call" | "put") => {
-    const price = valueOption({ ...DEFAULT_OPTION_CALC_DRAFT, side, spot: 100, strike,
-      daysToExpiry: daysToExpiryFrom(expiration, now), rate: 0.04, dividendYield: 0.01,
-      volatility: typeof volatility === "number" ? volatility : volatility(strike) }).price;
-    return { contractSymbol: `${side}-${strike}-${expiration}`, strike, expiration, currency: "USD",
-      bid: price * 0.99, ask: price * 1.01, lastPrice: price * 2, openInterest: 100, volume: 1,
-      impliedVolatility: 0.75, change: 0, percentChange: 0, lastTradeDate: now / 1000, inTheMoney: false };
-  };
-  const strikes = [60, 70, 80, 85, 90, 95, 100, 105, 110, 115, 120, 130, 140];
-  return { underlyingSymbol: "AAPL", expirationDates: [selected, next],
-    calls: strikes.map((strike) => contract(strike, "call")), puts: strikes.map((strike) => contract(strike, "put")),
-    asOf: "2026-09-22T13:45:00Z", providerId: "test" };
-}
-function ready(data: OptionsChain): QueryEntry<OptionsChain> {
-  return { phase: "ready", data, lastGoodData: data, source: "test", fetchedAt: now,
-    staleAt: now + 60000, error: null, attempts: [] };
-}
-function selection(overrides: Partial<OptionsEnrichmentSelection> = {}): OptionsEnrichmentSelection {
-  return { instrument, expiration: selected, selectedEntry: ready(chain()), catalogue: [selected, next],
-    spot: 100, spotAsOf: now - 1000, ...overrides };
-}
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  let reject!: (error: unknown) => void;
-  const promise = new Promise<T>((done, fail) => { resolve = done; reject = fail; });
-  return { promise, resolve, reject };
-}
-async function settle() { await new Promise((resolve) => setTimeout(resolve, 0)); }
-
-describe("options enrichment projection", () => {
-  test("annualizes only at the far expiry's 30-day boundary, independently of the expiry gap", () => {
-    const front = { years: 1 / 365, volatility: 0.3 };
-    expect(optionsEnrichmentTermSlope(front, { years: 3 / 365, volatility: 0.312 }))
-      .toMatchObject({ termSlopeAnnualized: false, termSlope: expect.closeTo(0.012, 10) });
-    expect(optionsEnrichmentTermSlope(front, { years: (30 - 1 / 86400) / 365, volatility: 0.312 }).termSlopeAnnualized).toBe(false);
-    const atBoundary = optionsEnrichmentTermSlope({ years: 29 / 365, volatility: 0.3 }, { years: 30 / 365, volatility: 0.312 });
-    expect(atBoundary.termSlopeAnnualized).toBe(true);
-    expect(atBoundary.termSlope).toBeCloseTo(0.012 * 365, 10);
-    expect(optionsEnrichmentTermSlope(front, { years: (30 + 1 / 86400) / 365, volatility: 0.312 }).termSlopeAnnualized).toBe(true);
-    expect(optionsEnrichmentTermSlope(front, { years: front.years, volatility: 0.312 }).termSlope).toBeNull();
-  });
-
-  test("short-tenor enrichment retains raw IV change and both expiry identities", () => {
-    const near = expiry(24), far = expiry(29);
-    const result = projectOptionsEnrichment({ ...selection({ expiration: near, selectedEntry: ready(chain(near)), catalogue: [near, far] }),
-      curve, neighbourEntry: ready(chain(far, 0.312)), now });
-    expect(result.termSlopeAnnualized).toBe(false);
-    expect(result.termSlope).toBeCloseTo(0.012, 4);
-    expect(result.expiration).toBe(near);
-    expect(result.neighbourExpiration).toBe(far);
-  });
-
-  test("matches a provider's bare underlying to a public listing key while retaining its cache scope", () => {
-    const scoped = { ...instrument, symbol: "AAPL:XNAS" };
-    const result = projectOptionsEnrichment({ ...selection({ instrument: scoped }), curve, neighbourEntry: ready(chain(next)), now });
-    expect(result.error).toBeNull();
-    expect(result.expectedMove.straddle).toBeGreaterThan(0);
-    expect(result.termSlope).not.toBeNull();
-    expect(result.key).toBe(buildOptionsKey({ instrument: scoped, expirationDate: selected }));
-    expect(result.key).not.toBe(buildOptionsKey({ instrument, expirationDate: selected }));
-  });
-
-  test("uses cleaned recomputed IV for moves and adjacent slope with dated instrument identity", () => {
-    const result = projectOptionsEnrichment({ ...selection(), curve, neighbourEntry: ready(chain(next, 0.4)), now });
-    expect(result.key).toBe(buildOptionsKey({ instrument, expirationDate: selected }));
-    expect(result.phase).toBe("ready");
-    expect(result.expectedMove.sigma).toBeCloseTo(100 * 0.3 * Math.sqrt(daysToExpiryFrom(selected, now) / 365), 4);
-    const pair = chain();
-    expect(result.expectedMove.straddle).toBeCloseTo(pair.calls[6]!.lastPrice / 2 + pair.puts[6]!.lastPrice / 2, 8);
-    expect(result.expectedMove.straddlePercent).toBeCloseTo(result.expectedMove.straddle!, 10);
-    expect(result.skew25).toBeCloseTo(0, 4);
-    expect(result.termSlope).toBeCloseTo(0.1 / ((daysToExpiryFrom(next, now) - daysToExpiryFrom(selected, now)) / 365), 4);
-    expect(result.source).toBe("test");
-    expect(result.asOf).toBe("2026-09-22T13:45:00Z");
-    expect(result.neighbourAsOf).toBe(result.asOf);
-    expect(result.rateAsOf).toEqual(["2026-09-21"]);
-    const skewed = projectOptionsEnrichment({ ...selection({ selectedEntry: ready(chain(selected, (strike) => 0.3 - (strike - 100) * 0.002)) }),
-      curve, neighbourEntry: ready(chain(next)), now });
-    expect(skewed.skew25!).toBeGreaterThan(0.02);
-    expect(skewed.skew25!).toBeLessThan(0.1);
-  });
-
-  test("keeps the quote-only straddle when Treasury fails and never replaces zero bids with last trades", () => {
-    const result = projectOptionsEnrichment({ ...selection(), curve: [], treasuryError: "offline",
-      neighbourEntry: ready(chain(next)), now });
-    expect(result.phase).toBe("partial");
-    expect(result.expectedMove.straddle).toBeGreaterThan(0);
-    expect(result.expectedMove.sigma).toBeNull();
-    expect(result.skew25).toBeNull();
-    expect(result.termSlope).toBeNull();
-    expect(result.error).toContain("Treasury: offline");
-    const zeroBid = chain();
-    zeroBid.calls = zeroBid.calls.map((contract) => ({ ...contract, bid: 0 }));
-    zeroBid.puts = zeroBid.puts.map((contract) => ({ ...contract, bid: 0 }));
-    const rejected = projectOptionsEnrichment({ ...selection({ selectedEntry: ready(zeroBid) }), curve, neighbourEntry: ready(chain(next)), now });
-    expect(rejected.phase).toBe("unavailable");
-    expect(rejected.expectedMove.straddle).toBeNull();
-    expect(rejected.expectedMove.sigma).toBeNull();
-  });
-
-  test("refuses removed, expired, mismatched, stale, failed and undated selections", () => {
-    const good = selection();
-    const mixed = chain(); mixed.puts[0]!.expiration = next;
-    const cases: Partial<OptionsEnrichmentSelection>[] = [
-      { catalogue: [] }, { expiration: expiry(-1), catalogue: [expiry(-1)] },
-      { selectedEntry: ready(chain(next)) }, { selectedEntry: ready(mixed) },
-      { selectedEntry: ready({ ...chain(), underlyingSymbol: "MSFT" }) },
-      { selectedEntry: { ...good.selectedEntry, staleAt: now } },
-      { selectedEntry: { ...good.selectedEntry, error: { reasonCode: "UPSTREAM_ERROR", message: "refresh failed" } } },
-      { selectedEntry: ready({ ...chain(), asOf: undefined }) }, { spot: NaN },
-    ];
-    for (const patch of cases) {
-      const result = projectOptionsEnrichment({ ...good, ...patch, curve, neighbourEntry: ready(chain(next)), now });
-      expect(result.phase).toBe("unavailable");
-      expect(result.error).toBeTruthy();
-      expect(result.expectedMove.straddle).toBeNull();
-      expect(result.skew25).toBeNull();
-      expect(result.termSlope).toBeNull();
-    }
-    const other = projectOptionsEnrichment({ ...good, instrument: { ...instrument, brokerInstanceId: "other-account" }, now });
-    expect(other.key).not.toBe(buildOptionsKey({ instrument, expirationDate: selected }));
-  });
-
-  test("missing or stale adjacent quotes only remove slope and never jump over the nearest tenor", () => {
-    const neighbour = ready(chain(next));
-    for (const entry of [null, { ...neighbour, staleAt: now }, ready({ ...chain(next), asOf: undefined }),
-      ready(chain(selected)), ready({ ...chain(next), underlyingSymbol: "MSFT" })]) {
-      const result = projectOptionsEnrichment({ ...selection({ catalogue: [expiry(120), next, selected, next] }),
-        curve, neighbourEntry: entry, now });
-      expect(result.neighbourExpiration).toBe(next);
-      expect(result.termSlope).toBeNull();
-      expect(result.expectedMove.sigma).toBeGreaterThan(0);
-      expect(result.error).toContain("Adjacent expiry");
-    }
-    expect(optionsEnrichmentNeighbour([NaN, selected, next, selected, expiry(-1)], selected, now)).toBe(next);
-    const last = projectOptionsEnrichment({ ...selection({ catalogue: [selected] }), curve, now });
-    expect(last.neighbourExpiration).toBeNull();
-    expect(last.termSlope).toBeNull();
-    expect(last.phase).toBe("ready");
-  });
-
-  test("retains both source dates and flags a slope crossing observation dates", () => {
-    const result = projectOptionsEnrichment({ ...selection(), curve, now,
-      neighbourEntry: ready({ ...chain(next), asOf: "2026-09-21T20:00:00Z", providerId: "other-source" }) });
-    expect(result.termSlope).not.toBeNull();
-    expect(result.asOf).toBe("2026-09-22T13:45:00Z");
-    expect(result.neighbourAsOf).toBe("2026-09-21T20:00:00Z");
-    expect(result.neighbourSource).toBe("other-source");
-    expect(result.warnings.some((warning) => warning.includes("different dates"))).toBe(true);
-  });
-});
-
-describe("options enrichment loading", () => {
-  test("publishes quoted then modeled selected metrics before the adjacent request completes", async () => {
-    const rateGate = deferred<typeof curve>();
-    const neighbourGate = deferred<QueryEntry<OptionsChain>>();
-    const snapshots: OptionsEnrichmentSnapshot[] = [];
-    const calls: { expiration?: number; force?: boolean; instrument: unknown }[] = [];
-    const loading = loadOptionsEnrichment({ ...selection(), forceRefresh: true, onSnapshot: (value) => snapshots.push(value) }, {
-      now: () => now, loadYieldCurve: () => rateGate.promise, loadOptions: async (request, options) => {
-        calls.push({ expiration: request.expirationDate, force: options?.forceRefresh, instrument: request.instrument });
-        return neighbourGate.promise;
-      },
-    });
-    expect(snapshots[0]!.expectedMove.straddle).toBeGreaterThan(0);
-    expect(snapshots[0]!.expectedMove.sigma).toBeNull();
-    rateGate.resolve(curve); await settle();
-    expect(snapshots.at(-1)!.expectedMove.sigma).toBeGreaterThan(0);
-    expect(snapshots.at(-1)!.termSlope).toBeNull();
-    expect(snapshots.at(-1)!.phase).toBe("partial");
-    neighbourGate.resolve(ready(chain(next, 0.4)));
-    const result = await loading;
-    expect(result.phase).toBe("ready");
-    expect(result.termSlope).not.toBeNull();
-    expect(calls).toEqual([{ expiration: next, force: true, instrument }]);
-    expect(snapshots[0]!.expectedMove.sigma).toBeNull();
-  });
-
-  test("uses an OMON-selected expiry outside the surface sample and shares its adjacent cache entry", async () => {
-    const catalogue = Array.from({ length: 120 }, (_, index) => expiry(index + 1));
-    const representative = selectSurfaceExpiries(catalogue, 18, now);
-    const expiration = catalogue.find((date) => date >= expiry(30) && !representative.includes(date))!;
-    const neighbour = optionsEnrichmentNeighbour(catalogue, expiration, now)!;
-    const calls: (number | undefined)[] = [];
-    const provider = { id: "test", getOptionsChain: async (_symbol: string, _exchange: string, requested?: number) => {
-      calls.push(requested); return { ...chain(requested), expirationDates: catalogue };
-    } } as unknown as DataProvider;
-    const coordinator = new MarketDataCoordinator(provider);
-    const selectedEntry = await coordinator.loadOptions({ instrument, expirationDate: expiration });
-    await coordinator.loadOptions({ instrument, expirationDate: neighbour });
-    const result = await loadOptionsEnrichment(selection({ expiration, selectedEntry, catalogue }), {
-      now: () => now, loadYieldCurve: async () => curve, loadOptions: coordinator.loadOptions.bind(coordinator),
-    });
-    expect(result.expiration).toBe(expiration);
-    expect(result.expectedMove.sigma).toBeGreaterThan(0);
-    expect(calls).toEqual([expiration, neighbour]);
-  });
-
-  test("does not fetch for invalid selected state and preserves partial quote data on independent failures", async () => {
-    let calls = 0;
-    const dependencies = { now: () => now, loadYieldCurve: async () => { calls += 1; throw new Error("rates offline"); },
-      loadOptions: async () => { calls += 1; throw new Error("neighbor offline"); } };
-    const invalid = await loadOptionsEnrichment(selection({ catalogue: [] }), dependencies);
-    expect(invalid.phase).toBe("unavailable");
-    expect(calls).toBe(0);
-    const partial = await loadOptionsEnrichment(selection(), dependencies);
-    expect(partial.phase).toBe("partial");
-    expect(partial.expectedMove.straddle).toBeGreaterThan(0);
-    expect(partial.error).toContain("rates offline");
-    expect(partial.error).toContain("neighbor offline");
-    expect(calls).toBe(2);
-  });
-
-  test("cancellation rejects promptly and prevents late snapshots or new dependency calls", async () => {
-    const gate = deferred<QueryEntry<OptionsChain>>();
-    const snapshots: OptionsEnrichmentSnapshot[] = [];
-    let calls = 0;
-    const dependencies = { now: () => now, loadYieldCurve: async () => curve,
-      loadOptions: async () => { calls += 1; return gate.promise; } };
-    const controller = new AbortController();
-    const loading = loadOptionsEnrichment({ ...selection(), signal: controller.signal, onSnapshot: (value) => snapshots.push(value) }, dependencies);
-    await settle(); controller.abort();
-    await expect(loading).rejects.toMatchObject({ name: "AbortError" });
-    const count = snapshots.length;
-    gate.resolve(ready(chain(next))); await settle();
-    expect(snapshots).toHaveLength(count);
-    expect(calls).toBe(1);
-    await expect(loadOptionsEnrichment({ ...selection(), signal: controller.signal }, dependencies)).rejects.toMatchObject({ name: "AbortError" });
-    expect(calls).toBe(1);
-    const immediate = new AbortController();
-    const superseded = loadOptionsEnrichment({ ...selection(), signal: immediate.signal }, dependencies);
-    immediate.abort();
-    await expect(superseded).rejects.toMatchObject({ name: "AbortError" });
-    expect(calls).toBe(1);
-  });
-});

package/src/plugins/builtin/options/expiry-selection.test.tsx

@@ -1,370 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { act, useReducer } from "react";
-import { CachedQuery } from "../../../data/cached-query";
-import type { DataProvider } from "../../../types/data-provider";
-import { Box } from "../../../ui";
-import { PaneFooterBar, PaneFooterProvider } from "../../../components/layout/pane/footer";
-import { takeSavedTextFile, testRender } from "../../../renderers/opentui/test-utils";
-import { exportPaneTable } from "../../../state/pane-table-export-registry";
-import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../market-data/coordinator";
-import { appReducer, createInitialState, type AppState } from "../../../state/app/context";
-import { createTestDataProvider } from "../../../test-support/data-provider";
-import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import { TestPaneProvider, createTestTicker, createTestPaneConfig } from "../../../test-support/pane";
-import type { OptionContract, OptionsChain, TickerFinancials } from "../../../types/financials";
-import type { TickerRecord } from "../../../types/ticker";
-import { OptionsView } from "./view";
-import { optionsModule } from "./index";
-import { draftFromParams } from "../options-calculator/model";
-
-const PANE_ID = "options:expiry-selection";
-const EXPIRIES = [Date.UTC(2026, 8, 18), Date.UTC(2026, 9, 16), Date.UTC(2026, 10, 20)].map((ms) => ms / 1000);
-const EXPIRY_CODES = ["260918", "261016", "261120"];
-let setup: Awaited<ReturnType<typeof testRender>> | undefined;
-const realNow = Date.now;
-
-afterEach(async () => {
-  if (setup) await act(async () => setup!.renderer.destroy());
-  setup = undefined;
-  setSharedMarketDataCoordinator(null);
-  Date.now = realNow;
-});
-
-async function settle() {
-  for (let i = 0; i < 4; i += 1) await act(async () => {
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    await setup!.renderOnce();
-  });
-}
-
-async function fixture(width = 80, heldExpiry = 0, cached = false, delayedSeed?: number) {
-  let now = Date.UTC(2026, 8, 17, 16);
-  Date.now = () => now;
-  let catalogue = [...EXPIRIES];
-  const requests: Array<{ symbol: string; expiration: number | undefined }> = [];
-  const launches: ReturnType<typeof draftFromParams>[] = [];
-  const pending = new Map<number, Promise<OptionsChain>>();
-  let wrongExpiry: number | undefined;
-  let failure = false;
-  const makeContract = (symbol: string, expiration: number, side: "C" | "P"): OptionContract => {
-    const index = EXPIRIES.indexOf(expiration);
-    return {
-      contractSymbol: `${symbol}${EXPIRY_CODES[index]}${side}00340000`, strike: 340, currency: "USD",
-      lastPrice: 10 + index * 10, change: 0, percentChange: 0, volume: 123, openInterest: 456,
-      bid: 9 + index * 10, ask: 11 + index * 10, impliedVolatility: 0.25,
-      inTheMoney: side === "P", expiration, lastTradeDate: now / 1000, lastUpdated: now,
-    };
-  };
-  const chain = (symbol: string, expiration: number): OptionsChain => ({
-    underlyingSymbol: symbol, expirationDates: [...catalogue],
-    calls: [makeContract(symbol, expiration, "C")], puts: [makeContract(symbol, expiration, "P")],
-  });
-  const financials = (symbol: string): TickerFinancials => ({
-    quote: { symbol, price: 330, currency: "USD", change: 0, changePercent: 0, lastUpdated: now, stale: false },
-    annualStatements: [], quarterlyStatements: [], priceHistory: [],
-  });
-  const provider = createTestDataProvider({
-    getTickerFinancials: async (symbol) => financials(symbol),
-    getQuote: async (symbol) => financials(symbol).quote!,
-    getOptionsChain: async (symbol, _exchange, expiration) => {
-      requests.push({ symbol, expiration });
-      if (failure) throw new Error("Options source offline");
-      return expiration != null && pending.has(expiration)
-        ? pending.get(expiration)! : chain(symbol, wrongExpiry ?? expiration ?? catalogue[0]!);
-    },
-  });
-  if (cached) {
-    const queries = new Map<string, CachedQuery<OptionsChain>>();
-    provider.getCachedQuery = ((method, args) => {
-      if (method !== "getOptionsChain") return undefined;
-      const [symbol, exchange, expiration] = args as [string, string, number | undefined];
-      const key = `${symbol}:${expiration ?? "default"}`;
-      if (!queries.has(key)) queries.set(key, new CachedQuery({ read: () => null, fetch: async () => ({
-        value: await provider.getOptionsChain!(symbol, exchange, expiration), fetchedAt: now,
-        staleAt: now + 600_000, expiresAt: now + 3_600_000, source: "test-cache",
-      }) }));
-      return queries.get(key);
-    }) as DataProvider["getCachedQuery"];
-  }
-  const coordinator = new MarketDataCoordinator(provider);
-  setSharedMarketDataCoordinator(coordinator);
-  const ticker = (symbol: string, expiry: number) => createTestTicker(`${symbol} ${EXPIRY_CODES[expiry]}C00340000`, symbol, {
-    assetCategory: "OPT", positions: [{ portfolio: "fixture", shares: 1, side: "short", avgCost: 5, broker: "manual", multiplier: 100 }],
-  });
-  await coordinator.loadSnapshot({ symbol: "AAPL", exchange: "" });
-  let switchTicker: (ticker: TickerRecord) => void = () => {};
-  let seedExpiration: (expiration: number) => void = () => {};
-  let currentState: AppState;
-  const initialTicker = ticker("AAPL", heldExpiry);
-  const config = createTestPaneConfig("/tmp/options-expiry-test", {
-    instanceId: PANE_ID, paneId: "options", binding: { kind: "fixed", symbol: initialTicker.metadata.ticker },
-    ...(delayedSeed == null ? {} : { settings: { expiration: delayedSeed } }),
-  });
-  const initial = createInitialState(config);
-  initial.focusedPaneId = PANE_ID;
-  initial.tickers = delayedSeed == null ? new Map([[initialTicker.metadata.ticker, initialTicker]]) : new Map();
-  const runtime = createTestPluginRuntime({
-    createPaneFromTemplate: (_id, options) => { launches.push(draftFromParams(options?.values)); },
-  });
-  function Harness() {
-    const [state, dispatch] = useReducer(appReducer, currentState ?? initial);
-    currentState = state;
-    switchTicker = (selected) => {
-      dispatch({ type: "SET_TICKERS", tickers: new Map([[selected.metadata.ticker, selected]]) });
-      dispatch({ type: "UPDATE_LAYOUT", layout: { ...state.config.layout,
-        instances: state.config.layout.instances.map((instance) => ({ ...instance,
-          binding: { kind: "fixed", symbol: selected.metadata.ticker } })) } });
-    };
-    seedExpiration = (expiration) => {
-      const pane = state.config.layout.instances[0]!;
-      const symbol = pane.binding?.kind === "fixed" ? pane.binding.symbol : "AAPL";
-      const incoming = optionsModule.paneTemplates![0]!.createInstance({
-        config: state.config, layout: state.config.layout, focusedPaneId: PANE_ID,
-        activeTicker: symbol, activeCollectionId: null,
-      }, { symbol, values: { expiration: String(expiration) } })!;
-      dispatch({ type: "UPDATE_LAYOUT", layout: { ...state.config.layout,
-        instances: [{ ...pane, settings: { ...pane.settings, ...incoming.settings } }] } });
-    };
-    return <TestPaneProvider state={state} dispatch={dispatch} paneId={PANE_ID} pluginId="ticker-research" runtime={runtime}>
-      <PaneFooterProvider>{(footer) => <Box width={width} height={18} flexDirection="column">
-        <Box width={width} height={17}><OptionsView width={width} height={17} focused /></Box>
-        <PaneFooterBar footer={footer} focused width={width} />
-      </Box>}</PaneFooterProvider>
-    </TestPaneProvider>;
-  }
-  await act(async () => { setup = await testRender(<Harness />, { width, height: 18 }); });
-  await settle();
-  async function key(key: "enter" | "left" | "right" | "c") {
-    await act(async () => {
-      if (key === "enter") setup!.mockInput.pressEnter();
-      else if (key === "left" || key === "right") setup!.mockInput.pressArrow(key);
-      else setup!.mockInput.pressKey(key);
-    });
-    await settle();
-  }
-  async function capture(label: string) {
-    const count = launches.length;
-    await key("c");
-    await exportPaneTable(PANE_ID, `${label}.csv`);
-    const csv = takeSavedTextFile()?.text ?? "";
-    const frame = setup!.captureCharFrame();
-    const result = { frame, csv, launch: launches.length > count ? launches.at(-1) : undefined, requests: [...requests] };
-    const evidence = process.env.OPTIONS_EXPIRY_EVIDENCE;
-    if (evidence) {
-      await Bun.write(`${evidence}/${width}-${label}.txt`, frame);
-      await Bun.write(`${evidence}/${width}-${label}.csv`, csv);
-      await Bun.write(`${evidence}/${width}-${label}.json`, JSON.stringify(result, null, 2));
-    }
-    return result;
-  }
-  async function refresh(dates: number[], expiration?: number, advanceClock = true) {
-    catalogue = dates;
-    if (advanceClock) now += 1_000;
-    await act(async () => { await coordinator.loadOptions({ instrument: { symbol: "AAPL", exchange: "" }, expirationDate: expiration }, { forceRefresh: true }); });
-    await settle();
-  }
-  const request = (expiration?: number) => ({ instrument: { symbol: "AAPL", exchange: "" }, expirationDate: expiration });
-  return { capture, key, refresh, pending, chain, requests,
-    get state() { return currentState; },
-    async handoff(expiration: number) { await act(async () => seedExpiration(expiration)); await settle(); },
-    async hydrateTicker() { await act(async () => switchTicker(initialTicker)); await settle(); },
-    setFailure: (value: boolean) => { failure = value; },
-    async reread(expiration?: number) {
-      await act(async () => { await coordinator.loadOptions(request(expiration)); }); await settle();
-    },
-    async batch(selected: number[], initial: number[]) {
-      await act(async () => {
-        catalogue = selected;
-        await coordinator.loadOptions(request(EXPIRIES[1]), { forceRefresh: true });
-        catalogue = initial;
-        await coordinator.loadOptions(request(), { forceRefresh: true });
-      }); await settle();
-    },
-    async remount() {
-      await act(async () => setup!.renderer.destroy());
-      await act(async () => { setup = await testRender(<Harness />, { width, height: 18 }); }); await settle();
-    },
-    setWrongExpiry: (expiration: number | undefined) => { wrongExpiry = expiration; },
-    async switchUnderlying() {
-      await coordinator.loadSnapshot({ symbol: "MSFT", exchange: "" });
-      await act(async () => switchTicker(ticker("MSFT", 1)));
-      await settle();
-    },
-  };
-}
-
-test.each([48, 80, 120])("retains a chosen expiry across unchanged, reordered and shortened catalogues at %i columns", async (width) => {
-  const f = await fixture(width);
-  await f.key("enter"); await f.key("right");
-  for (const [label, catalogue] of [
-    ["chosen", EXPIRIES], ["reordered", [EXPIRIES[2]!, EXPIRIES[0]!, EXPIRIES[1]!]], ["prior-removed", EXPIRIES.slice(1)],
-  ] as const) {
-    await f.refresh([...catalogue]);
-    const result = await f.capture(label);
-    expect(result.launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-    expect(result.launch?.marketPrice).toBe(20);
-    expect(result.csv).toContain("19.00,21.00,10.0%,20.00");
-    expect(result.frame).not.toContain("AAPL261120");
-  }
-});
-
-test("selected-chain refresh uses the same date identities for the catalogue, table and navigation", async () => {
-  const f = await fixture(); await f.key("enter"); await f.key("right");
-  await f.refresh(EXPIRIES.slice(1), EXPIRIES[1]);
-  const selected = await f.capture("selected-query-refresh");
-  expect(selected.launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-  await f.key("right");
-  expect((await f.capture("next-after-refresh")).launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-});
-
-test.each([48, 80, 120])("a removed selected expiry cannot seed another contract and can recover at %i columns", async (width) => {
-  const f = await fixture(width); await f.key("enter"); await f.key("right");
-  await f.refresh([EXPIRIES[0]!, EXPIRIES[2]!]);
-  const missing = await f.capture("selected-removed");
-  expect(missing.launch).toBeUndefined();
-  expect(missing.frame).toContain("Selected expiration unavailable.");
-  expect(missing.csv.split("\n")).toHaveLength(1);
-  await f.refresh(EXPIRIES);
-  const recovered = await f.capture("selected-recovered");
-  expect(recovered.launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-  expect(recovered.frame).not.toContain("Selected expiration unavailable.");
-});
-
-test("a new underlying initializes its held expiry after a researcher chose another date", async () => {
-  const f = await fixture(80, 1);
-  expect((await f.capture("held-initial")).launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-  await f.key("enter"); await f.key("right");
-  expect((await f.capture("held-roll")).launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-  await f.switchUnderlying();
-  const changed = await f.capture("new-underlying");
-  expect(changed.launch?.symbol).toBe("MSFT");
-  expect(changed.launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-  expect(changed.frame).not.toContain("AAPL");
-});
-
-test("repeated surface handoffs override persisted local choices without resetting ordinary selection", async () => {
-  const f = await fixture();
-  await f.handoff(EXPIRIES[1]!);
-  expect((await f.capture("first-handoff")).launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-  await f.key("enter"); await f.key("right");
-  expect(f.state.config.layout.instances[0]!.settings?.expiration).toBe(EXPIRIES[2]);
-  await f.refresh(EXPIRIES);
-  expect((await f.capture("local-after-handoff")).launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-  await f.remount();
-  expect((await f.capture("persisted-local-choice")).launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-  await f.handoff(EXPIRIES[1]!);
-  expect((await f.capture("repeated-handoff")).launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-  await f.handoff(EXPIRIES[0]!);
-  expect((await f.capture("changed-handoff")).launch?.marketReference?.expiration).toBe(EXPIRIES[0]);
-  await f.switchUnderlying();
-  expect((await f.capture("handoff-target-changed")).launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-});
-
-test("a saved surface seed waits for ticker hydration before claiming its instrument scope", async () => {
-  const f = await fixture(80, 0, false, EXPIRIES[2]);
-  expect(f.state.config.layout.instances[0]!.settings?.expirationTargetKey).toBeUndefined();
-  // A bound symbol without a saved record (a shared layout) still shows its chain.
-  expect((await f.capture("unsaved-ticker")).frame).not.toContain("No ticker selected");
-  expect(f.state.config.layout.instances[0]!.settings?.expirationTargetKey).toBeUndefined();
-  await f.hydrateTicker();
-  expect((await f.capture("hydrated-handoff")).launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-  expect(f.state.config.layout.instances[0]!.settings?.expirationTargetKey).toContain("AAPL");
-});
-
-test("late and wrong-expiry responses cannot replace a newly selected contract", async () => {
-  const f = await fixture();
-  let finish: (chain: OptionsChain) => void = () => {};
-  f.pending.set(EXPIRIES[1]!, new Promise((resolve) => { finish = resolve; }));
-  await f.key("enter"); await f.key("right");
-  const loading = await f.capture("cold-expiry");
-  expect(loading.launch).toBeUndefined();
-  expect(loading.csv.split("\n")).toHaveLength(1);
-  await f.key("right");
-  expect((await f.capture("newer-selection")).launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-  await act(async () => finish(f.chain("AAPL", EXPIRIES[1]!))); await settle();
-  expect((await f.capture("late-response")).launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-  f.setWrongExpiry(EXPIRIES[1]);
-  await f.refresh(EXPIRIES, EXPIRIES[2]);
-  const wrong = await f.capture("wrong-expiry");
-  expect(wrong.launch).toBeUndefined();
-  expect(wrong.frame).toContain("Selected expiration unavailable.");
-  expect(wrong.csv.split("\n")).toHaveLength(1);
-});
-
-
-test("same-millisecond catalogue refresh retains a removed selection as unavailable", async () => {
-  const f = await fixture(); await f.key("enter"); await f.key("right");
-  await f.refresh([EXPIRIES[0]!, EXPIRIES[2]!], undefined, false);
-  const removed = await f.capture("equal-time-removal");
-  expect(removed.launch).toBeUndefined();
-  expect(removed.frame).toContain("Selected expiration unavailable.");
-  await f.refresh(EXPIRIES, undefined, false);
-  expect((await f.capture("equal-time-recovery")).launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-});
-
-test("visiting a cached expiry cannot restore an older catalogue, and an empty refresh disables the selected contract", async () => {
-  const f = await fixture(); await f.key("enter"); await f.key("right"); await f.key("right");
-  await f.key("left");
-  await f.refresh(EXPIRIES.slice(1), EXPIRIES[1]);
-  await f.key("right");
-  const cached = await f.capture("cached-expiry");
-  expect(cached.launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-  expect(cached.frame).not.toContain("Sep 18 '26");
-  await f.refresh([], EXPIRIES[2]);
-  const empty = await f.capture("empty-catalogue");
-  expect(empty.launch).toBeUndefined();
-  expect(empty.frame).toContain("Selected expiration unavailable.");
-  expect(empty.csv.split("\n")).toHaveLength(1);
-});
-
-
-test("the existing expiry selector can leave an unavailable date for an explicitly chosen contract", async () => {
-  const f = await fixture(); await f.key("enter"); await f.key("right");
-  await f.refresh([EXPIRIES[0]!, EXPIRIES[2]!]);
-  expect((await f.capture("explicit-selection-before")).launch).toBeUndefined();
-  await f.key("right");
-  const selected = await f.capture("explicit-selection-after");
-  expect(selected.launch?.marketReference?.expiration).toBe(EXPIRIES[2]);
-  expect(selected.launch?.marketPrice).toBe(30);
-  expect(selected.frame).not.toContain("Selected expiration unavailable.");
-});
-
-
-test("an ordinary CachedQuery read cannot revive an expiry removed by a later same-time response", async () => {
-  const f = await fixture(80, 0, true); await f.key("enter"); await f.key("right");
-  await f.refresh([EXPIRIES[0]!, EXPIRIES[2]!], undefined, false);
-  expect((await f.capture("cached-read-removed")).launch).toBeUndefined();
-  const calls = f.requests.length;
-  await f.reread(EXPIRIES[1]);
-  const read = await f.capture("cached-read-retained");
-  expect(f.requests).toHaveLength(calls);
-  expect(read.launch).toBeUndefined();
-  expect(read.csv.split("\n")).toHaveLength(1);
-});
-
-test.each([false, true])("batched equal-time responses honor completion order with cached provider %s", async (cached) => {
-  const f = await fixture(80, 0, cached); await f.key("enter"); await f.key("right");
-  await f.batch(EXPIRIES, [EXPIRIES[0]!, EXPIRIES[2]!]);
-  const removed = await f.capture(`batch-${cached}`);
-  expect(removed.launch).toBeUndefined();
-  expect(removed.csv.split("\n")).toHaveLength(1);
-  await f.refresh(EXPIRIES, EXPIRIES[1], false);
-  expect((await f.capture(`batch-recovered-${cached}`)).launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-});
-
-test.each([false, true])("empty and removed catalogues survive failed refreshes and remount with cached provider %s", async (cached) => {
-  const f = await fixture(80, 1, cached);
-  expect((await f.capture(`remount-chosen-${cached}`)).launch?.marketReference?.expiration).toBe(EXPIRIES[1]);
-  for (const [label, dates] of [["removed", [EXPIRIES[0]!, EXPIRIES[2]!]], ["empty", []]] as const) {
-    f.setFailure(false);
-    await f.refresh([...dates], EXPIRIES[1]);
-    f.setFailure(true);
-    await f.refresh(EXPIRIES, EXPIRIES[1]);
-    await f.refresh(EXPIRIES);
-    await f.remount();
-    const remounted = await f.capture(`remount-${label}-${cached}`);
-    expect(remounted.launch).toBeUndefined();
-    expect(remounted.csv.split("\n")).toHaveLength(1);
-    expect(remounted.frame).toContain("Selected expiration unavailable.");
-  }
-});