backtest-kit 1.5.27 → 1.5.29

package/build/index.cjs

@@ -2043,7 +2043,7 @@ const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
 const BASE_WAIT_FOR_INIT_FN = async (self) => {
-    backtest$1.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+    bt.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
         entityName: self.entityName,
         directory: self._directory,
     });
@@ -2101,7 +2101,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
             entityName: this.entityName,
             baseDir,
         });
@@ -2117,7 +2117,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         return path.join(this.baseDir, this.entityName, `${entityId}.json`);
     }
     async waitForInit(initial) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             entityName: this.entityName,
             initial,
         });
@@ -2134,7 +2134,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         return length;
     }
     async readValue(entityId) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2151,7 +2151,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         }
     }
     async hasValue(entityId) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2168,7 +2168,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         }
     }
     async writeValue(entityId, entity) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2189,7 +2189,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if entity not found or deletion fails
      */
     async removeValue(entityId) {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_VALUE, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2211,7 +2211,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if deletion fails
      */
     async removeAll() {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_ALL, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_ALL, {
             entityName: this.entityName,
         });
         try {
@@ -2233,7 +2233,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if reading fails
      */
     async *values() {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_VALUES, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_VALUES, {
             entityName: this.entityName,
         });
         try {
@@ -2262,7 +2262,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if reading fails
      */
     async *keys() {
-        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
             entityName: this.entityName,
         });
         try {
@@ -2367,7 +2367,7 @@ class PersistSignalUtils {
          * @returns Promise resolving to signal or null
          */
         this.readSignalData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getSignalStorage.has(key);
             const stateStorage = this.getSignalStorage(symbol, strategyName);
@@ -2389,7 +2389,7 @@ class PersistSignalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSignalData = async (signalRow, symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getSignalStorage.has(key);
             const stateStorage = this.getSignalStorage(symbol, strategyName);
@@ -2412,7 +2412,7 @@ class PersistSignalUtils {
      * ```
      */
     usePersistSignalAdapter(Ctor) {
-        backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
         this.PersistSignalFactory = Ctor;
     }
 }
@@ -2464,7 +2464,7 @@ class PersistRiskUtils {
          * @returns Promise resolving to Map of active positions
          */
         this.readPositionData = async (riskName) => {
-            backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const isInitial = !this.getRiskStorage.has(riskName);
             const stateStorage = this.getRiskStorage(riskName);
             await stateStorage.waitForInit(isInitial);
@@ -2485,7 +2485,7 @@ class PersistRiskUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePositionData = async (riskRow, riskName) => {
-            backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const isInitial = !this.getRiskStorage.has(riskName);
             const stateStorage = this.getRiskStorage(riskName);
             await stateStorage.waitForInit(isInitial);
@@ -2508,7 +2508,7 @@ class PersistRiskUtils {
      * ```
      */
     usePersistRiskAdapter(Ctor) {
-        backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
         this.PersistRiskFactory = Ctor;
     }
 }
@@ -2558,7 +2558,7 @@ class PersistScheduleUtils {
          * @returns Promise resolving to scheduled signal or null
          */
         this.readScheduleData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const stateStorage = this.getScheduleStorage(symbol, strategyName);
@@ -2580,7 +2580,7 @@ class PersistScheduleUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName) => {
-            backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const stateStorage = this.getScheduleStorage(symbol, strategyName);
@@ -2603,7 +2603,7 @@ class PersistScheduleUtils {
      * ```
      */
     usePersistScheduleAdapter(Ctor) {
-        backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
         this.PersistScheduleFactory = Ctor;
     }
 }
@@ -2653,7 +2653,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);
@@ -2676,7 +2676,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);
@@ -2700,7 +2700,7 @@ class PersistPartialUtils {
      * ```
      */
     usePersistPartialAdapter(Ctor) {
-        backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
         this.PersistPartialFactory = Ctor;
     }
 }
@@ -3169,7 +3169,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        backtest$1.loggerService.warn(message, payload);
+        bt.loggerService.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -3248,6 +3248,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3299,6 +3300,7 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: currentPrice,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3366,6 +3368,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: self._pendingSignal.priceOpen,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3382,6 +3385,7 @@ const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice)
         symbol: self.params.execution.context.symbol,
         percentTp: 0,
         percentSl: 0,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3407,6 +3411,7 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: currentPrice,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3438,6 +3443,7 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: signal.priceOpen,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3502,6 +3508,7 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3571,6 +3578,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
         symbol: self.params.execution.context.symbol,
         percentTp,
         percentSl,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3588,6 +3596,7 @@ const RETURN_IDLE_FN = async (self, currentPrice) => {
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         currentPrice: currentPrice,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3614,6 +3623,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -3709,6 +3719,7 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -4207,6 +4218,7 @@ class ClientStrategy {
                         strategyName: this.params.method.context.strategyName,
                         exchangeName: this.params.method.context.exchangeName,
                         symbol: this.params.execution.context.symbol,
+                        backtest: this.params.execution.context.backtest,
                     };
                     return result; // Cast to IStrategyBacktestResult (which includes Active)
                 }
@@ -4337,7 +4349,7 @@ class MergeRisk {
      * @returns Promise resolving to true if all risks approve, false if any risk rejects
      */
     async checkSignal(params) {
-        backtest$1.loggerService.info("MergeRisk checkSignal", {
+        bt.loggerService.info("MergeRisk checkSignal", {
             params,
         });
         const riskCheck = await Promise.all(this._riskList.map(async (risk) => await risk.checkSignal(params)));
@@ -4354,7 +4366,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have registered the signal
      */
     async addSignal(symbol, context) {
-        backtest$1.loggerService.info("MergeRisk addSignal", {
+        bt.loggerService.info("MergeRisk addSignal", {
             symbol,
             context,
         });
@@ -4371,7 +4383,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have removed the signal
      */
     async removeSignal(symbol, context) {
-        backtest$1.loggerService.info("MergeRisk removeSignal", {
+        bt.loggerService.info("MergeRisk removeSignal", {
             symbol,
             context,
         });
@@ -4439,19 +4451,19 @@ class RiskUtils {
          * }
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_DATA, {
+        this.getData = async (symbol, strategyName, backtest) => {
+            bt.loggerService.info(RISK_METHOD_NAME_GET_DATA, {
                 symbol,
                 strategyName,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
+            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA));
+                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.riskMarkdownService.getData(symbol, strategyName);
+            return await bt.riskMarkdownService.getData(symbol, strategyName, backtest);
         };
         /**
          * Generates markdown report with all risk rejection events for a symbol-strategy pair.
@@ -4494,19 +4506,19 @@ class RiskUtils {
          * // - my-strategy: 1
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
+        this.getReport = async (symbol, strategyName, backtest, columns) => {
+            bt.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
+            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
+                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName, columns);
+            return await bt.riskMarkdownService.getReport(symbol, strategyName, backtest, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -4540,20 +4552,20 @@ class RiskUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, {
+        this.dump = async (symbol, strategyName, backtest, path, columns) => {
+            bt.loggerService.info(RISK_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
+            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP));
+                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP));
             }
-            await backtest$1.riskMarkdownService.dump(symbol, strategyName, path, columns);
+            await bt.riskMarkdownService.dump(symbol, strategyName, backtest, path, columns);
         };
     }
 }
@@ -5171,7 +5183,7 @@ const DO_VALIDATION_FN = functoolsKit.trycatch(async (validation, params) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        backtest$1.loggerService.warn(message, payload);
+        bt.loggerService.warn(message, payload);
         console.warn(message, payload);
         validationSubject.next(error);
     },
@@ -5266,7 +5278,7 @@ class ClientRisk {
             }
             if (!isValid) {
                 // Call params.onRejected for riskSubject emission
-                await this.params.onRejected(params.symbol, params, riskMap.size, rejectionNote, Date.now());
+                await this.params.onRejected(params.symbol, params, riskMap.size, rejectionNote, Date.now(), this.params.backtest);
                 // Call schema callbacks.onRejected if defined
                 if (this.params.callbacks?.onRejected) {
                     this.params.callbacks.onRejected(params.symbol, params);
@@ -5347,8 +5359,9 @@ class ClientRisk {
  * @param activePositionCount - Number of active positions at rejection time
  * @param comment - Rejection reason from validation note or "N/A"
  * @param timestamp - Event timestamp in milliseconds
+ * @param backtest - True if backtest mode, false if live mode
  */
-const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment, timestamp) => await riskSubject.next({
+const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment, timestamp, backtest) => await riskSubject.next({
     symbol,
     pendingSignal: params.pendingSignal,
     strategyName: params.strategyName,
@@ -5357,6 +5370,7 @@ const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment,
     activePositionCount,
     comment,
     timestamp,
+    backtest,
 });
 /**
  * Connection service routing risk operations to correct ClientRisk instance.
@@ -6427,6 +6441,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.
@@ -7031,7 +7052,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 &&
@@ -7095,7 +7116,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
@@ -7608,10 +7629,10 @@ class BacktestMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$5());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$5());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -7638,7 +7659,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);
         };
         /**
@@ -7647,21 +7668,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();
         };
         /**
@@ -7670,22 +7693,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);
         };
         /**
@@ -7695,6 +7720,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
          *
@@ -7703,45 +7729,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 {
@@ -8092,10 +8121,10 @@ class LiveMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$4());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -8121,7 +8150,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);
             }
@@ -8141,21 +8170,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();
         };
         /**
@@ -8164,22 +8195,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);
         };
         /**
@@ -8189,6 +8222,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
          *
@@ -8197,45 +8231,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 {
@@ -8490,10 +8527,10 @@ class ScheduleMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$3());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates scheduled/opened/cancelled events.
          * Should be called from signalEmitter subscription.
@@ -8512,7 +8549,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);
             }
@@ -8533,21 +8570,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();
         };
         /**
@@ -8556,22 +8595,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);
         };
         /**
@@ -8581,6 +8622,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
          *
@@ -8589,45 +8631,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 {
@@ -8866,10 +8911,10 @@ class PerformanceMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create PerformanceStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create PerformanceStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new PerformanceStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new PerformanceStorage());
         /**
          * Processes performance events and accumulates metrics.
          * Should be called from performance tracking code.
@@ -8882,7 +8927,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);
         };
         /**
@@ -8890,22 +8935,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);
         };
         /**
@@ -8913,21 +8960,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);
         };
         /**
@@ -8935,42 +8984,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();
             }
         };
@@ -9734,10 +9786,10 @@ class HeatMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create HeatmapStorage for a strategy.
-         * Each strategy gets its own isolated heatmap storage instance.
+         * Memoized function to get or create HeatmapStorage for a strategy and backtest mode.
+         * Each strategy + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([strategyName]) => `${strategyName}`, () => new HeatmapStorage());
+        this.getStorage = functoolsKit.memoize(([strategyName, backtest]) => `${strategyName}:${backtest ? "backtest" : "live"}`, () => new HeatmapStorage());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from signal emitter subscription.
@@ -9753,19 +9805,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}%`);
@@ -9775,24 +9828,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
@@ -9806,11 +9861,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);
         };
         /**
@@ -9820,6 +9876,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
          *
@@ -9828,43 +9885,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.
@@ -12433,10 +12499,10 @@ class PartialMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$1());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage$1());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -12453,7 +12519,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);
         };
         /**
@@ -12472,7 +12538,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);
         };
         /**
@@ -12481,21 +12547,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();
         };
         /**
@@ -12504,22 +12572,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);
         };
         /**
@@ -12529,6 +12599,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
          *
@@ -12537,45 +12608,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 {
@@ -13151,10 +13225,10 @@ class RiskMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
-         * Each symbol-strategy combination gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
+         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, () => new ReportStorage());
         /**
          * Processes risk rejection events and accumulates them.
          * Should be called from riskSubject subscription.
@@ -13171,7 +13245,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);
         };
         /**
@@ -13180,21 +13254,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();
         };
         /**
@@ -13203,22 +13279,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);
         };
         /**
@@ -13228,6 +13306,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
          *
@@ -13236,45 +13315,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 {
@@ -13579,7 +13661,7 @@ const backtest = {
     ...templateServices,
 };
 init();
-var backtest$1 = backtest;
+var bt = backtest;
 
 /**
  * Sets custom logger implementation for the framework.
@@ -13599,7 +13681,7 @@ var backtest$1 = backtest;
  * ```
  */
 function setLogger(logger) {
-    backtest$1.loggerService.setLogger(logger);
+    bt.loggerService.setLogger(logger);
 }
 /**
  * Sets global configuration parameters for the framework.
@@ -13617,7 +13699,7 @@ function setConfig(config, _unsafe) {
     const prevConfig = Object.assign({}, GLOBAL_CONFIG);
     try {
         Object.assign(GLOBAL_CONFIG, config);
-        !_unsafe && backtest$1.configValidationService.validate();
+        !_unsafe && bt.configValidationService.validate();
     }
     catch (error) {
         console.warn(`backtest-kit setConfig failed: ${functoolsKit.getErrorMessage(error)}`, config);
@@ -13688,7 +13770,7 @@ function setColumns(columns, _unsafe) {
     const prevConfig = Object.assign({}, COLUMN_CONFIG);
     try {
         Object.assign(COLUMN_CONFIG, columns);
-        !_unsafe && backtest$1.columnValidationService.validate();
+        !_unsafe && bt.columnValidationService.validate();
     }
     catch (error) {
         console.warn(`backtest-kit setColumns failed: ${functoolsKit.getErrorMessage(error)}`, columns);
@@ -13773,11 +13855,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.
@@ -13815,11 +13897,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.
@@ -13852,11 +13934,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.
@@ -13896,11 +13978,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.
@@ -13955,11 +14037,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.
@@ -14023,11 +14105,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.
@@ -14117,11 +14199,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";
@@ -14157,8 +14239,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.
@@ -14191,8 +14273,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.
@@ -14220,8 +14302,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.
@@ -14250,8 +14332,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.
@@ -14289,8 +14371,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.
@@ -14325,8 +14407,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.
@@ -14365,8 +14447,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";
@@ -14423,7 +14505,7 @@ const LISTEN_RISK_ONCE_METHOD_NAME = "event.listenRiskOnce";
  * ```
  */
 function listenSignal(fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_METHOD_NAME);
     return signalEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14459,7 +14541,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);
 }
 /**
@@ -14483,7 +14565,7 @@ function listenSignalOnce(filterFn, fn) {
  * ```
  */
 function listenSignalLive(fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_LIVE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_LIVE_METHOD_NAME);
     return signalLiveEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14508,7 +14590,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);
 }
 /**
@@ -14532,7 +14614,7 @@ function listenSignalLiveOnce(filterFn, fn) {
  * ```
  */
 function listenSignalBacktest(fn) {
-    backtest$1.loggerService.log(LISTEN_SIGNAL_BACKTEST_METHOD_NAME);
+    bt.loggerService.log(LISTEN_SIGNAL_BACKTEST_METHOD_NAME);
     return signalBacktestEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14557,7 +14639,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);
 }
 /**
@@ -14585,7 +14667,7 @@ function listenSignalBacktestOnce(filterFn, fn) {
  * ```
  */
 function listenError(fn) {
-    backtest$1.loggerService.log(LISTEN_ERROR_METHOD_NAME);
+    bt.loggerService.log(LISTEN_ERROR_METHOD_NAME);
     return errorEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -14613,7 +14695,7 @@ function listenError(fn) {
  * ```
  */
 function listenExit(fn) {
-    backtest$1.loggerService.log(LISTEN_EXIT_METHOD_NAME);
+    bt.loggerService.log(LISTEN_EXIT_METHOD_NAME);
     return exitEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -14644,7 +14726,7 @@ function listenExit(fn) {
  * ```
  */
 function listenDoneLive(fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_LIVE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_LIVE_METHOD_NAME);
     return doneLiveSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14674,7 +14756,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);
 }
 /**
@@ -14706,7 +14788,7 @@ function listenDoneLiveOnce(filterFn, fn) {
  * ```
  */
 function listenDoneBacktest(fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_BACKTEST_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_BACKTEST_METHOD_NAME);
     return doneBacktestSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14737,7 +14819,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);
 }
 /**
@@ -14767,7 +14849,7 @@ function listenDoneBacktestOnce(filterFn, fn) {
  * ```
  */
 function listenDoneWalker(fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_WALKER_METHOD_NAME);
+    bt.loggerService.log(LISTEN_DONE_WALKER_METHOD_NAME);
     return doneWalkerSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14796,7 +14878,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);
 }
 /**
@@ -14830,7 +14912,7 @@ function listenDoneWalkerOnce(filterFn, fn) {
  * ```
  */
 function listenBacktestProgress(fn) {
-    backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
     return progressBacktestEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14864,7 +14946,7 @@ function listenBacktestProgress(fn) {
  * ```
  */
 function listenWalkerProgress(fn) {
-    backtest$1.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
     return progressWalkerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14892,7 +14974,7 @@ function listenWalkerProgress(fn) {
  * ```
  */
 function listenOptimizerProgress(fn) {
-    backtest$1.loggerService.log(LISTEN_PROGRESS_OPTIMIZER_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PROGRESS_OPTIMIZER_METHOD_NAME);
     return progressOptimizerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14928,7 +15010,7 @@ function listenOptimizerProgress(fn) {
  * ```
  */
 function listenPerformance(fn) {
-    backtest$1.loggerService.log(LISTEN_PERFORMANCE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PERFORMANCE_METHOD_NAME);
     return performanceEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14962,7 +15044,7 @@ function listenPerformance(fn) {
  * ```
  */
 function listenWalker(fn) {
-    backtest$1.loggerService.log(LISTEN_WALKER_METHOD_NAME);
+    bt.loggerService.log(LISTEN_WALKER_METHOD_NAME);
     return walkerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15005,7 +15087,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);
 }
 /**
@@ -15040,7 +15122,7 @@ function listenWalkerOnce(filterFn, fn) {
  * ```
  */
 function listenWalkerComplete(fn) {
-    backtest$1.loggerService.log(LISTEN_WALKER_COMPLETE_METHOD_NAME);
+    bt.loggerService.log(LISTEN_WALKER_COMPLETE_METHOD_NAME);
     return walkerCompleteSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15068,7 +15150,7 @@ function listenWalkerComplete(fn) {
  * ```
  */
 function listenValidation(fn) {
-    backtest$1.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
+    bt.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
     return validationSubject.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -15096,7 +15178,7 @@ function listenValidation(fn) {
  * ```
  */
 function listenPartialProfit(fn) {
-    backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
     return partialProfitSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15130,7 +15212,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);
 }
 /**
@@ -15158,7 +15240,7 @@ function listenPartialProfitOnce(filterFn, fn) {
  * ```
  */
 function listenPartialLoss(fn) {
-    backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
+    bt.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
     return partialLossSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15192,7 +15274,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);
 }
 /**
@@ -15224,7 +15306,7 @@ function listenPartialLossOnce(filterFn, fn) {
  * ```
  */
 function listenRisk(fn) {
-    backtest$1.loggerService.log(LISTEN_RISK_METHOD_NAME);
+    bt.loggerService.log(LISTEN_RISK_METHOD_NAME);
     return riskSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15261,7 +15343,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);
 }
 
@@ -15289,12 +15371,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.
@@ -15315,10 +15397,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.
@@ -15336,11 +15418,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.
@@ -15358,11 +15440,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.
@@ -15379,8 +15461,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());
 }
 /**
@@ -15399,9 +15481,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";
@@ -15472,13 +15554,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";
@@ -15565,7 +15647,7 @@ class BacktestInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -15584,7 +15666,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,
@@ -15600,23 +15682,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.
@@ -15639,14 +15725,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(functoolsKit.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) {
@@ -15683,11 +15778,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.
@@ -15704,11 +15799,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.
@@ -15726,11 +15821,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.
@@ -15751,12 +15846,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);
         };
     }
 }
@@ -15795,14 +15890,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);
@@ -15829,13 +15924,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);
@@ -15858,11 +15953,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);
@@ -15881,11 +15976,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);
@@ -15905,11 +16000,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);
@@ -15932,11 +16027,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);
@@ -16066,7 +16161,7 @@ class LiveInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_TASK, {
+            bt.loggerService.info(LIVE_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16085,7 +16180,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,
@@ -16104,23 +16199,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.
@@ -16143,14 +16242,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(functoolsKit.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) {
@@ -16187,11 +16295,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.
@@ -16208,11 +16316,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.
@@ -16230,11 +16338,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.
@@ -16255,12 +16363,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);
         };
     }
 }
@@ -16312,13 +16420,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);
@@ -16345,12 +16453,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);
@@ -16373,11 +16481,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);
@@ -16396,11 +16504,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);
@@ -16420,11 +16528,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);
@@ -16447,11 +16555,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);
@@ -16535,18 +16643,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.
@@ -16562,18 +16671,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.
@@ -16592,19 +16702,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);
         };
     }
 }
@@ -16642,7 +16753,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");
@@ -16685,14 +16796,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.
@@ -16717,14 +16828,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.
@@ -16746,14 +16857,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);
     }
 }
 
@@ -16787,7 +16898,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,
@@ -16841,7 +16952,7 @@ class WalkerInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            backtest$1.loggerService.info(WALKER_METHOD_NAME_TASK, {
+            bt.loggerService.info(WALKER_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16860,7 +16971,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,
@@ -16876,35 +16987,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,
@@ -16929,15 +17044,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(functoolsKit.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,
@@ -16980,14 +17104,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 });
             }
         };
         /**
@@ -17005,12 +17129,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,
             });
@@ -17032,12 +17156,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);
@@ -17062,13 +17186,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);
@@ -17109,17 +17233,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);
@@ -17144,17 +17268,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);
@@ -17183,15 +17307,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);
@@ -17210,15 +17334,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);
@@ -17239,15 +17363,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);
@@ -17271,15 +17395,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);
@@ -17371,15 +17495,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.
@@ -17407,15 +17531,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.
@@ -17436,15 +17560,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);
         };
     }
 }
@@ -17531,12 +17655,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,
@@ -17557,12 +17681,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,
@@ -17583,12 +17707,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,
@@ -17637,12 +17761,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.
@@ -17654,12 +17778,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.
@@ -17673,13 +17797,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);
         };
     }
 }
@@ -17760,15 +17884,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.
@@ -17809,15 +17933,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.
@@ -17851,15 +17975,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);
         };
     }
 }