tradeblocks-mcp 3.0.2 → 3.0.3

package/server/{chunk-72GKJE2U.js → chunk-BOPHW5M6.js}

@@ -15420,12 +15420,7 @@ function normalQuantile(p) {
     4.374664141464968,
     2.938163982698783
   ];
-  const d = [
-    0.007784695709041462,
-    0.3224671290700398,
-    2.445134137142996,
-    3.754408661907416
-  ];
+  const d = [0.007784695709041462, 0.3224671290700398, 2.445134137142996, 3.754408661907416];
   const pLow = 0.02425;
   const pHigh = 1 - pLow;
   let q;
@@ -15589,10 +15584,7 @@ function calculateCorrelationMatrix(trades, options = {}) {
   }
   const strategyReturns = {};
   for (const strategy of Object.keys(strategyDailyReturns)) {
-    strategyReturns[strategy] = aggregateByPeriod(
-      strategyDailyReturns[strategy],
-      timePeriod
-    );
+    strategyReturns[strategy] = aggregateByPeriod(strategyDailyReturns[strategy], timePeriod);
   }
   const allDates = /* @__PURE__ */ new Set();
   for (const returns of Object.values(strategyReturns)) {
@@ -15727,9 +15719,7 @@ function normalizeReturn(trade, mode) {
       return trade.pl / trade.marginReq;
     }
     case "notional": {
-      const notional = Math.abs(
-        (trade.openingPrice || 0) * (trade.numContracts || 0)
-      );
+      const notional = Math.abs((trade.openingPrice || 0) * (trade.numContracts || 0));
       if (!notional) {
         return null;
       }
@@ -15742,9 +15732,7 @@ function normalizeReturn(trade, mode) {
 function getTradeDateKey(trade, basis) {
   const date = basis === "closed" ? trade.dateClosed : trade.dateOpened;
   if (!date) {
-    throw new Error(
-      "Trade is missing required date information for correlation calculation"
-    );
+    throw new Error("Trade is missing required date information for correlation calculation");
   }
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -15761,9 +15749,7 @@ function getIsoWeekKey(dateStr) {
   const dayOfWeek = thursday.getUTCDay() || 7;
   thursday.setUTCDate(thursday.getUTCDate() + (4 - dayOfWeek));
   const yearStart = new Date(Date.UTC(thursday.getUTCFullYear(), 0, 1));
-  const weekNum = Math.ceil(
-    ((thursday.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
-  );
+  const weekNum = Math.ceil(((thursday.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
   return `${thursday.getUTCFullYear()}-W${String(weekNum).padStart(2, "0")}`;
 }
 function getMonthKey(dateStr) {
@@ -15850,9 +15836,7 @@ function performTailRiskAnalysis(trades, options = {}) {
   }
   if (strategyFilter && strategyFilter.length > 0) {
     const filterSet = new Set(strategyFilter);
-    filteredTrades = filteredTrades.filter(
-      (t) => t.strategy && filterSet.has(t.strategy)
-    );
+    filteredTrades = filteredTrades.filter((t) => t.strategy && filterSet.has(t.strategy));
   }
   if (dateRange?.from || dateRange?.to) {
     filteredTrades = filteredTrades.filter((t) => {
@@ -15867,41 +15851,27 @@ function performTailRiskAnalysis(trades, options = {}) {
       return true;
     });
   }
-  const aligned = aggregateAndAlignReturns(
-    filteredTrades,
-    normalization,
-    dateBasis
-  );
+  const aligned = aggregateAndAlignReturns(filteredTrades, normalization, dateBasis);
   if (aligned.strategies.length < 2) {
-    return createEmptyResult(
-      aligned,
-      tailThreshold,
-      varianceThreshold,
-      startTime
-    );
+    return createEmptyResult(aligned, tailThreshold, varianceThreshold, startTime);
   }
   if (aligned.dates.length < minTradingDays) {
-    return createEmptyResult(
-      aligned,
-      tailThreshold,
-      varianceThreshold,
-      startTime
-    );
+    return createEmptyResult(aligned, tailThreshold, varianceThreshold, startTime);
   }
   const transformedReturns = aligned.returns.map(
     (strategyReturns) => probabilityIntegralTransform(strategyReturns)
   );
   const copulaCorrelationMatrix = computeCorrelationMatrix(transformedReturns);
-  const { eigenvalues, eigenvectors, explainedVariance, effectiveFactors } = performEigenAnalysis(copulaCorrelationMatrix, varianceThreshold);
+  const { eigenvalues, eigenvectors, explainedVariance, effectiveFactors } = performEigenAnalysis(
+    copulaCorrelationMatrix,
+    varianceThreshold
+  );
   const jointTailRiskResult = estimateJointTailRisk(
     transformedReturns,
     aligned.tradedMask,
     tailThreshold
   );
-  const analytics = calculateTailRiskAnalytics(
-    jointTailRiskResult.matrix,
-    aligned.strategies
-  );
+  const analytics = calculateTailRiskAnalytics(jointTailRiskResult.matrix, aligned.strategies);
   const marginalContributions = calculateMarginalContributions(
     copulaCorrelationMatrix,
     jointTailRiskResult.matrix,
@@ -15998,9 +15968,7 @@ function normalizeReturn2(trade, mode) {
       break;
     }
     case "notional": {
-      const notional = Math.abs(
-        (trade.openingPrice || 0) * (trade.numContracts || 0)
-      );
+      const notional = Math.abs((trade.openingPrice || 0) * (trade.numContracts || 0));
       if (!notional || notional === 0) {
         return null;
       }
@@ -16084,10 +16052,7 @@ function performEigenAnalysis(correlationMatrix, varianceThreshold = 0.8) {
       effectiveFactors
     };
   } catch (error) {
-    console.warn(
-      "Eigenvalue decomposition failed, using identity fallback:",
-      error
-    );
+    console.warn("Eigenvalue decomposition failed, using identity fallback:", error);
     return {
       eigenvalues: new Array(n).fill(1),
       eigenvectors: correlationMatrix.map(
@@ -16146,10 +16111,7 @@ function estimateJointTailRisk(transformedReturns, tradedMask, tailThreshold) {
           }
         }
       }
-      const minTailObs = getMinTailObservations(
-        tailThreshold,
-        sharedTradingDays
-      );
+      const minTailObs = getMinTailObservations(tailThreshold, sharedTradingDays);
       if (iInTailAndBothTraded < minTailObs) {
         row.push(NaN);
         insufficientPairs++;
@@ -16220,10 +16182,7 @@ function calculateMarginalContributions(_copulaCorrelationMatrix, jointTailRiskM
   }
   const contributions = [];
   const firstEigenvector = eigenvectors[0] || new Array(n).fill(0);
-  const sumAbsLoadings = firstEigenvector.reduce(
-    (sum2, val) => sum2 + Math.abs(val),
-    0
-  );
+  const sumAbsLoadings = firstEigenvector.reduce((sum2, val) => sum2 + Math.abs(val), 0);
   for (let i = 0; i < n; i++) {
     const concentrationScore = sumAbsLoadings > 0 ? Math.abs(firstEigenvector[i]) / sumAbsLoadings : 1 / n;
     let sumJointRisk = 0;
@@ -20837,8 +20796,10 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
         if (!trade.dateOpened) return false;
         const date = new Date(trade.dateOpened);
         if (isNaN(date.getTime())) return false;
-        if (typeof trade.openingCommissionsFees !== "number" || isNaN(trade.openingCommissionsFees)) return false;
-        if (typeof trade.closingCommissionsFees !== "number" || isNaN(trade.closingCommissionsFees)) return false;
+        if (typeof trade.openingCommissionsFees !== "number" || isNaN(trade.openingCommissionsFees))
+          return false;
+        if (typeof trade.closingCommissionsFees !== "number" || isNaN(trade.closingCommissionsFees))
+          return false;
         return true;
       } catch {
         return false;
@@ -20877,7 +20838,10 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
     const streaks = this.calculateStreaks(validTrades);
     const timeInDrawdown = this.calculateTimeInDrawdown(validTrades, adjustedDailyLogs);
     const periodicWinRates = this.calculatePeriodicWinRates(validTrades);
-    const initialCapital = _PortfolioStatsCalculator.calculateInitialCapital(validTrades, adjustedDailyLogs);
+    const initialCapital = _PortfolioStatsCalculator.calculateInitialCapital(
+      validTrades,
+      adjustedDailyLogs
+    );
     return {
       totalTrades,
       totalPl,
@@ -20915,14 +20879,17 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
     if (trades.length === 0) {
       return {};
     }
-    const tradesByStrategy = trades.reduce((acc, trade) => {
-      const strategy = trade.strategy || "Unknown";
-      if (!acc[strategy]) {
-        acc[strategy] = [];
-      }
-      acc[strategy].push(trade);
-      return acc;
-    }, {});
+    const tradesByStrategy = trades.reduce(
+      (acc, trade) => {
+        const strategy = trade.strategy || "Unknown";
+        if (!acc[strategy]) {
+          acc[strategy] = [];
+        }
+        acc[strategy].push(trade);
+        return acc;
+      },
+      {}
+    );
     const strategyStats = {};
     Object.entries(tradesByStrategy).forEach(([strategyName, strategyTrades]) => {
       const portfolioStats = this.calculatePortfolioStats(strategyTrades);
@@ -20957,7 +20924,9 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
       return maxDrawdown2;
     }
     if (trades.length === 0) return 0;
-    const closedTrades = trades.filter((trade) => trade.dateClosed && trade.fundsAtClose !== void 0);
+    const closedTrades = trades.filter(
+      (trade) => trade.dateClosed && trade.fundsAtClose !== void 0
+    );
     if (closedTrades.length === 0) return 0;
     const sortedTrades = [...closedTrades].sort((a, b) => {
       try {
@@ -21058,9 +21027,7 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
    * Calculate average days to expiration (DTE)
    */
   calculateAvgDTE(trades) {
-    const tradesWithDTE = trades.filter(
-      (trade) => trade.dateClosed && trade.dateOpened
-    );
+    const tradesWithDTE = trades.filter((trade) => trade.dateClosed && trade.dateOpened);
     if (tradesWithDTE.length === 0) return void 0;
     const totalDTE = tradesWithDTE.reduce((sum2, trade) => {
       const openDate = new Date(trade.dateOpened);
@@ -21081,7 +21048,9 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
       return a.timeOpened.localeCompare(b.timeOpened);
     });
     const startDate = new Date(sortedTrades[0].dateOpened);
-    const endDate = new Date(sortedTrades[sortedTrades.length - 1].dateClosed || sortedTrades[sortedTrades.length - 1].dateOpened);
+    const endDate = new Date(
+      sortedTrades[sortedTrades.length - 1].dateClosed || sortedTrades[sortedTrades.length - 1].dateOpened
+    );
     const totalYears = (endDate.getTime() - startDate.getTime()) / (1e3 * 60 * 60 * 24 * 365.25);
     if (totalYears <= 0) return void 0;
     const initialCapital = _PortfolioStatsCalculator.calculateInitialCapital(trades);
@@ -21148,7 +21117,9 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
     if (winningTrades.length === 0 || losingTrades.length === 0) return void 0;
     const winRate = winningTrades.length / trades.length;
     const avgWin = winningTrades.reduce((sum2, trade) => sum2 + trade.pl, 0) / winningTrades.length;
-    const avgLoss = Math.abs(losingTrades.reduce((sum2, trade) => sum2 + trade.pl, 0) / losingTrades.length);
+    const avgLoss = Math.abs(
+      losingTrades.reduce((sum2, trade) => sum2 + trade.pl, 0) / losingTrades.length
+    );
     if (avgLoss === 0) return void 0;
     const winLossRatio = avgWin / avgLoss;
     const kellyPercentage = (winRate * winLossRatio - (1 - winRate)) / winLossRatio;
@@ -21194,7 +21165,9 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
       return daysInDrawdown / dailyLogEntries.length * 100;
     }
     if (trades.length === 0) return void 0;
-    const closedTrades = trades.filter((trade) => trade.dateClosed && trade.fundsAtClose !== void 0);
+    const closedTrades = trades.filter(
+      (trade) => trade.dateClosed && trade.fundsAtClose !== void 0
+    );
     if (closedTrades.length === 0) return void 0;
     const sortedTrades = [...closedTrades].sort((a, b) => {
       try {
@@ -21243,7 +21216,9 @@ var PortfolioStatsCalculator = class _PortfolioStatsCalculator {
       }
       monthlyTrades.get(monthKey).push(trade);
       const startOfYear = new Date(date.getFullYear(), 0, 1);
-      const weekNumber = Math.ceil(((date.getTime() - startOfYear.getTime()) / 864e5 + startOfYear.getDay() + 1) / 7);
+      const weekNumber = Math.ceil(
+        ((date.getTime() - startOfYear.getTime()) / 864e5 + startOfYear.getDay() + 1) / 7
+      );
       const weekKey = `${date.getFullYear()}-${String(weekNumber).padStart(2, "0")}`;
       if (!weeklyTrades.has(weekKey)) {
         weeklyTrades.set(weekKey, []);
@@ -21420,7 +21395,14 @@ var WalkForwardAnalyzer = class {
     const calculator = new PortfolioStatsCalculator();
     const startedAt = /* @__PURE__ */ new Date();
     if (sortedTrades.length === 0) {
-      const emptyResults = this.buildResults([], options.config, 0, 0, sortedTrades.length, startedAt);
+      const emptyResults = this.buildResults(
+        [],
+        options.config,
+        0,
+        0,
+        sortedTrades.length,
+        startedAt
+      );
       return {
         config: options.config,
         results: emptyResults,
@@ -21441,8 +21423,16 @@ var WalkForwardAnalyzer = class {
     for (let index = 0; index < windows.length; index++) {
       this.throwIfAborted(options.signal);
       const window2 = windows[index];
-      const inSampleTrades = this.filterTrades(sortedTrades, window2.inSampleStart, window2.inSampleEnd);
-      const outSampleTrades = this.filterTrades(sortedTrades, window2.outOfSampleStart, window2.outOfSampleEnd);
+      const inSampleTrades = this.filterTrades(
+        sortedTrades,
+        window2.inSampleStart,
+        window2.inSampleEnd
+      );
+      const outSampleTrades = this.filterTrades(
+        sortedTrades,
+        window2.outOfSampleStart,
+        window2.outOfSampleEnd
+      );
       const minInSample = options.config.minInSampleTrades ?? DEFAULT_MIN_IN_SAMPLE_TRADES;
       const minOutSample = options.config.minOutOfSampleTrades ?? DEFAULT_MIN_OUT_SAMPLE_TRADES;
       if (inSampleTrades.length < minInSample || outSampleTrades.length < minOutSample) {
@@ -21451,7 +21441,9 @@ var WalkForwardAnalyzer = class {
         skippedWindows.push({ ...window2, reason, detail });
         continue;
       }
-      const combinationIterator = this.buildCombinationIterator(options.config.parameterRanges || {});
+      const combinationIterator = this.buildCombinationIterator(
+        options.config.parameterRanges || {}
+      );
       if (combinationIterator.count > MAX_PARAMETER_COMBINATIONS) {
         throw new Error(
           `Walk-forward parameter grid too large (${combinationIterator.count.toLocaleString()} combinations). Reduce ranges or increase step sizes.`
@@ -21482,7 +21474,12 @@ var WalkForwardAnalyzer = class {
           inSampleInitialCapital
         );
         const inSampleStats = calculator.calculatePortfolioStats(scaledInSampleTrades);
-        if (!this.isRiskAcceptable(params, inSampleStats, scaledInSampleTrades, options.config.performanceFloor)) {
+        if (!this.isRiskAcceptable(
+          params,
+          inSampleStats,
+          scaledInSampleTrades,
+          options.config.performanceFloor
+        )) {
           continue;
         }
         if (enforceDiversificationConstraints && diversificationConfig) {
@@ -21494,7 +21491,10 @@ var WalkForwardAnalyzer = class {
             continue;
           }
         }
-        const targetValue = this.getTargetMetricValue(inSampleStats, options.config.optimizationTarget);
+        const targetValue = this.getTargetMetricValue(
+          inSampleStats,
+          options.config.optimizationTarget
+        );
         if (!Number.isFinite(targetValue)) {
           continue;
         }
@@ -21549,7 +21549,10 @@ var WalkForwardAnalyzer = class {
         inSampleMetrics: bestCombo.inSampleStats,
         outOfSampleMetrics: outSampleStats,
         targetMetricInSample: bestCombo.score,
-        targetMetricOutOfSample: this.getTargetMetricValue(outSampleStats, options.config.optimizationTarget),
+        targetMetricOutOfSample: this.getTargetMetricValue(
+          outSampleStats,
+          options.config.optimizationTarget
+        ),
         diversificationMetrics
       };
       periods.push(period);
@@ -21623,7 +21626,9 @@ var WalkForwardAnalyzer = class {
       const inSampleStart = new Date(cursor);
       const inSampleEnd = new Date(cursor + (config4.inSampleDays - 1) * DAY_MS);
       const outOfSampleStart = new Date(inSampleEnd.getTime() + DAY_MS);
-      const outOfSampleEnd = new Date(outOfSampleStart.getTime() + (config4.outOfSampleDays - 1) * DAY_MS);
+      const outOfSampleEnd = new Date(
+        outOfSampleStart.getTime() + (config4.outOfSampleDays - 1) * DAY_MS
+      );
       if (outOfSampleStart > lastDate) {
         break;
       }
@@ -21638,7 +21643,9 @@ var WalkForwardAnalyzer = class {
     return windows;
   }
   floorToUTCDate(date) {
-    const floored = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+    const floored = new Date(
+      Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate())
+    );
     return floored;
   }
   buildCombinationIterator(parameterRanges) {
@@ -21824,10 +21831,7 @@ var WalkForwardAnalyzer = class {
       maxCorrelationPair,
       avgTailDependence: tailRiskResult?.analytics.averageJointTailRisk ?? 0,
       maxTailDependence: tailRiskResult?.analytics.highestJointTailRisk.value ?? 0,
-      maxTailDependencePair: tailRiskResult?.analytics.highestJointTailRisk.pair ?? [
-        "",
-        ""
-      ],
+      maxTailDependencePair: tailRiskResult?.analytics.highestJointTailRisk.pair ?? ["", ""],
       effectiveFactors: tailRiskResult?.effectiveFactors ?? correlationMatrix.strategies.length,
       highRiskPairsPct: tailRiskResult?.analytics.highRiskPairsPct ?? 0,
       // Track insufficient tail data for UI display
@@ -22198,10 +22202,7 @@ function createSyntheticMaxLossTrades(trades, percentage, simulationLength, base
     return [];
   }
   const requestedBudget = Math.ceil(simulationLength * percentage / 100);
-  const cappedBudget = Math.min(
-    simulationLength,
-    Math.max(1, requestedBudget)
-  );
+  const cappedBudget = Math.min(simulationLength, Math.max(1, requestedBudget));
   if (cappedBudget <= 0) {
     return [];
   }
@@ -22397,9 +22398,7 @@ function calculatePercentageReturns(trades, normalizeTo1Lot, initialCapital) {
   if (trades.length === 0) {
     return [];
   }
-  const sortedTrades = [...trades].sort(
-    (a, b) => a.dateOpened.getTime() - b.dateOpened.getTime()
-  );
+  const sortedTrades = [...trades].sort((a, b) => a.dateOpened.getTime() - b.dateOpened.getTime());
   const percentageReturns = [];
   let capital;
   if (initialCapital !== void 0 && initialCapital > 0) {
@@ -22424,9 +22423,7 @@ function calculateMarginReturns(trades) {
   if (trades.length === 0) {
     return [];
   }
-  const sortedTrades = [...trades].sort(
-    (a, b) => a.dateOpened.getTime() - b.dateOpened.getTime()
-  );
+  const sortedTrades = [...trades].sort((a, b) => a.dateOpened.getTime() - b.dateOpened.getTime());
   const returns = [];
   for (const trade of sortedTrades) {
     if (trade.marginReq > 0) {
@@ -22520,25 +22517,13 @@ function runMonteCarloSimulation(trades, params) {
   let actualResamplePoolSize;
   const isPercentageMode = params.resampleMethod === "percentage";
   if (params.resampleMethod === "trades") {
-    const tradePool = getTradeResamplePool(
-      trades,
-      params.resampleWindow,
-      params.strategy
-    );
+    const tradePool = getTradeResamplePool(trades, params.resampleWindow, params.strategy);
     actualResamplePoolSize = tradePool.length;
-    resamplePool = tradePool.map(
-      (t) => params.normalizeTo1Lot ? scaleTradeToOneLot(t) : t.pl
-    );
+    resamplePool = tradePool.map((t) => params.normalizeTo1Lot ? scaleTradeToOneLot(t) : t.pl);
   } else if (params.resampleMethod === "daily") {
     const filteredTrades = params.strategy && params.strategy !== "all" ? trades.filter((t) => t.strategy === params.strategy) : trades;
-    const dailyReturns = calculateDailyReturns(
-      filteredTrades,
-      params.normalizeTo1Lot
-    );
-    const dailyPLs = getDailyResamplePool(
-      dailyReturns,
-      params.resampleWindow
-    );
+    const dailyReturns = calculateDailyReturns(filteredTrades, params.normalizeTo1Lot);
+    const dailyPLs = getDailyResamplePool(dailyReturns, params.resampleWindow);
     actualResamplePoolSize = dailyPLs.length;
     resamplePool = dailyPLs;
   } else {
@@ -22557,10 +22542,7 @@ function runMonteCarloSimulation(trades, params) {
         params.historicalInitialCapital
         // Use historical capital (if provided) to reconstruct trajectory
       );
-      const percentagePool = getPercentageResamplePool(
-        percentageReturns,
-        params.resampleWindow
-      );
+      const percentagePool = getPercentageResamplePool(percentageReturns, params.resampleWindow);
       actualResamplePoolSize = percentagePool.length;
       resamplePool = percentagePool;
     }
@@ -22611,20 +22593,13 @@ function runMonteCarloSimulation(trades, params) {
       resamplePool = [...resamplePool, ...worstCaseTrades];
     }
   }
-  const enforcedGuaranteeTrades = params.worstCaseEnabled && params.worstCaseMode === "guarantee" && params.simulationLength > 0 ? worstCaseTrades.slice(
-    0,
-    Math.min(worstCaseTrades.length, params.simulationLength)
-  ) : [];
+  const enforcedGuaranteeTrades = params.worstCaseEnabled && params.worstCaseMode === "guarantee" && params.simulationLength > 0 ? worstCaseTrades.slice(0, Math.min(worstCaseTrades.length, params.simulationLength)) : [];
   const simulations = [];
   for (let i = 0; i < params.numSimulations; i++) {
     const seed = params.randomSeed !== void 0 ? params.randomSeed + i : void 0;
     const guaranteeActive = enforcedGuaranteeTrades.length > 0;
     const baselineSampleSize = guaranteeActive ? Math.max(0, params.simulationLength - enforcedGuaranteeTrades.length) : params.simulationLength;
-    let resampledPLs = resampleWithReplacement(
-      resamplePool,
-      baselineSampleSize,
-      seed
-    );
+    let resampledPLs = resampleWithReplacement(resamplePool, baselineSampleSize, seed);
     if (guaranteeActive) {
       const combined = [...resampledPLs];
       const rng = seed !== void 0 ? createSeededRandom(seed + 999999) : Math.random;
@@ -22714,10 +22689,7 @@ function calculateStatistics(simulations) {
     50
   );
   const meanSharpeRatio = sharpeRatios.reduce((sum2, s) => sum2 + s, 0) / sharpeRatios.length;
-  const variance2 = finalValues.reduce(
-    (sum2, v) => sum2 + Math.pow(v - meanFinalValue, 2),
-    0
-  ) / (finalValues.length - 1);
+  const variance2 = finalValues.reduce((sum2, v) => sum2 + Math.pow(v - meanFinalValue, 2), 0) / (finalValues.length - 1);
   const stdFinalValue = Math.sqrt(variance2);
   const profitableSimulations = totalReturns.filter((r) => r > 0).length;
   const probabilityOfProfit = profitableSimulations / totalReturns.length;
@@ -22908,10 +22880,7 @@ function linearRegression(y) {
   const slope = sumX2 > 0 ? sumXY / sumX2 : 0;
   const intercept = meanY - slope * meanX;
   const predicted = x.map((xi) => slope * xi + intercept);
-  const ssRes = y.reduce(
-    (sum2, yi, i) => sum2 + (yi - predicted[i]) ** 2,
-    0
-  );
+  const ssRes = y.reduce((sum2, yi, i) => sum2 + (yi - predicted[i]) ** 2, 0);
   const ssTot = y.reduce((sum2, yi) => sum2 + (yi - meanY) ** 2, 0);
   const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 0;
   const mse = n > 2 ? ssRes / (n - 2) : 0;
@@ -23152,7 +23121,13 @@ function segmentByPeriod(trades) {
       const monthDate = parseMonthKey(m.periodKey);
       return monthDate !== null && getQuarterKey(monthDate) === qKey;
     }).map((m) => m.avgMonthlyReturnPct);
-    return computePeriodMetrics(qKey, quarterTrades, isPartial, partialNote, constituentMonthlyReturns);
+    return computePeriodMetrics(
+      qKey,
+      quarterTrades,
+      isPartial,
+      partialNote,
+      constituentMonthlyReturns
+    );
   });
   const yearlyGroups = groupTradesByKey(sortedTrades, getYearKey);
   const yearKeys = Array.from(yearlyGroups.keys()).sort();
@@ -23165,7 +23140,13 @@ function segmentByPeriod(trades) {
       index === yearKeys.length - 1
     );
     const constituentMonthlyReturns = monthlyMetrics.filter((m) => m.periodKey.startsWith(yKey + "-")).map((m) => m.avgMonthlyReturnPct);
-    return computePeriodMetrics(yKey, yearTrades, isPartial, partialNote, constituentMonthlyReturns);
+    return computePeriodMetrics(
+      yKey,
+      yearTrades,
+      isPartial,
+      partialNote,
+      constituentMonthlyReturns
+    );
   });
   const yearlyTrends = computePeriodTrends(yearlyMetrics);
   const quarterlyTrends = computePeriodTrends(quarterlyMetrics);
@@ -23362,7 +23343,14 @@ function computeRollingMetrics(trades, options) {
   };
 }
 function computeSeasonalAverages(series) {
-  const metricNames = ["winRate", "profitFactor", "kellyPercent", "sharpeRatio", "avgReturn", "netPl"];
+  const metricNames = [
+    "winRate",
+    "profitFactor",
+    "kellyPercent",
+    "sharpeRatio",
+    "avgReturn",
+    "netPl"
+  ];
   const buckets = {};
   for (const metric of metricNames) {
     buckets[metric] = { Q1: [], Q2: [], Q3: [], Q4: [] };
@@ -23598,9 +23586,17 @@ function runRegimeComparison(trades, options) {
   };
   const recentResult = runMonteCarloSimulation(recentPool, recentParams);
   const metricPairs = [
-    ["probabilityOfProfit", fullResult.statistics.probabilityOfProfit, recentResult.statistics.probabilityOfProfit],
+    [
+      "probabilityOfProfit",
+      fullResult.statistics.probabilityOfProfit,
+      recentResult.statistics.probabilityOfProfit
+    ],
     ["sharpeRatio", fullResult.statistics.meanSharpeRatio, recentResult.statistics.meanSharpeRatio],
-    ["medianMaxDrawdown", fullResult.statistics.medianMaxDrawdown, recentResult.statistics.medianMaxDrawdown]
+    [
+      "medianMaxDrawdown",
+      fullResult.statistics.medianMaxDrawdown,
+      recentResult.statistics.medianMaxDrawdown
+    ]
   ];
   const comparison = metricPairs.map(([metric, fullValue, recentValue]) => {
     const delta = recentValue - fullValue;
@@ -23773,7 +23769,6 @@ function analyzeWalkForwardDegradation(trades, options) {
   if (options) {
     for (const [key, value] of Object.entries(options)) {
       if (value !== void 0) {
-        ;
         definedOptions[key] = value;
       }
     }
@@ -23862,7 +23857,11 @@ function analyzeWalkForwardDegradation(trades, options) {
     const oosMetrics = computeMetrics(oosTrades);
     const sharpeEfficiency = computeEfficiency(oosMetrics.sharpe, isMetrics.sharpe, "sharpe");
     const winRateEfficiency = computeEfficiency(oosMetrics.winRate, isMetrics.winRate, "winRate");
-    const pfEfficiency = computeEfficiency(oosMetrics.profitFactor, isMetrics.profitFactor, "profitFactor");
+    const pfEfficiency = computeEfficiency(
+      oosMetrics.profitFactor,
+      isMetrics.profitFactor,
+      "profitFactor"
+    );
     if (isMetrics.sharpe !== null && isMetrics.sharpe < 0) {
       warnings.push(
         `Negative IS Sharpe in period ${window2.periodIndex} -- efficiency ratio may be misleading`
@@ -23871,9 +23870,21 @@ function analyzeWalkForwardDegradation(trades, options) {
     periods.push({
       window: window2,
       metrics: {
-        sharpe: { inSample: isMetrics.sharpe, outOfSample: oosMetrics.sharpe, efficiency: sharpeEfficiency },
-        winRate: { inSample: isMetrics.winRate, outOfSample: oosMetrics.winRate, efficiency: winRateEfficiency },
-        profitFactor: { inSample: isMetrics.profitFactor, outOfSample: oosMetrics.profitFactor, efficiency: pfEfficiency }
+        sharpe: {
+          inSample: isMetrics.sharpe,
+          outOfSample: oosMetrics.sharpe,
+          efficiency: sharpeEfficiency
+        },
+        winRate: {
+          inSample: isMetrics.winRate,
+          outOfSample: oosMetrics.winRate,
+          efficiency: winRateEfficiency
+        },
+        profitFactor: {
+          inSample: isMetrics.profitFactor,
+          outOfSample: oosMetrics.profitFactor,
+          efficiency: pfEfficiency
+        }
       },
       sufficient: true,
       warnings
@@ -23917,7 +23928,10 @@ function analyzeWalkForwardDegradation(trades, options) {
   const qualifyingCount = qualifyingPeriods.length;
   const recentCount = Math.min(config4.recentPeriodCount, qualifyingCount);
   const recentPeriodSlice = qualifyingPeriods.slice(-recentCount);
-  const historicalPeriodSlice = qualifyingPeriods.slice(0, Math.max(0, qualifyingCount - recentCount));
+  const historicalPeriodSlice = qualifyingPeriods.slice(
+    0,
+    Math.max(0, qualifyingCount - recentCount)
+  );
   const recentData = getEfficiencyData(recentPeriodSlice);
   const historicalData = getEfficiencyData(historicalPeriodSlice);
   const recentAvgEfficiency = {
@@ -24004,9 +24018,7 @@ function getIsoWeekKey2(dateStr) {
   const dayOfWeek = thursday.getUTCDay() || 7;
   thursday.setUTCDate(thursday.getUTCDate() + (4 - dayOfWeek));
   const yearStart = new Date(Date.UTC(thursday.getUTCFullYear(), 0, 1));
-  const weekNum = Math.ceil(
-    ((thursday.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
-  );
+  const weekNum = Math.ceil(((thursday.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
   return `${thursday.getUTCFullYear()}-W${String(weekNum).padStart(2, "0")}`;
 }
 function getMonthKey3(dateStr) {
@@ -24025,9 +24037,7 @@ function applyDateRangeFilter(trades, dateRange) {
 }
 function applyStrategyFilter(trades, strategy) {
   if (!strategy) return trades;
-  return trades.filter(
-    (t) => t.strategy.toLowerCase() === strategy.toLowerCase()
-  );
+  return trades.filter((t) => t.strategy.toLowerCase() === strategy.toLowerCase());
 }
 function calculateScaledPl(btPl, actualPl, btContracts, actualContracts, scaling) {
   let scaledBtPl = btPl;
@@ -24206,14 +24216,20 @@ function analyzeLiveAlignment(backtestTrades, actualTrades, options) {
   if (actualTrades.length === 0) {
     warnings.push("No actual trades provided");
   }
-  const { pairs, unmatchedBacktestByStrategy, unmatchedActualByStrategy } = matchTradesWithScaledPl(filteredBacktest, filteredActual, scaling);
+  const { pairs, unmatchedBacktestByStrategy, unmatchedActualByStrategy } = matchTradesWithScaledPl(
+    filteredBacktest,
+    filteredActual,
+    scaling
+  );
   if (pairs.length === 0 && (backtestTrades.length > 0 || actualTrades.length > 0)) {
     warnings.push("No matched trade pairs found");
   }
   const minOverlapTrades = Math.min(filteredBacktest.length, filteredActual.length);
   const matchRate = minOverlapTrades > 0 ? pairs.length / minOverlapTrades : 0;
   if (matchRate > 0 && matchRate < 0.5) {
-    warnings.push(`Low match rate (${(matchRate * 100).toFixed(1)}%) - trade matching may be unreliable`);
+    warnings.push(
+      `Low match rate (${(matchRate * 100).toFixed(1)}%) - trade matching may be unreliable`
+    );
   }
   const dayStrategyMap = /* @__PURE__ */ new Map();
   for (const pair of pairs) {
@@ -24236,12 +24252,14 @@ function analyzeLiveAlignment(backtestTrades, actualTrades, options) {
     if (agreed) stratData.agreed++;
     strategyDayAgreement.set(strategy, stratData);
   }
-  const directionByStrategy = Array.from(strategyDayAgreement.entries()).map(([strategy, data]) => ({
-    strategy,
-    rate: data.total > 0 ? data.agreed / data.total : 0,
-    totalDays: data.total,
-    agreementDays: data.agreed
-  }));
+  const directionByStrategy = Array.from(strategyDayAgreement.entries()).map(
+    ([strategy, data]) => ({
+      strategy,
+      rate: data.total > 0 ? data.agreed / data.total : 0,
+      totalDays: data.total,
+      agreementDays: data.agreed
+    })
+  );
   const directionAgreement = {
     overallRate: totalDays > 0 ? agreementDays / totalDays : 0,
     totalDays,
@@ -24395,20 +24413,9 @@ function safePercentChange(current, comparison) {
   if (comparison === 0) return null;
   return (current - comparison) / Math.abs(comparison) * 100;
 }
-var DOLLAR_METRICS = /* @__PURE__ */ new Set([
-  "avgWin",
-  "avgLoss",
-  "avgReturn",
-  "netPl"
-]);
-var DOLLAR_TREND_METRICS = /* @__PURE__ */ new Set([
-  "netPl",
-  "tradeCount"
-]);
-var HIGHER_IS_WORSE_METRICS = /* @__PURE__ */ new Set([
-  "maxDrawdownPercent",
-  "medianMaxDrawdown"
-]);
+var DOLLAR_METRICS = /* @__PURE__ */ new Set(["avgWin", "avgLoss", "avgReturn", "netPl"]);
+var DOLLAR_TREND_METRICS = /* @__PURE__ */ new Set(["netPl", "tradeCount"]);
+var HIGHER_IS_WORSE_METRICS = /* @__PURE__ */ new Set(["maxDrawdownPercent", "medianMaxDrawdown"]);
 function extractObservations(periodResult, rollingResult, regimeResult, wfResult, liveResult) {
   const observations = [];
   for (const m of rollingResult.recentVsHistorical.metrics) {
@@ -24666,14 +24673,18 @@ function synthesizeEdgeDecay(trades, actualTrades, options) {
   const winRateComp = findMetric(rollingResult.recentVsHistorical.metrics, "winRate");
   const pfComp = findMetric(rollingResult.recentVsHistorical.metrics, "profitFactor");
   const sharpeComp = findMetric(rollingResult.recentVsHistorical.metrics, "sharpeRatio");
-  const rateObsWithPct = observations.filter((o) => o.percentChange !== null && o.metricType === "rate");
+  const rateObsWithPct = observations.filter(
+    (o) => o.percentChange !== null && o.metricType === "rate"
+  );
   let decayCount = 0;
   for (const o of rateObsWithPct) {
     const isDecay = HIGHER_IS_WORSE_METRICS.has(o.metric) ? o.percentChange > 0 : o.percentChange < 0;
     if (isDecay) decayCount++;
   }
   const decayFraction = rateObsWithPct.length > 0 ? decayCount / rateObsWithPct.length : 0;
-  const rateObsWithAbsPct = observations.filter((o) => o.absPercentChange !== null && o.metricType === "rate");
+  const rateObsWithAbsPct = observations.filter(
+    (o) => o.absPercentChange !== null && o.metricType === "rate"
+  );
   const meanAbsPctValue = rateObsWithAbsPct.length > 0 ? rateObsWithAbsPct.reduce((sum2, o) => sum2 + o.absPercentChange, 0) / rateObsWithAbsPct.length : 0;
   const meanAbsPctNormalized = Math.min(meanAbsPctValue / 50, 1) * decayFraction;
   const mcDivergenceValue = regimeResult?.divergence.compositeScore ?? null;
@@ -24708,15 +24719,35 @@ function synthesizeEdgeDecay(trades, actualTrades, options) {
       structuralFlagRatio: BASE_WEIGHTS.structuralFlagRatio / otherSum
     };
   }
-  const compositeDecayScore = Math.max(0, Math.min(
-    1,
-    meanAbsPctNormalized * weights.meanAbsPercentChange + mcDivergenceNormalized * mcDecayDirection * weights.mcRegimeDivergence + wfEffDeltaNormalized * weights.wfEfficiencyDelta + structuralFlagRatioNormalized * weights.structuralFlagRatio
-  ));
+  const compositeDecayScore = Math.max(
+    0,
+    Math.min(
+      1,
+      meanAbsPctNormalized * weights.meanAbsPercentChange + mcDivergenceNormalized * mcDecayDirection * weights.mcRegimeDivergence + wfEffDeltaNormalized * weights.wfEfficiencyDelta + structuralFlagRatioNormalized * weights.structuralFlagRatio
+    )
+  );
   const compositeDecayScoreComponents = {
-    meanAbsPercentChange: { value: meanAbsPctValue, normalized: meanAbsPctNormalized, weight: weights.meanAbsPercentChange, decayFraction },
-    mcRegimeDivergence: { value: mcDivergenceValue, normalized: mcDivergenceNormalized * mcDecayDirection, weight: weights.mcRegimeDivergence },
-    wfEfficiencyDelta: { value: wfEffDeltaValue, normalized: wfEffDeltaNormalized, weight: weights.wfEfficiencyDelta },
-    structuralFlagRatio: { value: structuralFlagRatioValue, normalized: structuralFlagRatioNormalized, weight: weights.structuralFlagRatio }
+    meanAbsPercentChange: {
+      value: meanAbsPctValue,
+      normalized: meanAbsPctNormalized,
+      weight: weights.meanAbsPercentChange,
+      decayFraction
+    },
+    mcRegimeDivergence: {
+      value: mcDivergenceValue,
+      normalized: mcDivergenceNormalized * mcDecayDirection,
+      weight: weights.mcRegimeDivergence
+    },
+    wfEfficiencyDelta: {
+      value: wfEffDeltaValue,
+      normalized: wfEffDeltaNormalized,
+      weight: weights.wfEfficiencyDelta
+    },
+    structuralFlagRatio: {
+      value: structuralFlagRatioValue,
+      normalized: structuralFlagRatioNormalized,
+      weight: weights.structuralFlagRatio
+    }
   };
   const summary = {
     totalTrades,
@@ -24969,7 +25000,9 @@ var PerformanceCalculator = class {
   static calculateMonthlyReturns(trades, initialCapital) {
     if (trades.length === 0) return {};
     if (!initialCapital) {
-      const firstTrade = trades.sort((a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime())[0];
+      const firstTrade = trades.sort(
+        (a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime()
+      )[0];
       initialCapital = firstTrade.fundsAtClose - firstTrade.pl;
     }
     const monthlyPl = this.aggregatePLByPeriod(trades, "monthly");
@@ -25102,53 +25135,300 @@ var PerformanceCalculator = class {
 // ../lib/models/report-config.ts
 var REPORT_FIELDS = [
   // Market conditions
-  { field: "openingVix", label: "Opening VIX", category: "market", description: "VIX level when the trade was opened" },
-  { field: "closingVix", label: "Closing VIX", category: "market", description: "VIX level when the trade was closed" },
-  { field: "vixChange", label: "VIX Change", category: "market", description: "How much VIX moved during the trade", formula: "Closing VIX - Opening VIX" },
-  { field: "vixChangePct", label: "VIX Change %", category: "market", unit: "%", description: "Percentage change in VIX during the trade", formula: "((Closing VIX - Opening VIX) / Opening VIX) \xD7 100" },
-  { field: "openingShortLongRatio", label: "Opening S/L Ratio", category: "market", description: "Short/Long ratio at trade entry - measures market sentiment" },
-  { field: "closingShortLongRatio", label: "Closing S/L Ratio", category: "market", description: "Short/Long ratio at trade exit" },
-  { field: "shortLongRatioChange", label: "S/L Ratio Change", category: "market", description: "How S/L ratio changed during the trade", formula: "Closing S/L Ratio / Opening S/L Ratio" },
-  { field: "shortLongRatioChangePct", label: "S/L Ratio Change %", category: "market", unit: "%", description: "Percentage change in S/L ratio", formula: "((Closing - Opening) / Opening) \xD7 100" },
-  { field: "gap", label: "Gap", category: "market", description: "Opening gap in points from previous close" },
-  { field: "movement", label: "Movement", category: "market", description: "Underlying price movement during the trade" },
+  {
+    field: "openingVix",
+    label: "Opening VIX",
+    category: "market",
+    description: "VIX level when the trade was opened"
+  },
+  {
+    field: "closingVix",
+    label: "Closing VIX",
+    category: "market",
+    description: "VIX level when the trade was closed"
+  },
+  {
+    field: "vixChange",
+    label: "VIX Change",
+    category: "market",
+    description: "How much VIX moved during the trade",
+    formula: "Closing VIX - Opening VIX"
+  },
+  {
+    field: "vixChangePct",
+    label: "VIX Change %",
+    category: "market",
+    unit: "%",
+    description: "Percentage change in VIX during the trade",
+    formula: "((Closing VIX - Opening VIX) / Opening VIX) \xD7 100"
+  },
+  {
+    field: "openingShortLongRatio",
+    label: "Opening S/L Ratio",
+    category: "market",
+    description: "Short/Long ratio at trade entry - measures market sentiment"
+  },
+  {
+    field: "closingShortLongRatio",
+    label: "Closing S/L Ratio",
+    category: "market",
+    description: "Short/Long ratio at trade exit"
+  },
+  {
+    field: "shortLongRatioChange",
+    label: "S/L Ratio Change",
+    category: "market",
+    description: "How S/L ratio changed during the trade",
+    formula: "Closing S/L Ratio / Opening S/L Ratio"
+  },
+  {
+    field: "shortLongRatioChangePct",
+    label: "S/L Ratio Change %",
+    category: "market",
+    unit: "%",
+    description: "Percentage change in S/L ratio",
+    formula: "((Closing - Opening) / Opening) \xD7 100"
+  },
+  {
+    field: "gap",
+    label: "Gap",
+    category: "market",
+    description: "Opening gap in points from previous close"
+  },
+  {
+    field: "movement",
+    label: "Movement",
+    category: "market",
+    description: "Underlying price movement during the trade"
+  },
   // Return metrics
-  { field: "pl", label: "Profit/Loss", category: "returns", unit: "$", description: "Trade profit or loss in dollars (before fees)" },
-  { field: "netPl", label: "Net P/L", category: "returns", unit: "$", description: "Profit/loss after subtracting all fees", formula: "P/L - Total Fees" },
-  { field: "plPct", label: "P/L %", category: "returns", unit: "%", description: "Return as a percentage of premium collected", formula: "(P/L / Premium) \xD7 100" },
-  { field: "netPlPct", label: "Net P/L %", category: "returns", unit: "%", description: "Net return as a percentage of premium", formula: "(Net P/L / Premium) \xD7 100" },
-  { field: "rom", label: "Return on Margin", category: "returns", unit: "%", description: "Return relative to margin required - measures capital efficiency", formula: "(P/L / Margin Required) \xD7 100" },
-  { field: "isWinner", label: "Is Winner", category: "returns", description: "Binary flag: 1 if trade was profitable, 0 if it was a loss" },
+  {
+    field: "pl",
+    label: "Profit/Loss",
+    category: "returns",
+    unit: "$",
+    description: "Trade profit or loss in dollars (before fees)"
+  },
+  {
+    field: "netPl",
+    label: "Net P/L",
+    category: "returns",
+    unit: "$",
+    description: "Profit/loss after subtracting all fees",
+    formula: "P/L - Total Fees"
+  },
+  {
+    field: "plPct",
+    label: "P/L %",
+    category: "returns",
+    unit: "%",
+    description: "Return as a percentage of premium collected",
+    formula: "(P/L / Premium) \xD7 100"
+  },
+  {
+    field: "netPlPct",
+    label: "Net P/L %",
+    category: "returns",
+    unit: "%",
+    description: "Net return as a percentage of premium",
+    formula: "(Net P/L / Premium) \xD7 100"
+  },
+  {
+    field: "rom",
+    label: "Return on Margin",
+    category: "returns",
+    unit: "%",
+    description: "Return relative to margin required - measures capital efficiency",
+    formula: "(P/L / Margin Required) \xD7 100"
+  },
+  {
+    field: "isWinner",
+    label: "Is Winner",
+    category: "returns",
+    description: "Binary flag: 1 if trade was profitable, 0 if it was a loss"
+  },
   // Risk metrics (MFE/MAE)
-  { field: "mfePercent", label: "MFE %", category: "risk", unit: "%", description: "Maximum Favorable Excursion - the best unrealized profit during the trade as % of premium", formula: "(Max Unrealized Profit / Premium) \xD7 100" },
-  { field: "maePercent", label: "MAE %", category: "risk", unit: "%", description: "Maximum Adverse Excursion - the worst unrealized loss during the trade as % of premium", formula: "(Max Unrealized Loss / Premium) \xD7 100" },
-  { field: "profitCapturePercent", label: "Profit Capture %", category: "risk", unit: "%", description: "How much of the peak profit was captured at exit", formula: "(P/L / MFE) \xD7 100" },
-  { field: "excursionRatio", label: "Excursion Ratio", category: "risk", description: "Reward/risk ratio - how much upside vs downside the trade experienced", formula: "MFE / MAE" },
-  { field: "rMultiple", label: "R-Multiple", category: "risk", description: 'Risk-adjusted return - how many "R" (risk units) were won or lost', formula: "P/L / MAE" },
+  {
+    field: "mfePercent",
+    label: "MFE %",
+    category: "risk",
+    unit: "%",
+    description: "Maximum Favorable Excursion - the best unrealized profit during the trade as % of premium",
+    formula: "(Max Unrealized Profit / Premium) \xD7 100"
+  },
+  {
+    field: "maePercent",
+    label: "MAE %",
+    category: "risk",
+    unit: "%",
+    description: "Maximum Adverse Excursion - the worst unrealized loss during the trade as % of premium",
+    formula: "(Max Unrealized Loss / Premium) \xD7 100"
+  },
+  {
+    field: "profitCapturePercent",
+    label: "Profit Capture %",
+    category: "risk",
+    unit: "%",
+    description: "How much of the peak profit was captured at exit",
+    formula: "(P/L / MFE) \xD7 100"
+  },
+  {
+    field: "excursionRatio",
+    label: "Excursion Ratio",
+    category: "risk",
+    description: "Reward/risk ratio - how much upside vs downside the trade experienced",
+    formula: "MFE / MAE"
+  },
+  {
+    field: "rMultiple",
+    label: "R-Multiple",
+    category: "risk",
+    description: 'Risk-adjusted return - how many "R" (risk units) were won or lost',
+    formula: "P/L / MAE"
+  },
   // Trade details
-  { field: "premium", label: "Premium", category: "trade", unit: "$", description: "Premium collected per contract when opening the trade" },
-  { field: "marginReq", label: "Margin Required", category: "trade", unit: "$", description: "Margin/buying power required to hold the position" },
-  { field: "openingPrice", label: "Opening Price", category: "trade", unit: "$", description: "Price of the position when opened" },
-  { field: "closingPrice", label: "Closing Price", category: "trade", unit: "$", description: "Price of the position when closed" },
-  { field: "numContracts", label: "Contracts", category: "trade", description: "Number of contracts traded" },
-  { field: "totalFees", label: "Total Fees", category: "trade", unit: "$", description: "All commissions and fees paid", formula: "Opening Fees + Closing Fees" },
-  { field: "openingCommissionsFees", label: "Opening Fees", category: "trade", unit: "$", description: "Commissions and fees paid when opening" },
-  { field: "closingCommissionsFees", label: "Closing Fees", category: "trade", unit: "$", description: "Commissions and fees paid when closing" },
-  { field: "maxProfit", label: "Max Profit", category: "trade", unit: "%", description: "Maximum unrealized profit as % of premium during the trade" },
-  { field: "maxLoss", label: "Max Loss", category: "trade", unit: "%", description: "Maximum unrealized loss as % of premium during the trade" },
+  {
+    field: "premium",
+    label: "Premium",
+    category: "trade",
+    unit: "$",
+    description: "Premium collected per contract when opening the trade"
+  },
+  {
+    field: "marginReq",
+    label: "Margin Required",
+    category: "trade",
+    unit: "$",
+    description: "Margin/buying power required to hold the position"
+  },
+  {
+    field: "openingPrice",
+    label: "Opening Price",
+    category: "trade",
+    unit: "$",
+    description: "Price of the position when opened"
+  },
+  {
+    field: "closingPrice",
+    label: "Closing Price",
+    category: "trade",
+    unit: "$",
+    description: "Price of the position when closed"
+  },
+  {
+    field: "numContracts",
+    label: "Contracts",
+    category: "trade",
+    description: "Number of contracts traded"
+  },
+  {
+    field: "totalFees",
+    label: "Total Fees",
+    category: "trade",
+    unit: "$",
+    description: "All commissions and fees paid",
+    formula: "Opening Fees + Closing Fees"
+  },
+  {
+    field: "openingCommissionsFees",
+    label: "Opening Fees",
+    category: "trade",
+    unit: "$",
+    description: "Commissions and fees paid when opening"
+  },
+  {
+    field: "closingCommissionsFees",
+    label: "Closing Fees",
+    category: "trade",
+    unit: "$",
+    description: "Commissions and fees paid when closing"
+  },
+  {
+    field: "maxProfit",
+    label: "Max Profit",
+    category: "trade",
+    unit: "%",
+    description: "Maximum unrealized profit as % of premium during the trade"
+  },
+  {
+    field: "maxLoss",
+    label: "Max Loss",
+    category: "trade",
+    unit: "%",
+    description: "Maximum unrealized loss as % of premium during the trade"
+  },
   // Timing
-  { field: "tradeNumber", label: "Trade #", category: "timing", description: "Sequential trade number (1 = first trade)" },
-  { field: "dateOpenedTimestamp", label: "Date Opened", category: "timing", description: "When the trade was opened (useful for time-series charts)" },
-  { field: "durationHours", label: "Duration (hrs)", category: "timing", unit: "hrs", description: "How long the position was held", formula: "Close Time - Open Time" },
-  { field: "dayOfWeek", label: "Day of Week", category: "timing", description: "Day of week when opened: 0=Sunday through 6=Saturday" },
-  { field: "hourOfDay", label: "Hour of Day", category: "timing", description: "Hour of day when opened (0-23 in Eastern Time)" },
-  { field: "timeOfDayMinutes", label: "Time of Day", category: "timing", description: "Exact time when opened as minutes since midnight (e.g., 11:45 = 705). Useful for scatter plots to analyze floating-time or multiple-entry trades" },
-  { field: "dayOfMonth", label: "Day of Month", category: "timing", description: "Day of month when opened (1-31)" },
-  { field: "monthOfYear", label: "Month of Year", category: "timing", description: "Month when opened (1=January through 12=December)" },
-  { field: "weekOfYear", label: "Week of Year", category: "timing", description: "ISO week number when opened (1-52)" },
+  {
+    field: "tradeNumber",
+    label: "Trade #",
+    category: "timing",
+    description: "Sequential trade number (1 = first trade)"
+  },
+  {
+    field: "dateOpenedTimestamp",
+    label: "Date Opened",
+    category: "timing",
+    description: "When the trade was opened (useful for time-series charts)"
+  },
+  {
+    field: "durationHours",
+    label: "Duration (hrs)",
+    category: "timing",
+    unit: "hrs",
+    description: "How long the position was held",
+    formula: "Close Time - Open Time"
+  },
+  {
+    field: "dayOfWeek",
+    label: "Day of Week",
+    category: "timing",
+    description: "Day of week when opened: 0=Sunday through 6=Saturday"
+  },
+  {
+    field: "hourOfDay",
+    label: "Hour of Day",
+    category: "timing",
+    description: "Hour of day when opened (0-23 in Eastern Time)"
+  },
+  {
+    field: "timeOfDayMinutes",
+    label: "Time of Day",
+    category: "timing",
+    description: "Exact time when opened as minutes since midnight (e.g., 11:45 = 705). Useful for scatter plots to analyze floating-time or multiple-entry trades"
+  },
+  {
+    field: "dayOfMonth",
+    label: "Day of Month",
+    category: "timing",
+    description: "Day of month when opened (1-31)"
+  },
+  {
+    field: "monthOfYear",
+    label: "Month of Year",
+    category: "timing",
+    description: "Month when opened (1=January through 12=December)"
+  },
+  {
+    field: "weekOfYear",
+    label: "Week of Year",
+    category: "timing",
+    description: "ISO week number when opened (1-52)"
+  },
   // Portfolio context
-  { field: "exposureOnOpen", label: "Portfolio Exposure %", category: "risk", unit: "%", description: "Portfolio margin exposure as % of equity at the exact moment this trade opened - shows how much risk was deployed when entering" },
-  { field: "exposureOnOpenDollars", label: "Portfolio Exposure $", category: "risk", unit: "$", description: "Portfolio margin exposure in dollars at the exact moment this trade opened - shows total margin at risk when entering" }
+  {
+    field: "exposureOnOpen",
+    label: "Portfolio Exposure %",
+    category: "risk",
+    unit: "%",
+    description: "Portfolio margin exposure as % of equity at the exact moment this trade opened - shows how much risk was deployed when entering"
+  },
+  {
+    field: "exposureOnOpenDollars",
+    label: "Portfolio Exposure $",
+    category: "risk",
+    unit: "$",
+    description: "Portfolio margin exposure in dollars at the exact moment this trade opened - shows total margin at risk when entering"
+  }
 ];
 
 // ../lib/calculations/index.ts
@@ -25179,9 +25459,15 @@ var CalculationOrchestrator = class {
       };
     }
     const calculator = new PortfolioStatsCalculator(config4);
-    const portfolioStats = calculator.calculatePortfolioStats(trades, dailyLogs);
+    const portfolioStats = calculator.calculatePortfolioStats(
+      trades,
+      dailyLogs
+    );
     const strategyStats = calculator.calculateStrategyStats(trades);
-    const performanceMetrics = PerformanceCalculator.calculatePerformanceMetrics(trades, dailyLogs);
+    const performanceMetrics = PerformanceCalculator.calculatePerformanceMetrics(
+      trades,
+      dailyLogs
+    );
     this.cache.set(blockId, {
       portfolioStats,
       strategyStats,
@@ -25221,9 +25507,9 @@ var calculationOrchestrator = new CalculationOrchestrator();
 var REPORTING_TRADE_COLUMN_ALIASES = {
   "Initial Premium ($)": "Initial Premium",
   "Initial Credit": "Initial Premium",
-  "Contracts": "No. of Contracts",
+  Contracts: "No. of Contracts",
   "Contracts Traded": "No. of Contracts",
-  "PL": "P/L"
+  PL: "P/L"
 };
 
 // ../lib/processing/tat-adapter.ts
@@ -25409,4 +25695,4 @@ decimal.js/decimal.mjs:
    *  MIT Licence
    *)
 */
-//# sourceMappingURL=chunk-72GKJE2U.js.map
+//# sourceMappingURL=chunk-BOPHW5M6.js.map