@fullstackcraftllc/floe 0.0.1

package/dist/blackscholes/index.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blackScholes = blackScholes;
+exports.calculateGreeks = calculateGreeks;
+exports.calculateImpliedVolatility = calculateImpliedVolatility;
+exports.getMillisecondsToExpiration = getMillisecondsToExpiration;
+exports.getTimeToExpirationInYears = getTimeToExpirationInYears;
+const types_1 = require("../types");
+const statistics_1 = require("../utils/statistics");
+/**
+ * Calculate option price using Black-Scholes model
+ *
+ * @param params - Black-Scholes parameters
+ * @returns Option price
+ *
+ * @example
+ * ```typescript
+ * const price = blackScholes({
+ *   spot: 100,
+ *   strike: 105,
+ *   timeToExpiry: 0.25,
+ *   volatility: 0.20,
+ *   riskFreeRate: 0.05,
+ *   optionType: 'call'
+ * });
+ * ```
+ */
+function blackScholes(params) {
+    const greeks = calculateGreeks(params);
+    return greeks.price;
+}
+/**
+ * Calculate complete option Greeks using Black-Scholes-Merton model
+ * Includes all first, second, and third-order Greeks
+ *
+ * @param params - Black-Scholes parameters
+ * @returns Complete Greeks including price
+ *
+ * @example
+ * ```typescript
+ * const greeks = calculateGreeks({
+ *   spot: 100,
+ *   strike: 105,
+ *   timeToExpiry: 0.25,
+ *   volatility: 0.20,
+ *   riskFreeRate: 0.05,
+ *   optionType: 'call'
+ * });
+ * ```
+ */
+function calculateGreeks(params) {
+    const { spot: S, strike: K, timeToExpiry: t, volatility: vol, riskFreeRate: r, optionType, dividendYield: q = 0, } = params;
+    // Safety checks
+    if (t < 0) {
+        return createZeroGreeks();
+    }
+    if (vol <= 0 || S <= 0 || t <= 0) {
+        return createZeroGreeks();
+    }
+    // Calculate d1 and d2
+    const sqrtT = Math.sqrt(t);
+    const d1 = (Math.log(S / K) + (r - q + (vol * vol) / 2) * t) / (vol * sqrtT);
+    const d2 = d1 - vol * sqrtT;
+    // Calculate probability functions
+    const nd1 = (0, statistics_1.normalPDF)(d1);
+    const Nd1 = (0, statistics_1.cumulativeNormalDistribution)(d1);
+    const Nd2 = (0, statistics_1.cumulativeNormalDistribution)(d2);
+    const eqt = Math.exp(-q * t);
+    const ert = Math.exp(-r * t);
+    if (optionType === 'call') {
+        return calculateCallGreeks(S, K, r, q, t, vol, d1, d2, nd1, Nd1, Nd2, eqt, ert);
+    }
+    else {
+        return calculatePutGreeks(S, K, r, q, t, vol, d1, d2, nd1, Nd1, Nd2, eqt, ert);
+    }
+}
+/**
+ * Calculate all Greeks for a call option
+ * @internal
+ */
+function calculateCallGreeks(S, K, r, q, t, vol, d1, d2, nd1, Nd1, Nd2, eqt, ert) {
+    const sqrtT = Math.sqrt(t);
+    // Price
+    const price = S * eqt * Nd1 - K * ert * Nd2;
+    // First-order Greeks
+    const delta = eqt * Nd1;
+    const gamma = (eqt * nd1) / (S * vol * sqrtT);
+    const theta = -(S * vol * eqt * nd1) / (2 * sqrtT) - r * K * ert * Nd2 + q * S * eqt * Nd1;
+    const vega = S * eqt * sqrtT * nd1;
+    const rho = K * t * ert * Nd2;
+    // Second-order Greeks
+    const vanna = -eqt * nd1 * (d2 / vol);
+    const charm = -q * eqt * Nd1 - (eqt * nd1 * (2 * (r - q) * t - d2 * vol * sqrtT)) / (2 * t * vol * sqrtT);
+    const volga = vega * ((d1 * d2) / (S * vol));
+    const speed = nd1 / (S * vol);
+    const zomma = (nd1 * d1) / (S * vol * vol);
+    // Third-order Greeks
+    const color = -(d1 * d2 * nd1) / (vol * vol);
+    const ultima = (d1 * d2 * d2 * nd1) / (vol * vol * vol);
+    return {
+        price: round(price, 2),
+        delta: round(delta, 5),
+        gamma: round(gamma, 5),
+        theta: round(theta / types_1.DAYS_PER_YEAR, 5), // Per day
+        vega: round(vega * 0.01, 5), // Per 1% change in volatility
+        rho: round(rho * 0.01, 5), // Per 1% change in interest rate
+        charm: round(charm / types_1.DAYS_PER_YEAR, 5), // Per day
+        vanna: round(vanna, 5),
+        volga: round(volga, 5),
+        speed: round(speed, 5),
+        zomma: round(zomma, 5),
+        color: round(color, 5),
+        ultima: round(ultima, 5),
+    };
+}
+/**
+ * Calculate all Greeks for a put option
+ * @internal
+ */
+function calculatePutGreeks(S, K, r, q, t, vol, d1, d2, nd1, Nd1, Nd2, eqt, ert) {
+    const sqrtT = Math.sqrt(t);
+    // Price
+    const price = K * ert * (0, statistics_1.cumulativeNormalDistribution)(-d2) - S * eqt * (0, statistics_1.cumulativeNormalDistribution)(-d1);
+    // First-order Greeks
+    const delta = -eqt * (0, statistics_1.cumulativeNormalDistribution)(-d1);
+    const gamma = (eqt * nd1) / (S * vol * sqrtT); // Same as call
+    const theta = -(S * vol * eqt * nd1) / (2 * sqrtT) + r * K * ert * (0, statistics_1.cumulativeNormalDistribution)(-d2) - q * S * eqt * (0, statistics_1.cumulativeNormalDistribution)(-d1);
+    const vega = S * eqt * sqrtT * nd1; // Same as call
+    const rho = -K * t * ert * (0, statistics_1.cumulativeNormalDistribution)(-d2);
+    // Second-order Greeks (same as call for gamma, vega, vanna)
+    const vanna = -eqt * nd1 * (d2 / vol); // Same as call
+    const charm = -q * eqt * (0, statistics_1.cumulativeNormalDistribution)(-d1) - (eqt * nd1 * (2 * (r - q) * t - d2 * vol * sqrtT)) / (2 * t * vol * sqrtT);
+    const volga = vega * ((d1 * d2) / (S * vol)); // Same as call
+    const speed = (nd1 * d1 * d1) / vol;
+    const zomma = ((1 + d1 * d2) * nd1) / (vol * vol * sqrtT);
+    // Third-order Greeks
+    const color = ((1 - d1 * d2) * nd1) / S;
+    const ultima = (t * S * nd1 * d1 * d1) / vol;
+    return {
+        price: round(price, 2),
+        delta: round(delta, 5),
+        gamma: round(gamma, 5),
+        theta: round(theta / types_1.DAYS_PER_YEAR, 5), // Per day
+        vega: round(vega * 0.01, 5), // Per 1% change in volatility
+        rho: round(rho * 0.01, 5), // Per 1% change in interest rate
+        charm: round(charm / types_1.DAYS_PER_YEAR, 5), // Per day
+        vanna: round(vanna, 5),
+        volga: round(volga, 5),
+        speed: round(speed, 5),
+        zomma: round(zomma, 5),
+        color: round(color, 5),
+        ultima: round(ultima, 5),
+    };
+}
+/**
+ * Calculate implied volatility using bisection method
+ *
+ * @param price - Observed option price
+ * @param spot - Current spot price
+ * @param strike - Strike price
+ * @param riskFreeRate - Risk-free interest rate (as decimal)
+ * @param dividendYield - Dividend yield (as decimal)
+ * @param timeToExpiry - Time to expiration in years
+ * @param optionType - 'call' or 'put'
+ * @returns Implied volatility as a percentage (e.g., 20.0 for 20%)
+ *
+ * @example
+ * ```typescript
+ * const iv = calculateImpliedVolatility(5.50, 100, 105, 0.05, 0, 0.25, 'call');
+ * console.log(`IV: ${iv}%`);
+ * ```
+ */
+function calculateImpliedVolatility(price, spot, strike, riskFreeRate, dividendYield, timeToExpiry, optionType) {
+    // Sanity checks
+    if (price <= 0 || spot <= 0 || strike <= 0 || timeToExpiry <= 0) {
+        return 0;
+    }
+    // Calculate intrinsic value
+    const intrinsic = optionType === 'call'
+        ? Math.max(0, spot * Math.exp(-dividendYield * timeToExpiry) - strike * Math.exp(-riskFreeRate * timeToExpiry))
+        : Math.max(0, strike * Math.exp(-riskFreeRate * timeToExpiry) - spot * Math.exp(-dividendYield * timeToExpiry));
+    // If price is at or below intrinsic value, return minimum IV
+    const extrinsic = price - intrinsic;
+    if (extrinsic <= 0.01) {
+        return 1.0; // 1% IV as floor
+    }
+    // Bisection search bounds (in decimal form)
+    let low = 0.0001;
+    let high = 5.0; // 500% volatility
+    let mid = 0;
+    // Bisection method
+    for (let i = 0; i < 100; i++) {
+        mid = 0.5 * (low + high);
+        const modelPrice = blackScholes({
+            spot,
+            strike,
+            timeToExpiry,
+            volatility: mid,
+            riskFreeRate,
+            dividendYield,
+            optionType,
+        });
+        const diff = modelPrice - price;
+        if (Math.abs(diff) < 1e-6) {
+            return mid * 100.0; // Return as percentage
+        }
+        if (diff > 0) {
+            // Model price too high → volatility too high
+            high = mid;
+        }
+        else {
+            // Model price too low → volatility too low
+            low = mid;
+        }
+    }
+    // Return midpoint as percentage
+    return 0.5 * (low + high) * 100.0;
+}
+/**
+ * Get milliseconds until expiration
+ *
+ * @param expirationTimestamp - Expiration timestamp in milliseconds
+ * @returns Milliseconds until expiration
+ */
+function getMillisecondsToExpiration(expirationTimestamp) {
+    return expirationTimestamp - Date.now();
+}
+/**
+ * Get time to expiration in years
+ *
+ * @param expirationTimestamp - Expiration timestamp in milliseconds
+ * @returns Time to expiration in years
+ */
+function getTimeToExpirationInYears(expirationTimestamp) {
+    const milliseconds = getMillisecondsToExpiration(expirationTimestamp);
+    return milliseconds / types_1.MILLISECONDS_PER_YEAR;
+}
+/**
+ * Helper: Round number to specified decimal places
+ * @internal
+ */
+function round(value, decimals) {
+    const factor = Math.pow(10, decimals);
+    return Math.round(value * factor) / factor;
+}
+/**
+ * Helper: Create zero Greeks object
+ * @internal
+ */
+function createZeroGreeks() {
+    return {
+        price: 0,
+        delta: 0,
+        gamma: 0,
+        theta: 0,
+        vega: 0,
+        rho: 0,
+        charm: 0,
+        vanna: 0,
+        volga: 0,
+        speed: 0,
+        zomma: 0,
+        color: 0,
+        ultima: 0,
+    };
+}

