gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/shared/volatility/options.test.ts

@@ -1,127 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { DEFAULT_OPTION_CALC_DRAFT, solveImpliedVolatility, valueOption } from "../../options-calculator/model";
-import { expectedMove, extractImpliedForward, forwardFromCarry, logForwardMoneyness, optionDelta,
-  optionMid, smileSkew, strikeForDelta, strikeFromLogMoneyness, volatilityTermSlope } from "./options";
-
-const input = { spot: 100, years: 0.5, rate: 0.04, dividendYield: 0.015, volatility: 0.3 };
-function quote(strike: number, side: "call" | "put") {
-  const price = valueOption({ ...DEFAULT_OPTION_CALC_DRAFT, ...input, strike, side, daysToExpiry: input.years * 365 }).price;
-  return { strike, bid: price - 0.01, ask: price + 0.01, contractSymbol: `${side}${strike}` };
-}
-
-describe("delta and forward conversions", () => {
-  test("inverts signed call/put deltas with dividend carry and changing scale", () => {
-    for (const spot of [0.001, 100, 100_000]) {
-      for (const side of ["call", "put"] as const) {
-        for (const absolute of [0.1, 0.25, 0.8]) {
-          const target = side === "call" ? absolute : -absolute;
-          const strike = strikeForDelta({ ...input, spot }, target, side)!;
-          expect(optionDelta({ ...input, spot }, strike, side)).toBeCloseTo(target, 7);
-        }
-      }
-    }
-  });
-  test("rejects targets beyond dividend-discounted delta and expiry boundaries", () => {
-    expect(strikeForDelta({ ...input, dividendYield: 2 }, 0.5, "call")).toBeNull();
-    expect(strikeForDelta(input, 0.25, "put")).toBeNull();
-    expect(strikeForDelta(input, 0, "call")).toBeNull();
-    expect(strikeForDelta({ ...input, years: 0 }, 0.25, "call")).toBeNull();
-    expect(strikeForDelta({ ...input, volatility: NaN }, 0.25, "call")).toBeNull();
-  });
-  test("round trips forward log-moneyness without overflowing ratios", () => {
-    const forward = forwardFromCarry(100, 0.5, 0.04, 0.015)!;
-    expect(forward).toBeCloseTo(101.257845, 5);
-    expect(strikeFromLogMoneyness(logForwardMoneyness(120, forward)!, forward)).toBeCloseTo(120, 9);
-    expect(logForwardMoneyness(1e300, 1e-300)).toBeCloseTo(600 * Math.log(10), 8);
-    expect(strikeFromLogMoneyness(1000, 100)).toBeNull();
-    expect(forwardFromCarry(100, -1, 0.04)).toBeNull();
-  });
-});
-
-describe("parity forward", () => {
-  test("recovers carry from paired bracketing quotes and preserves contributing contracts", () => {
-    const strikes = [85, 90, 95, 100, 105, 110, 115];
-    const result = extractImpliedForward(strikes.map((k) => quote(k, "call")), strikes.map((k) => quote(k, "put")), 100, 0.5, 0.04);
-    expect(result.forward).toBeCloseTo(forwardFromCarry(100, 0.5, 0.04, 0.015)!, 6);
-    expect(result.dividendYield).toBeCloseTo(0.015, 6);
-    expect(result.pairs.map((pair) => pair.strike)).toEqual([95, 100, 105, 110]);
-    expect(result.pairs[0]?.call).toBe("call95");
-    expect(result.warnings).toEqual([]);
-  });
-  test("missing side never invents a measured forward, one valid pair is marked partial", () => {
-    expect(extractImpliedForward([quote(100, "call")], [], 100, 0.5, 0.04).forward).toBeNull();
-    const one = extractImpliedForward([quote(100, "call")], [quote(100, "put")], 100, 0.5, 0.04);
-    expect(one.forward).not.toBeNull();
-    expect(one.warnings).toContain("Parity strikes do not bracket spot");
-    expect(optionMid({ bid: 0, ask: 2 })).toBeNull();
-    expect(optionMid({ bid: 2, ask: 1 })).toBeNull();
-    expect(extractImpliedForward([quote(100, "call")], [quote(100, "put")], 100, 0, 0.04).forward).toBeNull();
-  });
-  test("median resists one corrupt pair and warns about disjoint quote intervals", () => {
-    const strikes = [95, 100, 105];
-    const calls = strikes.map((k) => quote(k, "call"));
-    calls[0] = { ...calls[0]!, bid: 30, ask: 30.02 };
-    const result = extractImpliedForward(calls, strikes.map((k) => quote(k, "put")), 100, 0.5, 0.04);
-    expect(result.forward).toBeCloseTo(forwardFromCarry(100, 0.5, 0.04, 0.015)!, 6);
-    expect(result.warnings).toContain("Parity forward quote intervals disagree");
-  });
-  test("stale far-strike pairs cannot set a forward far from spot carry", () => {
-    // Quotes left on pre-split contracts implied a forward of 5.5x spot.
-    const stale = (strike: number, call: number, put: number) => [
-      { strike, bid: call - 8, ask: call + 8, contractSymbol: `call${strike}` },
-      { strike, bid: put - 1, ask: put + 1, contractSymbol: `put${strike}` },
-    ] as const;
-    const pairs = [stale(470, 820, 24), stale(480, 814, 25)];
-    const result = extractImpliedForward(pairs.map(([call]) => call), pairs.map(([, put]) => put), 229, 0.24, 0.04);
-    expect(result.forward).toBeNull();
-    expect(result.warnings).toEqual(["Parity forwards are inconsistent with spot"]);
-    // VIX options settle on a future that can trade far from the spot index.
-    const vix = extractImpliedForward(pairs.map(([call]) => call), pairs.map(([, put]) => put), 229, 0.24, 0.04, "^VIX");
-    expect(vix.forward).not.toBeNull();
-    // A stale pair nearest spot is skipped for the next valid strike.
-    const strikes = [90, 95, 100, 110, 115];
-    const [call105, put105] = stale(105, 400, 1);
-    const mixed = extractImpliedForward([...strikes.map((k) => quote(k, "call")), call105],
-      [...strikes.map((k) => quote(k, "put")), put105], 100, 0.5, 0.04);
-    expect(mixed.pairs.map((pair) => pair.strike)).toEqual([95, 100, 110, 115]);
-    expect(mixed.forward).toBeCloseTo(forwardFromCarry(100, 0.5, 0.04, 0.015)!, 6);
-  });
-  test("the existing IV solver recovers volatility when forward is the underlying", () => {
-    const forward = forwardFromCarry(input.spot, input.years, input.rate, input.dividendYield)!;
-    // Setting q=r gives discounted Black forward pricing without duplicating a pricer.
-    const draft = { ...DEFAULT_OPTION_CALC_DRAFT, ...input, spot: forward, strike: 110,
-      daysToExpiry: input.years * 365, dividendYield: input.rate };
-    const mid = (quote(110, "call").bid + quote(110, "call").ask) / 2;
-    expect(solveImpliedVolatility(draft, mid).volatility).toBeCloseTo(input.volatility, 6);
-    expect(solveImpliedVolatility(draft, forward + 1).volatility).toBeNull();
-  });
-});
-
-test("expected move uses a same-strike ATM straddle and separate one-sigma estimate", () => {
-  const call = quote(100, "call"), put = quote(100, "put");
-  const move = expectedMove([call], [put], 100, 0.5, 0.3);
-  expect(move.straddle).toBeCloseTo(optionMid(call)! + optionMid(put)!, 9);
-  expect(move.sigma).toBeCloseTo(100 * 0.3 * Math.sqrt(0.5), 8);
-  expect(move.sigmaPercent).toBe(move.sigma);
-  expect(expectedMove([quote(90, "call")], [quote(110, "put")], 100, 0.5, 0.3).straddle).toBeNull();
-  expect(expectedMove([quote(110, "call")], [quote(110, "put")], 100, 0.5, 0.3).straddle).toBeNull();
-  expect(expectedMove([], [], 100, 0, 0.3).sigma).toBe(0);
-  expect(expectedMove([quote(105, "call")], [quote(105, "put")], 100, 0.5, 0.3).straddle).not.toBeNull();
-  const huge = { strike: 100, bid: 1e308, ask: 1e308 };
-  expect(expectedMove([huge], [huge], 100, 0.5, 0.3).straddle).toBeNull();
-});
-
-test("skew signs distinguish put premium from conventional call-minus-put risk reversal", () => {
-  const flat = smileSkew(input, () => 0.3);
-  expect(flat.put25).toBeCloseTo(0.3, 8);
-  expect(flat.butterfly).toBe(0);
-  expect(smileSkew({ spot: 100, years: 1, rate: 0 }, () => 2).call25).toBeCloseTo(2, 8);
-  expect(Object.values(smileSkew({ ...input, spot: NaN }, () => 0.3)).every((value) => value === null)).toBe(true);
-  const smile = (strike: number) => 0.3 - 0.03 * Math.log(strike / 100);
-  const skew = smileSkew(input, smile);
-  expect(skew.putCallSkew!).toBeGreaterThan(0);
-  expect(skew.riskReversal).toBe(-skew.putCallSkew!);
-  expect(skew.moneynessSkew).toBeCloseTo(smile(90) - smile(110), 9);
-  expect(volatilityTermSlope({ years: 0.25, volatility: 0.4 }, { years: 0.5, volatility: 0.3 })).toBeCloseTo(-0.4, 9);
-  expect(volatilityTermSlope({ years: 0.5, volatility: 0.4 }, { years: 0.5, volatility: 0.3 })).toBeNull();
-});

