backtest-kit 1.5.27 → 1.5.29

package/build/index.mjs

@@ -2041,7 +2041,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,
     });
@@ -2099,7 +2099,7 @@ const PersistBase = makeExtendable(class {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a] = 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,
         });
@@ -2115,7 +2115,7 @@ const PersistBase = makeExtendable(class {
         return 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,
         });
@@ -2132,7 +2132,7 @@ const PersistBase = 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,
         });
@@ -2149,7 +2149,7 @@ const PersistBase = 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,
         });
@@ -2166,7 +2166,7 @@ const PersistBase = 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,
         });
@@ -2187,7 +2187,7 @@ const PersistBase = 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,
         });
@@ -2209,7 +2209,7 @@ const PersistBase = 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 {
@@ -2231,7 +2231,7 @@ const PersistBase = 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 {
@@ -2260,7 +2260,7 @@ const PersistBase = 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 {
@@ -2365,7 +2365,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);
@@ -2387,7 +2387,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);
@@ -2410,7 +2410,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;
     }
 }
@@ -2462,7 +2462,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);
@@ -2483,7 +2483,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);
@@ -2506,7 +2506,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;
     }
 }
@@ -2556,7 +2556,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);
@@ -2578,7 +2578,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);
@@ -2601,7 +2601,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;
     }
 }
@@ -2651,7 +2651,7 @@ class PersistPartialUtils {
          * @returns Promise resolving to partial data record
          */
         this.readPartialData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            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);
@@ -2674,7 +2674,7 @@ class PersistPartialUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePartialData = async (partialData, symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            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);
@@ -2698,7 +2698,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;
     }
 }
@@ -3167,7 +3167,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        backtest$1.loggerService.warn(message, payload);
+        bt.loggerService.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -3246,6 +3246,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);
@@ -3297,6 +3298,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);
@@ -3364,6 +3366,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);
@@ -3380,6 +3383,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);
@@ -3405,6 +3409,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);
@@ -3436,6 +3441,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);
@@ -3500,6 +3506,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);
@@ -3569,6 +3576,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);
@@ -3586,6 +3594,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);
@@ -3612,6 +3621,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);
@@ -3707,6 +3717,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);
@@ -4205,6 +4216,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)
                 }
@@ -4335,7 +4347,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)));
@@ -4352,7 +4364,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,
         });
@@ -4369,7 +4381,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,
         });
@@ -4437,19 +4449,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.
@@ -4492,19 +4504,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.
@@ -4538,20 +4550,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);
         };
     }
 }
@@ -5169,7 +5181,7 @@ const DO_VALIDATION_FN = trycatch(async (validation, params) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        backtest$1.loggerService.warn(message, payload);
+        bt.loggerService.warn(message, payload);
         console.warn(message, payload);
         validationSubject.next(error);
     },
@@ -5264,7 +5276,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);
@@ -5345,8 +5357,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,
@@ -5355,6 +5368,7 @@ const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment,
     activePositionCount,
     comment,
     timestamp,
