qntjs-lib 1.0.3 → 1.1.1

package/dist/index.d.ts

@@ -2,4 +2,6 @@ export * as math from './math/index.js';
 export * as ta from './ta/index.js';
 export * as arr from './arr/arr.js';
 export * as stats from './stats/index.js';
+export * as perf from './perf/index.js';
+export type { MaxDrawdownInfo, DrawdownDurationResult } from './perf/index.js';
 export type { KstOptions, UltoscOptions, IchimokuOptions } from './ta/index.js';

package/dist/perf/dd.d.ts

@@ -0,0 +1,80 @@
+export type DrawdownDurationResult = {
+    durations: Int32Array;
+    maxDuration: number;
+};
+export type MaxDrawdownInfo = {
+    maxDrawdown: number;
+    peakIndex: number;
+    troughIndex: number;
+    startIndex: number;
+    endIndex: number;
+};
+/**
+ * Compute the drawdown series from an equity/price series.
+ * For valid points: out[i] = equity[i]/peak - 1 (<= 0). NaNs propagate and do not update the peak.
+ * @param equity Array-like equity or price series
+ * @returns Float64Array of drawdowns (same length)
+ */
+export declare function dd(equity: ArrayLike<number>): Float64Array;
+/**
+ * Compute the maximum drawdown magnitude over the entire series.
+ * Returns a positive number (0..+inf) or NaN when no valid points.
+ * @param equity Array-like equity or price series
+ * @returns Maximum drawdown magnitude (positive) or NaN
+ */
+export declare function maxdd(equity: ArrayLike<number>): number;
+/**
+ * Compute detailed information about the maximum drawdown, including peak, trough, and recovery indices.
+ * When no valid points exist returns NaN/placeholder indices (-1).
+ * @param equity Array-like equity or price series
+ * @returns MaxDrawdownInfo with `maxDrawdown`, `peakIndex`, `troughIndex`, `startIndex`, and `endIndex`
+ */
+export declare function maxddDetails(equity: ArrayLike<number>): MaxDrawdownInfo;
+/**
+ * Rolling maximum drawdown over a trailing window.
+ * For each index i computes the max drawdown observed within the trailing window.
+ * @param equity Array-like equity or price series
+ * @param window Rolling window length (positive integer)
+ * @returns Float64Array of rolling max drawdowns
+ */
+export declare function rollmaxdd(equity: ArrayLike<number>, window: number): Float64Array;
+/**
+ * Compute drawdown durations (consecutive periods in current drawdown) and the maximum duration.
+ * Positions where equity is NaN are marked with -1.
+ * @param equity Array-like equity or price series
+ * @returns DrawdownDurationResult { durations: Int32Array, maxDuration: number }
+ */
+export declare function dduration(equity: ArrayLike<number>): DrawdownDurationResult;
+/**
+ * Recovery factor: ratio of annualized return (CAGR) to maximum drawdown magnitude.
+ * Returns NaN if insufficient data, invalid start value, or zero/NaN max drawdown.
+ * @param equity Array-like equity or price series
+ * @param freq Periods per year (default 252)
+ * @returns Recovery factor or NaN
+ */
+export declare function recoveryFactor(equity: ArrayLike<number>, freq?: number): number;
+/**
+ * Calmar ratio: CAGR over a lookback period divided by the max drawdown magnitude over the same period.
+ * If `lookbackPeriodYears` is null uses the entire series. Returns NaN on invalid inputs or zero drawdown.
+ * @param equity Array-like equity or price series
+ * @param lookbackPeriodYears Lookback window in years (null = full span)
+ * @param freq Periods per year (default 252)
+ * @returns Calmar ratio or NaN
+ */
+export declare function calmarRatio(equity: ArrayLike<number>, lookbackPeriodYears?: number | null, freq?: number): number;
+/**
+ * Ulcer Index: measures depth and duration of drawdowns (root-mean-square of depths).
+ * Returns NaN for empty input.
+ * @param equity Array-like equity or price series
+ * @returns Ulcer Index (>=0) or NaN
+ */
+export declare function ulcerIndex(equity: ArrayLike<number>): number;
+/**
+ * Rolling Ulcer Index computed over a trailing window.
+ * Returns NaN for windows with insufficient valid samples (< minPeriod) or invalid window.
+ * @param equity Array-like equity or price series
+ * @param window Rolling window length (positive integer)
+ * @param minPeriod Minimum number of valid points required in window
+ * @returns Float64Array of rolling ulcer index values
+ */
+export declare function rollUlcerIndex(equity: ArrayLike<number>, window: number, minPeriod?: number): Float64Array;