package/dist/exposure/index.d.ts

@@ -0,0 +1,35 @@
+import { OptionChain, ExposurePerExpiry, IVSurface } from '../types';
+/**
+ * Calculate Gamma, Vanna, and Charm exposures for an option chain
+ *
+ * @param chain - Option chain with market context (spot, rates, options)
+ * @param ivSurfaces - IV surfaces for all expirations
+ * @returns Array of exposure metrics per expiration
+ *
+ * @example
+ * ```typescript
+ * const exposures = calculateGammaVannaCharmExposures(chain, ivSurfaces);
+ * ```
+ */
+export declare function calculateGammaVannaCharmExposures(chain: OptionChain, ivSurfaces: IVSurface[]): ExposurePerExpiry[];
+/**
+ * Calculate shares needed to cover net exposure
+ *
+ * @param sharesOutstanding - Total shares outstanding
+ * @param totalNetExposure - Total net exposure (gamma + vanna + charm)
+ * @param underlyingMark - Current spot price
+ * @returns Action to cover, shares to cover, implied move %, and resulting price
+ *
+ * @example
+ * ```typescript
+ * const coverage = calculateSharesNeededToCover(1000000000, -5000000, 450.50);
+ * console.log(`Action: ${coverage.actionToCover}`);
+ * console.log(`Shares: ${coverage.sharesToCover}`);
+ * ```
+ */
+export declare function calculateSharesNeededToCover(sharesOutstanding: number, totalNetExposure: number, underlyingMark: number): {
+    actionToCover: string;
+    sharesToCover: number;
+    impliedMoveToCover: number;
+    resultingSpotToCover: number;
+};

