gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/treasury-auctions/pane.test.tsx

@@ -1,174 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { act, useState } from "react";
-import { emitKeypress as emitTuiKeypress, testRender, type TestKeyEvent } from "../../../renderers/opentui/test-utils";
-import { appReducer, createInitialState, type AppAction, type AppState } from "../../../state/app/context";
-import { createTestPaneConfig, TestPaneProvider } from "../../../test-support/pane";
-import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import type { PluginPersistence } from "../../../types/plugin";
-import {
-  attachTreasuryAuctionsPersistence,
-  resetTreasuryAuctionsPersistence,
-} from "./cache";
-import { TreasuryAuctionsPane } from "./pane";
-import type { TreasuryAuction } from "./types";
-
-function auction(overrides: Partial<TreasuryAuction> & { secType: string; securityTerm: string }): TreasuryAuction {
-  return {
-    id: `${overrides.secType}|${overrides.auctionDate ?? "2026-08-12"}|${overrides.securityTerm}`,
-    auctionDate: "2026-08-12",
-    highInvestmentRate: null,
-    highYield: null,
-    avgMedYield: null,
-    highPrice: null,
-    lowPrice: null,
-    avgMedPrice: null,
-    bidToCoverRatio: null,
-    competitiveAccepted: null,
-    indirectAccepted: null,
-    primaryDealerAccepted: null,
-    totalAccepted: null,
-    offeringAmount: null,
-    ...overrides,
-  };
-}
-
-const AUCTIONS: TreasuryAuction[] = [
-  auction({
-    secType: "Bond",
-    securityTerm: "20-Year",
-    auctionDate: "2026-08-19",
-    offeringAmount: 16_000_000_000,
-  }),
-  auction({
-    secType: "Bill",
-    securityTerm: "13-Week",
-    auctionDate: "2026-08-17",
-    highInvestmentRate: 3.802,
-    bidToCoverRatio: 2.86,
-    competitiveAccepted: 80_000_000_000,
-    indirectAccepted: 48_000_000_000,
-    totalAccepted: 98_725_863_900,
-  }),
-  auction({
-    secType: "Note",
-    securityTerm: "10-Year",
-    auctionDate: "2026-08-12",
-    highYield: 4.683,
-    bidToCoverRatio: 2.53,
-    competitiveAccepted: 41_821_613_600,
-    indirectAccepted: 32_087_936_000,
-    primaryDealerAccepted: 3_597_810_000,
-    totalAccepted: 52_623_557_100,
-  }),
-];
-
-/** Fresh cache so the pane renders without touching the Treasury endpoint. */
-function seedCache(): void {
-  const record = { value: AUCTIONS, fetchedAt: Date.now(), stale: false,
-    staleAt: Date.now() + 60_000, expiresAt: Date.now() + 60_000 };
-  attachTreasuryAuctionsPersistence({
-    getResource: () => record,
-    setResource: () => record,
-  } as unknown as PluginPersistence);
-}
-
-let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
-
-afterEach(async () => {
-  resetTreasuryAuctionsPersistence();
-  if (!testSetup) return;
-  await act(async () => {
-    testSetup!.renderer.destroy();
-  });
-  testSetup = undefined;
-});
-
-const PANE_INSTANCE_ID = "treasury-auctions:test";
-const paneRuntime = createTestPluginRuntime();
-
-function Harness() {
-  // The filter tab and the open auction are pane state, so the harness needs a
-  // reducer; filtering dispatches both in the same batch.
-  const [paneState, setPaneState] = useState<AppState["paneState"]>({});
-  const state = createInitialState(createTestPaneConfig("/tmp/gloomberb-auctions-pane-test", {
-    paneId: "treasury-auctions", instanceId: PANE_INSTANCE_ID,
-  }));
-  state.paneState = paneState;
-  const dispatch = (action: AppAction) => setPaneState(
-    (current) => appReducer({ ...state, paneState: current }, action).paneState,
-  );
-  return (
-    <TestPaneProvider
-      state={state}
-      dispatch={dispatch}
-      paneId={PANE_INSTANCE_ID}
-      pluginId="macro"
-      runtime={paneRuntime}
-    >
-      <TreasuryAuctionsPane
-        paneId="treasury-auctions"
-        paneType="treasury-auctions"
-        focused
-        width={92}
-        height={20}
-      />
-    </TestPaneProvider>
-  );
-}
-
-async function renderSettled() {
-  await act(async () => {
-    await testSetup!.renderOnce();
-    await testSetup!.renderOnce();
-  });
-}
-
-const emitKeypress = (event: TestKeyEvent) => emitTuiKeypress(testSetup!, event);
-
-describe("TreasuryAuctionsPane", () => {
-  test("renders auction metrics and keeps one placeholder for unpublished results", async () => {
-    seedCache();
-    testSetup = await testRender(<Harness />, { width: 92, height: 20 });
-    await renderSettled();
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("13-Week");
-    expect(frame).toContain("3.802%");
-    expect(frame).toContain("2.86");
-    // Indirect share is derived, not reported.
-    expect(frame).toContain("60.0%");
-    // The 20-Year is announced but unpublished: every metric cell reads the
-    // same placeholder the reported-but-missing cells use.
-    expect(frame).toContain("20-Year");
-    expect(frame).not.toContain("pending");
-  });
-
-  test("opens a detail view for the selected auction", async () => {
-    seedCache();
-    testSetup = await testRender(<Harness />, { width: 92, height: 20 });
-    await renderSettled();
-
-    await emitKeypress({ name: "down", sequence: "\u001B[B" });
-    await emitKeypress({ name: "enter", sequence: "\r" });
-    await renderSettled();
-
-    const detail = testSetup.captureCharFrame();
-    expect(detail).toContain("Bill 13-Week");
-    expect(detail).toContain("Bid-to-cover");
-    expect(detail).toContain("Total accepted");
-  });
-
-  test("the filter key narrows the board to one security group", async () => {
-    seedCache();
-    testSetup = await testRender(<Harness />, { width: 92, height: 20 });
-    await renderSettled();
-
-    // all -> bills
-    await emitKeypress({ name: "f", sequence: "f" });
-    await renderSettled();
-
-    const bills = testSetup.captureCharFrame();
-    expect(bills).toContain("13-Week");
-    expect(bills).not.toContain("10-Year");
-  });
-});

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

