orderflow-metrics 0.24.0

package/dist/rangevol.js

@@ -0,0 +1,101 @@
+/**
+ * Range-based volatility estimators from OHLC candles.
+ *
+ * Close-to-close realized volatility (see `volatility`) throws away most of each
+ * bar — it reads only the close. But the open, high, and low carry information
+ * too, and using them yields far more efficient volatility estimates from the
+ * same data. Four classic estimators, in increasing order of what they use:
+ *
+ *  - Parkinson (1980): the high-low range only.
+ *  - Garman-Klass (1980): adds the open and close.
+ *  - Rogers-Satchell (1991): drift-independent (correct under a trending mean).
+ *  - Yang-Zhang (2000): drift-independent and robust to overnight jumps.
+ *
+ * Each returns the estimated volatility (standard deviation) *per bar*. To
+ * annualize, multiply the variance by the number of bars per year, or the
+ * volatility by its square root. Prices must be strictly positive.
+ */
+const LN2 = Math.LN2;
+/** Parkinson (1980) high-low volatility. Returns 0 for an empty input. */
+export function parkinsonVolatility(bars) {
+    const n = bars.length;
+    if (n === 0)
+        return 0;
+    let s = 0;
+    for (const b of bars) {
+        const hl = Math.log(b.high / b.low);
+        s += hl * hl;
+    }
+    return Math.sqrt(s / (4 * LN2) / n);
+}
+/** Garman-Klass (1980) OHLC volatility. Returns 0 for an empty input. */
+export function garmanKlassVolatility(bars) {
+    const n = bars.length;
+    if (n === 0)
+        return 0;
+    let s = 0;
+    for (const b of bars) {
+        const hl = Math.log(b.high / b.low);
+        const co = Math.log(b.close / b.open);
+        s += 0.5 * hl * hl - (2 * LN2 - 1) * co * co;
+    }
+    const v = s / n;
+    return v > 0 ? Math.sqrt(v) : 0;
+}
+/**
+ * Rogers-Satchell (1991) drift-independent OHLC volatility. Correct even when
+ * the price has a non-zero mean drift. Returns 0 for an empty input.
+ */
+export function rogersSatchellVolatility(bars) {
+    const n = bars.length;
+    if (n === 0)
+        return 0;
+    let s = 0;
+    for (const b of bars) {
+        s +=
+            Math.log(b.high / b.close) * Math.log(b.high / b.open) +
+                Math.log(b.low / b.close) * Math.log(b.low / b.open);
+    }
+    const v = s / n;
+    return v > 0 ? Math.sqrt(v) : 0;
+}
+/**
+ * Yang-Zhang (2000) volatility: a minimum-variance combination of overnight,
+ * open-to-close, and Rogers-Satchell variances that is both drift-independent
+ * and robust to opening jumps. Uses each bar's open relative to the previous
+ * close, so it needs at least three bars; returns 0 otherwise.
+ */
+export function yangZhangVolatility(bars) {
+    const n = bars.length;
+    if (n < 3)
+        return 0;
+    const overnight = [];
+    const openClose = [];
+    let rs = 0;
+    for (let i = 1; i < n; i++) {
+        const prev = bars[i - 1];
+        const b = bars[i];
+        overnight.push(Math.log(b.open / prev.close));
+        openClose.push(Math.log(b.close / b.open));
+        rs +=
+            Math.log(b.high / b.close) * Math.log(b.high / b.open) +
+                Math.log(b.low / b.close) * Math.log(b.low / b.open);
+    }
+    const m = overnight.length;
+    const mean = (a) => a.reduce((x, y) => x + y, 0) / a.length;
+    const ob = mean(overnight);
+    const cb = mean(openClose);
+    let so = 0;
+    let sc = 0;
+    for (let i = 0; i < m; i++) {
+        so += (overnight[i] - ob) ** 2;
+        sc += (openClose[i] - cb) ** 2;
+    }
+    so /= m - 1;
+    sc /= m - 1;
+    const rsv = rs / m;
+    const k = 0.34 / (1.34 + (m + 1) / (m - 1));
+    const v = so + k * sc + (1 - k) * rsv;
+    return v > 0 ? Math.sqrt(v) : 0;
+}
+//# sourceMappingURL=rangevol.js.map

package/dist/rangevol.js.map

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