package/dist/perf/distribution.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Value-at-Risk (VaR) estimator.
+ * Supports `historical` (empirical quantile) and `parametric` (normal) methods.
+ * Returns NaN for empty inputs or invalid alpha or when parametric stats are invalid.
+ * @param returns Array-like returns series
+ * @param alpha Tail probability (default 0.05)
+ * @param method 'historical' | 'parametric' (default 'historical')
+ * @returns VaR as a number (left-tail) or NaN
+ */
+export declare function valueAtRisk(returns: ArrayLike<number>, alpha?: number, method?: 'historical' | 'parametric'): number;
+/**
+ * Expected shortfall (conditional tail expectation) estimator.
+ * Supports `historical` (empirical mean of losses <= VaR) and `parametric` (normal) methods.
+ * Returns NaN for empty inputs, invalid alpha, or invalid parametric stats.
+ * @param returns Array-like returns series
+ * @param alpha Tail probability (default 0.05)
+ * @param method 'historical' | 'parametric' (default 'historical')
+ * @returns Expected shortfall (left-tail) or NaN
+ */
+export declare function expectedShortfall(returns: ArrayLike<number>, alpha?: number, method?: 'historical' | 'parametric'): number;
+/**
+ * Tail ratio: mean of upper tail divided by absolute mean of lower tail.
+ * Returns NaN for empty inputs, invalid alpha, or when either tail has no observations or lower mean is zero.
+ * @param returns Array-like returns series
+ * @param alpha Tail probability (default 0.05)
+ * @returns Tail ratio or NaN
+ */
+export declare function tailRatio(returns: ArrayLike<number>, alpha?: number): number;
+/**
+ * Omega ratio: sum of gains above `requiredReturn` divided by sum of losses below it.
+ * Returns NaN for empty inputs or when there is no variation (all gains or all losses zero).
+ * @param returns Array-like returns series
+ * @param requiredReturn Threshold for gains/losses (default 0)
+ * @returns Omega ratio number, Infinity if no losses, or NaN when no variation
+ */
+export declare function omegaRatio(returns: ArrayLike<number>, requiredReturn?: number): number;
+declare const _default: {
+    valueAtRisk: typeof valueAtRisk;
+    expectedShortfall: typeof expectedShortfall;
+    tailRatio: typeof tailRatio;
+    omegaRatio: typeof omegaRatio;
+};
+export default _default;

package/dist/perf/index.d.ts

@@ -0,0 +1,5 @@
+export { cagr, cumreturns, logreturns, returns, dailyReturns } from './returns.js';
+export { dd, dduration, maxdd, maxddDetails, recoveryFactor, calmarRatio, rollmaxdd, ulcerIndex, rollUlcerIndex } from './dd.js';
+export type { DrawdownDurationResult, MaxDrawdownInfo } from './dd.js';
+export { sharpe, sortino, rollsharpe, rollsortino, vol, rollvol } from './volatility.js';
+export { valueAtRisk, expectedShortfall, omegaRatio, tailRatio } from './distribution.js';

