hagan-sabr 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Moshe Malka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# hagan-sabr
+
+The **SABR** stochastic-volatility model — the Hagan et al. (2002) implied-volatility expansions (**lognormal** and **normal**), the **Obłój** correction, and **(α, ρ, ν) calibration** to a market smile. Zero dependencies.
+
+```
+npm install hagan-sabr
+```
+
+## Why
+
+SABR is the market-standard model for interest-rate swaption and FX volatility smiles — but there was no focused JavaScript/TypeScript implementation. `@quantlib/ql` has it buried in a 28 MB WASM bundle behind a C++-style API. This is the Hagan formulas as a handful of typed functions, and its lognormal output **matches QuantLib's `sabrVolatility` to 1e-9** across 315 test cases.
+
+```ts
+import { lognormalVol, calibrate } from "hagan-sabr";
+
+const p = { alpha: 0.2, beta: 0.5, rho: -0.3, nu: 0.4 };
+lognormalVol(100, 100, 1, p);   // ATM Black vol ≈ 0.0202
+lognormalVol(100, 80, 1, p);    // the smile at a lower strike
+
+// Fit (α, ρ, ν) to a market smile (β fixed):
+const fit = calibrate(100, 2, [
+  { strike: 80, vol: 0.245 },
+  { strike: 100, vol: 0.202 },
+  { strike: 120, vol: 0.199 },
+  // …
+], { beta: 0.5 });
+fit.alpha; fit.rho; fit.nu; fit.rmse;
+```
+
+## API
+
+Parameters: forward `F`, strike `K`, expiry `T` (years), and `{ alpha, beta, rho, nu }` — α > 0, 0 ≤ β ≤ 1, −1 < ρ < 1, ν ≥ 0. Vols are decimals.
+
+- **`lognormalVol(F, K, T, params)`** — Hagan Black/lognormal implied vol (matches QuantLib).
+- **`normalVol(F, K, T, params)`** — Hagan Bachelier/normal implied vol (eq. 2.18).
+- **`oblojVol(F, K, T, params)`** — the Obłój (2008) refinement that fixes the small-strike / long-maturity leading term.
+- **`calibrate(F, T, quotes, opts?)`** — least-squares fit of (α, ρ, ν) with β fixed (default 0.5), via Nelder–Mead; returns the params plus fit `rmse`.
+
+Invalid inputs throw `RangeError`.
+
+## Correctness
+
+The lognormal expansion is validated against **QuantLib's `sabrVolatility`** — 315 fixtures spanning β ∈ {0, 0.3, 0.5, 0.7, 1}, forwards from 0.02 to 100, expiries to 5y, and strikes from deep ITM to deep OTM — all matching to **1e-9** ([`test/generate-fixtures.py`](test/generate-fixtures.py)). The normal and Obłój variants are cross-checked against an independent reference implementation, and calibration is verified to recover known parameters from a synthetic smile.
+
+## Related
+
+Pairs with [`svi-vol-surface`](https://github.com/moshejs/svi-vol-surface) (arbitrage-free surface parametrization). Part of a quant/fixed-income toolkit: [`compounded-sofr`](https://github.com/moshejs/compounded-sofr) · [`day-count`](https://github.com/moshejs/day-count) · [`instrument-identifiers`](https://github.com/moshejs/instrument-identifiers) · [`newyorkfed`](https://github.com/moshejs/newyorkfed).
+
+## Author
+
+Built by **[Moshe Malka](https://moshemalka.com)** — engineering leader in New York City. Studio work at [Quentin.Code](https://www.quentin.software/).
+
+MIT © Moshe Malka

package/dist/index.cjs

@@ -0,0 +1,212 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  calibrate: () => calibrate,
+  lognormalVol: () => lognormalVol,
+  normalVol: () => normalVol,
+  oblojVol: () => oblojVol
+});
+module.exports = __toCommonJS(index_exports);
+function validate(F, K, T, p) {
+  if (!(F > 0)) throw new RangeError(`forward must be positive, got ${F}`);
+  if (!(K > 0)) throw new RangeError(`strike must be positive, got ${K}`);
+  if (!(T > 0)) throw new RangeError(`expiry must be positive, got ${T}`);
+  if (!(p.alpha > 0)) throw new RangeError(`alpha must be positive, got ${p.alpha}`);
+  if (p.beta < 0 || p.beta > 1) throw new RangeError(`beta must be in [0,1], got ${p.beta}`);
+  if (p.rho <= -1 || p.rho >= 1) throw new RangeError(`rho must be in (-1,1), got ${p.rho}`);
+  if (p.nu < 0) throw new RangeError(`nu must be non-negative, got ${p.nu}`);
+}
+function zOverX(z, rho) {
+  if (Math.abs(z) < 1e-12) {
+    return 1 - rho * z / 2 + (2 - 3 * rho * rho) * z * z / 12;
+  }
+  const x = Math.log((Math.sqrt(1 - 2 * rho * z + z * z) + z - rho) / (1 - rho));
+  return z / x;
+}
+function lognormalVol(F, K, T, p) {
+  validate(F, K, T, p);
+  const { alpha, beta, rho, nu } = p;
+  const oneMinusBeta = 1 - beta;
+  const logFK = Math.log(F / K);
+  const FKbeta = Math.pow(F * K, oneMinusBeta / 2);
+  const term1 = oneMinusBeta * oneMinusBeta * alpha * alpha / (24 * FKbeta * FKbeta);
+  const term2 = rho * beta * nu * alpha / (4 * FKbeta);
+  const term3 = (2 - 3 * rho * rho) * nu * nu / 24;
+  const timeFactor = 1 + (term1 + term2 + term3) * T;
+  if (Math.abs(logFK) < 1e-12) {
+    return alpha / Math.pow(F, oneMinusBeta) * timeFactor;
+  }
+  const logFK2 = logFK * logFK;
+  const logFK4 = logFK2 * logFK2;
+  const denom = FKbeta * (1 + oneMinusBeta * oneMinusBeta * logFK2 / 24 + oneMinusBeta * oneMinusBeta * oneMinusBeta * oneMinusBeta * logFK4 / 1920);
+  const z = nu / alpha * FKbeta * logFK;
+  return alpha / denom * zOverX(z, rho) * timeFactor;
+}
+function normalVol(F, K, T, p) {
+  validate(F, K, T, p);
+  const { alpha, beta, rho, nu } = p;
+  const oneMinusBeta = 1 - beta;
+  const FKpow1mb = Math.pow(F * K, oneMinusBeta);
+  const FKhalf = Math.pow(F * K, oneMinusBeta / 2);
+  const c1 = -beta * (2 - beta) * alpha * alpha / (24 * FKpow1mb);
+  const c2 = rho * beta * nu * alpha / (4 * FKhalf);
+  const c3 = (2 - 3 * rho * rho) * nu * nu / 24;
+  const timeFactor = 1 + (c1 + c2 + c3) * T;
+  const level = alpha * Math.pow(F * K, beta / 2);
+  if (Math.abs(F - K) < 1e-12 * Math.max(1, F)) {
+    return level * timeFactor;
+  }
+  const logFK = Math.log(F / K);
+  const logFK2 = logFK * logFK;
+  const logFK4 = logFK2 * logFK2;
+  const numerator = 1 + logFK2 / 24 + logFK4 / 1920;
+  const denominator = 1 + oneMinusBeta * oneMinusBeta * logFK2 / 24 + oneMinusBeta * oneMinusBeta * oneMinusBeta * oneMinusBeta * logFK4 / 1920;
+  const z = nu / alpha * FKhalf * logFK;
+  return level * (numerator / denominator) * zOverX(z, rho) * timeFactor;
+}
+function oblojVol(F, K, T, p) {
+  validate(F, K, T, p);
+  const { alpha, beta, rho, nu } = p;
+  const oneMinusBeta = 1 - beta;
+  const logFK = Math.log(F / K);
+  const FKbeta = Math.pow(F * K, oneMinusBeta / 2);
+  const term1 = oneMinusBeta * oneMinusBeta * alpha * alpha / (24 * FKbeta * FKbeta);
+  const term2 = rho * beta * nu * alpha / (4 * FKbeta);
+  const term3 = (2 - 3 * rho * rho) * nu * nu / 24;
+  const timeFactor = 1 + (term1 + term2 + term3) * T;
+  let leading;
+  if (Math.abs(logFK) < 1e-12) {
+    leading = alpha / Math.pow(F, oneMinusBeta);
+  } else if (oneMinusBeta < 1e-8) {
+    const z = nu / alpha * logFK;
+    leading = nu * logFK / (z === 0 ? 1 : Math.log((Math.sqrt(1 - 2 * rho * z + z * z) + z - rho) / (1 - rho)));
+  } else {
+    const z = nu / alpha * (Math.pow(F, oneMinusBeta) - Math.pow(K, oneMinusBeta)) / oneMinusBeta;
+    const xz = Math.log((Math.sqrt(1 - 2 * rho * z + z * z) + z - rho) / (1 - rho));
+    leading = nu * logFK / (xz === 0 ? 1 : xz);
+  }
+  return leading * timeFactor;
+}
+function calibrate(F, T, quotes, opts = {}) {
+  if (!(F > 0)) throw new RangeError(`forward must be positive, got ${F}`);
+  if (!(T > 0)) throw new RangeError(`expiry must be positive, got ${T}`);
+  if (quotes.length < 3) throw new RangeError("calibration needs at least 3 quotes");
+  const beta = opts.beta ?? 0.5;
+  const atm = [...quotes].sort((a, b) => Math.abs(a.strike - F) - Math.abs(b.strike - F))[0];
+  const alpha0 = opts.initial?.alpha ?? atm.vol * Math.pow(F, 1 - beta);
+  const rho0 = opts.initial?.rho ?? 0;
+  const nu0 = opts.initial?.nu ?? 0.3;
+  const objective = (v) => {
+    const alpha2 = Math.exp(v[0]);
+    const rho2 = Math.tanh(v[1]);
+    const nu2 = Math.exp(v[2]);
+    let sse = 0;
+    for (const q of quotes) {
+      const model = lognormalVol(F, q.strike, T, { alpha: alpha2, beta, rho: rho2, nu: nu2 });
+      const w = q.weight ?? 1;
+      const e = model - q.vol;
+      sse += w * e * e;
+    }
+    return sse;
+  };
+  const start = [Math.log(alpha0), Math.atanh(clamp(rho0, -0.999, 0.999)), Math.log(Math.max(nu0, 1e-6))];
+  const { point, iterations } = nelderMead(objective, start, opts.maxIter ?? 2e3);
+  const alpha = Math.exp(point[0]);
+  const rho = Math.tanh(point[1]);
+  const nu = Math.exp(point[2]);
+  const totalW = quotes.reduce((s, q) => s + (q.weight ?? 1), 0);
+  const rmse = Math.sqrt(objective(point) / totalW);
+  return { alpha, beta, rho, nu, rmse, iterations };
+}
+function clamp(x, lo, hi) {
+  return Math.max(lo, Math.min(hi, x));
+}
+function nelderMead(f, x0, maxIter) {
+  const n = x0.length;
+  const alpha = 1;
+  const gamma = 2;
+  const rho = 0.5;
+  const sigma = 0.5;
+  const simplex = [x0.slice()];
+  for (let i = 0; i < n; i++) {
+    const p = x0.slice();
+    const xi = p[i];
+    p[i] = xi + (xi !== 0 ? 0.1 * xi : 0.1);
+    simplex.push(p);
+  }
+  let fvals = simplex.map(f);
+  let iter = 0;
+  for (; iter < maxIter; iter++) {
+    const order = fvals.map((v, i) => i).sort((a, b) => fvals[a] - fvals[b]);
+    const s = order.map((i) => simplex[i]);
+    const fs = order.map((i) => fvals[i]);
+    for (let i = 0; i < s.length; i++) {
+      simplex[i] = s[i];
+      fvals[i] = fs[i];
+    }
+    if (Math.abs(fvals[n] - fvals[0]) < 1e-14) break;
+    const centroid = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) centroid[j] += simplex[i][j];
+    }
+    for (let j = 0; j < n; j++) centroid[j] /= n;
+    const worst = simplex[n];
+    const reflected = centroid.map((c, j) => c + alpha * (c - worst[j]));
+    const fr = f(reflected);
+    if (fr < fvals[0]) {
+      const expanded = centroid.map((c, j) => c + gamma * (reflected[j] - c));
+      const fe = f(expanded);
+      if (fe < fr) {
+        simplex[n] = expanded;
+        fvals[n] = fe;
+      } else {
+        simplex[n] = reflected;
+        fvals[n] = fr;
+      }
+    } else if (fr < fvals[n - 1]) {
+      simplex[n] = reflected;
+      fvals[n] = fr;
+    } else {
+      const contracted = centroid.map((c, j) => c + rho * (worst[j] - c));
+      const fc = f(contracted);
+      if (fc < fvals[n]) {
+        simplex[n] = contracted;
+        fvals[n] = fc;
+      } else {
+        for (let i = 1; i <= n; i++) {
+          simplex[i] = simplex[0].map((b, j) => b + sigma * (simplex[i][j] - b));
+          fvals[i] = f(simplex[i]);
+        }
+      }
+    }
+  }
+  let best = 0;
+  for (let i = 1; i < fvals.length; i++) if (fvals[i] < fvals[best]) best = i;
+  return { point: simplex[best], value: fvals[best], iterations: iter };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calibrate,
+  lognormalVol,
+  normalVol,
+  oblojVol
+});