@@ -1,179 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { MarketDataCoordinator } from "../../../market-data/coordinator";
-import type { QueryEntry } from "../../../market-data/result-types";
-import type { OptionsChain } from "../../../types/financials";
-import { createSurfaceDependencies, loadVolatilitySurface, selectSurfaceExpiries, type SurfaceLoaderDependencies } from "./client";
-import type { SurfaceSnapshot } from "./model";
-
-const now = Date.UTC(2026, 8, 22, 14);
-const expirations = Array.from({ length: 22 }, (_, index) => Date.UTC(2026, 9, index + 1) / 1000);
-const curve = [{ maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: "2026-09-21" }];
-const emptyChain = (dates = expirations): OptionsChain => ({ underlyingSymbol: "AAPL", expirationDates: dates, calls: [], puts: [] });
-const ready = (data: OptionsChain): QueryEntry<OptionsChain> => ({ phase: "ready", data, lastGoodData: data,
-  source: "test", fetchedAt: now, staleAt: now + 60_000, error: null, attempts: [] });
-
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  let reject!: (reason: unknown) => void;
-  const promise = new Promise<T>((a, b) => { resolve = a; reject = b; });
-  return { promise, resolve, reject };
-}
-async function settle() { await new Promise((resolve) => setTimeout(resolve, 0)); }
-
-describe("surface expiry selection", () => {
-  const daily = Array.from({ length: 40 }, (_, index) => Date.UTC(2026, 8, 23 + index) / 1000);
-  const days = (expiration: number) => (expiration * 1000 - now) / 86_400_000;
-
-  test("thins daily listings geometrically before filling from the longest skipped tenor", () => {
-    const selected = selectSurfaceExpiries(daily, 12, now);
-    expect(selected).toHaveLength(12);
-    expect(selected).toEqual([...selected].sort((a, b) => a - b));
-    // Nearest-first would stop inside two weeks; thinning reaches the end of the listing.
-    expect(days(selected.at(-1)!)).toBeGreaterThan(38);
-    expect(selected.slice(0, 4).map(days).every((value, index, all) => index === 0 || value >= all[index - 1]! * 1.35)).toBe(true);
-  });
-
-  test("a short catalogue is requested completely and a larger limit is a superset", () => {
-    const monthly = Array.from({ length: 10 }, (_, index) => Date.UTC(2026, 9 + index, 15) / 1000);
-    expect(selectSurfaceExpiries(monthly, 18, now)).toEqual(monthly);
-    const narrow = selectSurfaceExpiries(daily, 12, now), wide = selectSurfaceExpiries(daily, 24, now);
-    expect(narrow.every((expiration) => wide.includes(expiration))).toBe(true);
-    expect(wide).toHaveLength(24);
-  });
-});
-
-describe("surface loader", () => {
-  test("required expiry pins extend the geometric sample and reuse the exact chain cache", async () => {
-    const sample = selectSurfaceExpiries(expirations, 3, now);
-    const pin = expirations.find((expiration) => !sample.includes(expiration))!;
-    const missing = expirations.at(-1)! + 7 * 86400;
-    const calls: (number | undefined)[] = [];
-    const provider = { id: "pinned-expiry", getOptionsChain: async (_symbol: string, _exchange: string, expiration?: number) => {
-      calls.push(expiration); return emptyChain();
-    } } as unknown as ConstructorParameters<typeof MarketDataCoordinator>[0];
-    const coordinator = new MarketDataCoordinator(provider);
-    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
-    const deps = { now: () => now, loadYieldCurve: async () => curve, loadOptions: coordinator.loadOptions.bind(coordinator) };
-    await coordinator.loadOptions({ instrument, expirationDate: pin });
-    const result = await loadVolatilitySurface({ instrument, spot: 100, limit: 3, requiredExpiries: [pin, pin, missing, NaN] }, deps);
-    expect(result.expiries.map((expiry) => expiry.expiration)).toEqual([...sample, pin].sort((a, b) => a - b));
-    expect(result.requested).toBe(4);
-    expect(result.loaded).toBe(4);
-    expect(result.failures).toContainEqual({ expiration: missing, message: "Selected expiration unavailable in the current option catalogue" });
-    expect(calls.filter((expiration) => expiration === pin)).toHaveLength(1);
-    expect(calls).not.toContain(missing);
-    expect(calls.some((expiration) => Number.isNaN(expiration))).toBe(false);
-    coordinator.destroy();
-  });
-
-  test("caps default catalogue, publishes partial failures and bounds concurrency at four", async () => {
-    const outstanding = new Map<number, ReturnType<typeof deferred<QueryEntry<OptionsChain>>>>();
-    let active = 0, maximum = 0;
-    const snapshots: SurfaceSnapshot[] = [];
-    const deps: SurfaceLoaderDependencies = { now: () => now, loadYieldCurve: async () => curve,
-      loadOptions: async (request) => {
-        if (request.expirationDate == null) return ready(emptyChain());
-        active += 1; maximum = Math.max(maximum, active);
-        const gate = deferred<QueryEntry<OptionsChain>>();
-        outstanding.set(request.expirationDate, gate);
-        try { return await gate.promise; } finally { active -= 1; }
-      } };
-    const loading = loadVolatilitySurface({ instrument: { symbol: "AAPL" }, spot: 100, onSnapshot: (value) => snapshots.push(value) }, deps);
-    await settle();
-    expect(outstanding.size).toBe(4);
-    const [first, second] = [...outstanding.keys()].sort((a, b) => a - b) as [number, number];
-    outstanding.get(first)!.resolve(ready(emptyChain()));
-    outstanding.get(second)!.reject(new Error("one expiry failed"));
-    await settle();
-    expect(snapshots.some((snapshot) => snapshot.loaded === 1 && snapshot.phase === "partial")).toBe(true);
-    expect(snapshots.at(-1)!.failures[0]!.expiration).toBe(second);
-    const completed = new Set([first, second]);
-    while (completed.size < 18) {
-      for (const [expiry, gate] of outstanding) {
-        if (completed.has(expiry)) continue;
-        completed.add(expiry); gate.resolve(ready(emptyChain()));
-      }
-      await settle();
-    }
-    const result = await loading;
-    expect(maximum).toBe(4);
-    expect(result.catalogue).toHaveLength(22);
-    expect(result.requested).toBe(18);
-    expect(result.loaded).toBe(18);
-    expect(result.failed).toBe(1);
-    expect(result.expiries[1]!.state).toBe("error");
-    expect(result.expiries[0]!.state).toBe("empty");
-    expect(snapshots[0]!.loaded).toBe(0);
-  });
-
-  test("abort promptly rejects without scheduling or emitting superseded results", async () => {
-    const gate = deferred<QueryEntry<OptionsChain>>();
-    let calls = 0;
-    const snapshots: SurfaceSnapshot[] = [];
-    const controller = new AbortController();
-    const loading = loadVolatilitySurface({ instrument: { symbol: "AAPL" }, spot: 100,
-      signal: controller.signal, onSnapshot: (value) => snapshots.push(value) }, {
-      now: () => now, loadYieldCurve: async () => curve,
-      loadOptions: async (request) => { if (!request.expirationDate) return ready(emptyChain()); calls += 1; return gate.promise; },
-    });
-    await settle();
-    expect(calls).toBe(4);
-    controller.abort();
-    await expect(loading).rejects.toMatchObject({ name: "AbortError" });
-    const count = snapshots.length;
-    gate.resolve(ready(emptyChain()));
-    await settle();
-    expect(snapshots).toHaveLength(count);
-    expect(calls).toBe(4);
-  });
-
-  test("rate failure preserves loaded slices and source failures instead of substituting a rate", async () => {
-    const result = await loadVolatilitySurface({ instrument: { symbol: "AAPL" }, spot: 100, spotAsOf: "2026-09-22T13:59:00Z" }, {
-      now: () => now, loadYieldCurve: async () => { throw new Error("Treasury offline"); },
-      loadOptions: async () => ready(emptyChain(expirations.slice(0, 2))),
-    });
-    expect(result.loaded).toBe(2);
-    expect(result.expiries.every((expiry) => expiry.rate === null)).toBe(true);
-    expect(result.failures).toContainEqual({ expiration: null, message: "Treasury: Treasury offline" });
-    expect(result.spotAsOf).toBe("2026-09-22T13:59:00Z");
-  });
-
-  test("incremental loads share exact coordinator keys with an options monitor", async () => {
-    const fetched: (number | undefined)[] = [];
-    const provider = { id: "test", getOptionsChain: async (_symbol: string, _exchange: string, expiry?: number) => {
-      fetched.push(expiry); return emptyChain();
-    } } as unknown as ConstructorParameters<typeof MarketDataCoordinator>[0];
-    const coordinator = new MarketDataCoordinator(provider);
-    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
-    const deps = { now: () => now, loadYieldCurve: async () => curve,
-      loadOptions: coordinator.loadOptions.bind(coordinator) };
-    await coordinator.loadOptions({ instrument, expirationDate: expirations[0] });
-    await loadVolatilitySurface({ instrument, spot: 100 }, deps);
-    await loadVolatilitySurface({ instrument, spot: 100, limit: 22 }, deps);
-    expect(fetched).toHaveLength(23);
-    expect(fetched.filter((expiry) => expiry === expirations[0])).toHaveLength(1);
-    expect(new Set(fetched).size).toBe(23);
-  });
-
-  test("headless dependencies use the same coordinator loader and expose missing catalogue", async () => {
-    const marketData = { id: "headless", getOptionsChain: async () => { throw new Error("chain offline"); } } as unknown as ConstructorParameters<typeof MarketDataCoordinator>[0];
-    const deps = createSurfaceDependencies(marketData, { getCloudYieldCurve: async () => curve });
-    const result = await loadVolatilitySurface({ instrument: { symbol: "AAPL" }, spot: 100 }, { ...deps, now: () => now });
-    expect(result.phase).toBe("error");
-    expect(result.failures[0]!.message).toBe("chain offline");
-    expect(result.requested).toBe(0);
-  });
-
-  test("a forced surface refresh reuses the catalogue's proven first slice", async () => {
-    const calls: (number | undefined)[] = [];
-    const provider = { id: "test", getOptionsChain: async (_symbol: string, _exchange: string, expiry?: number) => {
-      calls.push(expiry);
-      return { ...emptyChain(expirations.slice(0, 2)), calls: [{ expiration: expiry ?? expirations[0], strike: 100, bid: 0, ask: 0 }] };
-    } } as unknown as ConstructorParameters<typeof MarketDataCoordinator>[0];
-    const coordinator = new MarketDataCoordinator(provider);
-    await loadVolatilitySurface({ instrument: { symbol: "AAPL" }, spot: 100, forceRefresh: true }, {
-      now: () => now, loadYieldCurve: async () => curve, loadOptions: coordinator.loadOptions.bind(coordinator),
-    });
-    expect(calls).toEqual([undefined, expirations[1]]);
-  });
-});

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

