@fullstackcraftllc/floe 0.0.13 → 0.0.15

package/dist/pressure/ivpath.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IV_PATH_CONFIG = void 0;
+exports.calculateIVPressures = calculateIVPressures;
+exports.predictIVSurfaceEvolution = predictIVSurfaceEvolution;
+exports.runCascadeSimulation = runCascadeSimulation;
+exports.analyzeIVPath = analyzeIVPath;
+exports.getIVPathOfLeastResistance = getIVPathOfLeastResistance;
+const regime_1 = require("./regime");
+exports.DEFAULT_IV_PATH_CONFIG = {
+    spotMoveScenario: 0,
+    timeStepHours: 1,
+    cascadeIterations: 5,
+    cascadeDampening: 0.5,
+    ivImpactPerMillion: 0.0005,
+    ivFloor: 0.05,
+    ivCeiling: 2.0,
+};
+/**
+ * Calculate IV pressure at each strike based on dealer positioning
+ */
+function calculateIVPressures(ivSurface, exposures, regimeParams, spotMove, config = {}) {
+    const cfg = { ...exports.DEFAULT_IV_PATH_CONFIG, ...config };
+    const { strikes, smoothedIVs } = ivSurface;
+    const { impliedSpotVolCorr, impliedVolOfVol, expectedDailyVolMove } = regimeParams;
+    const pressures = [];
+    const exposureByStrike = new Map();
+    for (const exp of exposures.strikeExposures) {
+        exposureByStrike.set(exp.strikePrice, exp);
+    }
+    for (let i = 0; i < strikes.length; i++) {
+        const strike = strikes[i];
+        const currentIV = smoothedIVs[i] / 100;
+        const exposure = exposureByStrike.get(strike) ?? findNearestExposure(strike, exposures);
+        const vannaIVPressure = calculateVannaIVPressure(exposure?.vannaExposure ?? 0, spotMove, impliedSpotVolCorr, cfg.ivImpactPerMillion);
+        const vommaIVPressure = calculateVommaIVPressure(exposure?.vannaExposure ?? 0, expectedDailyVolMove, impliedVolOfVol, cfg.ivImpactPerMillion);
+        const vetaIVPressure = calculateVetaIVPressure(exposure?.charmExposure ?? 0, cfg.timeStepHours, cfg.ivImpactPerMillion);
+        const liquidityScore = estimateLiquidity(strike, exposures.spotPrice, currentIV);
+        const netIVPressure = vannaIVPressure + vommaIVPressure + vetaIVPressure;
+        const liquidityMultiplier = 1 / (liquidityScore + 0.1);
+        const expectedIVMove = netIVPressure * liquidityMultiplier;
+        pressures.push({
+            strike,
+            currentIV,
+            vannaIVPressure,
+            vommaIVPressure,
+            vetaIVPressure,
+            netIVPressure,
+            liquidityScore,
+            expectedIVMove,
+        });
+    }
+    return pressures;
+}
+function calculateVannaIVPressure(vannaExposure, spotMove, spotVolCorr, ivImpactPerMillion) {
+    const vannaHedgingFlow = -vannaExposure * spotMove;
+    const ivImpact = (vannaHedgingFlow / 1000000) * ivImpactPerMillion;
+    const corrMultiplier = 1 + Math.abs(spotVolCorr) * 0.5;
+    return ivImpact * corrMultiplier;
+}
+function calculateVommaIVPressure(vannaExposure, expectedVolMove, volOfVol, ivImpactPerMillion) {
+    const vommaProxy = vannaExposure * 0.1;
+    const vommaHedgingFlow = vommaProxy * Math.pow(expectedVolMove, 2) * volOfVol * 10;
+    return (vommaHedgingFlow / 1000000) * ivImpactPerMillion;
+}
+function calculateVetaIVPressure(charmExposure, timeStepHours, ivImpactPerMillion) {
+    const timeDecayFlow = charmExposure * (timeStepHours / 6.5);
+    return (timeDecayFlow / 1000000) * ivImpactPerMillion * 0.1;
+}
+function estimateLiquidity(strike, spot, iv) {
+    const moneyness = Math.abs(Math.log(strike / spot)) / iv;
+    return Math.max(0.1, 1 - moneyness * 0.4);
+}
+function findNearestExposure(strike, exposures) {
+    let nearest;
+    let minDist = Infinity;
+    for (const exp of exposures.strikeExposures) {
+        const dist = Math.abs(exp.strikePrice - strike);
+        if (dist < minDist) {
+            minDist = dist;
+            nearest = exp;
+        }
+    }
+    return nearest;
+}
+/**
+ * Predict how the IV surface will evolve given dealer positioning
+ */
+function predictIVSurfaceEvolution(ivSurface, exposures, spot, spotMoveScenario = 0, config = {}) {
+    const cfg = { ...exports.DEFAULT_IV_PATH_CONFIG, ...config, spotMoveScenario };
+    const regimeParams = (0, regime_1.deriveRegimeParams)(ivSurface, spot);
+    const strikePressures = calculateIVPressures(ivSurface, exposures, regimeParams, spotMoveScenario, cfg);
+    const predictedIVs = ivSurface.smoothedIVs.map((iv, i) => {
+        const pressure = strikePressures[i];
+        const newIV = iv / 100 + pressure.expectedIVMove;
+        return Math.max(cfg.ivFloor, Math.min(cfg.ivCeiling, newIV)) * 100;
+    });
+    const predictedSurface = {
+        ...ivSurface,
+        smoothedIVs: predictedIVs,
+        rawIVs: predictedIVs,
+    };
+    const atmIdx = findATMIndex(ivSurface.strikes, spot);
+    const atmIVMove = (predictedIVs[atmIdx] - ivSurface.smoothedIVs[atmIdx]) / 100;
+    const skewChange = calculateSkewChange(ivSurface, predictedSurface, spot);
+    const curvatureChange = calculateCurvatureChange(ivSurface, predictedSurface, spot);
+    const netSurfacePressure = strikePressures.reduce((sum, p) => sum + p.netIVPressure * (p.liquidityScore + 0.1), 0);
+    const confidence = Math.min(1, calculatePositioningClarity(exposures) * 0.8);
+    return {
+        currentSurface: ivSurface,
+        predictedSurface,
+        strikePressures,
+        netSurfacePressure,
+        atmIVMove,
+        skewChange,
+        curvatureChange,
+        confidence,
+    };
+}
+function findATMIndex(strikes, spot) {
+    let minDist = Infinity;
+    let atmIdx = 0;
+    for (let i = 0; i < strikes.length; i++) {
+        const dist = Math.abs(strikes[i] - spot);
+        if (dist < minDist) {
+            minDist = dist;
+            atmIdx = i;
+        }
+    }
+    return atmIdx;
+}
+function calculateSkewChange(current, predicted, spot) {
+    const { strikes } = current;
+    const atmIdx = findATMIndex(strikes, spot);
+    const atmIV = current.smoothedIVs[atmIdx] / 100;
+    const stdDev = spot * atmIV * Math.sqrt(1 / 252);
+    const putIdx = findATMIndex(strikes, spot - stdDev);
+    const callIdx = findATMIndex(strikes, spot + stdDev);
+    const currentSkew = (current.smoothedIVs[putIdx] - current.smoothedIVs[callIdx]) / 100;
+    const predictedSkew = (predicted.smoothedIVs[putIdx] - predicted.smoothedIVs[callIdx]) / 100;
+    return predictedSkew - currentSkew;
+}
+function calculateCurvatureChange(current, predicted, spot) {
+    const { strikes } = current;
+    const atmIdx = findATMIndex(strikes, spot);
+    if (atmIdx === 0 || atmIdx === strikes.length - 1)
+        return 0;
+    const deltaK = (strikes[atmIdx + 1] - strikes[atmIdx - 1]) / 2;
+    if (deltaK === 0)
+        return 0;
+    const currentCurv = (current.smoothedIVs[atmIdx - 1] + current.smoothedIVs[atmIdx + 1] - 2 * current.smoothedIVs[atmIdx]) / (deltaK * deltaK);
+    const predictedCurv = (predicted.smoothedIVs[atmIdx - 1] + predicted.smoothedIVs[atmIdx + 1] - 2 * predicted.smoothedIVs[atmIdx]) / (deltaK * deltaK);
+    return predictedCurv - currentCurv;
+}
+function calculatePositioningClarity(exposures) {
+    const totalAbs = Math.abs(exposures.totalGammaExposure) +
+        Math.abs(exposures.totalVannaExposure) +
+        Math.abs(exposures.totalCharmExposure);
+    if (totalAbs === 0)
+        return 0;
+    const netExposure = exposures.totalNetExposure;
+    const directionalClarity = Math.abs(netExposure) / totalAbs;
+    const maxStrikeExposure = Math.max(...exposures.strikeExposures.map(e => Math.abs(e.netExposure)));
+    const concentration = maxStrikeExposure / (totalAbs + 1);
+    return (directionalClarity + concentration) / 2;
+}
+/**
+ * Run a cascade simulation showing feedback loops
+ */
+function runCascadeSimulation(ivSurface, exposures, spot, spotShock = 0, config = {}) {
+    const cfg = { ...exports.DEFAULT_IV_PATH_CONFIG, ...config };
+    const steps = [];
+    let currentSpot = spot * (1 + spotShock);
+    let currentSurface = ivSurface;
+    let currentExposures = exposures;
+    let cumulativeIVMove = 0;
+    let cumulativeSpotMove = spotShock;
+    const initialRegime = (0, regime_1.deriveRegimeParams)(ivSurface, spot);
+    const initial = {
+        step: 0,
+        spot,
+        ivSurface,
+        exposures,
+        regime: initialRegime.regime,
+        ivPressure: 0,
+        spotPressure: 0,
+        cumulativeIVMove: 0,
+        cumulativeSpotMove: 0,
+    };
+    for (let i = 0; i < cfg.cascadeIterations; i++) {
+        const regime = (0, regime_1.deriveRegimeParams)(currentSurface, currentSpot);
+        const evolution = predictIVSurfaceEvolution(currentSurface, currentExposures, currentSpot, i === 0 ? spotShock : 0, cfg);
+        const dampenedIVMove = evolution.atmIVMove * Math.pow(cfg.cascadeDampening, i);
+        cumulativeIVMove += dampenedIVMove;
+        currentSurface = evolution.predictedSurface;
+        const spotPressure = estimateSpotPressureFromIVChange(dampenedIVMove, currentExposures, currentSpot);
+        const dampenedSpotMove = spotPressure * Math.pow(cfg.cascadeDampening, i);
+        cumulativeSpotMove += dampenedSpotMove;
+        currentSpot = currentSpot * (1 + dampenedSpotMove);
+        steps.push({
+            step: i + 1,
+            spot: currentSpot,
+            ivSurface: currentSurface,
+            exposures: currentExposures,
+            regime: regime.regime,
+            ivPressure: dampenedIVMove,
+            spotPressure: dampenedSpotMove,
+            cumulativeIVMove,
+            cumulativeSpotMove,
+        });
+    }
+    const outcome = determineOutcome(steps);
+    const insight = generateInsight(initial, steps, outcome, spotShock);
+    return {
+        initial,
+        steps,
+        terminal: steps[steps.length - 1],
+        outcome,
+        insight,
+    };
+}
+function estimateSpotPressureFromIVChange(ivChange, exposures, spot) {
+    const deltaChange = exposures.totalVannaExposure * ivChange;
+    return (deltaChange / 1000000000) * 0.001;
+}
+function determineOutcome(steps) {
+    if (steps.length < 3)
+        return 'converged';
+    const lastSteps = steps.slice(-3);
+    const ivMoves = lastSteps.map(s => Math.abs(s.ivPressure));
+    const isDiverging = ivMoves[2] > ivMoves[1] && ivMoves[1] > ivMoves[0];
+    if (isDiverging)
+        return 'diverged';
+    const signs = lastSteps.map(s => Math.sign(s.ivPressure));
+    const isOscillating = signs[0] !== signs[1] && signs[1] !== signs[2];
+    if (isOscillating)
+        return 'oscillating';
+    return 'converged';
+}
+function generateInsight(initial, steps, outcome, spotShock) {
+    const terminal = steps[steps.length - 1];
+    const totalIVMove = terminal.cumulativeIVMove * 100;
+    const totalSpotMove = terminal.cumulativeSpotMove * 100;
+    const direction = spotShock < 0 ? 'down' : spotShock > 0 ? 'up' : 'flat';
+    if (outcome === 'diverged') {
+        return `Warning: Cascade diverged after ${spotShock * 100}% spot ${direction} shock. ` +
+            `IV moved ${totalIVMove.toFixed(2)} vol points cumulatively.`;
+    }
+    if (outcome === 'oscillating') {
+        return `Cascade oscillated after ${spotShock * 100}% spot ${direction} shock. ` +
+            `Net IV move: ${totalIVMove.toFixed(2)} vol points.`;
+    }
+    if (Math.abs(totalIVMove) > 2) {
+        return `Significant IV reaction: ${spotShock * 100}% spot ${direction} shock triggered ` +
+            `${totalIVMove.toFixed(2)} vol point IV move through feedback loop.`;
+    }
+    return `Minimal cascade effect: ${spotShock * 100}% spot ${direction} shock absorbed ` +
+        `with only ${totalIVMove.toFixed(2)} vol point IV move.`;
+}
+/**
+ * Analyze IV path for multiple spot scenarios
+ */
+function analyzeIVPath(ivSurface, exposures, spot, options = {}) {
+    const scenarios = options.spotScenarios ?? [-0.03, -0.02, -0.01, 0, 0.01, 0.02, 0.03];
+    const results = new Map();
+    for (const scenario of scenarios) {
+        const evolution = predictIVSurfaceEvolution(ivSurface, exposures, spot, scenario, options.config);
+        results.set(scenario, evolution);
+    }
+    return results;
+}
+/**
+ * Get the IV path of least resistance
+ */
+function getIVPathOfLeastResistance(ivSurface, exposures, spot) {
+    const regimeParams = (0, regime_1.deriveRegimeParams)(ivSurface, spot);
+    const upPressures = calculateIVPressures(ivSurface, exposures, regimeParams, 0.01);
+    const downPressures = calculateIVPressures(ivSurface, exposures, regimeParams, -0.01);
+    const neutralPressures = calculateIVPressures(ivSurface, exposures, regimeParams, 0);
+    const upNetPressure = upPressures.reduce((sum, p) => sum + p.netIVPressure, 0);
+    const downNetPressure = downPressures.reduce((sum, p) => sum + p.netIVPressure, 0);
+    const neutralNetPressure = neutralPressures.reduce((sum, p) => sum + p.netIVPressure, 0);
+    let direction = 'stable';
+    let magnitude = 0;
+    let rationale = '';
+    const netBias = (downNetPressure + neutralNetPressure) - upNetPressure;
+    if (netBias > 0.001) {
+        direction = 'up';
+        magnitude = Math.abs(netBias);
+        rationale = `Positioning suggests IV upside bias. Vanna hedging would add ${(magnitude * 100).toFixed(2)} vol points on down moves.`;
+    }
+    else if (netBias < -0.001) {
+        direction = 'down';
+        magnitude = Math.abs(netBias);
+        rationale = `Positioning suggests IV downside bias. Vol selling pressure would reduce IV by ${(magnitude * 100).toFixed(2)} vol points.`;
+    }
+    else {
+        direction = 'stable';
+        magnitude = 0;
+        rationale = `Balanced positioning suggests IV stability.`;
+    }
+    const confidence = calculatePositioningClarity(exposures);
+    return { direction, magnitude, confidence, rationale };
+}

