@fullstackcraftllc/floe 0.0.13 → 0.0.14

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 });

package/dist/utils/indexOptions.js

@@ -9,8 +9,9 @@ exports.getUnderlyingFromOptionRoot = exports.OPTION_ROOT_TO_UNDERLYING = void 0
 exports.OPTION_ROOT_TO_UNDERLYING = {
     'SPXW': 'SPX', // SPX Weekly options
     'SPXPM': 'SPX', // SPX PM-settled options
-    'NDXP': 'NDX', // NDX PM-settled options
+    'NDXP': 'NDX', // NDXP is Tradier's NDX options root
     'RUTW': 'RUT', // RUT Weekly options
+    'DJXW': 'DJX', // DJX Weekly options
     // Add more as needed
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fullstackcraftllc/floe",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "Production-ready options analytics toolkit. Normalize broker data structures and calculate Black-Scholes, Greeks, and exposures with a clean, type-safe API. Built for trading platforms and fintech applications.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",