@tradejs/cli 1.0.9 → 1.0.11

package/dist/lib/aiTrainCharts.js

@@ -0,0 +1,711 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/aiTrainCharts.ts
+var aiTrainCharts_exports = {};
+__export(aiTrainCharts_exports, {
+  buildAiChartSnapshot: () => buildAiChartSnapshot
+});
+module.exports = __toCommonJS(aiTrainCharts_exports);
+
+// src/lib/aiTrainMetrics.ts
+var divideOrNull = (num, denom) => {
+  if (denom <= 0) {
+    return null;
+  }
+  return num / denom;
+};
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var DAYS_PER_WEEK = 7;
+var DAYS_PER_MONTH = 30.4375;
+var getEvaluationPeriodDays = (evaluations) => {
+  let minTimestamp = null;
+  let maxTimestamp = null;
+  for (const evaluation of evaluations) {
+    const timestamp = typeof evaluation.timestamp === "number" && Number.isFinite(evaluation.timestamp) ? evaluation.timestamp : null;
+    if (timestamp == null) {
+      continue;
+    }
+    if (minTimestamp == null || timestamp < minTimestamp) {
+      minTimestamp = timestamp;
+    }
+    if (maxTimestamp == null || timestamp > maxTimestamp) {
+      maxTimestamp = timestamp;
+    }
+  }
+  if (minTimestamp == null || maxTimestamp == null) {
+    return null;
+  }
+  return Math.max((maxTimestamp - minTimestamp) / DAY_MS, 1);
+};
+var qualitySortKey = (quality) => quality == null ? Number.POSITIVE_INFINITY : quality;
+var emptyRiskSummary = () => ({
+  trades: 0,
+  totalProfit: 0,
+  grossProfit: 0,
+  grossLoss: 0,
+  profitFactor: null,
+  payoffRatio: null,
+  avgWin: null,
+  avgLoss: null,
+  largestWin: null,
+  largestLoss: null,
+  winRate: null,
+  maxDrawdown: 0,
+  maxDrawdownPctOfGrossProfit: null,
+  maxDrawdownPctOfTotalProfit: null,
+  recoveryFactor: null,
+  ulcerIndex: null,
+  maxConsecutiveWins: 0,
+  maxConsecutiveLosses: 0
+});
+var summarizeApprovedRisk = (evaluations) => {
+  const approvedEvaluations = evaluations.filter((evaluation) => evaluation.aiApproved).sort((left, right) => {
+    const leftTimestamp = typeof left.timestamp === "number" && Number.isFinite(left.timestamp) ? left.timestamp : Number.POSITIVE_INFINITY;
+    const rightTimestamp = typeof right.timestamp === "number" && Number.isFinite(right.timestamp) ? right.timestamp : Number.POSITIVE_INFINITY;
+    return leftTimestamp - rightTimestamp;
+  });
+  if (!approvedEvaluations.length) {
+    return emptyRiskSummary();
+  }
+  let grossProfit = 0;
+  let grossLoss = 0;
+  let wins = 0;
+  let losses = 0;
+  let largestWin = null;
+  let largestLoss = null;
+  let equity = 0;
+  let peakEquity = 0;
+  let maxDrawdown = 0;
+  let drawdownSquares = 0;
+  let currentWinStreak = 0;
+  let currentLossStreak = 0;
+  let maxConsecutiveWins = 0;
+  let maxConsecutiveLosses = 0;
+  for (const evaluation of approvedEvaluations) {
+    const profit = evaluation.profit;
+    if (profit > 0) {
+      grossProfit += profit;
+      wins += 1;
+      largestWin = largestWin == null ? profit : Math.max(largestWin, profit);
+      currentWinStreak += 1;
+      currentLossStreak = 0;
+    } else if (profit < 0) {
+      grossLoss += Math.abs(profit);
+      losses += 1;
+      largestLoss = largestLoss == null ? profit : Math.min(largestLoss, profit);
+      currentLossStreak += 1;
+      currentWinStreak = 0;
+    } else {
+      currentWinStreak = 0;
+      currentLossStreak = 0;
+    }
+    maxConsecutiveWins = Math.max(maxConsecutiveWins, currentWinStreak);
+    maxConsecutiveLosses = Math.max(maxConsecutiveLosses, currentLossStreak);
+    equity += profit;
+    peakEquity = Math.max(peakEquity, equity);
+    const drawdown = Math.max(0, peakEquity - equity);
+    maxDrawdown = Math.max(maxDrawdown, drawdown);
+    drawdownSquares += drawdown * drawdown;
+  }
+  const totalProfit = grossProfit - grossLoss;
+  const avgWin = divideOrNull(grossProfit, wins);
+  const avgLoss = divideOrNull(grossLoss, losses);
+  return {
+    trades: approvedEvaluations.length,
+    totalProfit,
+    grossProfit,
+    grossLoss,
+    profitFactor: grossLoss > 0 ? grossProfit / grossLoss : null,
+    payoffRatio: avgWin != null && avgLoss != null && avgLoss > 0 ? avgWin / avgLoss : null,
+    avgWin,
+    avgLoss,
+    largestWin,
+    largestLoss,
+    winRate: divideOrNull(wins, approvedEvaluations.length),
+    maxDrawdown,
+    maxDrawdownPctOfGrossProfit: grossProfit > 0 ? maxDrawdown / grossProfit : null,
+    maxDrawdownPctOfTotalProfit: totalProfit > 0 ? maxDrawdown / totalProfit : null,
+    recoveryFactor: maxDrawdown > 0 ? totalProfit / maxDrawdown : null,
+    ulcerIndex: Math.sqrt(drawdownSquares / approvedEvaluations.length),
+    maxConsecutiveWins,
+    maxConsecutiveLosses
+  };
+};
+var summarizeAiTrainEvaluations = (evaluations) => {
+  let approved = 0;
+  let rejected = 0;
+  let correct = 0;
+  let incorrect = 0;
+  let profitable = 0;
+  let unprofitable = 0;
+  let flat = 0;
+  let truePositive = 0;
+  let falsePositive = 0;
+  let trueNegative = 0;
+  let falseNegative = 0;
+  let totalProfitAll = 0;
+  let totalProfitApproved = 0;
+  const bucketMap = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    const { profit, profitableTrade, aiApproved, quality } = evaluation;
+    totalProfitAll += profit;
+    if (profitableTrade) {
+      profitable += 1;
+    } else if (profit < 0) {
+      unprofitable += 1;
+    } else {
+      flat += 1;
+    }
+    if (aiApproved) {
+      approved += 1;
+      totalProfitApproved += profit;
+    } else {
+      rejected += 1;
+    }
+    const isCorrect = aiApproved === profitableTrade;
+    if (isCorrect) {
+      correct += 1;
+    } else {
+      incorrect += 1;
+    }
+    if (aiApproved && profitableTrade) {
+      truePositive += 1;
+    } else if (aiApproved && !profitableTrade) {
+      falsePositive += 1;
+    } else if (!aiApproved && profitableTrade) {
+      falseNegative += 1;
+    } else {
+      trueNegative += 1;
+    }
+    const bucket = bucketMap.get(quality) ?? {
+      quality,
+      count: 0,
+      approved: 0,
+      profitable: 0,
+      totalProfit: 0
+    };
+    bucket.count += 1;
+    bucket.totalProfit += profit;
+    if (aiApproved) {
+      bucket.approved += 1;
+    }
+    if (profitableTrade) {
+      bucket.profitable += 1;
+    }
+    bucketMap.set(quality, bucket);
+  }
+  const avgProfitAll = divideOrNull(totalProfitAll, evaluations.length);
+  const avgProfitApproved = divideOrNull(totalProfitApproved, approved);
+  const periodDays = getEvaluationPeriodDays(evaluations);
+  const avgProfitApprovedPerDay = periodDays == null ? null : divideOrNull(totalProfitApproved, periodDays);
+  const avgApprovedTradesPerDay = periodDays == null ? null : divideOrNull(approved, periodDays);
+  const avgProfitApprovedPerMonth = avgProfitApprovedPerDay == null ? null : avgProfitApprovedPerDay * DAYS_PER_MONTH;
+  const avgApprovedTradesPerWeek = avgApprovedTradesPerDay == null ? null : avgApprovedTradesPerDay * DAYS_PER_WEEK;
+  const expectancyDelta = avgProfitAll == null || avgProfitApproved == null ? null : avgProfitApproved - avgProfitAll;
+  return {
+    approved,
+    rejected,
+    correct,
+    incorrect,
+    truePositive,
+    falsePositive,
+    trueNegative,
+    falseNegative,
+    profitable,
+    unprofitable,
+    flat,
+    precisionApproved: divideOrNull(truePositive, approved),
+    recallWinners: divideOrNull(truePositive, profitable),
+    avgProfitAll,
+    avgProfitApproved,
+    avgProfitApprovedPerDay,
+    avgProfitApprovedPerMonth,
+    avgApprovedTradesPerDay,
+    avgApprovedTradesPerWeek,
+    expectancyDelta,
+    approvedRisk: summarizeApprovedRisk(evaluations),
+    qualityBuckets: [...bucketMap.values()].sort(
+      (a, b) => qualitySortKey(a.quality) - qualitySortKey(b.quality)
+    )
+  };
+};
+var getDirectionSortKey = (direction) => {
+  if (direction === "LONG") {
+    return 0;
+  }
+  if (direction === "SHORT") {
+    return 1;
+  }
+  return 2;
+};
+var summarizeAiTrainEvaluationsByDirection = (evaluations) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    const direction = typeof evaluation.direction === "string" && evaluation.direction.trim() ? evaluation.direction : "UNKNOWN";
+    const bucket = grouped.get(direction) ?? [];
+    bucket.push(evaluation);
+    grouped.set(direction, bucket);
+  }
+  return [...grouped.entries()].sort(
+    ([leftDirection], [rightDirection]) => getDirectionSortKey(leftDirection) - getDirectionSortKey(rightDirection) || leftDirection.localeCompare(rightDirection)
+  ).map(([direction, directionEvaluations]) => ({
+    direction,
+    summary: summarizeAiTrainEvaluations(directionEvaluations)
+  }));
+};
+
+// src/lib/aiTrainCharts.ts
+var formatRatio = (value) => value == null ? "n/a" : `${(value * 100).toFixed(1)}%`;
+var formatPercent = (value) => value == null ? "n/a" : `${(value * 100).toFixed(1)}%`;
+var formatPercentValue = (value) => value == null ? "n/a" : `${value.toFixed(1)}%`;
+var formatSigned = (value) => value == null ? "n/a" : `${value >= 0 ? "+" : ""}${value.toFixed(2)}`;
+var formatNumber = (value) => value == null ? "n/a" : value.toFixed(2);
+var formatUtcWindowTimestamp = (timestamp) => {
+  if (timestamp == null || !Number.isFinite(timestamp)) {
+    return "n/a";
+  }
+  return new Date(timestamp).toISOString().replace("T", " ").replace(".000Z", " UTC");
+};
+var resolveMetricTone = (value) => {
+  if (value == null) {
+    return "default";
+  }
+  if (value > 0) {
+    return "success";
+  }
+  if (value < 0) {
+    return "error";
+  }
+  return "neutral";
+};
+var buildAiChartMetrics = (params) => {
+  const { summary, maxDrawdownPercent } = params;
+  const metrics = [
+    {
+      id: "maxDrawdown",
+      label: "Max drawdown",
+      value: formatPercentValue(maxDrawdownPercent),
+      tone: maxDrawdownPercent == null ? "default" : maxDrawdownPercent > 0 ? "warning" : "success"
+    },
+    {
+      id: "approved",
+      label: "Approved",
+      value: String(summary.approved)
+    },
+    {
+      id: "accuracy",
+      label: "Accuracy",
+      value: formatPercent(
+        summary.correct + summary.incorrect > 0 ? summary.correct / (summary.correct + summary.incorrect) : null
+      )
+    },
+    {
+      id: "precision",
+      label: "Precision",
+      value: formatPercent(summary.precisionApproved)
+    },
+    {
+      id: "recall",
+      label: "Recall",
+      value: formatPercent(summary.recallWinners)
+    },
+    {
+      id: "pnl",
+      label: "P&L",
+      value: formatSigned(summary.approvedRisk.totalProfit),
+      tone: resolveMetricTone(summary.approvedRisk.totalProfit)
+    },
+    {
+      id: "monthlyPnl",
+      label: "Monthly P&L",
+      value: formatSigned(summary.avgProfitApprovedPerMonth),
+      tone: resolveMetricTone(summary.avgProfitApprovedPerMonth)
+    },
+    {
+      id: "approvedPerDay",
+      label: "Approved/Day",
+      value: formatNumber(summary.avgApprovedTradesPerDay)
+    },
+    {
+      id: "avgProfit",
+      label: "Avg Profit",
+      value: formatSigned(summary.avgProfitApproved),
+      tone: resolveMetricTone(summary.avgProfitApproved)
+    }
+  ];
+  return metrics;
+};
+var buildAiChartDetails = (params) => {
+  const { summary, rows } = params;
+  let windowStart = null;
+  let windowEnd = null;
+  for (const row of rows) {
+    const timestamp = row.timestamp != null && Number.isFinite(row.timestamp) ? row.timestamp : null;
+    if (timestamp == null) {
+      continue;
+    }
+    if (windowStart == null || timestamp < windowStart) {
+      windowStart = timestamp;
+    }
+    if (windowEnd == null || timestamp > windowEnd) {
+      windowEnd = timestamp;
+    }
+  }
+  const directionDetails = summarizeAiTrainEvaluationsByDirection(rows).filter(({ direction }) => direction === "LONG" || direction === "SHORT").flatMap(({ direction, summary: directionSummary }) => [
+    {
+      id: `direction:${direction}:approved`,
+      label: `${direction} approved`,
+      value: String(directionSummary.approved)
+    },
+    {
+      id: `direction:${direction}:precision`,
+      label: `${direction} precision`,
+      value: formatRatio(directionSummary.precisionApproved)
+    },
+    {
+      id: `direction:${direction}:monthlyPnl`,
+      label: `${direction} monthly_pnl`,
+      value: formatSigned(directionSummary.avgProfitApprovedPerMonth),
+      tone: resolveMetricTone(directionSummary.avgProfitApprovedPerMonth)
+    },
+    {
+      id: `direction:${direction}:pnl`,
+      label: `${direction} pnl`,
+      value: formatSigned(directionSummary.approvedRisk.totalProfit),
+      tone: resolveMetricTone(directionSummary.approvedRisk.totalProfit)
+    },
+    {
+      id: `direction:${direction}:avgProfit`,
+      label: `${direction} avg_profit`,
+      value: formatSigned(directionSummary.avgProfitApproved),
+      tone: resolveMetricTone(directionSummary.avgProfitApproved)
+    }
+  ]);
+  const symbolDetails = [
+    ...rows.reduce((grouped, row) => {
+      if (!row.symbol) {
+        return grouped;
+      }
+      const symbolRows = grouped.get(row.symbol) ?? [];
+      symbolRows.push(row);
+      grouped.set(row.symbol, symbolRows);
+      return grouped;
+    }, /* @__PURE__ */ new Map()).entries()
+  ].map(([symbol, symbolRows]) => {
+    const symbolSummary = summarizeAiTrainEvaluations(symbolRows);
+    return {
+      symbol,
+      summary: symbolSummary,
+      pnl: symbolSummary.approvedRisk.totalProfit
+    };
+  }).filter(({ summary: summary2 }) => summary2.approved > 0).sort(
+    (left, right) => Math.abs(right.pnl) - Math.abs(left.pnl) || right.pnl - left.pnl || left.symbol.localeCompare(right.symbol)
+  ).slice(0, 10).flatMap(({ symbol, summary: summary2, pnl }) => [
+    {
+      id: `symbol:${symbol}:pnl`,
+      label: `${symbol} pnl`,
+      value: formatSigned(pnl),
+      tone: resolveMetricTone(pnl)
+    },
+    {
+      id: `symbol:${symbol}:orders`,
+      label: `${symbol} approved`,
+      value: String(summary2.approved)
+    },
+    {
+      id: `symbol:${symbol}:winRate`,
+      label: `${symbol} win_rate`,
+      value: formatRatio(summary2.approvedRisk.winRate)
+    }
+  ]);
+  const details = [
+    {
+      id: "window",
+      label: "window",
+      value: `${formatUtcWindowTimestamp(windowStart)} -> ${formatUtcWindowTimestamp(windowEnd)}`
+    },
+    {
+      id: "approved",
+      label: "approved",
+      value: String(summary.approved)
+    },
+    {
+      id: "confusion",
+      label: "TP / FP / TN / FN",
+      value: `${summary.truePositive} / ${summary.falsePositive} / ${summary.trueNegative} / ${summary.falseNegative}`
+    },
+    {
+      id: "precisionApproved",
+      label: "precision_approved",
+      value: formatRatio(summary.precisionApproved)
+    },
+    {
+      id: "recallWinners",
+      label: "recall_winners",
+      value: formatRatio(summary.recallWinners)
+    },
+    {
+      id: "avgProfitAll",
+      label: "avg_profit_all",
+      value: formatSigned(summary.avgProfitAll),
+      tone: resolveMetricTone(summary.avgProfitAll)
+    },
+    {
+      id: "avgProfitApproved",
+      label: "avg_profit_approved",
+      value: formatSigned(summary.avgProfitApproved),
+      tone: resolveMetricTone(summary.avgProfitApproved)
+    },
+    {
+      id: "avgProfitApprovedPerDay",
+      label: "avg_profit_approved_per_day",
+      value: formatSigned(summary.avgProfitApprovedPerDay),
+      tone: resolveMetricTone(summary.avgProfitApprovedPerDay)
+    },
+    {
+      id: "avgProfitApprovedPerMonth",
+      label: "avg_profit_approved_per_month",
+      value: formatSigned(summary.avgProfitApprovedPerMonth),
+      tone: resolveMetricTone(summary.avgProfitApprovedPerMonth)
+    },
+    {
+      id: "avgApprovedTradesPerDay",
+      label: "avg_approved_trades_per_day",
+      value: formatNumber(summary.avgApprovedTradesPerDay)
+    },
+    {
+      id: "avgApprovedTradesPerWeek",
+      label: "avg_approved_trades_per_week",
+      value: formatNumber(summary.avgApprovedTradesPerWeek)
+    },
+    {
+      id: "expectancyDelta",
+      label: "expectancy_delta",
+      value: formatSigned(summary.expectancyDelta),
+      tone: resolveMetricTone(summary.expectancyDelta)
+    },
+    {
+      id: "maxLossStreak",
+      label: "max_loss_streak",
+      value: String(summary.approvedRisk.maxConsecutiveLosses),
+      tone: summary.approvedRisk.maxConsecutiveLosses > 0 ? "warning" : "success"
+    },
+    ...directionDetails,
+    ...symbolDetails
+  ];
+  return details;
+};
+var buildStrategyWideEquityCurve = (evaluations) => {
+  if (!evaluations.length) {
+    return [];
+  }
+  const sorted = [...evaluations].sort(
+    (left, right) => (left.timestamp ?? 0) - (right.timestamp ?? 0) || left.symbol.localeCompare(right.symbol) || left.signalId.localeCompare(right.signalId)
+  );
+  let amount = 100;
+  const firstTimestamp = sorted[0]?.timestamp ?? Date.now();
+  const orderLog = [[firstTimestamp, amount]];
+  for (const evaluation of sorted) {
+    amount += evaluation.profit;
+    orderLog.push([
+      evaluation.timestamp ?? firstTimestamp,
+      Number(amount.toFixed(4))
+    ]);
+  }
+  if (orderLog.length === 1) {
+    orderLog.push([firstTimestamp, amount]);
+  }
+  return orderLog;
+};
+var sortAiChartEvaluations = (evaluations) => [...evaluations].sort(
+  (left, right) => (left.timestamp ?? 0) - (right.timestamp ?? 0) || left.symbol.localeCompare(right.symbol) || left.signalId.localeCompare(right.signalId)
+);
+var toFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var buildStrategyWideOrders = (evaluations) => {
+  let amount = 100;
+  return sortAiChartEvaluations(evaluations).flatMap((evaluation, index) => {
+    const tradeResult = evaluation.tradeResult;
+    const equityBefore = amount;
+    amount = Number((amount + evaluation.profit).toFixed(4));
+    if (!tradeResult) {
+      return [];
+    }
+    const entryPrice = toFiniteNumber(tradeResult?.entryPrice);
+    const qty = toFiniteNumber(tradeResult?.qty);
+    const notional = entryPrice != null && qty != null ? Number((entryPrice * qty).toFixed(8)) : null;
+    return {
+      id: `${evaluation.signalId}:${evaluation.timestamp ?? index}`,
+      symbol: evaluation.symbol,
+      direction: tradeResult?.direction ?? evaluation.direction ?? null,
+      timestamp: evaluation.timestamp ?? tradeResult?.exitTimestamp ?? null,
+      entryTimestamp: tradeResult?.entryTimestamp ?? evaluation.timestamp ?? null,
+      exitTimestamp: tradeResult?.exitTimestamp ?? evaluation.timestamp ?? null,
+      exitReason: tradeResult?.exitReason ?? null,
+      pnl: evaluation.profit,
+      equityBefore,
+      equityAfter: amount,
+      qty,
+      notional,
+      requestedEntryPrice: toFiniteNumber(tradeResult?.requestedEntryPrice),
+      entryPrice,
+      requestedExitPrice: toFiniteNumber(tradeResult?.requestedExitPrice),
+      exitPrice: toFiniteNumber(tradeResult?.exitPrice),
+      openFee: toFiniteNumber(tradeResult?.openFee),
+      closeFee: toFiniteNumber(tradeResult?.closeFee),
+      fundingFee: toFiniteNumber(tradeResult?.fundingFee),
+      totalFee: toFiniteNumber(tradeResult?.totalFee),
+      entrySlippageBps: toFiniteNumber(tradeResult?.entrySlippageBps),
+      entryBaseSlippageBps: toFiniteNumber(tradeResult?.entryBaseSlippageBps),
+      entrySpreadBps: toFiniteNumber(tradeResult?.entrySpreadBps),
+      entrySpreadSlippageBps: toFiniteNumber(
+        tradeResult?.entrySpreadSlippageBps
+      ),
+      entryMarketImpactBps: toFiniteNumber(tradeResult?.entryMarketImpactBps),
+      entryDelayRiskBps: toFiniteNumber(tradeResult?.entryDelayRiskBps),
+      exitSlippageBps: toFiniteNumber(tradeResult?.exitSlippageBps),
+      exitBaseSlippageBps: toFiniteNumber(tradeResult?.exitBaseSlippageBps),
+      exitSpreadBps: toFiniteNumber(tradeResult?.exitSpreadBps),
+      exitSpreadSlippageBps: toFiniteNumber(tradeResult?.exitSpreadSlippageBps),
+      exitMarketImpactBps: toFiniteNumber(tradeResult?.exitMarketImpactBps),
+      exitDelayRiskBps: toFiniteNumber(tradeResult?.exitDelayRiskBps),
+      totalSlippageCost: toFiniteNumber(tradeResult?.totalSlippageCost),
+      sequence: evaluation.sequence ?? index + 1
+    };
+  });
+};
+var calculateMaxDrawdownPercent = (orderLog) => {
+  if (!orderLog.length) {
+    return null;
+  }
+  let peak = orderLog[0]?.[1] ?? 0;
+  let maxDrawdownPercent = 0;
+  for (const [, amount] of orderLog) {
+    if (!Number.isFinite(amount)) {
+      continue;
+    }
+    peak = Math.max(peak, amount);
+    if (peak <= 0) {
+      continue;
+    }
+    const drawdownPercent = (peak - amount) / peak * 100;
+    maxDrawdownPercent = Math.max(maxDrawdownPercent, drawdownPercent);
+  }
+  return Number(maxDrawdownPercent.toFixed(1));
+};
+var resolveAiVariantGroup = (params) => {
+  const normalizedConfigId = params.configId.trim();
+  if (!normalizedConfigId) {
+    return null;
+  }
+  return {
+    key: normalizedConfigId,
+    label: `config ${normalizedConfigId}`
+  };
+};
+var buildAiChartSnapshot = (params) => {
+  const {
+    evaluatedRows,
+    strategyName,
+    generatedAt,
+    runLabel,
+    minQuality,
+    datasetId
+  } = params;
+  const groupsByVariant = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluatedRows) {
+    const variantGroup = resolveAiVariantGroup({
+      configId: evaluation.configId
+    });
+    if (!variantGroup) {
+      continue;
+    }
+    const existingGroup = groupsByVariant.get(variantGroup.key);
+    if (existingGroup) {
+      existingGroup.rows.push(evaluation);
+      continue;
+    }
+    groupsByVariant.set(variantGroup.key, {
+      key: variantGroup.key,
+      label: variantGroup.label,
+      rows: [evaluation]
+    });
+  }
+  const variantGroups = [...groupsByVariant.values()].sort(
+    (left, right) => left.label.localeCompare(right.label)
+  );
+  const groupByVariant = variantGroups.length > 1;
+  const groups = groupByVariant ? variantGroups : [
+    {
+      key: strategyName,
+      label: "",
+      rows: evaluatedRows
+    }
+  ];
+  const cards = [];
+  for (const threshold of [minQuality]) {
+    for (const group of groups) {
+      const thresholdEvaluations = group.rows.map((evaluation) => ({
+        ...evaluation,
+        aiApproved: evaluation.modelDirection === evaluation.direction && evaluation.quality != null && evaluation.quality >= threshold
+      }));
+      const summary = summarizeAiTrainEvaluations(thresholdEvaluations);
+      const approvedRows = thresholdEvaluations.filter(
+        (evaluation) => evaluation.aiApproved
+      );
+      const orderLog = buildStrategyWideEquityCurve(approvedRows);
+      const orders = buildStrategyWideOrders(approvedRows);
+      cards.push({
+        cardId: `${strategyName}-${group.key}-q${threshold}-${generatedAt}`,
+        generatedAt,
+        strategyName,
+        title: groupByVariant ? `${strategyName} \xB7 ${group.label}` : strategyName,
+        subtitle: runLabel ? `q${threshold}+ \xB7 ${runLabel}` : `q${threshold}+`,
+        datasetId,
+        symbols: [
+          ...new Set(
+            group.rows.map((evaluation) => evaluation.symbol).filter(Boolean)
+          )
+        ].sort(),
+        orderLog,
+        orders,
+        stat: null,
+        metrics: buildAiChartMetrics({
+          summary,
+          maxDrawdownPercent: calculateMaxDrawdownPercent(orderLog)
+        }),
+        details: buildAiChartDetails({
+          summary,
+          rows: thresholdEvaluations
+        }),
+        tags: groupByVariant ? [`q${threshold}+`, group.label] : [`q${threshold}+`]
+      });
+    }
+  }
+  return {
+    mode: "ai",
+    generatedAt,
+    runLabel,
+    strategies: cards
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAiChartSnapshot
+});