package/dist/perf/returns.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Compute simple period returns from a level series.
+ * For each i>0: returns[i] = source[i]/source[i-1] - 1 when both values are finite and previous != 0.
+ * The first element is always NaN. Invalid or non-finite inputs produce NaN at that position.
+ * @param source Input level series (prices/equity)
+ * @returns Float32Array of simple returns (same length as `source`)
+ */
+export declare function returns(source: ArrayLike<number>): Float32Array;
+/**
+ * Compute log returns from a level series.
+ * For each i>0: logreturns[i] = log(source[i]/source[i-1]) when both values are finite and previous>0.
+ * The first element is always NaN. Invalid or non-positive previous values yield NaN.
+ * @param source Input level series (prices/equity)
+ * @returns Float32Array of log returns (same length as `source`)
+ */
+export declare function logreturns(source: ArrayLike<number>): Float32Array;
+/**
+ * Compute cumulative compound returns from a returns series, skipping NaNs.
+ * Cumulative return at i is prod_{j<=i, r_j finite} (1+r_j) - 1; NaN inputs leave an output NaN at that position.
+ * @param returns Simple returns series
+ * @returns Float64Array of cumulative returns
+ */
+export declare function cumreturns(returns: ArrayLike<number>): Float64Array;
+/**
+ * Compute the compound annual growth rate (CAGR) from a returns series.
+ * Ignores NaNs. `freq` is the number of periods per year (default 252).
+ * @param returns Simple returns series
+ * @param freq Periods per year (default 252)
+ * @returns CAGR as a number, or NaN when insufficient data
+ */
+export declare function cagr(returns: ArrayLike<number>, freq?: number): number;
+/**
+ * Aggregate irregular (event-aligned) returns into calendar-day returns.
+ *
+ * The function groups `returnsArr` by calendar day (optionally shifted by `tzOffsetMinutes`),
+ * compounds returns within each day (prod(1+r)-1) and returns a continuous range of days
+ * from the minimum to the maximum observed day. Missing days are filled with zero returns.
+ *
+ * @param tsMs Array of timestamps (ms since epoch) aligned to `returnsArr`
+ * @param returnsArr Array of simple returns aligned to `tsMs`
+ * @param tzOffsetMinutes Optional timezone offset in minutes (default 0, UTC)
+ * @returns Object { days: number[], dailyReturns: Float32Array }
+ */
+export declare function dailyReturns(tsMs: ArrayLike<number>, returnsArr: ArrayLike<number>, tzOffsetMinutes?: number): {
+    days: number[];
+    dailyReturns: Float32Array<ArrayBuffer>;
+};

package/dist/perf/volatility.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Compute the (annualized) Sharpe ratio for a returns series.
+ * Uses NaN-aware mean and sample standard deviation (ddof=1).
+ * Returns NaN for empty input, zero or NaN volatility, or invalid mean.
+ * @param returns Array-like returns series
+ * @param riskFree Annualized risk-free rate (default 0)
+ * @param freq Periods per year (default 252)
+ * @returns Sharpe ratio (annualized) or NaN
+ */
+export declare function sharpe(returns: ArrayLike<number>, riskFree?: number, freq?: number): number;
+/**
+ * Compute the (annualized) Sortino ratio for a returns series.
+ * Uses downside deviation (sample corrected) computed over negative excess returns.
+ * Requires at least two downside observations; returns NaN otherwise.
+ * @param returns Array-like returns series
+ * @param requiredReturn Target return to define downside (default 0)
+ * @param freq Periods per year (default 252)
+ * @param minPeriod Minimum valid periods (unused for scalar Sortino)
+ * @returns Sortino ratio (annualized) or NaN
+ */
+export declare function sortino(returns: ArrayLike<number>, requiredReturn?: number, freq?: number, minPeriod?: number): number;
+/**
+ * Rolling Sharpe ratio computed over a trailing window.
+ * Output is a Float64Array aligned with `returns`; positions before enough data are NaN.
+ * @param returns Array-like returns series
+ * @param window Rolling window length
+ * @param riskFree Annualized risk-free rate (default 0)
+ * @param freq Periods per year (default 252)
+ * @param minPeriod Minimum number of valid samples required per window (default 1)
+ * @returns Float64Array of rolling Sharpe ratios
+ */
+export declare function rollsharpe(returns: ArrayLike<number>, window: number, riskFree?: number, freq?: number, minPeriod?: number): Float64Array;
+/**
+ * Rolling Sortino ratio computed over a trailing window using downside deviations.
+ * Outputs NaN where insufficient downside or invalid data exists.
+ * @param returns Array-like returns series
+ * @param window Rolling window length
+ * @param requiredReturn Target return to define downside (default 0)
+ * @param freq Periods per year (default 252)
+ * @param minPeriod Minimum number of valid samples required per window (default 1)
+ * @returns Float64Array of rolling Sortino ratios
+ */
+export declare function rollsortino(returns: ArrayLike<number>, window: number, requiredReturn?: number, freq?: number, minPeriod?: number): Float64Array;
+/**
+ * Annualized volatility (sample standard deviation) of returns.
+ * Uses NaN-aware `stats.stdev` with ddof=1. Returns NaN for empty input or zero/NaN sigma.
+ * @param returns Array-like returns series
+ * @param freq Periods per year (default 252)
+ * @returns Annualized volatility or NaN
+ */
+export declare function vol(returns: ArrayLike<number>, freq?: number): number;
+/**
+ * Rolling annualized volatility (sample stddev) over a trailing window.
+ * Outputs NaN for windows with insufficient valid samples or zero/NaN sigma.
+ * @param returns Array-like returns series
+ * @param window Rolling window length
+ * @param freq Periods per year (default 252)
+ * @param minPeriod Minimum number of valid samples required per window (default 1)
+ * @returns Float64Array of rolling volatilities
+ */
+export declare function rollvol(returns: ArrayLike<number>, window: number, freq?: number, minPeriod?: number): Float64Array;

