@fullstackcraftllc/floe 0.0.13 → 0.0.15

package/dist/iv/index.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeVarianceSwapIV = computeVarianceSwapIV;
+exports.computeImpliedVolatility = computeImpliedVolatility;
+const types_1 = require("../types");
+const blackscholes_1 = require("../blackscholes");
+// ============================================================================
+// Internal helpers
+// ============================================================================
+/**
+ * Compute ΔK for each strike: half the distance between adjacent strikes.
+ * For endpoints, use the distance to the single neighbor.
+ */
+function computeDeltaK(strikes) {
+    const deltaK = new Map();
+    if (strikes.length === 0)
+        return deltaK;
+    if (strikes.length === 1) {
+        deltaK.set(strikes[0], 1); // fallback
+        return deltaK;
+    }
+    for (let i = 0; i < strikes.length; i++) {
+        if (i === 0) {
+            deltaK.set(strikes[i], strikes[i + 1] - strikes[i]);
+        }
+        else if (i === strikes.length - 1) {
+            deltaK.set(strikes[i], strikes[i] - strikes[i - 1]);
+        }
+        else {
+            deltaK.set(strikes[i], (strikes[i + 1] - strikes[i - 1]) / 2);
+        }
+    }
+    return deltaK;
+}
+/**
+ * Group options by strike, pairing calls and puts.
+ */
+function pairOptionsByStrike(options) {
+    const pairs = new Map();
+    for (const opt of options) {
+        const existing = pairs.get(opt.strike) || {};
+        if (opt.optionType === 'call') {
+            existing.call = opt;
+        }
+        else {
+            existing.put = opt;
+        }
+        pairs.set(opt.strike, existing);
+    }
+    return pairs;
+}
+/**
+ * Get mid price for an option. Returns 0 if no valid quote.
+ */
+function midPrice(opt) {
+    if (!opt)
+        return 0;
+    if (opt.bid > 0 && opt.ask > 0)
+        return (opt.bid + opt.ask) / 2;
+    if (opt.mark > 0)
+        return opt.mark;
+    return 0;
+}
+/**
+ * Compute the model-free implied variance for a single expiration
+ * using the CBOE variance swap methodology.
+ *
+ * This implements the formula:
+ *
+ *   σ² = (2/T) × Σᵢ (ΔKᵢ/Kᵢ²) × e^(rT) × Q(Kᵢ) - (1/T) × (F/K₀ - 1)²
+ *
+ * Where:
+ * - K₀ is the strike where |call_mid - put_mid| is minimized
+ * - F = K₀ + e^(rT) × (call(K₀) - put(K₀)) is the forward price
+ * - Q(Kᵢ) = put mid for Kᵢ < K₀, call mid for Kᵢ > K₀,
+ *   average of call and put mids at K₀
+ * - ΔKᵢ = (Kᵢ₊₁ - Kᵢ₋₁) / 2 (actual strike spacing, not hardcoded)
+ *
+ * Two consecutive zero-bid options terminate the summation in each
+ * direction (puts walking down, calls walking up), per CBOE rules.
+ *
+ * @param options - All options for one expiration (calls and puts)
+ * @param spot - Current underlying price
+ * @param riskFreeRate - Annual risk-free rate as decimal (e.g. 0.05)
+ * @returns Variance swap result with annualized IV
+ */
+function computeVarianceSwapIV(options, spot, riskFreeRate) {
+    // Pair calls and puts by strike
+    const pairs = pairOptionsByStrike(options);
+    const strikes = Array.from(pairs.keys()).sort((a, b) => a - b);
+    if (strikes.length === 0) {
+        return emptyResult(spot);
+    }
+    // Use first option's expiration (all should be same expiry)
+    const expiration = options[0].expirationTimestamp;
+    const T = (0, blackscholes_1.getTimeToExpirationInYears)(expiration);
+    if (T <= 0) {
+        return emptyResult(spot);
+    }
+    const r = riskFreeRate;
+    const eRT = Math.exp(r * T);
+    // Step 1: Find K₀ — strike where |call_mid - put_mid| is minimized
+    // Only consider strikes within reasonable range of spot
+    let k0 = strikes[0];
+    let minDiff = Infinity;
+    let callAtK0 = 0;
+    let putAtK0 = 0;
+    for (const strike of strikes) {
+        const pair = pairs.get(strike);
+        const callMid = midPrice(pair.call);
+        const putMid = midPrice(pair.put);
+        if (callMid > 0 && putMid > 0) {
+            const diff = Math.abs(callMid - putMid);
+            if (diff < minDiff) {
+                minDiff = diff;
+                k0 = strike;
+                callAtK0 = callMid;
+                putAtK0 = putMid;
+            }
+        }
+    }
+    // Step 2: Forward price via put-call parity
+    const F = k0 + eRT * (callAtK0 - putAtK0);
+    // Step 3: Compute ΔK for each strike
+    const deltaKMap = computeDeltaK(strikes);
+    // Step 4: Sum OTM contributions
+    // Puts below K₀ (walk down, stop after two consecutive zero bids)
+    let putContribution = 0;
+    let callContribution = 0;
+    let numStrikes = 0;
+    // Put side: strikes ≤ K₀, walking downward from K₀
+    const putStrikes = strikes.filter(k => k <= k0).reverse(); // descending
+    let consecutiveZeroBids = 0;
+    for (const strike of putStrikes) {
+        const pair = pairs.get(strike);
+        const dk = deltaKMap.get(strike) || 1;
+        let Q = 0;
+        if (strike === k0) {
+            // At K₀: average of call and put
+            Q = (midPrice(pair.call) + midPrice(pair.put)) / 2;
+        }
+        else {
+            // Below K₀: use put
+            if (!pair.put || pair.put.bid === 0) {
+                consecutiveZeroBids++;
+                if (consecutiveZeroBids >= 2)
+                    break;
+                continue;
+            }
+            consecutiveZeroBids = 0;
+            Q = midPrice(pair.put);
+        }
+        if (Q > 0) {
+            putContribution += (dk / (strike * strike)) * eRT * Q;
+            numStrikes++;
+        }
+    }
+    // Call side: strikes ≥ K₀, walking upward from K₀
+    const callStrikes = strikes.filter(k => k >= k0); // ascending
+    consecutiveZeroBids = 0;
+    for (const strike of callStrikes) {
+        const pair = pairs.get(strike);
+        const dk = deltaKMap.get(strike) || 1;
+        let Q = 0;
+        if (strike === k0) {
+            // Already counted in put side, skip to avoid double-counting
+            continue;
+        }
+        else {
+            // Above K₀: use call
+            if (!pair.call || pair.call.bid === 0) {
+                consecutiveZeroBids++;
+                if (consecutiveZeroBids >= 2)
+                    break;
+                continue;
+            }
+            consecutiveZeroBids = 0;
+            Q = midPrice(pair.call);
+        }
+        if (Q > 0) {
+            callContribution += (dk / (strike * strike)) * eRT * Q;
+            numStrikes++;
+        }
+    }
+    // Step 5: Compute σ²
+    const totalContribution = putContribution + callContribution;
+    const variance = (2 / T) * totalContribution - (1 / T) * Math.pow(F / k0 - 1, 2);
+    // Guard against negative variance (can happen with bad data)
+    const clampedVariance = Math.max(0, variance);
+    const iv = Math.sqrt(clampedVariance);
+    return {
+        impliedVolatility: iv,
+        annualizedVariance: clampedVariance,
+        forward: F,
+        k0,
+        timeToExpiry: T,
+        expiration,
+        numStrikes,
+        putContribution,
+        callContribution,
+    };
+}
+/**
+ * Compute implied volatility from option prices using the CBOE
+ * variance swap methodology.
+ *
+ * If only nearTermOptions are provided, computes the single-expiration
+ * model-free implied volatility directly.
+ *
+ * If farTermOptions are also provided, performs CBOE VIX-style
+ * interpolation between the two terms to produce a constant-maturity
+ * measure at `targetDays` (defaults to the far term's DTE).
+ *
+ * The interpolation formula (in variance space):
+ *
+ *   VIX = 100 × √{ [T₁σ₁² × (N₂ - N_target)/(N₂ - N₁)
+ *                   + T₂σ₂² × (N_target - N₁)/(N₂ - N₁)]
+ *                   × N_365 / N_target }
+ *
+ * @param nearTermOptions - Options for the near-term expiration
+ * @param spot - Current underlying price
+ * @param riskFreeRate - Annual risk-free rate as decimal
+ * @param farTermOptions - Options for the far-term expiration (optional)
+ * @param targetDays - Target constant maturity in days for interpolation
+ *                     (defaults to far term DTE if far term provided)
+ */
+function computeImpliedVolatility(nearTermOptions, spot, riskFreeRate, farTermOptions, targetDays) {
+    const nearResult = computeVarianceSwapIV(nearTermOptions, spot, riskFreeRate);
+    // Single-term mode
+    if (!farTermOptions || farTermOptions.length === 0) {
+        return {
+            impliedVolatility: nearResult.impliedVolatility,
+            nearTerm: nearResult,
+            farTerm: null,
+            targetDays: null,
+            isInterpolated: false,
+        };
+    }
+    // Two-term interpolation mode
+    const farResult = computeVarianceSwapIV(farTermOptions, spot, riskFreeRate);
+    const N1 = nearResult.timeToExpiry * types_1.MILLISECONDS_PER_YEAR; // near term ms
+    const N2 = farResult.timeToExpiry * types_1.MILLISECONDS_PER_YEAR; // far term ms
+    const T1 = nearResult.timeToExpiry;
+    const T2 = farResult.timeToExpiry;
+    const sigma1sq = nearResult.annualizedVariance;
+    const sigma2sq = farResult.annualizedVariance;
+    // Target in milliseconds
+    const N365 = types_1.MILLISECONDS_PER_YEAR;
+    const effectiveTargetDays = targetDays ?? Math.round(farResult.timeToExpiry * 365);
+    const Ntarget = effectiveTargetDays * (types_1.MILLISECONDS_PER_YEAR / 365);
+    // Guard: if near and far are the same expiration, just return near
+    if (Math.abs(N2 - N1) < 1) {
+        return {
+            impliedVolatility: nearResult.impliedVolatility,
+            nearTerm: nearResult,
+            farTerm: farResult,
+            targetDays: effectiveTargetDays,
+            isInterpolated: false,
+        };
+    }
+    // CBOE interpolation in variance space
+    const weight1 = (N2 - Ntarget) / (N2 - N1);
+    const weight2 = (Ntarget - N1) / (N2 - N1);
+    const interpolatedVariance = (T1 * sigma1sq * weight1 + T2 * sigma2sq * weight2) * (N365 / Ntarget);
+    const clampedVariance = Math.max(0, interpolatedVariance);
+    const iv = Math.sqrt(clampedVariance);
+    return {
+        impliedVolatility: iv,
+        nearTerm: nearResult,
+        farTerm: farResult,
+        targetDays: effectiveTargetDays,
+        isInterpolated: true,
+    };
+}
+function emptyResult(spot) {
+    return {
+        impliedVolatility: 0,
+        annualizedVariance: 0,
+        forward: spot,
+        k0: spot,
+        timeToExpiry: 0,
+        expiration: 0,
+        numStrikes: 0,
+        putContribution: 0,
+        callContribution: 0,
+    };
+}