package/dist/pressure/normalize.d.ts

@@ -0,0 +1,6 @@
+import { ExposurePerExpiry } from '../types';
+import { RegimeParams, NormalizedExposureSummary } from './types';
+/**
+ * Normalize raw exposures to comparable "expected daily flow" units
+ */
+export declare function normalizeExposures(exposures: ExposurePerExpiry, regimeParams: RegimeParams): NormalizedExposureSummary;

package/dist/pressure/normalize.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExposures = normalizeExposures;
+/**
+ * Normalize raw exposures to comparable "expected daily flow" units
+ */
+function normalizeExposures(exposures, regimeParams) {
+    const { expectedDailySpotMove, expectedDailyVolMove, impliedSpotVolCorr, regime } = regimeParams;
+    const corrAmplifier = 1 + Math.abs(impliedSpotVolCorr);
+    const volOfVolMultiplier = {
+        calm: 0.5,
+        normal: 1.0,
+        stressed: 2.5,
+        crisis: 5.0,
+    };
+    const normalizedStrikes = [];
+    let totalEffectiveGamma = 0;
+    let totalEffectiveVanna = 0;
+    let totalEffectiveCharm = 0;
+    for (const strike of exposures.strikeExposures) {
+        const effectiveGamma = Math.abs(strike.gammaExposure) * expectedDailySpotMove;
+        const effectiveVanna = Math.abs(strike.vannaExposure) *
+            expectedDailySpotMove *
+            expectedDailyVolMove *
+            volOfVolMultiplier[regime] *
+            corrAmplifier;
+        const effectiveCharm = Math.abs(strike.charmExposure);
+        const totalEffective = effectiveGamma + effectiveVanna + effectiveCharm;
+        let dominant = 'gamma';
+        if (effectiveVanna > effectiveGamma && effectiveVanna > effectiveCharm) {
+            dominant = 'vanna';
+        }
+        else if (effectiveCharm > effectiveGamma && effectiveCharm > effectiveVanna) {
+            dominant = 'charm';
+        }
+        normalizedStrikes.push({
+            strike: strike.strikePrice,
+            rawGamma: strike.gammaExposure,
+            rawVanna: strike.vannaExposure,
+            rawCharm: strike.charmExposure,
+            effectiveGamma,
+            effectiveVanna,
+            effectiveCharm,
+            totalEffective,
+            dominant,
+        });
+        totalEffectiveGamma += effectiveGamma;
+        totalEffectiveVanna += effectiveVanna;
+        totalEffectiveCharm += effectiveCharm;
+    }
+    const totalEffective = totalEffectiveGamma + totalEffectiveVanna + totalEffectiveCharm;
+    const weights = {
+        gamma: totalEffective > 0 ? totalEffectiveGamma / totalEffective : 0.33,
+        vanna: totalEffective > 0 ? totalEffectiveVanna / totalEffective : 0.33,
+        charm: totalEffective > 0 ? totalEffectiveCharm / totalEffective : 0.34,
+    };
+    let dominantGreek = 'gamma';
+    if (weights.vanna > weights.gamma && weights.vanna > weights.charm) {
+        dominantGreek = 'vanna';
+    }
+    else if (weights.charm > weights.gamma && weights.charm > weights.vanna) {
+        dominantGreek = 'charm';
+    }
+    return {
+        spot: exposures.spotPrice,
+        expiration: exposures.expiration,
+        regimeParams,
+        strikeExposures: normalizedStrikes,
+        totalEffectiveGamma,
+        totalEffectiveVanna,
+        totalEffectiveCharm,
+        totalEffective,
+        dominantGreek,
+        weights,
+    };
+}

