@fullstackcraftllc/floe 0.0.13 → 0.0.15

package/dist/impliedpdf/adjusted.js

@@ -0,0 +1,500 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuantile = exports.getCumulativeProbability = exports.getProbabilityInRange = exports.OPEX_CONFIG = exports.CRISIS_CONFIG = exports.LOW_VOL_CONFIG = exports.DEFAULT_ADJUSTMENT_CONFIG = void 0;
+exports.estimateExposureAdjustedPDF = estimateExposureAdjustedPDF;
+exports.getEdgeAtPrice = getEdgeAtPrice;
+exports.getSignificantAdjustmentLevels = getSignificantAdjustmentLevels;
+const index_1 = require("./index");
+Object.defineProperty(exports, "getProbabilityInRange", { enumerable: true, get: function () { return index_1.getProbabilityInRange; } });
+Object.defineProperty(exports, "getCumulativeProbability", { enumerable: true, get: function () { return index_1.getCumulativeProbability; } });
+Object.defineProperty(exports, "getQuantile", { enumerable: true, get: function () { return index_1.getQuantile; } });
+// ============================================================================
+// Default Configuration
+// ============================================================================
+/**
+ * Default configuration tuned for SPX-like indices
+ */
+exports.DEFAULT_ADJUSTMENT_CONFIG = {
+    gamma: {
+        enabled: true,
+        attractorStrength: 0.3,
+        repellentStrength: 0.3,
+        threshold: 1000000, // $1M GEX
+        decayRate: 2.0,
+    },
+    vanna: {
+        enabled: true,
+        spotVolBeta: -3.0,
+        maxTailMultiplier: 2.5,
+        feedbackIterations: 3,
+    },
+    charm: {
+        enabled: true,
+        timeHorizon: 'daily',
+        shiftScale: 1.0,
+    },
+};
+/**
+ * Configuration for low volatility / grinding markets
+ */
+exports.LOW_VOL_CONFIG = {
+    gamma: {
+        enabled: true,
+        attractorStrength: 0.4, // Stronger pinning
+        repellentStrength: 0.2,
+        threshold: 500000,
+        decayRate: 1.5,
+    },
+    vanna: {
+        enabled: true,
+        spotVolBeta: -2.0, // Less reactive
+        maxTailMultiplier: 1.5,
+        feedbackIterations: 2,
+    },
+    charm: {
+        enabled: true,
+        timeHorizon: 'daily',
+        shiftScale: 1.5, // Charm matters more in calm markets
+    },
+};
+/**
+ * Configuration for high volatility / crisis markets
+ */
+exports.CRISIS_CONFIG = {
+    gamma: {
+        enabled: true,
+        attractorStrength: 0.1, // Pins don't hold
+        repellentStrength: 0.5, // -GEX acceleration dominates
+        threshold: 2000000,
+        decayRate: 3.0,
+    },
+    vanna: {
+        enabled: true,
+        spotVolBeta: -5.0, // Highly reactive
+        maxTailMultiplier: 3.0,
+        feedbackIterations: 5,
+    },
+    charm: {
+        enabled: true,
+        timeHorizon: 'intraday',
+        shiftScale: 0.5, // Charm less important vs gamma/vanna
+    },
+};
+/**
+ * Configuration for OPEX week
+ */
+exports.OPEX_CONFIG = {
+    gamma: {
+        enabled: true,
+        attractorStrength: 0.5, // Strong pinning into expiry
+        repellentStrength: 0.4,
+        threshold: 1000000,
+        decayRate: 2.5,
+    },
+    vanna: {
+        enabled: true,
+        spotVolBeta: -3.0,
+        maxTailMultiplier: 2.0,
+        feedbackIterations: 3,
+    },
+    charm: {
+        enabled: true,
+        timeHorizon: 'intraday', // Charm accelerates into expiry
+        shiftScale: 2.0,
+    },
+};
+// ============================================================================
+// Core Functions
+// ============================================================================
+/**
+ * Estimate an exposure-adjusted implied probability distribution.
+ *
+ * This function takes the standard market-implied PDF (Breeden-Litzenberger)
+ * and adjusts it based on dealer Greek exposures to produce a "mechanically-informed"
+ * probability distribution that accounts for:
+ *
+ * - **Gamma**: Creates "sticky" zones (+GEX) where price pins, and "slippery" zones
+ *   (-GEX) where price accelerates through
+ * - **Vanna**: Fattens tails based on the IV-spot feedback loop (selloffs spike IV,
+ *   which forces more selling via negative vanna)
+ * - **Charm**: Shifts the mean based on predictable delta decay over time
+ *
+ * @param symbol - Underlying ticker symbol
+ * @param underlyingPrice - Current spot price
+ * @param callOptions - Call options for a single expiry
+ * @param exposures - Exposure metrics from calculateGammaVannaCharmExposures()
+ * @param config - Adjustment configuration (uses defaults if not provided)
+ * @returns Baseline and adjusted PDFs with comparison metrics
+ *
+ * @example
+ * ```typescript
+ * // Get exposures first
+ * const allExposures = calculateGammaVannaCharmExposures(chain, ivSurfaces);
+ * const expiryExposures = allExposures.find(e => e.expiration === targetExpiry);
+ *
+ * // Calculate adjusted PDF
+ * const result = estimateExposureAdjustedPDF(
+ *   'SPX',
+ *   4520,
+ *   callOptionsForExpiry,
+ *   expiryExposures
+ * );
+ *
+ * // Compare probabilities
+ * const target = 4400;
+ * const baselineProb = getCumulativeProbability(result.baseline, target);
+ * const adjustedProb = getCumulativeProbability(result.adjusted, target);
+ * console.log(`Market says ${baselineProb}% chance of ${target}`);
+ * console.log(`Flow-adjusted: ${adjustedProb}% chance`);
+ * ```
+ */
+function estimateExposureAdjustedPDF(symbol, underlyingPrice, callOptions, exposures, config = {}) {
+    // Merge config with defaults
+    const cfg = mergeConfig(config);
+    // Step 1: Get baseline PDF using existing Breeden-Litzenberger implementation
+    const baselineResult = (0, index_1.estimateImpliedProbabilityDistribution)(symbol, underlyingPrice, callOptions);
+    if (!baselineResult.success) {
+        return { success: false, error: baselineResult.error };
+    }
+    const baseline = baselineResult.distribution;
+    // Step 2: Calculate gamma modifiers
+    const gammaModifiers = cfg.gamma.enabled
+        ? calculateGammaModifiers(baseline.strikeProbabilities, exposures, underlyingPrice, cfg.gamma)
+        : baseline.strikeProbabilities.map(() => 1.0);
+    // Step 3: Calculate vanna modifiers
+    const vannaModifiers = cfg.vanna.enabled
+        ? calculateVannaModifiers(baseline.strikeProbabilities, exposures, underlyingPrice, cfg.vanna)
+        : baseline.strikeProbabilities.map(() => 1.0);
+    // Step 4: Calculate charm-induced mean shift
+    const charmShift = cfg.charm.enabled
+        ? calculateCharmShift(exposures, underlyingPrice, cfg.charm)
+        : 0;
+    // Step 5: Apply modifiers to create adjusted probabilities
+    const adjustedProbabilities = applyModifiers(baseline.strikeProbabilities, gammaModifiers, vannaModifiers, charmShift);
+    // Step 6: Normalize to ensure probabilities sum to 1
+    const normalizedProbabilities = normalizeProbabilities(adjustedProbabilities);
+    // Step 7: Recalculate distribution statistics
+    const adjusted = recalculateDistributionStats(baseline, normalizedProbabilities, underlyingPrice);
+    // Step 8: Calculate comparison metrics
+    const comparison = calculateComparison(baseline, adjusted, gammaModifiers, vannaModifiers, charmShift);
+    return {
+        baseline,
+        adjusted,
+        gammaModifiers,
+        vannaModifiers,
+        charmShift,
+        comparison,
+    };
+}
+// ============================================================================
+// Modifier Calculations
+// ============================================================================
+/**
+ * Calculate gamma-based probability modifiers.
+ *
+ * Positive GEX creates "attractors" - price tends to pin at these levels.
+ * Negative GEX creates "repellents" - price accelerates through these levels.
+ *
+ * Uses 1/d² decay similar to the "local hedge pressure field" concept.
+ */
+function calculateGammaModifiers(strikeProbabilities, exposures, spot, config) {
+    const modifiers = [];
+    // Find max absolute GEX for normalization
+    const maxGex = Math.max(...exposures.strikeExposures.map(e => Math.abs(e.gammaExposure)), 1 // Prevent division by zero
+    );
+    for (const prob of strikeProbabilities) {
+        let modifier = 1.0;
+        for (const exposure of exposures.strikeExposures) {
+            // Skip insignificant exposures
+            if (Math.abs(exposure.gammaExposure) < config.threshold) {
+                continue;
+            }
+            // Distance normalized by spot price
+            const distance = Math.abs(prob.strike - exposure.strikePrice) / spot;
+            // Influence decays with distance squared (electrostatic/gravitational)
+            const influence = 1 / (1 + config.decayRate * distance * distance);
+            // Normalized GEX (-1 to 1)
+            const normalizedGex = exposure.gammaExposure / maxGex;
+            if (exposure.gammaExposure > 0) {
+                // Positive GEX = attractor = increase probability density
+                modifier *= 1 + config.attractorStrength * normalizedGex * influence;
+            }
+            else {
+                // Negative GEX = repellent = decrease probability density
+                modifier *= 1 - config.repellentStrength * Math.abs(normalizedGex) * influence;
+            }
+        }
+        // Clamp to reasonable bounds
+        modifiers.push(Math.max(0.1, Math.min(3.0, modifier)));
+    }
+    return modifiers;
+}
+/**
+ * Calculate vanna-based probability modifiers.
+ *
+ * Vanna creates feedback loops:
+ * - Spot drops → IV spikes → negative vanna forces selling → spot drops more
+ *
+ * This fattens the left tail beyond what the market-implied PDF shows.
+ */
+function calculateVannaModifiers(strikeProbabilities, exposures, spot, config) {
+    const modifiers = [];
+    // Sum vanna below and above spot
+    const vannaBelow = exposures.strikeExposures
+        .filter(e => e.strikePrice < spot)
+        .reduce((sum, e) => sum + e.vannaExposure, 0);
+    const vannaAbove = exposures.strikeExposures
+        .filter(e => e.strikePrice > spot)
+        .reduce((sum, e) => sum + e.vannaExposure, 0);
+    for (const prob of strikeProbabilities) {
+        let modifier = 1.0;
+        // Percentage move to this strike
+        const movePercent = (prob.strike - spot) / spot;
+        if (movePercent < 0) {
+            // Downside move: estimate IV spike
+            const ivSpike = -movePercent * Math.abs(config.spotVolBeta);
+            // Vanna flow from IV change
+            // Negative vanna * positive IV change = selling pressure
+            const vannaFlow = vannaBelow * ivSpike;
+            if (vannaFlow < 0) {
+                // Selling pressure increases left tail probability
+                let cumulativeEffect = 0;
+                let currentFlow = Math.abs(vannaFlow);
+                // Iterate feedback loop (each iteration dampens ~50%)
+                for (let i = 0; i < config.feedbackIterations; i++) {
+                    cumulativeEffect += currentFlow;
+                    currentFlow *= 0.5;
+                }
+                // Scale to modifier (normalize by spot * $1M for comparability)
+                const effectScale = cumulativeEffect / (spot * 1000000);
+                modifier = 1 + Math.min(config.maxTailMultiplier - 1, effectScale);
+            }
+        }
+        else if (movePercent > 0) {
+            // Upside move: IV typically compresses (asymmetrically less than down moves)
+            const ivCompress = movePercent * Math.abs(config.spotVolBeta) * 0.5;
+            // Positive vanna + IV compression = less buying pressure on upside
+            const vannaFlow = vannaAbove * (-ivCompress);
+            if (vannaFlow > 0) {
+                const effectScale = vannaFlow / (spot * 1000000);
+                modifier = Math.max(0.5, 1 - effectScale * 0.5);
+            }
+        }
+        modifiers.push(modifier);
+    }
+    return modifiers;
+}
+/**
+ * Calculate charm-induced mean shift.
+ *
+ * Net charm represents guaranteed delta decay. Negative net charm means
+ * dealers will be net sellers over time (downward pressure).
+ */
+function calculateCharmShift(exposures, spot, config) {
+    const timeMultiplier = {
+        'intraday': 0.25,
+        'daily': 1.0,
+        'weekly': 5.0,
+    }[config.timeHorizon];
+    // Estimate price impact of charm flow
+    // Heuristic: $1B of flow ≈ 0.1% price impact for large indices
+    const flowImpactPerBillion = 0.001 * spot;
+    const priceShift = (exposures.totalCharmExposure / 1000000000) * flowImpactPerBillion * timeMultiplier;
+    return priceShift * config.shiftScale;
+}
+// ============================================================================
+// PDF Operations
+// ============================================================================
+/**
+ * Apply gamma, vanna, and charm modifiers to probability distribution
+ */
+function applyModifiers(strikeProbabilities, gammaModifiers, vannaModifiers, charmShift) {
+    return strikeProbabilities.map((sp, i) => ({
+        strike: sp.strike + charmShift,
+        probability: sp.probability * gammaModifiers[i] * vannaModifiers[i],
+    }));
+}
+/**
+ * Normalize probabilities to sum to 1
+ */
+function normalizeProbabilities(strikeProbabilities) {
+    const sum = strikeProbabilities.reduce((acc, sp) => acc + sp.probability, 0);
+    if (sum < 1e-9) {
+        // If all probabilities are essentially zero, return uniform
+        const uniform = 1 / strikeProbabilities.length;
+        return strikeProbabilities.map(sp => ({ ...sp, probability: uniform }));
+    }
+    return strikeProbabilities.map(sp => ({
+        strike: sp.strike,
+        probability: sp.probability / sum,
+    }));
+}
+/**
+ * Recalculate distribution statistics from adjusted probabilities
+ */
+function recalculateDistributionStats(baseline, adjustedProbabilities, underlyingPrice) {
+    // Most likely price (mode)
+    let mostLikelyPrice = adjustedProbabilities[0].strike;
+    let maxProb = 0;
+    for (const sp of adjustedProbabilities) {
+        if (sp.probability > maxProb) {
+            maxProb = sp.probability;
+            mostLikelyPrice = sp.strike;
+        }
+    }
+    // Median (50th percentile)
+    let cumulative = 0;
+    let medianPrice = adjustedProbabilities[Math.floor(adjustedProbabilities.length / 2)].strike;
+    for (const sp of adjustedProbabilities) {
+        cumulative += sp.probability;
+        if (cumulative >= 0.5) {
+            medianPrice = sp.strike;
+            break;
+        }
+    }
+    // Expected value (mean)
+    let mean = 0;
+    for (const sp of adjustedProbabilities) {
+        mean += sp.strike * sp.probability;
+    }
+    // Variance and expected move (std dev)
+    let variance = 0;
+    for (const sp of adjustedProbabilities) {
+        const diff = sp.strike - mean;
+        variance += diff * diff * sp.probability;
+    }
+    const expectedMove = Math.sqrt(variance);
+    // Tail skew
+    let leftTail = 0;
+    let rightTail = 0;
+    for (const sp of adjustedProbabilities) {
+        if (sp.strike < mean) {
+            leftTail += sp.probability;
+        }
+        else {
+            rightTail += sp.probability;
+        }
+    }
+    const tailSkew = rightTail / Math.max(leftTail, 1e-9);
+    // Cumulative above/below spot
+    let cumulativeBelowSpot = 0;
+    let cumulativeAboveSpot = 0;
+    for (const sp of adjustedProbabilities) {
+        if (sp.strike < underlyingPrice) {
+            cumulativeBelowSpot += sp.probability;
+        }
+        else if (sp.strike > underlyingPrice) {
+            cumulativeAboveSpot += sp.probability;
+        }
+    }
+    return {
+        symbol: baseline.symbol,
+        expiryDate: baseline.expiryDate,
+        calculationTimestamp: Date.now(),
+        underlyingPrice,
+        strikeProbabilities: adjustedProbabilities,
+        mostLikelyPrice,
+        medianPrice,
+        expectedValue: mean,
+        expectedMove,
+        tailSkew,
+        cumulativeProbabilityAboveSpot: cumulativeAboveSpot,
+        cumulativeProbabilityBelowSpot: cumulativeBelowSpot,
+    };
+}
+/**
+ * Calculate comparison metrics between baseline and adjusted distributions
+ */
+function calculateComparison(baseline, adjusted, gammaModifiers, vannaModifiers, charmShift) {
+    // Tail percentiles
+    const baseline5 = (0, index_1.getQuantile)(baseline, 0.05);
+    const baseline95 = (0, index_1.getQuantile)(baseline, 0.95);
+    const adjusted5 = (0, index_1.getQuantile)(adjusted, 0.05);
+    const adjusted95 = (0, index_1.getQuantile)(adjusted, 0.95);
+    // Determine dominant factor
+    const gammaEffect = Math.max(...gammaModifiers) - Math.min(...gammaModifiers);
+    const vannaEffect = Math.max(...vannaModifiers) - Math.min(...vannaModifiers);
+    const charmEffect = Math.abs(charmShift) / baseline.underlyingPrice;
+    let dominantFactor = 'none';
+    const maxEffect = Math.max(gammaEffect, vannaEffect, charmEffect);
+    if (maxEffect > 0.01) {
+        if (gammaEffect === maxEffect)
+            dominantFactor = 'gamma';
+        else if (vannaEffect === maxEffect)
+            dominantFactor = 'vanna';
+        else
+            dominantFactor = 'charm';
+    }
+    return {
+        meanShift: adjusted.expectedValue - baseline.expectedValue,
+        meanShiftPercent: ((adjusted.expectedValue - baseline.expectedValue) / baseline.underlyingPrice) * 100,
+        stdDevChange: adjusted.expectedMove - baseline.expectedMove,
+        tailSkewChange: adjusted.tailSkew - baseline.tailSkew,
+        leftTail: {
+            baseline: baseline5,
+            adjusted: adjusted5,
+            ratio: adjusted5 / baseline5,
+        },
+        rightTail: {
+            baseline: baseline95,
+            adjusted: adjusted95,
+            ratio: adjusted95 / baseline95,
+        },
+        dominantFactor,
+    };
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Merge partial config with defaults
+ */
+function mergeConfig(partial) {
+    return {
+        gamma: { ...exports.DEFAULT_ADJUSTMENT_CONFIG.gamma, ...partial.gamma },
+        vanna: { ...exports.DEFAULT_ADJUSTMENT_CONFIG.vanna, ...partial.vanna },
+        charm: { ...exports.DEFAULT_ADJUSTMENT_CONFIG.charm, ...partial.charm },
+    };
+}
+/**
+ * Get the "edge" - the difference between market-implied and flow-adjusted
+ * probability of reaching a price level.
+ *
+ * Positive edge means the market is underpricing the probability of reaching that level.
+ * Negative edge means the market is overpricing it.
+ *
+ * @example
+ * ```typescript
+ * const result = estimateExposureAdjustedPDF(...);
+ * const edge = getEdgeAtPrice(result, 4400);
+ * console.log(`Edge at 4400: ${(edge * 100).toFixed(2)}%`);
+ * // Output: "Edge at 4400: 2.35%"
+ * // Meaning: flow mechanics suggest 2.35% higher probability than market prices
+ * ```
+ */
+function getEdgeAtPrice(result, price) {
+    const baselineProb = (0, index_1.getCumulativeProbability)(result.baseline, price);
+    const adjustedProb = (0, index_1.getCumulativeProbability)(result.adjusted, price);
+    return adjustedProb - baselineProb;
+}
+/**
+ * Get price levels where the adjustment is most significant
+ */
+function getSignificantAdjustmentLevels(result, threshold = 0.01) {
+    const levels = [];
+    for (let i = 0; i < result.baseline.strikeProbabilities.length; i++) {
+        const baselineProb = result.baseline.strikeProbabilities[i].probability;
+        const adjustedProb = result.adjusted.strikeProbabilities[i]?.probability ?? 0;
+        const edge = adjustedProb - baselineProb;
+        if (Math.abs(edge) >= threshold) {
+            levels.push({
+                strike: result.baseline.strikeProbabilities[i].strike,
+                baselineProb,
+                adjustedProb,
+                edge,
+            });
+        }
+    }
+    // Sort by absolute edge descending
+    return levels.sort((a, b) => Math.abs(b.edge) - Math.abs(a.edge));
+}

package/dist/impliedpdf/index.d.ts

@@ -146,3 +146,4 @@ export declare function getCumulativeProbability(distribution: ImpliedProbabilit
  * ```
  */
 export declare function getQuantile(distribution: ImpliedProbabilityDistribution, probability: number): number;
+export { estimateExposureAdjustedPDF, getEdgeAtPrice, getSignificantAdjustmentLevels, DEFAULT_ADJUSTMENT_CONFIG, LOW_VOL_CONFIG, CRISIS_CONFIG, OPEX_CONFIG, type ExposureAdjustmentConfig, type AdjustedPDFResult, type PDFComparison, } from './adjusted';

package/dist/impliedpdf/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPEX_CONFIG = exports.CRISIS_CONFIG = exports.LOW_VOL_CONFIG = exports.DEFAULT_ADJUSTMENT_CONFIG = exports.getSignificantAdjustmentLevels = exports.getEdgeAtPrice = exports.estimateExposureAdjustedPDF = void 0;
 exports.estimateImpliedProbabilityDistribution = estimateImpliedProbabilityDistribution;
 exports.estimateImpliedProbabilityDistributions = estimateImpliedProbabilityDistributions;
 exports.getProbabilityInRange = getProbabilityInRange;
@@ -276,3 +277,12 @@ function getQuantile(distribution, probability) {
     }
     return distribution.strikeProbabilities[distribution.strikeProbabilities.length - 1]?.strike ?? 0;
 }
+// Re-export exposure-adjusted PDF functionality
+var adjusted_1 = require("./adjusted");
+Object.defineProperty(exports, "estimateExposureAdjustedPDF", { enumerable: true, get: function () { return adjusted_1.estimateExposureAdjustedPDF; } });
+Object.defineProperty(exports, "getEdgeAtPrice", { enumerable: true, get: function () { return adjusted_1.getEdgeAtPrice; } });
+Object.defineProperty(exports, "getSignificantAdjustmentLevels", { enumerable: true, get: function () { return adjusted_1.getSignificantAdjustmentLevels; } });
+Object.defineProperty(exports, "DEFAULT_ADJUSTMENT_CONFIG", { enumerable: true, get: function () { return adjusted_1.DEFAULT_ADJUSTMENT_CONFIG; } });
+Object.defineProperty(exports, "LOW_VOL_CONFIG", { enumerable: true, get: function () { return adjusted_1.LOW_VOL_CONFIG; } });
+Object.defineProperty(exports, "CRISIS_CONFIG", { enumerable: true, get: function () { return adjusted_1.CRISIS_CONFIG; } });
+Object.defineProperty(exports, "OPEX_CONFIG", { enumerable: true, get: function () { return adjusted_1.OPEX_CONFIG; } });

package/dist/index.d.ts

@@ -12,11 +12,17 @@ export { calculateGammaVannaCharmExposures, calculateSharesNeededToCover, } from
 export { cumulativeNormalDistribution, normalPDF, } from './utils/statistics';
 export { buildOCCSymbol, parseOCCSymbol, generateStrikesAroundSpot, generateOCCSymbolsForStrikes, generateOCCSymbolsAroundSpot, } from './utils/occ';
 export type { OCCSymbolParams, ParsedOCCSymbol, StrikeGenerationParams, } from './utils/occ';
-export { estimateImpliedProbabilityDistribution, estimateImpliedProbabilityDistributions, getProbabilityInRange, getCumulativeProbability, getQuantile, } from './impliedpdf';
-export type { StrikeProbability, ImpliedProbabilityDistribution, ImpliedPDFResult, } from './impliedpdf';
+export { estimateImpliedProbabilityDistribution, estimateImpliedProbabilityDistributions, getProbabilityInRange, getCumulativeProbability, getQuantile, estimateExposureAdjustedPDF, getEdgeAtPrice, getSignificantAdjustmentLevels, DEFAULT_ADJUSTMENT_CONFIG, LOW_VOL_CONFIG, CRISIS_CONFIG, OPEX_CONFIG, } from './impliedpdf';
+export type { StrikeProbability, ImpliedProbabilityDistribution, ImpliedPDFResult, ExposureAdjustmentConfig, AdjustedPDFResult, PDFComparison, } from './impliedpdf';
+export { deriveRegimeParams, interpolateIVAtStrike, computeHedgeImpulseCurve, computeCharmIntegral, analyzeHedgeFlow, } from './hedgeflow';
+export type { MarketRegime, RegimeParams, HedgeImpulseConfig, HedgeImpulsePoint, HedgeImpulseCurve, ZeroCrossing, ImpulseExtremum, DirectionalAsymmetry, ImpulseRegime, CharmIntegralConfig, CharmBucket, CharmIntegral, HedgeFlowAnalysis, } from './hedgeflow';
 export { FloeClient, Broker } from './client/FloeClient';
 export { TradierClient } from './client/brokers/TradierClient';
 export { TastyTradeClient } from './client/brokers/TastyTradeClient';
 export { TradeStationClient } from './client/brokers/TradeStationClient';
 export type { AggressorSide, IntradayTrade } from './client/brokers/TradierClient';
 export { genericAdapter, schwabAdapter, ibkrAdapter, tdaAdapter, brokerAdapters, getAdapter, createOptionChain, } from './adapters';
+export { computeVarianceSwapIV, computeImpliedVolatility, } from './iv';
+export type { VarianceSwapResult, ImpliedVolatilityResult, } from './iv';
+export { computeRealizedVolatility, } from './rv';
+export type { PriceObservation, RealizedVolatilityResult, } from './rv';

package/dist/index.js

@@ -20,7 +20,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOptionChain = exports.getAdapter = exports.brokerAdapters = exports.tdaAdapter = exports.ibkrAdapter = exports.schwabAdapter = exports.genericAdapter = exports.TradeStationClient = exports.TastyTradeClient = exports.TradierClient = exports.Broker = exports.FloeClient = exports.getQuantile = exports.getCumulativeProbability = exports.getProbabilityInRange = exports.estimateImpliedProbabilityDistributions = exports.estimateImpliedProbabilityDistribution = exports.generateOCCSymbolsAroundSpot = exports.generateOCCSymbolsForStrikes = exports.generateStrikesAroundSpot = exports.parseOCCSymbol = exports.buildOCCSymbol = exports.normalPDF = exports.cumulativeNormalDistribution = exports.calculateSharesNeededToCover = exports.calculateGammaVannaCharmExposures = exports.smoothTotalVarianceSmile = exports.getIVForStrike = exports.getIVSurfaces = exports.getTimeToExpirationInYears = exports.getMillisecondsToExpiration = exports.calculateImpliedVolatility = exports.calculateGreeks = exports.blackScholes = void 0;
+exports.computeRealizedVolatility = exports.computeImpliedVolatility = exports.computeVarianceSwapIV = exports.createOptionChain = exports.getAdapter = exports.brokerAdapters = exports.tdaAdapter = exports.ibkrAdapter = exports.schwabAdapter = exports.genericAdapter = exports.TradeStationClient = exports.TastyTradeClient = exports.TradierClient = exports.Broker = exports.FloeClient = exports.analyzeHedgeFlow = exports.computeCharmIntegral = exports.computeHedgeImpulseCurve = exports.interpolateIVAtStrike = exports.deriveRegimeParams = exports.OPEX_CONFIG = exports.CRISIS_CONFIG = exports.LOW_VOL_CONFIG = exports.DEFAULT_ADJUSTMENT_CONFIG = exports.getSignificantAdjustmentLevels = exports.getEdgeAtPrice = exports.estimateExposureAdjustedPDF = exports.getQuantile = exports.getCumulativeProbability = exports.getProbabilityInRange = exports.estimateImpliedProbabilityDistributions = exports.estimateImpliedProbabilityDistribution = exports.generateOCCSymbolsAroundSpot = exports.generateOCCSymbolsForStrikes = exports.generateStrikesAroundSpot = exports.parseOCCSymbol = exports.buildOCCSymbol = exports.normalPDF = exports.cumulativeNormalDistribution = exports.calculateSharesNeededToCover = exports.calculateGammaVannaCharmExposures = exports.smoothTotalVarianceSmile = exports.getIVForStrike = exports.getIVSurfaces = exports.getTimeToExpirationInYears = exports.getMillisecondsToExpiration = exports.calculateImpliedVolatility = exports.calculateGreeks = exports.blackScholes = void 0;
 // Core types
 __exportStar(require("./types"), exports);
 // Black-Scholes pricing and Greeks
@@ -59,6 +59,25 @@ Object.defineProperty(exports, "estimateImpliedProbabilityDistributions", { enum
 Object.defineProperty(exports, "getProbabilityInRange", { enumerable: true, get: function () { return impliedpdf_1.getProbabilityInRange; } });
 Object.defineProperty(exports, "getCumulativeProbability", { enumerable: true, get: function () { return impliedpdf_1.getCumulativeProbability; } });
 Object.defineProperty(exports, "getQuantile", { enumerable: true, get: function () { return impliedpdf_1.getQuantile; } });
+// Exposure-adjusted PDF
+Object.defineProperty(exports, "estimateExposureAdjustedPDF", { enumerable: true, get: function () { return impliedpdf_1.estimateExposureAdjustedPDF; } });
+Object.defineProperty(exports, "getEdgeAtPrice", { enumerable: true, get: function () { return impliedpdf_1.getEdgeAtPrice; } });
+Object.defineProperty(exports, "getSignificantAdjustmentLevels", { enumerable: true, get: function () { return impliedpdf_1.getSignificantAdjustmentLevels; } });
+Object.defineProperty(exports, "DEFAULT_ADJUSTMENT_CONFIG", { enumerable: true, get: function () { return impliedpdf_1.DEFAULT_ADJUSTMENT_CONFIG; } });
+Object.defineProperty(exports, "LOW_VOL_CONFIG", { enumerable: true, get: function () { return impliedpdf_1.LOW_VOL_CONFIG; } });
+Object.defineProperty(exports, "CRISIS_CONFIG", { enumerable: true, get: function () { return impliedpdf_1.CRISIS_CONFIG; } });
+Object.defineProperty(exports, "OPEX_CONFIG", { enumerable: true, get: function () { return impliedpdf_1.OPEX_CONFIG; } });
+// Hedge flow analysis (impulse curve, charm integral, regime derivation)
+var hedgeflow_1 = require("./hedgeflow");
+// Regime derivation from IV surface
+Object.defineProperty(exports, "deriveRegimeParams", { enumerable: true, get: function () { return hedgeflow_1.deriveRegimeParams; } });
+Object.defineProperty(exports, "interpolateIVAtStrike", { enumerable: true, get: function () { return hedgeflow_1.interpolateIVAtStrike; } });
+// Hedge impulse curve
+Object.defineProperty(exports, "computeHedgeImpulseCurve", { enumerable: true, get: function () { return hedgeflow_1.computeHedgeImpulseCurve; } });
+// Charm integral
+Object.defineProperty(exports, "computeCharmIntegral", { enumerable: true, get: function () { return hedgeflow_1.computeCharmIntegral; } });
+// Combined analysis
+Object.defineProperty(exports, "analyzeHedgeFlow", { enumerable: true, get: function () { return hedgeflow_1.analyzeHedgeFlow; } });
 // Client
 var FloeClient_1 = require("./client/FloeClient");
 Object.defineProperty(exports, "FloeClient", { enumerable: true, get: function () { return FloeClient_1.FloeClient; } });
@@ -78,3 +97,10 @@ Object.defineProperty(exports, "tdaAdapter", { enumerable: true, get: function (
 Object.defineProperty(exports, "brokerAdapters", { enumerable: true, get: function () { return adapters_1.brokerAdapters; } });
 Object.defineProperty(exports, "getAdapter", { enumerable: true, get: function () { return adapters_1.getAdapter; } });
 Object.defineProperty(exports, "createOptionChain", { enumerable: true, get: function () { return adapters_1.createOptionChain; } });
+// Model-free implied volatility (variance swap / VIX methodology)
+var iv_1 = require("./iv");
+Object.defineProperty(exports, "computeVarianceSwapIV", { enumerable: true, get: function () { return iv_1.computeVarianceSwapIV; } });
+Object.defineProperty(exports, "computeImpliedVolatility", { enumerable: true, get: function () { return iv_1.computeImpliedVolatility; } });
+// Realized volatility (tick-based quadratic variation)
+var rv_1 = require("./rv");
+Object.defineProperty(exports, "computeRealizedVolatility", { enumerable: true, get: function () { return rv_1.computeRealizedVolatility; } });

package/dist/iv/index.d.ts

@@ -0,0 +1,52 @@
+import { NormalizedOption } from '../types';
+import { VarianceSwapResult, ImpliedVolatilityResult } from './types';
+export type { VarianceSwapResult, ImpliedVolatilityResult } from './types';
+/**
+ * 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
+ */
+export declare function computeVarianceSwapIV(options: NormalizedOption[], spot: number, riskFreeRate: number): VarianceSwapResult;
+/**
+ * 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)
+ */
+export declare function computeImpliedVolatility(nearTermOptions: NormalizedOption[], spot: number, riskFreeRate: number, farTermOptions?: NormalizedOption[] | null, targetDays?: number): ImpliedVolatilityResult;