@tradejs/core 1.0.8 → 1.0.10

package/dist/backtest.js

@@ -30,27 +30,45 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/backtest.ts
 var backtest_exports = {};
 __export(backtest_exports, {
+  calculateAdvancedTradeMetrics: () => calculateAdvancedTradeMetrics,
   calculateMaxDrawdown: () => calculateMaxDrawdown,
   calculateStatsFull: () => calculateStatsFull,
   classifyMetric: () => classifyMetric,
   compactOrderLog: () => compactOrderLog,
-  createTestSuite: () => createTestSuite,
-  generateName: () => generateName,
-  generateParamGrid: () => generateParamGrid,
   getBacktestScore: () => getBacktestScore,
   getFormatted: () => getFormatted,
   getTimeline: () => getTimeline,
-  mergeConfigs: () => mergeConfigs,
   parseTestName: () => parseTestName,
   sortBestTests: () => sortBestTests
 });
 module.exports = __toCommonJS(backtest_exports);
 
-// src/utils/grid.ts
-var import_lodash = __toESM(require("lodash"));
+// src/utils/tests.ts
+var parseTestName = (testName) => {
+  const [symbol, testSuiteId, testId] = testName.split("_");
+  return { symbol, testSuiteId, testId };
+};
+
+// src/utils/stat.ts
+var import_date_fns = require("date-fns");
 
 // src/constants/index.ts
+var BACKTEST_EXECUTION_DELAY_MS = 5 * 6e4;
 var BACKTEST_DEFAULT_DAYS = 160;
