tradeblocks-mcp 3.0.2 → 3.3.1

package/dist/{chunk-QTTR7AAW.js → chunk-2I3S2ZLT.js}

@@ -19791,8 +19791,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;
@@ -19831,7 +19833,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,
@@ -19869,14 +19874,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);
@@ -19911,7 +19919,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 {
@@ -20012,9 +20022,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);
@@ -20035,7 +20043,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);
@@ -20102,7 +20112,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;
@@ -20148,7 +20160,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 {
@@ -20197,7 +20211,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, []);
@@ -20377,12 +20393,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;
@@ -20510,10 +20521,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)) {
@@ -20648,9 +20656,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;
       }
@@ -20663,9 +20669,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");
@@ -20682,9 +20686,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) {
@@ -20734,9 +20736,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) => {
@@ -20751,41 +20751,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,
@@ -20882,9 +20868,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;
       }
@@ -20968,10 +20952,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(
@@ -21030,10 +21011,7 @@ function estimateJointTailRisk(transformedReturns, tradedMask, tailThreshold) {
           }
         }
       }
-      const minTailObs = getMinTailObservations(
-        tailThreshold,
-        sharedTradingDays
-      );
+      const minTailObs = getMinTailObservations(tailThreshold, sharedTradingDays);
       if (iInTailAndBothTraded < minTailObs) {
         row.push(NaN);
         insufficientPairs++;
@@ -21104,10 +21082,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;
@@ -21303,7 +21278,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");
@@ -21439,6 +21416,262 @@ var DAY_MS = 24 * 60 * 60 * 1e3;
 // ../lib/calculations/walk-forward-degradation.ts
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 
+// ../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, percentile = 0.95) {
+  if (holdingPeriodsTradingDays.length === 0) return 1;
+  const sorted = [...holdingPeriodsTradingDays].sort((a, b) => a - b);
+  return Math.max(1, Math.round(percentileOf(sorted, percentile)));
+}
+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 = {
@@ -21467,9 +21700,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,
@@ -21509,9 +21748,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
@@ -21654,6 +21893,8 @@ export {
   PortfolioStatsCalculator,
   calculateCorrelationMatrix,
   performTailRiskAnalysis,
+  holdingPeriodBlockDays,
+  pairedBlockBootstrap,
   REPORTING_TRADE_COLUMN_ALIASES,
   isTatFormat,
   convertTatRowToReportingTrade
@@ -21669,4 +21910,4 @@ decimal.js/decimal.mjs:
    *  MIT Licence
    *)
 */
-//# sourceMappingURL=chunk-QTTR7AAW.js.map
+//# sourceMappingURL=chunk-2I3S2ZLT.js.map