@wingman-ai/gateway 0.1.0

package/dist/tools/finance/optionsAnalytics.cjs

@@ -0,0 +1,222 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    analyzeOptionStructure: ()=>analyzeOptionStructure
+});
+const DEFAULT_MULTIPLIER = 100;
+const intrinsicValue = (spot, strike, type)=>{
+    if ("call" === type) return Math.max(0, spot - strike);
+    return Math.max(0, strike - spot);
+};
+const toPositionSign = (side)=>"buy" === side ? 1 : -1;
+const uniqueSorted = (values)=>{
+    const set = new Set();
+    for (const value of values)set.add(value);
+    return Array.from(set).sort((a, b)=>a - b);
+};
+const roundTo = (value, decimals = 6)=>{
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+};
+const erf = (x)=>{
+    const sign = x < 0 ? -1 : 1;
+    const absX = Math.abs(x);
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const t = 1 / (1 + p * absX);
+    const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
+    return sign * y;
+};
+const normCdf = (x)=>0.5 * (1 + erf(x / Math.sqrt(2)));
+const normPdf = (x)=>Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+const computeLegGreeks = (input)=>{
+    const { spot, strike, daysToExpiry, impliedVol, riskFreeRate, dividendYield } = input;
+    const t = daysToExpiry / 365;
+    const iv = impliedVol;
+    const sqrtT = Math.sqrt(t);
+    const d1 = (Math.log(spot / strike) + (riskFreeRate - dividendYield + 0.5 * iv * iv) * t) / (iv * sqrtT);
+    const d2 = d1 - iv * sqrtT;
+    const expQT = Math.exp(-dividendYield * t);
+    const expRT = Math.exp(-riskFreeRate * t);
+    const pdf = normPdf(d1);
+    const callDelta = expQT * normCdf(d1);
+    const putDelta = expQT * (normCdf(d1) - 1);
+    const gamma = expQT * pdf / (spot * iv * sqrtT);
+    const vega = spot * expQT * pdf * sqrtT / 100;
+    const callTheta = (-(spot * expQT * pdf * iv) / (2 * sqrtT) - riskFreeRate * strike * expRT * normCdf(d2) + dividendYield * spot * expQT * normCdf(d1)) / 365;
+    const putTheta = (-(spot * expQT * pdf * iv) / (2 * sqrtT) + riskFreeRate * strike * expRT * normCdf(-d2) - dividendYield * spot * expQT * normCdf(-d1)) / 365;
+    return {
+        delta: "call" === input.type ? callDelta : putDelta,
+        gamma,
+        vega,
+        theta: "call" === input.type ? callTheta : putTheta
+    };
+};
+const analyzeOptionStructure = (input)=>{
+    const riskFreeRate = input.riskFreeRate ?? 0;
+    const dividendYield = input.dividendYield ?? 0;
+    const legs = input.legs;
+    const normalizedLegs = legs.map((leg)=>({
+            ...leg,
+            qty: leg.qty ?? 1,
+            contractMultiplier: leg.contractMultiplier ?? DEFAULT_MULTIPLIER
+        }));
+    const payoffAt = (spot)=>normalizedLegs.reduce((total, leg)=>{
+            const positionSign = toPositionSign(leg.side);
+            const qty = leg.qty ?? 1;
+            const multiplier = leg.contractMultiplier ?? DEFAULT_MULTIPLIER;
+            const premiumCashflow = ("buy" === leg.side ? -1 : 1) * leg.premium * qty * multiplier;
+            const intrinsic = intrinsicValue(spot, leg.strike, leg.type);
+            return total + positionSign * intrinsic * qty * multiplier + premiumCashflow;
+        }, 0);
+    const netPremium = normalizedLegs.reduce((total, leg)=>{
+        const qty = leg.qty ?? 1;
+        const multiplier = leg.contractMultiplier ?? DEFAULT_MULTIPLIER;
+        const cashflow = ("sell" === leg.side ? 1 : -1) * leg.premium;
+        return total + cashflow * qty * multiplier;
+    }, 0);
+    const netDebit = netPremium < 0 ? -netPremium : 0;
+    const netCredit = netPremium > 0 ? netPremium : 0;
+    const strikes = uniqueSorted(normalizedLegs.map((leg)=>leg.strike));
+    const points = [
+        0,
+        ...strikes
+    ];
+    const payoffs = points.map((spot)=>payoffAt(spot));
+    const netCallExposure = normalizedLegs.reduce((total, leg)=>{
+        if ("call" !== leg.type) return total;
+        const qty = leg.qty ?? 1;
+        const multiplier = leg.contractMultiplier ?? DEFAULT_MULTIPLIER;
+        return total + toPositionSign(leg.side) * qty * multiplier;
+    }, 0);
+    const unboundedProfit = netCallExposure > 0;
+    const unboundedLoss = netCallExposure < 0;
+    const maxPayoff = Math.max(...payoffs);
+    const minPayoff = Math.min(...payoffs);
+    const bestCasePayoff = unboundedProfit ? null : roundTo(maxPayoff, 4);
+    const worstCasePayoff = unboundedLoss ? null : roundTo(minPayoff, 4);
+    const maxProfit = {
+        usd: unboundedProfit ? null : roundTo(Math.max(0, maxPayoff), 4),
+        unbounded: unboundedProfit
+    };
+    const maxLoss = {
+        usd: unboundedLoss ? null : roundTo(Math.max(0, -minPayoff), 4),
+        unbounded: unboundedLoss
+    };
+    const breakevens = [];
+    for(let i = 0; i < points.length - 1; i += 1){
+        const a = points[i];
+        const b = points[i + 1];
+        const fa = payoffs[i];
+        const fb = payoffs[i + 1];
+        if (0 === fa) {
+            breakevens.push(a);
+            continue;
+        }
+        if (0 === fb) {
+            breakevens.push(b);
+            continue;
+        }
+        if (fa * fb < 0) {
+            const root = a + (0 - fa) * (b - a) / (fb - fa);
+            breakevens.push(root);
+        }
+    }
+    if (strikes.length > 0 && 0 !== netCallExposure) {
+        const maxStrike = strikes[strikes.length - 1];
+        const payoffAtMaxStrike = payoffAt(maxStrike);
+        const slope = netCallExposure;
+        if (slope > 0 && payoffAtMaxStrike < 0) breakevens.push(maxStrike - payoffAtMaxStrike / slope);
+        else if (slope < 0 && payoffAtMaxStrike > 0) breakevens.push(maxStrike - payoffAtMaxStrike / slope);
+    }
+    const dedupedBreakevens = uniqueSorted(breakevens.filter((value)=>Number.isFinite(value)).map((value)=>roundTo(value, 4)));
+    let legsComputed = 0;
+    let legsMissing = 0;
+    let delta = 0;
+    let gamma = 0;
+    let vega = 0;
+    let theta = 0;
+    for (const leg of normalizedLegs){
+        if (void 0 === input.daysToExpiry || void 0 === leg.impliedVol || !Number.isFinite(leg.impliedVol) || leg.impliedVol <= 0) {
+            legsMissing += 1;
+            continue;
+        }
+        legsComputed += 1;
+        const { delta: legDelta, gamma: legGamma, vega: legVega, theta: legTheta } = computeLegGreeks({
+            spot: input.underlyingPrice,
+            strike: leg.strike,
+            daysToExpiry: input.daysToExpiry,
+            impliedVol: leg.impliedVol,
+            riskFreeRate,
+            dividendYield,
+            type: leg.type
+        });
+        const positionSign = toPositionSign(leg.side);
+        const qty = leg.qty ?? 1;
+        const multiplier = leg.contractMultiplier ?? DEFAULT_MULTIPLIER;
+        delta += positionSign * legDelta * qty * multiplier;
+        gamma += positionSign * legGamma * qty * multiplier;
+        vega += positionSign * legVega * qty * multiplier;
+        theta += positionSign * legTheta * qty * multiplier;
+    }
+    let greeksStatus = "insufficient-data";
+    if (legsComputed > 0 && 0 === legsMissing) greeksStatus = "ok";
+    else if (legsComputed > 0) greeksStatus = "partial";
+    const greeks = {
+        status: greeksStatus,
+        legsComputed,
+        legsMissing
+    };
+    if (legsComputed > 0) {
+        greeks.delta = roundTo(delta, 6);
+        greeks.gamma = roundTo(gamma, 6);
+        greeks.vega = roundTo(vega, 6);
+        greeks.theta = roundTo(theta, 6);
+    }
+    return {
+        underlyingPrice: input.underlyingPrice,
+        netPremium: roundTo(netPremium, 4),
+        netDebit: roundTo(netDebit, 4),
+        netCredit: roundTo(netCredit, 4),
+        maxProfit,
+        maxLoss,
+        bestCasePayoff,
+        worstCasePayoff,
+        breakevens: dedupedBreakevens,
+        greeks
+    };
+};
+exports.analyzeOptionStructure = __webpack_exports__.analyzeOptionStructure;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "analyzeOptionStructure"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tools/finance/optionsAnalytics.d.ts