package/src/plugins/builtin/shared/volatility/realized.test.ts

@@ -1,201 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { PricePoint } from "../../../../types/financials";
-import {
-  realizedVolatility,
-  realizedVolatilityCadenceIssue,
-  realizedVolatilityResult,
-  rollingRealizedVolatility,
-  volatilityCone,
-  type RealizedVolatilityEstimator,
-} from "./realized";
-
-function history(returns: readonly number[]): PricePoint[] {
-  const points: PricePoint[] = [{ date: new Date(Date.UTC(2025, 0, 1)), close: 100 }];
-  for (const [index, value] of returns.entries()) {
-    points.push({ date: new Date(Date.UTC(2025, 0, index + 2)), close: points.at(-1)!.close * Math.exp(value) });
-  }
-  return points;
-}
-
-function rangeHistory(length: number): PricePoint[] {
-  return Array.from({ length }, (_, index) => ({
-    date: new Date(Date.UTC(2025, 0, index + 1)),
-    open: 100,
-    high: 100 * Math.exp(0.03),
-    low: 100 * Math.exp(-0.02),
-    close: 100 * Math.exp(0.01),
-  }));
-}
-
-describe("realized volatility estimators", () => {
-  test("close-to-close uses n centered returns and sample variance", () => {
-    // Mean log return 0.02, sample variance 0.0006.
-    const points = history([0.01, -0.01, 0.04, 0.04]);
-    expect(realizedVolatility(points, 4)).toBeCloseTo(Math.sqrt(0.0006 * 252), 12);
-    expect(realizedVolatility(points.slice(1), 4)).toBeNull();
-    expect(realizedVolatility(points, 2)).toBeCloseTo(0, 12);
-    expect(realizedVolatility(history([0.02, 0.02, 0.02]), 3)).toBeCloseTo(0, 12);
-    for (const window of [0, 1, -3, 2.5, NaN, Infinity]) {
-      expect(realizedVolatilityResult(points, window).reason).toBe("invalid-window");
-    }
-  });
-
-  test("range estimates agree with analytic log-OHLC examples and require n bars", () => {
-    const points = rangeHistory(3);
-    expect(realizedVolatility(points, 3, "parkinson")).toBeCloseTo(Math.sqrt(252 * 0.05 ** 2 / (4 * Math.LN2)), 12);
-    expect(realizedVolatility(points, 3, "garman-klass")).toBeCloseTo(Math.sqrt(252 * (0.5 * 0.05 ** 2 - (2 * Math.LN2 - 1) * 0.01 ** 2)), 12);
-    expect(realizedVolatility(points, 3, "rogers-satchell")).toBeCloseTo(Math.sqrt(252 * 0.0012), 12);
-    expect(realizedVolatility(points, 3, "close-to-close")).toBeNull();
-    for (const estimator of ["parkinson", "garman-klass", "rogers-satchell"] as const) {
-      expect(realizedVolatility(points.slice(1), 3, estimator)).toBeNull();
-    }
-  });
-
-  test("Yang-Zhang combines centered overnight and intraday variance with Rogers-Satchell", () => {
-    const points: PricePoint[] = [{ date: new Date(Date.UTC(2025, 0, 1)), close: 100 }];
-    const overnight = [0.01, -0.02, 0.015];
-    const intraday = [0.02, -0.01, 0.005];
-    for (let index = 0; index < 3; index += 1) {
-      const open = points.at(-1)!.close * Math.exp(overnight[index]!);
-      const close = open * Math.exp(intraday[index]!);
-      points.push({
-        date: new Date(Date.UTC(2025, 0, index + 2)), open, close,
-        high: Math.max(open, close) * Math.exp(0.012),
-        low: Math.min(open, close) * Math.exp(-0.013),
-      });
-    }
-    const weight = 0.34 / 3.34;
-    // Overnight sample variance = 0.000358333..., intraday = 0.000225.
-    // Daily RS = 0.000813, 0.000563, 0.000438.
-    const expected = Math.sqrt(252 * (0.0003583333333333333 + weight * 0.000225 + (1 - weight) * (0.000813 + 0.000563 + 0.000438) / 3));
-    expect(realizedVolatility(points, 3, "yang-zhang")).toBeCloseTo(expected, 12);
-    expect(realizedVolatility(points.slice(1), 3, "yang-zhang")).toBeNull();
-  });
-
-  test("Yang-Zhang sees opening jumps that intraday range estimators cannot see", () => {
-    const points = history([0.1, -0.1, 0.1, -0.1]).map((point) => ({ ...point, open: point.close, high: point.close, low: point.close }));
-    expect(realizedVolatility(points, 4, "yang-zhang")).toBeCloseTo(realizedVolatility(points, 4)!, 12);
-    expect(realizedVolatility(points, 4, "yang-zhang")).toBeGreaterThan(1);
-    for (const estimator of ["parkinson", "garman-klass", "rogers-satchell"] as const) {
-      expect(realizedVolatility(points, 4, estimator)).toBe(0);
-    }
-  });
-});
-
-describe("history integrity and rolling windows", () => {
-  test("daily cadence guard recognizes corrected chronology and rejects contradictory fallback bars", () => {
-    const daily = rangeHistory(10);
-    expect(realizedVolatilityCadenceIssue([...daily, daily[4]!].reverse())).toBeNull();
-    const weekly = daily.map((point, index) => ({ ...point, date: new Date(Date.UTC(2025, 0, 1 + index * 7)) }));
-    expect(realizedVolatilityCadenceIssue(weekly)).toContain("weekly");
-    expect(realizedVolatilityCadenceIssue([...daily, { date: new Date(Date.UTC(2025, 0, 1, 14)) }])).toContain("intraday");
-    expect(realizedVolatilityCadenceIssue([...daily, { date: new Date(NaN) }])).toContain("invalid history date");
-    // One holiday gap in otherwise daily observations does not imply weekly data.
-    expect(realizedVolatilityCadenceIssue([...daily, { date: new Date(Date.UTC(2025, 0, 15)) }])).toBeNull();
-  });
-
-  test("preserves invalid observations as gaps and recovers after they leave the window", () => {
-    const points = history([0.01, -0.01, 0.02, -0.02, 0.01, -0.01]);
-    const broken = { ...points[2]!, high: 80, low: 120 };
-    points[2] = broken;
-    const result = realizedVolatilityResult(points.slice(0, 5), 2);
-    expect(result.reason).toBe("inconsistent-ohlc");
-    expect(result.integrity!.sourcePoints[0]!.high).toBe(80);
-    broken.high = 90;
-    expect(result.integrity!.sourcePoints[0]!.high).toBe(80);
-    expect(Object.isFrozen(result.integrity!.sourcePoints[0])).toBe(true);
-    const series = rollingRealizedVolatility(points, { windows: [2] });
-    expect(series.map((point) => point.values[2] === null)).toEqual([true, true, true, true, true, false, false]);
-    expect(series.at(-1)!.values[2]).toBeCloseTo(realizedVolatility(points.slice(-3), 2)!, 12);
-  });
-
-  test("does not substitute older observations for invalid closes or incomplete OHLC", () => {
-    const points = rangeHistory(4);
-    for (const close of [0, -1, NaN, Infinity]) {
-      expect(realizedVolatility([...points, { ...points[3]!, close }], 2)).toBeNull();
-    }
-    const closeOnly = points.map(({ date, close }) => ({ date, close }));
-    expect(realizedVolatility(closeOnly, 2)).toBe(0);
-    for (const estimator of ["parkinson", "garman-klass", "rogers-satchell", "yang-zhang"] as const) {
-      expect(realizedVolatilityResult(closeOnly, 2, estimator).reason).toBe("missing-ohlc");
-    }
-    const noOpen = points.map((point) => ({ ...point, open: undefined }));
-    expect(realizedVolatility(noOpen, 3, "parkinson")).toBeGreaterThan(0);
-    expect(realizedVolatility(noOpen, 3, "garman-klass")).toBeNull();
-  });
-
-  test("deduplicates persisted corrections and sorts before choosing observations", () => {
-    const good = history([0.01, -0.02, 0.03, -0.04]);
-    const broken = { ...good[2]!, close: 0 };
-    const corrected = [broken, ...good].map((point) => ({ ...point, date: point.date.toISOString() as unknown as Date }));
-    expect(realizedVolatility(corrected, 4)).toBeCloseTo(realizedVolatility(good, 4)!, 12);
-    expect(realizedVolatility([...good].reverse(), 4)).toBeCloseTo(realizedVolatility(good, 4)!, 12);
-    expect(realizedVolatility([...good, broken], 4)).toBeNull();
-    expect(realizedVolatility(good.slice(1).flatMap((point) => [point, point]), 4)).toBeNull();
-    expect(realizedVolatilityResult([...good, { date: new Date(NaN), close: 100 }], 4).reason).toBe("invalid-date");
-  });
-
-  test("retains finite extreme prices without overflowing ratios", () => {
-    const points = history([0, 0, 0, 0]).map((point, index) => ({ ...point, close: index % 2 ? 1e300 : 1e-300 }));
-    expect(realizedVolatility(points, 4)).toBeFinite();
-    const flat = points.map((point) => ({ ...point, close: 1e300, open: 1e300, high: 1e300, low: 1e300 }));
-    for (const estimator of ["close-to-close", "parkinson", "garman-klass", "rogers-satchell", "yang-zhang"] satisfies RealizedVolatilityEstimator[]) {
-      expect(realizedVolatility(flat, 4, estimator)).toBe(0);
-    }
-    const wideRange = flat.map((point) => ({ ...point, high: 1e300, low: 1e-300, close: 100, open: 100 }));
-    for (const estimator of ["parkinson", "garman-klass", "rogers-satchell", "yang-zhang"] as const) {
-      expect(realizedVolatility(wideRange, 4, estimator)).toBeFinite();
-      expect(realizedVolatility(wideRange, 4, estimator)).toBeGreaterThan(0);
-    }
-  });
-
-  test("computes each requested window without consuming duplicate sessions", () => {
-    const points = history(Array.from({ length: 270 }, (_, index) => 0.01 * Math.sin(index)));
-    const series = rollingRealizedVolatility(points);
-    expect(series[259]!.values[260]).toBeNull();
-    for (const window of [10, 20, 30, 60, 90, 180, 260]) {
-      expect(series.at(-1)!.values[window]).toBeCloseTo(realizedVolatility(points, window)!, 12);
-    }
-  });
-});
-
-describe("volatility cone", () => {
-  test("computes rank and distribution from rolling estimates, with midpoint ties", () => {
-    const points = history([0.01, -0.01, 0.02, -0.02, 0.03]);
-    const stats = volatilityCone(points, { windows: [2] })[0]!;
-    const factor = Math.sqrt(126);
-    // Two-return sample standard deviations equal |r2-r1| / sqrt(2).
-    expect(stats.sampleSize).toBe(4);
-    expect(stats.min).toBeCloseTo(0.02 * factor, 12);
-    expect(stats.max).toBeCloseTo(0.05 * factor, 12);
-    expect(stats.mean).toBeCloseTo(0.035 * factor, 12);
-    expect(stats.median).toBeCloseTo(0.035 * factor, 12);
-    expect(stats.current).toBeCloseTo(0.05 * factor, 12);
-    expect(stats.percentile).toBe(87.5);
-    expect(volatilityCone(history([0, 0, 0, 0]), { windows: [2] })[0]!.percentile).toBe(50);
-  });
-
-  test("uses calendar lookbacks, preserves warmup, and does not backfill a missing current", () => {
-    const points = history(Array.from({ length: 800 }, () => 0));
-    const oneYear = volatilityCone(points, { windows: [260], lookbackYears: 1 })[0]!;
-    const twoYears = volatilityCone(points, { windows: [260], lookbackYears: 2 })[0]!;
-    expect(oneYear.sampleSize).toBe(365);
-    expect(twoYears.sampleSize).toBe(541);
-    points.at(-1)!.close = 0;
-    const missing = volatilityCone(points, { windows: [260] })[0]!;
-    expect(missing.current).toBeNull();
-    expect(missing.percentile).toBeNull();
-    expect(missing.mean).toBe(0);
-    expect(missing.sampleSize).toBe(364);
-    const empty = volatilityCone([], { windows: [30] })[0]!;
-    expect(empty.sampleSize).toBe(0);
-    expect(empty.mean).toBeNull();
-    expect(empty.percentile).toBeNull();
-  });
-
-  test("a leap-day lookback keeps March 1 from the prior year", () => {
-    const dates = ["2023-02-27", "2023-02-28", "2023-03-01", "2024-02-29"];
-    const points = rangeHistory(4).map((point, index) => ({ ...point, date: new Date(dates[index]!) }));
-    expect(volatilityCone(points, { windows: [2], estimator: "parkinson", lookbackYears: 1 })[0]!.sampleSize).toBe(2);
-  });
-});

