@tradejs/node 1.0.9 → 1.0.11

package/dist/backtest.mjs

@@ -1,20 +1,22 @@
 import {
   BUILTIN_CONNECTOR_NAMES,
   getConnectorCreatorByName
-} from "./chunk-JMDYEKIO.mjs";
+} from "./chunk-V3YMKE4I.mjs";
 import {
   buildMlPayload,
+  enrichSignalWithBinanceMarketContext,
+  enrichSignalWithCoinMarketCapContext,
   enrichSignalWithDerivativesContext
-} from "./chunk-JRRG3YQG.mjs";
+} from "./chunk-37VNDZVX.mjs";
 import {
   buildAiPayload
-} from "./chunk-2JKX3DM7.mjs";
+} from "./chunk-IUZML4RK.mjs";
 import {
   getStrategyCreator
-} from "./chunk-WGOYR6AB.mjs";
+} from "./chunk-QVSMINLG.mjs";
 import {
   getTradejsProjectCwd
-} from "./chunk-JU77QVJ3.mjs";
+} from "./chunk-WS5DYEVZ.mjs";
 import "./chunk-6DZX6EAA.mjs";
 
 // src/backtest.ts
@@ -22,6 +24,14 @@ export * from "@tradejs/core/backtest";
 
 // src/testing.ts
 import { alignSortedCandlesByTimestamp } from "@tradejs/core/indicators";