package/dist/scheduling.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Execution scheduling: split a parent order into child slices.
+ *
+ * `twap` spreads size evenly across a fixed number of slices (time-weighted).
+ * `pov` participates at a fixed fraction of each interval's volume
+ * (percentage-of-volume). Both return the child sizes; sizes may be fractional.
+ */
+/**
+ * TWAP: split ``totalSize`` into ``slices`` equal child orders. The sizes sum
+ * exactly to ``totalSize`` (any floating residual lands in the last slice).
+ */
+export declare function twap(totalSize: number, slices: number): number[];
+/**
+ * POV: for each interval, trade ``rate`` × that interval's volume, capped by
+ * the size still remaining. Returns per-interval child sizes; their sum is the
+ * filled amount (less than ``totalSize`` if the volume was insufficient).
+ */
+export declare function pov(totalSize: number, intervalVolumes: readonly number[], rate: number): number[];
+//# sourceMappingURL=scheduling.d.ts.map

package/dist/scheduling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling.d.ts","sourceRoot":"","sources":["../src/scheduling.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,wBAAgB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAYhE;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CACjB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,IAAI,EAAE,MAAM,GACX,MAAM,EAAE,CAcV"}

package/dist/scheduling.js

@@ -0,0 +1,45 @@
+/**
+ * Execution scheduling: split a parent order into child slices.
+ *
+ * `twap` spreads size evenly across a fixed number of slices (time-weighted).
+ * `pov` participates at a fixed fraction of each interval's volume
+ * (percentage-of-volume). Both return the child sizes; sizes may be fractional.
+ */
+/**
+ * TWAP: split ``totalSize`` into ``slices`` equal child orders. The sizes sum
+ * exactly to ``totalSize`` (any floating residual lands in the last slice).
+ */
+export function twap(totalSize, slices) {
+    if (slices < 1 || !Number.isInteger(slices)) {
+        throw new Error("slices must be a positive integer");
+    }
+    const out = [];
+    let allocated = 0;
+    for (let i = 1; i <= slices; i++) {
+        const target = (totalSize * i) / slices;
+        out.push(target - allocated);
+        allocated = target;
+    }
+    return out;
+}
+/**
+ * POV: for each interval, trade ``rate`` × that interval's volume, capped by
+ * the size still remaining. Returns per-interval child sizes; their sum is the
+ * filled amount (less than ``totalSize`` if the volume was insufficient).
+ */
+export function pov(totalSize, intervalVolumes, rate) {
+    const r = Math.max(0, rate);
+    const out = [];
+    let remaining = totalSize;
+    for (const vol of intervalVolumes) {
+        if (remaining <= 0) {
+            out.push(0);
+            continue;
+        }
+        const child = Math.min(remaining, r * Math.max(0, vol));
+        out.push(child);
+        remaining -= child;
+    }
+    return out;
+}
+//# sourceMappingURL=scheduling.js.map