+var DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS = [
+  "BTCUSDT",
+  "ETHUSDT"
+];
+var DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS = [
+  "BNBUSDT",
+  "SOLUSDT",
+  "TRXUSDT",
+  "XRPUSDT"
+];
+var DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS = [
+  ...DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS,
+  ...DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS
+];
 var TestThresholdsConfig = {
   // Период и частота — используем как требования к качеству теста, в скоринг не влияют
   periodDays: {
@@ -109,9 +127,10 @@ var TestThresholdsConfig = {
     precision: 2
   },
   netProfit: {
-    thresholds: [5, 20],
+    thresholds: [0, 0],
     direction: "higher",
     isAmount: true,
+    neutralValue: 0,
     precision: 2
   },
   totalReturn: {
@@ -179,135 +198,8 @@ var TestThresholdsConfig = {
   }
 };
 
-// src/utils/timestamp.ts
-var import_date_fns = require("date-fns");
-var import_date_fns2 = require("date-fns");
-var TIMELINE_STEP = 864e5;
-var getTimestamp = (days = 0) => {
-  if (days > 0) {
-    return (0, import_date_fns2.getUnixTime)((0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), days)) * 1e3;
-  }
-  return (0, import_date_fns2.getUnixTime)(/* @__PURE__ */ new Date()) * 1e3;
-};
-var getTimeline = (start = getTimestamp(BACKTEST_DEFAULT_DAYS), end = getTimestamp(), step = TIMELINE_STEP) => {
-  const res = new Array();
-  for (let ind = start; ind <= end; ind += step) {
-    res.push(ind);
-  }
-  return res;
-};
-var compactOrderLog = (timeline, orderLog) => {
-  const result = [];
-  let currentAmount = orderLog.length > 0 && orderLog[0].amount != null ? orderLog[0].amount : 100;
-  let orderLogCursor = 0;
-  for (let timelineIndex = 0; timelineIndex < timeline.length; timelineIndex++) {
-    const currentTimestamp = timeline[timelineIndex];
-    let lastApplicableOrderIndex = -1;
-    let nextCursor = orderLogCursor;
-    for (let checkIndex = orderLogCursor; checkIndex < orderLog.length; checkIndex++) {
-      const checkOrder = orderLog[checkIndex];
-      if (checkOrder.timestamp <= currentTimestamp) {
-        lastApplicableOrderIndex = checkIndex;
-        nextCursor = checkIndex + 1;
-      } else {
-        break;
-      }
-    }
-    if (lastApplicableOrderIndex !== -1) {
-      currentAmount = orderLog[lastApplicableOrderIndex].amount;
-      orderLogCursor = nextCursor;
-    }
-    result.push([currentTimestamp, currentAmount]);
-  }
-  return result;
-};
-
-// src/utils/uuid.ts
-var import_node_crypto = require("crypto");
-var uuid = (len = 12) => {
-  const uuid2 = (0, import_node_crypto.randomUUID)();
-  return uuid2.slice(-len);
-};
-
-// src/utils/grid.ts
-var generateParamGrid = (paramOptions) => {
-  const keys = Object.keys(paramOptions);
-  const combinations = [];
-  const helper = (index = 0, current = {}) => {
-    if (index === keys.length) {
-      combinations.push(current);
-      return;
-    }
-    const key = keys[index];
-    for (const value of paramOptions[key] || []) {
-      const copiedValue = typeof value === "object" && value !== null ? structuredClone(value) : value;
-      helper(index + 1, {
-        ...current,
-        [key]: copiedValue
-      });
-    }
-  };
-  helper();
-  return combinations;
-};
-var generateName = (prefix) => `${prefix}_${uuid(6)}`;
-var mergeConfigs = (configs) => {
-  const result = {};
-  for (const config of configs) {
-    for (const [key, value] of Object.entries(config)) {
-      if (!result[key]) {
-        result[key] = [];
-      }
-      const clonedValue = typeof value === "object" && value !== null ? import_lodash.default.cloneDeep(value) : value;
-      const isDuplicate = result[key].some(
-        (existing) => import_lodash.default.isEqual(existing, value)
-      );
-      if (!isDuplicate) {
-        result[key].push(clonedValue);
-      }
-    }
-  }
-  for (const key in result) {
-    if (result[key].every((v) => typeof v === "number")) {
-      result[key] = import_lodash.default.sortBy(result[key]);
-    }
-  }
-  return result;
-};
-var createTestSuite = (userName, tickers, strategyName, backtestConfig, connectorName) => {
-  const start = getTimestamp(BACKTEST_DEFAULT_DAYS);
-  const end = getTimestamp();
-  const testSuiteId = uuid(6);
-  const paramGrid = generateParamGrid(backtestConfig);
-  return tickers.flatMap(
-    (symbol) => paramGrid.map((params) => {
-      const testId = uuid(6);
-      return {
-        userName,
-        name: `${symbol}_${testSuiteId}_${testId}`,
-        testId,
-        testSuiteId,
-        symbol,
-        options: { start, end },
-        strategyName,
-        strategyConfig: params,
-        connectorName
-      };
-    })
-  );
-};
-
-// src/utils/tests.ts
-var parseTestName = (testName) => {
-  const [symbol, testSuiteId, testId] = testName.split("_");
-  return { symbol, testSuiteId, testId };
-};
-
-// src/utils/stat.ts
-var import_date_fns3 = require("date-fns");
-
 // src/utils/math.ts
-var import_lodash2 = __toESM(require("lodash"));
+var import_lodash = __toESM(require("lodash"));
 var round = (value, precision = 2) => precision > 0 ? Math.round(value * 10 ** precision) / 10 ** precision : Math.round(value);
 var sum = (xs) => xs.reduce((a, b) => a + b, 0);
 var mean = (xs) => xs.length ? sum(xs) / xs.length : 0;
@@ -351,6 +243,412 @@ var calculateMaxDrawdown = (amounts) => {
   }
   return maxDrawdown;
 };
