backtest-kit 1.5.26 → 1.5.28

package/build/index.cjs

@@ -2043,7 +2043,7 @@ const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
 const BASE_WAIT_FOR_INIT_FN = async (self) => {
-    backtest$1.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+    bt.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
         entityName: self.entityName,
         directory: self._directory,
     });
@@ -2101,7 +2101,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
             entityName: this.entityName,
             baseDir,
         });
@@ -2117,7 +2117,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         return path.join(this.baseDir, this.entityName, `${entityId}.json`);
     }
     async waitForInit(initial) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             entityName: this.entityName,
             initial,
         });
@@ -2134,7 +2134,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         return length;
     }
     async readValue(entityId) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2151,7 +2151,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         }
     }
     async hasValue(entityId) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2168,7 +2168,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         }
     }
     async writeValue(entityId, entity) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2189,7 +2189,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if entity not found or deletion fails
      */
     async removeValue(entityId) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_VALUE, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2211,7 +2211,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if deletion fails
      */
     async removeAll() {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_ALL, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_ALL, {
             entityName: this.entityName,
         });
         try {
@@ -2233,7 +2233,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if reading fails
      */
     async *values() {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_VALUES, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_VALUES, {
             entityName: this.entityName,
         });
         try {
@@ -2262,7 +2262,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if reading fails
      */
     async *keys() {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
             entityName: this.entityName,
         });
         try {
@@ -2367,7 +2367,7 @@ class PersistSignalUtils {
          * @returns Promise resolving to signal or null
          */
         this.readSignalData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getSignalStorage.has(key);
             const stateStorage = this.getSignalStorage(symbol, strategyName);
@@ -2389,7 +2389,7 @@ class PersistSignalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSignalData = async (signalRow, symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getSignalStorage.has(key);
             const stateStorage = this.getSignalStorage(symbol, strategyName);
@@ -2412,7 +2412,7 @@ class PersistSignalUtils {
      * ```
      */
     usePersistSignalAdapter(Ctor) {
-        backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
         this.PersistSignalFactory = Ctor;
     }
 }
@@ -2464,7 +2464,7 @@ class PersistRiskUtils {
          * @returns Promise resolving to Map of active positions
          */
         this.readPositionData = async (riskName) => {
-            backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const isInitial = !this.getRiskStorage.has(riskName);
             const stateStorage = this.getRiskStorage(riskName);
             await stateStorage.waitForInit(isInitial);
@@ -2485,7 +2485,7 @@ class PersistRiskUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePositionData = async (riskRow, riskName) => {
-            backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const isInitial = !this.getRiskStorage.has(riskName);
             const stateStorage = this.getRiskStorage(riskName);
             await stateStorage.waitForInit(isInitial);
@@ -2508,7 +2508,7 @@ class PersistRiskUtils {
      * ```
      */
     usePersistRiskAdapter(Ctor) {
-        backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
         this.PersistRiskFactory = Ctor;
     }
 }
@@ -2558,7 +2558,7 @@ class PersistScheduleUtils {
          * @returns Promise resolving to scheduled signal or null
          */
         this.readScheduleData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const stateStorage = this.getScheduleStorage(symbol, strategyName);
@@ -2580,7 +2580,7 @@ class PersistScheduleUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const stateStorage = this.getScheduleStorage(symbol, strategyName);
@@ -2603,7 +2603,7 @@ class PersistScheduleUtils {
      * ```
      */
     usePersistScheduleAdapter(Ctor) {
-        backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
         this.PersistScheduleFactory = Ctor;
     }
 }
@@ -2628,7 +2628,7 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
  * Utility class for managing partial profit/loss levels persistence.
  *
  * Features:
- * - Memoized storage instances per symbol
+ * - Memoized storage instances per symbol:strategyName
  * - Custom adapter support
  * - Atomic read/write operations for partial data
  * - Crash-safe partial state management
@@ -2638,23 +2638,25 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
 class PersistPartialUtils {
     constructor() {
         this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = functoolsKit.memoize(([symbol]) => `${symbol}`, (symbol) => Reflect.construct(this.PersistPartialFactory, [
-            symbol,
+        this.getPartialStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => Reflect.construct(this.PersistPartialFactory, [
+            `${symbol}_${strategyName}`,
             `./dump/data/partial/`,
         ]));
         /**
-         * Reads persisted partial data for a symbol.
+         * Reads persisted partial data for a symbol and strategy.
          *
          * Called by ClientPartial.waitForInit() to restore state.
          * Returns empty object if no partial data exists.
          *
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise resolving to partial data record
          */
-        this.readPartialData = async (symbol) => {
-            backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
-            const isInitial = !this.getPartialStorage.has(symbol);
-            const stateStorage = this.getPartialStorage(symbol);
+        this.readPartialData = async (symbol, strategyName) => {
+            bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getPartialStorage.has(key);
+            const stateStorage = this.getPartialStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             const PARTIAL_STORAGE_KEY = "levels";
             if (await stateStorage.hasValue(PARTIAL_STORAGE_KEY)) {
@@ -2670,12 +2672,14 @@ class PersistPartialUtils {
          *
          * @param partialData - Record of signal IDs to partial data
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise that resolves when write is complete
          */
-        this.writePartialData = async (partialData, symbol) => {
-            backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
-            const isInitial = !this.getPartialStorage.has(symbol);
-            const stateStorage = this.getPartialStorage(symbol);
+        this.writePartialData = async (partialData, symbol, strategyName) => {
+            bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getPartialStorage.has(key);
+            const stateStorage = this.getPartialStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             const PARTIAL_STORAGE_KEY = "levels";
             await stateStorage.writeValue(PARTIAL_STORAGE_KEY, partialData);
@@ -2696,7 +2700,7 @@ class PersistPartialUtils {
      * ```
      */
     usePersistPartialAdapter(Ctor) {
-        backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
         this.PersistPartialFactory = Ctor;
     }
 }
@@ -2710,10 +2714,10 @@ class PersistPartialUtils {
  * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
  *
  * // Read partial data
- * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT");
+ * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT", "my-strategy");
  *
  * // Write partial data
- * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT");
+ * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT", "my-strategy");
  * ```
  */
 const PersistPartialAdapter = new PersistPartialUtils();
@@ -3165,7 +3169,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        backtest$1.loggerService.warn(message, payload);
+        bt.loggerService.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -3244,6 +3248,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3295,6 +3300,7 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: currentPrice,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3362,6 +3368,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: self._pendingSignal.priceOpen,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3378,6 +3385,7 @@ const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice)
         symbol: self.params.execution.context.symbol,
         percentTp: 0,
         percentSl: 0,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3403,6 +3411,7 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: currentPrice,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3434,6 +3443,7 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: signal.priceOpen,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3498,6 +3508,7 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3567,6 +3578,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
         symbol: self.params.execution.context.symbol,
         percentTp,
         percentSl,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3584,6 +3596,7 @@ const RETURN_IDLE_FN = async (self, currentPrice) => {
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: currentPrice,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3610,6 +3623,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3705,6 +3719,7 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -4203,6 +4218,7 @@ class ClientStrategy {
                         strategyName: this.params.method.context.strategyName,
                         exchangeName: this.params.method.context.exchangeName,
                         symbol: this.params.execution.context.symbol,
+                        backtest: this.params.execution.context.backtest,
                     };
                     return result; // Cast to IStrategyBacktestResult (which includes Active)
                 }
@@ -4333,7 +4349,7 @@ class MergeRisk {
      * @returns Promise resolving to true if all risks approve, false if any risk rejects
      */
     async checkSignal(params) {
-        backtest$1.loggerService.info("MergeRisk checkSignal", {
+        bt.loggerService.info("MergeRisk checkSignal", {
             params,
         });
         const riskCheck = await Promise.all(this._riskList.map(async (risk) => await risk.checkSignal(params)));
@@ -4350,7 +4366,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have registered the signal
      */
     async addSignal(symbol, context) {
-        backtest$1.loggerService.info("MergeRisk addSignal", {
+        bt.loggerService.info("MergeRisk addSignal", {
             symbol,
             context,
         });
@@ -4367,7 +4383,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have removed the signal
      */
     async removeSignal(symbol, context) {
-        backtest$1.loggerService.info("MergeRisk removeSignal", {
+        bt.loggerService.info("MergeRisk removeSignal", {
             symbol,
             context,
         });
@@ -4435,19 +4451,19 @@ class RiskUtils {
          * }
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_DATA, {
+        this.getData = async (symbol, strategyName, backtest) => {
+            bt.loggerService.info(RISK_METHOD_NAME_GET_DATA, {
                 symbol,
                 strategyName,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
+            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA));
+                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.riskMarkdownService.getData(symbol, strategyName);
+            return await bt.riskMarkdownService.getData(symbol, strategyName, backtest);
         };
         /**
          * Generates markdown report with all risk rejection events for a symbol-strategy pair.
@@ -4490,19 +4506,19 @@ class RiskUtils {
          * // - my-strategy: 1
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
+        this.getReport = async (symbol, strategyName, backtest, columns) => {
+            bt.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
+            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
+                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName, columns);
+            return await bt.riskMarkdownService.getReport(symbol, strategyName, backtest, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -4536,20 +4552,20 @@ class RiskUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, {
+        this.dump = async (symbol, strategyName, backtest, path, columns) => {
+            bt.loggerService.info(RISK_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
+            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP));
+                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP));
             }
-            await backtest$1.riskMarkdownService.dump(symbol, strategyName, path, columns);
+            await bt.riskMarkdownService.dump(symbol, strategyName, backtest, path, columns);
         };
     }
 }
@@ -4574,25 +4590,25 @@ const NOOP_RISK = {
     addSignal: () => Promise.resolve(),
     removeSignal: () => Promise.resolve(),
 };
-const GET_RISK_FN = (dto, self) => {
+const GET_RISK_FN = (dto, backtest, self) => {
     const hasRiskName = !!dto.riskName;
-    const hasRiskList = !!(dto.riskList?.length);
+    const hasRiskList = !!dto.riskList?.length;
     // Нет ни riskName, ни riskList
     if (!hasRiskName && !hasRiskList) {
         return NOOP_RISK;
     }
     // Есть только riskName (без riskList)
     if (hasRiskName && !hasRiskList) {
-        return self.riskConnectionService.getRisk(dto.riskName);
+        return self.riskConnectionService.getRisk(dto.riskName, backtest);
     }
     // Есть только riskList (без riskName)
     if (!hasRiskName && hasRiskList) {
-        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName)));
+        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)));
     }
     // Есть и riskName, и riskList - объединяем (riskName в начало)
     return new MergeRisk([
-        self.riskConnectionService.getRisk(dto.riskName),
-        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName))
+        self.riskConnectionService.getRisk(dto.riskName, backtest),
+        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)),
     ]);
 };
 /**
@@ -4634,7 +4650,7 @@ class StrategyConnectionService {
          * @param strategyName - Name of registered strategy schema
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => {
+        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, (symbol, strategyName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -4647,7 +4663,7 @@ class StrategyConnectionService {
                 risk: GET_RISK_FN({
                     riskName,
                     riskList,
-                }, this),
+                }, backtest, this),
                 riskName,
                 strategyName,
                 getSignal,
@@ -4664,12 +4680,13 @@ class StrategyConnectionService {
          *
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, strategyName) => {
+        this.getPendingSignal = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyConnectionService getPendingSignal", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             return await strategy.getPendingSignal(symbol, strategyName);
         };
         /**
@@ -4682,12 +4699,13 @@ class StrategyConnectionService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
-        this.getStopped = async (symbol, strategyName) => {
+        this.getStopped = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyConnectionService getStopped", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             return await strategy.getStopped(symbol, strategyName);
         };
         /**
@@ -4705,7 +4723,8 @@ class StrategyConnectionService {
                 symbol,
                 strategyName,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const backtest = this.executionContextService.context.backtest;
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             await strategy.waitForInit();
             const tick = await strategy.tick(symbol, strategyName);
             {
@@ -4736,7 +4755,8 @@ class StrategyConnectionService {
                 strategyName,
                 candleCount: candles.length,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const backtest = this.executionContextService.context.backtest;
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             await strategy.waitForInit();
             const tick = await strategy.backtest(symbol, strategyName, candles);
             {
@@ -4757,11 +4777,11 @@ class StrategyConnectionService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx, backtest) => {
+        this.stop = async (backtest, ctx) => {
             this.loggerService.log("strategyConnectionService stop", {
                 ctx,
             });
-            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName);
+            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName, backtest);
             await strategy.stop(ctx.symbol, ctx.strategyName, backtest);
         };
         /**
@@ -4772,12 +4792,12 @@ class StrategyConnectionService {
          *
          * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("strategyConnectionService clear", {
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStrategy.clear(key);
             }
             else {
@@ -5163,7 +5183,7 @@ const DO_VALIDATION_FN = functoolsKit.trycatch(async (validation, params) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        backtest$1.loggerService.warn(message, payload);
+        bt.loggerService.warn(message, payload);
         console.warn(message, payload);
         validationSubject.next(error);
     },
@@ -5172,9 +5192,15 @@ const DO_VALIDATION_FN = functoolsKit.trycatch(async (validation, params) => {
  * Initializes active positions by reading from persistence.
  * Uses singleshot pattern to ensure it only runs once.
  * This function is exported for use in tests or other modules.
+ *
+ * In backtest mode, initializes with empty Map. In live mode, reads from persist storage.
  */
 const WAIT_FOR_INIT_FN$1 = async (self) => {
-    self.params.logger.debug("ClientRisk waitForInit");
+    self.params.logger.debug("ClientRisk waitForInit", { backtest: self.params.backtest });
+    if (self.params.backtest) {
+        self._activePositions = new Map();
+        return;
+    }
     const persistedPositions = await PersistRiskAdapter.readPositionData(self.params.riskName);
     self._activePositions = new Map(persistedPositions);
 };
@@ -5222,6 +5248,7 @@ class ClientRisk {
             this.params.logger.debug("ClientRisk checkSignal", {
                 symbol: params.symbol,
                 strategyName: params.strategyName,
+                backtest: this.params.backtest,
             });
             if (this._activePositions === POSITION_NEED_FETCH) {
                 await this.waitForInit();
@@ -5251,7 +5278,7 @@ class ClientRisk {
             }
             if (!isValid) {
                 // Call params.onRejected for riskSubject emission
-                await this.params.onRejected(params.symbol, params, riskMap.size, rejectionNote, Date.now());
+                await this.params.onRejected(params.symbol, params, riskMap.size, rejectionNote, Date.now(), this.params.backtest);
                 // Call schema callbacks.onRejected if defined
                 if (this.params.callbacks?.onRejected) {
                     this.params.callbacks.onRejected(params.symbol, params);
@@ -5267,8 +5294,12 @@ class ClientRisk {
     }
     /**
      * Persists current active positions to disk.
+     * Skips in backtest mode.
      */
     async _updatePositions() {
+        if (this.params.backtest) {
+            return;
+        }
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
         }
@@ -5282,6 +5313,7 @@ class ClientRisk {
         this.params.logger.debug("ClientRisk addSignal", {
             symbol,
             context,
+            backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
@@ -5304,6 +5336,7 @@ class ClientRisk {
         this.params.logger.debug("ClientRisk removeSignal", {
             symbol,
             context,
+            backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
@@ -5326,8 +5359,9 @@ class ClientRisk {
  * @param activePositionCount - Number of active positions at rejection time
  * @param comment - Rejection reason from validation note or "N/A"
  * @param timestamp - Event timestamp in milliseconds
+ * @param backtest - True if backtest mode, false if live mode
  */
-const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment, timestamp) => await riskSubject.next({
+const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment, timestamp, backtest) => await riskSubject.next({
     symbol,
     pendingSignal: params.pendingSignal,
     strategyName: params.strategyName,
@@ -5336,6 +5370,7 @@ const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment,
     activePositionCount,
     comment,
     timestamp,
+    backtest,
 });
 /**
  * Connection service routing risk operations to correct ClientRisk instance.
@@ -5374,19 +5409,21 @@ class RiskConnectionService {
         this.loggerService = inject(TYPES.loggerService);
         this.riskSchemaService = inject(TYPES.riskSchemaService);
         /**
-         * Retrieves memoized ClientRisk instance for given risk name.
+         * Retrieves memoized ClientRisk instance for given risk name and backtest mode.
          *
          * Creates ClientRisk on first call, returns cached instance on subsequent calls.
-         * Cache key is riskName string.
+         * Cache key is "riskName:backtest" string to separate live and backtest instances.
          *
          * @param riskName - Name of registered risk schema
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = functoolsKit.memoize(([riskName]) => `${riskName}`, (riskName) => {
+        this.getRisk = functoolsKit.memoize(([riskName, backtest]) => `${riskName}:${backtest ? "backtest" : "live"}`, (riskName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
                 logger: this.loggerService,
+                backtest,
                 onRejected: COMMIT_REJECTION_FN,
             });
         });
@@ -5398,7 +5435,7 @@ class RiskConnectionService {
          * ClientRisk will emit riskSubject event via onRejected callback when signal is rejected.
          *
          * @param params - Risk check arguments (portfolio state, position details)
-         * @param context - Execution context with risk name
+         * @param context - Execution context with risk name and backtest mode
          * @returns Promise resolving to risk check result
          */
         this.checkSignal = async (params, context) => {
@@ -5406,46 +5443,48 @@ class RiskConnectionService {
                 symbol: params.symbol,
                 context,
             });
-            return await this.getRisk(context.riskName).checkSignal(params);
+            return await this.getRisk(context.riskName, context.backtest).checkSignal(params);
         };
         /**
          * Registers an opened signal with the risk management system.
          * Routes to appropriate ClientRisk instance.
          *
          * @param symbol - Trading pair symbol
-         * @param context - Context information (strategyName, riskName)
+         * @param context - Context information (strategyName, riskName, backtest)
          */
         this.addSignal = async (symbol, context) => {
             this.loggerService.log("riskConnectionService addSignal", {
                 symbol,
                 context,
             });
-            await this.getRisk(context.riskName).addSignal(symbol, context);
+            await this.getRisk(context.riskName, context.backtest).addSignal(symbol, context);
         };
         /**
          * Removes a closed signal from the risk management system.
          * Routes to appropriate ClientRisk instance.
          *
          * @param symbol - Trading pair symbol
-         * @param context - Context information (strategyName, riskName)
+         * @param context - Context information (strategyName, riskName, backtest)
          */
         this.removeSignal = async (symbol, context) => {
             this.loggerService.log("riskConnectionService removeSignal", {
                 symbol,
                 context,
             });
-            await this.getRisk(context.riskName).removeSignal(symbol, context);
+            await this.getRisk(context.riskName, context.backtest).removeSignal(symbol, context);
         };
         /**
          * Clears the cached ClientRisk instance for the given risk name.
          *
          * @param riskName - Name of the risk schema to clear from cache
          */
-        this.clear = async (riskName) => {
+        this.clear = async (backtest, riskName) => {
             this.loggerService.log("riskConnectionService clear", {
                 riskName,
+                backtest,
             });
-            this.getRisk.clear(riskName);
+            const key = `${riskName}:${backtest ? "backtest" : "live"}`;
+            this.getRisk.clear(key);
         };
     }
 }
@@ -5668,7 +5707,7 @@ class StrategyCoreService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, strategyName) => {
+        this.getPendingSignal = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyCoreService getPendingSignal", {
                 symbol,
                 strategyName,
@@ -5677,7 +5716,7 @@ class StrategyCoreService {
                 throw new Error("strategyCoreService getPendingSignal requires a method context");
             }
             await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getPendingSignal(symbol, strategyName);
+            return await this.strategyConnectionService.getPendingSignal(backtest, symbol, strategyName);
         };
         /**
          * Checks if the strategy has been stopped.
@@ -5689,16 +5728,17 @@ class StrategyCoreService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
-        this.getStopped = async (symbol, strategyName) => {
+        this.getStopped = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyCoreService getStopped", {
                 symbol,
                 strategyName,
+                backtest,
             });
             if (!MethodContextService.hasContext()) {
                 throw new Error("strategyCoreService getStopped requires a method context");
             }
             await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getStopped(symbol, strategyName);
+            return await this.strategyConnectionService.getStopped(backtest, symbol, strategyName);
         };
         /**
          * Checks signal status at a specific timestamp.
@@ -5772,13 +5812,13 @@ class StrategyCoreService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx, backtest) => {
+        this.stop = async (backtest, ctx) => {
             this.loggerService.log("strategyCoreService stop", {
                 ctx,
                 backtest,
             });
             await this.validate(ctx.symbol, ctx.strategyName);
-            return await this.strategyConnectionService.stop(ctx, backtest);
+            return await this.strategyConnectionService.stop(backtest, ctx);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -5788,14 +5828,14 @@ class StrategyCoreService {
          *
          * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("strategyCoreService clear", {
                 ctx,
             });
             if (ctx) {
                 await this.validate(ctx.symbol, ctx.strategyName);
             }
-            return await this.strategyConnectionService.clear(ctx);
+            return await this.strategyConnectionService.clear(backtest, ctx);
         };
     }
 }
@@ -5936,14 +5976,15 @@ class RiskGlobalService {
          * If no riskName is provided, clears all risk data.
          * @param riskName - Optional name of the risk instance to clear
          */
-        this.clear = async (riskName) => {
+        this.clear = async (backtest, riskName) => {
             this.loggerService.log("riskGlobalService clear", {
                 riskName,
+                backtest,
             });
             if (riskName) {
                 await this.validate(riskName);
             }
-            return await this.riskConnectionService.clear(riskName);
+            return await this.riskConnectionService.clear(backtest, riskName);
         };
     }
 }
@@ -6487,7 +6528,7 @@ class BacktestLogicPrivateService {
                 });
             }
             // Check if strategy should stop before processing next frame
-            if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+            if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (before tick)", {
                     symbol,
                     when: when.toISOString(),
@@ -6512,7 +6553,7 @@ class BacktestLogicPrivateService {
                 continue;
             }
             // Check if strategy should stop when idle (no active signal)
-            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName))) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
                     symbol,
                     when: when.toISOString(),
@@ -6614,7 +6655,7 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after scheduled signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -6707,7 +6748,7 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -6850,7 +6891,7 @@ class LiveLogicPrivateService {
             previousEventTimestamp = currentTimestamp;
             // Check if strategy should stop when idle (no active signal)
             if (result.action === "idle") {
-                if (await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                if (await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(false, symbol, this.methodContextService.context.strategyName))) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (idle state)", {
                         symbol,
                         when: when.toISOString(),
@@ -6872,7 +6913,7 @@ class LiveLogicPrivateService {
             yield result;
             // Check if strategy should stop after signal is closed
             if (result.action === "closed") {
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(false, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: result.signal.id,
@@ -7004,7 +7045,7 @@ class WalkerLogicPrivateService {
                     symbol,
                 });
                 // Get statistics from BacktestMarkdownService
-                const stats = await this.backtestMarkdownService.getData(symbol, strategyName);
+                const stats = await this.backtestMarkdownService.getData(symbol, strategyName, true);
                 // Extract metric value
                 const value = stats[metric];
                 const metricValue = value !== null &&
@@ -7068,7 +7109,7 @@ class WalkerLogicPrivateService {
             bestStrategy,
             bestMetric,
             bestStats: bestStrategy !== null
-                ? await this.backtestMarkdownService.getData(symbol, bestStrategy)
+                ? await this.backtestMarkdownService.getData(symbol, bestStrategy, true)
                 : null,
         };
         // Call onComplete callback if provided with final best results
@@ -7581,10 +7622,10 @@ class BacktestMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$5());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$5());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -7611,7 +7652,7 @@ class BacktestMarkdownService {
             if (data.action !== "closed") {
                 return;
             }
-            const storage = this.getStorage(data.symbol, data.strategyName);
+            const storage = this.getStorage(data.symbol, data.strategyName, true);
             storage.addSignal(data);
         };
         /**
@@ -7620,21 +7661,23 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy");
+         * const stats = await service.getData("BTCUSDT", "my-strategy", true);
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
+        this.getData = async (symbol, strategyName, backtest) => {
             this.loggerService.log("backtestMarkdownService getData", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getData();
         };
         /**
@@ -7643,22 +7686,24 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all closed signals
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", true);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.backtest_columns) => {
+        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService getReport", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -7668,6 +7713,7 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/backtest")
          * @param columns - Column configuration for formatting the table
          *
@@ -7676,45 +7722,48 @@ class BacktestMarkdownService {
          * const service = new BacktestMarkdownService();
          *
          * // Save to default path: ./dump/backtest/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy");
+         * await service.dump("BTCUSDT", "my-strategy", true);
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", true, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) => {
+        this.dump = async (symbol, strategyName, backtest, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService dump", {
                 symbol,
                 strategyName,
+                backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated signal data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
          * If nothing is provided, clears all data.
          *
+         * @param backtest - Backtest mode flag
          * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
          *
-         * // Clear specific symbol-strategy pair
-         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific symbol-strategy-backtest triple
+         * await service.clear(true, { symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("backtestMarkdownService clear", {
+                backtest,
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStorage.clear(key);
             }
             else {
@@ -8065,10 +8114,10 @@ class LiveMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$4());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -8094,7 +8143,7 @@ class LiveMarkdownService {
             this.loggerService.log("liveMarkdownService tick", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.strategyName);
+            const storage = this.getStorage(data.symbol, data.strategyName, false);
             if (data.action === "idle") {
                 storage.addIdleEvent(data.currentPrice);
             }
@@ -8114,21 +8163,23 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy");
+         * const stats = await service.getData("BTCUSDT", "my-strategy", false);
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
+        this.getData = async (symbol, strategyName, backtest) => {
             this.loggerService.log("liveMarkdownService getData", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getData();
         };
         /**
@@ -8137,22 +8188,24 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.live_columns) => {
+        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.live_columns) => {
             this.loggerService.log("liveMarkdownService getReport", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -8162,6 +8215,7 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/live")
          * @param columns - Column configuration for formatting the table
          *
@@ -8170,45 +8224,48 @@ class LiveMarkdownService {
          * const service = new LiveMarkdownService();
          *
          * // Save to default path: ./dump/live/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy");
+         * await service.dump("BTCUSDT", "my-strategy", false);
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) => {
+        this.dump = async (symbol, strategyName, backtest, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) => {
             this.loggerService.log("liveMarkdownService dump", {
                 symbol,
                 strategyName,
+                backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
          * If nothing is provided, clears all data.
          *
+         * @param backtest - Backtest mode flag
          * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
          *
-         * // Clear specific symbol-strategy pair
-         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific symbol-strategy-backtest triple
+         * await service.clear(false, { symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("liveMarkdownService clear", {
+                backtest,
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStorage.clear(key);
             }
             else {
@@ -8463,10 +8520,10 @@ class ScheduleMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$3());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates scheduled/opened/cancelled events.
          * Should be called from signalEmitter subscription.
@@ -8485,7 +8542,7 @@ class ScheduleMarkdownService {
             this.loggerService.log("scheduleMarkdownService tick", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.strategyName);
+            const storage = this.getStorage(data.symbol, data.strategyName, data.backtest);
             if (data.action === "scheduled") {
                 storage.addScheduledEvent(data);
             }
@@ -8506,21 +8563,23 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy");
+         * const stats = await service.getData("BTCUSDT", "my-strategy", false);
          * console.log(stats.cancellationRate, stats.avgWaitTime);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
+        this.getData = async (symbol, strategyName, backtest) => {
             this.loggerService.log("scheduleMarkdownService getData", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getData();
         };
         /**
@@ -8529,22 +8588,24 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.schedule_columns) => {
+        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService getReport", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -8554,6 +8615,7 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/schedule")
          * @param columns - Column configuration for formatting the table
          *
@@ -8562,45 +8624,48 @@ class ScheduleMarkdownService {
          * const service = new ScheduleMarkdownService();
          *
          * // Save to default path: ./dump/schedule/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy");
+         * await service.dump("BTCUSDT", "my-strategy", false);
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) => {
+        this.dump = async (symbol, strategyName, backtest, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService dump", {
                 symbol,
                 strategyName,
+                backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
          * If nothing is provided, clears all data.
          *
+         * @param backtest - Backtest mode flag
          * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
          *
-         * // Clear specific symbol-strategy pair
-         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific symbol-strategy-backtest triple
+         * await service.clear(false, { symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("scheduleMarkdownService clear", {
+                backtest,
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStorage.clear(key);
             }
             else {
@@ -8839,10 +8904,10 @@ class PerformanceMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create PerformanceStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create PerformanceStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new PerformanceStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new PerformanceStorage());
         /**
          * Processes performance events and accumulates metrics.
          * Should be called from performance tracking code.
@@ -8855,7 +8920,7 @@ class PerformanceMarkdownService {
             });
             const symbol = event.symbol || "global";
             const strategyName = event.strategyName || "global";
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, event.backtest);
             storage.addEvent(event);
         };
         /**
@@ -8863,22 +8928,24 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Performance statistics with aggregated metrics
          *
          * @example
          * ```typescript
-         * const stats = await performanceService.getData("BTCUSDT", "my-strategy");
+         * const stats = await performanceService.getData("BTCUSDT", "my-strategy", false);
          * console.log("Total time:", stats.totalDuration);
          * console.log("Slowest operation:", Object.values(stats.metricStats)
          *   .sort((a, b) => b.avgDuration - a.avgDuration)[0]);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
+        this.getData = async (symbol, strategyName, backtest) => {
             this.loggerService.log("performanceMarkdownService getData", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getData(strategyName);
         };
         /**
@@ -8886,21 +8953,23 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await performanceService.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await performanceService.getReport("BTCUSDT", "my-strategy", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.performance_columns) => {
+        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService getReport", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -8908,42 +8977,45 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report
          * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
          * // Save to default path: ./dump/performance/my-strategy.md
-         * await performanceService.dump("BTCUSDT", "my-strategy");
+         * await performanceService.dump("BTCUSDT", "my-strategy", false);
          *
          * // Save to custom path
-         * await performanceService.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await performanceService.dump("BTCUSDT", "my-strategy", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) => {
+        this.dump = async (symbol, strategyName, backtest, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService dump", {
                 symbol,
                 strategyName,
+                backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated performance data from storage.
          *
-         * @param symbol - Optional trading pair symbol
-         * @param strategyName - Optional strategy name
+         * @param backtest - Backtest mode flag
+         * @param ctx - Optional context with symbol and strategyName
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("performanceMarkdownService clear", {
+                backtest,
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStorage.clear(key);
             }
-            {
+            else {
                 this.getStorage.clear();
             }
         };
@@ -9707,10 +9779,10 @@ class HeatMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create HeatmapStorage for a strategy.
-         * Each strategy gets its own isolated heatmap storage instance.
+         * Memoized function to get or create HeatmapStorage for a strategy and backtest mode.
+         * Each strategy + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, () => new HeatmapStorage());
+        this.getStorage = functoolsKit.memoize(([strategyName, backtest]) => `${strategyName}:${backtest ? "backtest" : "live"}`, () => new HeatmapStorage());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from signal emitter subscription.
@@ -9726,19 +9798,20 @@ class HeatMarkdownService {
             if (data.action !== "closed") {
                 return;
             }
-            const storage = this.getStorage(data.strategyName);
+            const storage = this.getStorage(data.strategyName, data.backtest);
             storage.addSignal(data);
         };
         /**
          * Gets aggregated portfolio heatmap statistics for a strategy.
          *
          * @param strategyName - Strategy name to get heatmap data for
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Promise resolving to heatmap statistics with per-symbol and portfolio-wide metrics
          *
          * @example
          * ```typescript
          * const service = new HeatMarkdownService();
-         * const stats = await service.getData("my-strategy");
+         * const stats = await service.getData("my-strategy", true);
          *
          * console.log(`Total symbols: ${stats.totalSymbols}`);
          * console.log(`Portfolio PNL: ${stats.portfolioTotalPnl}%`);
@@ -9748,24 +9821,26 @@ class HeatMarkdownService {
          * });
          * ```
          */
-        this.getData = async (strategyName) => {
+        this.getData = async (strategyName, backtest) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_GET_DATA, {
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(strategyName, backtest);
             return storage.getData();
         };
         /**
          * Generates markdown report with portfolio heatmap table for a strategy.
          *
          * @param strategyName - Strategy name to generate heatmap report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
          * const service = new HeatMarkdownService();
-         * const markdown = await service.getReport("my-strategy");
+         * const markdown = await service.getReport("my-strategy", true);
          * console.log(markdown);
          * // Output:
          * // # Portfolio Heatmap: my-strategy
@@ -9779,11 +9854,12 @@ class HeatMarkdownService {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName, columns = COLUMN_CONFIG.heat_columns) => {
+        this.getReport = async (strategyName, backtest, columns = COLUMN_CONFIG.heat_columns) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_GET_REPORT, {
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(strategyName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -9793,6 +9869,7 @@ class HeatMarkdownService {
          * Default filename: {strategyName}.md
          *
          * @param strategyName - Strategy name to save heatmap report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
          * @param columns - Column configuration for formatting the table
          *
@@ -9801,43 +9878,52 @@ class HeatMarkdownService {
          * const service = new HeatMarkdownService();
          *
          * // Save to default path: ./dump/heatmap/my-strategy.md
-         * await service.dump("my-strategy");
+         * await service.dump("my-strategy", true);
          *
          * // Save to custom path: ./reports/my-strategy.md
-         * await service.dump("my-strategy", "./reports");
+         * await service.dump("my-strategy", true, "./reports");
          * ```
          */
-        this.dump = async (strategyName, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) => {
+        this.dump = async (strategyName, backtest, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_DUMP, {
                 strategyName,
+                backtest,
                 path,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(strategyName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated heatmap data from storage.
-         * If strategyName is provided, clears only that strategy's data.
-         * If strategyName is omitted, clears all strategies' data.
+         * If ctx is provided, clears only that strategy+backtest combination's data.
+         * If ctx is omitted, clears all data.
          *
-         * @param strategyName - Optional strategy name to clear specific strategy data
+         * @param backtest - Backtest mode flag
+         * @param ctx - Optional context with strategyName to clear specific data
          *
          * @example
          * ```typescript
          * const service = new HeatMarkdownService();
          *
-         * // Clear specific strategy data
-         * await service.clear("my-strategy");
+         * // Clear specific strategy+backtest data
+         * await service.clear(true, { strategyName: "my-strategy" });
          *
-         * // Clear all strategies' data
+         * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (strategyName) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_CLEAR, {
-                strategyName,
+                backtest,
+                ctx,
             });
-            this.getStorage.clear(strategyName);
+            if (ctx) {
+                const key = `${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
         };
         /**
          * Initializes the service by subscribing to signal events.
@@ -11667,6 +11753,9 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
     if (self._states === NEED_FETCH) {
         throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
     }
+    if (data.id !== self.params.signalId) {
+        throw new Error(`Signal ID mismatch: expected ${self.params.signalId}, got ${data.id}`);
+    }
     let state = self._states.get(data.id);
     if (!state) {
         state = {
@@ -11691,7 +11780,7 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, backtest);
+        await self._persistState(symbol, data.strategyName);
     }
 };
 /**
@@ -11713,6 +11802,9 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
     if (self._states === NEED_FETCH) {
         throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
     }
+    if (data.id !== self.params.signalId) {
+        throw new Error(`Signal ID mismatch: expected ${self.params.signalId}, got ${data.id}`);
+    }
     let state = self._states.get(data.id);
     if (!state) {
         state = {
@@ -11738,7 +11830,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, backtest);
+        await self._persistState(symbol, data.strategyName);
     }
 };
 /**
@@ -11747,15 +11839,29 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
  * Loads persisted partial state from disk and restores in-memory Maps.
  * Converts serialized arrays back to Sets for O(1) lookups.
  *
+ * ONLY runs in LIVE mode (backtest=false). In backtest mode, state is not persisted.
+ *
  * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy identifier
+ * @param backtest - True if backtest mode, false if live mode
  * @param self - ClientPartial instance reference
  */
-const WAIT_FOR_INIT_FN = async (symbol, self) => {
-    self.params.logger.debug("ClientPartial waitForInit", { symbol });
-    if (self._states === NEED_FETCH) {
-        throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
+const WAIT_FOR_INIT_FN = async (symbol, strategyName, self) => {
+    self.params.logger.debug("ClientPartial waitForInit", {
+        symbol,
+        strategyName,
+        backtest: self.params.backtest
+    });
+    if (self._states !== NEED_FETCH) {
+        throw new Error("ClientPartial WAIT_FOR_INIT_FN should be called once!");
     }
-    const partialData = await PersistPartialAdapter.readPartialData(symbol);
+    self._states = new Map();
+    // Skip persistence in backtest mode
+    if (self.params.backtest) {
+        self.params.logger.debug("ClientPartial waitForInit: skipping persist read in backtest mode");
+        return;
+    }
+    const partialData = await PersistPartialAdapter.readPartialData(symbol, strategyName);
     for (const [signalId, data] of Object.entries(partialData)) {
         const state = {
             profitLevels: new Set(data.profitLevels),
@@ -11765,6 +11871,7 @@ const WAIT_FOR_INIT_FN = async (symbol, self) => {
     }
     self.params.logger.info("ClientPartial restored state", {
         symbol,
+        strategyName,
         signalCount: Object.keys(partialData).length,
     });
 };
@@ -11843,23 +11950,24 @@ class ClientPartial {
         /**
          * Initializes partial state by loading from disk.
          *
-         * Uses singleshot pattern to ensure initialization happens exactly once per symbol.
+         * Uses singleshot pattern to ensure initialization happens exactly once per symbol:strategyName.
          * Reads persisted state from PersistPartialAdapter and restores to _states Map.
          *
          * Must be called before profit()/loss()/clear() methods.
          *
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Promise that resolves when initialization is complete
          *
          * @example
          * ```typescript
          * const partial = new ClientPartial(params);
-         * await partial.waitForInit("BTCUSDT"); // Load persisted state
+         * await partial.waitForInit("BTCUSDT", "my-strategy", false); // Load persisted state (live mode)
          * // Now profit()/loss() can be called
          * ```
          */
-        this.waitForInit = functoolsKit.singleshot(async (symbol) => await WAIT_FOR_INIT_FN(symbol, this));
-        this._states = new Map();
+        this.waitForInit = functoolsKit.singleshot(async (symbol, strategyName) => await WAIT_FOR_INIT_FN(symbol, strategyName, this));
     }
     /**
      * Persists current partial state to disk.
@@ -11872,13 +11980,15 @@ class ClientPartial {
      * Uses atomic file writes via PersistPartialAdapter.
      *
      * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param backtest - True if backtest mode
      * @returns Promise that resolves when persistence is complete
      */
-    async _persistState(symbol, backtest) {
-        if (backtest) {
+    async _persistState(symbol, strategyName) {
+        if (this.params.backtest) {
             return;
         }
-        this.params.logger.debug("ClientPartial persistState", { symbol });
+        this.params.logger.debug("ClientPartial persistState", { symbol, strategyName });
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
         }
@@ -11889,7 +11999,7 @@ class ClientPartial {
                 lossLevels: Array.from(state.lossLevels),
             };
         }
-        await PersistPartialAdapter.writePartialData(partialData, symbol);
+        await PersistPartialAdapter.writePartialData(partialData, symbol, strategyName);
     }
     /**
      * Processes profit state and emits events for newly reached profit levels.
@@ -12010,8 +12120,11 @@ class ClientPartial {
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
         }
+        if (data.id !== this.params.signalId) {
+            throw new Error(`Signal ID mismatch: expected ${this.params.signalId}, got ${data.id}`);
+        }
         this._states.delete(data.id);
-        await this._persistState(symbol, backtest);
+        await this._persistState(symbol, data.strategyName);
     }
 }
 
@@ -12106,15 +12219,17 @@ class PartialConnectionService {
         /**
          * Memoized factory function for ClientPartial instances.
          *
-         * Creates one ClientPartial per signal ID with configured callbacks.
+         * Creates one ClientPartial per signal ID and backtest mode with configured callbacks.
          * Instances are cached until clear() is called.
          *
-         * Key format: signalId
+         * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = functoolsKit.memoize(([signalId]) => `${signalId}`, () => {
+        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => `${signalId}:${backtest ? "backtest" : "live"}`, (signalId, backtest) => {
             return new ClientPartial({
+                signalId,
                 logger: this.loggerService,
+                backtest,
                 onProfit: COMMIT_PROFIT_FN,
                 onLoss: COMMIT_LOSS_FN,
             });
@@ -12142,8 +12257,8 @@ class PartialConnectionService {
                 backtest,
                 when,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             return await partial.profit(symbol, data, currentPrice, revenuePercent, backtest, when);
         };
         /**
@@ -12169,8 +12284,8 @@ class PartialConnectionService {
                 backtest,
                 when,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             return await partial.loss(symbol, data, currentPrice, lossPercent, backtest, when);
         };
         /**
@@ -12191,15 +12306,17 @@ class PartialConnectionService {
          * @returns Promise that resolves when clear is complete
          */
         this.clear = async (symbol, data, priceClose, backtest) => {
-            this.loggerService.log("partialConnectionService profit", {
+            this.loggerService.log("partialConnectionService clear", {
                 symbol,
                 data,
                 priceClose,
+                backtest,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             await partial.clear(symbol, data, priceClose, backtest);
-            this.getPartial.clear(data.id);
+            const key = `${data.id}:${backtest ? "backtest" : "live"}`;
+            this.getPartial.clear(key);
         };
     }
 }
@@ -12375,10 +12492,10 @@ class PartialMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$1());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$1());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -12395,7 +12512,7 @@ class PartialMarkdownService {
             this.loggerService.log("partialMarkdownService tickProfit", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.data.strategyName);
+            const storage = this.getStorage(data.symbol, data.data.strategyName, data.backtest);
             storage.addProfitEvent(data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
         };
         /**
@@ -12414,7 +12531,7 @@ class PartialMarkdownService {
             this.loggerService.log("partialMarkdownService tickLoss", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.data.strategyName);
+            const storage = this.getStorage(data.symbol, data.data.strategyName, data.backtest);
             storage.addLossEvent(data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
         };
         /**
@@ -12423,21 +12540,23 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to get data for
          * @param strategyName - Strategy name to get data for
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy");
+         * const stats = await service.getData("BTCUSDT", "my-strategy", false);
          * console.log(stats.totalProfit, stats.totalLoss);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
+        this.getData = async (symbol, strategyName, backtest) => {
             this.loggerService.log("partialMarkdownService getData", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getData();
         };
         /**
@@ -12446,22 +12565,24 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.partial_columns) => {
+        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService getReport", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getReport(symbol, strategyName, columns);
         };
         /**
@@ -12471,6 +12592,7 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to save report for
          * @param strategyName - Strategy name to save report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/partial")
          * @param columns - Column configuration for formatting the table
          *
@@ -12479,45 +12601,48 @@ class PartialMarkdownService {
          * const service = new PartialMarkdownService();
          *
          * // Save to default path: ./dump/partial/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy");
+         * await service.dump("BTCUSDT", "my-strategy", false);
          *
          * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) => {
+        this.dump = async (symbol, strategyName, backtest, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService dump", {
                 symbol,
                 strategyName,
+                backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
          * If nothing is provided, clears all data.
          *
+         * @param backtest - Backtest mode flag
          * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
          *
-         * // Clear specific symbol-strategy pair
-         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific symbol-strategy-backtest triple
+         * await service.clear(false, { symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("partialMarkdownService clear", {
+                backtest,
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStorage.clear(key);
             }
             else {
@@ -13093,10 +13218,10 @@ class RiskMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage());
         /**
          * Processes risk rejection events and accumulates them.
          * Should be called from riskSubject subscription.
@@ -13113,7 +13238,7 @@ class RiskMarkdownService {
             this.loggerService.log("riskMarkdownService tickRejection", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.strategyName);
+            const storage = this.getStorage(data.symbol, data.strategyName, data.backtest);
             storage.addRejectionEvent(data);
         };
         /**
@@ -13122,21 +13247,23 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to get data for
          * @param strategyName - Strategy name to get data for
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new RiskMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy");
+         * const stats = await service.getData("BTCUSDT", "my-strategy", false);
          * console.log(stats.totalRejections, stats.bySymbol);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
+        this.getData = async (symbol, strategyName, backtest) => {
             this.loggerService.log("riskMarkdownService getData", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getData();
         };
         /**
@@ -13145,22 +13272,24 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
          * ```typescript
          * const service = new RiskMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.risk_columns) => {
+        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService getReport", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             return storage.getReport(symbol, strategyName, columns);
         };
         /**
@@ -13170,6 +13299,7 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to save report for
          * @param strategyName - Strategy name to save report for
+         * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/risk")
          * @param columns - Column configuration for formatting the table
          *
@@ -13178,45 +13308,48 @@ class RiskMarkdownService {
          * const service = new RiskMarkdownService();
          *
          * // Save to default path: ./dump/risk/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy");
+         * await service.dump("BTCUSDT", "my-strategy", false);
          *
          * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
+        this.dump = async (symbol, strategyName, backtest, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService dump", {
                 symbol,
                 strategyName,
+                backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName);
+            const storage = this.getStorage(symbol, strategyName, backtest);
             await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
          * If nothing is provided, clears all data.
          *
+         * @param backtest - Backtest mode flag
          * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new RiskMarkdownService();
          *
-         * // Clear specific symbol-strategy pair
-         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific symbol-strategy-backtest triple
+         * await service.clear(false, { symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("riskMarkdownService clear", {
+                backtest,
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStorage.clear(key);
             }
             else {
@@ -13521,7 +13654,7 @@ const backtest = {
     ...templateServices,
 };
 init();
-var backtest$1 = backtest;
+var bt = backtest;
 
 /**
  * Sets custom logger implementation for the framework.
@@ -13541,7 +13674,7 @@ var backtest$1 = backtest;
  * ```
  */
 function setLogger(logger) {
-    backtest$1.loggerService.setLogger(logger);
+    bt.loggerService.setLogger(logger);
 }
 /**
  * Sets global configuration parameters for the framework.
@@ -13559,7 +13692,7 @@ function setConfig(config, _unsafe) {
     const prevConfig = Object.assign({}, GLOBAL_CONFIG);
     try {
         Object.assign(GLOBAL_CONFIG, config);
-        !_unsafe && backtest$1.configValidationService.validate();
+        !_unsafe && bt.configValidationService.validate();
     }
     catch (error) {
         console.warn(`backtest-kit setConfig failed: ${functoolsKit.getErrorMessage(error)}`, config);
@@ -13630,7 +13763,7 @@ function setColumns(columns, _unsafe) {
     const prevConfig = Object.assign({}, COLUMN_CONFIG);
     try {
         Object.assign(COLUMN_CONFIG, columns);
-        !_unsafe && backtest$1.columnValidationService.validate();
+        !_unsafe && bt.columnValidationService.validate();
     }
     catch (error) {
         console.warn(`backtest-kit setColumns failed: ${functoolsKit.getErrorMessage(error)}`, columns);
@@ -13715,11 +13848,11 @@ const ADD_OPTIMIZER_METHOD_NAME = "add.addOptimizer";
  * ```
  */
 function addStrategy(strategySchema) {
-    backtest$1.loggerService.info(ADD_STRATEGY_METHOD_NAME, {
+    bt.loggerService.info(ADD_STRATEGY_METHOD_NAME, {
         strategySchema,
     });
-    backtest$1.strategyValidationService.addStrategy(strategySchema.strategyName, strategySchema);
-    backtest$1.strategySchemaService.register(strategySchema.strategyName, strategySchema);
+    bt.strategyValidationService.addStrategy(strategySchema.strategyName, strategySchema);
+    bt.strategySchemaService.register(strategySchema.strategyName, strategySchema);
 }
 /**
  * Registers an exchange data source in the framework.
@@ -13757,11 +13890,11 @@ function addStrategy(strategySchema) {
  * ```
  */
 function addExchange(exchangeSchema) {
-    backtest$1.loggerService.info(ADD_EXCHANGE_METHOD_NAME, {
+    bt.loggerService.info(ADD_EXCHANGE_METHOD_NAME, {
         exchangeSchema,
     });
-    backtest$1.exchangeValidationService.addExchange(exchangeSchema.exchangeName, exchangeSchema);
-    backtest$1.exchangeSchemaService.register(exchangeSchema.exchangeName, exchangeSchema);
+    bt.exchangeValidationService.addExchange(exchangeSchema.exchangeName, exchangeSchema);
+    bt.exchangeSchemaService.register(exchangeSchema.exchangeName, exchangeSchema);
 }
 /**
  * Registers a timeframe generator for backtesting.
@@ -13794,11 +13927,11 @@ function addExchange(exchangeSchema) {
  * ```
  */
 function addFrame(frameSchema) {
-    backtest$1.loggerService.info(ADD_FRAME_METHOD_NAME, {
+    bt.loggerService.info(ADD_FRAME_METHOD_NAME, {
         frameSchema,
     });
-    backtest$1.frameValidationService.addFrame(frameSchema.frameName, frameSchema);
-    backtest$1.frameSchemaService.register(frameSchema.frameName, frameSchema);
+    bt.frameValidationService.addFrame(frameSchema.frameName, frameSchema);
+    bt.frameSchemaService.register(frameSchema.frameName, frameSchema);
 }
 /**
  * Registers a walker for strategy comparison.
@@ -13838,11 +13971,11 @@ function addFrame(frameSchema) {
  * ```
  */
 function addWalker(walkerSchema) {
-    backtest$1.loggerService.info(ADD_WALKER_METHOD_NAME, {
+    bt.loggerService.info(ADD_WALKER_METHOD_NAME, {
         walkerSchema,
     });
-    backtest$1.walkerValidationService.addWalker(walkerSchema.walkerName, walkerSchema);
-    backtest$1.walkerSchemaService.register(walkerSchema.walkerName, walkerSchema);
+    bt.walkerValidationService.addWalker(walkerSchema.walkerName, walkerSchema);
+    bt.walkerSchemaService.register(walkerSchema.walkerName, walkerSchema);
 }
 /**
  * Registers a position sizing configuration in the framework.
@@ -13897,11 +14030,11 @@ function addWalker(walkerSchema) {
  * ```
  */
 function addSizing(sizingSchema) {
-    backtest$1.loggerService.info(ADD_SIZING_METHOD_NAME, {
+    bt.loggerService.info(ADD_SIZING_METHOD_NAME, {
         sizingSchema,
     });
-    backtest$1.sizingValidationService.addSizing(sizingSchema.sizingName, sizingSchema);
-    backtest$1.sizingSchemaService.register(sizingSchema.sizingName, sizingSchema);
+    bt.sizingValidationService.addSizing(sizingSchema.sizingName, sizingSchema);
+    bt.sizingSchemaService.register(sizingSchema.sizingName, sizingSchema);
 }
 /**
  * Registers a risk management configuration in the framework.
@@ -13965,11 +14098,11 @@ function addSizing(sizingSchema) {
  * ```
  */
 function addRisk(riskSchema) {
-    backtest$1.loggerService.info(ADD_RISK_METHOD_NAME, {
+    bt.loggerService.info(ADD_RISK_METHOD_NAME, {
         riskSchema,
     });
-    backtest$1.riskValidationService.addRisk(riskSchema.riskName, riskSchema);
-    backtest$1.riskSchemaService.register(riskSchema.riskName, riskSchema);
+    bt.riskValidationService.addRisk(riskSchema.riskName, riskSchema);
+    bt.riskSchemaService.register(riskSchema.riskName, riskSchema);
 }
 /**
  * Registers an optimizer configuration in the framework.
@@ -14059,11 +14192,11 @@ function addRisk(riskSchema) {
  * ```
  */
 function addOptimizer(optimizerSchema) {
-    backtest$1.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
+    bt.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
         optimizerSchema,
     });
-    backtest$1.optimizerValidationService.addOptimizer(optimizerSchema.optimizerName, optimizerSchema);
-    backtest$1.optimizerSchemaService.register(optimizerSchema.optimizerName, optimizerSchema);
+    bt.optimizerValidationService.addOptimizer(optimizerSchema.optimizerName, optimizerSchema);
+    bt.optimizerSchemaService.register(optimizerSchema.optimizerName, optimizerSchema);
 }
 
 const LIST_EXCHANGES_METHOD_NAME = "list.listExchanges";
@@ -14099,8 +14232,8 @@ const LIST_OPTIMIZERS_METHOD_NAME = "list.listOptimizers";
  * ```
  */
 async function listExchanges() {
-    backtest$1.loggerService.log(LIST_EXCHANGES_METHOD_NAME);
-    return await backtest$1.exchangeValidationService.list();
+    bt.loggerService.log(LIST_EXCHANGES_METHOD_NAME);
+    return await bt.exchangeValidationService.list();
 }
 /**
  * Returns a list of all registered strategy schemas.
@@ -14133,8 +14266,8 @@ async function listExchanges() {
  * ```
  */
 async function listStrategies() {
-    backtest$1.loggerService.log(LIST_STRATEGIES_METHOD_NAME);
-    return await backtest$1.strategyValidationService.list();
+    bt.loggerService.log(LIST_STRATEGIES_METHOD_NAME);
+    return await bt.strategyValidationService.list();
 }
 /**
  * Returns a list of all registered frame schemas.
@@ -14162,8 +14295,8 @@ async function listStrategies() {
  * ```
  */
 async function listFrames() {
-    backtest$1.loggerService.log(LIST_FRAMES_METHOD_NAME);
-    return await backtest$1.frameValidationService.list();
+    bt.loggerService.log(LIST_FRAMES_METHOD_NAME);
+    return await bt.frameValidationService.list();
 }
 /**
  * Returns a list of all registered walker schemas.
@@ -14192,8 +14325,8 @@ async function listFrames() {
  * ```
  */
 async function listWalkers() {
-    backtest$1.loggerService.log(LIST_WALKERS_METHOD_NAME);
-    return await backtest$1.walkerValidationService.list();
+    bt.loggerService.log(LIST_WALKERS_METHOD_NAME);
+    return await bt.walkerValidationService.list();
 }
 /**
  * Returns a list of all registered sizing schemas.
@@ -14231,8 +14364,8 @@ async function listWalkers() {
  * ```
  */
 async function listSizings() {
-    backtest$1.loggerService.log(LIST_SIZINGS_METHOD_NAME);
-    return await backtest$1.sizingValidationService.list();
+    bt.loggerService.log(LIST_SIZINGS_METHOD_NAME);
+    return await bt.sizingValidationService.list();
 }
 /**
  * Returns a list of all registered risk schemas.
@@ -14267,8 +14400,8 @@ async function listSizings() {
  * ```
  */
 async function listRisks() {
-    backtest$1.loggerService.log(LIST_RISKS_METHOD_NAME);
-    return await backtest$1.riskValidationService.list();
+    bt.loggerService.log(LIST_RISKS_METHOD_NAME);
+    return await bt.riskValidationService.list();
 }
 /**
  * Returns a list of all registered optimizer schemas.
@@ -14307,8 +14440,8 @@ async function listRisks() {
  * ```
  */
 async function listOptimizers() {
-    backtest$1.loggerService.log(LIST_OPTIMIZERS_METHOD_NAME);
-    return await backtest$1.optimizerValidationService.list();
+    bt.loggerService.log(LIST_OPTIMIZERS_METHOD_NAME);
+    return await bt.optimizerValidationService.list();
 }
 
 const LISTEN_SIGNAL_METHOD_NAME = "event.listenSignal";
@@ -14365,7 +14498,7 @@ const LISTEN_RISK_ONCE_METHOD_NAME = "event.listenRiskOnce";
  * ```
  */
 function listenSignal(fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_METHOD_NAME);
     return signalEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14401,7 +14534,7 @@ function listenSignal(fn) {
  * ```
  */
 function listenSignalOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_ONCE_METHOD_NAME);
     return signalEmitter.filter(filterFn).once(fn);
 }
 /**
@@ -14425,7 +14558,7 @@ function listenSignalOnce(filterFn, fn) {
  * ```
  */
 function listenSignalLive(fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_LIVE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_LIVE_METHOD_NAME);
     return signalLiveEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14450,7 +14583,7 @@ function listenSignalLive(fn) {
  * ```
  */
 function listenSignalLiveOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME);
     return signalLiveEmitter.filter(filterFn).once(fn);
 }
 /**
@@ -14474,7 +14607,7 @@ function listenSignalLiveOnce(filterFn, fn) {
  * ```
  */
 function listenSignalBacktest(fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_BACKTEST_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_BACKTEST_METHOD_NAME);
     return signalBacktestEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14499,7 +14632,7 @@ function listenSignalBacktest(fn) {
  * ```
  */
 function listenSignalBacktestOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME);
     return signalBacktestEmitter.filter(filterFn).once(fn);
 }
 /**
@@ -14527,7 +14660,7 @@ function listenSignalBacktestOnce(filterFn, fn) {
  * ```
  */
 function listenError(fn) {
-    backtest$1.loggerService.log(LISTEN_ERROR_METHOD_NAME);
+    bt.loggerService.log(LISTEN_ERROR_METHOD_NAME);
     return errorEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -14555,7 +14688,7 @@ function listenError(fn) {
  * ```
  */
 function listenExit(fn) {
-    backtest$1.loggerService.log(LISTEN_EXIT_METHOD_NAME);
+    bt.loggerService.log(LISTEN_EXIT_METHOD_NAME);
     return exitEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -14586,7 +14719,7 @@ function listenExit(fn) {
  * ```
  */
 function listenDoneLive(fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_LIVE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_LIVE_METHOD_NAME);
     return doneLiveSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14616,7 +14749,7 @@ function listenDoneLive(fn) {
  * ```
  */
 function listenDoneLiveOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_LIVE_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_LIVE_ONCE_METHOD_NAME);
     return doneLiveSubject.filter(filterFn).once(fn);
 }
 /**
@@ -14648,7 +14781,7 @@ function listenDoneLiveOnce(filterFn, fn) {
  * ```
  */
 function listenDoneBacktest(fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_BACKTEST_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_BACKTEST_METHOD_NAME);
     return doneBacktestSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14679,7 +14812,7 @@ function listenDoneBacktest(fn) {
  * ```
  */
 function listenDoneBacktestOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_BACKTEST_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_BACKTEST_ONCE_METHOD_NAME);
     return doneBacktestSubject.filter(filterFn).once(fn);
 }
 /**
@@ -14709,7 +14842,7 @@ function listenDoneBacktestOnce(filterFn, fn) {
  * ```
  */
 function listenDoneWalker(fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_WALKER_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_WALKER_METHOD_NAME);
     return doneWalkerSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14738,7 +14871,7 @@ function listenDoneWalker(fn) {
  * ```
  */
 function listenDoneWalkerOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_WALKER_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_WALKER_ONCE_METHOD_NAME);
     return doneWalkerSubject.filter(filterFn).once(fn);
 }
 /**
@@ -14772,7 +14905,7 @@ function listenDoneWalkerOnce(filterFn, fn) {
  * ```
  */
 function listenBacktestProgress(fn) {
-    backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
     return progressBacktestEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14806,7 +14939,7 @@ function listenBacktestProgress(fn) {
  * ```
  */
 function listenWalkerProgress(fn) {
-    backtest$1.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
     return progressWalkerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14834,7 +14967,7 @@ function listenWalkerProgress(fn) {
  * ```
  */
 function listenOptimizerProgress(fn) {
-    backtest$1.loggerService.log(LISTEN_PROGRESS_OPTIMIZER_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PROGRESS_OPTIMIZER_METHOD_NAME);
     return progressOptimizerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14870,7 +15003,7 @@ function listenOptimizerProgress(fn) {
  * ```
  */
 function listenPerformance(fn) {
-    backtest$1.loggerService.log(LISTEN_PERFORMANCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PERFORMANCE_METHOD_NAME);
     return performanceEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14904,7 +15037,7 @@ function listenPerformance(fn) {
  * ```
  */
 function listenWalker(fn) {
-    backtest$1.loggerService.log(LISTEN_WALKER_METHOD_NAME);
+    bt.loggerService.log(LISTEN_WALKER_METHOD_NAME);
     return walkerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14947,7 +15080,7 @@ function listenWalker(fn) {
  * ```
  */
 function listenWalkerOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_WALKER_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_WALKER_ONCE_METHOD_NAME);
     return walkerEmitter.filter(filterFn).once(fn);
 }
 /**
@@ -14982,7 +15115,7 @@ function listenWalkerOnce(filterFn, fn) {
  * ```
  */
 function listenWalkerComplete(fn) {
-    backtest$1.loggerService.log(LISTEN_WALKER_COMPLETE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_WALKER_COMPLETE_METHOD_NAME);
     return walkerCompleteSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15010,7 +15143,7 @@ function listenWalkerComplete(fn) {
  * ```
  */
 function listenValidation(fn) {
-    backtest$1.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
+    bt.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
     return validationSubject.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -15038,7 +15171,7 @@ function listenValidation(fn) {
  * ```
  */
 function listenPartialProfit(fn) {
-    backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
     return partialProfitSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15072,7 +15205,7 @@ function listenPartialProfit(fn) {
  * ```
  */
 function listenPartialProfitOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME);
     return partialProfitSubject.filter(filterFn).once(fn);
 }
 /**
@@ -15100,7 +15233,7 @@ function listenPartialProfitOnce(filterFn, fn) {
  * ```
  */
 function listenPartialLoss(fn) {
-    backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
     return partialLossSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15134,7 +15267,7 @@ function listenPartialLoss(fn) {
  * ```
  */
 function listenPartialLossOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME);
     return partialLossSubject.filter(filterFn).once(fn);
 }
 /**
@@ -15166,7 +15299,7 @@ function listenPartialLossOnce(filterFn, fn) {
  * ```
  */
 function listenRisk(fn) {
-    backtest$1.loggerService.log(LISTEN_RISK_METHOD_NAME);
+    bt.loggerService.log(LISTEN_RISK_METHOD_NAME);
     return riskSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15203,7 +15336,7 @@ function listenRisk(fn) {
  * ```
  */
 function listenRiskOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
     return riskSubject.filter(filterFn).once(fn);
 }
 
@@ -15231,12 +15364,12 @@ const GET_MODE_METHOD_NAME = "exchange.getMode";
  * ```
  */
 async function getCandles(symbol, interval, limit) {
-    backtest$1.loggerService.info(GET_CANDLES_METHOD_NAME, {
+    bt.loggerService.info(GET_CANDLES_METHOD_NAME, {
         symbol,
         interval,
         limit,
     });
-    return await backtest$1.exchangeConnectionService.getCandles(symbol, interval, limit);
+    return await bt.exchangeConnectionService.getCandles(symbol, interval, limit);
 }
 /**
  * Calculates VWAP (Volume Weighted Average Price) for a symbol.
@@ -15257,10 +15390,10 @@ async function getCandles(symbol, interval, limit) {
  * ```
  */
 async function getAveragePrice(symbol) {
-    backtest$1.loggerService.info(GET_AVERAGE_PRICE_METHOD_NAME, {
+    bt.loggerService.info(GET_AVERAGE_PRICE_METHOD_NAME, {
         symbol,
     });
-    return await backtest$1.exchangeConnectionService.getAveragePrice(symbol);
+    return await bt.exchangeConnectionService.getAveragePrice(symbol);
 }
 /**
  * Formats a price value according to exchange rules.
@@ -15278,11 +15411,11 @@ async function getAveragePrice(symbol) {
  * ```
  */
 async function formatPrice(symbol, price) {
-    backtest$1.loggerService.info(FORMAT_PRICE_METHOD_NAME, {
+    bt.loggerService.info(FORMAT_PRICE_METHOD_NAME, {
         symbol,
         price,
     });
-    return await backtest$1.exchangeConnectionService.formatPrice(symbol, price);
+    return await bt.exchangeConnectionService.formatPrice(symbol, price);
 }
 /**
  * Formats a quantity value according to exchange rules.
@@ -15300,11 +15433,11 @@ async function formatPrice(symbol, price) {
  * ```
  */
 async function formatQuantity(symbol, quantity) {
-    backtest$1.loggerService.info(FORMAT_QUANTITY_METHOD_NAME, {
+    bt.loggerService.info(FORMAT_QUANTITY_METHOD_NAME, {
         symbol,
         quantity,
     });
-    return await backtest$1.exchangeConnectionService.formatQuantity(symbol, quantity);
+    return await bt.exchangeConnectionService.formatQuantity(symbol, quantity);
 }
 /**
  * Gets the current date from execution context.
@@ -15321,8 +15454,8 @@ async function formatQuantity(symbol, quantity) {
  * ```
  */
 async function getDate() {
-    backtest$1.loggerService.info(GET_DATE_METHOD_NAME);
-    const { when } = backtest$1.executionContextService.context;
+    bt.loggerService.info(GET_DATE_METHOD_NAME);
+    const { when } = bt.executionContextService.context;
     return new Date(when.getTime());
 }
 /**
@@ -15341,9 +15474,9 @@ async function getDate() {
  * ```
  */
 async function getMode() {
-    backtest$1.loggerService.info(GET_MODE_METHOD_NAME);
-    const { backtest: bt } = backtest$1.executionContextService.context;
-    return bt ? "backtest" : "live";
+    bt.loggerService.info(GET_MODE_METHOD_NAME);
+    const { backtest: bt$1 } = bt.executionContextService.context;
+    return bt$1 ? "backtest" : "live";
 }
 
 const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
@@ -15414,13 +15547,13 @@ const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
  * ```
  */
 async function dumpSignal(signalId, history, signal, outputDir = "./dump/strategy") {
-    backtest$1.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
+    bt.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
         signalId,
         history,
         signal,
         outputDir,
     });
-    return await backtest$1.outlineMarkdownService.dumpSignal(signalId, history, signal, outputDir);
+    return await bt.outlineMarkdownService.dumpSignal(signalId, history, signal, outputDir);
 }
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
@@ -15507,7 +15640,7 @@ class BacktestInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -15526,7 +15659,7 @@ class BacktestInstance {
          * ```
          */
         this.getStatus = async () => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_STATUS);
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_STATUS);
             return {
                 id: this.id,
                 symbol: this.symbol,
@@ -15542,23 +15675,27 @@ class BacktestInstance {
          * @returns Async generator yielding closed signals with PNL
          */
         this.run = (symbol, context) => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_RUN, {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_RUN, {
                 symbol,
                 context,
             });
             {
-                backtest$1.backtestMarkdownService.clear({ symbol, strategyName: context.strategyName });
-                backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
+                bt.backtestMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                bt.liveMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                bt.scheduleMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                bt.performanceMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                bt.partialMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                bt.riskMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyCoreService.clear({ symbol, strategyName: context.strategyName });
+                bt.strategyCoreService.clear(true, { symbol, strategyName: context.strategyName });
             }
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(riskName);
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskGlobalService.clear(true, riskName);
+                riskList && riskList.forEach((riskName) => bt.riskGlobalService.clear(true, riskName));
             }
-            return backtest$1.backtestCommandService.run(symbol, context);
+            return bt.backtestCommandService.run(symbol, context);
         };
         /**
          * Runs backtest in background without yielding results.
@@ -15581,15 +15718,24 @@ class BacktestInstance {
          * ```
          */
         this.background = (symbol, context) => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_BACKGROUND, {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_BACKGROUND, {
                 symbol,
                 context,
             });
+            {
+                const currentStatus = this.task.getStatus();
+                if (currentStatus === "pending") {
+                    throw new Error(`Backtest.background is already running for symbol=${symbol} strategyName=${context.strategyName} exchangeName=${context.exchangeName} frameName=${context.frameName}`);
+                }
+                if (currentStatus === "rejected") {
+                    throw new Error(`Backtest.background has failed for symbol=${symbol} strategyName=${context.strategyName} exchangeName=${context.exchangeName} frameName=${context.frameName}`);
+                }
+            }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop({ symbol, strategyName: context.strategyName }, true);
-                backtest$1.strategyCoreService
-                    .getPendingSignal(symbol, context.strategyName)
+                bt.strategyCoreService.stop(true, { symbol, strategyName: context.strategyName });
+                bt.strategyCoreService
+                    .getPendingSignal(true, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -15625,11 +15771,11 @@ class BacktestInstance {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
                 symbol,
                 strategyName,
             });
-            await backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
+            await bt.strategyCoreService.stop(true, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
@@ -15646,11 +15792,11 @@ class BacktestInstance {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info("BacktestUtils.getData", {
+            bt.loggerService.info("BacktestUtils.getData", {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.backtestMarkdownService.getData(symbol, strategyName);
+            return await bt.backtestMarkdownService.getData(symbol, strategyName, true);
         };
         /**
          * Generates markdown report with all closed signals for a symbol-strategy pair.
@@ -15668,11 +15814,11 @@ class BacktestInstance {
          * ```
          */
         this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName, columns);
+            return await bt.backtestMarkdownService.getReport(symbol, strategyName, true, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15693,12 +15839,12 @@ class BacktestInstance {
          * ```
          */
         this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, path, columns);
+            await bt.backtestMarkdownService.dump(symbol, strategyName, true, path, columns);
         };
     }
 }
@@ -15737,14 +15883,14 @@ class BacktestUtils {
          */
         this.run = (symbol, context) => {
             {
-                backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_RUN);
-                backtest$1.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_RUN);
-                backtest$1.frameValidationService.validate(context.frameName, BACKTEST_METHOD_NAME_RUN);
+                bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_RUN);
+                bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_RUN);
+                bt.frameValidationService.validate(context.frameName, BACKTEST_METHOD_NAME_RUN);
             }
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_RUN);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_RUN));
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_RUN);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.run(symbol, context);
@@ -15771,13 +15917,13 @@ class BacktestUtils {
          * ```
          */
         this.background = (symbol, context) => {
-            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_BACKGROUND);
-            backtest$1.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_BACKGROUND);
-            backtest$1.frameValidationService.validate(context.frameName, BACKTEST_METHOD_NAME_BACKGROUND);
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_BACKGROUND);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_BACKGROUND);
+            bt.frameValidationService.validate(context.frameName, BACKTEST_METHOD_NAME_BACKGROUND);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BACKGROUND);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BACKGROUND));
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BACKGROUND);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.background(symbol, context);
@@ -15800,11 +15946,11 @@ class BacktestUtils {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_STOP);
+            bt.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_STOP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.stop(symbol, strategyName);
@@ -15823,11 +15969,11 @@ class BacktestUtils {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, "BacktestUtils.getData");
+            bt.strategyValidationService.validate(strategyName, "BacktestUtils.getData");
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, "BacktestUtils.getData");
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, "BacktestUtils.getData"));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, "BacktestUtils.getData");
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, "BacktestUtils.getData"));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.getData(symbol, strategyName);
@@ -15847,11 +15993,11 @@ class BacktestUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
+            bt.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.getReport(symbol, strategyName, columns);
@@ -15874,11 +16020,11 @@ class BacktestUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_DUMP);
+            bt.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.dump(symbol, strategyName, path, columns);
@@ -16008,7 +16154,7 @@ class LiveInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_TASK, {
+            bt.loggerService.info(LIVE_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16027,7 +16173,7 @@ class LiveInstance {
          * ```
          */
         this.getStatus = async () => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_STATUS);
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_STATUS);
             return {
                 id: this.id,
                 symbol: this.symbol,
@@ -16046,23 +16192,27 @@ class LiveInstance {
          * @returns Infinite async generator yielding opened and closed signals
          */
         this.run = (symbol, context) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_RUN, {
+            bt.loggerService.info(LIVE_METHOD_NAME_RUN, {
                 symbol,
                 context,
             });
             {
-                backtest$1.liveMarkdownService.clear({ symbol, strategyName: context.strategyName });
-                backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
+                bt.backtestMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                bt.liveMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                bt.scheduleMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                bt.performanceMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                bt.partialMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                bt.riskMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyCoreService.clear({ symbol, strategyName: context.strategyName });
+                bt.strategyCoreService.clear(false, { symbol, strategyName: context.strategyName });
             }
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(riskName);
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskGlobalService.clear(false, riskName);
+                riskList && riskList.forEach((riskName) => bt.riskGlobalService.clear(false, riskName));
             }
-            return backtest$1.liveCommandService.run(symbol, context);
+            return bt.liveCommandService.run(symbol, context);
         };
         /**
          * Runs live trading in background without yielding results.
@@ -16085,15 +16235,24 @@ class LiveInstance {
          * ```
          */
         this.background = (symbol, context) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_BACKGROUND, {
+            bt.loggerService.info(LIVE_METHOD_NAME_BACKGROUND, {
                 symbol,
                 context,
             });
+            const currentStatus = this.task.getStatus();
+            {
+                if (currentStatus === "pending") {
+                    throw new Error(`Live.background is already running for symbol=${symbol} strategyName=${context.strategyName} exchangeName=${context.exchangeName}`);
+                }
+                if (currentStatus === "rejected") {
+                    throw new Error(`Live.background has failed for symbol=${symbol} strategyName=${context.strategyName} exchangeName=${context.exchangeName}`);
+                }
+            }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop({ symbol, strategyName: context.strategyName }, false);
-                backtest$1.strategyCoreService
-                    .getPendingSignal(symbol, context.strategyName)
+                bt.strategyCoreService.stop(false, { symbol, strategyName: context.strategyName });
+                bt.strategyCoreService
+                    .getPendingSignal(false, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -16129,11 +16288,11 @@ class LiveInstance {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_STOP, {
+            bt.loggerService.info(LIVE_METHOD_NAME_STOP, {
                 symbol,
                 strategyName,
             });
-            await backtest$1.strategyCoreService.stop({ symbol, strategyName }, false);
+            await bt.strategyCoreService.stop(false, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
@@ -16150,11 +16309,11 @@ class LiveInstance {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info("LiveUtils.getData", {
+            bt.loggerService.info("LiveUtils.getData", {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.liveMarkdownService.getData(symbol, strategyName);
+            return await bt.liveMarkdownService.getData(symbol, strategyName, false);
         };
         /**
          * Generates markdown report with all events for a symbol-strategy pair.
@@ -16172,11 +16331,11 @@ class LiveInstance {
          * ```
          */
         this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName, columns);
+            return await bt.liveMarkdownService.getReport(symbol, strategyName, false, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -16197,12 +16356,12 @@ class LiveInstance {
          * ```
          */
         this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
+            bt.loggerService.info(LIVE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path, columns);
+            await bt.liveMarkdownService.dump(symbol, strategyName, false, path, columns);
         };
     }
 }
@@ -16254,13 +16413,13 @@ class LiveUtils {
          */
         this.run = (symbol, context) => {
             {
-                backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_RUN);
-                backtest$1.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_RUN);
+                bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_RUN);
+                bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_RUN);
             }
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN));
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.run(symbol, context);
@@ -16287,12 +16446,12 @@ class LiveUtils {
          * ```
          */
         this.background = (symbol, context) => {
-            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_BACKGROUND);
-            backtest$1.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_BACKGROUND);
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_BACKGROUND);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_BACKGROUND);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND));
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.background(symbol, context);
@@ -16315,11 +16474,11 @@ class LiveUtils {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_STOP);
+            bt.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_STOP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.stop(symbol, strategyName);
@@ -16338,11 +16497,11 @@ class LiveUtils {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, "LiveUtils.getData");
+            bt.strategyValidationService.validate(strategyName, "LiveUtils.getData");
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.getData(symbol, strategyName);
@@ -16362,11 +16521,11 @@ class LiveUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_REPORT);
+            bt.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.getReport(symbol, strategyName, columns);
@@ -16389,11 +16548,11 @@ class LiveUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_DUMP);
+            bt.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.dump(symbol, strategyName, path, columns);
@@ -16477,18 +16636,19 @@ class ScheduleUtils {
          * console.log(stats.cancellationRate, stats.avgWaitTime);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_DATA, {
+        this.getData = async (symbol, strategyName, backtest) => {
+            bt.loggerService.info(SCHEDULE_METHOD_NAME_GET_DATA, {
                 symbol,
                 strategyName,
+                backtest,
             });
-            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
+            bt.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.scheduleMarkdownService.getData(symbol, strategyName);
+            return await bt.scheduleMarkdownService.getData(symbol, strategyName, backtest);
         };
         /**
          * Generates markdown report with all scheduled events for a symbol-strategy pair.
@@ -16504,18 +16664,19 @@ class ScheduleUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
+        this.getReport = async (symbol, strategyName, backtest, columns) => {
+            bt.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
+                backtest,
             });
-            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
+            bt.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName, columns);
+            return await bt.scheduleMarkdownService.getReport(symbol, strategyName, backtest, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -16534,19 +16695,20 @@ class ScheduleUtils {
          * await Schedule.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
+        this.dump = async (symbol, strategyName, backtest, path, columns) => {
+            bt.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
+                backtest,
                 path,
             });
-            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_DUMP);
+            bt.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP));
             }
-            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, path, columns);
+            await bt.scheduleMarkdownService.dump(symbol, strategyName, backtest, path, columns);
         };
     }
 }
@@ -16584,7 +16746,7 @@ const PERFORMANCE_METHOD_NAME_DUMP = "Performance.dump";
  *   console.log(`${event.metricType}: ${event.duration.toFixed(2)}ms`);
  * });
  *
- * // Run backtest...
+ * // Run bt...
  *
  * // Get aggregated statistics
  * const stats = await Performance.getData("my-strategy");
@@ -16627,14 +16789,14 @@ class Performance {
      * }
      * ```
      */
-    static async getData(symbol, strategyName) {
-        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
+    static async getData(symbol, strategyName, backtest) {
+        bt.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
         {
-            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-            riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA);
-            riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA));
+            const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+            riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA);
+            riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA));
         }
-        return backtest$1.performanceMarkdownService.getData(symbol, strategyName);
+        return bt.performanceMarkdownService.getData(symbol, strategyName, backtest);
     }
     /**
      * Generates markdown report with performance analysis.
@@ -16659,14 +16821,14 @@ class Performance {
      * await fs.writeFile("performance-report.md", markdown);
      * ```
      */
-    static async getReport(symbol, strategyName, columns) {
-        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
+    static async getReport(symbol, strategyName, backtest, columns) {
+        bt.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
-            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-            riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
-            riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT));
+            const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+            riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
+            riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT));
         }
-        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName, columns);
+        return bt.performanceMarkdownService.getReport(symbol, strategyName, backtest, columns);
     }
     /**
      * Saves performance report to disk.
@@ -16688,14 +16850,14 @@ class Performance {
      * await Performance.dump("BTCUSDT", "my-strategy", "./reports/perf");
      * ```
      */
-    static async dump(symbol, strategyName, path = "./dump/performance", columns) {
-        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_DUMP);
+    static async dump(symbol, strategyName, backtest, path = "./dump/performance", columns) {
+        bt.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_DUMP);
         {
-            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-            riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
-            riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP));
+            const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+            riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
+            riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP));
         }
-        return backtest$1.performanceMarkdownService.dump(symbol, strategyName, path, columns);
+        return bt.performanceMarkdownService.dump(symbol, strategyName, backtest, path, columns);
     }
 }
 
@@ -16729,7 +16891,7 @@ const INSTANCE_TASK_FN = async (symbol, context, self) => {
         }
     }
     if (!self._isDone) {
-        const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+        const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
         await doneWalkerSubject.next({
             exchangeName: walkerSchema.exchangeName,
             strategyName: context.walkerName,
@@ -16783,7 +16945,7 @@ class WalkerInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_TASK, {
+            bt.loggerService.info(WALKER_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16802,7 +16964,7 @@ class WalkerInstance {
          * ```
          */
         this.getStatus = async () => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_STATUS);
+            bt.loggerService.info(WALKER_METHOD_NAME_GET_STATUS);
             return {
                 id: this.id,
                 symbol: this.symbol,
@@ -16818,34 +16980,39 @@ class WalkerInstance {
          * @returns Async generator yielding progress updates after each strategy
          */
         this.run = (symbol, context) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_RUN, {
+            bt.loggerService.info(WALKER_METHOD_NAME_RUN, {
                 symbol,
                 context,
             });
-            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
-            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
-            backtest$1.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
-            backtest$1.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
+            bt.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
+            const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
+            bt.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
+            bt.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
             for (const strategyName of walkerSchema.strategies) {
-                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
             }
-            backtest$1.walkerMarkdownService.clear(context.walkerName);
+            bt.walkerMarkdownService.clear(context.walkerName);
             // Clear backtest data for all strategies
             for (const strategyName of walkerSchema.strategies) {
                 {
-                    backtest$1.backtestMarkdownService.clear({ symbol, strategyName });
-                    backtest$1.scheduleMarkdownService.clear({ symbol, strategyName });
+                    bt.backtestMarkdownService.clear(true, { symbol, strategyName });
+                    bt.liveMarkdownService.clear(true, { symbol, strategyName });
+                    bt.scheduleMarkdownService.clear(true, { symbol, strategyName });
+                    bt.performanceMarkdownService.clear(true, { symbol, strategyName });
+                    bt.partialMarkdownService.clear(true, { symbol, strategyName });
+                    bt.riskMarkdownService.clear(true, { symbol, strategyName });
                 }
                 {
-                    backtest$1.strategyCoreService.clear({ symbol, strategyName });
+                    bt.strategyCoreService.clear(true, { symbol, strategyName });
                 }
                 {
-                    const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                    riskName && backtest$1.riskGlobalService.clear(riskName);
-                    riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                    const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                    riskName && bt.riskGlobalService.clear(true, riskName);
+                    riskList &&
+                        riskList.forEach((riskName) => bt.riskGlobalService.clear(true, riskName));
                 }
             }
-            return backtest$1.walkerCommandService.run(symbol, {
+            return bt.walkerCommandService.run(symbol, {
                 walkerName: context.walkerName,
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
@@ -16870,16 +17037,29 @@ class WalkerInstance {
          * ```
          */
         this.background = (symbol, context) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_BACKGROUND, {
+            bt.loggerService.info(WALKER_METHOD_NAME_BACKGROUND, {
                 symbol,
                 context,
             });
-            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+            const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
+            {
+                const currentStatus = this.task.getStatus();
+                if (currentStatus === "pending") {
+                    throw new Error(`Walker.background is already running for symbol=${symbol} walkerName=${context.walkerName}`);
+                }
+                if (currentStatus === "rejected") {
+                    throw new Error(`Walker.background has failed for symbol=${symbol} walkerName=${context.walkerName}`);
+                }
+            }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
-                    walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
+                    bt.strategyCoreService.stop(true, { symbol, strategyName });
+                    walkerStopSubject.next({
+                        symbol,
+                        strategyName,
+                        walkerName: context.walkerName,
+                    });
                 }
                 if (!this._isDone) {
                     doneWalkerSubject.next({
@@ -16917,14 +17097,14 @@ class WalkerInstance {
          * ```
          */
         this.stop = async (symbol, walkerName) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_STOP, {
+            bt.loggerService.info(WALKER_METHOD_NAME_STOP, {
                 symbol,
                 walkerName,
             });
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            const walkerSchema = bt.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName });
-                await backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
+                await bt.strategyCoreService.stop(true, { symbol, strategyName });
             }
         };
         /**
@@ -16942,12 +17122,12 @@ class WalkerInstance {
          * ```
          */
         this.getData = async (symbol, walkerName) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_DATA, {
+            bt.loggerService.info(WALKER_METHOD_NAME_GET_DATA, {
                 symbol,
                 walkerName,
             });
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
-            return await backtest$1.walkerMarkdownService.getData(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            const walkerSchema = bt.walkerSchemaService.get(walkerName);
+            return await bt.walkerMarkdownService.getData(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             });
@@ -16969,12 +17149,12 @@ class WalkerInstance {
          * ```
          */
         this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
+            bt.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
                 symbol,
                 walkerName,
             });
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
-            return await backtest$1.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            const walkerSchema = bt.walkerSchemaService.get(walkerName);
+            return await bt.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             }, strategyColumns, pnlColumns);
@@ -16999,13 +17179,13 @@ class WalkerInstance {
          * ```
          */
         this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_DUMP, {
+            bt.loggerService.info(WALKER_METHOD_NAME_DUMP, {
                 symbol,
                 walkerName,
                 path,
             });
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
-            await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            const walkerSchema = bt.walkerSchemaService.get(walkerName);
+            await bt.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             }, path, strategyColumns, pnlColumns);
@@ -17046,15 +17226,17 @@ class WalkerUtils {
          * @returns Async generator yielding progress updates after each strategy
          */
         this.run = (symbol, context) => {
-            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
-            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
-            backtest$1.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
-            backtest$1.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
+            bt.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
+            const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
+            bt.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
+            bt.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
             for (const strategyName of walkerSchema.strategies) {
-                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.run(symbol, context);
@@ -17079,15 +17261,17 @@ class WalkerUtils {
          * ```
          */
         this.background = (symbol, context) => {
-            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_BACKGROUND);
-            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
-            backtest$1.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_BACKGROUND);
-            backtest$1.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_BACKGROUND);
+            bt.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_BACKGROUND);
+            const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
+            bt.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_BACKGROUND);
+            bt.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_BACKGROUND);
             for (const strategyName of walkerSchema.strategies) {
-                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_BACKGROUND);
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_BACKGROUND);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.background(symbol, context);
@@ -17116,13 +17300,15 @@ class WalkerUtils {
          * ```
          */
         this.stop = async (symbol, walkerName) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_STOP);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            bt.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_STOP);
+            const walkerSchema = bt.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
-                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.stop(symbol, walkerName);
@@ -17141,13 +17327,15 @@ class WalkerUtils {
          * ```
          */
         this.getData = async (symbol, walkerName) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_DATA);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            bt.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_DATA);
+            const walkerSchema = bt.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
-                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.getData(symbol, walkerName);
@@ -17168,13 +17356,15 @@ class WalkerUtils {
          * ```
          */
         this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_REPORT);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            bt.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_REPORT);
+            const walkerSchema = bt.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
-                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.getReport(symbol, walkerName, strategyColumns, pnlColumns);
@@ -17198,13 +17388,15 @@ class WalkerUtils {
          * ```
          */
         this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_DUMP);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            bt.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_DUMP);
+            const walkerSchema = bt.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
-                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.dump(symbol, walkerName, path, strategyColumns, pnlColumns);
@@ -17296,15 +17488,15 @@ class HeatUtils {
          * });
          * ```
          */
-        this.getData = async (strategyName) => {
-            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName });
-            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_DATA);
+        this.getData = async (strategyName, backtest) => {
+            bt.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName });
+            bt.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.heatMarkdownService.getData(strategyName);
+            return await bt.heatMarkdownService.getData(strategyName, backtest);
         };
         /**
          * Generates markdown report with portfolio heatmap table for a strategy.
@@ -17332,15 +17524,15 @@ class HeatUtils {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName, columns) => {
-            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
-            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_REPORT);
+        this.getReport = async (strategyName, backtest, columns) => {
+            bt.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
+            bt.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.heatMarkdownService.getReport(strategyName, columns);
+            return await bt.heatMarkdownService.getReport(strategyName, backtest, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -17361,15 +17553,15 @@ class HeatUtils {
          * await Heat.dump("my-strategy", "./reports");
          * ```
          */
-        this.dump = async (strategyName, path, columns) => {
-            backtest$1.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
-            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_DUMP);
+        this.dump = async (strategyName, backtest, path, columns) => {
+            bt.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
+            bt.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP));
             }
-            await backtest$1.heatMarkdownService.dump(strategyName, path, columns);
+            await bt.heatMarkdownService.dump(strategyName, backtest, path, columns);
         };
     }
 }
@@ -17456,12 +17648,12 @@ class PositionSizeUtils {
  * @throws Error if sizing schema method is not "fixed-percentage"
  */
 PositionSizeUtils.fixedPercentage = async (symbol, accountBalance, priceOpen, priceStopLoss, context) => {
-    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_FIXED, {
+    bt.loggerService.info(POSITION_SIZE_METHOD_NAME_FIXED, {
         context,
         symbol,
     });
-    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_FIXED, "fixed-percentage");
-    return await backtest$1.sizingGlobalService.calculate({
+    bt.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_FIXED, "fixed-percentage");
+    return await bt.sizingGlobalService.calculate({
         symbol,
         accountBalance,
         priceOpen,
@@ -17482,12 +17674,12 @@ PositionSizeUtils.fixedPercentage = async (symbol, accountBalance, priceOpen, pr
  * @throws Error if sizing schema method is not "kelly-criterion"
  */
 PositionSizeUtils.kellyCriterion = async (symbol, accountBalance, priceOpen, winRate, winLossRatio, context) => {
-    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_KELLY, {
+    bt.loggerService.info(POSITION_SIZE_METHOD_NAME_KELLY, {
         context,
         symbol,
     });
-    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_KELLY, "kelly-criterion");
-    return await backtest$1.sizingGlobalService.calculate({
+    bt.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_KELLY, "kelly-criterion");
+    return await bt.sizingGlobalService.calculate({
         symbol,
         accountBalance,
         priceOpen,
@@ -17508,12 +17700,12 @@ PositionSizeUtils.kellyCriterion = async (symbol, accountBalance, priceOpen, win
  * @throws Error if sizing schema method is not "atr-based"
  */
 PositionSizeUtils.atrBased = async (symbol, accountBalance, priceOpen, atr, context) => {
-    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_ATR, {
+    bt.loggerService.info(POSITION_SIZE_METHOD_NAME_ATR, {
         context,
         symbol,
     });
-    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_ATR, "atr-based");
-    return await backtest$1.sizingGlobalService.calculate({
+    bt.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_ATR, "atr-based");
+    return await bt.sizingGlobalService.calculate({
         symbol,
         accountBalance,
         priceOpen,
@@ -17562,12 +17754,12 @@ class OptimizerUtils {
          * @throws Error if optimizer not found
          */
         this.getData = async (symbol, context) => {
-            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_GET_DATA, {
+            bt.loggerService.info(OPTIMIZER_METHOD_NAME_GET_DATA, {
                 symbol,
                 context,
             });
-            backtest$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_DATA);
-            return await backtest$1.optimizerGlobalService.getData(symbol, context.optimizerName);
+            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_DATA);
+            return await bt.optimizerGlobalService.getData(symbol, context.optimizerName);
         };
         /**
          * Generates complete executable strategy code.
@@ -17579,12 +17771,12 @@ class OptimizerUtils {
          * @throws Error if optimizer not found
          */
         this.getCode = async (symbol, context) => {
-            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_GET_CODE, {
+            bt.loggerService.info(OPTIMIZER_METHOD_NAME_GET_CODE, {
                 symbol,
                 context,
             });
-            backtest$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_CODE);
-            return await backtest$1.optimizerGlobalService.getCode(symbol, context.optimizerName);
+            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_CODE);
+            return await bt.optimizerGlobalService.getCode(symbol, context.optimizerName);
         };
         /**
          * Generates and saves strategy code to file.
@@ -17598,13 +17790,13 @@ class OptimizerUtils {
          * @throws Error if optimizer not found or file write fails
          */
         this.dump = async (symbol, context, path) => {
-            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_DUMP, {
+            bt.loggerService.info(OPTIMIZER_METHOD_NAME_DUMP, {
                 symbol,
                 context,
                 path,
             });
-            backtest$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_DUMP);
-            await backtest$1.optimizerGlobalService.dump(symbol, context.optimizerName, path);
+            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_DUMP);
+            await bt.optimizerGlobalService.dump(symbol, context.optimizerName, path);
         };
     }
 }
@@ -17685,15 +17877,15 @@ class PartialUtils {
          * }
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName });
-            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_DATA);
+        this.getData = async (symbol, strategyName, backtest) => {
+            bt.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName });
+            bt.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.partialMarkdownService.getData(symbol, strategyName);
+            return await bt.partialMarkdownService.getData(symbol, strategyName, backtest);
         };
         /**
          * Generates markdown report with all partial profit/loss events for a symbol-strategy pair.
@@ -17734,15 +17926,15 @@ class PartialUtils {
          * // **Loss events:** 1
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
-            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
+        this.getReport = async (symbol, strategyName, backtest, columns) => {
+            bt.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
+            bt.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName, columns);
+            return await bt.partialMarkdownService.getReport(symbol, strategyName, backtest, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -17776,15 +17968,15 @@ class PartialUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
-            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_DUMP);
+        this.dump = async (symbol, strategyName, backtest, path, columns) => {
+            bt.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
+            bt.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP));
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP));
             }
-            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path, columns);
+            await bt.partialMarkdownService.dump(symbol, strategyName, backtest, path, columns);
         };
     }
 }