tradeblocks-mcp 4.3.0 → 4.4.0

package/dist/{sync-EW33QZPD.js → sync-P6QUZFSF.js}

@@ -8,7 +8,7 @@ import {
   syncAllBlocks,
   syncBlock,
   upsertSyncMetadata
-} from "./chunk-TLX7IBCM.js";
+} from "./chunk-CZNPQ574.js";
 import "./chunk-D4AWELQU.js";
 import "./chunk-IW75IC6I.js";
 import "./chunk-ZSVYX5PP.js";
@@ -26,4 +26,4 @@ export {
   syncBlock,
   upsertSyncMetadata
 };
-//# sourceMappingURL=sync-EW33QZPD.js.map
+//# sourceMappingURL=sync-P6QUZFSF.js.map

package/dist/test-exports.js

@@ -131,7 +131,7 @@ import {
   writeParquetPartition,
   writeQuoteMinutesPartition,
   writeSpotPartition
-} from "./chunk-TLX7IBCM.js";
+} from "./chunk-CZNPQ574.js";
 import "./chunk-D4AWELQU.js";
 import "./chunk-IW75IC6I.js";
 import "./chunk-ZSVYX5PP.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tradeblocks-mcp",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "MCP server for options trade analysis",
   "author": "David Romeo <davidmromeo@gmail.com>",
   "type": "module",

package/server/{chunk-YIWLVX7Z.js → chunk-5JTQEV7P.js}