package/dist/exposure/index.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateGammaVannaCharmExposures = calculateGammaVannaCharmExposures;
+exports.calculateSharesNeededToCover = calculateSharesNeededToCover;
+const types_1 = require("../types");
+const blackscholes_1 = require("../blackscholes");
+const volatility_1 = require("../volatility");
+/**
+ * Calculate Gamma, Vanna, and Charm exposures for an option chain
+ *
+ * @param chain - Option chain with market context (spot, rates, options)
+ * @param ivSurfaces - IV surfaces for all expirations
+ * @returns Array of exposure metrics per expiration
+ *
+ * @example
+ * ```typescript
+ * const exposures = calculateGammaVannaCharmExposures(chain, ivSurfaces);
+ * ```
+ */
+function calculateGammaVannaCharmExposures(chain, ivSurfaces) {
+    const { spot, riskFreeRate, dividendYield, options } = chain;
+    const exposureRows = [];
+    // Get unique expirations from options
+    const expirationsSet = new Set();
+    for (const option of options) {
+        expirationsSet.add(option.expirationTimestamp);
+    }
+    const expirations = Array.from(expirationsSet).sort((a, b) => a - b);
+    // Loop through all expirations
+    for (const expiration of expirations) {
+        // Skip any expiration that is in the past
+        if (expiration < Date.now()) {
+            continue;
+        }
+        // Reset totals for this expiration
+        let totalGammaExposure = 0.0;
+        let totalVannaExposure = 0.0;
+        let totalCharmExposure = 0.0;
+        let strikeOfMaxGamma = 0.0;
+        let strikeOfMinGamma = 0.0;
+        let strikeOfMaxVanna = 0.0;
+        let strikeOfMinVanna = 0.0;
+        let strikeOfMaxCharm = 0.0;
+        let strikeOfMinCharm = 0.0;
+        let strikeOfMaxNet = 0.0;
+        let strikeOfMinNet = 0.0;
+        const strikeExposures = [];
+        // Process all call options first
+        for (const callOption of options) {
+            // Check if this option is at the expiration we are looking at
+            if (callOption.expirationTimestamp !== expiration || callOption.optionType === 'put') {
+                continue;
+            }
+            // Get the corresponding put option
+            const putOption = options.find((opt) => opt.expirationTimestamp === expiration &&
+                opt.optionType === 'put' &&
+                opt.strike === callOption.strike);
+            if (!putOption) {
+                continue; // Skip if no matching put
+            }
+            // Get IV for this strike and expiry from the surface
+            const callIVAtStrike = (0, volatility_1.getIVForStrike)(ivSurfaces, expiration, 'call', callOption.strike);
+            const putIVAtStrike = (0, volatility_1.getIVForStrike)(ivSurfaces, expiration, 'put', putOption.strike);
+            // Get time to expiration in years
+            const timeToExpirationInYears = (0, blackscholes_1.getTimeToExpirationInYears)(expiration);
+            // Calculate Greeks for both call and put
+            // Rates are already decimals in OptionChain, IV from surface is percentage
+            const callGreeks = (0, blackscholes_1.calculateGreeks)({
+                spot,
+                strike: callOption.strike,
+                timeToExpiry: timeToExpirationInYears,
+                volatility: callIVAtStrike / 100.0, // Convert from percentage to decimal
+                riskFreeRate,
+                dividendYield,
+                optionType: 'call',
+            });
+            const putGreeks = (0, blackscholes_1.calculateGreeks)({
+                spot,
+                strike: putOption.strike,
+                timeToExpiry: timeToExpirationInYears,
+                volatility: putIVAtStrike / 100.0,
+                riskFreeRate,
+                dividendYield,
+                optionType: 'put',
+            });
+            // Calculate exposures from dealer perspective
+            // Dealer is short calls (negative gamma) and long puts (positive gamma)
+            // Multiply by 100 for contract size, multiply by spot for dollar exposure
+            // Multiply by 0.01 for 1% move sensitivity
+            // Gamma: second order with respect to price twice
+            const gammaExposureForStrike = -callOption.openInterest * callGreeks.gamma * (spot * 100.0) * spot * 0.01 +
+                putOption.openInterest * putGreeks.gamma * (spot * 100.0) * spot * 0.01;
+            // Vanna: second order with respect to price and volatility
+            const vannaExposureForStrike = -callOption.openInterest * callGreeks.vanna * (spot * 100.0) * callIVAtStrike * 0.01 +
+                putOption.openInterest * putGreeks.vanna * (spot * 100.0) * putIVAtStrike * 0.01;
+            // Charm: second order with respect to price and time
+            // Already normalized per day in calculateGreeks
+            const charmExposureForStrike = -callOption.openInterest * callGreeks.charm * (spot * 100.0) * types_1.DAYS_PER_YEAR * timeToExpirationInYears +
+                putOption.openInterest * putGreeks.charm * (spot * 100.0) * types_1.DAYS_PER_YEAR * timeToExpirationInYears;
+            // NaN checks
+            const gammaExposure = isNaN(gammaExposureForStrike) ? 0.0 : gammaExposureForStrike;
+            const vannaExposure = isNaN(vannaExposureForStrike) ? 0.0 : vannaExposureForStrike;
+            const charmExposure = isNaN(charmExposureForStrike) ? 0.0 : charmExposureForStrike;
+            // Add to totals
+            totalGammaExposure += gammaExposure;
+            totalVannaExposure += vannaExposure;
+            totalCharmExposure += charmExposure;
+            // Add to strike exposures
+            strikeExposures.push({
+                strikePrice: callOption.strike,
+                gammaExposure,
+                vannaExposure,
+                charmExposure,
+                netExposure: gammaExposure + vannaExposure + charmExposure,
+            });
+        }
+        if (strikeExposures.length === 0) {
+            continue; // No options for this expiration
+        }
+        // Sort by gamma exposure and find extremes
+        strikeExposures.sort((a, b) => b.gammaExposure - a.gammaExposure);
+        strikeOfMaxGamma = strikeExposures[0].strikePrice;
+        strikeOfMinGamma = strikeExposures[strikeExposures.length - 1].strikePrice;
+        // Sort by vanna exposure and find extremes
+        strikeExposures.sort((a, b) => b.vannaExposure - a.vannaExposure);
+        strikeOfMaxVanna = strikeExposures[0].strikePrice;
+        strikeOfMinVanna = strikeExposures[strikeExposures.length - 1].strikePrice;
+        // Sort by charm exposure and find extremes
+        strikeExposures.sort((a, b) => b.charmExposure - a.charmExposure);
+        strikeOfMaxCharm = strikeExposures[0].strikePrice;
+        strikeOfMinCharm = strikeExposures[strikeExposures.length - 1].strikePrice;
+        // Sort by net exposure and find extremes
+        strikeExposures.sort((a, b) => b.netExposure - a.netExposure);
+        strikeOfMaxNet = strikeExposures[0].strikePrice;
+        strikeOfMinNet = strikeExposures[strikeExposures.length - 1].strikePrice;
+        const totalNetExposure = totalGammaExposure + totalVannaExposure + totalCharmExposure;
+        // Add exposure row
+        exposureRows.push({
+            spotPrice: spot,
+            expiration,
+            totalGammaExposure,
+            totalVannaExposure,
+            totalCharmExposure,
+            totalNetExposure,
+            strikeOfMaxGamma,
+            strikeOfMinGamma,
+            strikeOfMaxVanna,
+            strikeOfMinVanna,
+            strikeOfMaxCharm,
+            strikeOfMinCharm,
+            strikeOfMaxNet,
+            strikeOfMinNet,
+            strikeExposures
+        });
+    }
+    return exposureRows;
+}
+/**
+ * Calculate shares needed to cover net exposure
+ *
+ * @param sharesOutstanding - Total shares outstanding
+ * @param totalNetExposure - Total net exposure (gamma + vanna + charm)
+ * @param underlyingMark - Current spot price
+ * @returns Action to cover, shares to cover, implied move %, and resulting price
+ *
+ * @example
+ * ```typescript
+ * const coverage = calculateSharesNeededToCover(1000000000, -5000000, 450.50);
+ * console.log(`Action: ${coverage.actionToCover}`);
+ * console.log(`Shares: ${coverage.sharesToCover}`);
+ * ```
+ */
+function calculateSharesNeededToCover(sharesOutstanding, totalNetExposure, underlyingMark) {
+    let actionToCover = 'BUY';
+    if (totalNetExposure > 0) {
+        actionToCover = 'SELL';
+    }
+    // Protect from inf or nan
+    if (sharesOutstanding === 0 ||
+        isNaN(sharesOutstanding) ||
+        !isFinite(sharesOutstanding)) {
+        return {
+            actionToCover: '',
+            sharesToCover: 0,
+            impliedMoveToCover: 0,
+            resultingSpotToCover: underlyingMark,
+        };
+    }
+    // Protect against division by zero for underlyingMark
+    if (underlyingMark === 0 ||
+        isNaN(underlyingMark) ||
+        !isFinite(underlyingMark)) {
+        return {
+            actionToCover: '',
+            sharesToCover: 0,
+            impliedMoveToCover: 0,
+            resultingSpotToCover: underlyingMark,
+        };
+    }
+    // Since this is the action the dealer makes, we negate it to get the implied move
+    // i.e. negative exposure means the dealer has to buy to cover, which implies upward pressure
+    // likewise positive exposure means the dealer has to sell to cover, which implies downward pressure
+    const sharesNeededToCoverFloat = -totalNetExposure / underlyingMark;
+    const impliedChange = (sharesNeededToCoverFloat / sharesOutstanding) * 100.0;
+    const resultingPrice = underlyingMark * (1 + impliedChange / 100);
+    return {
+        actionToCover,
+        sharesToCover: Math.abs(sharesNeededToCoverFloat),
+        impliedMoveToCover: impliedChange,
+        resultingSpotToCover: resultingPrice,
+    };
+}