package/dist/iv/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Result of computing model-free implied variance for a single expiration
+ * using the CBOE variance swap methodology.
+ */
+export interface VarianceSwapResult {
+    /** Annualized implied volatility as decimal (e.g. 0.20 = 20%) */
+    impliedVolatility: number;
+    /** Annualized variance σ² */
+    annualizedVariance: number;
+    /** Forward price F derived from put-call parity at K₀ */
+    forward: number;
+    /** At-the-money strike K₀ (strike where |call - put| is minimized) */
+    k0: number;
+    /** Time to expiry in years */
+    timeToExpiry: number;
+    /** Expiration timestamp (ms) */
+    expiration: number;
+    /** Number of strikes that contributed to the variance sum */
+    numStrikes: number;
+    /** Total put-side contribution to variance */
+    putContribution: number;
+    /** Total call-side contribution to variance */
+    callContribution: number;
+}
+/**
+ * Result of computing implied volatility, either single-term or
+ * interpolated between two terms (CBOE VIX-style).
+ */
+export interface ImpliedVolatilityResult {
+    /** Final annualized implied volatility as decimal */
+    impliedVolatility: number;
+    /** Near-term (or only-term) variance swap result */
+    nearTerm: VarianceSwapResult;
+    /** Far-term variance swap result, if two terms provided */
+    farTerm: VarianceSwapResult | null;
+    /** Target days for interpolation (null if single-term) */
+    targetDays: number | null;
+    /** Whether the result is interpolated between two terms */
+    isInterpolated: boolean;
+}

