tradeblocks-mcp 3.0.2 → 3.3.1

package/server/{chunk-72GKJE2U.js → chunk-RJDJHZ5Y.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 = {
@@ -23971,6 +23985,69 @@ function analyzeWalkForwardDegradation(trades, options) {
   };
 }
 
+// ../lib/calculations/trade-set-alignment.ts
+var KEY_SEPARATOR = "	";
+var REASON_EMPTY_STRATEGY = "empty or non-string strategy";
+var REASON_INVALID_DATE = "invalid dateOpened";
+function computeMatchKey(strategy, dateOpened, time) {
+  if (typeof strategy !== "string" || strategy.length === 0) {
+    return { key: null, reason: REASON_EMPTY_STRATEGY };
+  }
+  const dateKey = formatDateKey2(new Date(dateOpened));
+  if (dateKey.includes("NaN")) {
+    return { key: null, reason: REASON_INVALID_DATE };
+  }
+  const timeKey = truncateTimeToMinute(time);
+  return { key: `${dateKey}${KEY_SEPARATOR}${strategy}${KEY_SEPARATOR}${timeKey}`, reason: null };
+}
+function matchTradeSets(backtestTrades, actualTrades) {
+  const actualByKey = /* @__PURE__ */ new Map();
+  const unusableActual = [];
+  actualTrades.forEach((trade, index) => {
+    const { key, reason } = computeMatchKey(
+      trade.strategy,
+      trade.dateOpened,
+      trade.rawTimeOpened ?? trade.timeOpened
+    );
+    if (key === null) {
+      unusableActual.push({ index, reason });
+      return;
+    }
+    const queue = actualByKey.get(key);
+    if (queue) queue.push(index);
+    else actualByKey.set(key, [index]);
+  });
+  const matched = [];
+  const unmatchedBacktestIndices = [];
+  const unusableBacktest = [];
+  backtestTrades.forEach((trade, index) => {
+    const { key, reason } = computeMatchKey(trade.strategy, trade.dateOpened, trade.timeOpened);
+    if (key === null) {
+      unusableBacktest.push({ index, reason });
+      return;
+    }
+    const queue = actualByKey.get(key);
+    if (queue && queue.length > 0) {
+      const actualIndex = queue.shift();
+      matched.push({ backtestIndex: index, actualIndex });
+    } else {
+      unmatchedBacktestIndices.push(index);
+    }
+  });
+  const unmatchedActualIndices = [];
+  for (const queue of actualByKey.values()) {
+    for (const idx of queue) unmatchedActualIndices.push(idx);
+  }
+  unmatchedActualIndices.sort((a, b) => a - b);
+  return {
+    matched,
+    unmatchedBacktestIndices,
+    unmatchedActualIndices,
+    unusableBacktest,
+    unusableActual
+  };
+}
+
 // ../lib/calculations/trade-matching.ts
 function formatDateKey2(d) {
   const year = d.getFullYear();
@@ -23980,11 +24057,17 @@ function formatDateKey2(d) {
 }
 function truncateTimeToMinute(time) {
   if (!time) return "00:00";
-  const parts = time.split(":");
-  if (parts.length >= 2) {
-    return `${parts[0].padStart(2, "0")}:${parts[1].padStart(2, "0")}`;
-  }
-  return "00:00";
+  const match = time.trim().match(/^(\d{1,2}):(\d{2})(?::\d{2}(?:\.\d+)?)?\s*([AP]M)?$/i);
+  if (!match) return "00:00";
+  let hour = Number(match[1]);
+  const period = match[3]?.toUpperCase();
+  if (period) {
+    if (hour < 1 || hour > 12) return "00:00";
+    hour = hour % 12 + (period === "PM" ? 12 : 0);
+  } else if (hour > 23) {
+    return "00:00";
+  }
+  return `${String(hour).padStart(2, "0")}:${match[2]}`;
 }
 function parseHourFromTime(timeOpened) {
   if (!timeOpened || typeof timeOpened !== "string") return null;
@@ -24004,9 +24087,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 +24106,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;
@@ -24046,111 +24125,88 @@ function calculateScaledPl(btPl, actualPl, btContracts, actualContracts, scaling
   return { scaledBtPl, scaledActualPl };
 }
 function matchTrades(backtestTrades, actualTrades, scaling) {
-  const actualByKey = /* @__PURE__ */ new Map();
-  actualTrades.forEach((trade) => {
-    const dateKey = formatDateKey2(new Date(trade.dateOpened));
-    const timeKey = truncateTimeToMinute(trade.timeOpened);
-    const key = `${dateKey}|${trade.strategy}|${timeKey}`;
-    const existing = actualByKey.get(key) || [];
-    existing.push(trade);
-    actualByKey.set(key, existing);
+  const {
+    matched,
+    unmatchedBacktestIndices,
+    unmatchedActualIndices,
+    unusableBacktest,
+    unusableActual
+  } = matchTradeSets(backtestTrades, actualTrades);
+  const matchedTrades = matched.map(({ backtestIndex, actualIndex }) => {
+    const btTrade = backtestTrades[backtestIndex];
+    const actualTrade = actualTrades[actualIndex];
+    const { scaledBtPl, scaledActualPl } = calculateScaledPl(
+      btTrade.pl,
+      actualTrade.pl,
+      btTrade.numContracts,
+      actualTrade.numContracts,
+      scaling
+    );
+    return {
+      date: formatDateKey2(new Date(btTrade.dateOpened)),
+      strategy: btTrade.strategy,
+      timeOpened: truncateTimeToMinute(btTrade.timeOpened),
+      // Total slippage = actual P/L - backtest P/L (after scaling)
+      totalSlippage: scaledActualPl - scaledBtPl,
+      openingVix: btTrade.openingVix,
+      closingVix: btTrade.closingVix,
+      gap: btTrade.gap,
+      movement: btTrade.movement,
+      hourOfDay: parseHourFromTime(btTrade.timeOpened),
+      contracts: actualTrade.numContracts
+    };
   });
-  const matchedTrades = [];
-  let unmatchedBacktestCount = 0;
-  let unmatchedActualCount = actualTrades.length;
-  for (const btTrade of backtestTrades) {
-    const dateKey = formatDateKey2(new Date(btTrade.dateOpened));
-    const timeKey = truncateTimeToMinute(btTrade.timeOpened);
-    const key = `${dateKey}|${btTrade.strategy}|${timeKey}`;
-    const actualMatches = actualByKey.get(key);
-    const actualTrade = actualMatches?.[0];
-    if (actualTrade) {
-      unmatchedActualCount--;
-      if (actualMatches && actualMatches.length > 1) {
-        actualByKey.set(key, actualMatches.slice(1));
-      } else {
-        actualByKey.delete(key);
-      }
-      const { scaledBtPl, scaledActualPl } = calculateScaledPl(
-        btTrade.pl,
-        actualTrade.pl,
-        btTrade.numContracts,
-        actualTrade.numContracts,
-        scaling
-      );
-      const totalSlippage = scaledActualPl - scaledBtPl;
-      matchedTrades.push({
-        date: dateKey,
-        strategy: btTrade.strategy,
-        timeOpened: timeKey,
-        totalSlippage,
-        openingVix: btTrade.openingVix,
-        closingVix: btTrade.closingVix,
-        gap: btTrade.gap,
-        movement: btTrade.movement,
-        hourOfDay: parseHourFromTime(btTrade.timeOpened),
-        contracts: actualTrade.numContracts
-      });
-    } else {
-      unmatchedBacktestCount++;
-    }
-  }
+  const unmatchedBacktestCount = unmatchedBacktestIndices.length + unusableBacktest.length;
+  const unmatchedActualCount = unmatchedActualIndices.length + unusableActual.length;
   return { matchedTrades, unmatchedBacktestCount, unmatchedActualCount };
 }
 
 // ../lib/calculations/live-alignment.ts
 function matchTradesWithScaledPl(backtestTrades, actualTrades, scaling) {
-  const actualByKey = /* @__PURE__ */ new Map();
-  for (const trade of actualTrades) {
-    const dateKey = formatDateKey2(new Date(trade.dateOpened));
-    const timeKey = truncateTimeToMinute(trade.timeOpened);
-    const key = `${dateKey}	${trade.strategy}	${timeKey}`;
-    const existing = actualByKey.get(key) || [];
-    existing.push(trade);
-    actualByKey.set(key, existing);
-  }
-  const pairs = [];
+  const {
+    matched,
+    unmatchedBacktestIndices,
+    unmatchedActualIndices,
+    unusableBacktest,
+    unusableActual
+  } = matchTradeSets(backtestTrades, actualTrades);
+  const pairs = matched.map(({ backtestIndex, actualIndex }) => {
+    const btTrade = backtestTrades[backtestIndex];
+    const actualTrade = actualTrades[actualIndex];
+    const { scaledBtPl, scaledActualPl } = calculateScaledPl(
+      btTrade.pl,
+      actualTrade.pl,
+      btTrade.numContracts,
+      actualTrade.numContracts,
+      scaling
+    );
+    return {
+      date: formatDateKey2(new Date(btTrade.dateOpened)),
+      strategy: btTrade.strategy,
+      scaledBtPl,
+      scaledActualPl,
+      slippage: scaledActualPl - scaledBtPl,
+      btContracts: btTrade.numContracts,
+      actualContracts: actualTrade.numContracts
+    };
+  });
   const unmatchedBacktestByStrategy = /* @__PURE__ */ new Map();
+  for (const index of unmatchedBacktestIndices) {
+    const strat = backtestTrades[index].strategy;
+    unmatchedBacktestByStrategy.set(strat, (unmatchedBacktestByStrategy.get(strat) || 0) + 1);
+  }
+  for (const { index } of unusableBacktest) {
+    const strat = backtestTrades[index].strategy;
+    unmatchedBacktestByStrategy.set(strat, (unmatchedBacktestByStrategy.get(strat) || 0) + 1);
+  }
   const unmatchedActualByStrategy = /* @__PURE__ */ new Map();
-  for (const trade of actualTrades) {
-    const strat = trade.strategy;
+  for (const index of unmatchedActualIndices) {
+    const strat = actualTrades[index].strategy;
     unmatchedActualByStrategy.set(strat, (unmatchedActualByStrategy.get(strat) || 0) + 1);
   }
-  for (const btTrade of backtestTrades) {
-    const dateKey = formatDateKey2(new Date(btTrade.dateOpened));
-    const timeKey = truncateTimeToMinute(btTrade.timeOpened);
-    const key = `${dateKey}	${btTrade.strategy}	${timeKey}`;
-    const actualMatches = actualByKey.get(key);
-    const actualTrade = actualMatches?.[0];
-    if (actualTrade) {
-      const strat = actualTrade.strategy;
-      const remaining = (unmatchedActualByStrategy.get(strat) || 1) - 1;
-      unmatchedActualByStrategy.set(strat, remaining);
-      if (actualMatches && actualMatches.length > 1) {
-        actualByKey.set(key, actualMatches.slice(1));
-      } else {
-        actualByKey.delete(key);
-      }
-      const { scaledBtPl, scaledActualPl } = calculateScaledPl(
-        btTrade.pl,
-        actualTrade.pl,
-        btTrade.numContracts,
-        actualTrade.numContracts,
-        scaling
-      );
-      pairs.push({
-        date: dateKey,
-        strategy: btTrade.strategy,
-        scaledBtPl,
-        scaledActualPl,
-        slippage: scaledActualPl - scaledBtPl,
-        btContracts: btTrade.numContracts,
-        actualContracts: actualTrade.numContracts
-      });
-    } else {
-      const strat = btTrade.strategy;
-      unmatchedBacktestByStrategy.set(strat, (unmatchedBacktestByStrategy.get(strat) || 0) + 1);
-    }
+  for (const { index } of unusableActual) {
+    const strat = actualTrades[index].strategy;
+    unmatchedActualByStrategy.set(strat, (unmatchedActualByStrategy.get(strat) || 0) + 1);
   }
   return { pairs, unmatchedBacktestByStrategy, unmatchedActualByStrategy };
 }
@@ -24200,20 +24256,33 @@ function analyzeLiveAlignment(backtestTrades, actualTrades, options) {
     filteredBacktest = [];
     filteredActual = [];
   }
+  const outsideOverlapBacktestCount = backtestTrades.length - filteredBacktest.length;
+  const outsideOverlapActualCount = actualTrades.length - filteredActual.length;
+  if (overlapRange && (outsideOverlapBacktestCount > 0 || outsideOverlapActualCount > 0)) {
+    warnings.push(
+      `${outsideOverlapBacktestCount} backtest trade(s) and ${outsideOverlapActualCount} actual trade(s) fall outside the shared overlap window and are excluded from alignment metrics`
+    );
+  }
   if (backtestTrades.length === 0) {
     warnings.push("No backtest trades provided");
   }
   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 +24305,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,
@@ -24355,6 +24426,8 @@ function analyzeLiveAlignment(backtestTrades, actualTrades, options) {
   const dataQuality = {
     backtestTradeCount: backtestTrades.length,
     actualTradeCount: actualTrades.length,
+    outsideOverlapBacktestCount,
+    outsideOverlapActualCount,
     matchedTradeCount: pairs.length,
     matchRate,
     overlapMonths: monthlySeries.length,
@@ -24395,20 +24468,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 +24728,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 +24774,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 +25055,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,55 +25190,558 @@ 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/paired-block-bootstrap.ts
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return function() {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function deriveSeed(seed, blockDays) {
+  return seed + Math.imul(blockDays, 2654435761) >>> 0;
+}
+function percentileOf(sorted, p) {
+  const n = sorted.length;
+  if (n === 1) return sorted[0];
+  const rank = p * (n - 1);
+  const lo = Math.floor(rank);
+  const hi = Math.ceil(rank);
+  if (lo === hi) return sorted[lo];
+  const weight = rank - lo;
+  return sorted[lo] * (1 - weight) + sorted[hi] * weight;
+}
+function observedValueMap(arm) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (let i = 0; i < arm.index.length; i++) {
+    if (arm.observedMask[i]) {
+      map2.set(arm.index[i], arm.values[i]);
+    }
+  }
+  return map2;
+}
+function isConstantArm(arm) {
+  return arm !== void 0 && "constant" in arm;
+}
+function unionDays(a, b) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of a) seen.add(d);
+  for (const d of b) seen.add(d);
+  return Array.from(seen).sort();
+}
+function buildOverlap(ambient, isObserved, deltaOf) {
+  const days = [];
+  const delta = [];
+  const runs = [];
+  let runStart = -1;
+  for (const day of ambient) {
+    if (isObserved(day)) {
+      if (runStart === -1) runStart = days.length;
+      days.push(day);
+      delta.push(deltaOf(day));
+    } else if (runStart !== -1) {
+      runs.push({ start: runStart, length: days.length - runStart });
+      runStart = -1;
+    }
+  }
+  if (runStart !== -1) {
+    runs.push({ start: runStart, length: days.length - runStart });
+  }
+  return { days, delta, runs };
+}
+function buildComparisonOverlap(armA, armB) {
+  const mapA = observedValueMap(armA);
+  if (armB === void 0 || isConstantArm(armB)) {
+    const c = armB === void 0 ? 0 : armB.constant;
+    return buildOverlap(
+      armA.index,
+      (day) => mapA.has(day),
+      (day) => mapA.get(day) - c
+    );
+  }
+  const mapB = observedValueMap(armB);
+  const ambient = unionDays(armA.index, armB.index);
+  return buildOverlap(
+    ambient,
+    (day) => mapA.has(day) && mapB.has(day),
+    (day) => mapA.get(day) - mapB.get(day)
+  );
+}
+function enumerateBlockStarts(runs, blockDays) {
+  const starts = [];
+  for (const run of runs) {
+    const lastStart = run.length - blockDays;
+    for (let offset = 0; offset <= lastStart; offset++) {
+      starts.push(run.start + offset);
+    }
+  }
+  return starts;
+}
+function drawResampleIndices(rng, blockStarts, blockDays, n) {
+  const indices = [];
+  while (indices.length < n) {
+    const start = blockStarts[Math.floor(rng() * blockStarts.length)];
+    for (let k = 0; k < blockDays && indices.length < n; k++) {
+      indices.push(start + k);
+    }
+  }
+  return indices;
+}
+function computeCore(params) {
+  const {
+    overlapDays,
+    runs,
+    deltaSeries,
+    memberDeltas,
+    extremum,
+    blockDays,
+    resamples,
+    seed,
+    ciLevel,
+    statistic,
+    effectiveNFloorBlocks
+  } = params;
+  const n = overlapDays.length;
+  const effectiveN = n / blockDays;
+  const takeExtremum = (values) => extremum === "min" ? Math.min(...values) : Math.max(...values);
+  let point;
+  if (n === 0) {
+    point = null;
+  } else if (memberDeltas) {
+    point = takeExtremum(memberDeltas.map((d) => statistic(d)));
+  } else {
+    point = statistic(deltaSeries);
+  }
+  const blockStarts = enumerateBlockStarts(runs, blockDays);
+  if (effectiveNFloorBlocks !== void 0 && effectiveN < effectiveNFloorBlocks) {
+    return { point, low: null, high: null, effectiveN, status: "notComparable" };
+  }
+  if (blockStarts.length < 2) {
+    return { point, low: null, high: null, effectiveN, status: "underpowered" };
+  }
+  const rng = mulberry32(deriveSeed(seed, blockDays));
+  const distribution = new Array(resamples);
+  for (let r = 0; r < resamples; r++) {
+    const idx = drawResampleIndices(rng, blockStarts, blockDays, n);
+    if (memberDeltas) {
+      const stats = memberDeltas.map((d) => statistic(idx.map((i) => d[i])));
+      distribution[r] = takeExtremum(stats);
+    } else {
+      distribution[r] = statistic(idx.map((i) => deltaSeries[i]));
+    }
+  }
+  distribution.sort((a, b) => a - b);
+  const alpha = 1 - ciLevel;
+  const low = percentileOf(distribution, alpha / 2);
+  const high = percentileOf(distribution, 1 - alpha / 2);
+  return { point, low, high, effectiveN, status: "resolved" };
+}
+function buildSelectionOverlap(members) {
+  const memberMaps = members.map((m) => {
+    const overlap2 = buildComparisonOverlap(m.armA, m.armB);
+    const map2 = /* @__PURE__ */ new Map();
+    for (let i = 0; i < overlap2.days.length; i++) {
+      map2.set(overlap2.days[i], overlap2.delta[i]);
+    }
+    return map2;
+  });
+  let ambient = [];
+  for (const m of members) {
+    const armBDays = isConstantArm(m.armB) || m.armB === void 0 ? [] : m.armB.index;
+    ambient = unionDays(ambient, unionDays(m.armA.index, armBDays));
+  }
+  const overlap = buildOverlap(
+    ambient,
+    (day) => memberMaps.every((map2) => map2.has(day)),
+    () => 0
+  );
+  const memberDeltas = memberMaps.map((map2) => overlap.days.map((day) => map2.get(day)));
+  return { days: overlap.days, runs: overlap.runs, memberDeltas };
+}
+function holdingPeriodBlockDays(holdingPeriodsTradingDays, percentile2 = 0.95) {
+  if (holdingPeriodsTradingDays.length === 0) return 1;
+  const sorted = [...holdingPeriodsTradingDays].sort((a, b) => a - b);
+  return Math.max(1, Math.round(percentileOf(sorted, percentile2)));
+}
+function pairedBlockBootstrap(input) {
+  const blockDays = Math.max(1, Math.round(input.holdingRule.blockDays));
+  const { ciLevel, resamples, seed, statistic, effectiveNFloorBlocks } = input;
+  let overlapDays;
+  let runs;
+  let deltaSeries;
+  let memberDeltas;
+  let extremum;
+  let selection = null;
+  if (input.selectionSet) {
+    const sel = buildSelectionOverlap(input.selectionSet.members);
+    overlapDays = sel.days;
+    runs = sel.runs;
+    memberDeltas = sel.memberDeltas;
+    extremum = input.selectionSet.extremum;
+    deltaSeries = [];
+    const memberPoints = sel.memberDeltas.map((d) => statistic(d));
+    const kConsidered = memberPoints.length;
+    const centroid = kConsidered > 0 ? memberPoints.reduce((s, v) => s + v, 0) / kConsidered : 0;
+    let maxGap = 0;
+    if (kConsidered >= 2) {
+      const ordered = [...memberPoints].sort((a, b) => a - b);
+      maxGap = extremum === "min" ? ordered[1] - ordered[0] : ordered[kConsidered - 1] - ordered[kConsidered - 2];
+    }
+    selection = { centroid, maxGap, kConsidered };
+  } else {
+    const overlap = buildComparisonOverlap(input.armA, input.armB);
+    overlapDays = overlap.days;
+    runs = overlap.runs;
+    deltaSeries = overlap.delta;
+  }
+  const overlapWindow = overlapDays.length > 0 ? { start: overlapDays[0], end: overlapDays[overlapDays.length - 1] } : null;
+  const primary = computeCore({
+    overlapDays,
+    runs,
+    deltaSeries,
+    memberDeltas,
+    extremum,
+    blockDays,
+    resamples,
+    seed,
+    ciLevel,
+    statistic,
+    effectiveNFloorBlocks
+  });
+  const sensitivity = [];
+  for (const multiplier of input.holdingRule.sensitivity ?? []) {
+    const sensBlockDays = Math.max(1, Math.round(multiplier * blockDays));
+    const sens = computeCore({
+      overlapDays,
+      runs,
+      deltaSeries,
+      memberDeltas,
+      extremum,
+      blockDays: sensBlockDays,
+      resamples,
+      seed,
+      ciLevel,
+      statistic,
+      effectiveNFloorBlocks
+    });
+    sensitivity.push({
+      blockDays: sensBlockDays,
+      ci: { low: sens.low, high: sens.high },
+      status: sens.status
+    });
+  }
+  return {
+    point: primary.point,
+    ci: { level: ciLevel, low: primary.low, high: primary.high, method: "paired-day-block" },
+    effectiveN: primary.effectiveN,
+    overlapWindow,
+    blockDays,
+    sensitivity,
+    selection,
+    status: primary.status,
+    seed
+  };
+}
+
 // ../lib/calculations/index.ts
 function generateDataHash(trades, dailyLogs) {
   const data = {
@@ -25179,9 +25770,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 +25818,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
@@ -25393,6 +25990,8 @@ export {
   matchTrades,
   analyzeLiveAlignment,
   synthesizeEdgeDecay,
+  holdingPeriodBlockDays,
+  pairedBlockBootstrap,
   REPORTING_TRADE_COLUMN_ALIASES,
   isTatFormat,
   convertTatRowToReportingTrade,
@@ -25409,4 +26008,4 @@ decimal.js/decimal.mjs:
    *  MIT Licence
    *)
 */
-//# sourceMappingURL=chunk-72GKJE2U.js.map
+//# sourceMappingURL=chunk-RJDJHZ5Y.js.map