package/dist/scheduling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling.js","sourceRoot":"","sources":["../src/scheduling.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,MAAM,UAAU,IAAI,CAAC,SAAiB,EAAE,MAAc;IACpD,IAAI,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACvD,CAAC;IACD,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC;QACxC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;QAC7B,SAAS,GAAG,MAAM,CAAC;IACrB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,GAAG,CACjB,SAAiB,EACjB,eAAkC,EAClC,IAAY;IAEZ,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IAC5B,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,IAAI,SAAS,GAAG,SAAS,CAAC;IAC1B,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;QAClC,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;YACnB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACZ,SAAS;QACX,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;QACxD,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChB,SAAS,IAAI,KAAK,CAAC;IACrB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/semivar.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Realized semivariance and signed jump variation
+ * (Barndorff-Nielsen, Kinnebrock & Shephard, 2010; Patton & Shephard, 2015).
+ *
+ * Realized variance (RV = Σ rᵢ²) treats an up-move and a down-move of equal
+ * size as identical risk. But most traders care far more about the downside.
+ * Realized semivariance splits RV by the *sign* of each return:
+ *
+ *   RS⁺ = Σ rᵢ² · 1{rᵢ > 0}   (upside)
+ *   RS⁻ = Σ rᵢ² · 1{rᵢ < 0}   (downside)
+ *   RS⁺ + RS⁻ = RV            (zero returns contribute to neither)
+ *
+ * The two halves carry different information: RS⁻ (bad volatility) is the part
+ * that predicts future risk and demands a premium, while RS⁺ (good volatility)
+ * behaves quite differently. Their difference is the *signed* jump variation,
+ * which — unlike ordinary jump variation — keeps the direction of jump risk:
+ *
+ *   signed jump variation = RS⁺ − RS⁻
+ *
+ * A positive value means upside moves dominate; a negative value means the
+ * series is downside-heavy. Each function takes a return series.
+ */
+/** Upside / downside decomposition of realized variance. Both are ≥ 0. */
+export interface Semivariance {
+    /** RS⁺ = Σ rᵢ² over strictly positive returns. */
+    upside: number;
+    /** RS⁻ = Σ rᵢ² over strictly negative returns. */
+    downside: number;
+}
+/**
+ * Realized semivariance: splits realized variance into the sum of squared
+ * positive returns (upside) and squared negative returns (downside). Zero
+ * returns are ignored, so `upside + downside` equals realized variance. An
+ * empty series returns { upside: 0, downside: 0 }.
+ */
+export declare function realizedSemivariance(returns: readonly number[]): Semivariance;
+/**
+ * Downside variance ratio: RS⁻ / (RS⁺ + RS⁻), the share of realized variance
+ * coming from negative returns, in [0, 1]. Returns 0 when realized variance is
+ * 0 (or the series is empty). A value above 0.5 marks a downside-heavy window.
+ */
+export declare function downsideVarianceRatio(returns: readonly number[]): number;
+/**
+ * Signed jump variation: RS⁺ − RS⁻ (Patton & Shephard, 2015). Positive when
+ * upside moves dominate, negative when downside moves dominate; unlike jump
+ * variation it can take either sign. Returns 0 for an empty series.
+ */
+export declare function signedJumpVariation(returns: readonly number[]): number;
+//# sourceMappingURL=semivar.d.ts.map

package/dist/semivar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semivar.d.ts","sourceRoot":"","sources":["../src/semivar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAQ7E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAIxE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAGtE"}

package/dist/semivar.js

@@ -0,0 +1,59 @@
+/**
+ * Realized semivariance and signed jump variation
+ * (Barndorff-Nielsen, Kinnebrock & Shephard, 2010; Patton & Shephard, 2015).
+ *
+ * Realized variance (RV = Σ rᵢ²) treats an up-move and a down-move of equal
+ * size as identical risk. But most traders care far more about the downside.
+ * Realized semivariance splits RV by the *sign* of each return:
+ *
+ *   RS⁺ = Σ rᵢ² · 1{rᵢ > 0}   (upside)
+ *   RS⁻ = Σ rᵢ² · 1{rᵢ < 0}   (downside)
+ *   RS⁺ + RS⁻ = RV            (zero returns contribute to neither)
+ *
+ * The two halves carry different information: RS⁻ (bad volatility) is the part
+ * that predicts future risk and demands a premium, while RS⁺ (good volatility)
+ * behaves quite differently. Their difference is the *signed* jump variation,
+ * which — unlike ordinary jump variation — keeps the direction of jump risk:
+ *
+ *   signed jump variation = RS⁺ − RS⁻
+ *
+ * A positive value means upside moves dominate; a negative value means the
+ * series is downside-heavy. Each function takes a return series.
+ */
+/**
+ * Realized semivariance: splits realized variance into the sum of squared
+ * positive returns (upside) and squared negative returns (downside). Zero
+ * returns are ignored, so `upside + downside` equals realized variance. An
+ * empty series returns { upside: 0, downside: 0 }.
+ */
+export function realizedSemivariance(returns) {
+    let upside = 0;
+    let downside = 0;
+    for (const r of returns) {
+        if (r > 0)
+            upside += r * r;
+        else if (r < 0)
+            downside += r * r;
+    }
+    return { upside, downside };
+}
+/**
+ * Downside variance ratio: RS⁻ / (RS⁺ + RS⁻), the share of realized variance
+ * coming from negative returns, in [0, 1]. Returns 0 when realized variance is
+ * 0 (or the series is empty). A value above 0.5 marks a downside-heavy window.
+ */
+export function downsideVarianceRatio(returns) {
+    const { upside, downside } = realizedSemivariance(returns);
+    const total = upside + downside;
+    return total > 0 ? downside / total : 0;
+}
+/**
+ * Signed jump variation: RS⁺ − RS⁻ (Patton & Shephard, 2015). Positive when
+ * upside moves dominate, negative when downside moves dominate; unlike jump
+ * variation it can take either sign. Returns 0 for an empty series.
+ */
+export function signedJumpVariation(returns) {
+    const { upside, downside } = realizedSemivariance(returns);
+    return upside - downside;
+}
+//# sourceMappingURL=semivar.js.map