package/src/plugins/builtin/shared/volatility/realized.ts

@@ -1,292 +0,0 @@
-import type { PricePoint } from "../../../../types/financials";
-import {
-  mergePriceHistoryIntegrity,
-  pricePointIntegrity,
-  type PriceHistoryIntegrity,
-} from "../../../../utils/price-history-integrity";
-
-export const VOLATILITY_TRADING_DAYS = 252;
-export const REALIZED_VOLATILITY_WINDOWS = [10, 20, 30, 60, 90, 180, 260] as const;
-
-export const REALIZED_VOLATILITY_ESTIMATORS = [
-  "close-to-close", "parkinson", "garman-klass", "rogers-satchell", "yang-zhang",
-] as const;
-export type RealizedVolatilityEstimator = typeof REALIZED_VOLATILITY_ESTIMATORS[number];
-
-export function isRealizedVolatilityEstimator(value: unknown): value is RealizedVolatilityEstimator {
-  return REALIZED_VOLATILITY_ESTIMATORS.some((estimator) => estimator === value);
-}
-
-export type RealizedVolatilityUnavailableReason =
-  | "invalid-window"
-  | "invalid-date"
-  | "insufficient-history"
-  | "inconsistent-ohlc"
-  | "missing-close"
-  | "missing-ohlc"
-  | "invalid-variance";
-
-export interface RealizedVolatilityResult {
-  /** Annualized decimal volatility, so 0.2 means 20%. */
-  value: number | null;
-  reason?: RealizedVolatilityUnavailableReason;
-  integrity?: PriceHistoryIntegrity;
-}
-
-export interface RollingRealizedVolatilityOptions {
-  windows?: readonly number[];
-  estimator?: RealizedVolatilityEstimator;
-}
-
-export interface RollingRealizedVolatilityPoint {
-  date: Date;
-  /** Values stay null across incomplete or rejected windows. */
-  values: Readonly<Record<number, number | null>>;
-}
-
-export interface VolatilityConeOptions extends RollingRealizedVolatilityOptions {
-  /** Calendar years ending on the last supplied observation, not on today's date. */
-  lookbackYears?: 1 | 2;
-}
-
-export interface VolatilityConeStatistics {
-  window: number;
-  current: number | null;
-  min: number | null;
-  max: number | null;
-  mean: number | null;
-  median: number | null;
-  /** Midrank percentile on a 0 to 100 scale; a constant history has rank 50. */
-  percentile: number | null;
-  sampleSize: number;
-}
-
-/**
- * Consumer guard for daily-data requests whose provider may have fallen back to
- * intraday or weekly bars. The estimators themselves remain general n-session
- * calculations. This detects cadence contradictions, not missing market sessions.
- */
-export function realizedVolatilityCadenceIssue(points: readonly Pick<PricePoint, "date">[]): string | null {
-  const timestamps = new Set<number>();
-  for (const point of points) {
-    const time = new Date(point.date).getTime();
-    if (!Number.isFinite(time)) return "Realized volatility unavailable: invalid history date";
-    timestamps.add(time);
-  }
-  const history = [...timestamps].sort((a, b) => a - b);
-  const days = new Set<number>();
-  const gaps: number[] = [];
-  for (let index = 0; index < history.length; index += 1) {
-    const time = history[index]!;
-    const day = Math.floor(time / 86_400_000);
-    if (days.has(day)) return "Daily history unavailable: intraday observations returned";
-    days.add(day);
-    if (index > 0) gaps.push(time - history[index - 1]!);
-  }
-  if (gaps.length === 0) return null;
-  gaps.sort((a, b) => a - b);
-  const middle = Math.floor(gaps.length / 2);
-  const median = gaps.length % 2 ? gaps[middle]! : (gaps[middle - 1]! + gaps[middle]!) / 2;
-  return median >= 5 * 86_400_000 ? "Daily history unavailable: observed cadence is weekly or slower" : null;
-}
-
-interface Observation {
-  time: number;
-  close: number | null;
-  open: number | null;
-  high: number | null;
-  low: number | null;
-  integrity?: PriceHistoryIntegrity;
-}
-
-function positiveLog(value: number | undefined): number | null {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.log(value) : null;
-}
-
-/** Corrections replace the same date before selection, matching the options monitor. */
-function observations(points: readonly PricePoint[]): Observation[] | null {
-  const dates = new Map<number, PricePoint>();
-  for (const point of points) {
-    const time = new Date(point.date).getTime();
-    if (!Number.isFinite(time)) return null;
-    dates.set(time, point);
-  }
-  return [...dates.entries()].sort(([a], [b]) => a - b).map(([time, point]) => ({
-    time,
-    close: positiveLog(point.close),
-    open: positiveLog(point.open),
-    high: positiveLog(point.high),
-    low: positiveLog(point.low),
-    integrity: pricePointIntegrity(point),
-  }));
-}
-
-function validWindow(window: number): boolean {
-  return Number.isInteger(window) && window >= 2;
-}
-
-/** Welford's centered variance avoids cancellation when the return drift is large. */
-function sampleVariance(values: readonly number[]): number {
-  let mean = 0;
-  let squaredDeviations = 0;
-  for (let index = 0; index < values.length; index += 1) {
-    const value = values[index]!;
-    const delta = value - mean;
-    mean += delta / (index + 1);
-    squaredDeviations += delta * (value - mean);
-  }
-  return squaredDeviations / (values.length - 1);
-}
-
-function unavailable(reason: RealizedVolatilityUnavailableReason): RealizedVolatilityResult {
-  return { value: null, reason };
-}
-
-function estimateWindow(
-  history: readonly Observation[],
-  end: number,
-  window: number,
-  estimator: RealizedVolatilityEstimator,
-): RealizedVolatilityResult {
-  if (!validWindow(window)) return unavailable("invalid-window");
-  const previousCloseRequired = estimator === "close-to-close" || estimator === "yang-zhang";
-  const start = end - window + 1;
-  const first = start - (previousCloseRequired ? 1 : 0);
-  // Validate selected observations before calculating. Removing one would bridge a gap.
-  // Even an incomplete window retains diagnostics for its rejected source rows.
-  const rejected: PriceHistoryIntegrity[] = [];
-  for (let index = Math.max(0, first); index <= end; index += 1) {
-    const integrity = history[index]!.integrity;
-    if (integrity) rejected.push(integrity);
-  }
-  if (rejected.length > 0) {
-    return { value: null, reason: "inconsistent-ohlc", integrity: mergePriceHistoryIntegrity(...rejected) };
-  }
-  for (let index = Math.max(0, first); index <= end; index += 1) {
-    const point = history[index]!;
-    if (point.close === null) return unavailable("missing-close");
-    // The predecessor supplies only its close, including for Yang-Zhang.
-    if (estimator !== "close-to-close" && index >= start
-      && (point.high === null || point.low === null || (estimator !== "parkinson" && point.open === null))) {
-      return unavailable("missing-ohlc");
-    }
-  }
-  if (first < 0) return unavailable("insufficient-history");
-
-  const returns: number[] = [];
-  const overnightReturns: number[] = [];
-  let rangeSum = 0;
-  for (let index = start; index <= end; index += 1) {
-    const point = history[index]!;
-    const close = point.close!;
-    if (estimator === "close-to-close") {
-      // Subtract logs: even two finite prices can have an overflowing ratio.
-      returns.push(close - history[index - 1]!.close!);
-      continue;
-    }
-    const high = point.high!;
-    const low = point.low!;
-    const range = high - low;
-    if (estimator === "parkinson") {
-      rangeSum += range * range / (4 * Math.LN2);
-    } else if (estimator === "garman-klass") {
-      const intraday = close - point.open!;
-      rangeSum += 0.5 * range * range - (2 * Math.LN2 - 1) * intraday * intraday;
-    } else {
-      const open = point.open!;
-      rangeSum += (high - open) * (high - close) + (low - open) * (low - close);
-      if (estimator === "yang-zhang") {
-        returns.push(close - open);
-        overnightReturns.push(open - history[index - 1]!.close!);
-      }
-    }
-  }
-
-  let variance: number;
-  if (estimator === "close-to-close") {
-    variance = sampleVariance(returns);
-  } else if (estimator === "yang-zhang") {
-    const weight = 0.34 / (1.34 + (window + 1) / (window - 1));
-    variance = sampleVariance(overnightReturns) + weight * sampleVariance(returns) + (1 - weight) * rangeSum / window;
-  } else {
-    variance = rangeSum / window;
-  }
-  if (!Number.isFinite(variance) || variance < -64 * Number.EPSILON) return unavailable("invalid-variance");
-  // Integrity checks permit machine precision noise at an OHLC boundary.
-  return { value: Math.sqrt(Math.max(0, variance) * VOLATILITY_TRADING_DAYS) };
-}
-
-/**
- * Latest n-session estimate. Close-to-close and Yang-Zhang need n+1 observations;
- * range estimators need n. Holidays and missing sessions cannot be inferred without
- * an exchange calendar. Supplied invalid observations remain gaps, never bridges.
- */
-export function realizedVolatilityResult(
-  points: readonly PricePoint[],
-  window = 30,
-  estimator: RealizedVolatilityEstimator = "close-to-close",
-): RealizedVolatilityResult {
-  if (!validWindow(window)) return unavailable("invalid-window");
-  const history = observations(points);
-  return history === null ? unavailable("invalid-date") : estimateWindow(history, history.length - 1, window, estimator);
-}
-
-export function realizedVolatility(
-  points: readonly PricePoint[],
-  window = 30,
-  estimator: RealizedVolatilityEstimator = "close-to-close",
-): number | null {
-  return realizedVolatilityResult(points, window, estimator).value;
-}
-
-/** Invalid dates make chronology unknowable and return no series. */
-export function rollingRealizedVolatility(
-  points: readonly PricePoint[],
-  options: RollingRealizedVolatilityOptions = {},
-): RollingRealizedVolatilityPoint[] {
-  const history = observations(points);
-  if (history === null) return [];
-  const windows = [...new Set(options.windows ?? REALIZED_VOLATILITY_WINDOWS)];
-  const estimator = options.estimator ?? "close-to-close";
-  return history.map((point, index) => ({
-    date: new Date(point.time),
-    values: Object.fromEntries(windows.map((window) => [window, estimateWindow(history, index, window, estimator).value])),
-  }));
-}
-
-/** Rolling estimates end inside the calendar lookback; earlier bars supply warmup. */
-export function volatilityCone(
-  points: readonly PricePoint[],
-  options: VolatilityConeOptions = {},
-): VolatilityConeStatistics[] {
-  const windows = [...new Set(options.windows ?? REALIZED_VOLATILITY_WINDOWS)];
-  const series = rollingRealizedVolatility(points, { ...options, windows });
-  const latest = series.at(-1);
-  const cutoff = new Date(latest?.date ?? 0);
-  const month = cutoff.getUTCMonth();
-  cutoff.setUTCFullYear(cutoff.getUTCFullYear() - (options.lookbackYears ?? 1));
-  // February 29 maps to February 28 when the prior year is not a leap year.
-  if (cutoff.getUTCMonth() !== month) cutoff.setUTCDate(0);
-  const selected = series.filter((point) => point.date.getTime() > cutoff.getTime());
-  return windows.map((window) => {
-    const current = latest?.values[window] ?? null;
-    const values = selected.flatMap((point) => {
-      const value = point.values[window];
-      return value == null ? [] : [value];
-    }).sort((a, b) => a - b);
-    const sampleSize = values.length;
-    const midpoint = Math.floor(sampleSize / 2);
-    return {
-      window,
-      current,
-      min: values[0] ?? null,
-      max: values.at(-1) ?? null,
-      mean: sampleSize > 0 ? values.reduce((total, value) => total + value, 0) / sampleSize : null,
-      median: sampleSize > 0 ? (sampleSize % 2 ? values[midpoint]! : (values[midpoint - 1]! + values[midpoint]!) / 2) : null,
-      percentile: current !== null && sampleSize > 0
-        ? 100 * (values.filter((value) => value < current).length + 0.5 * values.filter((value) => value === current).length) / sampleSize
-        : null,
-      sampleSize,
-    };
-  });
-}