package/dist/iv/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/pressure/grid.d.ts

@@ -0,0 +1,14 @@
+import { OptionChain, IVSurface, ExposurePerExpiry } from '../types';
+import { RegimeParams, HedgingPressure, PressureGrid } from './types';
+/**
+ * Calculate hedging pressure at a specific (spot, time) point
+ */
+export declare function calculatePressureAt(spot: number, timeToExpiry: number, exposures: ExposurePerExpiry, regimeParams: RegimeParams): HedgingPressure;
+/**
+ * Build a complete pressure grid for visualization
+ */
+export declare function buildPressureGrid(symbol: string, chain: OptionChain, exposures: ExposurePerExpiry, ivSurface: IVSurface, options?: {
+    spotRangePercent?: number;
+    spotStepPercent?: number;
+    timeStepMinutes?: number;
+}): PressureGrid;

package/dist/pressure/grid.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculatePressureAt = calculatePressureAt;
+exports.buildPressureGrid = buildPressureGrid;
+const types_1 = require("../types");
+const regime_1 = require("./regime");
+/**
+ * Calculate hedging pressure at a specific (spot, time) point
+ */
+function calculatePressureAt(spot, timeToExpiry, exposures, regimeParams) {
+    const { expectedDailySpotMove, expectedDailyVolMove, impliedSpotVolCorr, regime } = regimeParams;
+    let gammaFlow = 0;
+    let vannaFlow = 0;
+    let charmFlow = 0;
+    for (const strike of exposures.strikeExposures) {
+        const gammaContrib = strike.gammaExposure * Math.pow(expectedDailySpotMove, 2);
+        gammaFlow += gammaContrib;
+        const corrAmplifier = 1 + Math.abs(impliedSpotVolCorr);
+        const vannaContrib = strike.vannaExposure * expectedDailySpotMove * expectedDailyVolMove * corrAmplifier;
+        vannaFlow += vannaContrib;
+        const daysToExpiry = timeToExpiry * 252;
+        const charmContrib = strike.charmExposure * Math.min(daysToExpiry, 1);
+        charmFlow += charmContrib;
+    }
+    const netPressure = gammaFlow + vannaFlow + charmFlow;
+    const regimeWeights = {
+        calm: { gamma: 0.3, vanna: 0.1, charm: 0.6 },
+        normal: { gamma: 0.4, vanna: 0.2, charm: 0.4 },
+        stressed: { gamma: 0.35, vanna: 0.4, charm: 0.25 },
+        crisis: { gamma: 0.25, vanna: 0.6, charm: 0.15 },
+    };
+    const w = regimeWeights[regime];
+    const effectivePressure = gammaFlow * w.gamma + vannaFlow * w.vanna + charmFlow * w.charm;
+    let direction = 'neutral';
+    const threshold = Math.abs(effectivePressure) * 0.1;
+    if (effectivePressure > threshold) {
+        direction = 'supportive';
+    }
+    else if (effectivePressure < -threshold) {
+        direction = 'resistive';
+    }
+    const hoursRemaining = timeToExpiry * 252 * 6.5;
+    return {
+        spot,
+        timeToExpiry,
+        hoursRemaining,
+        gammaFlow,
+        vannaFlow,
+        charmFlow,
+        netPressure,
+        effectivePressure,
+        direction,
+    };
+}
+/**
+ * Build a complete pressure grid for visualization
+ */
+function buildPressureGrid(symbol, chain, exposures, ivSurface, options = {}) {
+    const { spotRangePercent = 2, spotStepPercent = 0.1, timeStepMinutes = 15, } = options;
+    const spot = chain.spot;
+    const expiration = exposures.expiration;
+    const timeToExpiry = (expiration - Date.now()) / types_1.MILLISECONDS_PER_YEAR;
+    const regimeParams = (0, regime_1.deriveRegimeParams)(ivSurface, spot);
+    const spotMin = spot * (1 - spotRangePercent / 100);
+    const spotMax = spot * (1 + spotRangePercent / 100);
+    const spotStep = spot * (spotStepPercent / 100);
+    const hoursRemaining = timeToExpiry * 252 * 6.5;
+    const timeMin = 0;
+    const timeMax = Math.max(hoursRemaining, 0.25);
+    const timeStep = timeStepMinutes / 60;
+    const cells = [];
+    const spotLevels = [];
+    const timeLevels = [];
+    for (let s = spotMin; s <= spotMax; s += spotStep) {
+        spotLevels.push(s);
+    }
+    for (let t = timeMax; t >= timeMin; t -= timeStep) {
+        timeLevels.push(t);
+    }
+    for (let i = 0; i < spotLevels.length; i++) {
+        cells[i] = [];
+        const s = spotLevels[i];
+        for (let j = 0; j < timeLevels.length; j++) {
+            const hoursLeft = timeLevels[j];
+            const t = hoursLeft / (252 * 6.5);
+            const pressure = calculatePressureAt(s, t, exposures, regimeParams);
+            cells[i][j] = {
+                spot: s,
+                hoursRemaining: hoursLeft,
+                pressure,
+                spotGradient: 0,
+                timeGradient: 0,
+            };
+        }
+    }
+    computeGradients(cells, spotStep, timeStep);
+    const keyLevels = findKeyLevels(cells, spotLevels, exposures);
+    const pathOfLeastResistance = computePathOfLeastResistance(cells, spotLevels, spot);
+    return {
+        symbol,
+        expiration,
+        currentSpot: spot,
+        timestamp: Date.now(),
+        regime: regimeParams.regime,
+        spotRange: { min: spotMin, max: spotMax, step: spotStep },
+        timeRange: { min: timeMin, max: timeMax, step: timeStep },
+        cells,
+        keyLevels,
+        pathOfLeastResistance,
+    };
+}
+function computeGradients(cells, spotStep, timeStep) {
+    const numSpot = cells.length;
+    const numTime = cells[0]?.length ?? 0;
+    for (let i = 0; i < numSpot; i++) {
+        for (let j = 0; j < numTime; j++) {
+            if (i > 0 && i < numSpot - 1) {
+                cells[i][j].spotGradient =
+                    (cells[i + 1][j].pressure.effectivePressure - cells[i - 1][j].pressure.effectivePressure) /
+                        (2 * spotStep);
+            }
+            if (j > 0 && j < numTime - 1) {
+                cells[i][j].timeGradient =
+                    (cells[i][j + 1].pressure.effectivePressure - cells[i][j - 1].pressure.effectivePressure) /
+                        (2 * timeStep);
+            }
+        }
+    }
+}
+function findKeyLevels(cells, spotLevels, exposures) {
+    const support = [];
+    const resistance = [];
+    const pinning = [];
+    let gammaFlip = null;
+    const currentSlice = cells.map(row => row[0]);
+    for (let i = 1; i < currentSlice.length; i++) {
+        const prev = currentSlice[i - 1].pressure.effectivePressure;
+        const curr = currentSlice[i].pressure.effectivePressure;
+        if (prev < 0 && curr >= 0) {
+            support.push((spotLevels[i - 1] + spotLevels[i]) / 2);
+        }
+        else if (prev >= 0 && curr < 0) {
+            resistance.push((spotLevels[i - 1] + spotLevels[i]) / 2);
+        }
+    }
+    for (const strike of exposures.strikeExposures) {
+        if (strike.gammaExposure > 0 && strike.gammaExposure > exposures.totalGammaExposure * 0.1) {
+            pinning.push(strike.strikePrice);
+        }
+    }
+    return { support, resistance, pinning, gammaFlip };
+}
+function computePathOfLeastResistance(cells, spotLevels, currentSpot) {
+    let currentSpotIdx = 0;
+    let minDist = Infinity;
+    for (let i = 0; i < spotLevels.length; i++) {
+        const dist = Math.abs(spotLevels[i] - currentSpot);
+        if (dist < minDist) {
+            minDist = dist;
+            currentSpotIdx = i;
+        }
+    }
+    const pressureAbove = [];
+    const pressureBelow = [];
+    for (let i = currentSpotIdx + 1; i < spotLevels.length; i++) {
+        pressureAbove.push(cells[i][0].pressure.effectivePressure);
+    }
+    for (let i = currentSpotIdx - 1; i >= 0; i--) {
+        pressureBelow.push(cells[i][0].pressure.effectivePressure);
+    }
+    const avgPressureAbove = pressureAbove.length > 0
+        ? pressureAbove.reduce((a, b) => a + b, 0) / pressureAbove.length
+        : 0;
+    const avgPressureBelow = pressureBelow.length > 0
+        ? pressureBelow.reduce((a, b) => a + b, 0) / pressureBelow.length
+        : 0;
+    const currentPressure = cells[currentSpotIdx][0].pressure.effectivePressure;
+    let direction = 'pin';
+    let targetSpot = currentSpot;
+    let confidence = 0;
+    let rationale = '';
+    if (currentPressure > 0 && Math.abs(currentPressure) > Math.abs(avgPressureAbove) &&
+        Math.abs(currentPressure) > Math.abs(avgPressureBelow)) {
+        direction = 'pin';
+        targetSpot = currentSpot;
+        confidence = Math.min(1, Math.abs(currentPressure) / (Math.abs(avgPressureAbove) + Math.abs(avgPressureBelow) + 1));
+        rationale = `Strong positive gamma at current level suggests pinning`;
+    }
+    else if (avgPressureAbove > 0 && avgPressureBelow < 0) {
+        direction = 'up';
+        for (let i = currentSpotIdx + 1; i < spotLevels.length; i++) {
+            if (cells[i][0].pressure.effectivePressure < 0) {
+                targetSpot = spotLevels[i];
+                break;
+            }
+            targetSpot = spotLevels[i];
+        }
+        confidence = Math.min(1, (avgPressureAbove - avgPressureBelow) / (Math.abs(avgPressureAbove) + Math.abs(avgPressureBelow) + 1));
+        rationale = `Supportive pressure above vs resistive below`;
+    }
+    else if (avgPressureAbove < 0 && avgPressureBelow > 0) {
+        direction = 'down';
+        for (let i = currentSpotIdx - 1; i >= 0; i--) {
+            if (cells[i][0].pressure.effectivePressure > 0) {
+                targetSpot = spotLevels[i];
+                break;
+            }
+            targetSpot = spotLevels[i];
+        }
+        confidence = Math.min(1, (avgPressureBelow - avgPressureAbove) / (Math.abs(avgPressureAbove) + Math.abs(avgPressureBelow) + 1));
+        rationale = `Resistive pressure above vs supportive below`;
+    }
+    else {
+        direction = 'pin';
+        targetSpot = currentSpot;
+        confidence = 0.3;
+        rationale = `Mixed pressure signals; defaulting to pin hypothesis`;
+    }
+    return { direction, targetSpot, confidence, rationale };
+}