package/dist/semivar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semivar.js","sourceRoot":"","sources":["../src/semivar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAUH;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAA0B;IAC7D,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,CAAC,GAAG,CAAC;YAAE,MAAM,IAAI,CAAC,GAAG,CAAC,CAAC;aACtB,IAAI,CAAC,GAAG,CAAC;YAAE,QAAQ,IAAI,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;AAC9B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAA0B;IAC9D,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAC3D,MAAM,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;IAChC,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAA0B;IAC5D,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAC3D,OAAO,MAAM,GAAG,QAAQ,CAAC;AAC3B,CAAC"}

package/dist/shortfall.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Implementation shortfall and arrival slippage.
+ *
+ * Perold's (1988) "implementation shortfall" measures the all-in cost of turning
+ * a paper decision into real fills. It splits into the cost paid on the shares
+ * you actually executed (vs the price when you decided), the opportunity cost of
+ * the shares you failed to execute as the price drifted away, and fees. Arrival
+ * slippage is the simpler, per-order version against the arrival mid.
+ *
+ * Sign convention: buys are +1, sells are -1. All costs are returned as
+ * *positive = worse* (a shortfall), in the input price/quantity units.
+ */
+import type { Side } from "./types.ts";
+export interface ShortfallResult {
+    /** Cost on executed shares vs the decision price. */
+    execution: number;
+    /** Opportunity cost of unexecuted shares as the price drifted. */
+    opportunity: number;
+    /** Explicit fees / commissions. */
+    fees: number;
+    /** execution + opportunity + fees. Positive = shortfall (cost). */
+    total: number;
+}
+/**
+ * Implementation shortfall of an order, decomposed into execution cost,
+ * opportunity cost, and fees.
+ *
+ * @param decisionPrice  price when the trade was decided (the paper benchmark)
+ * @param avgExecPrice   volume-weighted average price actually paid/received
+ * @param executedQty    shares actually filled
+ * @param targetQty      shares originally intended
+ * @param finalPrice     price at the end of trading (for the unfilled remainder)
+ * @param fees           explicit costs (default 0)
+ */
+export declare function implementationShortfall(side: Side, decisionPrice: number, avgExecPrice: number, executedQty: number, targetQty: number, finalPrice: number, fees?: number): ShortfallResult;
+/**
+ * Arrival slippage in basis points: signed cost of the average execution price
+ * against the arrival price. Positive = adverse (paid up on a buy / sold low on
+ * a sell). Returns 0 when the arrival price is 0.
+ */
+export declare function arrivalSlippageBps(side: Side, arrivalPrice: number, avgExecPrice: number): number;
+//# sourceMappingURL=shortfall.d.ts.map

package/dist/shortfall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortfall.d.ts","sourceRoot":"","sources":["../src/shortfall.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAMvC,MAAM,WAAW,eAAe;IAC9B,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,EACV,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,IAAI,SAAI,GACP,eAAe,CAMjB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,MAAM,CAGR"}

package/dist/shortfall.js

@@ -0,0 +1,32 @@
+function dir(side) {
+    return side === "buy" ? 1 : -1;
+}
+/**
+ * Implementation shortfall of an order, decomposed into execution cost,
+ * opportunity cost, and fees.
+ *
+ * @param decisionPrice  price when the trade was decided (the paper benchmark)
+ * @param avgExecPrice   volume-weighted average price actually paid/received
+ * @param executedQty    shares actually filled
+ * @param targetQty      shares originally intended
+ * @param finalPrice     price at the end of trading (for the unfilled remainder)
+ * @param fees           explicit costs (default 0)
+ */
+export function implementationShortfall(side, decisionPrice, avgExecPrice, executedQty, targetQty, finalPrice, fees = 0) {
+    const d = dir(side);
+    const execution = d * (avgExecPrice - decisionPrice) * executedQty;
+    const unexecuted = Math.max(0, targetQty - executedQty);
+    const opportunity = d * (finalPrice - decisionPrice) * unexecuted;
+    return { execution, opportunity, fees, total: execution + opportunity + fees };
+}
+/**
+ * Arrival slippage in basis points: signed cost of the average execution price
+ * against the arrival price. Positive = adverse (paid up on a buy / sold low on
+ * a sell). Returns 0 when the arrival price is 0.
+ */
+export function arrivalSlippageBps(side, arrivalPrice, avgExecPrice) {
+    if (arrivalPrice === 0)
+        return 0;
+    return ((dir(side) * (avgExecPrice - arrivalPrice)) / arrivalPrice) * 10_000;
+}
+//# sourceMappingURL=shortfall.js.map