package/dist/untyped/index.d.ts

@@ -31,6 +31,19 @@ export type IchimokuOptions = {
     senkouB?: number;
 };
 
+export type DrawdownDurationResult = {
+    durations: Int32Array;
+    maxDuration: number;
+};
+
+export type MaxDrawdownInfo = {
+    maxDrawdown: number;
+    peakIndex: number;
+    troughIndex: number;
+    startIndex: number;
+    endIndex: number;
+};
+
 declare namespace math {
   /**
    * Element-wise absolute value.
@@ -1191,4 +1204,220 @@ declare namespace stats {
   export function zscore(source: ArrayLike<number>, skipna?: boolean): number[];
 }
 
-export { math, ta, arr, stats };
+declare namespace perf {
+  /**
+   * Compute the compound annual growth rate (CAGR) from a returns series.
+   * Ignores NaNs. `freq` is the number of periods per year (default 252).
+   * @param returns Simple returns series
+   * @param freq Periods per year (default 252)
+   * @returns CAGR as a number, or NaN when insufficient data
+   */
+  export function cagr(returns: ArrayLike<number>, freq?: number): number;
+  /**
+   * Calmar ratio: CAGR over a lookback period divided by the max drawdown magnitude over the same period.
+   * If `lookbackPeriodYears` is null uses the entire series. Returns NaN on invalid inputs or zero drawdown.
+   * @param equity Array-like equity or price series
+   * @param lookbackPeriodYears Lookback window in years (null = full span)
+   * @param freq Periods per year (default 252)
+   * @returns Calmar ratio or NaN
+   */
+  export function calmarRatio(equity: ArrayLike<number>, lookbackPeriodYears?: number | null, freq?: number): number;
+  /**
+   * Compute cumulative compound returns from a returns series, skipping NaNs.
+   * Cumulative return at i is prod_{j<=i, r_j finite} (1+r_j) - 1; NaN inputs leave an output NaN at that position.
+   * @param returns Simple returns series
+   * @returns Float64Array of cumulative returns
+   */
+  export function cumreturns(returns: ArrayLike<number>): number[];
+  /**
+   * Aggregate irregular (event-aligned) returns into calendar-day returns.
+   *
+   * The function groups `returnsArr` by calendar day (optionally shifted by `tzOffsetMinutes`),
+   * compounds returns within each day (prod(1+r)-1) and returns a continuous range of days
+   * from the minimum to the maximum observed day. Missing days are filled with zero returns.
+   *
+   * @param tsMs Array of timestamps (ms since epoch) aligned to `returnsArr`
+   * @param returnsArr Array of simple returns aligned to `tsMs`
+   * @param tzOffsetMinutes Optional timezone offset in minutes (default 0, UTC)
+   * @returns Object { days: number[], dailyReturns: Float32Array }
+   */
+  export function dailyReturns(tsMs: ArrayLike<number>, returnsArr: ArrayLike<number>, tzOffsetMinutes?: number): {
+    days: number[];
+    dailyReturns: Float32Array<ArrayBuffer>;
+};
+  /**
+   * Compute the drawdown series from an equity/price series.
+   * For valid points: out[i] = equity[i]/peak - 1 (<= 0). NaNs propagate and do not update the peak.
+   * @param equity Array-like equity or price series
+   * @returns Float64Array of drawdowns (same length)
+   */
+  export function dd(equity: ArrayLike<number>): number[];
+  /**
+   * Compute drawdown durations (consecutive periods in current drawdown) and the maximum duration.
+   * Positions where equity is NaN are marked with -1.
+   * @param equity Array-like equity or price series
+   * @returns DrawdownDurationResult { durations: Int32Array, maxDuration: number }
+   */
+  export function dduration(equity: ArrayLike<number>): DrawdownDurationResult;
+  /**
+   * Expected shortfall (conditional tail expectation) estimator.
+   * Supports `historical` (empirical mean of losses <= VaR) and `parametric` (normal) methods.
+   * Returns NaN for empty inputs, invalid alpha, or invalid parametric stats.
+   * @param returns Array-like returns series
+   * @param alpha Tail probability (default 0.05)
+   * @param method 'historical' | 'parametric' (default 'historical')
+   * @returns Expected shortfall (left-tail) or NaN
+   */
+  export function expectedShortfall(returns: ArrayLike<number>, alpha?: number, method?: 'historical' | 'parametric'): number;
+  /**
+   * Compute log returns from a level series.
+   * For each i>0: logreturns[i] = log(source[i]/source[i-1]) when both values are finite and previous>0.
+   * The first element is always NaN. Invalid or non-positive previous values yield NaN.
+   * @param source Input level series (prices/equity)
+   * @returns Float32Array of log returns (same length as `source`)
+   */
+  export function logreturns(source: ArrayLike<number>): Float32Array;
+  /**
+   * Compute the maximum drawdown magnitude over the entire series.
+   * Returns a positive number (0..+inf) or NaN when no valid points.
+   * @param equity Array-like equity or price series
+   * @returns Maximum drawdown magnitude (positive) or NaN
+   */
+  export function maxdd(equity: ArrayLike<number>): number;
+  /**
+   * Compute detailed information about the maximum drawdown, including peak, trough, and recovery indices.
+   * When no valid points exist returns NaN/placeholder indices (-1).
+   * @param equity Array-like equity or price series
+   * @returns MaxDrawdownInfo with `maxDrawdown`, `peakIndex`, `troughIndex`, `startIndex`, and `endIndex`
+   */
+  export function maxddDetails(equity: ArrayLike<number>): MaxDrawdownInfo;
+  /**
+   * Omega ratio: sum of gains above `requiredReturn` divided by sum of losses below it.
+   * Returns NaN for empty inputs or when there is no variation (all gains or all losses zero).
+   * @param returns Array-like returns series
+   * @param requiredReturn Threshold for gains/losses (default 0)
+   * @returns Omega ratio number, Infinity if no losses, or NaN when no variation
+   */
+  export function omegaRatio(returns: ArrayLike<number>, requiredReturn?: number): number;
+  /**
+   * Recovery factor: ratio of annualized return (CAGR) to maximum drawdown magnitude.
+   * Returns NaN if insufficient data, invalid start value, or zero/NaN max drawdown.
+   * @param equity Array-like equity or price series
+   * @param freq Periods per year (default 252)
+   * @returns Recovery factor or NaN
+   */
+  export function recoveryFactor(equity: ArrayLike<number>, freq?: number): number;
+  /**
+   * Compute simple period returns from a level series.
+   * For each i>0: returns[i] = source[i]/source[i-1] - 1 when both values are finite and previous != 0.
+   * The first element is always NaN. Invalid or non-finite inputs produce NaN at that position.
+   * @param source Input level series (prices/equity)
+   * @returns Float32Array of simple returns (same length as `source`)
+   */
+  export function returns(source: ArrayLike<number>): Float32Array;
+  /**
+   * Rolling Ulcer Index computed over a trailing window.
+   * Returns NaN for windows with insufficient valid samples (< minPeriod) or invalid window.
+   * @param equity Array-like equity or price series
+   * @param window Rolling window length (positive integer)
+   * @param minPeriod Minimum number of valid points required in window
+   * @returns Float64Array of rolling ulcer index values
+   */
+  export function rollUlcerIndex(equity: ArrayLike<number>, window: number, minPeriod?: number): number[];
+  /**
+   * Rolling maximum drawdown over a trailing window.
+   * For each index i computes the max drawdown observed within the trailing window.
+   * @param equity Array-like equity or price series
+   * @param window Rolling window length (positive integer)
+   * @returns Float64Array of rolling max drawdowns
+   */
+  export function rollmaxdd(equity: ArrayLike<number>, window: number): number[];
+  /**
+   * Rolling Sharpe ratio computed over a trailing window.
+   * Output is a Float64Array aligned with `returns`; positions before enough data are NaN.
+   * @param returns Array-like returns series
+   * @param window Rolling window length
+   * @param riskFree Annualized risk-free rate (default 0)
+   * @param freq Periods per year (default 252)
+   * @param minPeriod Minimum number of valid samples required per window (default 1)
+   * @returns Float64Array of rolling Sharpe ratios
+   */
+  export function rollsharpe(returns: ArrayLike<number>, window: number, riskFree?: number, freq?: number, minPeriod?: number): number[];
+  /**
+   * Rolling Sortino ratio computed over a trailing window using downside deviations.
+   * Outputs NaN where insufficient downside or invalid data exists.
+   * @param returns Array-like returns series
+   * @param window Rolling window length
+   * @param requiredReturn Target return to define downside (default 0)
+   * @param freq Periods per year (default 252)
+   * @param minPeriod Minimum number of valid samples required per window (default 1)
+   * @returns Float64Array of rolling Sortino ratios
+   */
+  export function rollsortino(returns: ArrayLike<number>, window: number, requiredReturn?: number, freq?: number, minPeriod?: number): number[];
+  /**
+   * Rolling annualized volatility (sample stddev) over a trailing window.
+   * Outputs NaN for windows with insufficient valid samples or zero/NaN sigma.
+   * @param returns Array-like returns series
+   * @param window Rolling window length
+   * @param freq Periods per year (default 252)
+   * @param minPeriod Minimum number of valid samples required per window (default 1)
+   * @returns Float64Array of rolling volatilities
+   */
+  export function rollvol(returns: ArrayLike<number>, window: number, freq?: number, minPeriod?: number): number[];
+  /**
+   * Compute the (annualized) Sharpe ratio for a returns series.
+   * Uses NaN-aware mean and sample standard deviation (ddof=1).
+   * Returns NaN for empty input, zero or NaN volatility, or invalid mean.
+   * @param returns Array-like returns series
+   * @param riskFree Annualized risk-free rate (default 0)
+   * @param freq Periods per year (default 252)
+   * @returns Sharpe ratio (annualized) or NaN
+   */
+  export function sharpe(returns: ArrayLike<number>, riskFree?: number, freq?: number): number;
+  /**
+   * Compute the (annualized) Sortino ratio for a returns series.
+   * Uses downside deviation (sample corrected) computed over negative excess returns.
+   * Requires at least two downside observations; returns NaN otherwise.
+   * @param returns Array-like returns series
+   * @param requiredReturn Target return to define downside (default 0)
+   * @param freq Periods per year (default 252)
+   * @param minPeriod Minimum valid periods (unused for scalar Sortino)
+   * @returns Sortino ratio (annualized) or NaN
+   */
+  export function sortino(returns: ArrayLike<number>, requiredReturn?: number, freq?: number, minPeriod?: number): number;
+  /**
+   * Tail ratio: mean of upper tail divided by absolute mean of lower tail.
+   * Returns NaN for empty inputs, invalid alpha, or when either tail has no observations or lower mean is zero.
+   * @param returns Array-like returns series
+   * @param alpha Tail probability (default 0.05)
+   * @returns Tail ratio or NaN
+   */
+  export function tailRatio(returns: ArrayLike<number>, alpha?: number): number;
+  /**
+   * Ulcer Index: measures depth and duration of drawdowns (root-mean-square of depths).
+   * Returns NaN for empty input.
+   * @param equity Array-like equity or price series
+   * @returns Ulcer Index (>=0) or NaN
+   */
+  export function ulcerIndex(equity: ArrayLike<number>): number;
+  /**
+   * Value-at-Risk (VaR) estimator.
+   * Supports `historical` (empirical quantile) and `parametric` (normal) methods.
+   * Returns NaN for empty inputs or invalid alpha or when parametric stats are invalid.
+   * @param returns Array-like returns series
+   * @param alpha Tail probability (default 0.05)
+   * @param method 'historical' | 'parametric' (default 'historical')
+   * @returns VaR as a number (left-tail) or NaN
+   */
+  export function valueAtRisk(returns: ArrayLike<number>, alpha?: number, method?: 'historical' | 'parametric'): number;
+  /**
+   * Annualized volatility (sample standard deviation) of returns.
+   * Uses NaN-aware `stats.stdev` with ddof=1. Returns NaN for empty input or zero/NaN sigma.
+   * @param returns Array-like returns series
+   * @param freq Periods per year (default 252)
+   * @returns Annualized volatility or NaN
+   */
+  export function vol(returns: ArrayLike<number>, freq?: number): number;
+}
+
+export { math, ta, arr, stats, perf };

package/dist/untyped/index.js

@@ -24,6 +24,7 @@ export const math = wrapNamespace(core.math || {});
 export const ta = wrapNamespace(core.ta || {});
 export const arr = wrapNamespace(core.arr || {});
 export const stats = wrapNamespace(core.stats || {});
+export const perf = wrapNamespace(core.perf || {});
 
-const _default = { math, ta, arr, stats };
+const _default = { math, ta, arr, stats, perf };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qntjs-lib",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "type": "module",
   "main": "./dist/bundle/index.js",
   "types": "./dist/index.d.ts",