+var MS_IN_DAY = 24 * 60 * 60 * 1e3;
+var DAYS_IN_YEAR = 365;
+var isFiniteMetric = (value) => typeof value === "number" && Number.isFinite(value);
+var safeRatio = (numerator, denominator) => {
+  if (!isFiniteMetric(numerator) || !isFiniteMetric(denominator)) {
+    return null;
+  }
+  if (Math.abs(denominator) <= Number.EPSILON) {
+    return null;
+  }
+  return numerator / denominator;
+};
+var percentile = (values, p) => {
+  if (!values.length) {
+    return null;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = (sorted.length - 1) * p;
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) {
+    return sorted[lower];
+  }
+  const weight = index - lower;
+  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+};
+var medianValue = (values) => percentile(values, 0.5);
+var getMonthKey = (timestamp) => {
+  const date = new Date(timestamp);
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}`;
+};
+var getQuarterKey = (timestamp) => {
+  const date = new Date(timestamp);
+  return `${date.getUTCFullYear()} Q${Math.floor(date.getUTCMonth() / 3) + 1}`;
+};
+var resolveTradeSession = (timestamp) => {
+  const hour = new Date(timestamp).getUTCHours();
+  if (hour < 8) {
+    return "Asia";
+  }
+  if (hour < 16) {
+    return "Europe";
+  }
+  return "US";
+};
+var getDateKey = (timestamp) => {
+  const date = new Date(timestamp);
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
+};
+var calculateDrawdownStats = (trades, orderLog) => {
+  const explicitPoints = (orderLog ?? []).map((point) => ({ timestamp: point[0], amount: point[1] })).filter(
+    (point) => isFiniteMetric(point.timestamp) && isFiniteMetric(point.amount)
+  ).sort((a, b) => a.timestamp - b.timestamp);
+  const points = explicitPoints.length ? explicitPoints : trades.slice().sort((a, b) => a.timestamp - b.timestamp).reduce(
+    (acc, trade) => {
+      const previous = acc[acc.length - 1]?.amount ?? 0;
+      acc.push({
+        timestamp: trade.timestamp,
+        amount: previous + trade.pnl
+      });
+      return acc;
+    },
+    [{ timestamp: trades[0]?.timestamp ?? 0, amount: 0 }]
+  );
+  if (!points.length) {
+    return { absolute: null, percent: null };
+  }
+  let peak = points[0].amount;
+  let maxAbsolute = 0;
+  let maxPercent = 0;
+  for (const point of points) {
+    if (point.amount > peak) {
+      peak = point.amount;
+    }
+    const absolute = peak - point.amount;
+    maxAbsolute = Math.max(maxAbsolute, absolute);
+    if (peak > 0) {
+      maxPercent = Math.max(maxPercent, absolute / peak * 100);
+    }
+  }
+  return { absolute: maxAbsolute, percent: maxPercent };
+};
+var calculateWorstRollingPnl = (trades, days) => {
+  if (!trades.length) {
+    return null;
+  }
+  const sorted = trades.slice().sort((a, b) => a.timestamp - b.timestamp);
+  const windowMs = days * MS_IN_DAY;
+  let start = 0;
+  let rollingPnl = 0;
+  let worstPnl = 0;
+  for (let end = 0; end < sorted.length; end += 1) {
+    rollingPnl += sorted[end].pnl;
+    while (start <= end && sorted[end].timestamp - sorted[start].timestamp > windowMs) {
+      rollingPnl -= sorted[start].pnl;
+      start += 1;
+    }
+    worstPnl = Math.min(worstPnl, rollingPnl);
+  }
+  return worstPnl;
+};
+var calculateLossStreak = (trades) => {
+  let current = 0;
+  let max = 0;
+  for (const trade of trades.slice().sort((a, b) => a.timestamp - b.timestamp)) {
+    if (trade.pnl < 0) {
+      current += 1;
+      max = Math.max(max, current);
+      continue;
+    }
+    current = 0;
+  }
+  return max;
+};
+var normalizeExitReason = (reason) => {
+  const normalized = String(reason ?? "").trim().toLowerCase();
+  if (normalized === "tp" || normalized === "take_profit") {
+    return "takeProfit";
+  }
+  if (normalized === "sl" || normalized === "stop_loss") {
+    return "stopLoss";
+  }
+  if (normalized === "exit" || normalized === "close" || normalized === "closed") {
+    return "exit";
+  }
+  return "unknown";
+};
+var calculateExitBreakdown = (trades) => {
+  const counts = {
+    takeProfit: 0,
+    stopLoss: 0,
+    exit: 0,
+    unknown: 0
+  };
+  for (const trade of trades) {
+    counts[normalizeExitReason(trade.exitReason)] += 1;
+  }
+  const total = trades.length;
+  const bucket = (count) => ({
+    count,
+    share: total ? count / total * 100 : null
+  });
+  return {
+    takeProfit: bucket(counts.takeProfit),
+    stopLoss: bucket(counts.stopLoss),
+    exit: bucket(counts.exit),
+    unknown: bucket(counts.unknown)
+  };
+};
+var calculateDailyPnlSeries = (trades, startTimestamp, endTimestamp) => {
+  const approvedTrades = trades.filter((trade) => trade.approved !== false);
+  if (!approvedTrades.length) {
+    return [];
+  }
+  const firstTimestamp = startTimestamp ?? Math.min(...approvedTrades.map((trade) => trade.timestamp));
+  const lastTimestamp = endTimestamp ?? Math.max(...approvedTrades.map((trade) => trade.timestamp));
+  if (!isFiniteMetric(firstTimestamp) || !isFiniteMetric(lastTimestamp) || lastTimestamp < firstTimestamp) {
+    return [];
+  }
+  const startDate = Date.UTC(
+    new Date(firstTimestamp).getUTCFullYear(),
+    new Date(firstTimestamp).getUTCMonth(),
+    new Date(firstTimestamp).getUTCDate()
+  );
+  const endDate = Date.UTC(
+    new Date(lastTimestamp).getUTCFullYear(),
+    new Date(lastTimestamp).getUTCMonth(),
+    new Date(lastTimestamp).getUTCDate()
+  );
+  const daily = /* @__PURE__ */ new Map();
+  for (let ts = startDate; ts <= endDate; ts += MS_IN_DAY) {
+    daily.set(getDateKey(ts), 0);
+  }
+  for (const trade of approvedTrades) {
+    const key = getDateKey(trade.timestamp);
+    daily.set(key, (daily.get(key) ?? 0) + trade.pnl);
+  }
+  return [...daily.values()];
+};
+var calculateStd = (values, valueMean) => {
+  if (!values.length) {
+    return 0;
+  }
+  return Math.sqrt(
+    values.reduce((acc, value) => acc + (value - valueMean) ** 2, 0) / values.length
+  );
+};
+var calculateSkewness = (values) => {
+  if (values.length < 3) {
+    return null;
+  }
+  const valueMean = mean(values);
+  const std = calculateStd(values, valueMean);
+  if (std <= Number.EPSILON) {
+    return null;
+  }
+  return values.reduce((acc, value) => acc + ((value - valueMean) / std) ** 3, 0) / values.length;
+};
+var sumTopPositiveProfitShare = (pnls, count) => {
+  const grossProfit = pnls.filter((pnl) => pnl > 0).reduce((acc, pnl) => acc + pnl, 0);
+  if (grossProfit <= 0) {
+    return null;
+  }
+  const topProfit = pnls.filter((pnl) => pnl > 0).sort((a, b) => b - a).slice(0, count).reduce((acc, pnl) => acc + pnl, 0);
+  return topProfit / grossProfit * 100;
+};
+var concentrationPercent = (items, limit) => {
+  const totals = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    totals.set(item.key, (totals.get(item.key) ?? 0) + Math.abs(item.pnl));
+  }
+  const totalAbsPnl = [...totals.values()].reduce(
+    (acc, value) => acc + value,
+    0
+  );
+  if (totalAbsPnl <= 0) {
+    return null;
+  }
+  const topAbsPnl = [...totals.values()].sort((a, b) => b - a).slice(0, limit).reduce((acc, value) => acc + value, 0);
+  return topAbsPnl / totalAbsPnl * 100;
+};
+var calculateAdvancedTradeMetrics = ({
+  trades,
+  orderLog,
+  startTimestamp,
+  endTimestamp
+}) => {
+  const normalizedTrades = trades.filter(
+    (trade) => isFiniteMetric(trade.timestamp) && isFiniteMetric(trade.pnl) && trade.timestamp > 0
+  ).sort((a, b) => a.timestamp - b.timestamp);
+  const pnls = normalizedTrades.map((trade) => trade.pnl);
+  const wins = pnls.filter((pnl) => pnl > 0).length;
+  const losses = pnls.filter((pnl) => pnl < 0).length;
+  const totalPnl = sum(pnls);
+  const grossProfit = pnls.filter((pnl) => pnl > 0).reduce((acc, pnl) => acc + pnl, 0);
+  const grossLoss = Math.abs(
+    pnls.filter((pnl) => pnl < 0).reduce((acc, pnl) => acc + pnl, 0)
+  );
+  const avgWin = wins ? grossProfit / wins : null;
+  const avgLoss = losses ? grossLoss / losses : null;
+  const firstTimestamp = startTimestamp ?? normalizedTrades[0]?.timestamp ?? null;
+  const lastTimestamp = endTimestamp ?? normalizedTrades[normalizedTrades.length - 1]?.timestamp ?? null;
+  const periodDays = isFiniteMetric(firstTimestamp) && isFiniteMetric(lastTimestamp) && lastTimestamp > firstTimestamp ? (lastTimestamp - firstTimestamp) / MS_IN_DAY : null;
+  const drawdown = calculateDrawdownStats(normalizedTrades, orderLog);
+  const monthly = /* @__PURE__ */ new Map();
+  const quarterly = /* @__PURE__ */ new Map();
+  for (const trade of normalizedTrades) {
+    const monthKey = getMonthKey(trade.timestamp);
+    const quarterKey = getQuarterKey(trade.timestamp);
+    const month = monthly.get(monthKey) ?? {
+      pnl: 0,
+      orders: 0,
+      wins: 0,
+      timestamp: trade.timestamp
+    };
+    month.pnl += trade.pnl;
+    month.orders += 1;
+    month.wins += trade.pnl > 0 ? 1 : 0;
+    month.timestamp = Math.min(month.timestamp, trade.timestamp);
+    monthly.set(monthKey, month);
+    quarterly.set(quarterKey, (quarterly.get(quarterKey) ?? 0) + trade.pnl);
+  }
+  const monthlyStats = [...monthly.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const monthlyPnls = monthlyStats.map(([, stat]) => stat.pnl);
+  const monthlyWinRates = monthlyStats.map(
+    ([, stat]) => stat.orders ? stat.wins / stat.orders * 100 : 0
+  );
+  const positiveMonths = monthlyStats.filter(([, stat]) => stat.pnl > 0).length;
+  const p25Monthly = percentile(monthlyPnls, 0.25);
+  const p75Monthly = percentile(monthlyPnls, 0.75);
+  const dailyPnls = calculateDailyPnlSeries(
+    normalizedTrades,
+    startTimestamp,
+    endTimestamp
+  );
+  const dailyMean = dailyPnls.length ? mean(dailyPnls) : null;
+  const dailyStd = dailyMean === null ? null : calculateStd(dailyPnls, dailyMean);
+  const downsideDailyPnls = dailyPnls.map((pnl) => Math.min(pnl, 0));
+  const downsideStd = downsideDailyPnls.some((pnl) => pnl < 0) ? Math.sqrt(
+    downsideDailyPnls.reduce((acc, pnl) => acc + pnl ** 2, 0) / downsideDailyPnls.length
+  ) : null;
+  const annualizedPnl = dailyMean === null ? null : dailyMean * DAYS_IN_YEAR;
+  const approvedFlags = normalizedTrades.filter(
+    (trade) => typeof trade.approved === "boolean"
+  );
+  const slippageCosts = normalizedTrades.map((trade) => trade.slippageCost).filter(isFiniteMetric);
+  const pnlBeforeSlippage = normalizedTrades.reduce((acc, trade) => {
+    if (isFiniteMetric(trade.grossPnl)) {
+      return acc + trade.grossPnl;
+    }
+    if (isFiniteMetric(trade.slippageCost)) {
+      return acc + trade.pnl + trade.slippageCost;
+    }
+    return acc + trade.pnl;
+  }, 0);
+  const directionStats = normalizedTrades.reduce(
+    (acc, trade) => {
+      const direction = String(trade.direction ?? "").toUpperCase();
+      if (direction === "LONG") {
+        acc.longTrades += 1;
+        acc.longPnl += trade.pnl;
+      }
+      if (direction === "SHORT") {
+        acc.shortTrades += 1;
+        acc.shortPnl += trade.pnl;
+      }
+      return acc;
+    },
+    { longTrades: 0, shortTrades: 0, longPnl: 0, shortPnl: 0 }
+  );
+  return {
+    core: {
+      trades: normalizedTrades.length,
+      wins,
+      losses,
+      winRate: normalizedTrades.length ? wins / normalizedTrades.length * 100 : null,
+      totalPnl,
+      avgTrade: normalizedTrades.length ? totalPnl / normalizedTrades.length : null,
+      grossProfit,
+      grossLoss,
+      profitFactor: safeRatio(grossProfit, grossLoss),
+      payoffRatio: safeRatio(avgWin, avgLoss),
+      expectancy: normalizedTrades.length ? totalPnl / normalizedTrades.length : null,
+      tradesPerDay: periodDays && periodDays > 0 ? normalizedTrades.length / periodDays : null,
+      tradesPerWeek: periodDays && periodDays > 0 ? normalizedTrades.length / periodDays * 7 : null
+    },
+    risk: {
+      maxDrawdown: drawdown.absolute,
+      maxDrawdownPercent: drawdown.percent,
+      maxDrawdownToTotalProfit: totalPnl > 0 ? safeRatio(drawdown.absolute, totalPnl) : null,
+      maxDrawdownToGrossProfit: grossProfit > 0 ? safeRatio(drawdown.absolute, grossProfit) : null,
+      recoveryFactor: safeRatio(totalPnl, drawdown.absolute),
+      maxLossStreak: calculateLossStreak(normalizedTrades),
+      losingMonthsCount: monthlyStats.filter(([, stat]) => stat.pnl < 0).length,
+      worstMonthPnl: monthlyPnls.length ? Math.min(...monthlyPnls) : null,
+      worstRolling30dPnl: calculateWorstRollingPnl(normalizedTrades, 30),
+      worstRolling90dPnl: calculateWorstRollingPnl(normalizedTrades, 90)
+    },
+    stability: {
+      monthlyWinRate: monthlyWinRates.length ? mean(monthlyWinRates) : null,
+      positiveMonthsPercent: monthlyStats.length ? positiveMonths / monthlyStats.length * 100 : null,
+      quarterlyPnl: [...quarterly.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([quarter, pnl]) => ({ quarter, pnl })),
+      rolling365Pnl: normalizedTrades.length && isFiniteMetric(lastTimestamp) ? normalizedTrades.filter(
+        (trade) => lastTimestamp - trade.timestamp <= 365 * MS_IN_DAY
+      ).reduce((acc, trade) => acc + trade.pnl, 0) : null,
+      medianMonthlyPnl: medianValue(monthlyPnls),
+      iqrMonthlyPnl: p25Monthly === null || p75Monthly === null ? null : p75Monthly - p25Monthly,
+      top5ProfitShare: sumTopPositiveProfitShare(pnls, 5),
+      top10ProfitShare: sumTopPositiveProfitShare(pnls, 10)
+    },
+    distribution: {
+      medianTrade: medianValue(pnls),
+      p10Trade: percentile(pnls, 0.1),
+      p25Trade: percentile(pnls, 0.25),
+      p75Trade: percentile(pnls, 0.75),
+      p90Trade: percentile(pnls, 0.9),
+      largestWin: wins ? Math.max(...pnls.filter((pnl) => pnl > 0)) : null,
+      largestLoss: losses ? Math.min(...pnls.filter((pnl) => pnl < 0)) : null,
+      tailRatio: safeRatio(
+        percentile(pnls, 0.95),
+        Math.abs(percentile(pnls, 0.05) ?? 0)
+      ),
+      skewness: calculateSkewness(pnls)
+    },
+    riskAdjusted: {
+      sharpeDaily: dailyMean !== null && dailyStd !== null && dailyStd > 0 ? dailyMean / dailyStd * Math.sqrt(DAYS_IN_YEAR) : null,
+      sortinoDaily: dailyMean !== null && downsideStd !== null && downsideStd > 0 ? dailyMean / downsideStd * Math.sqrt(DAYS_IN_YEAR) : null,
+      calmar: safeRatio(annualizedPnl, drawdown.absolute),
+      mar: safeRatio(annualizedPnl, drawdown.absolute)
+    },
+    operational: {
+      avgSlippageCost: slippageCosts.length ? mean(slippageCosts) : null,
+      pnlBeforeSlippage: normalizedTrades.length ? pnlBeforeSlippage : null,
+      pnlAfterSlippage: totalPnl,
+      approvalRate: approvedFlags.length ? approvedFlags.filter((trade) => trade.approved).length / approvedFlags.length * 100 : null,
+      blockedProfitableTrades: normalizedTrades.filter(
+        (trade) => trade.blocked && trade.pnl > 0
+      ).length,
+      approvedLosingTrades: normalizedTrades.filter(
+        (trade) => trade.approved && trade.pnl < 0
+      ).length,
+      symbolConcentrationTop1: concentrationPercent(
+        normalizedTrades.filter((trade) => trade.symbol).map((trade) => ({ key: String(trade.symbol), pnl: trade.pnl })),
+        1
+      ),
+      symbolConcentrationTop5: concentrationPercent(
+        normalizedTrades.filter((trade) => trade.symbol).map((trade) => ({ key: String(trade.symbol), pnl: trade.pnl })),
+        5
+      ),
+      sessionConcentrationTop1: concentrationPercent(
+        normalizedTrades.map((trade) => ({
+          key: trade.session ?? resolveTradeSession(trade.timestamp),
+          pnl: trade.pnl
+        })),
+        1
+      ),
+      longTrades: directionStats.longTrades,
+      shortTrades: directionStats.shortTrades,
+      longPnl: directionStats.longPnl,
+      shortPnl: directionStats.shortPnl,
+      exitBreakdown: calculateExitBreakdown(normalizedTrades)
+    }
+  };
+};
 var computeMonthlyEquityStats = (positionLogData, opts) => {
   const MAR = opts?.mar ?? 0;
   const useSample = !!opts?.sampleStd;
@@ -378,12 +676,12 @@ var computeMonthlyEquityStats = (positionLogData, opts) => {
   const startTs = equityPoints2[0].ts;
   const endTs = equityPoints2[equityPoints2.length - 1].ts;
   const eomSeries = [];
-  let monthCursor = (0, import_date_fns3.startOfMonth)(new Date(startTs));
-  const lastMonth = (0, import_date_fns3.endOfMonth)(new Date(endTs));
+  let monthCursor = (0, import_date_fns.startOfMonth)(new Date(startTs));
+  const lastMonth = (0, import_date_fns.endOfMonth)(new Date(endTs));
   let i = 0;
   let lastAmount = equityPoints2[0].amount;
   while (monthCursor <= lastMonth) {
-    const eom = (0, import_date_fns3.endOfMonth)(monthCursor);
+    const eom = (0, import_date_fns.endOfMonth)(monthCursor);
     const eomTs = eom.getTime();
     while (i < equityPoints2.length && equityPoints2[i].ts <= eomTs) {
       lastAmount = equityPoints2[i].amount;
@@ -391,7 +689,7 @@ var computeMonthlyEquityStats = (positionLogData, opts) => {
     }
     const key = `${eom.getFullYear()}-${String(eom.getMonth() + 1).padStart(2, "0")}`;
     eomSeries.push({ month: key, ts: eomTs, amount: lastAmount });
-    monthCursor = (0, import_date_fns3.addMonths)(monthCursor, 1);
+    monthCursor = (0, import_date_fns.addMonths)(monthCursor, 1);
   }
   const monthlyReturns = [];
   for (let k = 1; k < eomSeries.length; k++) {
@@ -436,7 +734,7 @@ var calculateStatsFull = (positionLogData) => {
   const points = equityPoints(positionLogData);
   const startTs = points[0].ts;
   const endTs = points[points.length - 1].ts;
-  const periodMs = (0, import_date_fns3.differenceInMilliseconds)(new Date(endTs), new Date(startTs));
+  const periodMs = (0, import_date_fns.differenceInMilliseconds)(new Date(endTs), new Date(startTs));
   const periodDays = periodMs / (1e3 * 60 * 60 * 24);
   const periodMonths = periodDays / 30.4375;
   const trades = positionLogData.length;
@@ -509,7 +807,10 @@ var calculateStatsFull = (positionLogData) => {
   };
 };
 var classifyMetric = (name, value) => {
-  const { thresholds, direction } = TestThresholdsConfig[name];
+  const { thresholds, direction, neutralValue } = TestThresholdsConfig[name];
+  if (neutralValue !== void 0 && value === neutralValue) {
+    return "neutral";
+  }
   if (direction === "higher") {
     if (value >= thresholds[1]) return "success";
     if (value >= thresholds[0]) return "warning";
@@ -556,19 +857,60 @@ var getFormatted = (stat, key) => {
     level
   };
 };
+
+// src/utils/timestamp.ts
+var import_date_fns2 = require("date-fns");
+var import_date_fns3 = require("date-fns");
+var TIMELINE_STEP = 864e5;
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 6 * 60 * 60 * 1e3;
+var getTimestamp = (days = 0) => {
+  if (days > 0) {
+    return (0, import_date_fns3.getUnixTime)((0, import_date_fns3.subDays)(/* @__PURE__ */ new Date(), days)) * 1e3;
+  }
+  return (0, import_date_fns3.getUnixTime)(/* @__PURE__ */ new Date()) * 1e3;
+};
+var getTimeline = (start = getTimestamp(BACKTEST_DEFAULT_DAYS), end = getTimestamp(), step = TIMELINE_STEP) => {
+  const res = new Array();
+  for (let ind = start; ind <= end; ind += step) {
+    res.push(ind);
+  }
+  return res;
+};
+var compactOrderLog = (timeline, orderLog) => {
+  const result = [];
+  let currentAmount = orderLog.length > 0 && orderLog[0].amount != null ? orderLog[0].amount : 100;
+  let orderLogCursor = 0;
+  for (let timelineIndex = 0; timelineIndex < timeline.length; timelineIndex++) {
+    const currentTimestamp = timeline[timelineIndex];
+    let lastApplicableOrderIndex = -1;
+    let nextCursor = orderLogCursor;
+    for (let checkIndex = orderLogCursor; checkIndex < orderLog.length; checkIndex++) {
+      const checkOrder = orderLog[checkIndex];
+      if (checkOrder.timestamp <= currentTimestamp) {
+        lastApplicableOrderIndex = checkIndex;
+        nextCursor = checkIndex + 1;
+      } else {
+        break;
+      }
+    }
+    if (lastApplicableOrderIndex !== -1) {
+      currentAmount = orderLog[lastApplicableOrderIndex].amount;
+      orderLogCursor = nextCursor;
+    }
+    result.push([currentTimestamp, currentAmount]);
+  }
+  return result;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  calculateAdvancedTradeMetrics,
   calculateMaxDrawdown,
   calculateStatsFull,
   classifyMetric,
   compactOrderLog,
-  createTestSuite,
-  generateName,
-  generateParamGrid,
   getBacktestScore,
   getFormatted,
   getTimeline,
-  mergeConfigs,
   parseTestName,
   sortBestTests
 });