@@ -1,73 +0,0 @@
-import { expect, test } from "bun:test";
-import { fitVolatilitySmile } from "../shared/volatility";
-import { buildSurfaceGrid, DEFAULT_SURFACE_SETTINGS, pendingSurfaceExpiry, type SurfaceExpiry,
-  type SurfacePoint, type SurfaceSnapshot } from "./model";
-import { readVolSurfaceEvidence, volSurfaceSemanticEvidence, type VolSurfaceEvidenceInput } from "./evidence";
-
-function input(view = "surface"): VolSurfaceEvidenceInput {
-  const now = Date.UTC(2026, 8, 22);
-  const expiries: SurfaceExpiry[] = [Date.UTC(2026, 11, 18), Date.UTC(2027, 2, 19)].map((date) => {
-    const expiry = pendingSurfaceExpiry(date / 1000, now);
-    const points = [90, 100, 110].map((strike) => ({ strike, volatility: 0.25, logMoneyness: Math.log(strike / 100), fitResidual: 0 })) as SurfacePoint[];
-    return { ...expiry, state: "ready", points, forward: 100, rate: 0.04, dividendYield: 0.04,
-      rateAsOf: ["2026-09-21"], source: "test", asOf: "2026-09-22T13:45:00Z", atmIV: 0.25,
-      fit: fitVolatilitySmile(points, expiry.years) };
-  });
-  const snapshot: SurfaceSnapshot = { symbol: "AAPL", spot: 100, spotAsOf: "2026-09-22T14:00:00Z", phase: "ready",
-    settings: DEFAULT_SURFACE_SETTINGS, requested: 2, loaded: 2, failed: 0, failures: [], warnings: [],
-    catalogue: expiries.map((expiry) => expiry.expiration), expiries, rateAsOf: "2026-09-21", fetchedAt: now };
-  return { snapshot, view, selectedExpiry: expiries[0]!, grid: buildSurfaceGrid(snapshot, { coordinates: [0.9, 1, 1.1] }),
-    loading: false, bitmapAvailable: true, axis: "forward", tenors: "listed", overlaySmiles: false };
-}
-
-test("surface evidence requires finite plotted quads backed by source observations", () => {
-  const rendered = input();
-  const evidence = volSurfaceSemanticEvidence(rendered);
-  expect(evidence.plottedValueCount).toBe(6);
-  expect(evidence.validQuadCount).toBe(2);
-  expect(evidence.complete).toBe(true);
-  expect(readVolSurfaceEvidence(evidence)).not.toBeNull();
-  expect(evidence.spotAsOf).toBe("2026-09-22T14:00:00Z");
-  expect(evidence.expiries[0]!.asOf).toBe("2026-09-22T13:45:00Z");
-  const singleRow = { ...rendered, grid: { ...rendered.grid!, rows: rendered.grid!.rows.slice(0, 1),
-    tenors: rendered.grid!.tenors.slice(0, 1), volatilities: rendered.grid!.volatilities.slice(0, 1) } };
-  expect(readVolSurfaceEvidence(volSurfaceSemanticEvidence(singleRow))).toBeNull();
-  expect(readVolSurfaceEvidence(volSurfaceSemanticEvidence({ ...singleRow, bitmapAvailable: false }))).not.toBeNull();
-  expect(readVolSurfaceEvidence({ ...evidence, plottedValueCount: 99 })).toBeNull();
-  expect(readVolSurfaceEvidence({ ...evidence, sourcePointCount: 0 })).toBeNull();
-  expect(readVolSurfaceEvidence({ ...evidence, grid: { ...evidence.grid!, values: [[null, null, null], [null, null, null]] } })).toBeNull();
-});
-
-test("partial, loading, rejected and stale expiry states cannot claim complete captures", () => {
-  const rendered = input();
-  const snapshot = rendered.snapshot!;
-  for (const changed of [
-    { ...snapshot, loaded: 1 },
-    { ...snapshot, failed: 1, failures: [{ expiration: snapshot.expiries[0]!.expiration, message: "offline" }] },
-    { ...snapshot, expiries: [{ ...snapshot.expiries[0]!, state: "empty" as const }, snapshot.expiries[1]!] },
-    { ...snapshot, expiries: [{ ...snapshot.expiries[0]!, stale: true }, snapshot.expiries[1]!] },
-  ]) {
-    const evidence = volSurfaceSemanticEvidence({ ...rendered, snapshot: changed });
-    expect(evidence.complete).toBe(false);
-    expect(readVolSurfaceEvidence({ ...evidence, complete: true })).toBeNull();
-  }
-  expect(volSurfaceSemanticEvidence({ ...rendered, loading: true }).complete).toBe(false);
-  expect(readVolSurfaceEvidence(volSurfaceSemanticEvidence({ ...rendered, snapshot: null, grid: null }))).toBeNull();
-});
-
-test("smile and term evidence follow the active plotted series and reject a wrong selected expiry", () => {
-  const smile = volSurfaceSemanticEvidence(input("smile"));
-  expect(smile.plottedValueCount).toBe(3);
-  expect(smile.sourcePointCount).toBe(3);
-  expect(smile.grid).toBeNull();
-  expect(readVolSurfaceEvidence(smile)).not.toBeNull();
-  expect(readVolSurfaceEvidence({ ...smile, selectedExpiration: 1 })).toBeNull();
-  const rendered = input("term");
-  const term = volSurfaceSemanticEvidence(rendered);
-  expect(term.plottedValueCount).toBe(2);
-  expect(term.term.map((point) => point.atm)).toEqual([0.25, 0.25]);
-  expect(readVolSurfaceEvidence(term)).not.toBeNull();
-  const empty = volSurfaceSemanticEvidence({ ...rendered,
-    snapshot: { ...rendered.snapshot!, expiries: rendered.snapshot!.expiries.map((expiry) => ({ ...expiry, atmIV: null })) } });
-  expect(readVolSurfaceEvidence(empty)).toBeNull();
-});

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