package/dist/pressure/regime.d.ts

@@ -0,0 +1,7 @@
+import { IVSurface } from '../types';
+import { RegimeParams } from './types';
+/**
+ * Derive regime parameters from the IV surface
+ */
+export declare function deriveRegimeParams(ivSurface: IVSurface, spot: number): RegimeParams;
+export declare function interpolateIVAtStrike(strikes: number[], ivs: number[], targetStrike: number): number;

package/dist/pressure/regime.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveRegimeParams = deriveRegimeParams;
+exports.interpolateIVAtStrike = interpolateIVAtStrike;
+/**
+ * Derive regime parameters from the IV surface
+ */
+function deriveRegimeParams(ivSurface, spot) {
+    const { strikes, smoothedIVs } = ivSurface;
+    const atmIV = interpolateIVAtStrike(strikes, smoothedIVs, spot) / 100;
+    const skew = calculateSkewAtSpot(strikes, smoothedIVs, spot);
+    const impliedSpotVolCorr = skewToCorrelation(skew);
+    const curvature = calculateCurvatureAtSpot(strikes, smoothedIVs, spot);
+    const impliedVolOfVol = curvatureToVolOfVol(curvature, atmIV);
+    const regime = ivToRegime(atmIV);
+    const expectedDailySpotMove = atmIV / Math.sqrt(252);
+    const expectedDailyVolMove = impliedVolOfVol / Math.sqrt(252);
+    return {
+        atmIV,
+        impliedSpotVolCorr,
+        impliedVolOfVol,
+        regime,
+        expectedDailySpotMove,
+        expectedDailyVolMove,
+    };
+}
+function skewToCorrelation(skew) {
+    const SKEW_TO_CORR_SCALE = 0.15;
+    return Math.max(-0.95, Math.min(0.5, skew * SKEW_TO_CORR_SCALE));
+}
+function curvatureToVolOfVol(curvature, atmIV) {
+    const VOL_OF_VOL_SCALE = 2.0;
+    return Math.sqrt(Math.abs(curvature)) * VOL_OF_VOL_SCALE * atmIV;
+}
+function ivToRegime(atmIV) {
+    if (atmIV < 0.15)
+        return 'calm';
+    if (atmIV < 0.20)
+        return 'normal';
+    if (atmIV < 0.35)
+        return 'stressed';
+    return 'crisis';
+}
+function interpolateIVAtStrike(strikes, ivs, targetStrike) {
+    if (strikes.length === 0 || ivs.length === 0)
+        return 20;
+    if (strikes.length === 1)
+        return ivs[0];
+    let lower = 0;
+    let upper = strikes.length - 1;
+    for (let i = 0; i < strikes.length - 1; i++) {
+        if (strikes[i] <= targetStrike && strikes[i + 1] >= targetStrike) {
+            lower = i;
+            upper = i + 1;
+            break;
+        }
+    }
+    if (targetStrike <= strikes[0])
+        return ivs[0];
+    if (targetStrike >= strikes[strikes.length - 1])
+        return ivs[ivs.length - 1];
+    const t = (targetStrike - strikes[lower]) / (strikes[upper] - strikes[lower]);
+    return ivs[lower] + t * (ivs[upper] - ivs[lower]);
+}
+function calculateSkewAtSpot(strikes, ivs, spot) {
+    if (strikes.length < 2)
+        return 0;
+    let lowerIdx = 0;
+    let upperIdx = strikes.length - 1;
+    for (let i = 0; i < strikes.length - 1; i++) {
+        if (strikes[i] <= spot && strikes[i + 1] >= spot) {
+            lowerIdx = i;
+            upperIdx = i + 1;
+            break;
+        }
+    }
+    const dIV = ivs[upperIdx] - ivs[lowerIdx];
+    const dK = strikes[upperIdx] - strikes[lowerIdx];
+    return dK > 0 ? (dIV / dK) * spot : 0;
+}
+function calculateCurvatureAtSpot(strikes, ivs, spot) {
+    if (strikes.length < 3)
+        return 0;
+    let centerIdx = 0;
+    for (let i = 0; i < strikes.length; i++) {
+        if (Math.abs(strikes[i] - spot) < Math.abs(strikes[centerIdx] - spot)) {
+            centerIdx = i;
+        }
+    }
+    if (centerIdx === 0 || centerIdx === strikes.length - 1)
+        return 0;
+    const h = (strikes[centerIdx + 1] - strikes[centerIdx - 1]) / 2;
+    if (h <= 0)
+        return 0;
+    const ivMinus = ivs[centerIdx - 1];
+    const iv = ivs[centerIdx];
+    const ivPlus = ivs[centerIdx + 1];
+    return ((ivPlus - 2 * iv + ivMinus) / (h * h)) * spot * spot;
+}

