@tradejs/node 1.0.5 → 1.0.8

package/dist/backtest.mjs

@@ -1,30 +1,29 @@
 import {
   BUILTIN_CONNECTOR_NAMES,
   getConnectorCreatorByName
-} from "./chunk-CIY64D57.mjs";
+} from "./chunk-JMDYEKIO.mjs";
 import {
-  buildMlPayload
-} from "./chunk-RBE4PZER.mjs";
+  buildMlPayload,
+  enrichSignalWithDerivativesContext
+} from "./chunk-JRRG3YQG.mjs";
 import {
-  require_lodash
-} from "./chunk-GKDBAF3A.mjs";
+  buildAiPayload
+} from "./chunk-2JKX3DM7.mjs";
 import {
   getStrategyCreator
-} from "./chunk-ZY6ULOWK.mjs";
+} from "./chunk-WGOYR6AB.mjs";
 import {
   getTradejsProjectCwd
-} from "./chunk-P2ZUWONT.mjs";
-import {
-  __toESM
-} from "./chunk-6DZX6EAA.mjs";
+} from "./chunk-JU77QVJ3.mjs";
+import "./chunk-6DZX6EAA.mjs";
 
 // src/backtest.ts
 export * from "@tradejs/core/backtest";
 
 // src/testing.ts
 import { alignSortedCandlesByTimestamp } from "@tradejs/core/indicators";