@@ -0,0 +1,44 @@
+export type OptionLegInput = {
+    type: "call" | "put";
+    side: "buy" | "sell";
+    strike: number;
+    premium: number;
+    qty?: number;
+    contractMultiplier?: number;
+    impliedVol?: number;
+};
+export type OptionsAnalysisInput = {
+    underlyingPrice: number;
+    legs: OptionLegInput[];
+    daysToExpiry?: number;
+    riskFreeRate?: number;
+    dividendYield?: number;
+};
+export type OptionsGreeks = {
+    status: "ok" | "partial" | "insufficient-data";
+    delta?: number;
+    gamma?: number;
+    vega?: number;
+    theta?: number;
+    legsComputed: number;
+    legsMissing: number;
+};
+export type OptionsAnalysisResult = {
+    underlyingPrice: number;
+    netPremium: number;
+    netDebit: number;
+    netCredit: number;
+    maxProfit: {
+        usd: number | null;
+        unbounded: boolean;
+    };
+    maxLoss: {
+        usd: number | null;
+        unbounded: boolean;
+    };
+    bestCasePayoff: number | null;
+    worstCasePayoff: number | null;
+    breakevens: number[];
+    greeks: OptionsGreeks;
+};
+export declare const analyzeOptionStructure: (input: OptionsAnalysisInput) => OptionsAnalysisResult;