+import {
+  BACKTEST_EXECUTION_INTERVAL,
+  BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED
+} from "@tradejs/core/constants";
+import {
+  releaseStrategyIndicatorsReplayCache,
+  releaseStrategyReplayCache
+} from "@tradejs/core/strategies";
 import { getBacktestPreloadStart } from "@tradejs/core/time";
 import { appendAiDatasetRow } from "@tradejs/infra/ai";
 import {
@@ -33,19 +43,37 @@ import { logger } from "@tradejs/infra/logger";
 
 // src/testConnector.ts
 import { randomUUID } from "crypto";
+import { FEE_PERCENT, INITIAL_BACKTEST_AMOUNT } from "@tradejs/core/constants";
+import { calculateStatsFull } from "@tradejs/core/backtest";
+import {
+  applyExecutionSlippage as applyModeledExecutionSlippage,
+  calculateExecutionSlippageBreakdown,
+  extractExecutionMarketImpactBps,
+  extractExecutionSpreadBps,
+  extractExecutionDelayRiskBps
+} from "@tradejs/core/trade";
 import { round } from "@tradejs/core/math";
-var FEE = 5e-3;
-var INITIAL_AMOUNT = 100;
+var PRICE_PRECISION = 8;
 var createTestConnector = (connector, context) => {
   let state = {};
   const orderLog = [];
   const positionLog = [];
+  const fastMode = Boolean(context?.fastMode);
+  const executionCostModel = context?.executionCostModel;
+  const makerFeeRate = executionCostModel?.fees.makerRate ?? FEE_PERCENT;
+  const takerFeeRate = executionCostModel?.fees.takerRate ?? FEE_PERCENT;
+  const fundingRates = [...context?.fundingRates ?? []].sort(
+    (left, right) => left.timestamp - right.timestamp
+  );
+  const processedFundingTimestamps = /* @__PURE__ */ new Set();
   let currentPosition = null;
-  let amount = INITIAL_AMOUNT;
+  let amount = INITIAL_BACKTEST_AMOUNT;
   let originalQty = 0;
   let currentPositionProfit = 0;
+  let currentSignalId = null;
   let takeProfits = [];
   let stopLossPrice = null;
+  let currentTradeResult = null;
   const closedSignalResults = [];
   const logOrder = (data) => {
     const nextEntry = {
@@ -56,10 +84,157 @@ var createTestConnector = (connector, context) => {
       index: orderLog.length
     };
     if (nextEntry.signal) {
-      const { indicators: _indicators, ...signalWithoutIndicators } = nextEntry.signal;
-      nextEntry.signal = signalWithoutIndicators;
+      const {
+        additionalIndicators: _additionalIndicators,
+        indicators: _indicators,
+        ...signalWithoutHeavyContext
+      } = nextEntry.signal;
+      nextEntry.signal = signalWithoutHeavyContext;
+    }
+    if (!fastMode) {
+      orderLog.push(nextEntry);
+    }
+  };
+  const roundNullable = (value) => value == null ? null : round(value);
+  const roundPrice = (value) => round(value, PRICE_PRECISION);
+  const roundNullablePrice = (value) => value == null ? null : roundPrice(value);
+  const getSlippageCost = ({
+    requestedPrice,
+    executionPrice,
+    direction,
+    stage,
+    qty
+  }) => {
+    if (direction === "LONG") {
+      return stage === "entry" ? Math.max(0, executionPrice - requestedPrice) * qty : Math.max(0, requestedPrice - executionPrice) * qty;
+    }
+    return stage === "entry" ? Math.max(0, requestedPrice - executionPrice) * qty : Math.max(0, executionPrice - requestedPrice) * qty;
+  };
+  const getSlippageBps = (requestedPrice, executionPrice) => requestedPrice ? (executionPrice - requestedPrice) / requestedPrice * 1e4 : 0;
+  const getWeightedAverage = (previousValue, previousQty, nextValue, nextQty) => {
+    if (previousValue == null || previousQty <= 0) {
+      return nextValue;
+    }
+    return (previousValue * previousQty + nextValue * nextQty) / (previousQty + nextQty);
+  };
+  const finalizeTradeResult = (tradeResult, timestamp) => {
+    if (!tradeResult.exitReason) {
+      return void 0;
+    }
+    return {
+      ...tradeResult,
+      exitTimestamp: tradeResult.exitTimestamp ?? timestamp,
+      exitReason: tradeResult.exitReason,
+      requestedEntryPrice: roundPrice(tradeResult.requestedEntryPrice),
+      entryPrice: roundPrice(tradeResult.entryPrice),
+      requestedExitPrice: roundNullablePrice(tradeResult.requestedExitPrice),
+      exitPrice: roundNullablePrice(tradeResult.exitPrice),
+      grossProfit: round(tradeResult.grossProfit),
+      netProfit: round(tradeResult.netProfit),
+      openFee: round(tradeResult.openFee),
+      closeFee: round(tradeResult.closeFee),
+      fundingFee: roundNullable(tradeResult.fundingFee),
+      totalFee: round(tradeResult.totalFee),
+      entrySlippagePrice: round(tradeResult.entrySlippagePrice),
+      entrySlippageBps: round(tradeResult.entrySlippageBps),
+      entryBaseSlippageBps: round(tradeResult.entryBaseSlippageBps),
+      entrySpreadBps: round(tradeResult.entrySpreadBps),
+      entrySpreadSlippageBps: round(tradeResult.entrySpreadSlippageBps),
+      entryMarketImpactBps: round(tradeResult.entryMarketImpactBps),
+      entryDelayRiskBps: roundNullable(tradeResult.entryDelayRiskBps),
+      entrySlippageCost: round(tradeResult.entrySlippageCost),
+      exitSlippagePrice: roundNullable(tradeResult.exitSlippagePrice),
+      exitSlippageBps: roundNullable(tradeResult.exitSlippageBps),
+      exitBaseSlippageBps: roundNullable(tradeResult.exitBaseSlippageBps),
+      exitSpreadBps: roundNullable(tradeResult.exitSpreadBps),
+      exitSpreadSlippageBps: roundNullable(tradeResult.exitSpreadSlippageBps),
+      exitMarketImpactBps: roundNullable(tradeResult.exitMarketImpactBps),
+      exitDelayRiskBps: roundNullable(tradeResult.exitDelayRiskBps),
+      exitSlippageCost: round(tradeResult.exitSlippageCost),
+      totalSlippageCost: round(tradeResult.totalSlippageCost),
+      qty: round(tradeResult.qty),
+      closedQty: round(tradeResult.closedQty)
+    };
+  };
+  const recordExitResult = ({
+    timestamp,
+    reason,
+    requestedPrice,
+    executionPrice,
+    qty,
+    grossProfit,
+    fee,
+    slippageBreakdown
+  }) => {
+    if (!currentTradeResult || !currentPosition) {
+      return;
     }
-    orderLog.push(nextEntry);
+    const previousClosedQty = currentTradeResult.closedQty;
+    const requestedExitPrice = getWeightedAverage(
+      currentTradeResult.requestedExitPrice,
+      previousClosedQty,
+      requestedPrice,
+      qty
+    );
+    const exitPrice = getWeightedAverage(
+      currentTradeResult.exitPrice,
+      previousClosedQty,
+      executionPrice,
+      qty
+    );
+    const exitBaseSlippageBps = getWeightedAverage(
+      currentTradeResult.exitBaseSlippageBps,
+      previousClosedQty,
+      slippageBreakdown.baseSlippageBps,
+      qty
+    );
+    const exitSpreadBps = getWeightedAverage(
+      currentTradeResult.exitSpreadBps,
+      previousClosedQty,
+      slippageBreakdown.spreadBps,
+      qty
+    );
+    const exitSpreadSlippageBps = getWeightedAverage(
+      currentTradeResult.exitSpreadSlippageBps,
+      previousClosedQty,
+      slippageBreakdown.spreadSlippageBps,
+      qty
+    );
+    const exitMarketImpactBps = getWeightedAverage(
+      currentTradeResult.exitMarketImpactBps,
+      previousClosedQty,
+      slippageBreakdown.marketImpactBps,
+      qty
+    );
+    const exitDelayRiskBps = null;
+    const exitSlippageCost = currentTradeResult.exitSlippageCost + getSlippageCost({
+      requestedPrice,
+      executionPrice,
+      direction: currentPosition.direction,
+      stage: "exit",
+      qty
+    });
+    currentTradeResult = {
+      ...currentTradeResult,
+      closedQty: previousClosedQty + qty,
+      exitTimestamp: timestamp,
+      exitReason: reason,
+      requestedExitPrice,
+      exitPrice,
+      grossProfit: currentTradeResult.grossProfit + grossProfit,
+      netProfit: currentTradeResult.netProfit + grossProfit - fee,
+      closeFee: currentTradeResult.closeFee + fee,
+      totalFee: currentTradeResult.openFee + currentTradeResult.closeFee + fee + (currentTradeResult.fundingFee ?? 0),
+      exitSlippagePrice: exitPrice - requestedExitPrice,
+      exitSlippageBps: getSlippageBps(requestedExitPrice, exitPrice),
+      exitBaseSlippageBps,
+      exitSpreadBps,
+      exitSpreadSlippageBps,
+      exitMarketImpactBps,
+      exitDelayRiskBps,
+      exitSlippageCost,
+      totalSlippageCost: currentTradeResult.entrySlippageCost + exitSlippageCost
+    };
   };
   const clearPosition = (timestamp) => {
     takeProfits = [];
@@ -69,11 +244,12 @@ var createTestConnector = (connector, context) => {
       return;
     }
     if (context?.mlEnabled || context?.aiEnabled) {
-      const signalId = currentPosition.signal?.signalId;
-      if (signalId) {
+      if (currentSignalId) {
+        const tradeResult = currentTradeResult ? finalizeTradeResult(currentTradeResult, timestamp) : void 0;
         closedSignalResults.push({
-          signalId,
-          profit: currentPositionProfit
+          signalId: currentSignalId,
+          profit: round(currentPositionProfit),
+          ...tradeResult ? { tradeResult } : {}
         });
       }
     }
@@ -89,10 +265,91 @@ var createTestConnector = (connector, context) => {
       }
     });
     currentPosition = null;
+    currentSignalId = null;
+    currentTradeResult = null;
     currentPositionProfit = 0;
   };
+  const getNetProfit = ({
+    grossProfit,
+    price,
+    qty,
+    feeRate = takerFeeRate
+  }) => {
+    const fee = price * qty * feeRate;
+    return {
+      fee,
+      profit: grossProfit - fee
+    };
+  };
+  const applyFunding = (candle) => {
+    if (!executionCostModel?.funding.enabled || !currentPosition) {
+      return;
+    }
+    for (const point of fundingRates) {
+      if (processedFundingTimestamps.has(point.timestamp) || point.symbol.toUpperCase() !== currentPosition.symbol.toUpperCase() || point.timestamp <= currentPosition.timestamp || point.timestamp > candle.timestamp) {
+        continue;
+      }
+      processedFundingTimestamps.add(point.timestamp);
+      const notional = candle.close * currentPosition.qty;
+      const fundingCost = notional * point.rate * (currentPosition.direction === "LONG" ? 1 : -1);
+      amount -= fundingCost;
+      currentPositionProfit -= fundingCost;
+      if (currentTradeResult) {
+        currentTradeResult.fundingFee = (currentTradeResult.fundingFee ?? 0) + fundingCost;
+        currentTradeResult.netProfit -= fundingCost;
+        currentTradeResult.totalFee += fundingCost;
+      }
+    }
+  };
+  const getExitTimestamp = (candle) => currentPosition ? Math.max(candle.timestamp, currentPosition.timestamp) : candle.timestamp;
+  const applyExecutionSlippage = ({
+    price,
+    direction,
+    stage,
+    signal
+  }) => {
+    const modelParams = {
+      baseSlippageBps: executionCostModel?.slippage.baseBps,
+      spreadBps: extractExecutionSpreadBps(signal),
+      spreadMultiplier: executionCostModel?.slippage.spreadMultiplier,
+      marketImpactBps: extractExecutionMarketImpactBps(signal) ?? executionCostModel?.slippage.marketImpactBps,
+      delayRiskBps: stage === "entry" ? (extractExecutionDelayRiskBps(signal) ?? 0) * (executionCostModel?.slippage.delayRiskMultiplier ?? 1) : null
+    };
+    return applyModeledExecutionSlippage({
+      price,
+      direction,
+      stage,
+      ...modelParams
+    });
+  };
+  const getExecutionSlippageBreakdown = ({
+    stage,
+    signal
+  }) => calculateExecutionSlippageBreakdown({
+    baseSlippageBps: executionCostModel?.slippage.baseBps,
+    spreadBps: extractExecutionSpreadBps(signal),
+    spreadMultiplier: executionCostModel?.slippage.spreadMultiplier,
+    marketImpactBps: extractExecutionMarketImpactBps(signal) ?? executionCostModel?.slippage.marketImpactBps,
+    delayRiskBps: stage === "entry" ? (extractExecutionDelayRiskBps(signal) ?? 0) * (executionCostModel?.slippage.delayRiskMultiplier ?? 1) : null
+  });
+  const getExecutionSlippageLogData = (slippageBreakdown, stage) => ({
+    executionSlippageStage: stage,
+    executionSlippageBps: round(slippageBreakdown.effectiveSlippageBps),
+    executionBaseSlippageBps: round(slippageBreakdown.baseSlippageBps),
+    executionSpreadBps: round(slippageBreakdown.spreadBps),
+    executionSpreadSlippageBps: round(slippageBreakdown.spreadSlippageBps),
+    executionMarketImpactBps: round(slippageBreakdown.marketImpactBps),
+    executionDelayRiskBps: stage === "entry" ? round(slippageBreakdown.delayRiskBps) : null
+  });
   return {
     __tradejsTestConnector: true,
+    capabilities: connector.capabilities,
+    universe: connector.universe,
+    accountId: connector.accountId,
+    deploymentId: connector.deploymentId,
+    listInstruments: (query) => connector.listInstruments(query),
+    getFundingRateHistory: connector.getFundingRateHistory ? (request) => connector.getFundingRateHistory(request) : void 0,
+    getTradingFeeRate: connector.getTradingFeeRate ? (symbol) => connector.getTradingFeeRate(symbol) : void 0,
     getState: async () => state,
     setState: async (newState) => {
       state = {
@@ -103,15 +360,22 @@ var createTestConnector = (connector, context) => {
     kline: async (options) => connector.kline(options),
     getResult: async () => {
       const orderLogId = randomUUID().slice(-12);
+      const fullStat = fastMode ? calculateStatsFull(positionLog) : null;
       return {
-        stat: {
-          amount,
-          profit: amount - INITIAL_AMOUNT,
+        stat: fullStat ? {
+          ...fullStat,
+          profit: fullStat.netProfit
+        } : {
+          amount: round(amount),
+          profit: round(amount - INITIAL_BACKTEST_AMOUNT),
           orders: positionLog.length
         },
         orderLogId,
-        inlineOrderLog: [...orderLog],
-        inlinePositionLog: [...positionLog]
+        ...executionCostModel ? { executionCostModel } : {},
+        ...fastMode ? {} : {
+          inlineOrderLog: orderLog,
+          inlinePositionLog: positionLog
+        }
       };
     },
     getPosition: async () => currentPosition || null,
@@ -137,6 +401,7 @@ var createTestConnector = (connector, context) => {
       if (!candle || !currentPosition || !currentPosition.qty) {
         return;
       }
+      applyFunding(candle);
       const isLong = currentPosition.direction === "LONG";
       const entryPrice = currentPosition.price;
       const high = candle.high;
@@ -146,47 +411,217 @@ var createTestConnector = (connector, context) => {
         const targetPrice = tp.price;
         const reached = isLong ? high >= targetPrice : low <= targetPrice;
         if (reached) {
+          const exitTimestamp = getExitTimestamp(candle);
           const qty = originalQty * tp.rate;
-          const profit = isLong ? (targetPrice - entryPrice) * qty : (entryPrice - targetPrice) * qty;
+          const slippageBreakdown = getExecutionSlippageBreakdown({
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const executionPrice = applyExecutionSlippage({
+            price: targetPrice,
+            direction: currentPosition.direction,
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const grossProfit = isLong ? (executionPrice - entryPrice) * qty : (entryPrice - executionPrice) * qty;
+          const { fee, profit } = getNetProfit({
+            grossProfit,
+            price: executionPrice,
+            qty
+          });
+          recordExitResult({
+            timestamp: exitTimestamp,
+            reason: "take_profit",
+            requestedPrice: targetPrice,
+            executionPrice,
+            qty,
+            grossProfit,
+            fee,
+            slippageBreakdown
+          });
           amount += profit;
           currentPositionProfit += profit;
           currentPosition.qty = parseFloat(
             (currentPosition.qty - qty).toFixed(8)
           );
           logOrder({
-            timestamp: candle.timestamp,
+            timestamp: exitTimestamp,
             qty,
-            price: targetPrice,
+            price: executionPrice,
             profit,
-            type: isLong ? "TAKE_PROFIT_LONG" : "TAKE_PROFIT_SHORT"
+            fee,
+            type: isLong ? "TAKE_PROFIT_LONG" : "TAKE_PROFIT_SHORT",
+            ...getExecutionSlippageLogData(slippageBreakdown, "exit")
           });
           tp.done = true;
         }
       }
       takeProfits = takeProfits.filter(({ done }) => !done);
       if (currentPosition && currentPosition.qty <= 0) {
-        clearPosition(candle.timestamp);
+        clearPosition(getExitTimestamp(candle));
       }
     },
     checkSl: async (candle) => {
       if (!stopLossPrice || !currentPosition || !candle) {
         return;
       }
+      applyFunding(candle);
       const isLong = currentPosition.direction === "LONG";
       const hitStop = isLong ? candle.low <= stopLossPrice : candle.high >= stopLossPrice;
       if (hitStop) {
+        const exitTimestamp = getExitTimestamp(candle);
         const qty = currentPosition.qty;
-        const profit = isLong ? (stopLossPrice - currentPosition.price) * qty : (currentPosition.price - stopLossPrice) * qty;
+        const slippageBreakdown = getExecutionSlippageBreakdown({
+          stage: "exit",
+          signal: currentPosition.signal
+        });
+        const executionPrice = applyExecutionSlippage({
+          price: stopLossPrice,
+          direction: currentPosition.direction,
+          stage: "exit",
+          signal: currentPosition.signal
+        });
+        const grossProfit = isLong ? (executionPrice - currentPosition.price) * qty : (currentPosition.price - executionPrice) * qty;
+        const { fee, profit } = getNetProfit({
+          grossProfit,
+          price: executionPrice,
+          qty
+        });
+        recordExitResult({
+          timestamp: exitTimestamp,
+          reason: "stop_loss",
+          requestedPrice: stopLossPrice,
+          executionPrice,
+          qty,
+          grossProfit,
+          fee,
+          slippageBreakdown
+        });
         amount += profit;
         currentPositionProfit += profit;
         logOrder({
-          timestamp: candle.timestamp,
+          timestamp: exitTimestamp,
           qty,
           profit,
-          price: stopLossPrice,
-          type: isLong ? "STOP_LOSS_LONG" : "STOP_LOSS_SHORT"
+          price: executionPrice,
+          fee,
+          type: isLong ? "STOP_LOSS_LONG" : "STOP_LOSS_SHORT",
+          ...getExecutionSlippageLogData(slippageBreakdown, "exit")
         });
-        clearPosition(candle.timestamp);
+        clearPosition(exitTimestamp);
+      }
+    },
+    checkExits: async (candle) => {
+      if (!candle || !currentPosition) {
+        return;
+      }
+      applyFunding(candle);
+      if (stopLossPrice) {
+        const isLong2 = currentPosition.direction === "LONG";
+        const hitStop = isLong2 ? candle.low <= stopLossPrice : candle.high >= stopLossPrice;
+        if (hitStop) {
+          const exitTimestamp = getExitTimestamp(candle);
+          const qty = currentPosition.qty;
+          const slippageBreakdown = getExecutionSlippageBreakdown({
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const executionPrice = applyExecutionSlippage({
+            price: stopLossPrice,
+            direction: currentPosition.direction,
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const grossProfit = isLong2 ? (executionPrice - currentPosition.price) * qty : (currentPosition.price - executionPrice) * qty;
+          const { fee, profit } = getNetProfit({
+            grossProfit,
+            price: executionPrice,
+            qty
+          });
+          recordExitResult({
+            timestamp: exitTimestamp,
+            reason: "stop_loss",
+            requestedPrice: stopLossPrice,
+            executionPrice,
+            qty,
+            grossProfit,
+            fee,
+            slippageBreakdown
+          });
+          amount += profit;
+          currentPositionProfit += profit;
+          logOrder({
+            timestamp: exitTimestamp,
+            qty,
+            profit,
+            price: executionPrice,
+            fee,
+            type: isLong2 ? "STOP_LOSS_LONG" : "STOP_LOSS_SHORT",
+            ...getExecutionSlippageLogData(slippageBreakdown, "exit")
+          });
+          clearPosition(exitTimestamp);
+        }
+      }
+      if (!currentPosition || !currentPosition.qty) {
+        return;
+      }
+      const isLong = currentPosition.direction === "LONG";
+      const entryPrice = currentPosition.price;
+      const high = candle.high;
+      const low = candle.low;
+      for (const tp of takeProfits) {
+        if (!currentPosition || currentPosition.qty <= 0) break;
+        const targetPrice = tp.price;
+        const reached = isLong ? high >= targetPrice : low <= targetPrice;
+        if (reached) {
+          const exitTimestamp = getExitTimestamp(candle);
+          const qty = originalQty * tp.rate;
+          const slippageBreakdown = getExecutionSlippageBreakdown({
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const executionPrice = applyExecutionSlippage({
+            price: targetPrice,
+            direction: currentPosition.direction,
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const grossProfit = isLong ? (executionPrice - entryPrice) * qty : (entryPrice - executionPrice) * qty;
+          const { fee, profit } = getNetProfit({
+            grossProfit,
+            price: executionPrice,
+            qty
+          });
+          recordExitResult({
+            timestamp: exitTimestamp,
+            reason: "take_profit",
+            requestedPrice: targetPrice,
+            executionPrice,
+            qty,
+            grossProfit,
+            fee,
+            slippageBreakdown
+          });
+          amount += profit;
+          currentPositionProfit += profit;
+          currentPosition.qty = parseFloat(
+            (currentPosition.qty - qty).toFixed(8)
+          );
+          logOrder({
+            timestamp: exitTimestamp,
+            qty,
+            price: executionPrice,
+            profit,
+            fee,
+            type: isLong ? "TAKE_PROFIT_LONG" : "TAKE_PROFIT_SHORT",
+            ...getExecutionSlippageLogData(slippageBreakdown, "exit")
+          });
+          tp.done = true;
+        }
+      }
+      takeProfits = takeProfits.filter(({ done }) => !done);
+      if (currentPosition && currentPosition.qty <= 0) {
+        clearPosition(getExitTimestamp(candle));
       }
     },
     placeOrder: async (order) => {
@@ -194,17 +629,77 @@ var createTestConnector = (connector, context) => {
         return false;
       }
       const isLong = order.direction === "LONG";
-      currentPosition = { ...order, amount };
+      const entrySlippageBreakdown = getExecutionSlippageBreakdown({
+        stage: "entry",
+        signal: order.signal
+      });
+      const entryPrice = applyExecutionSlippage({
+        price: order.price,
+        direction: order.direction,
+        stage: "entry",
+        signal: order.signal
+      });
+      currentPosition = { ...order, price: entryPrice, amount };
+      currentSignalId = typeof order.signal?.signalId === "string" && order.signal.signalId ? order.signal.signalId : null;
       originalQty = order.qty;
-      const fee = order.price * order.qty * FEE;
-      const profit = fee * -1;
+      const { fee, profit } = getNetProfit({
+        grossProfit: 0,
+        price: entryPrice,
+        qty: order.qty,
+        feeRate: order.isLimit ? makerFeeRate : takerFeeRate
+      });
+      const entrySlippageCost = getSlippageCost({
+        requestedPrice: order.price,
+        executionPrice: entryPrice,
+        direction: order.direction,
+        stage: "entry",
+        qty: order.qty
+      });
       amount += profit;
       currentPositionProfit = profit;
+      currentTradeResult = currentSignalId ? {
+        signalId: currentSignalId,
+        direction: order.direction,
+        qty: order.qty,
+        closedQty: 0,
+        entryTimestamp: order.timestamp,
+        exitTimestamp: null,
+        exitReason: null,
+        requestedEntryPrice: order.price,
+        entryPrice,
+        requestedExitPrice: null,
+        exitPrice: null,
+        grossProfit: 0,
+        netProfit: profit,
+        openFee: fee,
+        closeFee: 0,
+        fundingFee: executionCostModel?.funding.enabled ? 0 : null,
+        totalFee: fee,
+        entrySlippagePrice: entryPrice - order.price,
+        entrySlippageBps: getSlippageBps(order.price, entryPrice),
+        entryBaseSlippageBps: entrySlippageBreakdown.baseSlippageBps,
+        entrySpreadBps: entrySlippageBreakdown.spreadBps,
+        entrySpreadSlippageBps: entrySlippageBreakdown.spreadSlippageBps,
+        entryMarketImpactBps: entrySlippageBreakdown.marketImpactBps,
+        entryDelayRiskBps: entrySlippageBreakdown.delayRiskBps,
+        entrySlippageCost,
+        exitSlippagePrice: null,
+        exitSlippageBps: null,
+        exitBaseSlippageBps: null,
+        exitSpreadBps: null,
+        exitSpreadSlippageBps: null,
+        exitMarketImpactBps: null,
+        exitDelayRiskBps: null,
+        exitSlippageCost: 0,
+        totalSlippageCost: entrySlippageCost
+      } : null;
       logOrder({
         ...order,
+        price: entryPrice,
         profit,
         fee,
-        type: isLong ? "OPEN_LONG" : "OPEN_SHORT"
+        type: isLong ? "OPEN_LONG" : "OPEN_SHORT",
+        ...getExecutionSlippageLogData(entrySlippageBreakdown, "entry")
       });
       return true;
     },
@@ -231,14 +726,42 @@ var createTestConnector = (connector, context) => {
         return false;
       }
       const isLong = currentPosition.direction === "LONG";
-      const profit = isLong ? (order.price - currentPosition.price) * currentPosition.qty : (currentPosition.price - order.price) * currentPosition.qty;
+      const slippageBreakdown = getExecutionSlippageBreakdown({
+        stage: "exit",
+        signal: currentPosition.signal
+      });
+      const executionPrice = applyExecutionSlippage({
+        price: order.price,
+        direction: currentPosition.direction,
+        stage: "exit",
+        signal: currentPosition.signal
+      });
+      const grossProfit = isLong ? (executionPrice - currentPosition.price) * currentPosition.qty : (currentPosition.price - executionPrice) * currentPosition.qty;
+      const { fee, profit } = getNetProfit({
+        grossProfit,
+        price: executionPrice,
+        qty: currentPosition.qty
+      });
+      recordExitResult({
+        timestamp: order.timestamp,
+        reason: "exit",
+        requestedPrice: order.price,
+        executionPrice,
+        qty: currentPosition.qty,
+        grossProfit,
+        fee,
+        slippageBreakdown
+      });
       amount += profit;
       currentPositionProfit += profit;
       logOrder({
         ...order,
+        price: executionPrice,
         qty: currentPosition.qty,
         profit,
-        type: isLong ? "CLOSE_LONG" : "CLOSE_SHORT"
+        fee,
+        type: isLong ? "CLOSE_LONG" : "CLOSE_SHORT",
+        ...getExecutionSlippageLogData(slippageBreakdown, "exit")
       });
       clearPosition(order.timestamp);
       return true;
@@ -249,10 +772,200 @@ var createTestConnector = (connector, context) => {
   };
 };
 
+// src/executionCosts.ts
+import {
+  BACKTEST_BASE_SLIPPAGE_BPS,
+  BACKTEST_DELAY_RISK_MULTIPLIER,
+  BACKTEST_MARKET_IMPACT_BPS,
+  BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
+  FEE_PERCENT as FEE_PERCENT2
+} from "@tradejs/core/constants";
+var finiteOr = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+var feeCache = /* @__PURE__ */ new WeakMap();
+var fundingCache = /* @__PURE__ */ new WeakMap();
+var loadTradingFee = async (connector, symbol) => {
+  if (!connector.getTradingFeeRate) return null;
+  let cache = feeCache.get(connector);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    feeCache.set(connector, cache);
+  }
+  const key = symbol.toUpperCase();
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const rate = await connector.getTradingFeeRate(symbol);
+  cache.set(key, rate);
+  return rate;
+};
+var loadFundingRates = (connector, symbol, startTime, endTime) => {
+  if (!connector.getFundingRateHistory) return Promise.resolve([]);
+  let cache = fundingCache.get(connector);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    fundingCache.set(connector, cache);
+  }
+  const key = `${symbol.toUpperCase()}:${startTime}:${endTime}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const pending = connector.getFundingRateHistory({ symbol, startTime, endTime }).catch(() => []);
+  cache.set(key, pending);
+  return pending;
+};
+var resolveExecutionCosts = async (params) => {
+  const { connector, symbol, config, startTime, endTime, instrument } = params;
+  const cacheOnly = config.EXECUTION_COSTS_CACHE_ONLY === true;
+  const hasConfiguredFees = Number.isFinite(Number(config.MAKER_FEE_RATE)) && Number.isFinite(Number(config.TAKER_FEE_RATE));
+  const exchangeFees = !cacheOnly && !hasConfiguredFees && connector.getTradingFeeRate ? await loadTradingFee(connector, symbol).catch(() => null) : null;
+  const makerRate = hasConfiguredFees ? Number(config.MAKER_FEE_RATE) : exchangeFees?.makerRate ?? FEE_PERCENT2;
+  const takerRate = hasConfiguredFees ? Number(config.TAKER_FEE_RATE) : exchangeFees?.takerRate ?? FEE_PERCENT2;
+  const fundingEnabled = config.FUNDING_ENABLED !== false && !cacheOnly && typeof connector.getFundingRateHistory === "function";
+  const fundingRates = fundingEnabled ? await loadFundingRates(connector, symbol, startTime, endTime) : [];
+  const requestedLeverage = Math.max(1, finiteOr(config.LEVERAGE, 10));
+  const venueMaxLeverage = Number(instrument?.venueMetadata?.maxLeverage);
+  const maxAllowed = Number.isFinite(venueMaxLeverage) ? venueMaxLeverage : null;
+  const effectiveLeverage = maxAllowed == null ? requestedLeverage : Math.min(requestedLeverage, maxAllowed);
+  const feeSource = hasConfiguredFees ? "config" : exchangeFees?.source ?? "fallback";
+  const fundingSource = !fundingEnabled ? cacheOnly ? "fallback" : "disabled" : fundingRates.length ? "historical" : "unavailable";
+  const usesFallback = feeSource === "fallback" || fundingEnabled && fundingSource === "unavailable" || config.SLIPPAGE_BASE_BPS == null && config.SLIPPAGE_SPREAD_MULTIPLIER == null && config.SLIPPAGE_MARKET_IMPACT_BPS == null;
+  return {
+    model: {
+      fees: { makerRate, takerRate, source: feeSource },
+      funding: {
+        enabled: fundingEnabled,
+        source: fundingSource,
+        points: fundingRates.length,
+        fromTimestamp: fundingRates[0]?.timestamp ?? null,
+        toTimestamp: fundingRates.at(-1)?.timestamp ?? null
+      },
+      slippage: {
+        baseBps: finiteOr(config.SLIPPAGE_BASE_BPS, BACKTEST_BASE_SLIPPAGE_BPS),
+        spreadMultiplier: finiteOr(
+          config.SLIPPAGE_SPREAD_MULTIPLIER,
+          BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER
+        ),
+        marketImpactBps: finiteOr(
+          config.SLIPPAGE_MARKET_IMPACT_BPS,
+          BACKTEST_MARKET_IMPACT_BPS
+        ),
+        delayRiskMultiplier: finiteOr(
+          config.SLIPPAGE_DELAY_RISK_MULTIPLIER,
+          BACKTEST_DELAY_RISK_MULTIPLIER
+        ),
+        source: config.SLIPPAGE_BASE_BPS != null || config.SLIPPAGE_SPREAD_MULTIPLIER != null || config.SLIPPAGE_MARKET_IMPACT_BPS != null ? "config" : "fallback"
+      },
+      leverage: {
+        requested: requestedLeverage,
+        effective: effectiveLeverage,
+        maxAllowed
+      },
+      quality: usesFallback ? "fallback" : fundingEnabled && fundingRates.length ? "full" : "partial",
+      capturedAt: Date.now()
+    },
+    fundingRates
+  };
+};
+
 // src/testing.ts
+var isBacktestEntryDelayControlCode = (value) => typeof value === "string" && value.startsWith("BACKTEST_ENTRY_DELAY_");
+var CLOSED_RESULT_FLUSH_INTERVAL = 500;
+var DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS = 6e4;
+var resolvePositiveInt = (value, fallback) => {
+  const parsed = parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var getStrategyCandleTimeoutMs = () => resolvePositiveInt(
+  process.env.BACKTEST_STRATEGY_CANDLE_TIMEOUT_MS,
+  DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS
+);
+var getEffectiveTimeoutMs = (baseTimeoutMs, stageTimeoutMs) => {
+  const base = baseTimeoutMs && baseTimeoutMs > 0 ? Math.trunc(baseTimeoutMs) : null;
+  const stage = stageTimeoutMs && stageTimeoutMs > 0 ? Math.trunc(stageTimeoutMs) : null;
+  if (base == null) return stage;
+  if (stage == null) return base;
+  return Math.min(base, stage);
+};
+var buildCandleByTimestamp = (candles) => new Map(
+  (candles ?? []).filter((candle) => typeof candle?.timestamp === "number").map((candle) => [candle.timestamp, candle])
+);
+var buildBacktestDatasetMetadata = ({
+  backtestRunId,
+  backtestTestKey,
+  chunkId
+}) => {
+  if (!backtestRunId || !backtestTestKey || !chunkId) {
+    return {};
+  }
+  return {
+    backtestRunId,
+    backtestTestKey,
+    backtestChunkId: chunkId
+  };
+};
+var cloneAiPayloadSignal = (signal) => {
+  const cloneValue = (value) => {
+    if (value == null) {
+      return value;
+    }
+    if (typeof structuredClone === "function") {
+      return structuredClone(value);
+    }
+    return JSON.parse(JSON.stringify(value));
+  };
+  return {
+    ...signal,
+    figures: cloneValue(signal.figures),
+    indicators: cloneValue(signal.indicators),
+    additionalIndicators: cloneValue(signal.additionalIndicators)
+  };
+};
+var buildReplaySignalEvaluationRecord = ({
+  signal,
+  testId,
+  userName,
+  strategyName,
+  symbol,
+  interval,
+  candle
+}) => {
+  if (!signal || typeof signal === "string") {
+    return {
+      evaluationId: `${testId}:${strategyName}:${symbol}:${candle.timestamp}`,
+      userName,
+      strategy: strategyName,
+      symbol,
+      interval,
+      timestamp: candle.timestamp,
+      evaluatedAt: candle.timestamp,
+      status: "skip",
+      reason: typeof signal === "string" && signal.trim() ? signal : "NO_SIGNAL"
+    };
+  }
+  const signalTimestamp = typeof signal.timestamp === "number" && Number.isFinite(signal.timestamp) ? signal.timestamp : candle.timestamp;
+  return {
+    evaluationId: `${signal.signalId || testId}:${strategyName}:${symbol}:${signalTimestamp}`,
+    userName,
+    strategy: signal.strategy || strategyName,
+    symbol: signal.symbol || symbol,
+    interval: signal.interval || interval,
+    timestamp: signalTimestamp,
+    evaluatedAt: candle.timestamp,
+    status: "signal",
+    reason: signal.orderSkipReason || signal.orderStatus,
+    signalId: signal.signalId,
+    direction: signal.direction,
+    orderStatus: signal.orderStatus,
+    orderSkipReason: signal.orderSkipReason,
+    aiAnalysis: signal.aiAnalysis ?? null,
+    ml: signal.ml
+  };
+};
 var createTestingKlineCacheState = () => ({
   coinKlineCache: /* @__PURE__ */ new Map(),
   btcKlineCache: /* @__PURE__ */ new Map(),
+  ethKlineCache: /* @__PURE__ */ new Map(),
   btcBinanceKlineCache: /* @__PURE__ */ new Map(),
   btcCoinbaseKlineCache: /* @__PURE__ */ new Map(),
   preparedDataCache: /* @__PURE__ */ new Map(),
@@ -279,11 +992,15 @@ var getKlineCacheKey = (params) => {
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe,
+    accountId
   } = params;
   return [
     userName,
     connectorName,
+    universe ?? "crypto",
+    accountId ?? "default",
     symbol,
     preloadStart,
     end,
@@ -301,21 +1018,47 @@ var getPreparedDataCacheKey = (params) => {
     end,
     interval,
     btcBinanceConnectorName,
-    btcCoinbaseConnectorName
+    btcCoinbaseConnectorName,
+    backtestExecutionInterval,
+    universe,
+    accountId
   } = params;
   return [
     userName,
     connectorName,
+    universe ?? "crypto",
+    accountId ?? "default",
     symbol,
     preloadStart,
     start,
     end,
     interval,
+    backtestExecutionInterval,
     btcBinanceConnectorName,
     btcCoinbaseConnectorName
   ].join(":");
 };
-var getConnectorCacheKey = (params) => [params.userName, params.connectorName].join(":");
+var getConnectorCacheKey = (params) => [
+  params.userName,
+  params.connectorName,
+  params.universe ?? "crypto",
+  params.accountId ?? "default"
+].join(":");
+var BACKTEST_INTERVAL = "15";
+var resolveBacktestExecutionInterval = (interval) => {
+  const normalized = String(interval);
+  if (normalized === "15") {
+    return BACKTEST_EXECUTION_INTERVAL;
+  }
+  if (normalized === "60") {
+    return "15";
+  }
+  return null;
+};
+var resolveIntervalMs = (interval) => {
+  const intervalMinutes = Number(interval);
+  return Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? intervalMinutes * 6e4 : Number(BACKTEST_INTERVAL) * 6e4;
+};
 var splitCandlesForTesting = (candles, start, preloadStart) => {
   const prevData = [];
   const testData = [];
@@ -329,9 +1072,56 @@ var splitCandlesForTesting = (candles, start, preloadStart) => {
   }
   return { prevData, testData };
 };
+var getCurrentOpenTimestamp = (interval) => {
+  const intervalMs = resolveIntervalMs(interval);
+  return Math.floor(Date.now() / intervalMs) * intervalMs;
+};
+var filterClosedAlignedCandles = (data, btcData, interval) => {
+  const currentOpenTimestamp = getCurrentOpenTimestamp(interval);
+  const closedData = [];
+  const closedBtcData = [];
+  for (let index = 0; index < data.length; index += 1) {
+    const candle = data[index];
+    const btcCandle = btcData[index];
+    if (!candle || !btcCandle || candle.timestamp >= currentOpenTimestamp) {
+      continue;
+    }
+    closedData.push(candle);
+    closedBtcData.push(btcCandle);
+  }
+  return {
+    data: closedData,
+    btcData: closedBtcData
+  };
+};
+var shouldLoadBacktestExecutionCandles = (interval) => {
+  if (!BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED) {
+    return false;
+  }
+  const executionInterval = resolveBacktestExecutionInterval(interval);
+  if (!executionInterval) {
+    return false;
+  }
+  const primaryMs = resolveIntervalMs(interval);
+  const executionMs = resolveIntervalMs(executionInterval);
+  return executionMs > 0 && executionMs < primaryMs;
+};
 var getCachedConnector = async (params) => {
-  const { state, projectRoot, userName, connectorName } = params;
-  const cacheKey = getConnectorCacheKey({ userName, connectorName });
+  const {
+    state,
+    projectRoot,
+    userName,
+    connectorName,
+    universe,
+    accountId,
+    deploymentId
+  } = params;
+  const cacheKey = getConnectorCacheKey({
+    userName,
+    connectorName,
+    universe,
+    accountId
+  });
   const cachedConnector = state.connectorCache.get(cacheKey);
   if (cachedConnector) {
     return cachedConnector;
@@ -344,7 +1134,10 @@ var getCachedConnector = async (params) => {
     return void 0;
   }
   const connector = await connectorCreator({
-    userName
+    userName,
+    universe,
+    accountId,
+    deploymentId
   });
   state.connectorCache.set(cacheKey, connector);
   return connector;
@@ -359,107 +1152,64 @@ var resetTestingKlineCache = (cwd) => {
     getTradejsProjectCwd(normalizedCwd)
   );
 };
-var testing = async ({
-  userName,
-  symbol,
-  options: { start, end },
-  name,
-  testId,
-  testSuiteId,
-  strategyName,
-  strategyConfig,
-  connectorName,
-  ml = false,
-  ai = false,
-  chunkId = "single",
-  timeoutMs
-}) => {
-  if (!start) {
-    throw new Error("no start");
-  }
-  const preloadStart = getBacktestPreloadStart(start);
-  const startedAt = Date.now();
-  const formatTimeoutMessage = (stage) => `Test ${name} (${symbol}) timed out after ${timeoutMs}ms during ${stage}`;
-  const getRemainingTimeoutMs = (stage) => {
-    if (!timeoutMs || timeoutMs <= 0) {
-      return null;
-    }
-    const remainingMs = timeoutMs - (Date.now() - startedAt);
-    if (remainingMs <= 0) {
-      throw new Error(formatTimeoutMessage(stage));
-    }
-    return remainingMs;
-  };
-  const throwIfTimedOut = (stage) => {
-    getRemainingTimeoutMs(stage);
-  };
-  const withTimeout = async (stage, promise) => {
-    const remainingMs = getRemainingTimeoutMs(stage);
-    if (remainingMs == null) {
-      return promise;
+var releaseTestingSymbolCache = (params) => {
+  const { cwd, userName, connectorName, symbol } = params;
+  const { state } = getTestingKlineCacheState(cwd);
+  const connectorPrefix = [userName, connectorName].join(":") + ":";
+  for (const cache of [state.coinKlineCache, state.preparedDataCache]) {
+    for (const key of cache.keys()) {
+      if (key.startsWith(connectorPrefix) && key.split(":").includes(symbol)) {
+        cache.delete(key);
+      }
     }
-    return await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(formatTimeoutMessage(stage)));
-      }, remainingMs);
-      promise.then(
-        (value) => {
-          clearTimeout(timer);
-          resolve(value);
-        },
-        (error) => {
-          clearTimeout(timer);
-          reject(error);
-        }
-      );
-    });
-  };
-  const { projectRoot, state } = getTestingKlineCacheState();
-  const connector = await withTimeout(
-    "connector init",
-    getCachedConnector({
-      state,
-      projectRoot,
-      userName,
-      connectorName
-    })
-  );
+  }
+};
+var prepareTestingData = async (params) => {
+  const {
+    state,
+    projectRoot,
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    start,
+    end,
+    interval,
+    universe = "crypto",
+    accountId,
+    deploymentId
+  } = params;
+  const binanceConnector = universe === "crypto" ? await getCachedConnector({
+    state,
+    projectRoot,
+    userName,
+    connectorName: BUILTIN_CONNECTOR_NAMES.Binance
+  }) : void 0;
+  const coinbaseConnector = universe === "crypto" ? await getCachedConnector({
+    state,
+    projectRoot,
+    userName,
+    connectorName: BUILTIN_CONNECTOR_NAMES.Coinbase
+  }) : void 0;
+  const cacheOnly = true;
+  const connector = await getCachedConnector({
+    state,
+    projectRoot,
+    userName,
+    connectorName,
+    universe,
+    accountId,
+    deploymentId
+  });
   if (!connector) {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
-  const strategyCreator = await withTimeout(
-    "strategy lookup",
-    getStrategyCreator(strategyName, projectRoot)
-  );
-  if (!strategyCreator) {
-    throw new Error(`Unknown strategy: ${strategyName}`);
-  }
-  const binanceConnector = await withTimeout(
-    "binance connector init",
-    getCachedConnector({
-      state,
-      projectRoot,
-      userName,
-      connectorName: BUILTIN_CONNECTOR_NAMES.Binance
-    })
-  );
-  const coinbaseConnector = await withTimeout(
-    "coinbase connector init",
-    getCachedConnector({
-      state,
-      projectRoot,
-      userName,
-      connectorName: BUILTIN_CONNECTOR_NAMES.Coinbase
-    })
-  );
   if (!binanceConnector || !coinbaseConnector) {
     logger.warn(
       "Binance/Coinbase connectors are unavailable. Reusing %s for BTC references.",
       connectorName
     );
   }
-  const interval = "15";
-  const cacheOnly = true;
   const coinCacheKey = getKlineCacheKey({
     userName,
     connectorName,
@@ -467,7 +1217,9 @@ var testing = async ({
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe,
+    accountId
   });
   const btcCacheKey = getKlineCacheKey({
     userName,
@@ -476,12 +1228,23 @@ var testing = async ({
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe,
+    accountId
+  });
+  const ethCacheKey = getKlineCacheKey({
+    userName,
+    connectorName,
+    symbol: "ETHUSDT",
+    preloadStart,
+    end,
+    interval,
+    cacheOnly,
+    universe,
+    accountId
   });
   const btcBinanceConnectorName = binanceConnector ? BUILTIN_CONNECTOR_NAMES.Binance : connectorName;
   const btcCoinbaseConnectorName = coinbaseConnector ? BUILTIN_CONNECTOR_NAMES.Coinbase : connectorName;
-  const cachedCoinData = state.coinKlineCache.get(coinCacheKey);
-  const cachedBtcData = state.btcKlineCache.get(btcCacheKey);
   const btcBinanceCacheKey = getKlineCacheKey({
     userName,
     connectorName: btcBinanceConnectorName,
@@ -489,7 +1252,8 @@ var testing = async ({
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe: "crypto"
   });
   const btcCoinbaseCacheKey = getKlineCacheKey({
     userName,
@@ -498,10 +1262,41 @@ var testing = async ({
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe: "crypto"
   });
+  const cachedCoinData = state.coinKlineCache.get(coinCacheKey);
+  const cachedBtcData = state.btcKlineCache.get(btcCacheKey);
+  const cachedEthData = state.ethKlineCache.get(ethCacheKey);
   const cachedBtcBinanceData = state.btcBinanceKlineCache.get(btcBinanceCacheKey);
   const cachedBtcCoinbaseData = state.btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
+  const backtestExecutionInterval = resolveBacktestExecutionInterval(interval);
+  const backtestExecutionCacheInterval = backtestExecutionInterval ?? interval;
+  const shouldLoadExecutionCandles = backtestExecutionInterval != null && shouldLoadBacktestExecutionCandles(interval);
+  const executionCoinCacheKey = getKlineCacheKey({
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    end,
+    interval: backtestExecutionCacheInterval,
+    cacheOnly,
+    universe,
+    accountId
+  });
+  const executionBtcCacheKey = getKlineCacheKey({
+    userName,
+    connectorName,
+    symbol: "BTCUSDT",
+    preloadStart,
+    end,
+    interval: backtestExecutionCacheInterval,
+    cacheOnly,
+    universe,
+    accountId
+  });
+  const cachedExecutionCoinData = shouldLoadExecutionCandles ? state.coinKlineCache.get(executionCoinCacheKey) : void 0;
+  const cachedExecutionBtcData = shouldLoadExecutionCandles ? state.btcKlineCache.get(executionBtcCacheKey) : void 0;
   const preparedDataCacheKey = getPreparedDataCacheKey({
     userName,
     connectorName,
@@ -510,118 +1305,407 @@ var testing = async ({
     start,
     end,
     interval,
+    backtestExecutionInterval: backtestExecutionCacheInterval,
     btcBinanceConnectorName,
-    btcCoinbaseConnectorName
+    btcCoinbaseConnectorName,
+    universe,
+    accountId
   });
-  let preparedData = state.preparedDataCache.get(preparedDataCacheKey);
-  if (!preparedData) {
-    const [data, btcData, btcBinanceData, btcCoinbaseData] = await withTimeout(
-      "kline preload",
-      Promise.all([
-        cachedCoinData ? Promise.resolve(cachedCoinData) : connector.kline({
-          symbol,
-          start: preloadStart,
-          end,
-          interval,
-          silent: true,
-          cacheOnly
-        }),
-        cachedBtcData ? Promise.resolve(cachedBtcData) : connector.kline({
-          symbol: "BTCUSDT",
-          start: preloadStart,
-          end,
-          interval,
-          silent: true,
-          cacheOnly
-        }),
-        cachedBtcBinanceData ? Promise.resolve(cachedBtcBinanceData) : (binanceConnector ?? connector).kline({
-          symbol: "BTCUSDT",
-          start: preloadStart,
-          end,
-          interval,
-          silent: true,
-          cacheOnly
-        }),
-        cachedBtcCoinbaseData ? Promise.resolve(cachedBtcCoinbaseData) : (coinbaseConnector ?? connector).kline({
-          symbol: "BTCUSDT",
-          start: preloadStart,
-          end,
-          interval,
-          silent: true,
-          cacheOnly
-        })
-      ])
-    );
-    if (!cachedCoinData) {
-      state.coinKlineCache.set(coinCacheKey, data);
-    }
-    if (!cachedBtcData) {
-      state.btcKlineCache.set(btcCacheKey, btcData);
+  const cachedPreparedData = state.preparedDataCache.get(preparedDataCacheKey);
+  if (cachedPreparedData) {
+    return cachedPreparedData;
+  }
+  const btcDataPromise = universe === "tradfi" ? Promise.resolve([]) : cachedBtcData ? Promise.resolve(cachedBtcData) : connector.kline({
+    symbol: "BTCUSDT",
+    start: preloadStart,
+    end,
+    interval,
+    silent: true,
+    cacheOnly
+  });
+  const ethDataPromise = universe === "tradfi" ? Promise.resolve([]) : cachedEthData ? Promise.resolve(cachedEthData) : connector.kline({
+    symbol: "ETHUSDT",
+    start: preloadStart,
+    end,
+    interval,
+    silent: true,
+    cacheOnly
+  });
+  const btcBinanceDataPromise = universe === "tradfi" ? Promise.resolve([]) : cachedBtcBinanceData ? Promise.resolve(cachedBtcBinanceData) : btcBinanceCacheKey === btcCacheKey ? btcDataPromise : (binanceConnector ?? connector).kline({
+    symbol: "BTCUSDT",
+    start: preloadStart,
+    end,
+    interval,
+    silent: true,
+    cacheOnly
+  });
+  const btcCoinbaseDataPromise = universe === "tradfi" ? Promise.resolve([]) : cachedBtcCoinbaseData ? Promise.resolve(cachedBtcCoinbaseData) : btcCoinbaseCacheKey === btcCacheKey ? btcDataPromise : (coinbaseConnector ?? connector).kline({
+    symbol: "BTCUSDT",
+    start: preloadStart,
+    end,
+    interval,
+    silent: true,
+    cacheOnly
+  });
+  const executionDataPromise = !shouldLoadExecutionCandles ? Promise.resolve([]) : cachedExecutionCoinData ? Promise.resolve(cachedExecutionCoinData) : connector.kline({
+    symbol,
+    start: preloadStart,
+    end,
+    interval: backtestExecutionInterval,
+    silent: true,
+    cacheOnly
+  });
+  const executionBtcDataPromise = universe === "tradfi" || !shouldLoadExecutionCandles ? Promise.resolve([]) : cachedExecutionBtcData ? Promise.resolve(cachedExecutionBtcData) : connector.kline({
+    symbol: "BTCUSDT",
+    start: preloadStart,
+    end,
+    interval: backtestExecutionInterval,
+    silent: true,
+    cacheOnly
+  });
+  const [
+    dataRaw,
+    btcDataRaw,
+    ethDataRaw,
+    btcBinanceDataRaw,
+    btcCoinbaseDataRaw,
+    executionDataRaw,
+    executionBtcDataRaw
+  ] = await Promise.all([
+    cachedCoinData ? Promise.resolve(cachedCoinData) : connector.kline({
+      symbol,
+      start: preloadStart,
+      end,
+      interval,
+      silent: true,
+      cacheOnly
+    }),
+    btcDataPromise,
+    ethDataPromise,
+    btcBinanceDataPromise,
+    btcCoinbaseDataPromise,
+    executionDataPromise,
+    executionBtcDataPromise
+  ]);
+  if (!cachedCoinData) {
+    state.coinKlineCache.set(coinCacheKey, dataRaw);
+  }
+  if (!cachedBtcData) {
+    state.btcKlineCache.set(btcCacheKey, btcDataRaw);
+  }
+  if (!cachedEthData) {
+    state.ethKlineCache.set(ethCacheKey, ethDataRaw);
+  }
+  if (!cachedBtcBinanceData) {
+    state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceDataRaw);
+  }
+  if (!cachedBtcCoinbaseData) {
+    state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseDataRaw);
+  }
+  if (shouldLoadExecutionCandles && !cachedExecutionCoinData) {
+    state.coinKlineCache.set(executionCoinCacheKey, executionDataRaw);
+  }
+  if (shouldLoadExecutionCandles && !cachedExecutionBtcData) {
+    state.btcKlineCache.set(executionBtcCacheKey, executionBtcDataRaw);
+  }
+  const aligned = universe === "tradfi" ? { alignedCoinCandles: dataRaw, alignedBtcCandles: dataRaw } : alignSortedCandlesByTimestamp(dataRaw, btcDataRaw);
+  const { data, btcData } = filterClosedAlignedCandles(
+    aligned.alignedCoinCandles,
+    aligned.alignedBtcCandles,
+    interval
+  );
+  const btcBinanceData = universe === "tradfi" ? [] : alignSortedCandlesByTimestamp(data, btcBinanceDataRaw).alignedBtcCandles;
+  const btcCoinbaseData = universe === "tradfi" ? [] : alignSortedCandlesByTimestamp(data, btcCoinbaseDataRaw).alignedBtcCandles;
+  const ethData = universe === "tradfi" ? [] : alignSortedCandlesByTimestamp(data, ethDataRaw).alignedBtcCandles;
+  const alignedExecution = shouldLoadExecutionCandles ? universe === "tradfi" ? {
+    alignedCoinCandles: executionDataRaw,
+    alignedBtcCandles: executionDataRaw
+  } : alignSortedCandlesByTimestamp(executionDataRaw, executionBtcDataRaw) : { alignedCoinCandles: [], alignedBtcCandles: [] };
+  const { data: backtestExecutionData, btcData: backtestExecutionBtcData } = filterClosedAlignedCandles(
+    alignedExecution.alignedCoinCandles,
+    alignedExecution.alignedBtcCandles,
+    backtestExecutionCacheInterval
+  );
+  const backtestExecutionDataByTimestamp = buildCandleByTimestamp(
+    backtestExecutionData
+  );
+  const backtestExecutionBtcDataByTimestamp = buildCandleByTimestamp(
+    backtestExecutionBtcData
+  );
+  const { prevData, testData } = splitCandlesForTesting(
+    data,
+    start,
+    preloadStart
+  );
+  const { prevData: btcPrevData, testData: btcTestData } = splitCandlesForTesting(btcData, start, preloadStart);
+  const { prevData: ethPrevData, testData: ethTestData } = splitCandlesForTesting(ethData, start, preloadStart);
+  const preparedData = {
+    data,
+    btcData,
+    ethData,
+    prevData,
+    btcPrevData,
+    ethPrevData,
+    testData,
+    btcTestData,
+    ethTestData,
+    btcBinanceData,
+    btcCoinbaseData,
+    backtestExecutionInterval: backtestExecutionCacheInterval,
+    backtestExecutionData,
+    backtestExecutionBtcData,
+    backtestExecutionDataByTimestamp,
+    backtestExecutionBtcDataByTimestamp
+  };
+  state.preparedDataCache.set(preparedDataCacheKey, preparedData);
+  return preparedData;
+};
+var canRunTestsInSharedCandleLoop = (tests) => {
+  if (tests.length <= 1) {
+    return false;
+  }
+  const first = tests[0];
+  const firstStart = first.options?.start;
+  const firstEnd = first.options?.end;
+  return tests.every(
+    (test) => test.userName === first.userName && test.connectorName === first.connectorName && (test.universe ?? "crypto") === (first.universe ?? "crypto") && (test.accountId ?? null) === (first.accountId ?? null) && (test.deploymentId ?? null) === (first.deploymentId ?? null) && test.symbol === first.symbol && test.strategyName === first.strategyName && test.options?.start === firstStart && test.options?.end === firstEnd && Boolean(test.ml) === Boolean(first.ml) && Boolean(test.ai) === Boolean(first.ai) && Boolean(test.fast) === Boolean(first.fast) && Boolean(test.collectReplaySignalEvaluations) === Boolean(first.collectReplaySignalEvaluations) && (test.interval ?? BACKTEST_INTERVAL) === (first.interval ?? BACKTEST_INTERVAL) && (test.timeoutMs ?? null) === (first.timeoutMs ?? null)
+  );
+};
+var testing = async ({
+  userName,
+  symbol,
+  options: { start, end },
+  name,
+  testId,
+  testSuiteId,
+  configId,
+  strategyName,
+  strategyConfig,
+  connectorName,
+  universe = "crypto",
+  assetClass,
+  instrument: requestedInstrument,
+  accountId,
+  deploymentId,
+  policyProfileId,
+  interval = BACKTEST_INTERVAL,
+  ml = false,
+  ai = false,
+  fast = false,
+  collectReplaySignalEvaluations = false,
+  chunkId = "single",
+  backtestRunId,
+  backtestTestKey,
+  timeoutMs
+}) => {
+  if (!start) {
+    throw new Error("no start");
+  }
+  const preloadStart = getBacktestPreloadStart(start);
+  const startedAt = Date.now();
+  let activeStageStartedAt = startedAt;
+  let lastProgressSentAt = 0;
+  let lastProgressSignature = "";
+  let currentCandleIndex = 0;
+  let totalCandles = 0;
+  const strategyCandleTimeoutMs = getStrategyCandleTimeoutMs();
+  const formatTimeoutMessage = (stage, stageTimeoutMs) => `Test ${name} (${symbol}) timed out after ${stageTimeoutMs}ms during ${stage}`;
+  const emitProgress = (stage, options = {}) => {
+    const now = Date.now();
+    const candleIndex = typeof options.candleIndex === "number" ? options.candleIndex : currentCandleIndex;
+    const candleTotal = typeof options.candleTotal === "number" ? options.candleTotal : totalCandles;
+    const signature = [
+      stage,
+      candleIndex,
+      candleTotal,
+      Math.floor((now - activeStageStartedAt) / 5e3)
+    ].join(":");
+    if (!options.force) {
+      if (signature === lastProgressSignature) {
+        return;
+      }
+      if (now - lastProgressSentAt < 4e3) {
+        return;
+      }
     }
-    if (!cachedBtcBinanceData) {
-      state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
+    lastProgressSentAt = now;
+    lastProgressSignature = signature;
+    process.send?.({
+      progress: true,
+      testName: name,
+      symbol,
+      strategyName,
+      stage,
+      candleIndex,
+      candleTotal,
+      elapsedMs: now - startedAt,
+      stageElapsedMs: now - activeStageStartedAt
+    });
+  };
+  const getStageTimeoutMs = () => {
+    if (!timeoutMs || timeoutMs <= 0) {
+      return null;
     }
-    if (!cachedBtcCoinbaseData) {
-      state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
+    return timeoutMs;
+  };
+  const throwIfTimedOut = (stage) => {
+    if (getStageTimeoutMs() == null) {
+      return;
     }
-    const { prevData: prevDataRaw, testData: testDataRaw } = splitCandlesForTesting(data, start, preloadStart);
-    const { prevData: btcPrevDataRaw, testData: btcTestDataRaw } = splitCandlesForTesting(btcData, start, preloadStart);
-    const { prevData: btcBinancePrevDataRaw } = splitCandlesForTesting(
-      btcBinanceData,
-      start,
-      preloadStart
-    );
-    const { prevData: btcCoinbasePrevDataRaw } = splitCandlesForTesting(
-      btcCoinbaseData,
-      start,
-      preloadStart
+    emitProgress(stage);
+  };
+  const withTimeout = async (stage, promise, stageTimeoutOverrideMs = null) => {
+    const stageTimeoutMs = getEffectiveTimeoutMs(
+      getStageTimeoutMs() ?? void 0,
+      stageTimeoutOverrideMs
     );
-    const { alignedCoinCandles: prevData2, alignedBtcCandles: btcPrevData2 } = alignSortedCandlesByTimestamp(prevDataRaw, btcPrevDataRaw);
-    const { alignedCoinCandles: testData2, alignedBtcCandles: btcTestData2 } = alignSortedCandlesByTimestamp(testDataRaw, btcTestDataRaw);
-    const { alignedBtcCandles: btcBinancePrevData2 } = alignSortedCandlesByTimestamp(prevDataRaw, btcBinancePrevDataRaw);
-    const { alignedBtcCandles: btcCoinbasePrevData2 } = alignSortedCandlesByTimestamp(prevDataRaw, btcCoinbasePrevDataRaw);
-    preparedData = {
-      prevData: prevData2,
-      btcPrevData: btcPrevData2,
-      testData: testData2,
-      btcTestData: btcTestData2,
-      btcBinancePrevData: btcBinancePrevData2,
-      btcCoinbasePrevData: btcCoinbasePrevData2
-    };
-    state.preparedDataCache.set(preparedDataCacheKey, preparedData);
+    if (stageTimeoutMs == null) {
+      return promise;
+    }
+    activeStageStartedAt = Date.now();
+    emitProgress(stage, { force: true });
+    return await new Promise((resolve, reject) => {
+      const heartbeat = setInterval(() => {
+        emitProgress(stage);
+      }, 5e3);
+      const timer = setTimeout(() => {
+        clearInterval(heartbeat);
+        reject(new Error(formatTimeoutMessage(stage, stageTimeoutMs)));
+      }, stageTimeoutMs);
+      promise.then(
+        (value) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  };
+  const runStage = (stage, fn) => {
+    if (getStageTimeoutMs() == null) {
+      return fn();
+    }
+    return withTimeout(stage, fn());
+  };
+  const runStrategyCandleStage = (stage, fn) => withTimeout(stage, fn(), strategyCandleTimeoutMs);
+  const { projectRoot, state } = getTestingKlineCacheState();
+  const connector = await withTimeout(
+    "connector init",
+    getCachedConnector({
+      state,
+      projectRoot,
+      userName,
+      connectorName,
+      universe,
+      accountId,
+      deploymentId
+    })
+  );
+  if (!connector) {
+    throw new Error(`Unknown connector: ${connectorName}`);
+  }
+  const strategyCreator = await withTimeout(
+    "strategy lookup",
+    getStrategyCreator(strategyName, projectRoot)
+  );
+  if (!strategyCreator) {
+    throw new Error(`Unknown strategy: ${strategyName}`);
   }
+  const preparedData = await withTimeout(
+    "kline preload",
+    prepareTestingData({
+      state,
+      projectRoot,
+      userName,
+      connectorName,
+      symbol,
+      preloadStart,
+      start,
+      end,
+      interval,
+      universe,
+      accountId,
+      deploymentId
+    })
+  );
   if (!preparedData) {
     throw new Error("Prepared backtest data not available");
   }
   const {
     prevData,
     btcPrevData,
+    ethPrevData,
+    ethTestData,
     testData,
     btcTestData,
-    btcBinancePrevData,
-    btcCoinbasePrevData
+    btcBinanceData,
+    btcCoinbaseData,
+    backtestExecutionInterval,
+    backtestExecutionData,
+    backtestExecutionBtcData,
+    backtestExecutionDataByTimestamp,
+    backtestExecutionBtcDataByTimestamp
   } = preparedData;
+  const runtimePrevData = prevData.slice();
+  const runtimeBtcPrevData = btcPrevData.slice();
+  const runtimeEthData = [...ethPrevData, ...ethTestData];
+  totalCandles = testData.length;
+  const instrument = requestedInstrument;
+  const { model: executionCostModel, fundingRates } = await resolveExecutionCosts({
+    connector,
+    symbol,
+    config: strategyConfig,
+    startTime: start,
+    endTime: end,
+    instrument
+  });
   const testConnector = createTestConnector(connector, {
     userName,
     mlEnabled: ml,
-    aiEnabled: ai
+    aiEnabled: ai,
+    fastMode: fast,
+    executionCostModel,
+    fundingRates
   });
   const strategy = await withTimeout(
     "strategy init",
     strategyCreator({
       userName,
-      config: strategyConfig,
+      connectorName,
+      universe,
+      assetClass: assetClass ?? instrument?.assetClass,
+      instrument,
+      accountId,
+      deploymentId,
+      policyProfileId,
+      config: {
+        ...strategyConfig,
+        INTERVAL: interval
+      },
       symbol,
-      data: prevData,
-      btcData: btcPrevData,
-      btcBinanceData: btcBinancePrevData,
-      btcCoinbaseData: btcCoinbasePrevData,
+      data: runtimePrevData,
+      btcData: runtimeBtcPrevData,
+      ethData: runtimeEthData,
+      btcBinanceData,
+      btcCoinbaseData,
+      backtestExecutionMarketData: {
+        interval: backtestExecutionInterval,
+        data: backtestExecutionData,
+        btcData: backtestExecutionBtcData,
+        dataByTimestamp: backtestExecutionDataByTimestamp,
+        btcDataByTimestamp: backtestExecutionBtcDataByTimestamp
+      },
       connector: testConnector
     })
   );
   const pendingMlPayloadBySignalId = /* @__PURE__ */ new Map();
   const pendingAiRowBySignalId = /* @__PURE__ */ new Map();
-  const replaySignalEvaluations = [];
+  const replaySignalEvaluations = collectReplaySignalEvaluations ? [] : null;
   const flushClosedResultsBatch = async () => {
     if (!ml && !ai) return;
     const batch = await testConnector.drainMlResultsBatch();
@@ -633,7 +1717,14 @@ var testing = async ({
         const fullRow = buildMlTrainingRow(payload, {
           profit: resultRecord.profit
         });
-        const row = trimMlTrainingRowWindows(fullRow, 5);
+        const row = {
+          ...trimMlTrainingRowWindows(fullRow, 5),
+          ...buildBacktestDatasetMetadata({
+            backtestRunId,
+            backtestTestKey,
+            chunkId
+          })
+        };
         await appendMlDatasetRow({
           strategyName,
           chunkId,
@@ -643,62 +1734,54 @@ var testing = async ({
       const aiRowBase = pendingAiRowBySignalId.get(resultRecord.signalId);
       if (aiRowBase) {
         pendingAiRowBySignalId.delete(resultRecord.signalId);
+        const { signal: aiSignal, ...rowBase } = aiRowBase;
         await appendAiDatasetRow({
           strategyName,
           chunkId,
           row: {
-            ...aiRowBase,
-            profit: resultRecord.profit
+            ...rowBase,
+            payload: buildAiPayload(aiSignal),
+            profit: resultRecord.profit,
+            tradeResult: resultRecord.tradeResult
           }
         });
       }
     }
   };
-  for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
-    if (candleIndex % 25 === 0) {
-      throwIfTimedOut("candle loop");
+  const processSignal = async (signal, candle) => {
+    if (isBacktestEntryDelayControlCode(signal)) {
+      return;
     }
-    const candle = testData[candleIndex];
-    const btcCandle = btcTestData[candleIndex];
-    await withTimeout("stop-loss check", testConnector.checkSl(candle));
-    await withTimeout("take-profit check", testConnector.checkTp(candle));
-    const signal = await withTimeout(
-      "strategy signal",
-      strategy(candle, btcCandle)
-    );
-    if (!signal || typeof signal === "string") {
-      replaySignalEvaluations.push({
-        evaluationId: `${testId}:${strategyName}:${symbol}:${candle.timestamp}`,
-        userName,
-        strategy: strategyName,
-        symbol,
-        interval,
-        timestamp: candle.timestamp,
-        evaluatedAt: candle.timestamp,
-        status: "skip",
-        reason: typeof signal === "string" && signal.trim() ? signal : "NO_SIGNAL"
-      });
-    } else {
-      replaySignalEvaluations.push({
-        evaluationId: `${signal.signalId || testId}:${strategyName}:${symbol}:${signal.timestamp || candle.timestamp}`,
-        userName,
-        strategy: signal.strategy || strategyName,
-        symbol: signal.symbol || symbol,
-        interval: signal.interval || interval,
-        timestamp: typeof signal.timestamp === "number" && Number.isFinite(signal.timestamp) ? signal.timestamp : candle.timestamp,
-        evaluatedAt: candle.timestamp,
-        status: "signal",
-        reason: signal.orderSkipReason || signal.orderStatus,
-        signalId: signal.signalId,
-        direction: signal.direction,
-        orderStatus: signal.orderStatus,
-        orderSkipReason: signal.orderSkipReason,
-        aiAnalysis: signal.aiAnalysis ?? null,
-        ml: signal.ml
-      });
+    if (replaySignalEvaluations) {
+      replaySignalEvaluations.push(
+        buildReplaySignalEvaluationRecord({
+          signal,
+          testId,
+          userName,
+          strategyName,
+          symbol,
+          interval,
+          candle
+        })
+      );
     }
     const shouldCapturePayload = signal && typeof signal !== "string" && signal.signalId && (ml || ai);
     if (shouldCapturePayload) {
+      await withTimeout(
+        "binance market context",
+        enrichSignalWithBinanceMarketContext({
+          signal,
+          env: "BACKTEST"
+        })
+      );
+      await withTimeout(
+        "coinmarketcap context",
+        enrichSignalWithCoinMarketCapContext({
+          signal,
+          env: "BACKTEST",
+          enabled: Boolean(ml || ai)
+        })
+      );
       await withTimeout(
         "derivatives context",
         enrichSignalWithDerivativesContext({
@@ -715,6 +1798,7 @@ var testing = async ({
           testId,
           testSuiteId,
           testName: name,
+          configId,
           symbol,
           strategyName,
           strategyConfig,
@@ -730,23 +1814,515 @@ var testing = async ({
         symbol: signal.symbol || symbol,
         direction: signal.direction,
         timestamp: signal.timestamp,
-        payload: buildAiPayload(signal),
+        signal: cloneAiPayloadSignal(signal),
         testId,
         testSuiteId,
         testName: name,
-        connectorName
+        configId,
+        connectorName,
+        ...buildBacktestDatasetMetadata({
+          backtestRunId,
+          backtestTestKey,
+          chunkId
+        })
       });
     }
+  };
+  for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
+    if (candleIndex % 25 === 0) {
+      throwIfTimedOut("candle loop");
+    }
+    currentCandleIndex = candleIndex + 1;
+    emitProgress("candle loop", {
+      force: candleIndex === 0 || currentCandleIndex === totalCandles
+    });
+    const candle = testData[candleIndex];
+    const btcCandle = btcTestData[candleIndex];
+    const delayedSignal = await runStrategyCandleStage(
+      "delayed entry",
+      async () => strategy.__tradejsFlushBacktestDelayedEntry?.(candle, btcCandle)
+    );
+    if (delayedSignal && typeof delayedSignal !== "string") {
+      await processSignal(delayedSignal, candle);
+    }
+    await runStage("exit checks", () => testConnector.checkExits(candle));
+    const signal = await runStrategyCandleStage(
+      "strategy signal",
+      () => strategy(candle, btcCandle)
+    );
+    await processSignal(signal, candle);
+    if ((candleIndex + 1) % CLOSED_RESULT_FLUSH_INTERVAL === 0) {
+      await withTimeout("flush closed results", flushClosedResultsBatch());
+    }
   }
   await withTimeout("flush closed results", flushClosedResultsBatch());
   const result = await withTimeout("collect result", testConnector.getResult());
-  return {
+  return replaySignalEvaluations ? {
     ...result,
     inlineReplaySignalEvaluations: replaySignalEvaluations
+  } : result;
+};
+var testingGroupInSharedCandleLoop = async (tests) => {
+  if (!canRunTestsInSharedCandleLoop(tests)) {
+    const results = [];
+    for (const test of tests) {
+      const result = await testing(test);
+      if (result) {
+        results.push({ test, result });
+      }
+    }
+    return results;
+  }
+  const first = tests[0];
+  const {
+    userName,
+    symbol,
+    options: { start, end },
+    strategyName,
+    connectorName,
+    universe = "crypto",
+    accountId,
+    deploymentId,
+    interval = BACKTEST_INTERVAL,
+    ml = false,
+    ai = false,
+    fast = false,
+    collectReplaySignalEvaluations = false,
+    chunkId = "single",
+    timeoutMs
+  } = first;
+  if (!start) {
+    throw new Error("no start");
+  }
+  const preloadStart = getBacktestPreloadStart(start);
+  const startedAt = Date.now();
+  let activeStageStartedAt = startedAt;
+  let lastProgressSentAt = 0;
+  let lastProgressSignature = "";
+  let currentCandleIndex = 0;
+  let totalCandles = 0;
+  const strategyCandleTimeoutMs = getStrategyCandleTimeoutMs();
+  const formatTimeoutMessage = (stage, stageTimeoutMs) => `Test group ${strategyName}/${symbol} timed out after ${stageTimeoutMs}ms during ${stage}`;
+  const emitProgress = (stage, options = {}) => {
+    const now = Date.now();
+    const candleIndex = typeof options.candleIndex === "number" ? options.candleIndex : currentCandleIndex;
+    const candleTotal = typeof options.candleTotal === "number" ? options.candleTotal : totalCandles;
+    const signature = [
+      stage,
+      candleIndex,
+      candleTotal,
+      Math.floor((now - activeStageStartedAt) / 5e3)
+    ].join(":");
+    if (!options.force) {
+      if (signature === lastProgressSignature) {
+        return;
+      }
+      if (now - lastProgressSentAt < 4e3) {
+        return;
+      }
+    }
+    lastProgressSentAt = now;
+    lastProgressSignature = signature;
+    process.send?.({
+      progress: true,
+      testName: first.name,
+      symbol,
+      strategyName,
+      stage,
+      candleIndex,
+      candleTotal,
+      elapsedMs: now - startedAt,
+      stageElapsedMs: now - activeStageStartedAt
+    });
+  };
+  const getStageTimeoutMs = () => {
+    if (!timeoutMs || timeoutMs <= 0) {
+      return null;
+    }
+    return timeoutMs;
+  };
+  const throwIfTimedOut = (stage) => {
+    if (getStageTimeoutMs() == null) {
+      return;
+    }
+    emitProgress(stage);
   };
+  const withTimeout = async (stage, promise, stageTimeoutOverrideMs = null) => {
+    const stageTimeoutMs = getEffectiveTimeoutMs(
+      getStageTimeoutMs() ?? void 0,
+      stageTimeoutOverrideMs
+    );
+    if (stageTimeoutMs == null) {
+      return promise;
+    }
+    activeStageStartedAt = Date.now();
+    emitProgress(stage, { force: true });
+    return await new Promise((resolve, reject) => {
+      const heartbeat = setInterval(() => {
+        emitProgress(stage);
+      }, 5e3);
+      const timer = setTimeout(() => {
+        clearInterval(heartbeat);
+        reject(new Error(formatTimeoutMessage(stage, stageTimeoutMs)));
+      }, stageTimeoutMs);
+      promise.then(
+        (value) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  };
+  const runStage = (stage, fn) => {
+    if (getStageTimeoutMs() == null) {
+      return fn();
+    }
+    return withTimeout(stage, fn());
+  };
+  const runStrategyCandleStage = (stage, fn) => withTimeout(stage, fn(), strategyCandleTimeoutMs);
+  const { projectRoot, state } = getTestingKlineCacheState();
+  const connector = await withTimeout(
+    "connector init",
+    getCachedConnector({
+      state,
+      projectRoot,
+      userName,
+      connectorName,
+      universe,
+      accountId,
+      deploymentId
+    })
+  );
+  if (!connector) {
+    throw new Error(`Unknown connector: ${connectorName}`);
+  }
+  const strategyCreator = await withTimeout(
+    "strategy lookup",
+    getStrategyCreator(strategyName, projectRoot)
+  );
+  if (!strategyCreator) {
+    throw new Error(`Unknown strategy: ${strategyName}`);
+  }
+  const preparedData = await withTimeout(
+    "kline preload",
+    prepareTestingData({
+      state,
+      projectRoot,
+      userName,
+      connectorName,
+      symbol,
+      preloadStart,
+      start,
+      end,
+      interval,
+      universe,
+      accountId,
+      deploymentId
+    })
+  );
+  if (!preparedData) {
+    throw new Error("Prepared backtest data not available");
+  }
+  const {
+    prevData,
+    btcPrevData,
+    ethPrevData,
+    ethTestData,
+    testData,
+    btcTestData,
+    btcBinanceData,
+    btcCoinbaseData,
+    backtestExecutionInterval,
+    backtestExecutionData,
+    backtestExecutionBtcData,
+    backtestExecutionDataByTimestamp,
+    backtestExecutionBtcDataByTimestamp
+  } = preparedData;
+  totalCandles = testData.length;
+  const sharedIndicatorsReplayKey = [
+    "shared",
+    userName,
+    connectorName,
+    strategyName,
+    symbol,
+    interval,
+    start,
+    end,
+    chunkId
+  ].join(":");
+  const runners = [];
+  try {
+    for (const test of tests) {
+      const instrument = test.instrument;
+      const { model: executionCostModel, fundingRates } = await resolveExecutionCosts({
+        connector,
+        symbol: test.symbol,
+        config: test.strategyConfig,
+        startTime: start,
+        endTime: end,
+        instrument
+      });
+      const testConnector = createTestConnector(connector, {
+        userName: test.userName,
+        mlEnabled: test.ml,
+        aiEnabled: test.ai,
+        fastMode: test.fast,
+        executionCostModel,
+        fundingRates
+      });
+      const strategy = await withTimeout(
+        "strategy init",
+        strategyCreator({
+          userName: test.userName,
+          connectorName: test.connectorName,
+          universe: test.universe ?? universe,
+          assetClass: test.assetClass ?? instrument?.assetClass,
+          instrument,
+          accountId: test.accountId ?? accountId,
+          deploymentId: test.deploymentId ?? deploymentId,
+          policyProfileId: test.policyProfileId,
+          config: {
+            ...test.strategyConfig,
+            INTERVAL: test.interval ?? interval
+          },
+          symbol: test.symbol,
+          data: prevData.slice(),
+          btcData: btcPrevData.slice(),
+          ethData: [...ethPrevData, ...ethTestData],
+          btcBinanceData,
+          btcCoinbaseData,
+          backtestExecutionMarketData: {
+            interval: backtestExecutionInterval,
+            data: backtestExecutionData,
+            btcData: backtestExecutionBtcData,
+            dataByTimestamp: backtestExecutionDataByTimestamp,
+            btcDataByTimestamp: backtestExecutionBtcDataByTimestamp
+          },
+          connector: testConnector,
+          sharedIndicatorsReplayKey
+        })
+      );
+      runners.push({
+        test,
+        strategy,
+        testConnector,
+        pendingMlPayloadBySignalId: /* @__PURE__ */ new Map(),
+        pendingAiRowBySignalId: /* @__PURE__ */ new Map(),
+        replaySignalEvaluations: collectReplaySignalEvaluations ? [] : null
+      });
+    }
+    const flushClosedResultsBatch = async (runner) => {
+      if (!runner.test.ml && !runner.test.ai) return;
+      const batch = await runner.testConnector.drainMlResultsBatch();
+      if (!batch.length) return;
+      for (const resultRecord of batch) {
+        const payload = runner.pendingMlPayloadBySignalId.get(
+          resultRecord.signalId
+        );
+        if (payload) {
+          runner.pendingMlPayloadBySignalId.delete(resultRecord.signalId);
+          const fullRow = buildMlTrainingRow(payload, {
+            profit: resultRecord.profit
+          });
+          const resolvedChunkId = runner.test.chunkId ?? "single";
+          const row = {
+            ...trimMlTrainingRowWindows(fullRow, 5),
+            ...buildBacktestDatasetMetadata({
+              backtestRunId: runner.test.backtestRunId,
+              backtestTestKey: runner.test.backtestTestKey,
+              chunkId: resolvedChunkId
+            })
+          };
+          await appendMlDatasetRow({
+            strategyName: runner.test.strategyName,
+            chunkId: resolvedChunkId,
+            row
+          });
+        }
+        const aiRowBase = runner.pendingAiRowBySignalId.get(
+          resultRecord.signalId
+        );
+        if (aiRowBase) {
+          runner.pendingAiRowBySignalId.delete(resultRecord.signalId);
+          const { signal: aiSignal, ...rowBase } = aiRowBase;
+          const resolvedChunkId = runner.test.chunkId ?? "single";
+          await appendAiDatasetRow({
+            strategyName: runner.test.strategyName,
+            chunkId: resolvedChunkId,
+            row: {
+              ...rowBase,
+              payload: buildAiPayload(aiSignal),
+              profit: resultRecord.profit,
+              tradeResult: resultRecord.tradeResult
+            }
+          });
+        }
+      }
+    };
+    const processRunnerSignal = async (runner, signal, candle) => {
+      if (isBacktestEntryDelayControlCode(signal)) {
+        return;
+      }
+      const { test } = runner;
+      if (runner.replaySignalEvaluations) {
+        runner.replaySignalEvaluations.push(
+          buildReplaySignalEvaluationRecord({
+            signal,
+            testId: test.testId,
+            userName: test.userName,
+            strategyName: test.strategyName,
+            symbol: test.symbol,
+            interval: test.interval ?? interval,
+            candle
+          })
+        );
+      }
+      const shouldCapturePayload = signal && typeof signal !== "string" && signal.signalId && (test.ml || test.ai);
+      if (shouldCapturePayload) {
+        await withTimeout(
+          "binance market context",
+          enrichSignalWithBinanceMarketContext({
+            signal,
+            env: "BACKTEST"
+          })
+        );
+        await withTimeout(
+          "coinmarketcap context",
+          enrichSignalWithCoinMarketCapContext({
+            signal,
+            env: "BACKTEST",
+            enabled: Boolean(test.ml || test.ai)
+          })
+        );
+        await withTimeout(
+          "derivatives context",
+          enrichSignalWithDerivativesContext({
+            signal,
+            env: "BACKTEST"
+          })
+        );
+      }
+      if (test.ml && signal && typeof signal !== "string" && signal.signalId) {
+        const payload = buildMlPayload({
+          signal,
+          context: {
+            userName: test.userName,
+            testId: test.testId,
+            testSuiteId: test.testSuiteId,
+            testName: test.name,
+            configId: test.configId,
+            symbol: test.symbol,
+            strategyName: test.strategyName,
+            strategyConfig: test.strategyConfig,
+            connectorName: test.connectorName
+          }
+        });
+        runner.pendingMlPayloadBySignalId.set(signal.signalId, payload);
+      }
+      if (test.ai && signal && typeof signal !== "string" && signal.signalId) {
+        runner.pendingAiRowBySignalId.set(signal.signalId, {
+          signalId: signal.signalId,
+          strategyName: signal.strategy || test.strategyName,
+          symbol: signal.symbol || test.symbol,
+          direction: signal.direction,
+          timestamp: signal.timestamp,
+          signal: cloneAiPayloadSignal(signal),
+          testId: test.testId,
+          testSuiteId: test.testSuiteId,
+          testName: test.name,
+          configId: test.configId,
+          connectorName: test.connectorName,
+          ...buildBacktestDatasetMetadata({
+            backtestRunId: test.backtestRunId,
+            backtestTestKey: test.backtestTestKey,
+            chunkId: test.chunkId ?? "single"
+          })
+        });
+      }
+    };
+    for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
+      if (candleIndex % 25 === 0) {
+        throwIfTimedOut("candle loop");
+      }
+      currentCandleIndex = candleIndex + 1;
+      emitProgress("candle loop", {
+        force: candleIndex === 0 || currentCandleIndex === totalCandles
+      });
+      const candle = testData[candleIndex];
+      const btcCandle = btcTestData[candleIndex];
+      const detectorNoSignalByKey = /* @__PURE__ */ new Map();
+      for (const runner of runners) {
+        const { test, testConnector, strategy } = runner;
+        const delayedSignal = await runStrategyCandleStage(
+          "delayed entry",
+          async () => strategy.__tradejsFlushBacktestDelayedEntry?.(candle, btcCandle)
+        );
+        if (delayedSignal && typeof delayedSignal !== "string") {
+          await processRunnerSignal(runner, delayedSignal, candle);
+        }
+        await runStage("exit checks", () => testConnector.checkExits(candle));
+        const detectorFanoutKey = strategy.detectorFanoutKey;
+        const detectorSkipCode = detectorFanoutKey ? detectorNoSignalByKey.get(detectorFanoutKey) : void 0;
+        const signal = await runStrategyCandleStage(
+          detectorSkipCode ? "strategy detector skip" : "strategy signal",
+          () => detectorSkipCode && strategy.canFastAdvanceDetectorNoSignal && strategy.advanceDetectorNoSignal ? strategy.advanceDetectorNoSignal(
+            candle,
+            btcCandle,
+            detectorSkipCode
+          ) : detectorSkipCode && strategy.skipDetectorNoSignal ? strategy.skipDetectorNoSignal(
+            candle,
+            btcCandle,
+            detectorSkipCode
+          ) : strategy(candle, btcCandle)
+        );
+        if (detectorFanoutKey && strategy.detectorNoSignalSkipReason && typeof signal === "string" && signal === strategy.detectorNoSignalSkipReason) {
+          detectorNoSignalByKey.set(detectorFanoutKey, signal);
+        }
+        await processRunnerSignal(runner, signal, candle);
+      }
+      if ((candleIndex + 1) % CLOSED_RESULT_FLUSH_INTERVAL === 0) {
+        await withTimeout(
+          "flush closed results",
+          Promise.all(runners.map((runner) => flushClosedResultsBatch(runner)))
+        );
+      }
+    }
+    const results = [];
+    for (const runner of runners) {
+      await withTimeout(
+        "flush closed results",
+        flushClosedResultsBatch(runner)
+      );
+      const result = await withTimeout(
+        "collect result",
+        runner.testConnector.getResult()
+      );
+      results.push({
+        test: runner.test,
+        result: runner.replaySignalEvaluations ? {
+          ...result,
+          inlineReplaySignalEvaluations: runner.replaySignalEvaluations
+        } : result
+      });
+    }
+    return results;
+  } finally {
+    releaseStrategyIndicatorsReplayCache(sharedIndicatorsReplayKey);
+    releaseStrategyReplayCache(sharedIndicatorsReplayKey);
+  }
 };
 export {
+  canRunTestsInSharedCandleLoop,
   createTestConnector,
+  releaseTestingSymbolCache,
   resetTestingKlineCache,
-  testing
+  resolveExecutionCosts,
+  testing,
+  testingGroupInSharedCandleLoop
 };