package/dist/index.d.cts

@@ -0,0 +1,73 @@
+/**
+ * hagan-sabr — the SABR stochastic-volatility model.
+ *
+ * The Hagan et al. (2002) implied-volatility expansions — lognormal (Black)
+ * and normal (Bachelier) — with the Obłój (2008) refinement, plus
+ * least-squares calibration of (α, ρ, ν) to a market smile.
+ *
+ * Parameters:
+ *   F     forward
+ *   K     strike
+ *   T     time to expiry (years)
+ *   alpha instantaneous vol level (α > 0)
+ *   beta  CEV exponent (0 ≤ β ≤ 1)
+ *   rho   correlation (−1 < ρ < 1)
+ *   nu    vol-of-vol (ν ≥ 0)
+ *
+ * Volatilities are returned as decimals (0.20 = 20%).
+ */
+interface SabrParams {
+    alpha: number;
+    beta: number;
+    rho: number;
+    nu: number;
+}
+/**
+ * Hagan (2002) lognormal (Black) implied volatility. This matches
+ * QuantLib's `sabrVolatility`.
+ *
+ * ```ts
+ * lognormalVol(100, 100, 1, { alpha: 0.2, beta: 0.5, rho: -0.3, nu: 0.4 });
+ * // ATM ≈ 0.0202 (= alpha / F^(1-beta) × …)
+ * ```
+ */
+declare function lognormalVol(F: number, K: number, T: number, p: SabrParams): number;
+/**
+ * Hagan (2002) normal (Bachelier) implied volatility (eq. 2.18), in the same
+ * units as the forward. Parallels the lognormal formula: the same z and
+ * z/x(z), a `(FK)^{β/2}` level, and a normal-specific time correction.
+ */
+declare function normalVol(F: number, K: number, T: number, p: SabrParams): number;
+/**
+ * Lognormal vol with the Obłój (2008) correction, which fixes an
+ * inconsistency in the original expansion for small strikes / long maturities.
+ * Differs from {@link lognormalVol} only in the leading (zeroth-order) term.
+ */
+declare function oblojVol(F: number, K: number, T: number, p: SabrParams): number;
+interface MarketQuote {
+    strike: number;
+    /** Observed lognormal (Black) implied vol as a decimal. */
+    vol: number;
+    /** Optional weight for the least-squares fit (default 1). */
+    weight?: number;
+}
+interface CalibrationOptions {
+    /** Fixed β (SABR β is usually fixed, not fitted). Default 0.5. */
+    beta?: number;
+    /** Initial guesses. */
+    initial?: Partial<Pick<SabrParams, "alpha" | "rho" | "nu">>;
+    /** Max Nelder–Mead iterations. Default 2000. */
+    maxIter?: number;
+}
+interface CalibrationResult extends SabrParams {
+    /** Root-mean-squared vol error at the optimum. */
+    rmse: number;
+    iterations: number;
+}
+/**
+ * Calibrate (α, ρ, ν) to a market smile by least squares (β fixed), using a
+ * Nelder–Mead simplex. Returns the fitted SABR parameters and fit RMSE.
+ */
+declare function calibrate(F: number, T: number, quotes: readonly MarketQuote[], opts?: CalibrationOptions): CalibrationResult;
+
+export { type CalibrationOptions, type CalibrationResult, type MarketQuote, type SabrParams, calibrate, lognormalVol, normalVol, oblojVol };

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * hagan-sabr — the SABR stochastic-volatility model.
+ *
+ * The Hagan et al. (2002) implied-volatility expansions — lognormal (Black)
+ * and normal (Bachelier) — with the Obłój (2008) refinement, plus
+ * least-squares calibration of (α, ρ, ν) to a market smile.
+ *
+ * Parameters:
+ *   F     forward
+ *   K     strike
+ *   T     time to expiry (years)
+ *   alpha instantaneous vol level (α > 0)
+ *   beta  CEV exponent (0 ≤ β ≤ 1)
+ *   rho   correlation (−1 < ρ < 1)
+ *   nu    vol-of-vol (ν ≥ 0)
+ *
+ * Volatilities are returned as decimals (0.20 = 20%).
+ */
+interface SabrParams {
+    alpha: number;
+    beta: number;
+    rho: number;
+    nu: number;
+}
+/**
+ * Hagan (2002) lognormal (Black) implied volatility. This matches
+ * QuantLib's `sabrVolatility`.
+ *
+ * ```ts
+ * lognormalVol(100, 100, 1, { alpha: 0.2, beta: 0.5, rho: -0.3, nu: 0.4 });
+ * // ATM ≈ 0.0202 (= alpha / F^(1-beta) × …)
+ * ```
+ */
+declare function lognormalVol(F: number, K: number, T: number, p: SabrParams): number;
+/**
+ * Hagan (2002) normal (Bachelier) implied volatility (eq. 2.18), in the same
+ * units as the forward. Parallels the lognormal formula: the same z and
+ * z/x(z), a `(FK)^{β/2}` level, and a normal-specific time correction.
+ */
+declare function normalVol(F: number, K: number, T: number, p: SabrParams): number;
+/**
+ * Lognormal vol with the Obłój (2008) correction, which fixes an
+ * inconsistency in the original expansion for small strikes / long maturities.
+ * Differs from {@link lognormalVol} only in the leading (zeroth-order) term.
+ */
+declare function oblojVol(F: number, K: number, T: number, p: SabrParams): number;
+interface MarketQuote {
+    strike: number;
+    /** Observed lognormal (Black) implied vol as a decimal. */
+    vol: number;
+    /** Optional weight for the least-squares fit (default 1). */
+    weight?: number;
+}
+interface CalibrationOptions {
+    /** Fixed β (SABR β is usually fixed, not fitted). Default 0.5. */
+    beta?: number;
+    /** Initial guesses. */
+    initial?: Partial<Pick<SabrParams, "alpha" | "rho" | "nu">>;
+    /** Max Nelder–Mead iterations. Default 2000. */
+    maxIter?: number;
+}
+interface CalibrationResult extends SabrParams {
+    /** Root-mean-squared vol error at the optimum. */
+    rmse: number;
+    iterations: number;
+}
+/**
+ * Calibrate (α, ρ, ν) to a market smile by least squares (β fixed), using a
+ * Nelder–Mead simplex. Returns the fitted SABR parameters and fit RMSE.
+ */
+declare function calibrate(F: number, T: number, quotes: readonly MarketQuote[], opts?: CalibrationOptions): CalibrationResult;
+
+export { type CalibrationOptions, type CalibrationResult, type MarketQuote, type SabrParams, calibrate, lognormalVol, normalVol, oblojVol };