package/dist/tools/finance/optionsAnalytics.js

@@ -0,0 +1,188 @@
+const DEFAULT_MULTIPLIER = 100;
+const intrinsicValue = (spot, strike, type)=>{
+    if ("call" === type) return Math.max(0, spot - strike);
+    return Math.max(0, strike - spot);
+};
+const toPositionSign = (side)=>"buy" === side ? 1 : -1;
+const uniqueSorted = (values)=>{
+    const set = new Set();
+    for (const value of values)set.add(value);
+    return Array.from(set).sort((a, b)=>a - b);
+};
+const roundTo = (value, decimals = 6)=>{
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+};
+const erf = (x)=>{
+    const sign = x < 0 ? -1 : 1;
+    const absX = Math.abs(x);
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const t = 1 / (1 + p * absX);
+    const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
+    return sign * y;
+};
+const normCdf = (x)=>0.5 * (1 + erf(x / Math.sqrt(2)));
+const normPdf = (x)=>Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+const computeLegGreeks = (input)=>{
+    const { spot, strike, daysToExpiry, impliedVol, riskFreeRate, dividendYield } = input;
+    const t = daysToExpiry / 365;
+    const iv = impliedVol;
+    const sqrtT = Math.sqrt(t);
+    const d1 = (Math.log(spot / strike) + (riskFreeRate - dividendYield + 0.5 * iv * iv) * t) / (iv * sqrtT);
+    const d2 = d1 - iv * sqrtT;
+    const expQT = Math.exp(-dividendYield * t);
+    const expRT = Math.exp(-riskFreeRate * t);
+    const pdf = normPdf(d1);
+    const callDelta = expQT * normCdf(d1);
+    const putDelta = expQT * (normCdf(d1) - 1);
+    const gamma = expQT * pdf / (spot * iv * sqrtT);
+    const vega = spot * expQT * pdf * sqrtT / 100;
+    const callTheta = (-(spot * expQT * pdf * iv) / (2 * sqrtT) - riskFreeRate * strike * expRT * normCdf(d2) + dividendYield * spot * expQT * normCdf(d1)) / 365;
+    const putTheta = (-(spot * expQT * pdf * iv) / (2 * sqrtT) + riskFreeRate * strike * expRT * normCdf(-d2) - dividendYield * spot * expQT * normCdf(-d1)) / 365;
+    return {
+        delta: "call" === input.type ? callDelta : putDelta,
+        gamma,
+        vega,
+        theta: "call" === input.type ? callTheta : putTheta
+    };
+};
+const analyzeOptionStructure = (input)=>{
+    const riskFreeRate = input.riskFreeRate ?? 0;
+    const dividendYield = input.dividendYield ?? 0;
+    const legs = input.legs;
+    const normalizedLegs = legs.map((leg)=>({
+            ...leg,
+            qty: leg.qty ?? 1,
+            contractMultiplier: leg.contractMultiplier ?? DEFAULT_MULTIPLIER
+        }));
+    const payoffAt = (spot)=>normalizedLegs.reduce((total, leg)=>{
+            const positionSign = toPositionSign(leg.side);
+            const qty = leg.qty ?? 1;
+            const multiplier = leg.contractMultiplier ?? DEFAULT_MULTIPLIER;
+            const premiumCashflow = ("buy" === leg.side ? -1 : 1) * leg.premium * qty * multiplier;
+            const intrinsic = intrinsicValue(spot, leg.strike, leg.type);
+            return total + positionSign * intrinsic * qty * multiplier + premiumCashflow;
+        }, 0);
+    const netPremium = normalizedLegs.reduce((total, leg)=>{
+        const qty = leg.qty ?? 1;
+        const multiplier = leg.contractMultiplier ?? DEFAULT_MULTIPLIER;
+        const cashflow = ("sell" === leg.side ? 1 : -1) * leg.premium;
+        return total + cashflow * qty * multiplier;
+    }, 0);
+    const netDebit = netPremium < 0 ? -netPremium : 0;
+    const netCredit = netPremium > 0 ? netPremium : 0;
+    const strikes = uniqueSorted(normalizedLegs.map((leg)=>leg.strike));
+    const points = [
+        0,
+        ...strikes
+    ];
+    const payoffs = points.map((spot)=>payoffAt(spot));
+    const netCallExposure = normalizedLegs.reduce((total, leg)=>{
+        if ("call" !== leg.type) return total;
+        const qty = leg.qty ?? 1;
+        const multiplier = leg.contractMultiplier ?? DEFAULT_MULTIPLIER;
+        return total + toPositionSign(leg.side) * qty * multiplier;
+    }, 0);
+    const unboundedProfit = netCallExposure > 0;
+    const unboundedLoss = netCallExposure < 0;
+    const maxPayoff = Math.max(...payoffs);
+    const minPayoff = Math.min(...payoffs);
+    const bestCasePayoff = unboundedProfit ? null : roundTo(maxPayoff, 4);
+    const worstCasePayoff = unboundedLoss ? null : roundTo(minPayoff, 4);
+    const maxProfit = {
+        usd: unboundedProfit ? null : roundTo(Math.max(0, maxPayoff), 4),
+        unbounded: unboundedProfit
+    };
+    const maxLoss = {
+        usd: unboundedLoss ? null : roundTo(Math.max(0, -minPayoff), 4),
+        unbounded: unboundedLoss
+    };
+    const breakevens = [];
+    for(let i = 0; i < points.length - 1; i += 1){
+        const a = points[i];
+        const b = points[i + 1];
+        const fa = payoffs[i];
+        const fb = payoffs[i + 1];
+        if (0 === fa) {
+            breakevens.push(a);
+            continue;
+        }
+        if (0 === fb) {
+            breakevens.push(b);
+            continue;
+        }
+        if (fa * fb < 0) {
+            const root = a + (0 - fa) * (b - a) / (fb - fa);
+            breakevens.push(root);
+        }
+    }
+    if (strikes.length > 0 && 0 !== netCallExposure) {
+        const maxStrike = strikes[strikes.length - 1];
+        const payoffAtMaxStrike = payoffAt(maxStrike);
+        const slope = netCallExposure;
+        if (slope > 0 && payoffAtMaxStrike < 0) breakevens.push(maxStrike - payoffAtMaxStrike / slope);
+        else if (slope < 0 && payoffAtMaxStrike > 0) breakevens.push(maxStrike - payoffAtMaxStrike / slope);
+    }
+    const dedupedBreakevens = uniqueSorted(breakevens.filter((value)=>Number.isFinite(value)).map((value)=>roundTo(value, 4)));
+    let legsComputed = 0;
+    let legsMissing = 0;
+    let delta = 0;
+    let gamma = 0;
+    let vega = 0;
+    let theta = 0;
+    for (const leg of normalizedLegs){
+        if (void 0 === input.daysToExpiry || void 0 === leg.impliedVol || !Number.isFinite(leg.impliedVol) || leg.impliedVol <= 0) {
+            legsMissing += 1;
+            continue;
+        }
+        legsComputed += 1;
+        const { delta: legDelta, gamma: legGamma, vega: legVega, theta: legTheta } = computeLegGreeks({
+            spot: input.underlyingPrice,
+            strike: leg.strike,
+            daysToExpiry: input.daysToExpiry,
+            impliedVol: leg.impliedVol,
+            riskFreeRate,
+            dividendYield,
+            type: leg.type
+        });
+        const positionSign = toPositionSign(leg.side);
+        const qty = leg.qty ?? 1;
+        const multiplier = leg.contractMultiplier ?? DEFAULT_MULTIPLIER;
+        delta += positionSign * legDelta * qty * multiplier;
+        gamma += positionSign * legGamma * qty * multiplier;
+        vega += positionSign * legVega * qty * multiplier;
+        theta += positionSign * legTheta * qty * multiplier;
+    }
+    let greeksStatus = "insufficient-data";
+    if (legsComputed > 0 && 0 === legsMissing) greeksStatus = "ok";
+    else if (legsComputed > 0) greeksStatus = "partial";
+    const greeks = {
+        status: greeksStatus,
+        legsComputed,
+        legsMissing
+    };
+    if (legsComputed > 0) {
+        greeks.delta = roundTo(delta, 6);
+        greeks.gamma = roundTo(gamma, 6);
+        greeks.vega = roundTo(vega, 6);
+        greeks.theta = roundTo(theta, 6);
+    }
+    return {
+        underlyingPrice: input.underlyingPrice,
+        netPremium: roundTo(netPremium, 4),
+        netDebit: roundTo(netDebit, 4),
+        netCredit: roundTo(netCredit, 4),
+        maxProfit,
+        maxLoss,
+        bestCasePayoff,
+        worstCasePayoff,
+        breakevens: dedupedBreakevens,
+        greeks
+    };
+};
+export { analyzeOptionStructure };