package/dist/pressure/index.d.ts

@@ -0,0 +1,5 @@
+export type { MarketRegime, RegimeParams, NormalizedExposure, NormalizedExposureSummary, HedgingPressure, PressureGridCell, KeyLevels, PathOfLeastResistance, PressureGrid, StrikeIVPressure, IVSurfaceEvolution, CascadeStep, CascadeSimulation, IVPathConfig, } from './types';
+export { deriveRegimeParams, interpolateIVAtStrike } from './regime';
+export { normalizeExposures } from './normalize';
+export { calculatePressureAt, buildPressureGrid } from './grid';
+export { calculateIVPressures, predictIVSurfaceEvolution, runCascadeSimulation, analyzeIVPath, getIVPathOfLeastResistance, DEFAULT_IV_PATH_CONFIG, } from './ivpath';

package/dist/pressure/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IV_PATH_CONFIG = exports.getIVPathOfLeastResistance = exports.analyzeIVPath = exports.runCascadeSimulation = exports.predictIVSurfaceEvolution = exports.calculateIVPressures = exports.buildPressureGrid = exports.calculatePressureAt = exports.normalizeExposures = exports.interpolateIVAtStrike = exports.deriveRegimeParams = void 0;
+// Regime derivation
+var regime_1 = require("./regime");
+Object.defineProperty(exports, "deriveRegimeParams", { enumerable: true, get: function () { return regime_1.deriveRegimeParams; } });
+Object.defineProperty(exports, "interpolateIVAtStrike", { enumerable: true, get: function () { return regime_1.interpolateIVAtStrike; } });
+// Exposure normalization
+var normalize_1 = require("./normalize");
+Object.defineProperty(exports, "normalizeExposures", { enumerable: true, get: function () { return normalize_1.normalizeExposures; } });
+// Pressure field
+var grid_1 = require("./grid");
+Object.defineProperty(exports, "calculatePressureAt", { enumerable: true, get: function () { return grid_1.calculatePressureAt; } });
+Object.defineProperty(exports, "buildPressureGrid", { enumerable: true, get: function () { return grid_1.buildPressureGrid; } });
+// IV path prediction
+var ivpath_1 = require("./ivpath");
+Object.defineProperty(exports, "calculateIVPressures", { enumerable: true, get: function () { return ivpath_1.calculateIVPressures; } });
+Object.defineProperty(exports, "predictIVSurfaceEvolution", { enumerable: true, get: function () { return ivpath_1.predictIVSurfaceEvolution; } });
+Object.defineProperty(exports, "runCascadeSimulation", { enumerable: true, get: function () { return ivpath_1.runCascadeSimulation; } });
+Object.defineProperty(exports, "analyzeIVPath", { enumerable: true, get: function () { return ivpath_1.analyzeIVPath; } });
+Object.defineProperty(exports, "getIVPathOfLeastResistance", { enumerable: true, get: function () { return ivpath_1.getIVPathOfLeastResistance; } });
+Object.defineProperty(exports, "DEFAULT_IV_PATH_CONFIG", { enumerable: true, get: function () { return ivpath_1.DEFAULT_IV_PATH_CONFIG; } });