package/dist/shortfall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortfall.js","sourceRoot":"","sources":["../src/shortfall.ts"],"names":[],"mappings":"AAcA,SAAS,GAAG,CAAC,IAAU;IACrB,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACjC,CAAC;AAaD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAU,EACV,aAAqB,EACrB,YAAoB,EACpB,WAAmB,EACnB,SAAiB,EACjB,UAAkB,EAClB,IAAI,GAAG,CAAC;IAER,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;IACpB,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,YAAY,GAAG,aAAa,CAAC,GAAG,WAAW,CAAC;IACnE,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,WAAW,CAAC,CAAC;IACxD,MAAM,WAAW,GAAG,CAAC,GAAG,CAAC,UAAU,GAAG,aAAa,CAAC,GAAG,UAAU,CAAC;IAClE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,EAAE,CAAC;AACjF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAChC,IAAU,EACV,YAAoB,EACpB,YAAoB;IAEpB,IAAI,YAAY,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACjC,OAAO,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,YAAY,CAAC,CAAC,GAAG,YAAY,CAAC,GAAG,MAAM,CAAC;AAC/E,CAAC"}

package/dist/simulate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Market-order simulation against a reconstructed order book.
+ *
+ * Sweep the book with a market order and see what you'd actually get: the
+ * volume-weighted fill price, slippage vs the starting mid, and any size the
+ * book was too thin to fill. Read-only — the book is not mutated.
+ */
+import { OrderBook } from "./orderbook.ts";
+export interface Fill {
+    price: number;
+    size: number;
+}
+export interface MarketOrderResult {
+    filledSize: number;
+    remainingSize: number;
+    /** volume-weighted average fill price, or null if nothing filled */
+    avgPrice: number | null;
+    notional: number;
+    /** cost vs the mid at start, in basis points (positive = adverse); null if unknown */
+    slippageBps: number | null;
+    fills: Fill[];
+}
+/**
+ * Simulate a market order. A ``buy`` consumes asks from best (lowest) upward;
+ * a ``sell`` consumes bids from best (highest) downward. Stops when filled or
+ * the book runs out (``remainingSize`` > 0).
+ */
+export declare function simulateMarketOrder(book: OrderBook, side: "buy" | "sell", size: number): MarketOrderResult;
+//# sourceMappingURL=simulate.d.ts.map

package/dist/simulate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.d.ts","sourceRoot":"","sources":["../src/simulate.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,sFAAsF;IACtF,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,KAAK,GAAG,MAAM,EACpB,IAAI,EAAE,MAAM,GACX,iBAAiB,CAiCnB"}

package/dist/simulate.js

@@ -0,0 +1,36 @@
+/**
+ * Simulate a market order. A ``buy`` consumes asks from best (lowest) upward;
+ * a ``sell`` consumes bids from best (highest) downward. Stops when filled or
+ * the book runs out (``remainingSize`` > 0).
+ */
+export function simulateMarketOrder(book, side, size) {
+    const startMid = book.mid();
+    const levels = book.depth(side === "buy" ? "ask" : "bid", Number.MAX_SAFE_INTEGER);
+    const fills = [];
+    let remaining = size;
+    let notional = 0;
+    for (const level of levels) {
+        if (remaining <= 0)
+            break;
+        const take = Math.min(remaining, level.size);
+        fills.push({ price: level.price, size: take });
+        notional += level.price * take;
+        remaining -= take;
+    }
+    const filled = size - remaining;
+    const avgPrice = filled > 0 ? notional / filled : null;
+    let slippageBps = null;
+    if (avgPrice !== null && startMid !== null && startMid !== 0) {
+        const raw = side === "buy" ? avgPrice - startMid : startMid - avgPrice;
+        slippageBps = (raw / startMid) * 10_000;
+    }
+    return {
+        filledSize: filled,
+        remainingSize: remaining,
+        avgPrice,
+        notional,
+        slippageBps,
+        fills,
+    };
+}
+//# sourceMappingURL=simulate.js.map