package/dist/greeks/index.d.ts

@@ -0,0 +1,29 @@
+import { BlackScholesParams, Greeks } from '../types';
+/**
+ * Calculate all Greeks for an option
+ *
+ * @param params - Black-Scholes parameters
+ * @returns All Greeks (delta, gamma, theta, vega, rho)
+ *
+ * @example
+ * ```typescript
+ * const greeks = calculateGreeks({
+ *   spot: 100,
+ *   strike: 105,
+ *   timeToExpiry: 0.25,
+ *   volatility: 0.20,
+ *   riskFreeRate: 0.05,
+ *   optionType: 'call'
+ * });
+ * console.log('Delta:', greeks.delta);
+ * ```
+ */
+export declare function calculateGreeks(params: BlackScholesParams): Greeks;
+/**
+ * Calculate delta only (optimized)
+ */
+export declare function calculateDelta(params: BlackScholesParams): number;
+/**
+ * Calculate gamma only (optimized)
+ */
+export declare function calculateGamma(params: BlackScholesParams): number;

package/dist/greeks/index.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateGreeks = calculateGreeks;
+exports.calculateDelta = calculateDelta;
+exports.calculateGamma = calculateGamma;
+const statistics_1 = require("../utils/statistics");
+/**
+ * Calculate all Greeks for an option
+ *
+ * @param params - Black-Scholes parameters
+ * @returns All Greeks (delta, gamma, theta, vega, rho)
+ *
+ * @example
+ * ```typescript
+ * const greeks = calculateGreeks({
+ *   spot: 100,
+ *   strike: 105,
+ *   timeToExpiry: 0.25,
+ *   volatility: 0.20,
+ *   riskFreeRate: 0.05,
+ *   optionType: 'call'
+ * });
+ * console.log('Delta:', greeks.delta);
+ * ```
+ */
+function calculateGreeks(params) {
+    const { spot, strike, timeToExpiry, volatility, riskFreeRate, optionType, dividendYield = 0, } = params;
+    // Handle edge case
+    if (timeToExpiry <= 0) {
+        return {
+            delta: 0,
+            gamma: 0,
+            theta: 0,
+            vega: 0,
+            rho: 0,
+        };
+    }
+    const sqrtT = Math.sqrt(timeToExpiry);
+    const d1 = (Math.log(spot / strike) +
+        (riskFreeRate - dividendYield + (volatility ** 2) / 2) * timeToExpiry) /
+        (volatility * sqrtT);
+    const d2 = d1 - volatility * sqrtT;
+    const Nd1 = (0, statistics_1.cumulativeNormalDistribution)(d1);
+    const Nd2 = (0, statistics_1.cumulativeNormalDistribution)(d2);
+    const nd1 = (0, statistics_1.normalPDF)(d1);
+    // Delta
+    const delta = optionType === 'call'
+        ? Math.exp(-dividendYield * timeToExpiry) * Nd1
+        : -Math.exp(-dividendYield * timeToExpiry) * (0, statistics_1.cumulativeNormalDistribution)(-d1);
+    // Gamma (same for calls and puts)
+    const gamma = (Math.exp(-dividendYield * timeToExpiry) * nd1) / (spot * volatility * sqrtT);
+    // Theta (per day, so divide by 365)
+    const theta = optionType === 'call'
+        ? (-(spot * nd1 * volatility * Math.exp(-dividendYield * timeToExpiry)) /
+            (2 * sqrtT) -
+            riskFreeRate * strike * Math.exp(-riskFreeRate * timeToExpiry) * Nd2 +
+            dividendYield * spot * Math.exp(-dividendYield * timeToExpiry) * Nd1) /
+            365
+        : (-(spot * nd1 * volatility * Math.exp(-dividendYield * timeToExpiry)) /
+            (2 * sqrtT) +
+            riskFreeRate * strike * Math.exp(-riskFreeRate * timeToExpiry) * (0, statistics_1.cumulativeNormalDistribution)(-d2) -
+            dividendYield * spot * Math.exp(-dividendYield * timeToExpiry) * (0, statistics_1.cumulativeNormalDistribution)(-d1)) /
+            365;
+    // Vega (per 1% change in volatility, so divide by 100)
+    const vega = (spot * Math.exp(-dividendYield * timeToExpiry) * nd1 * sqrtT) / 100;
+    // Rho (per 1% change in interest rate, so divide by 100)
+    const rho = optionType === 'call'
+        ? (strike * timeToExpiry * Math.exp(-riskFreeRate * timeToExpiry) * Nd2) / 100
+        : (-strike * timeToExpiry * Math.exp(-riskFreeRate * timeToExpiry) * (0, statistics_1.cumulativeNormalDistribution)(-d2)) /
+            100;
+    return {
+        delta,
+        gamma,
+        theta,
+        vega,
+        rho,
+    };
+}
+/**
+ * Calculate delta only (optimized)
+ */
+function calculateDelta(params) {
+    const { spot, strike, timeToExpiry, volatility, riskFreeRate, optionType, dividendYield = 0 } = params;
+    if (timeToExpiry <= 0)
+        return 0;
+    const sqrtT = Math.sqrt(timeToExpiry);
+    const d1 = (Math.log(spot / strike) +
+        (riskFreeRate - dividendYield + (volatility ** 2) / 2) * timeToExpiry) /
+        (volatility * sqrtT);
+    return optionType === 'call'
+        ? Math.exp(-dividendYield * timeToExpiry) * (0, statistics_1.cumulativeNormalDistribution)(d1)
+        : -Math.exp(-dividendYield * timeToExpiry) * (0, statistics_1.cumulativeNormalDistribution)(-d1);
+}
+/**
+ * Calculate gamma only (optimized)
+ */
+function calculateGamma(params) {
+    const { spot, strike, timeToExpiry, volatility, riskFreeRate, dividendYield = 0 } = params;
+    if (timeToExpiry <= 0)
+        return 0;
+    const sqrtT = Math.sqrt(timeToExpiry);
+    const d1 = (Math.log(spot / strike) +
+        (riskFreeRate - dividendYield + (volatility ** 2) / 2) * timeToExpiry) /
+        (volatility * sqrtT);
+    const nd1 = (0, statistics_1.normalPDF)(d1);
+    return (Math.exp(-dividendYield * timeToExpiry) * nd1) / (spot * volatility * sqrtT);
+}

package/dist/impliedpdf/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fullstackcraftllc/floe - Options Analytics Library
+ *
+ * A comprehensive TypeScript library for options pricing, Greeks calculation,
+ * and dealer exposure analysis across multiple brokers.
+ */
+export * from './types';
+export { blackScholes, calculateGreeks, calculateImpliedVolatility, getMillisecondsToExpiration, getTimeToExpirationInYears, } from './blackscholes';
+export { getIVSurfaces, getIVForStrike, } from './volatility';
+export { smoothTotalVarianceSmile, } from './volatility/smoothing';
+export { calculateGammaVannaCharmExposures, calculateSharesNeededToCover, } from './exposure';
+export { cumulativeNormalDistribution, normalPDF, } from './utils/statistics';
+export { genericAdapter, schwabAdapter, ibkrAdapter, tdaAdapter, brokerAdapters, getAdapter, createOptionChain, } from './adapters';