@@ -3717,7 +3717,7 @@ async function openReadWriteConnection(dbPath, threads, memoryLimit) {
   await createMarketParquetViews(connection, dataRoot);
   await ensureMarketDataTables(connection);
   try {
-    const blocksDir = (await import("./sync-2POG6KA6.js")).getBlocksDir(dataRoot);
+    const blocksDir = (await import("./sync-336543PJ.js")).getBlocksDir(dataRoot);
     await migrateMetadataToJson(connection, dataRoot, blocksDir);
   } catch (err) {
     console.warn(
@@ -21776,254 +21776,6 @@ function pearsonCorrelation(x, y) {
   return result;
 }
 
-// ../lib/calculations/field-analysis.ts
-function getNumericTradeFieldValue(trade, field) {
-  if (typeof field !== "string") return null;
-  let value;
-  if (field.startsWith("custom.")) value = trade.customFields?.[field.slice(7)];
-  else if (field.startsWith("daily.")) value = trade.dailyCustomFields?.[field.slice(6)];
-  else if (field.includes(".")) {
-    const dot2 = field.indexOf(".");
-    value = trade.staticDatasetFields?.[field.slice(0, dot2)]?.[field.slice(dot2 + 1)];
-  } else value = trade[field];
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function percentile2(sorted, p) {
-  const index = p / 100 * (sorted.length - 1);
-  const lower = Math.floor(index);
-  const upper = Math.ceil(index);
-  return lower === upper ? sorted[lower] : sorted[lower] + (sorted[upper] - sorted[lower]) * (index - lower);
-}
-function fieldStatisticsFromValues(values, bucketCount = 10) {
-  if (!values.length) return null;
-  const sorted = [...values].sort((a, b) => a - b);
-  const min3 = sorted[0];
-  const max3 = sorted[sorted.length - 1];
-  const sum2 = values.reduce((a, b) => a + b, 0);
-  const avg = sum2 / values.length;
-  const median2 = percentile2(sorted, 50);
-  const stdDev = values.length < 2 ? 0 : Math.sqrt(values.reduce((sum3, value) => sum3 + (value - avg) ** 2, 0) / (values.length - 1));
-  const percentiles = {
-    p5: percentile2(sorted, 5),
-    p10: percentile2(sorted, 10),
-    p25: percentile2(sorted, 25),
-    p50: median2,
-    p75: percentile2(sorted, 75),
-    p90: percentile2(sorted, 90),
-    p95: percentile2(sorted, 95)
-  };
-  const bucketSize = (max3 - min3) / bucketCount || 1;
-  const histogram = Array.from({ length: bucketCount }, (_, i) => ({
-    min: min3 + i * bucketSize,
-    max: i === bucketCount - 1 ? max3 + 1e-3 : min3 + (i + 1) * bucketSize,
-    count: 0
-  }));
-  for (const value of values) {
-    const index = Math.min(Math.floor((value - min3) / bucketSize), bucketCount - 1);
-    if (histogram[index]) histogram[index].count++;
-  }
-  return {
-    statistics: { count: values.length, min: min3, max: max3, sum: sum2, avg, median: median2, stdDev },
-    percentiles,
-    histogram
-  };
-}
-function rankPredictiveTradeFields(trades, targetField = "pl", minSamples = 30, includeCustomFields = true, additionalFields = []) {
-  const fields = REPORT_FIELDS.filter(
-    (info) => info?.field && info.field !== targetField
-  ).map(({ field, label }) => ({ field, label }));
-  for (const entry of additionalFields) {
-    if (entry.field !== targetField && !fields.some(({ field }) => field === entry.field))
-      fields.push(entry);
-  }
-  if (includeCustomFields) {
-    const names = /* @__PURE__ */ new Set();
-    for (const trade of trades)
-      for (const key of Object.keys(trade.customFields ?? {})) names.add(key);
-    for (const name79 of names) {
-      const field = `custom.${name79}`;
-      if (field !== targetField) fields.push({ field, label: `Custom: ${name79}` });
-    }
-  }
-  const rankedFields = [];
-  const fieldsSkipped = [];
-  for (const { field, label } of fields) {
-    const pairs = [];
-    for (const trade of trades) {
-      const x = getNumericTradeFieldValue(trade, field);
-      const y = getNumericTradeFieldValue(trade, targetField);
-      if (x !== null && y !== null) pairs.push({ x, y });
-    }
-    if (pairs.length < minSamples) {
-      fieldsSkipped.push({
-        field,
-        label,
-        reason: "insufficient_samples",
-        sampleSize: pairs.length
-      });
-      continue;
-    }
-    const xValues = pairs.map((pair) => pair.x);
-    if (Math.min(...xValues) === Math.max(...xValues)) {
-      fieldsSkipped.push({ field, label, reason: "no_variance", sampleSize: pairs.length });
-      continue;
-    }
-    const correlation = pearsonCorrelation(
-      xValues,
-      pairs.map((pair) => pair.y)
-    );
-    const absCorrelation = Math.abs(correlation);
-    rankedFields.push({
-      field,
-      label,
-      correlation: Math.round(correlation * 1e4) / 1e4,
-      absCorrelation: Math.round(absCorrelation * 1e4) / 1e4,
-      sampleSize: pairs.length,
-      direction: correlation >= 0 ? "positive" : "negative"
-    });
-  }
-  rankedFields.sort((a, b) => b.absCorrelation - a.absCorrelation);
-  return {
-    totalFieldsAnalyzed: fields.length,
-    fieldsWithSufficientData: rankedFields.length,
-    rankedFields,
-    fieldsSkipped
-  };
-}
-
-// ../lib/calculations/kelly.ts
-var ZERO_METRICS = {
-  fraction: 0,
-  percent: 0,
-  winRate: 0,
-  payoffRatio: 0,
-  avgWin: 0,
-  avgLoss: 0,
-  hasValidKelly: false
-};
-function hasUnrealisticAbsoluteValues(avgWin, avgLoss, startingCapital) {
-  if (!startingCapital) {
-    return avgWin > 1e7 || avgLoss > 1e7;
-  }
-  return avgWin > startingCapital * 100 || avgLoss > startingCapital * 100;
-}
-function calculateKellyFromReturns(trades) {
-  const winReturns = [];
-  const lossReturns = [];
-  for (const trade of trades) {
-    const pl = trade.pl || 0;
-    const margin = trade.marginReq || 0;
-    if (margin <= 0) continue;
-    const returnPct = pl / margin * 100;
-    if (pl > 0) {
-      winReturns.push(returnPct);
-    } else if (pl < 0) {
-      lossReturns.push(Math.abs(returnPct));
-    }
-  }
-  const totalTrades = winReturns.length + lossReturns.length;
-  const winRate = totalTrades > 0 ? winReturns.length / totalTrades : 0;
-  const avgWinPct = winReturns.length > 0 ? winReturns.reduce((sum2, val) => sum2 + val, 0) / winReturns.length : 0;
-  const avgLossPct = lossReturns.length > 0 ? lossReturns.reduce((sum2, val) => sum2 + val, 0) / lossReturns.length : 0;
-  const hasValidKelly = winReturns.length > 0 && lossReturns.length > 0 && avgLossPct > 0;
-  if (!hasValidKelly) {
-    return {
-      fraction: 0,
-      avgWinPct,
-      avgLossPct,
-      payoffRatio: avgLossPct > 0 ? avgWinPct / avgLossPct : 0,
-      winRate,
-      hasValidKelly: false
-    };
-  }
-  const payoffRatio = avgWinPct / avgLossPct;
-  const lossRate = 1 - winRate;
-  const kellyFraction = (payoffRatio * winRate - lossRate) / payoffRatio;
-  return {
-    fraction: kellyFraction,
-    avgWinPct,
-    avgLossPct,
-    payoffRatio,
-    winRate,
-    hasValidKelly: true
-  };
-}
-function calculateKellyMetrics(trades, startingCapital) {
-  if (trades.length === 0) {
-    return ZERO_METRICS;
-  }
-  const wins = [];
-  const losses = [];
-  for (const trade of trades) {
-    const pl = trade.pl || 0;
-    if (pl > 0) {
-      wins.push(pl);
-    } else if (pl < 0) {
-      losses.push(Math.abs(pl));
-    }
-  }
-  const totalTrades = trades.length;
-  const winRate = wins.length / totalTrades;
-  const avgWin = wins.length > 0 ? wins.reduce((sum2, val) => sum2 + val, 0) / wins.length : 0;
-  const avgLoss = losses.length > 0 ? losses.reduce((sum2, val) => sum2 + val, 0) / losses.length : 0;
-  const hasValidKelly = wins.length > 0 && losses.length > 0 && avgLoss > 0;
-  const unrealistic = hasUnrealisticAbsoluteValues(avgWin, avgLoss, startingCapital);
-  let normalizedMetrics = null;
-  const hasMarginData = trades.some((t) => (t.marginReq || 0) > 0);
-  if (hasMarginData) {
-    normalizedMetrics = calculateKellyFromReturns(trades);
-  }
-  if (!hasValidKelly) {
-    return {
-      fraction: 0,
-      percent: 0,
-      winRate,
-      payoffRatio: avgLoss > 0 ? avgWin / avgLoss : 0,
-      avgWin,
-      avgLoss,
-      hasValidKelly: false,
-      calculationMethod: "absolute",
-      hasUnrealisticValues: unrealistic,
-      avgWinPct: normalizedMetrics?.avgWinPct,
-      avgLossPct: normalizedMetrics?.avgLossPct,
-      normalizedKellyPct: normalizedMetrics?.hasValidKelly ? normalizedMetrics.fraction * 100 : void 0
-    };
-  }
-  const payoffRatio = avgWin / avgLoss;
-  const lossRate = 1 - winRate;
-  const kellyFraction = (payoffRatio * winRate - lossRate) / payoffRatio;
-  const kellyPercent = kellyFraction * 100;
-  return {
-    fraction: kellyFraction,
-    percent: kellyPercent,
-    winRate,
-    payoffRatio,
-    avgWin,
-    avgLoss,
-    hasValidKelly: true,
-    calculationMethod: normalizedMetrics && normalizedMetrics.hasValidKelly ? "percentage" : "absolute",
-    hasUnrealisticValues: unrealistic,
-    avgWinPct: normalizedMetrics?.avgWinPct,
-    avgLossPct: normalizedMetrics?.avgLossPct,
-    normalizedKellyPct: normalizedMetrics?.hasValidKelly ? normalizedMetrics.fraction * 100 : void 0
-  };
-}
-function calculateStrategyKellyMetrics(trades, startingCapital) {
-  const strategyMap = /* @__PURE__ */ new Map();
-  for (const trade of trades) {
-    const strategy = trade.strategy || "Uncategorized";
-    if (!strategyMap.has(strategy)) {
-      strategyMap.set(strategy, []);
-    }
-    strategyMap.get(strategy).push(trade);
-  }
-  const metricsMap = /* @__PURE__ */ new Map();
-  for (const [strategy, strategyTrades] of strategyMap.entries()) {
-    metricsMap.set(strategy, calculateKellyMetrics(strategyTrades, startingCapital));
-  }
-  return metricsMap;
-}
-
 // ../lib/calculations/correlation.ts
 function calculateCorrelationMatrix(trades, options = {}) {
   const {
@@ -22273,6 +22025,288 @@ function calculateCorrelationAnalytics(matrix2, minSamples = 2) {
   };
 }
 
+// ../lib/calculations/field-analysis.ts
+var KENDALL_PAIR_LIMIT = 75e6;
+var KendallPairWorkLimitError = class extends RangeError {
+  pairLimit = KENDALL_PAIR_LIMIT;
+  estimatedPairs;
+  fieldCount;
+  tradeCount;
+  constructor(estimatedPairs, fieldCount, tradeCount) {
+    super(
+      `kendall_pair_work_limit: ${estimatedPairs} estimated pairs exceed ${KENDALL_PAIR_LIMIT}`
+    );
+    this.name = "KendallPairWorkLimitError";
+    this.estimatedPairs = estimatedPairs;
+    this.fieldCount = fieldCount;
+    this.tradeCount = tradeCount;
+  }
+};
+function getNumericTradeFieldValue(trade, field) {
+  if (typeof field !== "string") return null;
+  let value;
+  if (field.startsWith("custom.")) value = trade.customFields?.[field.slice(7)];
+  else if (field.startsWith("daily.")) value = trade.dailyCustomFields?.[field.slice(6)];
+  else if (field.includes(".")) {
+    const dot2 = field.indexOf(".");
+    value = trade.staticDatasetFields?.[field.slice(0, dot2)]?.[field.slice(dot2 + 1)];
+  } else value = trade[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function percentile2(sorted, p) {
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  return lower === upper ? sorted[lower] : sorted[lower] + (sorted[upper] - sorted[lower]) * (index - lower);
+}
+function fieldStatisticsFromValues(values, bucketCount = 10) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const min3 = sorted[0];
+  const max3 = sorted[sorted.length - 1];
+  const sum2 = values.reduce((a, b) => a + b, 0);
+  const avg = sum2 / values.length;
+  const median2 = percentile2(sorted, 50);
+  const stdDev = values.length < 2 ? 0 : Math.sqrt(values.reduce((sum3, value) => sum3 + (value - avg) ** 2, 0) / (values.length - 1));
+  const percentiles = {
+    p5: percentile2(sorted, 5),
+    p10: percentile2(sorted, 10),
+    p25: percentile2(sorted, 25),
+    p50: median2,
+    p75: percentile2(sorted, 75),
+    p90: percentile2(sorted, 90),
+    p95: percentile2(sorted, 95)
+  };
+  const bucketSize = (max3 - min3) / bucketCount || 1;
+  const histogram = Array.from({ length: bucketCount }, (_, i) => ({
+    min: min3 + i * bucketSize,
+    max: i === bucketCount - 1 ? max3 + 1e-3 : min3 + (i + 1) * bucketSize,
+    count: 0
+  }));
+  for (const value of values) {
+    const index = Math.min(Math.floor((value - min3) / bucketSize), bucketCount - 1);
+    if (histogram[index]) histogram[index].count++;
+  }
+  return {
+    statistics: { count: values.length, min: min3, max: max3, sum: sum2, avg, median: median2, stdDev },
+    percentiles,
+    histogram
+  };
+}
+function rankPredictiveTradeFields(trades, targetField = "pl", minSamples = 30, includeCustomFields = true, additionalFields = [], method = "pearson") {
+  const fields = REPORT_FIELDS.filter(
+    (info) => info?.field && info.field !== targetField
+  ).map(({ field, label }) => ({ field, label }));
+  for (const entry of additionalFields) {
+    if (entry.field !== targetField && !fields.some(({ field }) => field === entry.field))
+      fields.push(entry);
+  }
+  if (includeCustomFields) {
+    const names = /* @__PURE__ */ new Set();
+    for (const trade of trades)
+      for (const key of Object.keys(trade.customFields ?? {})) names.add(key);
+    for (const name79 of names) {
+      const field = `custom.${name79}`;
+      if (field !== targetField) fields.push({ field, label: `Custom: ${name79}` });
+    }
+  }
+  if (method === "kendall") {
+    let estimatedPairs = 0;
+    let fieldCount = 0;
+    for (const { field } of fields) {
+      let count = 0;
+      for (const trade of trades) {
+        if (getNumericTradeFieldValue(trade, field) !== null && getNumericTradeFieldValue(trade, targetField) !== null)
+          count++;
+      }
+      if (count >= minSamples) {
+        fieldCount++;
+        estimatedPairs += count * (count - 1) / 2;
+      }
+    }
+    if (estimatedPairs > KENDALL_PAIR_LIMIT)
+      throw new KendallPairWorkLimitError(estimatedPairs, fieldCount, trades.length);
+  }
+  const rankedFields = [];
+  const fieldsSkipped = [];
+  for (const { field, label } of fields) {
+    const pairs = [];
+    for (const trade of trades) {
+      const x = getNumericTradeFieldValue(trade, field);
+      const y = getNumericTradeFieldValue(trade, targetField);
+      if (x !== null && y !== null) pairs.push({ x, y });
+    }
+    if (pairs.length < minSamples) {
+      fieldsSkipped.push({
+        field,
+        label,
+        reason: "insufficient_samples",
+        sampleSize: pairs.length
+      });
+      continue;
+    }
+    const xValues = pairs.map((pair) => pair.x);
+    if (Math.min(...xValues) === Math.max(...xValues)) {
+      fieldsSkipped.push({ field, label, reason: "no_variance", sampleSize: pairs.length });
+      continue;
+    }
+    const correlate = method === "spearman" ? spearmanCorrelation : method === "kendall" ? kendallTau : pearsonCorrelation;
+    const correlation = correlate(
+      xValues,
+      pairs.map((pair) => pair.y)
+    );
+    const absCorrelation = Math.abs(correlation);
+    rankedFields.push({
+      field,
+      label,
+      correlation: Math.round(correlation * 1e4) / 1e4,
+      absCorrelation: Math.round(absCorrelation * 1e4) / 1e4,
+      sampleSize: pairs.length,
+      direction: correlation >= 0 ? "positive" : "negative"
+    });
+  }
+  rankedFields.sort((a, b) => b.absCorrelation - a.absCorrelation);
+  return {
+    totalFieldsAnalyzed: fields.length,
+    fieldsWithSufficientData: rankedFields.length,
+    rankedFields,
+    fieldsSkipped
+  };
+}
+
+// ../lib/calculations/kelly.ts
+var ZERO_METRICS = {
+  fraction: 0,
+  percent: 0,
+  winRate: 0,
+  payoffRatio: 0,
+  avgWin: 0,
+  avgLoss: 0,
+  hasValidKelly: false
+};
+function hasUnrealisticAbsoluteValues(avgWin, avgLoss, startingCapital) {
+  if (!startingCapital) {
+    return avgWin > 1e7 || avgLoss > 1e7;
+  }
+  return avgWin > startingCapital * 100 || avgLoss > startingCapital * 100;
+}
+function calculateKellyFromReturns(trades) {
+  const winReturns = [];
+  const lossReturns = [];
+  for (const trade of trades) {
+    const pl = trade.pl || 0;
+    const margin = trade.marginReq || 0;
+    if (margin <= 0) continue;
+    const returnPct = pl / margin * 100;
+    if (pl > 0) {
+      winReturns.push(returnPct);
+    } else if (pl < 0) {
+      lossReturns.push(Math.abs(returnPct));
+    }
+  }
+  const totalTrades = winReturns.length + lossReturns.length;
+  const winRate = totalTrades > 0 ? winReturns.length / totalTrades : 0;
+  const avgWinPct = winReturns.length > 0 ? winReturns.reduce((sum2, val) => sum2 + val, 0) / winReturns.length : 0;
+  const avgLossPct = lossReturns.length > 0 ? lossReturns.reduce((sum2, val) => sum2 + val, 0) / lossReturns.length : 0;
+  const hasValidKelly = winReturns.length > 0 && lossReturns.length > 0 && avgLossPct > 0;
+  if (!hasValidKelly) {
+    return {
+      fraction: 0,
+      avgWinPct,
+      avgLossPct,
+      payoffRatio: avgLossPct > 0 ? avgWinPct / avgLossPct : 0,
+      winRate,
+      hasValidKelly: false
+    };
+  }
+  const payoffRatio = avgWinPct / avgLossPct;
+  const lossRate = 1 - winRate;
+  const kellyFraction = (payoffRatio * winRate - lossRate) / payoffRatio;
+  return {
+    fraction: kellyFraction,
+    avgWinPct,
+    avgLossPct,
+    payoffRatio,
+    winRate,
+    hasValidKelly: true
+  };
+}
+function calculateKellyMetrics(trades, startingCapital) {
+  if (trades.length === 0) {
+    return ZERO_METRICS;
+  }
+  const wins = [];
+  const losses = [];
+  for (const trade of trades) {
+    const pl = trade.pl || 0;
+    if (pl > 0) {
+      wins.push(pl);
+    } else if (pl < 0) {
+      losses.push(Math.abs(pl));
+    }
+  }
+  const totalTrades = trades.length;
+  const winRate = wins.length / totalTrades;
+  const avgWin = wins.length > 0 ? wins.reduce((sum2, val) => sum2 + val, 0) / wins.length : 0;
+  const avgLoss = losses.length > 0 ? losses.reduce((sum2, val) => sum2 + val, 0) / losses.length : 0;
+  const hasValidKelly = wins.length > 0 && losses.length > 0 && avgLoss > 0;
+  const unrealistic = hasUnrealisticAbsoluteValues(avgWin, avgLoss, startingCapital);
+  let normalizedMetrics = null;
+  const hasMarginData = trades.some((t) => (t.marginReq || 0) > 0);
+  if (hasMarginData) {
+    normalizedMetrics = calculateKellyFromReturns(trades);
+  }
+  if (!hasValidKelly) {
+    return {
+      fraction: 0,
+      percent: 0,
+      winRate,
+      payoffRatio: avgLoss > 0 ? avgWin / avgLoss : 0,
+      avgWin,
+      avgLoss,
+      hasValidKelly: false,
+      calculationMethod: "absolute",
+      hasUnrealisticValues: unrealistic,
+      avgWinPct: normalizedMetrics?.avgWinPct,
+      avgLossPct: normalizedMetrics?.avgLossPct,
+      normalizedKellyPct: normalizedMetrics?.hasValidKelly ? normalizedMetrics.fraction * 100 : void 0
+    };
+  }
+  const payoffRatio = avgWin / avgLoss;
+  const lossRate = 1 - winRate;
+  const kellyFraction = (payoffRatio * winRate - lossRate) / payoffRatio;
+  const kellyPercent = kellyFraction * 100;
+  return {
+    fraction: kellyFraction,
+    percent: kellyPercent,
+    winRate,
+    payoffRatio,
+    avgWin,
+    avgLoss,
+    hasValidKelly: true,
+    calculationMethod: normalizedMetrics && normalizedMetrics.hasValidKelly ? "percentage" : "absolute",
+    hasUnrealisticValues: unrealistic,
+    avgWinPct: normalizedMetrics?.avgWinPct,
+    avgLossPct: normalizedMetrics?.avgLossPct,
+    normalizedKellyPct: normalizedMetrics?.hasValidKelly ? normalizedMetrics.fraction * 100 : void 0
+  };
+}
+function calculateStrategyKellyMetrics(trades, startingCapital) {
+  const strategyMap = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    const strategy = trade.strategy || "Uncategorized";
+    if (!strategyMap.has(strategy)) {
+      strategyMap.set(strategy, []);
+    }
+    strategyMap.get(strategy).push(trade);
+  }
+  const metricsMap = /* @__PURE__ */ new Map();
+  for (const [strategy, strategyTrades] of strategyMap.entries()) {
+    metricsMap.set(strategy, calculateKellyMetrics(strategyTrades, startingCapital));
+  }
+  return metricsMap;
+}
+
 // ../lib/calculations/tail-risk-analysis.ts
 var HIGH_DEPENDENCE_THRESHOLD = 0.5;
 var CONCENTRATION_WEIGHT = 0.5;
@@ -26062,6 +26096,25 @@ function pairedBlockBootstrap(input) {
   };
 }
 
+// ../lib/calculations/holm-adjust.ts
+function holmAdjust(pValues) {
+  const ranked = pValues.map((pValue, index) => {
+    if (!Number.isFinite(pValue) || pValue < 0 || pValue > 1) {
+      throw new RangeError(`pValues[${index}] must be a finite number in [0, 1]`);
+    }
+    return { pValue, index };
+  });
+  ranked.sort((a, b) => a.pValue - b.pValue || a.index - b.index);
+  const adjusted = new Array(pValues.length);
+  let running = 0;
+  for (let rank = 0; rank < ranked.length; rank++) {
+    const { pValue, index } = ranked[rank];
+    running = Math.max(running, Math.min(1, (ranked.length - rank) * pValue));
+    adjusted[index] = running;
+  }
+  return adjusted;
+}
+
 // ../lib/processing/tat-adapter.ts
 var TAT_SIGNATURE_HEADERS = ["tradeid", "profitloss", "buyingpower"];
 function isTatFormat(headers) {
@@ -27896,13 +27949,14 @@ export {
   getRanks,
   kendallTau,
   pearsonCorrelation,
+  calculateCorrelationMatrix,
+  calculateCorrelationAnalytics,
+  KendallPairWorkLimitError,
   getNumericTradeFieldValue,
   fieldStatisticsFromValues,
   rankPredictiveTradeFields,
   calculateKellyMetrics,
   calculateStrategyKellyMetrics,
-  calculateCorrelationMatrix,
-  calculateCorrelationAnalytics,
   performTailRiskAnalysis,
   singleTapeWalkForwardByTrades,
   STRESS_SCENARIOS,
@@ -27917,6 +27971,7 @@ export {
   synthesizeEdgeDecay,
   holdingPeriodBlockDays,
   pairedBlockBootstrap,
+  holmAdjust,
   processStaticDatasetContent,
   validateDatasetName,
   canonicalJson,
@@ -28002,4 +28057,4 @@ decimal.js/decimal.mjs:
    *  MIT Licence
    *)
 */
-//# sourceMappingURL=chunk-YIWLVX7Z.js.map
+//# sourceMappingURL=chunk-5JTQEV7P.js.map