package/dist/simulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.js","sourceRoot":"","sources":["../src/simulate.ts"],"names":[],"mappings":"AAyBA;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CACjC,IAAe,EACf,IAAoB,EACpB,IAAY;IAEZ,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;IAEnF,MAAM,KAAK,GAAW,EAAE,CAAC;IACzB,IAAI,SAAS,GAAG,IAAI,CAAC;IACrB,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,SAAS,IAAI,CAAC;YAAE,MAAM;QAC1B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7C,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/C,QAAQ,IAAI,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QAC/B,SAAS,IAAI,IAAI,CAAC;IACpB,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChC,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IAEvD,IAAI,WAAW,GAAkB,IAAI,CAAC;IACtC,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;QAC7D,MAAM,GAAG,GAAG,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACvE,WAAW,GAAG,CAAC,GAAG,GAAG,QAAQ,CAAC,GAAG,MAAM,CAAC;IAC1C,CAAC;IAED,OAAO;QACL,UAAU,EAAE,MAAM;QAClB,aAAa,EAAE,SAAS;QACxB,QAAQ;QACR,QAAQ;QACR,WAAW;QACX,KAAK;KACN,CAAC;AACJ,CAAC"}

package/dist/spreadest.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Bid-ask spread estimators from daily OHLC data.
+ *
+ * When all you have is low-frequency bars — daily high, low, and close — you can
+ * still back out an estimate of the effective bid-ask spread. Two well-known,
+ * dependency-free estimators:
+ *
+ *  - Corwin & Schultz (2012): the high-low range over two consecutive periods
+ *    reflects both fundamental volatility and the bid-ask bounce. The bounce can
+ *    be isolated because volatility scales with the time interval while the
+ *    spread does not.
+ *  - Abdi & Ranaldo (2017): compares each close to the mid-point of the current
+ *    and the next period's high-low range; their covariance recovers the spread.
+ *
+ * Both return a *proportional* spread (a fraction of price, e.g. 0.01 = 100 bps).
+ * Negative estimates — noise when the true spread is close to zero — are floored
+ * at 0. Prices must be strictly positive.
+ */
+export interface Ohlc {
+    high: number;
+    low: number;
+    close: number;
+}
+/**
+ * Corwin-Schultz (2012) high-low proportional spread estimate, averaged over all
+ * consecutive bar pairs. Per-pair negative estimates are set to 0 before
+ * averaging (as recommended in the paper). Returns 0 for fewer than two bars.
+ */
+export declare function corwinSchultz(bars: Ohlc[]): number;
+/**
+ * Abdi-Ranaldo (2017) proportional spread estimate from close, high, and low.
+ * Uses the covariance of each log-close with the mid-range of the current and
+ * next bar: S = sqrt(max(4 · E[(c_t − η_t)(c_t − η_{t+1})], 0)), where
+ * η = (log high + log low) / 2. Returns 0 for fewer than two bars or when the
+ * estimate is negative.
+ */
+export declare function abdiRanaldo(bars: Ohlc[]): number;
+//# sourceMappingURL=spreadest.d.ts.map

package/dist/spreadest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spreadest.d.ts","sourceRoot":"","sources":["../src/spreadest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAKD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,CAmBlD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,CAahD"}

package/dist/spreadest.js