package/dist/pressure/ivpath.d.ts

@@ -0,0 +1,31 @@
+import { IVSurface, ExposurePerExpiry } from '../types';
+import { RegimeParams, StrikeIVPressure, IVSurfaceEvolution, CascadeSimulation, IVPathConfig } from './types';
+export declare const DEFAULT_IV_PATH_CONFIG: IVPathConfig;
+/**
+ * Calculate IV pressure at each strike based on dealer positioning
+ */
+export declare function calculateIVPressures(ivSurface: IVSurface, exposures: ExposurePerExpiry, regimeParams: RegimeParams, spotMove: number, config?: Partial<IVPathConfig>): StrikeIVPressure[];
+/**
+ * Predict how the IV surface will evolve given dealer positioning
+ */
+export declare function predictIVSurfaceEvolution(ivSurface: IVSurface, exposures: ExposurePerExpiry, spot: number, spotMoveScenario?: number, config?: Partial<IVPathConfig>): IVSurfaceEvolution;
+/**
+ * Run a cascade simulation showing feedback loops
+ */
+export declare function runCascadeSimulation(ivSurface: IVSurface, exposures: ExposurePerExpiry, spot: number, spotShock?: number, config?: Partial<IVPathConfig>): CascadeSimulation;
+/**
+ * Analyze IV path for multiple spot scenarios
+ */
+export declare function analyzeIVPath(ivSurface: IVSurface, exposures: ExposurePerExpiry, spot: number, options?: {
+    spotScenarios?: number[];
+    config?: Partial<IVPathConfig>;
+}): Map<number, IVSurfaceEvolution>;
+/**
+ * Get the IV path of least resistance
+ */
+export declare function getIVPathOfLeastResistance(ivSurface: IVSurface, exposures: ExposurePerExpiry, spot: number): {
+    direction: 'up' | 'down' | 'stable';
+    magnitude: number;
+    confidence: number;
+    rationale: string;
+};