package/dist/pressure/types.d.ts

@@ -0,0 +1,182 @@
+import { IVSurface, ExposurePerExpiry } from '../types';
+/**
+ * Regime classification based on IV level and surface characteristics
+ */
+export type MarketRegime = 'calm' | 'normal' | 'stressed' | 'crisis';
+/**
+ * Parameters derived from the IV surface itself (no external data needed)
+ */
+export interface RegimeParams {
+    /** ATM implied volatility (as decimal, e.g., 0.18 for 18%) */
+    atmIV: number;
+    /** Implied spot-vol correlation derived from skew */
+    impliedSpotVolCorr: number;
+    /** Implied vol-of-vol derived from smile curvature */
+    impliedVolOfVol: number;
+    /** Regime classification */
+    regime: MarketRegime;
+    /** Expected daily spot move (as decimal) */
+    expectedDailySpotMove: number;
+    /** Expected daily vol move (as decimal) */
+    expectedDailyVolMove: number;
+}
+/**
+ * Normalized exposure at a single strike
+ */
+export interface NormalizedExposure {
+    strike: number;
+    rawGamma: number;
+    rawVanna: number;
+    rawCharm: number;
+    effectiveGamma: number;
+    effectiveVanna: number;
+    effectiveCharm: number;
+    totalEffective: number;
+    dominant: 'gamma' | 'vanna' | 'charm';
+}
+/**
+ * Aggregate normalized exposure metrics
+ */
+export interface NormalizedExposureSummary {
+    spot: number;
+    expiration: number;
+    regimeParams: RegimeParams;
+    strikeExposures: NormalizedExposure[];
+    totalEffectiveGamma: number;
+    totalEffectiveVanna: number;
+    totalEffectiveCharm: number;
+    totalEffective: number;
+    dominantGreek: 'gamma' | 'vanna' | 'charm';
+    weights: {
+        gamma: number;
+        vanna: number;
+        charm: number;
+    };
+}
+/**
+ * Hedging pressure at a (spot, time) coordinate
+ */
+export interface HedgingPressure {
+    spot: number;
+    timeToExpiry: number;
+    hoursRemaining: number;
+    gammaFlow: number;
+    vannaFlow: number;
+    charmFlow: number;
+    netPressure: number;
+    effectivePressure: number;
+    direction: 'supportive' | 'resistive' | 'neutral';
+}
+/**
+ * Grid cell for pressure visualization
+ */
+export interface PressureGridCell {
+    spot: number;
+    hoursRemaining: number;
+    pressure: HedgingPressure;
+    spotGradient: number;
+    timeGradient: number;
+}
+/**
+ * Key levels derived from pressure field
+ */
+export interface KeyLevels {
+    support: number[];
+    resistance: number[];
+    pinning: number[];
+    gammaFlip: number | null;
+}
+/**
+ * Path of least resistance analysis
+ */
+export interface PathOfLeastResistance {
+    direction: 'up' | 'down' | 'pin';
+    targetSpot: number;
+    confidence: number;
+    rationale: string;
+}
+/**
+ * Complete pressure grid
+ */
+export interface PressureGrid {
+    symbol: string;
+    expiration: number;
+    currentSpot: number;
+    timestamp: number;
+    regime: MarketRegime;
+    spotRange: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    timeRange: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    cells: PressureGridCell[][];
+    keyLevels: KeyLevels;
+    pathOfLeastResistance: PathOfLeastResistance;
+}
+/**
+ * IV pressure at a specific strike
+ */
+export interface StrikeIVPressure {
+    strike: number;
+    currentIV: number;
+    vannaIVPressure: number;
+    vommaIVPressure: number;
+    vetaIVPressure: number;
+    netIVPressure: number;
+    liquidityScore: number;
+    expectedIVMove: number;
+}
+/**
+ * IV surface evolution prediction
+ */
+export interface IVSurfaceEvolution {
+    currentSurface: IVSurface;
+    predictedSurface: IVSurface;
+    strikePressures: StrikeIVPressure[];
+    netSurfacePressure: number;
+    atmIVMove: number;
+    skewChange: number;
+    curvatureChange: number;
+    confidence: number;
+}
+/**
+ * Cascade simulation step
+ */
+export interface CascadeStep {
+    step: number;
+    spot: number;
+    ivSurface: IVSurface;
+    exposures: ExposurePerExpiry;
+    regime: MarketRegime;
+    ivPressure: number;
+    spotPressure: number;
+    cumulativeIVMove: number;
+    cumulativeSpotMove: number;
+}
+/**
+ * Full cascade simulation result
+ */
+export interface CascadeSimulation {
+    initial: CascadeStep;
+    steps: CascadeStep[];
+    terminal: CascadeStep;
+    outcome: 'converged' | 'diverged' | 'oscillating';
+    insight: string;
+}
+/**
+ * Configuration for IV path prediction
+ */
+export interface IVPathConfig {
+    spotMoveScenario: number;
+    timeStepHours: number;
+    cascadeIterations: number;
+    cascadeDampening: number;
+    ivImpactPerMillion: number;
+    ivFloor: number;
+    ivCeiling: number;
+}

package/dist/pressure/types.js

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