@@ -0,0 +1,68 @@
+/**
+ * Bid-ask spread estimators from daily OHLC data.
+ *
+ * When all you have is low-frequency bars — daily high, low, and close — you can
+ * still back out an estimate of the effective bid-ask spread. Two well-known,
+ * dependency-free estimators:
+ *
+ *  - Corwin & Schultz (2012): the high-low range over two consecutive periods
+ *    reflects both fundamental volatility and the bid-ask bounce. The bounce can
+ *    be isolated because volatility scales with the time interval while the
+ *    spread does not.
+ *  - Abdi & Ranaldo (2017): compares each close to the mid-point of the current
+ *    and the next period's high-low range; their covariance recovers the spread.
+ *
+ * Both return a *proportional* spread (a fraction of price, e.g. 0.01 = 100 bps).
+ * Negative estimates — noise when the true spread is close to zero — are floored
+ * at 0. Prices must be strictly positive.
+ */
+/** 3 - 2√2 ≈ 0.1716, the Corwin-Schultz normalizing constant. */
+const K = 3 - 2 * Math.SQRT2;
+/**
+ * Corwin-Schultz (2012) high-low proportional spread estimate, averaged over all
+ * consecutive bar pairs. Per-pair negative estimates are set to 0 before
+ * averaging (as recommended in the paper). Returns 0 for fewer than two bars.
+ */
+export function corwinSchultz(bars) {
+    if (bars.length < 2)
+        return 0;
+    let sum = 0;
+    let n = 0;
+    for (let i = 0; i + 1 < bars.length; i++) {
+        const a = bars[i];
+        const b = bars[i + 1];
+        const hlA = Math.log(a.high / a.low);
+        const hlB = Math.log(b.high / b.low);
+        const beta = hlA * hlA + hlB * hlB;
+        const g = Math.log(Math.max(a.high, b.high) / Math.min(a.low, b.low));
+        const gamma = g * g;
+        const alpha = (Math.sqrt(2 * beta) - Math.sqrt(beta)) / K - Math.sqrt(gamma / K);
+        const s = (2 * (Math.exp(alpha) - 1)) / (1 + Math.exp(alpha));
+        sum += s > 0 ? s : 0;
+        n++;
+    }
+    return n === 0 ? 0 : sum / n;
+}
+/**
+ * Abdi-Ranaldo (2017) proportional spread estimate from close, high, and low.
+ * Uses the covariance of each log-close with the mid-range of the current and
+ * next bar: S = sqrt(max(4 · E[(c_t − η_t)(c_t − η_{t+1})], 0)), where
+ * η = (log high + log low) / 2. Returns 0 for fewer than two bars or when the
+ * estimate is negative.
+ */
+export function abdiRanaldo(bars) {
+    if (bars.length < 2)
+        return 0;
+    let sum = 0;
+    let n = 0;
+    for (let t = 0; t + 1 < bars.length; t++) {
+        const c = Math.log(bars[t].close);
+        const etaT = (Math.log(bars[t].high) + Math.log(bars[t].low)) / 2;
+        const etaN = (Math.log(bars[t + 1].high) + Math.log(bars[t + 1].low)) / 2;
+        sum += (c - etaT) * (c - etaN);
+        n++;
+    }
+    const s2 = 4 * (n === 0 ? 0 : sum / n);
+    return s2 > 0 ? Math.sqrt(s2) : 0;
+}
+//# sourceMappingURL=spreadest.js.map

package/dist/spreadest.js.map

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

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Core input types for order-flow metrics.
+ *
+ * Prices and sizes are plain numbers; timestamps (if provided) are opaque to
+ * this library — pass whatever epoch unit your feed uses, we never compare
+ * across records.
+ */
+export type Side = "buy" | "sell";
+/** Top-of-book (level-1) snapshot. */
+export interface L1Quote {
+    ts?: number;
+    bidPrice: number;
+    bidSize: number;
+    askPrice: number;
+    askSize: number;
+}
+/** A single executed trade. */
+export interface Trade {
+    ts?: number;
+    price: number;
+    size: number;
+    side: Side;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,MAAM,CAAC;AAElC,sCAAsC;AACtC,MAAM,WAAW,OAAO;IACtB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,+BAA+B;AAC/B,MAAM,WAAW,KAAK;IACpB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;CACZ"}

package/dist/types.js

@@ -0,0 +1,9 @@
+/**
+ * Core input types for order-flow metrics.
+ *
+ * Prices and sizes are plain numbers; timestamps (if provided) are opaque to
+ * this library — pass whatever epoch unit your feed uses, we never compare
+ * across records.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/volatility.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Realized volatility from a return series.
+ *
+ * Returns are period returns (e.g. log returns between consecutive prints or
+ * bars). Realized variance is the sum of squared returns; realized volatility
+ * is its square root. Annualized volatility scales the per-period variance by
+ * the number of periods in a year (zero-mean convention, standard for
+ * high-frequency returns).
+ */
+/** Realized variance: Σ rᵢ². */
+export declare function realizedVariance(returns: readonly number[]): number;
+/** Realized volatility over the sample: √(Σ rᵢ²). */
+export declare function realizedVolatility(returns: readonly number[]): number;
+/**
+ * Annualized volatility: √( mean(rᵢ²) · periodsPerYear ).
+ *
+ * ``periodsPerYear`` is how many return periods make up a year (e.g. 252 for
+ * daily, 252·390 for 1-minute equity bars). Returns 0 for an empty series.
+ */
+export declare function annualizedVolatility(returns: readonly number[], periodsPerYear: number): number;
+//# sourceMappingURL=volatility.d.ts.map