+    backtest,
 });
 /**
  * Connection service routing risk operations to correct ClientRisk instance.
@@ -6425,6 +6439,13 @@ class WalkerSchemaService {
             if (walkerSchema.strategies.length === 0) {
                 throw new Error(`walker schema validation failed: strategies array cannot be empty for walkerName=${walkerSchema.walkerName}`);
             }
+            if (walkerSchema.strategies &&
+                walkerSchema.strategies.length !== new Set(walkerSchema.strategies).size) {
+                throw new Error(`walker schema validation failed: found duplicate strategies for walkerName=${walkerSchema.walkerName} strategies=[${walkerSchema.strategies}]`);
+            }
+            if (walkerSchema.strategies?.some((value) => typeof value !== "string")) {
+                throw new Error(`walker schema validation failed: invalid strategies for walkerName=${walkerSchema.walkerName} strategies=[${walkerSchema.strategies}]`);
+            }
         };
         /**
          * Overrides an existing walker schema with partial updates.
@@ -7029,7 +7050,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 &&
@@ -7093,7 +7114,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
@@ -7606,10 +7627,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 = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$5());
+        this.getStorage = 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.
@@ -7636,7 +7657,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);
         };
         /**
@@ -7645,21 +7666,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();
         };
         /**
@@ -7668,22 +7691,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);
         };
         /**
@@ -7693,6 +7718,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
          *
@@ -7701,45 +7727,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 {
@@ -8090,10 +8119,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 = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$4());
+        this.getStorage = 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.
@@ -8119,7 +8148,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);
             }
@@ -8139,21 +8168,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();
         };
         /**
@@ -8162,22 +8193,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);
         };
         /**
@@ -8187,6 +8220,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
          *
@@ -8195,45 +8229,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 {
@@ -8488,10 +8525,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 = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$3());
+        this.getStorage = 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.
@@ -8510,7 +8547,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);
             }
@@ -8531,21 +8568,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();
         };
         /**
@@ -8554,22 +8593,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);
         };
         /**
@@ -8579,6 +8620,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
          *
@@ -8587,45 +8629,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 {
@@ -8864,10 +8909,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 = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new PerformanceStorage());
+        this.getStorage = memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new PerformanceStorage());
         /**
          * Processes performance events and accumulates metrics.
          * Should be called from performance tracking code.
@@ -8880,7 +8925,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);
         };
         /**
@@ -8888,22 +8933,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);
         };
         /**
@@ -8911,21 +8958,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);
         };
         /**
@@ -8933,42 +8982,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();
             }
         };
@@ -9732,10 +9784,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 = memoize(([strategyName]) => `${strategyName}`, () => new HeatmapStorage());
+        this.getStorage = memoize(([strategyName, backtest]) => `${strategyName}:${backtest ? "backtest" : "live"}`, () => new HeatmapStorage());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from signal emitter subscription.
@@ -9751,19 +9803,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}%`);
@@ -9773,24 +9826,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
@@ -9804,11 +9859,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);
         };
         /**
@@ -9818,6 +9874,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
          *
@@ -9826,43 +9883,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.
@@ -12431,10 +12497,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 = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$1());
+        this.getStorage = memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$1());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -12451,7 +12517,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);
         };
         /**
@@ -12470,7 +12536,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);
         };
         /**
@@ -12479,21 +12545,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();
         };
         /**
@@ -12502,22 +12570,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);
         };
         /**
@@ -12527,6 +12597,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
          *
@@ -12535,45 +12606,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 {
@@ -13149,10 +13223,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 = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage());
+        this.getStorage = memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage());
         /**
          * Processes risk rejection events and accumulates them.
          * Should be called from riskSubject subscription.
@@ -13169,7 +13243,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);
         };
         /**
@@ -13178,21 +13252,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();
         };
         /**
@@ -13201,22 +13277,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);
         };
         /**
@@ -13226,6 +13304,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
          *
@@ -13234,45 +13313,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 {
@@ -13577,7 +13659,7 @@ const backtest = {
     ...templateServices,
 };
 init();
-var backtest$1 = backtest;
+var bt = backtest;
 
 /**
  * Sets custom logger implementation for the framework.
@@ -13597,7 +13679,7 @@ var backtest$1 = backtest;
  * ```
  */
 function setLogger(logger) {
-    backtest$1.loggerService.setLogger(logger);
+    bt.loggerService.setLogger(logger);
 }
 /**
  * Sets global configuration parameters for the framework.
@@ -13615,7 +13697,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: ${getErrorMessage(error)}`, config);
@@ -13686,7 +13768,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: ${getErrorMessage(error)}`, columns);
@@ -13771,11 +13853,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.
@@ -13813,11 +13895,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.
@@ -13850,11 +13932,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.
@@ -13894,11 +13976,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.
@@ -13953,11 +14035,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.
@@ -14021,11 +14103,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.
@@ -14115,11 +14197,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";
@@ -14155,8 +14237,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.
@@ -14189,8 +14271,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.
@@ -14218,8 +14300,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.
@@ -14248,8 +14330,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.
@@ -14287,8 +14369,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.
@@ -14323,8 +14405,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.
@@ -14363,8 +14445,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";
@@ -14421,7 +14503,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14457,7 +14539,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);
 }
 /**
@@ -14481,7 +14563,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14506,7 +14588,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);
 }
 /**
@@ -14530,7 +14612,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14555,7 +14637,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);
 }
 /**
@@ -14583,7 +14665,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(queued(async (error) => fn(error)));
 }
 /**
@@ -14611,7 +14693,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(queued(async (error) => fn(error)));
 }
 /**
@@ -14642,7 +14724,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14672,7 +14754,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);
 }
 /**
@@ -14704,7 +14786,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14735,7 +14817,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);
 }
 /**
@@ -14765,7 +14847,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14794,7 +14876,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);
 }
 /**
@@ -14828,7 +14910,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14862,7 +14944,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14890,7 +14972,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14926,7 +15008,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14960,7 +15042,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15003,7 +15085,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);
 }
 /**
@@ -15038,7 +15120,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15066,7 +15148,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(queued(async (error) => fn(error)));
 }
 /**
@@ -15094,7 +15176,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15128,7 +15210,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);
 }
 /**
@@ -15156,7 +15238,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15190,7 +15272,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);
 }
 /**
@@ -15222,7 +15304,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15259,7 +15341,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);
 }
 
@@ -15287,12 +15369,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.
@@ -15313,10 +15395,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.
@@ -15334,11 +15416,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.
@@ -15356,11 +15438,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.
@@ -15377,8 +15459,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());
 }
 /**
@@ -15397,9 +15479,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";
@@ -15470,13 +15552,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";
@@ -15563,7 +15645,7 @@ class BacktestInstance {
          * @internal
          */
         this.task = singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -15582,7 +15664,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,