package/dist/index.js

@@ -0,0 +1,184 @@
+// src/index.ts
+function validate(F, K, T, p) {
+  if (!(F > 0)) throw new RangeError(`forward must be positive, got ${F}`);
+  if (!(K > 0)) throw new RangeError(`strike must be positive, got ${K}`);
+  if (!(T > 0)) throw new RangeError(`expiry must be positive, got ${T}`);
+  if (!(p.alpha > 0)) throw new RangeError(`alpha must be positive, got ${p.alpha}`);
+  if (p.beta < 0 || p.beta > 1) throw new RangeError(`beta must be in [0,1], got ${p.beta}`);
+  if (p.rho <= -1 || p.rho >= 1) throw new RangeError(`rho must be in (-1,1), got ${p.rho}`);
+  if (p.nu < 0) throw new RangeError(`nu must be non-negative, got ${p.nu}`);
+}
+function zOverX(z, rho) {
+  if (Math.abs(z) < 1e-12) {
+    return 1 - rho * z / 2 + (2 - 3 * rho * rho) * z * z / 12;
+  }
+  const x = Math.log((Math.sqrt(1 - 2 * rho * z + z * z) + z - rho) / (1 - rho));
+  return z / x;
+}
+function lognormalVol(F, K, T, p) {
+  validate(F, K, T, p);
+  const { alpha, beta, rho, nu } = p;
+  const oneMinusBeta = 1 - beta;
+  const logFK = Math.log(F / K);
+  const FKbeta = Math.pow(F * K, oneMinusBeta / 2);
+  const term1 = oneMinusBeta * oneMinusBeta * alpha * alpha / (24 * FKbeta * FKbeta);
+  const term2 = rho * beta * nu * alpha / (4 * FKbeta);
+  const term3 = (2 - 3 * rho * rho) * nu * nu / 24;
+  const timeFactor = 1 + (term1 + term2 + term3) * T;
+  if (Math.abs(logFK) < 1e-12) {
+    return alpha / Math.pow(F, oneMinusBeta) * timeFactor;
+  }
+  const logFK2 = logFK * logFK;
+  const logFK4 = logFK2 * logFK2;
+  const denom = FKbeta * (1 + oneMinusBeta * oneMinusBeta * logFK2 / 24 + oneMinusBeta * oneMinusBeta * oneMinusBeta * oneMinusBeta * logFK4 / 1920);
+  const z = nu / alpha * FKbeta * logFK;
+  return alpha / denom * zOverX(z, rho) * timeFactor;
+}
+function normalVol(F, K, T, p) {
+  validate(F, K, T, p);
+  const { alpha, beta, rho, nu } = p;
+  const oneMinusBeta = 1 - beta;
+  const FKpow1mb = Math.pow(F * K, oneMinusBeta);
+  const FKhalf = Math.pow(F * K, oneMinusBeta / 2);
+  const c1 = -beta * (2 - beta) * alpha * alpha / (24 * FKpow1mb);
+  const c2 = rho * beta * nu * alpha / (4 * FKhalf);
+  const c3 = (2 - 3 * rho * rho) * nu * nu / 24;
+  const timeFactor = 1 + (c1 + c2 + c3) * T;
+  const level = alpha * Math.pow(F * K, beta / 2);
+  if (Math.abs(F - K) < 1e-12 * Math.max(1, F)) {
+    return level * timeFactor;
+  }
+  const logFK = Math.log(F / K);
+  const logFK2 = logFK * logFK;
+  const logFK4 = logFK2 * logFK2;
+  const numerator = 1 + logFK2 / 24 + logFK4 / 1920;
+  const denominator = 1 + oneMinusBeta * oneMinusBeta * logFK2 / 24 + oneMinusBeta * oneMinusBeta * oneMinusBeta * oneMinusBeta * logFK4 / 1920;
+  const z = nu / alpha * FKhalf * logFK;
+  return level * (numerator / denominator) * zOverX(z, rho) * timeFactor;
+}
+function oblojVol(F, K, T, p) {
+  validate(F, K, T, p);
+  const { alpha, beta, rho, nu } = p;
+  const oneMinusBeta = 1 - beta;
+  const logFK = Math.log(F / K);
+  const FKbeta = Math.pow(F * K, oneMinusBeta / 2);
+  const term1 = oneMinusBeta * oneMinusBeta * alpha * alpha / (24 * FKbeta * FKbeta);
+  const term2 = rho * beta * nu * alpha / (4 * FKbeta);
+  const term3 = (2 - 3 * rho * rho) * nu * nu / 24;
+  const timeFactor = 1 + (term1 + term2 + term3) * T;
+  let leading;
+  if (Math.abs(logFK) < 1e-12) {
+    leading = alpha / Math.pow(F, oneMinusBeta);
+  } else if (oneMinusBeta < 1e-8) {
+    const z = nu / alpha * logFK;
+    leading = nu * logFK / (z === 0 ? 1 : Math.log((Math.sqrt(1 - 2 * rho * z + z * z) + z - rho) / (1 - rho)));
+  } else {
+    const z = nu / alpha * (Math.pow(F, oneMinusBeta) - Math.pow(K, oneMinusBeta)) / oneMinusBeta;
+    const xz = Math.log((Math.sqrt(1 - 2 * rho * z + z * z) + z - rho) / (1 - rho));
+    leading = nu * logFK / (xz === 0 ? 1 : xz);
+  }
+  return leading * timeFactor;
+}
+function calibrate(F, T, quotes, opts = {}) {
+  if (!(F > 0)) throw new RangeError(`forward must be positive, got ${F}`);
+  if (!(T > 0)) throw new RangeError(`expiry must be positive, got ${T}`);
+  if (quotes.length < 3) throw new RangeError("calibration needs at least 3 quotes");
+  const beta = opts.beta ?? 0.5;
+  const atm = [...quotes].sort((a, b) => Math.abs(a.strike - F) - Math.abs(b.strike - F))[0];
+  const alpha0 = opts.initial?.alpha ?? atm.vol * Math.pow(F, 1 - beta);
+  const rho0 = opts.initial?.rho ?? 0;
+  const nu0 = opts.initial?.nu ?? 0.3;
+  const objective = (v) => {
+    const alpha2 = Math.exp(v[0]);
+    const rho2 = Math.tanh(v[1]);
+    const nu2 = Math.exp(v[2]);
+    let sse = 0;
+    for (const q of quotes) {
+      const model = lognormalVol(F, q.strike, T, { alpha: alpha2, beta, rho: rho2, nu: nu2 });
+      const w = q.weight ?? 1;
+      const e = model - q.vol;
+      sse += w * e * e;
+    }
+    return sse;
+  };
+  const start = [Math.log(alpha0), Math.atanh(clamp(rho0, -0.999, 0.999)), Math.log(Math.max(nu0, 1e-6))];
+  const { point, iterations } = nelderMead(objective, start, opts.maxIter ?? 2e3);
+  const alpha = Math.exp(point[0]);
+  const rho = Math.tanh(point[1]);
+  const nu = Math.exp(point[2]);
+  const totalW = quotes.reduce((s, q) => s + (q.weight ?? 1), 0);
+  const rmse = Math.sqrt(objective(point) / totalW);
+  return { alpha, beta, rho, nu, rmse, iterations };
+}
+function clamp(x, lo, hi) {
+  return Math.max(lo, Math.min(hi, x));
+}
+function nelderMead(f, x0, maxIter) {
+  const n = x0.length;
+  const alpha = 1;
+  const gamma = 2;
+  const rho = 0.5;
+  const sigma = 0.5;
+  const simplex = [x0.slice()];
+  for (let i = 0; i < n; i++) {
+    const p = x0.slice();
+    const xi = p[i];
+    p[i] = xi + (xi !== 0 ? 0.1 * xi : 0.1);
+    simplex.push(p);
+  }
+  let fvals = simplex.map(f);
+  let iter = 0;
+  for (; iter < maxIter; iter++) {
+    const order = fvals.map((v, i) => i).sort((a, b) => fvals[a] - fvals[b]);
+    const s = order.map((i) => simplex[i]);
+    const fs = order.map((i) => fvals[i]);
+    for (let i = 0; i < s.length; i++) {
+      simplex[i] = s[i];
+      fvals[i] = fs[i];
+    }
+    if (Math.abs(fvals[n] - fvals[0]) < 1e-14) break;
+    const centroid = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) centroid[j] += simplex[i][j];
+    }
+    for (let j = 0; j < n; j++) centroid[j] /= n;
+    const worst = simplex[n];
+    const reflected = centroid.map((c, j) => c + alpha * (c - worst[j]));
+    const fr = f(reflected);
+    if (fr < fvals[0]) {
+      const expanded = centroid.map((c, j) => c + gamma * (reflected[j] - c));
+      const fe = f(expanded);
+      if (fe < fr) {
+        simplex[n] = expanded;
+        fvals[n] = fe;
+      } else {
+        simplex[n] = reflected;
+        fvals[n] = fr;
+      }
+    } else if (fr < fvals[n - 1]) {
+      simplex[n] = reflected;
+      fvals[n] = fr;
+    } else {
+      const contracted = centroid.map((c, j) => c + rho * (worst[j] - c));
+      const fc = f(contracted);
+      if (fc < fvals[n]) {
+        simplex[n] = contracted;
+        fvals[n] = fc;
+      } else {
+        for (let i = 1; i <= n; i++) {
+          simplex[i] = simplex[0].map((b, j) => b + sigma * (simplex[i][j] - b));
+          fvals[i] = f(simplex[i]);
+        }
+      }
+    }
+  }
+  let best = 0;
+  for (let i = 1; i < fvals.length; i++) if (fvals[i] < fvals[best]) best = i;
+  return { point: simplex[best], value: fvals[best], iterations: iter };
+}
+export {
+  calibrate,
+  lognormalVol,
+  normalVol,
+  oblojVol
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "hagan-sabr",
+  "version": "1.0.0",
+  "description": "The SABR stochastic-volatility model — Hagan (2002) lognormal & normal implied-vol expansions, the Obłój correction, and (alpha, rho, nu) smile calibration. Matches QuantLib. Zero dependencies.",
+  "keywords": [
+    "sabr",
+    "hagan",
+    "implied-volatility",
+    "volatility-smile",
+    "stochastic-volatility",
+    "swaption",
+    "options",
+    "quant",
+    "quantitative-finance",
+    "derivatives",
+    "finance"
+  ],
+  "homepage": "https://moshemalka.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moshejs/hagan-sabr.git"
+  },
+  "bugs": "https://github.com/moshejs/hagan-sabr/issues",
+  "author": "Moshe Malka <hello@moshemalka.com> (https://moshemalka.com)",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}