-import { PRELOAD_DAYS } from "@tradejs/core/constants";
-import { getTimestamp } from "@tradejs/core/time";
+import { getBacktestPreloadStart } from "@tradejs/core/time";
+import { appendAiDatasetRow } from "@tradejs/infra/ai";
 import {
   appendMlDatasetRow,
   buildMlTrainingRow,
@@ -33,15 +32,11 @@ import {
 import { logger } from "@tradejs/infra/logger";
 
 // src/testConnector.ts
-var import_lodash = __toESM(require_lodash());
 import { randomUUID } from "crypto";
-import { TTL_1D } from "@tradejs/core/constants";
 import { round } from "@tradejs/core/math";
-import { redisKeys, setData } from "@tradejs/infra/redis";
 var FEE = 5e-3;
 var INITIAL_AMOUNT = 100;
 var createTestConnector = (connector, context) => {
-  const userName = context?.userName;
   let state = {};
   const orderLog = [];
   const positionLog = [];
@@ -51,7 +46,7 @@ var createTestConnector = (connector, context) => {
   let currentPositionProfit = 0;
   let takeProfits = [];
   let stopLossPrice = null;
-  const closedMlResults = [];
+  const closedSignalResults = [];
   const logOrder = (data) => {
     const nextEntry = {
       ...currentPosition || {},
@@ -61,7 +56,8 @@ var createTestConnector = (connector, context) => {
       index: orderLog.length
     };
     if (nextEntry.signal) {
-      nextEntry.signal = import_lodash.default.omit(nextEntry.signal, "indicators");
+      const { indicators: _indicators, ...signalWithoutIndicators } = nextEntry.signal;
+      nextEntry.signal = signalWithoutIndicators;
     }
     orderLog.push(nextEntry);
   };
@@ -72,10 +68,10 @@ var createTestConnector = (connector, context) => {
     if (!currentPosition) {
       return;
     }
-    if (context?.mlEnabled) {
+    if (context?.mlEnabled || context?.aiEnabled) {
       const signalId = currentPosition.signal?.signalId;
       if (signalId) {
-        closedMlResults.push({
+        closedSignalResults.push({
           signalId,
           profit: currentPositionProfit
         });
@@ -96,6 +92,7 @@ var createTestConnector = (connector, context) => {
     currentPositionProfit = 0;
   };
   return {
+    __tradejsTestConnector: true,
     getState: async () => state,
     setState: async (newState) => {
       state = {
@@ -106,33 +103,38 @@ var createTestConnector = (connector, context) => {
     kline: async (options) => connector.kline(options),
     getResult: async () => {
       const orderLogId = randomUUID().slice(-12);
-      const cacheUserName = userName || "root";
-      await setData(
-        redisKeys.cacheOrders(cacheUserName, orderLogId),
-        orderLog,
-        {
-          expire: TTL_1D
-        }
-      );
-      await setData(
-        redisKeys.cachePositions(cacheUserName, orderLogId),
-        positionLog,
-        {
-          expire: TTL_1D
-        }
-      );
       return {
         stat: {
           amount,
           profit: amount - INITIAL_AMOUNT,
           orders: positionLog.length
         },
-        orderLogId
+        orderLogId,
+        inlineOrderLog: [...orderLog],
+        inlinePositionLog: [...positionLog]
       };
     },
     getPosition: async () => currentPosition || null,
+    getOpenPositionPnl: async () => {
+      if (typeof connector.getOpenPositionPnl === "function") {
+        return connector.getOpenPositionPnl();
+      }
+      if (!currentPosition) {
+        return [];
+      }
+      return [
+        {
+          symbol: currentPosition.symbol,
+          qty: currentPosition.qty,
+          price: currentPosition.price,
+          currentPrice: currentPosition.price,
+          unrealizedPnl: 0,
+          direction: currentPosition.direction
+        }
+      ];
+    },
     checkTp: async (candle) => {
-      if (import_lodash.default.isEmpty(candle) || !currentPosition || !currentPosition.qty) {
+      if (!candle || !currentPosition || !currentPosition.qty) {
         return;
       }
       const isLong = currentPosition.direction === "LONG";
@@ -167,7 +169,7 @@ var createTestConnector = (connector, context) => {
       }
     },
     checkSl: async (candle) => {
-      if (!stopLossPrice || !currentPosition || import_lodash.default.isEmpty(candle)) {
+      if (!stopLossPrice || !currentPosition || !candle) {
         return;
       }
       const isLong = currentPosition.direction === "LONG";
@@ -187,13 +189,11 @@ var createTestConnector = (connector, context) => {
         clearPosition(candle.timestamp);
       }
     },
-    placeOrder: async (order, tp = [], slPrice) => {
+    placeOrder: async (order) => {
       if (currentPosition) {
         return false;
       }
       const isLong = order.direction === "LONG";
-      takeProfits = import_lodash.default.cloneDeep(tp);
-      stopLossPrice = slPrice || null;
       currentPosition = { ...order, amount };
       originalQty = order.qty;
       const fee = order.price * order.qty * FEE;
@@ -208,6 +208,24 @@ var createTestConnector = (connector, context) => {
       });
       return true;
     },
+    setTakeProfits: async ({ takeProfits: nextTakeProfits }) => {
+      if (!currentPosition) {
+        return false;
+      }
+      takeProfits = Array.isArray(nextTakeProfits) ? nextTakeProfits.map((tp) => ({ ...tp })) : [];
+      return true;
+    },
+    setStopLoss: async ({ stopLossPrice: nextStopLossPrice }) => {
+      if (!currentPosition) {
+        return false;
+      }
+      stopLossPrice = nextStopLossPrice || null;
+      currentPosition = {
+        ...currentPosition,
+        ...stopLossPrice != null ? { slPrice: stopLossPrice } : {}
+      };
+      return true;
+    },
     closePosition: async (order) => {
       if (!currentPosition) {
         return false;
@@ -227,17 +245,18 @@ var createTestConnector = (connector, context) => {
     },
     getTickers: connector.getTickers,
     getPositions: connector.getPositions,
-    drainMlResultsBatch: async () => closedMlResults.splice(0)
+    drainMlResultsBatch: async () => closedSignalResults.splice(0)
   };
 };
 
 // src/testing.ts
-var preloadStart = getTimestamp(PRELOAD_DAYS);
 var createTestingKlineCacheState = () => ({
   coinKlineCache: /* @__PURE__ */ new Map(),
   btcKlineCache: /* @__PURE__ */ new Map(),
   btcBinanceKlineCache: /* @__PURE__ */ new Map(),
-  btcCoinbaseKlineCache: /* @__PURE__ */ new Map()
+  btcCoinbaseKlineCache: /* @__PURE__ */ new Map(),
+  preparedDataCache: /* @__PURE__ */ new Map(),
+  connectorCache: /* @__PURE__ */ new Map()
 });
 var testingKlineCacheStateByProjectRoot = /* @__PURE__ */ new Map();
 var getTestingKlineCacheState = (cwd = getTradejsProjectCwd()) => {
@@ -253,7 +272,15 @@ var getTestingKlineCacheState = (cwd = getTradejsProjectCwd()) => {
   };
 };
 var getKlineCacheKey = (params) => {
-  const { userName, connectorName, symbol, end, interval, cacheOnly } = params;
+  const {
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    end,
+    interval,
+    cacheOnly
+  } = params;
   return [
     userName,
     connectorName,
@@ -264,6 +291,64 @@ var getKlineCacheKey = (params) => {
     cacheOnly ? 1 : 0
   ].join(":");
 };
+var getPreparedDataCacheKey = (params) => {
+  const {
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    start,
+    end,
+    interval,
+    btcBinanceConnectorName,
+    btcCoinbaseConnectorName
+  } = params;
+  return [
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    start,
+    end,
+    interval,
+    btcBinanceConnectorName,
+    btcCoinbaseConnectorName
+  ].join(":");
+};
+var getConnectorCacheKey = (params) => [params.userName, params.connectorName].join(":");
+var splitCandlesForTesting = (candles, start, preloadStart) => {
+  const prevData = [];
+  const testData = [];
+  for (const candle of candles) {
+    if (candle.timestamp < preloadStart) continue;
+    if (candle.timestamp < start) {
+      prevData.push(candle);
+    } else {
+      testData.push(candle);
+    }
+  }
+  return { prevData, testData };
+};
+var getCachedConnector = async (params) => {
+  const { state, projectRoot, userName, connectorName } = params;
+  const cacheKey = getConnectorCacheKey({ userName, connectorName });
+  const cachedConnector = state.connectorCache.get(cacheKey);
+  if (cachedConnector) {
+    return cachedConnector;
+  }
+  const connectorCreator = await getConnectorCreatorByName(
+    connectorName,
+    projectRoot
+  );
+  if (!connectorCreator) {
+    return void 0;
+  }
+  const connector = await connectorCreator({
+    userName
+  });
+  state.connectorCache.set(cacheKey, connector);
+  return connector;
+};
 var resetTestingKlineCache = (cwd) => {
   const normalizedCwd = String(cwd ?? "").trim();
   if (!normalizedCwd) {
@@ -285,35 +370,89 @@ var testing = async ({
   strategyConfig,
   connectorName,
   ml = false,
-  chunkId = "single"
+  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;
+    }
+    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 connectorCreator = await getConnectorCreatorByName(
-    connectorName,
-    projectRoot
+  const connector = await withTimeout(
+    "connector init",
+    getCachedConnector({
+      state,
+      projectRoot,
+      userName,
+      connectorName
+    })
   );
-  if (!connectorCreator) {
+  if (!connector) {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
-  const connector = await connectorCreator({
-    userName
-  });
-  const strategyCreator = await getStrategyCreator(strategyName, projectRoot);
+  const strategyCreator = await withTimeout(
+    "strategy lookup",
+    getStrategyCreator(strategyName, projectRoot)
+  );
   if (!strategyCreator) {
     throw new Error(`Unknown strategy: ${strategyName}`);
   }
-  const binanceCreator = await getConnectorCreatorByName(
-    BUILTIN_CONNECTOR_NAMES.Binance,
-    projectRoot
+  const binanceConnector = await withTimeout(
+    "binance connector init",
+    getCachedConnector({
+      state,
+      projectRoot,
+      userName,
+      connectorName: BUILTIN_CONNECTOR_NAMES.Binance
+    })
   );
-  const coinbaseCreator = await getConnectorCreatorByName(
-    BUILTIN_CONNECTOR_NAMES.Coinbase,
-    projectRoot
+  const coinbaseConnector = await withTimeout(
+    "coinbase connector init",
+    getCachedConnector({
+      state,
+      projectRoot,
+      userName,
+      connectorName: BUILTIN_CONNECTOR_NAMES.Coinbase
+    })
   );
-  if (!binanceCreator || !coinbaseCreator) {
+  if (!binanceConnector || !coinbaseConnector) {
     logger.warn(
       "Binance/Coinbase connectors are unavailable. Reusing %s for BTC references.",
       connectorName
@@ -325,6 +464,7 @@ var testing = async ({
     userName,
     connectorName,
     symbol,
+    preloadStart,
     end,
     interval,
     cacheOnly
@@ -333,160 +473,240 @@ var testing = async ({
     userName,
     connectorName,
     symbol: "BTCUSDT",
+    preloadStart,
     end,
     interval,
     cacheOnly
   });
+  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: binanceCreator ? BUILTIN_CONNECTOR_NAMES.Binance : connectorName,
+    connectorName: btcBinanceConnectorName,
     symbol: "BTCUSDT",
+    preloadStart,
     end,
     interval,
     cacheOnly
   });
   const btcCoinbaseCacheKey = getKlineCacheKey({
     userName,
-    connectorName: coinbaseCreator ? BUILTIN_CONNECTOR_NAMES.Coinbase : connectorName,
+    connectorName: btcCoinbaseConnectorName,
     symbol: "BTCUSDT",
+    preloadStart,
     end,
     interval,
     cacheOnly
   });
   const cachedBtcBinanceData = state.btcBinanceKlineCache.get(btcBinanceCacheKey);
   const cachedBtcCoinbaseData = state.btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
-  const [data, btcData, btcBinanceData, btcCoinbaseData] = await 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) : binanceCreator ? binanceCreator({ userName }).then(
-      (binanceConnector) => binanceConnector.kline({
-        symbol: "BTCUSDT",
-        start: preloadStart,
-        end,
-        interval,
-        silent: true,
-        cacheOnly
-      })
-    ) : connector.kline({
-      symbol: "BTCUSDT",
-      start: preloadStart,
-      end,
-      interval,
-      silent: true,
-      cacheOnly
-    }),
-    cachedBtcCoinbaseData ? Promise.resolve(cachedBtcCoinbaseData) : coinbaseCreator ? coinbaseCreator({ userName }).then(
-      (coinbaseConnector) => coinbaseConnector.kline({
-        symbol: "BTCUSDT",
-        start: preloadStart,
-        end,
-        interval,
-        silent: true,
-        cacheOnly
-      })
-    ) : 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);
-  }
-  if (!cachedBtcBinanceData) {
-    state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
+  const preparedDataCacheKey = getPreparedDataCacheKey({
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    start,
+    end,
+    interval,
+    btcBinanceConnectorName,
+    btcCoinbaseConnectorName
+  });
+  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);
+    }
+    if (!cachedBtcBinanceData) {
+      state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
+    }
+    if (!cachedBtcCoinbaseData) {
+      state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
+    }
+    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
+    );
+    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 (!cachedBtcCoinbaseData) {
-    state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
+  if (!preparedData) {
+    throw new Error("Prepared backtest data not available");
   }
-  const prevDataRaw = data.filter(
-    (candle) => candle.timestamp >= preloadStart && candle.timestamp < start
-  );
-  const btcPrevDataRaw = btcData.filter(
-    (candle) => candle.timestamp >= preloadStart && candle.timestamp < start
-  );
-  const testDataRaw = data.filter(
-    (candle) => candle.timestamp >= start
-  );
-  const btcTestDataRaw = btcData.filter(
-    (candle) => candle.timestamp >= start
-  );
-  const { alignedCoinCandles: prevData, alignedBtcCandles: btcPrevData } = alignSortedCandlesByTimestamp(prevDataRaw, btcPrevDataRaw);
-  const { alignedCoinCandles: testData, alignedBtcCandles: btcTestData } = alignSortedCandlesByTimestamp(testDataRaw, btcTestDataRaw);
-  const { alignedBtcCandles: btcBinancePrevData } = alignSortedCandlesByTimestamp(
-    prevDataRaw,
-    btcBinanceData.filter(
-      (candle) => candle.timestamp >= preloadStart && candle.timestamp < start
-    )
-  );
-  const { alignedBtcCandles: btcCoinbasePrevData } = alignSortedCandlesByTimestamp(
-    prevDataRaw,
-    btcCoinbaseData.filter(
-      (candle) => candle.timestamp >= preloadStart && candle.timestamp < start
-    )
-  );
+  const {
+    prevData,
+    btcPrevData,
+    testData,
+    btcTestData,
+    btcBinancePrevData,
+    btcCoinbasePrevData
+  } = preparedData;
   const testConnector = createTestConnector(connector, {
     userName,
-    mlEnabled: ml
-  });
-  const strategy = await strategyCreator({
-    userName,
-    config: strategyConfig,
-    symbol,
-    data: prevData,
-    btcData: btcPrevData,
-    btcBinanceData: btcBinancePrevData,
-    btcCoinbaseData: btcCoinbasePrevData,
-    connector: testConnector
+    mlEnabled: ml,
+    aiEnabled: ai
   });
+  const strategy = await withTimeout(
+    "strategy init",
+    strategyCreator({
+      userName,
+      config: strategyConfig,
+      symbol,
+      data: prevData,
+      btcData: btcPrevData,
+      btcBinanceData: btcBinancePrevData,
+      btcCoinbaseData: btcCoinbasePrevData,
+      connector: testConnector
+    })
+  );
   const pendingMlPayloadBySignalId = /* @__PURE__ */ new Map();
-  const flushMlResultsBatch = async () => {
-    if (!ml) return;
+  const pendingAiRowBySignalId = /* @__PURE__ */ new Map();
+  const replaySignalEvaluations = [];
+  const flushClosedResultsBatch = async () => {
+    if (!ml && !ai) return;
     const batch = await testConnector.drainMlResultsBatch();
     if (!batch.length) return;
     for (const resultRecord of batch) {
       const payload = pendingMlPayloadBySignalId.get(resultRecord.signalId);
-      if (!payload) continue;
-      pendingMlPayloadBySignalId.delete(resultRecord.signalId);
-      const fullRow = buildMlTrainingRow(payload, {
-        profit: resultRecord.profit
-      });
-      const row = trimMlTrainingRowWindows(fullRow, 5);
-      await appendMlDatasetRow({
-        strategyName,
-        chunkId,
-        row
-      });
+      if (payload) {
+        pendingMlPayloadBySignalId.delete(resultRecord.signalId);
+        const fullRow = buildMlTrainingRow(payload, {
+          profit: resultRecord.profit
+        });
+        const row = trimMlTrainingRowWindows(fullRow, 5);
+        await appendMlDatasetRow({
+          strategyName,
+          chunkId,
+          row
+        });
+      }
+      const aiRowBase = pendingAiRowBySignalId.get(resultRecord.signalId);
+      if (aiRowBase) {
+        pendingAiRowBySignalId.delete(resultRecord.signalId);
+        await appendAiDatasetRow({
+          strategyName,
+          chunkId,
+          row: {
+            ...aiRowBase,
+            profit: resultRecord.profit
+          }
+        });
+      }
     }
   };
   for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
+    if (candleIndex % 25 === 0) {
+      throwIfTimedOut("candle loop");
+    }
     const candle = testData[candleIndex];
     const btcCandle = btcTestData[candleIndex];
-    await testConnector.checkSl(candle);
-    await testConnector.checkTp(candle);
-    const signal = await strategy(candle, btcCandle);
+    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
+      });
+    }
+    const shouldCapturePayload = signal && typeof signal !== "string" && signal.signalId && (ml || ai);
+    if (shouldCapturePayload) {
+      await withTimeout(
+        "derivatives context",
+        enrichSignalWithDerivativesContext({
+          signal,
+          env: "BACKTEST"
+        })
+      );
+    }
     if (ml && signal && typeof signal !== "string" && signal.signalId) {
       const payload = buildMlPayload({
         signal,
@@ -503,9 +723,27 @@ var testing = async ({
       });
       pendingMlPayloadBySignalId.set(signal.signalId, payload);
     }
+    if (ai && signal && typeof signal !== "string" && signal.signalId) {
+      pendingAiRowBySignalId.set(signal.signalId, {
+        signalId: signal.signalId,
+        strategyName: signal.strategy || strategyName,
+        symbol: signal.symbol || symbol,
+        direction: signal.direction,
+        timestamp: signal.timestamp,
+        payload: buildAiPayload(signal),
+        testId,
+        testSuiteId,
+        testName: name,
+        connectorName
+      });
+    }
   }
-  await flushMlResultsBatch();
-  return await testConnector.getResult();
+  await withTimeout("flush closed results", flushClosedResultsBatch());
+  const result = await withTimeout("collect result", testConnector.getResult());
+  return {
+    ...result,
+    inlineReplaySignalEvaluations: replaySignalEvaluations
+  };
 };
 export {
   createTestConnector,