@samsmith2121/synthetic-leverage-engine 0.1.0

package/dist/src/backtest.d.ts

@@ -0,0 +1,3 @@
+import { BacktestResult, DayInput, EngineConfig, MonteCarloConfig, MonteCarloResult } from './types';
+export declare function runFixedBacktest(days: DayInput[], config: EngineConfig): BacktestResult;
+export declare function runMonteCarloBacktest(sourceDays: DayInput[], engineConfig: EngineConfig, mcConfig: MonteCarloConfig): MonteCarloResult;

package/dist/src/backtest.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFixedBacktest = runFixedBacktest;
+exports.runMonteCarloBacktest = runMonteCarloBacktest;
+const benchmark_1 = require("./benchmark");
+const step_1 = require("./step");
+const metrics_1 = require("./metrics");
+const validation_1 = require("./validation");
+const DEFAULT_BLOCK_LENGTH = 5;
+function runFixedBacktest(days, config) {
+    (0, validation_1.validateConfig)(config);
+    (0, validation_1.validateDayInputs)(days, config);
+    const daily = [];
+    let previousTargetPosition = config.initialTargetPosition ?? 0;
+    let previousAppliedPosition = config.initialAppliedPosition ?? previousTargetPosition;
+    let previousBorrowRateDaily = config.initialBorrowRateDaily ?? days[0].borrowRateDaily;
+    for (let i = 0; i < days.length; i += 1) {
+        const day = days[i];
+        const previousDay = i > 0 ? days[i - 1] : undefined;
+        const previousState = i > 0 ? daily[i - 1] : undefined;
+        const state = (0, step_1.runDayStep)({
+            day,
+            previousDay,
+            previousState,
+            previousTargetPosition,
+            previousAppliedPosition,
+            previousBorrowRateDaily,
+            config,
+        });
+        daily.push(state);
+        previousTargetPosition = state.targetPosition;
+        previousAppliedPosition = state.appliedPosition;
+        previousBorrowRateDaily = state.borrowRateDaily;
+    }
+    const result = (0, step_1.summarizeResult)(daily);
+    result.benchmark = buildBenchmarkResult(days, result);
+    result.invariants = (0, validation_1.evaluateBacktestInvariants)(result.daily, result.benchmark ?? null);
+    if (config.enableInvariantChecks ?? true) {
+        (0, validation_1.assertBacktestInvariants)(result.daily);
+    }
+    return result;
+}
+function runMonteCarloBacktest(sourceDays, engineConfig, mcConfig) {
+    (0, validation_1.validateConfig)(engineConfig);
+    (0, validation_1.validateDayInputs)(sourceDays, engineConfig);
+    (0, validation_1.validateMonteCarloConfig)(mcConfig);
+    const seedBase = mcConfig.seed ?? 123456789;
+    const blockLength = resolveBlockLength(mcConfig.blockLength, sourceDays.length);
+    const pathResults = [];
+    for (let i = 0; i < mcConfig.paths; i += 1) {
+        const seed = (seedBase + i) >>> 0;
+        const rng = mulberry32(seed);
+        const pathDays = buildSyntheticPath(sourceDays, mcConfig.horizonDays, blockLength, rng);
+        const result = runFixedBacktest(pathDays, engineConfig);
+        pathResults.push({ index: i, seed, result });
+    }
+    const monteCarloResult = {
+        config: {
+            ...mcConfig,
+            blockLength,
+        },
+        paths: pathResults,
+        summary: buildMonteCarloSummary(pathResults.map((p) => p.result)),
+    };
+    const sameSeedCheck = rerunMonteCarloForInvariant(sourceDays, engineConfig, {
+        ...mcConfig,
+        blockLength,
+    });
+    const differentSeedCheck = rerunMonteCarloForInvariant(sourceDays, engineConfig, {
+        ...mcConfig,
+        seed: (seedBase + 1) >>> 0,
+        blockLength,
+    });
+    monteCarloResult.invariants = (0, validation_1.evaluateMonteCarloInvariants)(monteCarloResult, sameSeedCheck, differentSeedCheck);
+    return monteCarloResult;
+}
+function rerunMonteCarloForInvariant(sourceDays, engineConfig, mcConfig) {
+    const seedBase = mcConfig.seed ?? 123456789;
+    const blockLength = resolveBlockLength(mcConfig.blockLength, sourceDays.length);
+    const paths = [];
+    for (let i = 0; i < mcConfig.paths; i += 1) {
+        const seed = (seedBase + i) >>> 0;
+        const rng = mulberry32(seed);
+        const pathDays = buildSyntheticPath(sourceDays, mcConfig.horizonDays, blockLength, rng);
+        paths.push({ index: i, seed, result: runFixedBacktest(pathDays, engineConfig) });
+    }
+    return {
+        config: mcConfig,
+        paths,
+        summary: buildMonteCarloSummary(paths.map((p) => p.result)),
+    };
+}
+function buildBenchmarkResult(days, result) {
+    const strategyReturns = result.daily.map((state) => ({
+        date: state.date,
+        value: state.capitalBaseBeforeReturn === 0 ? 0 : state.equityEnd / state.capitalBaseBeforeReturn - 1,
+    }));
+    const benchmarkReturns = days
+        .filter((d) => d.benchmarkReturn !== undefined)
+        .map((d) => ({ date: d.date, value: d.benchmarkReturn ?? 0 }));
+    return (0, benchmark_1.buildBenchmarkComparison)(strategyReturns, benchmarkReturns, result.daily[0]?.equityStart ?? 0);
+}
+function buildSyntheticPath(sourceDays, horizonDays, blockLength, rng) {
+    const startDate = new Date(`${sourceDays[0].date}T00:00:00Z`);
+    const generated = [];
+    const contiguousTuples = sourceDays.map((day) => ({
+        assetReturn: day.assetReturn,
+        signalInput: day.signalInput,
+        borrowRateDaily: day.borrowRateDaily,
+        benchmarkReturn: day.benchmarkReturn,
+        contribution: day.contribution,
+        expenseRatioAnnual: day.expenseRatioAnnual,
+        tradeSpread: day.tradeSpread,
+    }));
+    let generatedDays = 0;
+    const maxStartIndex = contiguousTuples.length - blockLength;
+    while (generatedDays < horizonDays) {
+        // Non-wrapping block bootstrap: sample only starts where a full block fits in source history.
+        const startIndex = Math.floor(rng() * (maxStartIndex + 1));
+        const currentBlockLength = Math.min(blockLength, horizonDays - generatedDays);
+        for (let j = 0; j < currentBlockLength; j += 1) {
+            const sampled = contiguousTuples[startIndex + j];
+            const date = new Date(startDate.getTime());
+            date.setUTCDate(startDate.getUTCDate() + generatedDays);
+            generated.push({
+                ...sampled,
+                date: date.toISOString().slice(0, 10),
+            });
+            generatedDays += 1;
+        }
+    }
+    return generated;
+}
+function resolveBlockLength(configBlockLength, sourceLength) {
+    const blockLength = configBlockLength ?? DEFAULT_BLOCK_LENGTH;
+    if (blockLength > sourceLength) {
+        throw new Error('blockLength must not exceed sourceDays length');
+    }
+    return blockLength;
+}
+function buildMonteCarloSummary(results) {
+    const endingEquitySeries = results.map((r) => r.finalEquity);
+    const twrSeries = results.map((r) => r.twrCagr ?? 0);
+    const maxDrawdownSeries = results.map((r) => r.maxDrawdown);
+    const endingEquity = summarizePercentiles(endingEquitySeries);
+    const twrCagr = summarizePercentiles(twrSeries);
+    const maxDrawdown = summarizePercentiles(maxDrawdownSeries);
+    return {
+        endingEquity,
+        twrCagr,
+        maxDrawdown,
+        medianEndingEquity: endingEquity.p50,
+        medianTwrCagr: twrCagr.p50,
+        medianMaxDrawdown: maxDrawdown.p50,
+    };
+}
+function summarizePercentiles(values) {
+    return {
+        p5: (0, metrics_1.percentile)(values, 0.05),
+        p50: (0, metrics_1.percentile)(values, 0.5),
+        p95: (0, metrics_1.percentile)(values, 0.95),
+    };
+}
+function mulberry32(seed) {
+    let s = seed >>> 0;
+    return function next() {
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = Math.imul(s ^ (s >>> 15), 1 | s);
+        t ^= t + Math.imul(t ^ (t >>> 7), 61 | t);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}

package/dist/src/benchmark.d.ts

@@ -0,0 +1,11 @@
+import { BenchmarkComparison, ReturnPoint } from './types';
+export interface AlignedSeries {
+    dates: string[];
+    strategyReturns: number[];
+    benchmarkReturns: number[];
+}
+/**
+ * Matched-date alignment only. Non-overlapping dates are excluded by design.
+ */
+export declare function alignReturnsByMatchedDates(strategy: ReturnPoint[], benchmark: ReturnPoint[]): AlignedSeries;
+export declare function buildBenchmarkComparison(strategy: ReturnPoint[], benchmark: ReturnPoint[], initialEquity: number): BenchmarkComparison | null;

package/dist/src/benchmark.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alignReturnsByMatchedDates = alignReturnsByMatchedDates;
+exports.buildBenchmarkComparison = buildBenchmarkComparison;
+const metrics_1 = require("./metrics");
+/**
+ * Matched-date alignment only. Non-overlapping dates are excluded by design.
+ */
+function alignReturnsByMatchedDates(strategy, benchmark) {
+    const strategyMap = new Map(strategy.map((r) => [r.date, r.value]));
+    const benchmarkMap = new Map(benchmark.map((r) => [r.date, r.value]));
+    const dates = [...strategyMap.keys()]
+        .filter((d) => benchmarkMap.has(d))
+        .sort((a, b) => a.localeCompare(b));
+    return {
+        dates,
+        strategyReturns: dates.map((d) => strategyMap.get(d) ?? 0),
+        benchmarkReturns: dates.map((d) => benchmarkMap.get(d) ?? 0),
+    };
+}
+function buildBenchmarkComparison(strategy, benchmark, initialEquity) {
+    const aligned = alignReturnsByMatchedDates(strategy, benchmark);
+    if (aligned.dates.length === 0) {
+        return null;
+    }
+    const strategyEquity = [];
+    const benchmarkEquity = [];
+    let strategyLevel = initialEquity;
+    let benchmarkLevel = initialEquity;
+    for (let i = 0; i < aligned.dates.length; i += 1) {
+        strategyLevel *= 1 + aligned.strategyReturns[i];
+        benchmarkLevel *= 1 + aligned.benchmarkReturns[i];
+        strategyEquity.push(strategyLevel);
+        benchmarkEquity.push(benchmarkLevel);
+    }
+    const benchmarkTotalReturn = (0, metrics_1.computeTotalReturn)(benchmarkEquity, initialEquity) ?? 0;
+    const strategyTotalReturn = (0, metrics_1.computeTotalReturn)(strategyEquity, initialEquity);
+    const benchmarkTwrCagr = computeCagrFromReturns(aligned.dates, aligned.benchmarkReturns);
+    const strategyTwrCagr = computeCagrFromReturns(aligned.dates, aligned.strategyReturns);
+    const benchmarkVolatility = (0, metrics_1.computeVolatilityFromReturns)(aligned.benchmarkReturns);
+    const benchmarkMaxDrawdown = (0, metrics_1.computeMaxDrawdownFromEquity)(benchmarkEquity);
+    const excessTotalReturn = strategyTotalReturn === null ? null : strategyTotalReturn - benchmarkTotalReturn;
+    const excessTwrCagr = strategyTwrCagr === null || benchmarkTwrCagr === null ? null : strategyTwrCagr - benchmarkTwrCagr;
+    const trackingError = computeTrackingError(aligned.strategyReturns, aligned.benchmarkReturns);
+    return {
+        dates: aligned.dates,
+        strategyReturns: aligned.strategyReturns,
+        benchmarkReturns: aligned.benchmarkReturns,
+        strategyEquity,
+        benchmarkEquity,
+        benchmarkTotalReturn,
+        benchmarkTwrCagr,
+        benchmarkVolatility,
+        benchmarkMaxDrawdown,
+        excessTotalReturn,
+        excessTwrCagr,
+        trackingError,
+    };
+}
+function computeTrackingError(strategyReturns, benchmarkReturns) {
+    if (strategyReturns.length !== benchmarkReturns.length || strategyReturns.length < 2) {
+        return null;
+    }
+    const activeReturns = strategyReturns.map((value, idx) => value - benchmarkReturns[idx]);
+    return (0, metrics_1.computeVolatilityFromReturns)(activeReturns);
+}
+function computeCagrFromReturns(dates, returns) {
+    if (dates.length < 2 || returns.length !== dates.length) {
+        return null;
+    }
+    let multiplier = 1;
+    for (const r of returns) {
+        if (!Number.isFinite(r) || r <= -1) {
+            return null;
+        }
+        multiplier *= 1 + r;
+    }
+    const start = new Date(`${dates[0]}T00:00:00Z`).getTime();
+    const end = new Date(`${dates[dates.length - 1]}T00:00:00Z`).getTime();
+    const daySpan = (end - start) / (1000 * 60 * 60 * 24);
+    if (daySpan <= 0) {
+        return null;
+    }
+    return Math.pow(multiplier, 365.25 / daySpan) - 1;
+}

package/dist/src/contributions.d.ts

@@ -0,0 +1,4 @@
+import { DayInput } from './types';
+/** Contribution timing convention: contribution is credited before day-t return. */
+export declare function getContributionForDay(day: DayInput): number;
+export declare function applyContribution(equity: number, contribution: number): number;

package/dist/src/contributions.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContributionForDay = getContributionForDay;
+exports.applyContribution = applyContribution;
+/** Contribution timing convention: contribution is credited before day-t return. */
+function getContributionForDay(day) {
+    return day.contribution ?? 0;
+}
+function applyContribution(equity, contribution) {
+    return equity + contribution;
+}

package/dist/src/costs.d.ts

@@ -0,0 +1,8 @@
+export declare function calculateTurnoverNotional(appliedPosition: number, priorAppliedPosition: number, equityBase: number): number;
+/** Trade cost convention: charged at start of day on turnover notional. */
+export declare function calculateTradeCost(turnoverNotional: number, tradeCostRate: number, tradeSpread?: number): number;
+/** Borrow drag applies only to exposure above 1x notional. */
+export declare function calculateBorrowDrag(appliedPosition: number, equityBase: number, borrowRateDaily: number): number;
+/** Expense-ratio drag is applied separately from borrow drag. */
+export declare function calculateExpenseDrag(equityBase: number, expenseRatioDaily: number): number;
+export declare function annualToDailyRate(annualRate: number): number;

package/dist/src/costs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTurnoverNotional = calculateTurnoverNotional;
+exports.calculateTradeCost = calculateTradeCost;
+exports.calculateBorrowDrag = calculateBorrowDrag;
+exports.calculateExpenseDrag = calculateExpenseDrag;
+exports.annualToDailyRate = annualToDailyRate;
+function calculateTurnoverNotional(appliedPosition, priorAppliedPosition, equityBase) {
+    return Math.abs(appliedPosition - priorAppliedPosition) * equityBase;
+}
+/** Trade cost convention: charged at start of day on turnover notional. */
+function calculateTradeCost(turnoverNotional, tradeCostRate, tradeSpread = 0) {
+    return turnoverNotional * (tradeCostRate + tradeSpread);
+}
+/** Borrow drag applies only to exposure above 1x notional. */
+function calculateBorrowDrag(appliedPosition, equityBase, borrowRateDaily) {
+    const borrowedFraction = Math.max(0, Math.abs(appliedPosition) - 1);
+    return borrowedFraction * equityBase * borrowRateDaily;
+}
+/** Expense-ratio drag is applied separately from borrow drag. */
+function calculateExpenseDrag(equityBase, expenseRatioDaily) {
+    return equityBase * expenseRatioDaily;
+}
+function annualToDailyRate(annualRate) {
+    if (annualRate <= -1) {
+        throw new Error('annualRate must be greater than -1');
+    }
+    return Math.pow(1 + annualRate, 1 / 365.25) - 1;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Public entry points for UI and application integrations.
+ * Prefer importing from this module (especially `public-api`) over deep internal files.
+ */
+export * from './public-api';
+export * from './types';
+export * from './signal';
+export * from './costs';
+export * from './contributions';
+export * from './benchmark';
+export * from './metrics';
+export * from './step';
+export * from './backtest';
+export * from './validation';
+export * from './analysis';
+export * from './reporting';
+export * from './validation-cases';
+export * from './validation-harness';

package/dist/src/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Public entry points for UI and application integrations.
+ * Prefer importing from this module (especially `public-api`) over deep internal files.
+ */
+__exportStar(require("./public-api"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./signal"), exports);
+__exportStar(require("./costs"), exports);
+__exportStar(require("./contributions"), exports);
+__exportStar(require("./benchmark"), exports);
+__exportStar(require("./metrics"), exports);
+__exportStar(require("./step"), exports);
+__exportStar(require("./backtest"), exports);
+__exportStar(require("./validation"), exports);
+__exportStar(require("./analysis"), exports);
+__exportStar(require("./reporting"), exports);
+__exportStar(require("./validation-cases"), exports);
+__exportStar(require("./validation-harness"), exports);

package/dist/src/metrics.d.ts

@@ -0,0 +1,15 @@
+import { CashFlowPoint, DailyState } from './types';
+/**
+ * True flow-neutral TWR CAGR.
+ * Daily return neutralizes external cash flows by using capital base after contribution.
+ */
+export declare function computeTwrCagr(dailyStates: DailyState[]): number | null;
+export declare function computeMaxDrawdownFromEquity(equityCurve: number[]): number;
+export declare function computeTotalReturn(equityCurve: number[], initialEquity: number): number | null;
+export declare function computeVolatilityFromReturns(returns: number[]): number | null;
+export declare function percentile(values: number[], p: number): number;
+/**
+ * XIRR with Newton + bracketed bisection fallback.
+ * Returns null when a valid root cannot be found safely.
+ */
+export declare function computeXirr(cashFlows: CashFlowPoint[], guess?: number, maxIterations?: number, tolerance?: number): number | null;

package/dist/src/metrics.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeTwrCagr = computeTwrCagr;
+exports.computeMaxDrawdownFromEquity = computeMaxDrawdownFromEquity;
+exports.computeTotalReturn = computeTotalReturn;
+exports.computeVolatilityFromReturns = computeVolatilityFromReturns;
+exports.percentile = percentile;
+exports.computeXirr = computeXirr;
+const DAYS_IN_YEAR = 365.25;
+/**
+ * True flow-neutral TWR CAGR.
+ * Daily return neutralizes external cash flows by using capital base after contribution.
+ */
+function computeTwrCagr(dailyStates) {
+    if (dailyStates.length < 2) {
+        return null;
+    }
+    let twrMultiplier = 1;
+    for (const state of dailyStates) {
+        const base = state.capitalBaseBeforeReturn;
+        if (!Number.isFinite(base) || base <= 0) {
+            return null;
+        }
+        const dailyReturn = state.equityEnd / base - 1;
+        if (!Number.isFinite(dailyReturn) || dailyReturn <= -1) {
+            return null;
+        }
+        twrMultiplier *= 1 + dailyReturn;
+    }
+    if (twrMultiplier <= 0) {
+        return null;
+    }
+    const days = dayDiff(dailyStates[0].date, dailyStates[dailyStates.length - 1].date);
+    if (days <= 0) {
+        return null;
+    }
+    return Math.pow(twrMultiplier, DAYS_IN_YEAR / days) - 1;
+}
+function computeMaxDrawdownFromEquity(equityCurve) {
+    if (equityCurve.length === 0) {
+        return 0;
+    }
+    let peak = equityCurve[0];
+    let maxDrawdown = 0;
+    for (const level of equityCurve) {
+        if (level > peak) {
+            peak = level;
+        }
+        if (peak > 0) {
+            const drawdown = (peak - level) / peak;
+            if (drawdown > maxDrawdown) {
+                maxDrawdown = drawdown;
+            }
+        }
+    }
+    return maxDrawdown;
+}
+function computeTotalReturn(equityCurve, initialEquity) {
+    if (equityCurve.length === 0 || initialEquity <= 0) {
+        return null;
+    }
+    const end = equityCurve[equityCurve.length - 1];
+    if (!Number.isFinite(end)) {
+        return null;
+    }
+    return end / initialEquity - 1;
+}
+function computeVolatilityFromReturns(returns) {
+    if (returns.length < 2) {
+        return null;
+    }
+    const mean = returns.reduce((acc, v) => acc + v, 0) / returns.length;
+    const variance = returns.reduce((acc, v) => acc + (v - mean) ** 2, 0) / (returns.length - 1);
+    if (!Number.isFinite(variance)) {
+        return null;
+    }
+    return Math.sqrt(variance) * Math.sqrt(365.25);
+}
+function percentile(values, p) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const clampedP = Math.max(0, Math.min(1, p));
+    const index = clampedP * (sorted.length - 1);
+    const lo = Math.floor(index);
+    const hi = Math.ceil(index);
+    if (lo === hi) {
+        return sorted[lo];
+    }
+    const weight = index - lo;
+    return sorted[lo] * (1 - weight) + sorted[hi] * weight;
+}
+/**
+ * XIRR with Newton + bracketed bisection fallback.
+ * Returns null when a valid root cannot be found safely.
+ */
+function computeXirr(cashFlows, guess = 0.1, maxIterations = 100, tolerance = 1e-8) {
+    if (cashFlows.length < 2) {
+        return null;
+    }
+    const ordered = [...cashFlows].sort((a, b) => a.date.localeCompare(b.date));
+    const hasPositive = ordered.some((f) => f.amount > 0);
+    const hasNegative = ordered.some((f) => f.amount < 0);
+    if (!hasPositive || !hasNegative) {
+        return null;
+    }
+    const newton = tryNewton(ordered, guess, maxIterations, tolerance);
+    if (newton !== null) {
+        return newton;
+    }
+    const bracket = findBracket(ordered);
+    if (bracket === null) {
+        return null;
+    }
+    return bisection(ordered, bracket.low, bracket.high, maxIterations * 2, tolerance);
+}
+function tryNewton(flows, guess, maxIterations, tolerance) {
+    let rate = Math.max(-0.95, guess);
+    for (let i = 0; i < maxIterations; i += 1) {
+        const val = npvAndDerivative(flows, rate);
+        if (val === null) {
+            return null;
+        }
+        const { npv, dNpv } = val;
+        if (Math.abs(npv) < tolerance) {
+            return rate;
+        }
+        if (!Number.isFinite(dNpv) || Math.abs(dNpv) < 1e-12) {
+            return null;
+        }
+        const next = rate - npv / dNpv;
+        if (!Number.isFinite(next) || next <= -0.999999) {
+            return null;
+        }
+        if (Math.abs(next - rate) < tolerance) {
+            return next;
+        }
+        rate = next;
+    }
+    return null;
+}
+function findBracket(flows) {
+    let low = -0.95;
+    let fLow = npv(flows, low);
+    if (fLow === null) {
+        return null;
+    }
+    const candidates = [0, 0.1, 0.2, 0.5, 1, 2, 5, 10, 25, 50, 100];
+    for (const high of candidates) {
+        const fHigh = npv(flows, high);
+        if (fHigh === null) {
+            continue;
+        }
+        if (fLow === 0) {
+            return { low, high: low };
+        }
+        if (fLow * fHigh < 0) {
+            return { low, high };
+        }
+        low = high;
+        fLow = fHigh;
+    }
+    return null;
+}
+function bisection(flows, low, high, maxIterations, tolerance) {
+    let fLow = npv(flows, low);
+    let fHigh = npv(flows, high);
+    if (fLow === null || fHigh === null || fLow * fHigh > 0) {
+        return null;
+    }
+    if (Math.abs(fLow) < tolerance) {
+        return low;
+    }
+    if (Math.abs(fHigh) < tolerance) {
+        return high;
+    }
+    for (let i = 0; i < maxIterations; i += 1) {
+        const mid = (low + high) / 2;
+        const fMid = npv(flows, mid);
+        if (fMid === null) {
+            return null;
+        }
+        if (Math.abs(fMid) < tolerance || Math.abs(high - low) < tolerance) {
+            return mid;
+        }
+        if (fLow * fMid < 0) {
+            high = mid;
+            fHigh = fMid;
+        }
+        else {
+            low = mid;
+            fLow = fMid;
+        }
+    }
+    return (low + high) / 2;
+}
+function npvAndDerivative(cashFlows, rate) {
+    if (rate <= -1) {
+        return null;
+    }
+    const t0 = toUnixDays(cashFlows[0].date);
+    let sum = 0;
+    let derivative = 0;
+    for (const flow of cashFlows) {
+        const t = (toUnixDays(flow.date) - t0) / DAYS_IN_YEAR;
+        const base = 1 + rate;
+        if (base <= 0) {
+            return null;
+        }
+        const discount = Math.pow(base, t);
+        if (!Number.isFinite(discount) || discount === 0) {
+            return null;
+        }
+        sum += flow.amount / discount;
+        derivative += (-t * flow.amount) / (discount * base);
+    }
+    if (!Number.isFinite(sum) || !Number.isFinite(derivative)) {
+        return null;
+    }
+    return { npv: sum, dNpv: derivative };
+}
+function npv(cashFlows, rate) {
+    const val = npvAndDerivative(cashFlows, rate);
+    return val?.npv ?? null;
+}
+function dayDiff(start, end) {
+    return Math.max(0, toUnixDays(end) - toUnixDays(start));
+}
+function toUnixDays(date) {
+    return new Date(`${date}T00:00:00Z`).getTime() / (1000 * 60 * 60 * 24);
+}