@tradejs/node 1.0.2 → 1.0.4

package/dist/{ai-NNJ3RLLL.mjs → ai-G7ATN4YL.mjs}

@@ -5,9 +5,9 @@ import {
   buildAiPayload,
   buildAiSystemPrompt,
   trimSeriesDeep
-} from "./chunk-ZIMX3JX2.mjs";
-import "./chunk-MHCXPD2B.mjs";
-import "./chunk-DE7ADBIR.mjs";
+} from "./chunk-LMAKIC3C.mjs";
+import "./chunk-ZY6ULOWK.mjs";
+import "./chunk-P2ZUWONT.mjs";
 import "./chunk-6DZX6EAA.mjs";
 export {
   MAX_AI_SERIES_POINTS,

package/dist/backtest.d.mts

@@ -1,7 +1,7 @@
 export * from '@tradejs/core/backtest';
 import { TestingBox, TestConnectorCreator } from '@tradejs/types';
 
-declare const resetTestingKlineCache: () => void;
+declare const resetTestingKlineCache: (cwd?: string) => void;
 declare const testing: TestingBox;
 
 declare const createTestConnector: TestConnectorCreator;

package/dist/backtest.d.ts

@@ -1,7 +1,7 @@
 export * from '@tradejs/core/backtest';
 import { TestingBox, TestConnectorCreator } from '@tradejs/types';
 
-declare const resetTestingKlineCache: () => void;
+declare const resetTestingKlineCache: (cwd?: string) => void;
 declare const testing: TestingBox;
 
 declare const createTestConnector: TestConnectorCreator;

package/dist/backtest.js

@@ -5550,6 +5550,7 @@ var TS_MODULE_RE = /\.(cts|mts|ts)$/i;
 var cachedByCwd = /* @__PURE__ */ new Map();
 var announcedConfigFile = /* @__PURE__ */ new Set();
 var tsNodeRegistered = false;
+var tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
 var getTradejsProjectCwd = (cwd) => {
   const explicit = String(cwd ?? "").trim();
   if (explicit) {
@@ -5591,6 +5592,28 @@ var ensureTsNodeRegistered = async () => {
   });
   tsNodeRegistered = true;
 };
+var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  if (tsconfigPathsRegisteredByCwd.has(projectRoot)) {
+    return;
+  }
+  const tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const register = tsconfigPathsModule.register;
+  if (typeof loadConfig !== "function" || typeof register !== "function") {
+    return;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return;
+  }
+  register({
+    baseUrl: loadedConfig.absoluteBaseUrl,
+    paths: loadedConfig.paths,
+    addMatchAll: false
+  });
+  tsconfigPathsRegisteredByCwd.add(projectRoot);
+};
 var toImportSpecifier = (moduleName) => {
   if (moduleName.startsWith("file://")) {
     return moduleName;
@@ -5618,6 +5641,7 @@ var importConfigFile = async (configFilePath) => {
   if (ext === ".ts" || ext === ".mts") {
     const requireFn = getRequireFn(import_path.default.dirname(configFilePath));
     await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(import_path.default.dirname(configFilePath));
     return requireFn(configFilePath);
   }
   return import(
@@ -5625,7 +5649,7 @@ var importConfigFile = async (configFilePath) => {
     configFileUrl
   );
 };
-var importTradejsModule = async (moduleName) => {
+var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   const normalized = String(moduleName ?? "").trim();
   if (!normalized) {
     return {};
@@ -5639,13 +5663,15 @@ var importTradejsModule = async (moduleName) => {
     }
   }
   const requireFn = getRequireFn(
-    import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : getTradejsProjectCwd()
+    import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : cwd
   );
   if (isTsModulePath(modulePath)) {
     await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(cwd);
     return requireFn(modulePath);
   }
   if (isBareModuleSpecifier(normalized)) {
+    await ensureTsconfigPathsRegistered(cwd);
     return requireFn(normalized);
   }
   try {
@@ -5656,6 +5682,7 @@ var importTradejsModule = async (moduleName) => {
   } catch (error) {
     if (isTsModulePath(modulePath)) {
       await ensureTsNodeRegistered();
+      await ensureTsconfigPathsRegistered(cwd);
       return requireFn(modulePath);
     }
     throw error;
@@ -5733,14 +5760,29 @@ var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
 };
 
 // src/strategy/manifests.ts
-var strategyCreators = /* @__PURE__ */ new Map();
-var strategyManifestsMap = /* @__PURE__ */ new Map();
-var pluginsLoadPromise = null;
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = /* @__PURE__ */ new Map();
+var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createStrategyRegistryState();
+    registryStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
 var toUniqueModules = (modules = []) => [
   ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
 ];
-var getConfiguredPluginModuleNames = async () => {
-  const config = await loadTradejsConfig();
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
   return {
     strategyModules: toUniqueModules(config.strategies),
     indicatorModules: toUniqueModules(config.indicators)
@@ -5774,14 +5816,14 @@ var extractIndicatorPluginDefinition = (moduleExport) => {
   );
   return indicatorEntries ? { indicatorEntries } : null;
 };
-var registerEntries = (entries, source) => {
+var registerEntries = (entries, source, state) => {
   for (const entry of entries) {
     const strategyName = entry.manifest?.name;
     if (!strategyName) {
       import_logger2.logger.warn("Skip strategy entry without name from %s", source);
       continue;
     }
-    if (strategyCreators.has(strategyName)) {
+    if (state.strategyCreators.has(strategyName)) {
       import_logger2.logger.warn(
         'Skip duplicate strategy "%s" from %s: already registered',
         strategyName,
@@ -5789,83 +5831,102 @@ var registerEntries = (entries, source) => {
       );
       continue;
     }
-    strategyCreators.set(strategyName, entry.creator);
-    strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyCreators.set(strategyName, entry.creator);
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
   }
 };
-var importStrategyPluginModule = async (moduleName) => {
+var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName);
+    return importTradejsModule(moduleName, cwd);
   }
   return import(
     /* webpackIgnore: true */
     moduleName
   );
 };
-var ensureStrategyPluginsLoaded = async () => {
-  if (pluginsLoadPromise) {
-    return pluginsLoadPromise;
-  }
-  pluginsLoadPromise = (async () => {
-    const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames();
-    const strategySet = new Set(strategyModules);
-    const indicatorSet = new Set(indicatorModules);
-    const pluginModuleNames = [
-      .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
-    ];
-    if (!pluginModuleNames.length) return;
-    for (const moduleName of pluginModuleNames) {
-      try {
-        const resolvedModuleName = resolvePluginModuleSpecifier(moduleName);
-        const moduleExport = await importStrategyPluginModule(resolvedModuleName);
-        if (strategySet.has(moduleName)) {
-          const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
-          if (!pluginDefinition) {
-            import_logger2.logger.warn(
-              'Skip strategy plugin "%s": export { strategyEntries } is missing',
-              moduleName
-            );
-          } else {
-            registerEntries(pluginDefinition.strategyEntries, moduleName);
+var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
+    state.pluginsLoadPromise = (async () => {
+      const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
+      const strategySet = new Set(strategyModules);
+      const indicatorSet = new Set(indicatorModules);
+      const pluginModuleNames = [
+        .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
+      ];
+      if (!pluginModuleNames.length) {
+        return;
+      }
+      for (const moduleName of pluginModuleNames) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importStrategyPluginModule(
+            resolvedModuleName,
+            projectRoot
+          );
+          if (strategySet.has(moduleName)) {
+            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+            if (!pluginDefinition) {
+              import_logger2.logger.warn(
+                'Skip strategy plugin "%s": export { strategyEntries } is missing',
+                moduleName
+              );
+            } else {
+              registerEntries(
+                pluginDefinition.strategyEntries,
+                moduleName,
+                state
+              );
+            }
           }
-        }
-        if (indicatorSet.has(moduleName)) {
-          const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
-          if (!indicatorPluginDefinition) {
+          if (indicatorSet.has(moduleName)) {
+            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+            if (!indicatorPluginDefinition) {
+              import_logger2.logger.warn(
+                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                moduleName
+              );
+            } else {
+              (0, import_indicators.registerIndicatorEntries)(
+                indicatorPluginDefinition.indicatorEntries,
+                moduleName,
+                projectRoot
+              );
+            }
+          }
+          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
             import_logger2.logger.warn(
-              'Skip indicator plugin "%s": export { indicatorEntries } is missing',
-              moduleName
-            );
-          } else {
-            (0, import_indicators.registerIndicatorEntries)(
-              indicatorPluginDefinition.indicatorEntries,
+              'Skip plugin "%s": no strategy/indicator sections requested in config',
               moduleName
             );
           }
-        }
-        if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+        } catch (error) {
           import_logger2.logger.warn(
-            'Skip plugin "%s": no strategy/indicator sections requested in config',
-            moduleName
+            'Failed to load plugin "%s": %s',
+            moduleName,
+            String(error)
           );
         }
-      } catch (error) {
-        import_logger2.logger.warn(
-          'Failed to load plugin "%s": %s',
-          moduleName,
-          String(error)
-        );
       }
-    }
-  })();
-  return pluginsLoadPromise;
+    })();
+  }
+  await state.pluginsLoadPromise;
 };
-var getStrategyCreator = async (name) => {
-  await ensureStrategyPluginsLoaded();
-  return strategyCreators.get(name);
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
 };
-var getStrategyManifest = (name) => {
-  return name ? strategyManifestsMap.get(name) : void 0;
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
+  }
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
 };
 var strategies = new Proxy(
   {},
@@ -5874,10 +5935,10 @@ var strategies = new Proxy(
       if (typeof property !== "string") {
         return void 0;
       }
-      return strategyCreators.get(property);
+      return getStrategyRegistryState().state.strategyCreators.get(property);
     },
     ownKeys: () => {
-      return [...strategyCreators.keys()];
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
     },
     getOwnPropertyDescriptor: () => ({
       enumerable: true,
@@ -5930,9 +5991,24 @@ var buildMlPayload = (payload) => {
 
 // src/connectorsRegistry.ts
 var import_logger3 = require("@tradejs/infra/logger");
-var connectorCreators = /* @__PURE__ */ new Map();
-var providerToConnectorName = /* @__PURE__ */ new Map();
-var pluginsLoadPromise2 = null;
+var createConnectorRegistryState = () => ({
+  connectorCreators: /* @__PURE__ */ new Map(),
+  providerToConnectorName: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot2 = /* @__PURE__ */ new Map();
+var getConnectorRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot2.get(projectRoot);
+  if (!state) {
+    state = createConnectorRegistryState();
+    registryStateByProjectRoot2.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
 var BUILTIN_CONNECTOR_NAMES = {
   ByBit: "ByBit",
   Binance: "Binance",
@@ -5943,7 +6019,7 @@ var normalizeProvider = (value) => String(value ?? "").trim().toLowerCase();
 var toUniqueModules2 = (modules = []) => [
   ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
 ];
-var findConnectorNameInsensitive = (name) => {
+var findConnectorNameInsensitive = (name, connectorCreators) => {
   const normalized = name.trim().toLowerCase();
   if (!normalized) {
     return null;
@@ -5963,7 +6039,7 @@ var normalizeProviders = (providers, connectorName) => {
   }
   return [normalizeProvider(connectorName)];
 };
-var registerProvider = (provider, connectorName, source) => {
+var registerProvider = (provider, connectorName, source, providerToConnectorName) => {
   const existing = providerToConnectorName.get(provider);
   if (existing && existing !== connectorName) {
     import_logger3.logger.warn(
@@ -5976,7 +6052,7 @@ var registerProvider = (provider, connectorName, source) => {
   }
   providerToConnectorName.set(provider, connectorName);
 };
-var registerEntry = (entry, source) => {
+var registerEntry = (entry, source, state) => {
   const connectorName = String(entry?.name ?? "").trim();
   if (!connectorName) {
     import_logger3.logger.warn("Skip connector entry without name from %s", source);
@@ -5990,7 +6066,10 @@ var registerEntry = (entry, source) => {
     );
     return;
   }
-  const existingByName = findConnectorNameInsensitive(connectorName);
+  const existingByName = findConnectorNameInsensitive(
+    connectorName,
+    state.connectorCreators
+  );
   if (existingByName) {
     import_logger3.logger.warn(
       'Skip duplicate connector "%s" from %s: already registered as %s',
@@ -6000,15 +6079,20 @@ var registerEntry = (entry, source) => {
     );
     return;
   }
-  connectorCreators.set(connectorName, entry.creator);
+  state.connectorCreators.set(connectorName, entry.creator);
   const providers = normalizeProviders(entry.providers, connectorName);
   for (const provider of providers) {
-    registerProvider(provider, connectorName, source);
+    registerProvider(
+      provider,
+      connectorName,
+      source,
+      state.providerToConnectorName
+    );
   }
 };
-var registerEntries2 = (entries, source) => {
+var registerEntries2 = (entries, source, state) => {
   for (const entry of entries) {
-    registerEntry(entry, source);
+    registerEntry(entry, source, state);
   }
 };
 var extractConnectorPluginDefinition = (moduleExport) => {
@@ -6029,64 +6113,71 @@ var extractConnectorPluginDefinition = (moduleExport) => {
   }
   return null;
 };
-var importConnectorPluginModule = async (moduleName) => {
+var importConnectorPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName);
+    return importTradejsModule(moduleName, cwd);
   }
   return import(
     /* webpackIgnore: true */
     moduleName
   );
 };
-var ensureConnectorPluginsLoaded = async () => {
-  if (pluginsLoadPromise2) {
-    return pluginsLoadPromise2;
-  }
-  pluginsLoadPromise2 = (async () => {
-    const config = await loadTradejsConfig();
-    const connectorModules = toUniqueModules2(config.connectors);
-    if (!connectorModules.length) {
-      return;
-    }
-    for (const moduleName of connectorModules) {
-      try {
-        const resolvedModuleName = resolvePluginModuleSpecifier(moduleName);
-        const moduleExport = await importConnectorPluginModule(resolvedModuleName);
-        const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
-        if (!pluginDefinition) {
+var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getConnectorRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    state.pluginsLoadPromise = (async () => {
+      const config = await loadTradejsConfig(projectRoot);
+      const connectorModules = toUniqueModules2(config.connectors);
+      if (!connectorModules.length) {
+        return;
+      }
+      for (const moduleName of connectorModules) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importConnectorPluginModule(
+            resolvedModuleName,
+            projectRoot
+          );
+          const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
+          if (!pluginDefinition) {
+            import_logger3.logger.warn(
+              'Skip connector plugin "%s": export { connectorEntries } is missing',
+              moduleName
+            );
+            continue;
+          }
+          registerEntries2(pluginDefinition.connectorEntries, moduleName, state);
+        } catch (error) {
           import_logger3.logger.warn(
-            'Skip connector plugin "%s": export { connectorEntries } is missing',
-            moduleName
+            'Failed to load connector plugin "%s": %s',
+            moduleName,
+            String(error)
           );
-          continue;
-        }
-        registerEntries2(pluginDefinition.connectorEntries, moduleName);
-      } catch (error) {
-        import_logger3.logger.warn(
-          'Failed to load connector plugin "%s": %s',
-          moduleName,
-          String(error)
-        );
+        }
       }
-    }
-  })();
-  return pluginsLoadPromise2;
+    })();
+  }
+  await state.pluginsLoadPromise;
 };
-var getConnectorCreatorByName = async (connectorName) => {
-  await ensureConnectorPluginsLoaded();
+var getConnectorCreatorByName = async (connectorName, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
   const raw = String(connectorName ?? "").trim();
   if (!raw) {
     return void 0;
   }
-  const direct = connectorCreators.get(raw);
+  const direct = state.connectorCreators.get(raw);
   if (direct) {
     return direct;
   }
-  const existing = findConnectorNameInsensitive(raw);
+  const existing = findConnectorNameInsensitive(raw, state.connectorCreators);
   if (!existing) {
     return void 0;
   }
-  return connectorCreators.get(existing);
+  return state.connectorCreators.get(existing);
 };
 var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
 
@@ -6291,10 +6382,25 @@ var createTestConnector = (connector, context) => {
 
 // src/testing.ts
 var preloadStart = (0, import_time.getTimestamp)(import_constants2.PRELOAD_DAYS);
-var coinKlineCache = /* @__PURE__ */ new Map();
-var btcKlineCache = /* @__PURE__ */ new Map();
-var btcBinanceKlineCache = /* @__PURE__ */ new Map();
-var btcCoinbaseKlineCache = /* @__PURE__ */ new Map();
+var createTestingKlineCacheState = () => ({
+  coinKlineCache: /* @__PURE__ */ new Map(),
+  btcKlineCache: /* @__PURE__ */ new Map(),
+  btcBinanceKlineCache: /* @__PURE__ */ new Map(),
+  btcCoinbaseKlineCache: /* @__PURE__ */ new Map()
+});
+var testingKlineCacheStateByProjectRoot = /* @__PURE__ */ new Map();
+var getTestingKlineCacheState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = testingKlineCacheStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createTestingKlineCacheState();
+    testingKlineCacheStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
 var getKlineCacheKey = (params) => {
   const { userName, connectorName, symbol, end, interval, cacheOnly } = params;
   return [
@@ -6307,11 +6413,15 @@ var getKlineCacheKey = (params) => {
     cacheOnly ? 1 : 0
   ].join(":");
 };
-var resetTestingKlineCache = () => {
-  coinKlineCache.clear();
-  btcKlineCache.clear();
-  btcBinanceKlineCache.clear();
-  btcCoinbaseKlineCache.clear();
+var resetTestingKlineCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    testingKlineCacheStateByProjectRoot.clear();
+    return;
+  }
+  testingKlineCacheStateByProjectRoot.delete(
+    getTradejsProjectCwd(normalizedCwd)
+  );
 };
 var testing = async ({
   userName,
@@ -6329,22 +6439,28 @@ var testing = async ({
   if (!start) {
     throw new Error("no start");
   }
-  const connectorCreator = await getConnectorCreatorByName(connectorName);
+  const { projectRoot, state } = getTestingKlineCacheState();
+  const connectorCreator = await getConnectorCreatorByName(
+    connectorName,
+    projectRoot
+  );
   if (!connectorCreator) {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
   const connector = await connectorCreator({
     userName
   });
-  const strategyCreator = await getStrategyCreator(strategyName);
+  const strategyCreator = await getStrategyCreator(strategyName, projectRoot);
   if (!strategyCreator) {
     throw new Error(`Unknown strategy: ${strategyName}`);
   }
   const binanceCreator = await getConnectorCreatorByName(
-    BUILTIN_CONNECTOR_NAMES.Binance
+    BUILTIN_CONNECTOR_NAMES.Binance,
+    projectRoot
   );
   const coinbaseCreator = await getConnectorCreatorByName(
-    BUILTIN_CONNECTOR_NAMES.Coinbase
+    BUILTIN_CONNECTOR_NAMES.Coinbase,
+    projectRoot
   );
   if (!binanceCreator || !coinbaseCreator) {
     import_logger4.logger.warn(
@@ -6370,8 +6486,8 @@ var testing = async ({
     interval,
     cacheOnly
   });
-  const cachedCoinData = coinKlineCache.get(coinCacheKey);
-  const cachedBtcData = btcKlineCache.get(btcCacheKey);
+  const cachedCoinData = state.coinKlineCache.get(coinCacheKey);
+  const cachedBtcData = state.btcKlineCache.get(btcCacheKey);
   const btcBinanceCacheKey = getKlineCacheKey({
     userName,
     connectorName: binanceCreator ? BUILTIN_CONNECTOR_NAMES.Binance : connectorName,
@@ -6388,8 +6504,8 @@ var testing = async ({
     interval,
     cacheOnly
   });
-  const cachedBtcBinanceData = btcBinanceKlineCache.get(btcBinanceCacheKey);
-  const cachedBtcCoinbaseData = btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
+  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,
@@ -6443,16 +6559,16 @@ var testing = async ({
     })
   ]);
   if (!cachedCoinData) {
-    coinKlineCache.set(coinCacheKey, data);
+    state.coinKlineCache.set(coinCacheKey, data);
   }
   if (!cachedBtcData) {
-    btcKlineCache.set(btcCacheKey, btcData);
+    state.btcKlineCache.set(btcCacheKey, btcData);
   }
   if (!cachedBtcBinanceData) {
-    btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
+    state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
   }
   if (!cachedBtcCoinbaseData) {
-    btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
+    state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
   }
   const prevDataRaw = data.filter(
     (candle) => candle.timestamp >= preloadStart && candle.timestamp < start