@@ -1,95 +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 type { YieldPoint } from "../yield-curve/treasury-data";
-import { stableSurfaceSheet, surfaceFreshnessLabel, type SurfaceSheetAxes } from "./live";
-import { buildSurfaceExpiry, buildSurfaceGrid, DEFAULT_SURFACE_SETTINGS, SURFACE_3D_DELTAS, withSurfaceTermSlopes,
-  type SurfaceSnapshot } from "./model";
-import { volatilitySurfaceInput } from "./raster";
-
-const now = Date.parse("2026-09-23T15:00:00Z");
-const curve: YieldPoint[] = [{ maturity: "1M", maturityYears: 1 / 12, yield: 4, asOf: "2026-09-22" },
-  { maturity: "3Y", maturityYears: 3, yield: 4, asOf: "2026-09-22" }];
-const expirations = [30, 60, 95, 190, 370, 740].map((days) => Date.UTC(2026, 8, 23 + days) / 1000);
-
-function chain(expiration: number, quoted: boolean): OptionsChain {
-  const days = daysToExpiryFrom(expiration, now);
-  const contract = (strike: number, side: "call" | "put"): OptionContract => {
-    const volatility = 0.25 + 0.4 * Math.log(strike / 100) ** 2;
-    const price = valueOption({ ...DEFAULT_OPTION_CALC_DRAFT, side, spot: 100, strike, daysToExpiry: days,
-      volatility, rate: 0.04, dividendYield: 0 }).price;
-    return { contractSymbol: `T-${expiration}-${side}-${strike}`, strike, expiration, currency: "USD", lastPrice: price,
-      bid: quoted ? price * 0.995 : 0, ask: quoted ? price * 1.005 : 0, impliedVolatility: volatility, openInterest: 100,
-      volume: 1, lastTradeDate: now / 1000 - 60, change: 0, percentChange: 0, inTheMoney: false };
-  };
-  const strikes = Array.from({ length: 13 }, (_, index) => 70 + index * 5);
-  return { underlyingSymbol: "T", expirationDates: expirations, asOf: new Date(now).toISOString(), dataSource: "live",
-    calls: strikes.map((strike) => contract(strike, "call")), puts: strikes.map((strike) => contract(strike, "put")) };
-}
-
-function snapshot(spot: number, unquoted: number[] = [], requested = expirations.length): SurfaceSnapshot {
-  const expiries = withSurfaceTermSlopes(expirations.map((expiration) => buildSurfaceExpiry({
-    chain: chain(expiration, !unquoted.includes(expiration)), expiration, spot, curve, now })));
-  return { symbol: "T", spot, phase: "ready", settings: DEFAULT_SURFACE_SETTINGS, catalogue: expirations, requested,
-    loaded: expirations.length, failed: 0, expiries, failures: [], warnings: [], rateAsOf: null, fetchedAt: now };
-}
-
-function deltaGrid(sheet: ReturnType<typeof stableSurfaceSheet<SurfaceSnapshot>>) {
-  return buildSurfaceGrid(sheet.snapshot, sheet.tenors
-    ? { axis: "delta", tenors: "fixed", fixedTenors: sheet.tenors, coordinates: SURFACE_3D_DELTAS }
-    : { axis: "delta", tenors: "listed", coordinates: SURFACE_3D_DELTAS });
-}
-
-test("a reload over the same expiries keeps the sheet's rows and columns so it can morph", () => {
-  const first = stableSurfaceSheet(snapshot(100), null);
-  expect(first.axes).not.toBeNull();
-  const firstGrid = deltaGrid(first);
-  expect(firstGrid.tenors.at(-1)).toBe(2);
-
-  // The longest slice loses its quotes and the spot moves: fitted from
-  // scratch, the sheet would stop at one year and change shape.
-  const reloaded = snapshot(101, [expirations.at(-1)!]);
-  expect(stableSurfaceSheet(reloaded, null).tenors!.at(-1)!.label).toBe("1Y");
-  const kept = stableSurfaceSheet(reloaded, first.axes);
-  const keptGrid = deltaGrid(kept);
-  expect(keptGrid.tenors).toEqual(firstGrid.tenors);
-  expect(keptGrid.moneyness).toEqual(firstGrid.moneyness);
-  expect(keptGrid.volatilities.map((row) => row.length)).toEqual(firstGrid.volatilities.map((row) => row.length));
-  expect(keptGrid.volatilities).not.toEqual(firstGrid.volatilities);
-
-  // Another expiry set, or a load still in progress, chooses afresh and pins nothing.
-  const other: SurfaceSheetAxes = { ...first.axes!, identity: "T|1,2,3" };
-  expect(stableSurfaceSheet(reloaded, other).tenors!.at(-1)!.label).toBe("1Y");
-  expect(stableSurfaceSheet(snapshot(100, [], expirations.length + 1), first.axes).axes).toBeNull();
-});
-
-test("a smile whose fit falls back on reload leaves the sheet instead of drawing a hole", () => {
-  const first = stableSurfaceSheet(snapshot(100), null);
-  const reloaded = snapshot(100);
-  const fellBack = { ...reloaded, expiries: reloaded.expiries.map((entry, index) => index === 2
-    ? { ...entry, fit: { ...entry.fit!, method: "monotone-cubic" as const } } : entry) };
-  const kept = stableSurfaceSheet(fellBack, first.axes);
-  expect(kept.snapshot.expiries.map((entry) => entry.expiration)).not.toContain(expirations[2]);
-  expect(kept.omitted.map((entry) => entry.expiration)).toEqual([expirations[2]!]);
-  // The delta sheet keeps its constant maturities, interpolated across the gap.
-  expect(deltaGrid(kept).tenors).toEqual(deltaGrid(first).tenors);
-});
-
-test("a reloaded sheet inside the drawn range keeps the box and colour scale", () => {
-  const grid = (lift: number) => ({ tenors: [0.1, 0.5], moneyness: [0.9, 1, 1.1],
-    volatilities: [[0.3 + lift, 0.25 + lift, 0.27 + lift], [0.29 + lift, 0.26 + lift, 0.28 + lift]] });
-  const drawn = volatilitySurfaceInput(grid(0), null);
-  const nudged = volatilitySurfaceInput(grid(0.004), null, drawn);
-  expect([nudged.zMin, nudged.zMax]).toEqual([drawn.zMin, drawn.zMax]);
-  const jumped = volatilitySurfaceInput(grid(0.2), null, drawn);
-  expect(jumped.zMax).toBeGreaterThan(drawn.zMax);
-});
-
-test("the footer names the quotes' basis and never calls a delayed or mixed surface real-time", () => {
-  const live = snapshot(100);
-  expect(surfaceFreshnessLabel(live, 15)).toBe("real-time · as of 15:00:00 UTC");
-  const mixed = { ...live, expiries: live.expiries.map((entry, index) => index ? entry : { ...entry, dataSource: "delayed" as const, delayMinutes: 15 }) };
-  expect(surfaceFreshnessLabel(mixed, 15)).toStartWith("mixed real-time and delayed");
-  const delayed = { ...live, expiries: live.expiries.map((entry) => ({ ...entry, dataSource: "delayed" as const, delayMinutes: 20 })) };
-  expect(surfaceFreshnessLabel(delayed, 15)).toStartWith("20m delayed");
-});