@@ -15598,23 +15680,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(true, { 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(true, riskName);
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, 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.
@@ -15637,14 +15723,23 @@ 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(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop(true, { symbol, strategyName: context.strategyName });
-                backtest$1.strategyCoreService
+                bt.strategyCoreService.stop(true, { symbol, strategyName: context.strategyName });
+                bt.strategyCoreService
                     .getPendingSignal(true, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
@@ -15681,11 +15776,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(true, { symbol, strategyName });
+            await bt.strategyCoreService.stop(true, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
@@ -15702,11 +15797,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.
@@ -15724,11 +15819,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.
@@ -15749,12 +15844,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);
         };
     }
 }
@@ -15793,14 +15888,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);
@@ -15827,13 +15922,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);
@@ -15856,11 +15951,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);
@@ -15879,11 +15974,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);
@@ -15903,11 +15998,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);
@@ -15930,11 +16025,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);
@@ -16064,7 +16159,7 @@ class LiveInstance {
          * @internal
          */
         this.task = singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_TASK, {
+            bt.loggerService.info(LIVE_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16083,7 +16178,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,
@@ -16102,23 +16197,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(false, { 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(false, riskName);
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(false, 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.
@@ -16141,14 +16240,23 @@ 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(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop(false, { symbol, strategyName: context.strategyName });
-                backtest$1.strategyCoreService
+                bt.strategyCoreService.stop(false, { symbol, strategyName: context.strategyName });
+                bt.strategyCoreService
                     .getPendingSignal(false, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
@@ -16185,11 +16293,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(false, { symbol, strategyName });
+            await bt.strategyCoreService.stop(false, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
@@ -16206,11 +16314,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.
@@ -16228,11 +16336,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.
@@ -16253,12 +16361,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);
         };
     }
 }
@@ -16310,13 +16418,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);
@@ -16343,12 +16451,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);
@@ -16371,11 +16479,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);
@@ -16394,11 +16502,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);
@@ -16418,11 +16526,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);
@@ -16445,11 +16553,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);
@@ -16533,18 +16641,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.
@@ -16560,18 +16669,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.
@@ -16590,19 +16700,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);
         };
     }
 }
@@ -16640,7 +16751,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");
@@ -16683,14 +16794,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.
@@ -16715,14 +16826,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.
@@ -16744,14 +16855,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);
     }
 }
 
@@ -16785,7 +16896,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,
@@ -16839,7 +16950,7 @@ class WalkerInstance {
          * @internal
          */
         this.task = singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_TASK, {
+            bt.loggerService.info(WALKER_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16858,7 +16969,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,
@@ -16874,35 +16985,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(true, { symbol, strategyName });
+                    bt.strategyCoreService.clear(true, { symbol, strategyName });
                 }
                 {
-                    const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                    riskName && backtest$1.riskGlobalService.clear(true, riskName);
+                    const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                    riskName && bt.riskGlobalService.clear(true, riskName);
                     riskList &&
-                        riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, riskName));
+                        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,
@@ -16927,15 +17042,24 @@ 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(getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
+                    bt.strategyCoreService.stop(true, { symbol, strategyName });
                     walkerStopSubject.next({
                         symbol,
                         strategyName,
@@ -16978,14 +17102,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(true, { symbol, strategyName });
+                await bt.strategyCoreService.stop(true, { symbol, strategyName });
             }
         };
         /**
@@ -17003,12 +17127,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,
             });
@@ -17030,12 +17154,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);
@@ -17060,13 +17184,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);
@@ -17107,17 +17231,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);
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
                 riskList &&
-                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.run(symbol, context);
@@ -17142,17 +17266,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);
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_BACKGROUND);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
                 riskList &&
-                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.background(symbol, context);
@@ -17181,15 +17305,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);
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
                 riskList &&
-                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.stop(symbol, walkerName);
@@ -17208,15 +17332,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);
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
                 riskList &&
-                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.getData(symbol, walkerName);
@@ -17237,15 +17361,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);
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
                 riskList &&
-                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
+                    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);
@@ -17269,15 +17393,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);
+                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
+                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
                 riskList &&
-                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
+                    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);
@@ -17369,15 +17493,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.
@@ -17405,15 +17529,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.
@@ -17434,15 +17558,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);
         };
     }
 }
@@ -17529,12 +17653,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,
@@ -17555,12 +17679,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,
@@ -17581,12 +17705,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,
@@ -17635,12 +17759,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.
@@ -17652,12 +17776,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.
@@ -17671,13 +17795,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);
         };
     }
 }
@@ -17758,15 +17882,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.
@@ -17807,15 +17931,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.
@@ -17849,15 +17973,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);
         };
     }
 }