tradeblocks-mcp 3.0.3 → 3.3.1

package/dist/trade-processor-DKDCWGKD.js

@@ -0,0 +1,9 @@
+import {
+  TradeProcessor
+} from "./chunk-WNTYA7ER.js";
+import "./chunk-YZA4RS76.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  TradeProcessor
+};
+//# sourceMappingURL=trade-processor-DKDCWGKD.js.map

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "tradeblocks-mcp",
-  "version": "3.0.3",
+  "version": "3.3.1",
   "description": "MCP server for options trade analysis",
   "author": "David Romeo <davidmromeo@gmail.com>",
   "type": "module",
-  "main": "dist/skill-installer.js",
   "bin": {
     "tradeblocks-mcp": "server/index.js"
   },
@@ -130,7 +129,6 @@
     "dev": "tsup --watch",
     "test": "NODE_OPTIONS='--experimental-vm-modules' jest",
     "verify:exports": "node scripts/verify-exports-surface.mjs",
-    "mcpb:pack": "npm run build && node scripts/pack-mcpb.js",
     "pack:beta": "npm run build && npm pack --pack-destination .",
     "prepublishOnly": "npm run build"
   },
@@ -151,7 +149,6 @@
     "@types/express": "^5.0.6",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.9.3",
-    "archiver": "^7.0.1",
     "esbuild": "^0.27.2",
     "jest": "^30.3.0",
     "ts-jest": "^29.4.9",
@@ -165,8 +162,7 @@
     "server",
     "dist",
     "src",
-    "agent-skills",
-    "manifest.json"
+    "agent-skills"
   ],
   "keywords": [
     "mcp",

package/server/{chunk-YUCOAJ4Z.js → chunk-536NSFED.js}

@@ -5,7 +5,7 @@ import {
   normalizeHeaders,
   rawTradeDataSchema,
   tradeSchema
-} from "./chunk-OBYKFW2B.js";
+} from "./chunk-SY6GDNVI.js";
 
 // ../lib/models/trade.ts
 var TRADE_COLUMN_MAPPING = {
@@ -404,4 +404,4 @@ var TradeProcessor = class {
 export {
   TradeProcessor
 };
-//# sourceMappingURL=chunk-YUCOAJ4Z.js.map
+//# sourceMappingURL=chunk-536NSFED.js.map

package/server/{chunk-GH2552SE.js → chunk-A3UKD64A.js}

@@ -4,7 +4,7 @@ import {
   dailyLogEntrySchema,
   findMissingHeaders,
   rawDailyLogDataSchema
-} from "./chunk-OBYKFW2B.js";
+} from "./chunk-SY6GDNVI.js";
 
 // ../lib/models/daily-log.ts
 var DAILY_LOG_COLUMN_MAPPING = {
@@ -327,4 +327,4 @@ var DailyLogProcessor = class {
 export {
   DailyLogProcessor
 };
-//# sourceMappingURL=chunk-GH2552SE.js.map
+//# sourceMappingURL=chunk-A3UKD64A.js.map

package/server/{chunk-ZBJCF4ZG.js → chunk-OMUDNJBJ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getSofrRateByKey
-} from "./chunk-BOPHW5M6.js";
+} from "./chunk-RJDJHZ5Y.js";
 import {
   loadMddsProtoRoot
 } from "./chunk-T66KH2XH.js";
@@ -3041,4 +3041,4 @@ export {
   getProvider,
   _resetProvider
 };
-//# sourceMappingURL=chunk-ZBJCF4ZG.js.map
+//# sourceMappingURL=chunk-OMUDNJBJ.js.map

package/server/{chunk-BOPHW5M6.js → chunk-RJDJHZ5Y.js}

@@ -23985,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();
@@ -23994,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;
@@ -24056,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 };
 }
@@ -24210,6 +24256,13 @@ 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");
   }
@@ -24373,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,
@@ -25431,6 +25486,262 @@ var REPORT_FIELDS = [
   }
 ];
 
+// ../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 = {
@@ -25679,6 +25990,8 @@ export {
   matchTrades,
   analyzeLiveAlignment,
   synthesizeEdgeDecay,
+  holdingPeriodBlockDays,
+  pairedBlockBootstrap,
   REPORTING_TRADE_COLUMN_ALIASES,
   isTatFormat,
   convertTatRowToReportingTrade,
@@ -25695,4 +26008,4 @@ decimal.js/decimal.mjs:
    *  MIT Licence
    *)
 */
-//# sourceMappingURL=chunk-BOPHW5M6.js.map
+//# sourceMappingURL=chunk-RJDJHZ5Y.js.map