@insiderfinance/totalfinance 0.1.0

package/modules/valuation/src/solvers.ts

@@ -0,0 +1,397 @@
+/**
+ * FC1 — return solvers. The plain call returns `number | null` and NEVER chooses among multiple
+ * economically admissible roots silently: `null` means "no root" or "ambiguous — read the
+ * report". `.explain()` reports convergence, the bracket/search range, iterations, EVERY
+ * admissible root found, and an ambiguity warning; callers select an explicit root from it.
+ */
+
+import {
+  requireRepresentableResult,
+  compoundFactor,
+  CONVENTIONS_VERSION,
+  type DayCount,
+  discountFactor,
+  ensureKnownKeys,
+  ErrorCode,
+  InputError,
+  type InterestCompounding,
+  isoDateToEpochMs,
+  type QuantWarning,
+  requireArgumentObject,
+  requireFiniteFields,
+  WarningCode,
+  yearFraction,
+} from '@totalfinance/core';
+import {
+  type DatedCashFlow,
+  type TimedCashFlow,
+  requireDatedCashFlows,
+  requireTimedCashFlows,
+} from './flows.js';
+import { requireCompoundingWhenPresent, requireDayCountWhenPresent } from './discounting.js';
+
+/** The admissible-rate floor: below −100% a periodic growth factor is not positive. */
+const RATE_FLOOR = -0.999999;
+const RATE_CEILING = 10; // 1,000% — beyond this an "IRR" is numerics, not economics
+const SCAN_STEPS = 400;
+const BISECTION_TOLERANCE = 1e-12;
+const MAX_ITERATIONS = 200;
+
+/** One admissible root with the residual NPV at that rate (≈ 0 by construction). */
+export interface InternalRateRoot {
+  annualRate: number;
+  residualNetPresentValue: number;
+}
+
+/** The `.explain()` report shared by the IRR family (Law 2 envelope). */
+export interface InternalRateOfReturnReport {
+  assumptions: {
+    conventionsVersion: string;
+    compounding: InterestCompounding;
+    /** Present only on the dated head. */
+    dayCount?: DayCount;
+    /** Present only on the dated head. */
+    asOf?: string;
+    searchRange: { from: number; to: number };
+  };
+  diagnostics: {
+    method: 'scan-bisect';
+    converged: boolean;
+    iterations: number;
+    warnings: QuantWarning[];
+  };
+  /** The plain call's answer: the single root, or null when none or many. */
+  value: number | null;
+  /** EVERY economically admissible root found in the search range. */
+  roots: InternalRateRoot[];
+}
+
+interface SolveOutcome {
+  roots: InternalRateRoot[];
+  iterations: number;
+  signChanges: number;
+}
+
+/** Scan the admissible range for sign changes, then bisect each to a root. */
+function solveRoots(net: (rate: number) => number): SolveOutcome {
+  const roots: InternalRateRoot[] = [];
+  let iterations = 0;
+  let signChanges = 0;
+  let previousRate = RATE_FLOOR;
+  let previousValue = net(previousRate);
+  for (let step = 1; step <= SCAN_STEPS; step++) {
+    const rate = RATE_FLOOR + ((RATE_CEILING - RATE_FLOOR) * step) / SCAN_STEPS;
+    const value = net(rate);
+    iterations++;
+    if (previousValue === 0) {
+      roots.push({ annualRate: previousRate, residualNetPresentValue: 0 });
+      signChanges++;
+    } else if (
+      Number.isFinite(previousValue) &&
+      Number.isFinite(value) &&
+      previousValue * value < 0
+    ) {
+      signChanges++;
+      let lowRate = previousRate;
+      let highRate = rate;
+      let lowValue = previousValue;
+      for (let i = 0; i < MAX_ITERATIONS; i++) {
+        iterations++;
+        const midRate = (lowRate + highRate) / 2;
+        const midValue = net(midRate);
+        if (Math.abs(midValue) < BISECTION_TOLERANCE || highRate - lowRate < BISECTION_TOLERANCE) {
+          roots.push({ annualRate: midRate, residualNetPresentValue: midValue });
+          break;
+        }
+        if (lowValue * midValue < 0) {
+          highRate = midRate;
+        } else {
+          lowRate = midRate;
+          lowValue = midValue;
+        }
+      }
+    }
+    previousRate = rate;
+    previousValue = value;
+  }
+  // Deduplicate near-identical roots from adjacent scan cells.
+  const deduped: InternalRateRoot[] = [];
+  for (const root of roots) {
+    if (!deduped.some((existing) => Math.abs(existing.annualRate - root.annualRate) < 1e-9)) {
+      deduped.push(root);
+    }
+  }
+  return { roots: deduped, iterations, signChanges };
+}
+
+function buildReport(
+  compounding: InterestCompounding,
+  outcome: SolveOutcome,
+  extras: { dayCount?: DayCount; asOf?: string },
+): InternalRateOfReturnReport {
+  const warnings: QuantWarning[] = [];
+  if (outcome.roots.length > 1) {
+    warnings.push({
+      code: WarningCode.DegenerateInput,
+      message: `multiple economically admissible internal rates exist (${outcome.roots.length}) — the plain call returns null; select an explicit root from this report.`,
+      severity: 'warn',
+      context: { roots: outcome.roots.map((root) => root.annualRate) },
+    });
+  }
+  if (outcome.roots.length === 0) {
+    warnings.push({
+      code: WarningCode.DegenerateInput,
+      message:
+        'no internal rate exists in the admissible search range — the NPV never crosses zero.',
+      severity: 'warn',
+      context: { searchRange: { from: RATE_FLOOR, to: RATE_CEILING } },
+    });
+  }
+  return {
+    assumptions: {
+      conventionsVersion: CONVENTIONS_VERSION,
+      compounding,
+      ...(extras.dayCount !== undefined ? { dayCount: extras.dayCount } : {}),
+      ...(extras.asOf !== undefined ? { asOf: extras.asOf } : {}),
+      searchRange: { from: RATE_FLOOR, to: RATE_CEILING },
+    },
+    diagnostics: {
+      method: 'scan-bisect',
+      converged: outcome.roots.length > 0,
+      iterations: outcome.iterations,
+      warnings,
+    },
+    value: outcome.roots.length === 1 ? outcome.roots[0]!.annualRate : null,
+    roots: outcome.roots,
+  };
+}
+
+// ---------------------------------------------------------------------------------------------------
+// internalRateOfReturn
+// ---------------------------------------------------------------------------------------------------
+
+/** Input for {@link internalRateOfReturn}. */
+export interface InternalRateOfReturnInput {
+  cashFlows: readonly TimedCashFlow[];
+  /** Default `'annual'` — documented and echoed in `.explain()`. */
+  compounding?: InterestCompounding;
+}
+
+const IRR_KEYS = ['cashFlows', 'compounding'] as const;
+
+function validateIrrInput(
+  functionName: string,
+  input: InternalRateOfReturnInput,
+): InterestCompounding {
+  requireArgumentObject(functionName, 'input', input);
+  ensureKnownKeys(functionName, 'input', input, IRR_KEYS);
+  requireTimedCashFlows(functionName, input.cashFlows);
+  requireCompoundingWhenPresent(functionName, input.compounding);
+  const hasPositive = input.cashFlows.some((flow) => flow.amount > 0);
+  const hasNegative = input.cashFlows.some((flow) => flow.amount < 0);
+  if (!hasPositive || !hasNegative) {
+    throw new InputError(
+      `${functionName}: an internal rate needs at least one inflow AND one outflow — all-one-sign cash flows have no crossing NPV.`,
+      { code: ErrorCode.InputOutOfRange, context: { field: 'cashFlows' } },
+    );
+  }
+  return input.compounding ?? 'annual';
+}
+
+function explainInternalRateOfReturn(input: InternalRateOfReturnInput): InternalRateOfReturnReport {
+  const compounding = validateIrrInput('internalRateOfReturn.explain', input);
+  const outcome = solveRoots((rate) => {
+    let total = 0;
+    for (const flow of input.cashFlows) {
+      total += flow.amount * discountFactor(rate, flow.timeYears, compounding);
+    }
+    return total;
+  });
+  return buildReport(compounding, outcome, {});
+}
+
+/**
+ * The internal rate of return of explicit timed flows, or `null` when no admissible root exists
+ * or MORE THAN ONE does — an ambiguous IRR is never chosen silently. `.explain()` carries every
+ * root and the ambiguity warning.
+ */
+export const internalRateOfReturn = Object.assign(
+  (input: InternalRateOfReturnInput): number | null => {
+    const compounding = validateIrrInput('internalRateOfReturn', input);
+    const outcome = solveRoots((rate) => {
+      let total = 0;
+      for (const flow of input.cashFlows) {
+        total += flow.amount * discountFactor(rate, flow.timeYears, compounding);
+      }
+      return total;
+    });
+    return outcome.roots.length === 1 ? outcome.roots[0]!.annualRate : null;
+  },
+  { explain: explainInternalRateOfReturn },
+);
+
+// ---------------------------------------------------------------------------------------------------
+// datedInternalRateOfReturn
+// ---------------------------------------------------------------------------------------------------
+
+/** Input for {@link datedInternalRateOfReturn}. */
+export interface DatedInternalRateOfReturnInput {
+  cashFlows: readonly DatedCashFlow[];
+  /** Strict `YYYY-MM-DD` valuation date; flows before it ACCUMULATE forward, never drop. */
+  asOf: string;
+  /** Default `'annual'` — documented and echoed in `.explain()`. */
+  compounding?: InterestCompounding;
+  /** Default `'ACT/365F'` — documented and echoed in `.explain()`. */
+  dayCount?: DayCount;
+}
+
+const DATED_IRR_KEYS = ['cashFlows', 'asOf', 'compounding', 'dayCount'] as const;
+const STRICT_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/** Shape via the regex, then the REAL calendar: `2025-02-30` must teach, never normalize. */
+const isCalendarDate = (value: string): boolean => {
+  try {
+    isoDateToEpochMs(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+function validateDatedIrrInput(
+  functionName: string,
+  input: DatedInternalRateOfReturnInput,
+): { compounding: InterestCompounding; dayCount: DayCount } {
+  requireArgumentObject(functionName, 'input', input);
+  ensureKnownKeys(functionName, 'input', input, DATED_IRR_KEYS);
+  requireDatedCashFlows(functionName, input.cashFlows);
+  if (
+    typeof input.asOf !== 'string' ||
+    !STRICT_DATE.test(input.asOf) ||
+    !isCalendarDate(input.asOf)
+  ) {
+    throw new InputError(
+      `${functionName}: asOf must be a strict YYYY-MM-DD calendar date. Received ${input.asOf === null ? 'null' : JSON.stringify(input.asOf)}.`,
+      { code: ErrorCode.InputWrongType, context: { field: 'asOf' } },
+    );
+  }
+  requireCompoundingWhenPresent(functionName, input.compounding);
+  requireDayCountWhenPresent(functionName, input.dayCount);
+  const hasPositive = input.cashFlows.some((flow) => flow.amount > 0);
+  const hasNegative = input.cashFlows.some((flow) => flow.amount < 0);
+  if (!hasPositive || !hasNegative) {
+    throw new InputError(
+      `${functionName}: an internal rate needs at least one inflow AND one outflow — all-one-sign cash flows have no crossing NPV.`,
+      { code: ErrorCode.InputOutOfRange, context: { field: 'cashFlows' } },
+    );
+  }
+  return { compounding: input.compounding ?? 'annual', dayCount: input.dayCount ?? 'ACT/365F' };
+}
+
+function datedNet(
+  input: DatedInternalRateOfReturnInput,
+  compounding: InterestCompounding,
+  dayCount: DayCount,
+): (rate: number) => number {
+  const offsets = input.cashFlows.map((flow) =>
+    yearFraction(input.asOf, flow.cashFlowDate, dayCount),
+  );
+  return (rate) => {
+    let total = 0;
+    for (let i = 0; i < input.cashFlows.length; i++) {
+      const years = offsets[i]!;
+      total +=
+        years >= 0
+          ? input.cashFlows[i]!.amount * discountFactor(rate, years, compounding)
+          : input.cashFlows[i]!.amount * compoundFactor(rate, -years, compounding);
+    }
+    return total;
+  };
+}
+
+function explainDatedInternalRateOfReturn(
+  input: DatedInternalRateOfReturnInput,
+): InternalRateOfReturnReport {
+  const { compounding, dayCount } = validateDatedIrrInput(
+    'datedInternalRateOfReturn.explain',
+    input,
+  );
+  const outcome = solveRoots(datedNet(input, compounding, dayCount));
+  return buildReport(compounding, outcome, { dayCount, asOf: input.asOf });
+}
+
+/**
+ * The dated internal rate of return AT `asOf` — historical flows accumulate forward, future
+ * flows discount back, under one declared convention. `null` on no root or ambiguity;
+ * `.explain()` carries every root.
+ */
+export const datedInternalRateOfReturn = Object.assign(
+  (input: DatedInternalRateOfReturnInput): number | null => {
+    const { compounding, dayCount } = validateDatedIrrInput('datedInternalRateOfReturn', input);
+    const outcome = solveRoots(datedNet(input, compounding, dayCount));
+    return outcome.roots.length === 1 ? outcome.roots[0]!.annualRate : null;
+  },
+  { explain: explainDatedInternalRateOfReturn },
+);
+
+// ---------------------------------------------------------------------------------------------------
+// modifiedInternalRateOfReturn
+// ---------------------------------------------------------------------------------------------------
+
+/** Input for {@link modifiedInternalRateOfReturn}. */
+export interface ModifiedInternalRateOfReturnInput {
+  cashFlows: readonly TimedCashFlow[];
+  /** Annual rate financing the negative flows (decimal). */
+  financeRate: number;
+  /** Annual rate reinvesting the positive flows (decimal). */
+  reinvestmentRate: number;
+  /** Default `'annual'` — documented and echoed. */
+  compounding?: InterestCompounding;
+}
+
+const MIRR_KEYS = ['cashFlows', 'financeRate', 'reinvestmentRate', 'compounding'] as const;
+
+/**
+ * Modified IRR: negative flows discount to time zero at `financeRate`; positive flows compound to
+ * the horizon at `reinvestmentRate`; the MIRR is the single rate equating them over the horizon.
+ * Deterministic — no root ambiguity exists, so the plain call returns a number.
+ */
+export function modifiedInternalRateOfReturn(input: ModifiedInternalRateOfReturnInput): number {
+  requireArgumentObject('modifiedInternalRateOfReturn', 'input', input);
+  ensureKnownKeys('modifiedInternalRateOfReturn', 'input', input, MIRR_KEYS);
+  requireFiniteFields('modifiedInternalRateOfReturn', input, ['financeRate', 'reinvestmentRate'], {
+    exampleCall:
+      'modifiedInternalRateOfReturn({ cashFlows: [{ amount: -1_000, timeYears: 0 }, { amount: 600, timeYears: 1 }, { amount: 600, timeYears: 2 }], financeRate: 0.08, reinvestmentRate: 0.05 })',
+  });
+  requireTimedCashFlows('modifiedInternalRateOfReturn', input.cashFlows);
+  requireCompoundingWhenPresent('modifiedInternalRateOfReturn', input.compounding);
+  const compounding = input.compounding ?? 'annual';
+  const horizon = Math.max(...input.cashFlows.map((flow) => flow.timeYears));
+  if (horizon <= 0) {
+    throw new InputError(
+      'modifiedInternalRateOfReturn: the latest cash flow must be after time zero — a zero-length horizon has no periodic return.',
+      { code: ErrorCode.InputOutOfRange, context: { field: 'cashFlows' } },
+    );
+  }
+  let financedPresent = 0;
+  let reinvestedTerminal = 0;
+  for (const flow of input.cashFlows) {
+    if (flow.amount < 0) {
+      financedPresent +=
+        -flow.amount * discountFactor(input.financeRate, flow.timeYears, compounding);
+    } else if (flow.amount > 0) {
+      reinvestedTerminal +=
+        flow.amount * compoundFactor(input.reinvestmentRate, horizon - flow.timeYears, compounding);
+    }
+  }
+  if (financedPresent === 0 || reinvestedTerminal === 0) {
+    throw new InputError(
+      'modifiedInternalRateOfReturn: needs at least one negative AND one positive cash flow.',
+      { code: ErrorCode.InputOutOfRange, context: { field: 'cashFlows' } },
+    );
+  }
+  return requireRepresentableResult(
+    'modifiedInternalRateOfReturn',
+    Math.pow(reinvestedTerminal / financedPresent, 1 / horizon) - 1,
+  );
+}

package/modules/volatility/dist/analytics.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Model-free volatility analytics (spec §10): the risk-neutral probability distribution implied by an
+ * option smile (Breeden–Litzenberger), a realized-volatility cone, and the VIX-style variance-swap
+ * fair volatility. These turn a fitted smile or a price history into the "probability of landing in a
+ * range" and "is vol cheap/rich" read-outs an options dashboard leads with.
+ */
+import { type Computed, type Diagnostics } from '../../core/dist/index.js';
+export interface RiskNeutralOptions {
+    spot: number;
+    /** Time to expiry in years. */
+    timeToExpiryYears: number;
+    riskFreeRate: number;
+    dividendYield?: number;
+    /** Central-difference step in strike (default `spot · 0.001`). */
+    step?: number;
+}
+export interface RiskNeutralDistribution {
+    /** Risk-neutral PDF at strike `K`: `e^{rT}·∂²C/∂K²` (clamped ≥ 0 — see {@link diagnostics}). */
+    density(strike: number): number;
+    /** Risk-neutral CDF `P(S_T ≤ K) = 1 + e^{rT}·∂C/∂K`, clamped to [0, 1]. */
+    cdf(strike: number): number;
+    probabilityBelow(strike: number): number;
+    probabilityAbove(strike: number): number;
+    probabilityBetween(lowerStrike: number, upperStrike: number): number;
+    /**
+     * LIVE disclosure channel for the two places this object silently repairs itself — it accumulates
+     * as the closures are called, so read it AFTER querying (it starts empty):
+     *
+     *  • `model.limitation` "negative density clamped" — `∂²C/∂K²` came out negative, which means the
+     *    smile is butterfly-arbitrageable there. The clamp keeps `density()` a density; the warning
+     *    stops a caller integrating a repaired curve and calling it the market's distribution.
+     *  • `model.limitation` "one-sided difference" — a query within `step` of zero, where the centred
+     *    difference would price a NEGATIVE strike (which returned `NaN`).
+     */
+    diagnostics: Diagnostics;
+}
+/**
+ * Breeden–Litzenberger (1978): the risk-neutral terminal distribution implied by a call-price curve.
+ * Given the smile `volatilitySmile(strike)`, prices calls via BSM and differentiates numerically:
+ * `f(K) = e^{rT}·∂²C/∂K²` and `F(K) = 1 + e^{rT}·∂C/∂K`. Use it for probability cones / expected-range
+ * bands. The smile must be arbitrage-free for the density to stay non-negative.
+ *
+ * Where it repairs itself, it SAYS SO on the returned `diagnostics`: a negative (arbitrageable)
+ * density clamped to zero, and the one-sided difference used for strikes within `step` of zero (a
+ * deep-downside probe like `density(0.05)` on a $100 name, which used to price a negative strike and
+ * return `NaN`). `diagnostics.warnings` fills in as the closures are queried — read it after use.
+ */
+export declare function riskNeutralDistribution(volatilitySmile: (strike: number) => number, options: RiskNeutralOptions): RiskNeutralDistribution;
+export interface VolatilityConeWindow {
+    /** Lookback length (number of returns) for this row. */
+    window: number;
+    min: number;
+    p25: number;
+    median: number;
+    p75: number;
+    max: number;
+    /** Annualized realized vol of the most recent `window` returns (the "current" reading). */
+    current: number;
+}
+/** The conventions `volatilityCone.explain` echoes: the applied windows and annualization. */
+export interface VolatilityConeAssumptions {
+    conventionsVersion: string;
+    /** The requested lookback windows, echoed in request order (one cone row each). */
+    windows: number[];
+    /** The applied annualization periods (`options.periodsPerYear`, default 252). */
+    periodsPerYear: number;
+    /** Realized vol is the rolling stddev of returns scaled by `√periodsPerYear`. */
+    annualization: 'sqrt-periods-per-year';
+}
+export type VolatilityConeFacade = ((returns: ArrayLike<number>, options: {
+    windows: number[];
+    periodsPerYear?: number;
+}) => VolatilityConeWindow[]) & {
+    explain: (returns: ArrayLike<number>, options: {
+        windows: number[];
+        periodsPerYear?: number;
+    }) => Omit<Computed<VolatilityConeWindow[]>, 'assumptions'> & {
+        assumptions: VolatilityConeAssumptions;
+    };
+};
+/**
+ * Realized-volatility cone: for each lookback `window`, the percentile spread of annualized realized
+ * volatility across all rolling windows of the return series, plus the current reading. The classic
+ * "is implied vol rich or cheap vs the underlying's own realized history" view.
+ *
+ * Facade (H27): the plain call returns the rows array; `.explain()` discloses the applied
+ * `periodsPerYear`, windows, and annualization convention in `assumptions`, and the observation
+ * count / annualization factor in `diagnostics.decomposition`. Hand-attached (not `seriesFacade`)
+ * so the closed-request teaching errors for the options bag stay byte-identical.
+ */
+export declare const volatilityCone: VolatilityConeFacade;
+export interface VarianceSwapResult {
+    /** Fair variance (annualized) from the model-free replication. */
+    variance: number;
+    /** Fair volatility `√variance` — the VIX-style model-free implied vol. */
+    fairVolatility: number;
+}
+/**
+ * Model-free implied volatility via the CBOE VIX replication (Demeterfi–Derman–Kamal–Zou): a strip of
+ * out-of-the-money option mid-prices integrates to the fair variance
+ * `σ² = (2/T)·Σ (ΔKᵢ/Kᵢ²)·e^{rT}·Q(Kᵢ) − (1/T)·(F/K₀ − 1)²`, where `K₀` is the highest strike below the
+ * forward `F`. `otmPrices[i]` is the OTM option (put below `F`, call above) mid at `strikes[i]`.
+ *
+ * **At `K₀` the CBOE strip is the AVERAGE of the put and the call**, and the `−(1/T)(F/K₀ − 1)²`
+ * correction subtracted here is derived for exactly that convention. Supply the `K₀` call as
+ * `boundaryCallPrice` and pass the `K₀` PUT in `otmPrices` — the two are averaged for you. With a
+ * put-only `K₀` price and no `boundaryCallPrice` the strip under-states variance by
+ * `ΔK₀·(F − K₀)/(T·K₀²)` (by put–call parity the missing half-difference is `(C−P)/2 = e^{−rT}(F−K₀)/2`),
+ * which on a typical 1-month index chain is ~1.7 vol points — so the disclosure rides the result.
+ */
+export declare function varianceSwapRate(options: {
+    strikes: number[];
+    otmPrices: number[];
+    forward: number;
+    riskFreeRate: number;
+    timeToExpiryYears: number;
+    /**
+     * The CALL price at `K₀` (the highest strike ≤ `F`), with the `K₀` PUT passed in `otmPrices`.
+     * Supplied ⇒ the `K₀` term becomes the CBOE put/call average; omitted ⇒ `otmPrices` is used as
+     * given and the put-only bias is disclosed in `diagnostics`.
+     */
+    boundaryCallPrice?: number;
+    /**
+     * Set when `otmPrices` at `K₀` is ALREADY the CBOE put/call average (a chain extractor that
+     * averaged there). Suppresses the put-only bias disclosure without touching the arithmetic. Cannot
+     * be combined with `boundaryCallPrice` — that would average an average.
+     */
+    boundaryPriceAveraged?: boolean;
+}): Computed<VarianceSwapResult, {
+    measure: 'risk-neutral';
+    method: 'ddkz-replication';
+}>;
+//# sourceMappingURL=analytics.d.ts.map

package/modules/volatility/dist/analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics.d.ts","sourceRoot":"","sources":["../src/analytics.ts"],"names":[],"mappings":"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"}