package/dist/tools/finance/optionsAnalytics.test.cjs

@@ -0,0 +1,128 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_optionsAnalytics_cjs_namespaceObject = require("./optionsAnalytics.cjs");
+(0, external_vitest_namespaceObject.describe)("optionsAnalytics", ()=>{
+    (0, external_vitest_namespaceObject.it)("computes long call payoff metrics", ()=>{
+        const result = (0, external_optionsAnalytics_cjs_namespaceObject.analyzeOptionStructure)({
+            underlyingPrice: 100,
+            legs: [
+                {
+                    type: "call",
+                    side: "buy",
+                    strike: 100,
+                    premium: 5
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(result.netDebit).toBeCloseTo(500, 2);
+        (0, external_vitest_namespaceObject.expect)(result.maxProfit.unbounded).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result.maxLoss.unbounded).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(result.maxLoss.usd).toBeCloseTo(500, 2);
+        (0, external_vitest_namespaceObject.expect)(result.breakevens).toContain(105);
+    });
+    (0, external_vitest_namespaceObject.it)("computes bull call debit spread metrics", ()=>{
+        const result = (0, external_optionsAnalytics_cjs_namespaceObject.analyzeOptionStructure)({
+            underlyingPrice: 100,
+            legs: [
+                {
+                    type: "call",
+                    side: "buy",
+                    strike: 100,
+                    premium: 5
+                },
+                {
+                    type: "call",
+                    side: "sell",
+                    strike: 110,
+                    premium: 2
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(result.netDebit).toBeCloseTo(300, 2);
+        (0, external_vitest_namespaceObject.expect)(result.maxProfit.unbounded).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(result.maxProfit.usd).toBeCloseTo(700, 2);
+        (0, external_vitest_namespaceObject.expect)(result.maxLoss.usd).toBeCloseTo(300, 2);
+        (0, external_vitest_namespaceObject.expect)(result.breakevens).toContain(103);
+    });
+    (0, external_vitest_namespaceObject.it)("computes bear call credit spread metrics", ()=>{
+        const result = (0, external_optionsAnalytics_cjs_namespaceObject.analyzeOptionStructure)({
+            underlyingPrice: 100,
+            legs: [
+                {
+                    type: "call",
+                    side: "sell",
+                    strike: 100,
+                    premium: 5
+                },
+                {
+                    type: "call",
+                    side: "buy",
+                    strike: 110,
+                    premium: 2
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(result.netCredit).toBeCloseTo(300, 2);
+        (0, external_vitest_namespaceObject.expect)(result.maxProfit.unbounded).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(result.maxProfit.usd).toBeCloseTo(300, 2);
+        (0, external_vitest_namespaceObject.expect)(result.maxLoss.usd).toBeCloseTo(700, 2);
+        (0, external_vitest_namespaceObject.expect)(result.breakevens).toContain(103);
+    });
+    (0, external_vitest_namespaceObject.it)("flags unbounded loss for naked short call", ()=>{
+        const result = (0, external_optionsAnalytics_cjs_namespaceObject.analyzeOptionStructure)({
+            underlyingPrice: 100,
+            legs: [
+                {
+                    type: "call",
+                    side: "sell",
+                    strike: 100,
+                    premium: 5
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(result.maxLoss.unbounded).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result.maxProfit.unbounded).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(result.maxProfit.usd).toBeCloseTo(500, 2);
+        (0, external_vitest_namespaceObject.expect)(result.breakevens).toContain(105);
+    });
+    (0, external_vitest_namespaceObject.it)("computes greeks when inputs provided", ()=>{
+        const result = (0, external_optionsAnalytics_cjs_namespaceObject.analyzeOptionStructure)({
+            underlyingPrice: 100,
+            daysToExpiry: 30,
+            riskFreeRate: 0.01,
+            legs: [
+                {
+                    type: "call",
+                    side: "buy",
+                    strike: 100,
+                    premium: 5,
+                    impliedVol: 0.2
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(result.greeks.status).toBe("ok");
+        (0, external_vitest_namespaceObject.expect)(result.greeks.delta).toBeGreaterThan(0);
+        (0, external_vitest_namespaceObject.expect)(result.greeks.theta).toBeLessThan(0);
+    });
+    (0, external_vitest_namespaceObject.it)("returns insufficient-data greeks when missing IV", ()=>{
+        const result = (0, external_optionsAnalytics_cjs_namespaceObject.analyzeOptionStructure)({
+            underlyingPrice: 100,
+            daysToExpiry: 30,
+            legs: [
+                {
+                    type: "call",
+                    side: "buy",
+                    strike: 100,
+                    premium: 5
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(result.greeks.status).toBe("insufficient-data");
+        (0, external_vitest_namespaceObject.expect)(result.greeks.legsMissing).toBe(1);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tools/finance/optionsAnalytics.test.d.ts

@@ -0,0 +1 @@
+export {};