backtest-kit 1.5.2 → 1.5.3

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, resolveDocuments, str, iterateDocuments, distinctDocuments, queued } from 'functools-kit';
+import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, and, resolveDocuments, str, iterateDocuments, distinctDocuments, queued } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
@@ -1673,6 +1673,8 @@ const walkerCompleteSubject = new Subject();
 /**
  * Walker stop emitter for walker cancellation events.
  * Emits when a walker comparison is stopped/cancelled.
+ *
+ * Includes walkerName to support multiple walkers running on the same symbol.
  */
 const walkerStopSubject = new Subject();
 /**
@@ -2907,6 +2909,23 @@ class ClientStrategy {
         });
         return this._pendingSignal;
     }
+    /**
+     * Returns the stopped state of the strategy.
+     *
+     * Indicates whether the strategy has been explicitly stopped and should
+     * not continue processing new ticks or signals.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Name of the strategy
+     * @returns Promise resolving to true if strategy is stopped, false otherwise
+     */
+    async getStopped(symbol, strategyName) {
+        this.params.logger.debug("ClientStrategy getStopped", {
+            symbol,
+            strategyName,
+        });
+        return this._isStopped;
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -3149,18 +3168,24 @@ class ClientStrategy {
      * // Existing signal will continue until natural close
      * ```
      */
-    async stop(symbol, strategyName) {
+    async stop(symbol, strategyName, backtest) {
         this.params.logger.debug("ClientStrategy stop", {
             symbol,
             strategyName,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
+            backtest,
         });
         this._isStopped = true;
         // Clear scheduled signal if exists
-        if (this._scheduledSignal) {
-            await this.setScheduledSignal(null);
+        if (!this._scheduledSignal) {
+            return;
         }
+        this._scheduledSignal = null;
+        if (backtest) {
+            return;
+        }
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, this.params.execution.context.symbol, this.params.strategyName);
     }
 }
 
@@ -3243,6 +3268,24 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, strategyName);
             return await strategy.getPendingSignal(symbol, strategyName);
         };
+        /**
+         * Retrieves the stopped state of the strategy.
+         *
+         * Delegates to the underlying strategy instance to check if it has been
+         * marked as stopped and should cease operation.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of the strategy
+         * @returns Promise resolving to true if strategy is stopped, false otherwise
+         */
+        this.getStopped = async (symbol, strategyName) => {
+            this.loggerService.log("strategyConnectionService getStopped", {
+                symbol,
+                strategyName,
+            });
+            const strategy = this.getStrategy(symbol, strategyName);
+            return await strategy.getStopped(symbol, strategyName);
+        };
         /**
          * Executes live trading tick for current strategy.
          *
@@ -3310,12 +3353,12 @@ class StrategyConnectionService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx) => {
+        this.stop = async (ctx, backtest) => {
             this.loggerService.log("strategyConnectionService stop", {
                 ctx
             });
             const strategy = this.getStrategy(ctx.symbol, ctx.strategyName);
-            await strategy.stop(ctx.symbol, ctx.strategyName);
+            await strategy.stop(ctx.symbol, ctx.strategyName, backtest);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -4180,6 +4223,24 @@ class StrategyGlobalService {
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getPendingSignal(symbol, strategyName);
         };
+        /**
+         * Checks if the strategy has been stopped.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to retrieve the stopped state from the strategy instance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of the strategy
+         * @returns Promise resolving to true if strategy is stopped, false otherwise
+         */
+        this.getStopped = async (symbol, strategyName) => {
+            this.loggerService.log("strategyGlobalService getStopped", {
+                symbol,
+                strategyName,
+            });
+            await this.validate(symbol, strategyName);
+            return await this.strategyConnectionService.getStopped(symbol, strategyName);
+        };
         /**
          * Checks signal status at a specific timestamp.
          *
@@ -4246,12 +4307,13 @@ class StrategyGlobalService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx) => {
+        this.stop = async (ctx, backtest) => {
             this.loggerService.log("strategyGlobalService stop", {
                 ctx,
+                backtest,
             });
             await this.validate(ctx.symbol, ctx.strategyName);
-            return await this.strategyConnectionService.stop(ctx);
+            return await this.strategyConnectionService.stop(ctx, backtest);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -4943,6 +5005,16 @@ class BacktestLogicPrivateService {
                     progress: totalFrames > 0 ? i / totalFrames : 0,
                 });
             }
+            // Check if strategy should stop before processing next frame
+            if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                this.loggerService.info("backtestLogicPrivateService stopped by user request (before tick)", {
+                    symbol,
+                    when: when.toISOString(),
+                    processedFrames: i,
+                    totalFrames,
+                });
+                break;
+            }
             let result;
             try {
                 result = await this.strategyGlobalService.tick(symbol, when, true);
@@ -4958,6 +5030,16 @@ class BacktestLogicPrivateService {
                 i++;
                 continue;
             }
+            // Check if strategy should stop when idle (no active signal)
+            if (await and(Promise.resolve(result.action === "idle"), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
+                    symbol,
+                    when: when.toISOString(),
+                    processedFrames: i,
+                    totalFrames,
+                });
+                break;
+            }
             // Если scheduled signal создан - обрабатываем через backtest()
             if (result.action === "scheduled") {
                 const signalStartTime = performance.now();
@@ -5050,6 +5132,16 @@ class BacktestLogicPrivateService {
                     i++;
                 }
                 yield backtestResult;
+                // Check if strategy should stop after signal is closed
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("backtestLogicPrivateService stopped by user request (after scheduled signal closed)", {
+                        symbol,
+                        signalId: backtestResult.signal.id,
+                        processedFrames: i,
+                        totalFrames,
+                    });
+                    break;
+                }
             }
             // Если обычный сигнал открыт, вызываем backtest
             if (result.action === "opened") {
@@ -5133,6 +5225,16 @@ class BacktestLogicPrivateService {
                     i++;
                 }
                 yield backtestResult;
+                // Check if strategy should stop after signal is closed
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("backtestLogicPrivateService stopped by user request (after signal closed)", {
+                        symbol,
+                        signalId: backtestResult.signal.id,
+                        processedFrames: i,
+                        totalFrames,
+                    });
+                    break;
+                }
             }
             // Track timeframe processing duration
             const timeframeEndTime = performance.now();
@@ -5240,7 +5342,8 @@ class LiveLogicPrivateService {
                 this.loggerService.warn("liveLogicPrivateService tick failed, retrying after sleep", {
                     symbol,
                     when: when.toISOString(),
-                    error: errorData(error), message: getErrorMessage(error),
+                    error: errorData(error),
+                    message: getErrorMessage(error),
                 });
                 await errorEmitter.next(error);
                 await sleep(TICK_TTL);
@@ -5264,11 +5367,19 @@ class LiveLogicPrivateService {
                 backtest: false,
             });
             previousEventTimestamp = currentTimestamp;
-            if (result.action === "active") {
+            // Check if strategy should stop when idle (no active signal)
+            if (result.action === "idle") {
+                if (await and(Promise.resolve(true), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                    this.loggerService.info("liveLogicPrivateService stopped by user request (idle state)", {
+                        symbol,
+                        when: when.toISOString(),
+                    });
+                    break;
+                }
                 await sleep(TICK_TTL);
                 continue;
             }
-            if (result.action === "idle") {
+            if (result.action === "active") {
                 await sleep(TICK_TTL);
                 continue;
             }
@@ -5278,12 +5389,21 @@ class LiveLogicPrivateService {
             }
             // Yield opened, closed results
             yield result;
+            // Check if strategy should stop after signal is closed
+            if (result.action === "closed") {
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("liveLogicPrivateService stopped by user request (after signal closed)", {
+                        symbol,
+                        signalId: result.signal.id,
+                    });
+                    break;
+                }
+            }
             await sleep(TICK_TTL);
         }
     }
 }
 
-const CANCEL_SYMBOL = Symbol("CANCEL_SYMBOL");
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -5341,112 +5461,121 @@ class WalkerLogicPrivateService {
         let strategiesTested = 0;
         let bestMetric = null;
         let bestStrategy = null;
-        let pendingStrategy;
-        const listenStop = walkerStopSubject
-            .filter((data) => {
-            let isOk = true;
-            isOk = isOk && data.symbol === symbol;
-            isOk = isOk && data.strategyName === pendingStrategy;
-            return isOk;
-        })
-            .map(() => CANCEL_SYMBOL)
-            .toPromise();
-        // Run backtest for each strategy
-        for (const strategyName of strategies) {
-            // Call onStrategyStart callback if provided
-            if (walkerSchema.callbacks?.onStrategyStart) {
-                walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
-            }
-            this.loggerService.info("walkerLogicPrivateService testing strategy", {
-                strategyName,
+        // Track stopped strategies in Set for efficient lookup
+        const stoppedStrategies = new Set();
+        // Subscribe to stop signals and collect them in Set
+        // Filter by both symbol AND walkerName to support multiple walkers on same symbol
+        // connect() returns destructor function
+        const unsubscribe = walkerStopSubject
+            .filter((data) => data.symbol === symbol && data.walkerName === context.walkerName)
+            .connect((data) => {
+            stoppedStrategies.add(data.strategyName);
+            this.loggerService.info("walkerLogicPrivateService received stop signal for strategy", {
                 symbol,
+                walkerName: context.walkerName,
+                strategyName: data.strategyName,
+                stoppedCount: stoppedStrategies.size,
             });
-            const iterator = this.backtestLogicPublicService.run(symbol, {
-                strategyName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-            });
-            pendingStrategy = strategyName;
-            let result;
-            try {
-                result = await Promise.race([
-                    await resolveDocuments(iterator),
-                    listenStop,
-                ]);
-            }
-            catch (error) {
-                console.warn(`walkerLogicPrivateService backtest failed symbol=${symbol} strategyName=${strategyName} exchangeName=${context.exchangeName}`);
-                this.loggerService.warn("walkerLogicPrivateService backtest failed for strategy, skipping", {
+        });
+        try {
+            // Run backtest for each strategy
+            for (const strategyName of strategies) {
+                // Check if this strategy should be stopped before starting
+                if (stoppedStrategies.has(strategyName)) {
+                    this.loggerService.info("walkerLogicPrivateService skipping stopped strategy", {
+                        symbol,
+                        strategyName,
+                    });
+                    break;
+                }
+                // Call onStrategyStart callback if provided
+                if (walkerSchema.callbacks?.onStrategyStart) {
+                    walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
+                }
+                this.loggerService.info("walkerLogicPrivateService testing strategy", {
                     strategyName,
                     symbol,
-                    error: errorData(error), message: getErrorMessage(error),
                 });
-                await errorEmitter.next(error);
-                // Call onStrategyError callback if provided
-                if (walkerSchema.callbacks?.onStrategyError) {
-                    walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+                const iterator = this.backtestLogicPublicService.run(symbol, {
+                    strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                });
+                try {
+                    await resolveDocuments(iterator);
                 }
-                continue;
-            }
-            if (result === CANCEL_SYMBOL) {
-                this.loggerService.info("walkerLogicPrivateService received stop signal, cancelling walker", {
-                    context,
+                catch (error) {
+                    console.warn(`walkerLogicPrivateService backtest failed symbol=${symbol} strategyName=${strategyName} exchangeName=${context.exchangeName}`);
+                    this.loggerService.warn("walkerLogicPrivateService backtest failed for strategy, skipping", {
+                        strategyName,
+                        symbol,
+                        error: errorData(error), message: getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    // Call onStrategyError callback if provided
+                    if (walkerSchema.callbacks?.onStrategyError) {
+                        walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+                    }
+                    continue;
+                }
+                this.loggerService.info("walkerLogicPrivateService backtest complete", {
+                    strategyName,
+                    symbol,
                 });
-                break;
-            }
-            this.loggerService.info("walkerLogicPrivateService backtest complete", {
-                strategyName,
-                symbol,
-            });
-            // Get statistics from BacktestMarkdownService
-            const stats = await this.backtestMarkdownService.getData(symbol, strategyName);
-            // Extract metric value
-            const value = stats[metric];
-            const metricValue = value !== null &&
-                value !== undefined &&
-                typeof value === "number" &&
-                !isNaN(value) &&
-                isFinite(value)
-                ? value
-                : null;
-            // Update best strategy if needed
-            const isBetter = bestMetric === null ||
-                (metricValue !== null && metricValue > bestMetric);
-            if (isBetter && metricValue !== null) {
-                bestMetric = metricValue;
-                bestStrategy = strategyName;
-            }
-            strategiesTested++;
-            const walkerContract = {
-                walkerName: context.walkerName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-                symbol,
-                strategyName,
-                stats,
-                metricValue,
-                metric,
-                bestMetric,
-                bestStrategy,
-                strategiesTested,
-                totalStrategies: strategies.length,
-            };
-            // Emit progress event
-            await progressWalkerEmitter.next({
-                walkerName: context.walkerName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-                symbol,
-                totalStrategies: strategies.length,
-                processedStrategies: strategiesTested,
-                progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
-            });
-            // Call onStrategyComplete callback if provided
-            if (walkerSchema.callbacks?.onStrategyComplete) {
-                walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+                // Get statistics from BacktestMarkdownService
+                const stats = await this.backtestMarkdownService.getData(symbol, strategyName);
+                // Extract metric value
+                const value = stats[metric];
+                const metricValue = value !== null &&
+                    value !== undefined &&
+                    typeof value === "number" &&
+                    !isNaN(value) &&
+                    isFinite(value)
+                    ? value
+                    : null;
+                // Update best strategy if needed
+                const isBetter = bestMetric === null ||
+                    (metricValue !== null && metricValue > bestMetric);
+                if (isBetter && metricValue !== null) {
+                    bestMetric = metricValue;
+                    bestStrategy = strategyName;
+                }
+                strategiesTested++;
+                const walkerContract = {
+                    walkerName: context.walkerName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    symbol,
+                    strategyName,
+                    stats,
+                    metricValue,
+                    metric,
+                    bestMetric,
+                    bestStrategy,
+                    strategiesTested,
+                    totalStrategies: strategies.length,
+                };
+                // Emit progress event
+                await progressWalkerEmitter.next({
+                    walkerName: context.walkerName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    symbol,
+                    totalStrategies: strategies.length,
+                    processedStrategies: strategiesTested,
+                    progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
+                });
+                // Call onStrategyComplete callback if provided
+                if (walkerSchema.callbacks?.onStrategyComplete) {
+                    await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+                }
+                await walkerEmitter.next(walkerContract);
+                yield walkerContract;
             }
-            await walkerEmitter.next(walkerContract);
-            yield walkerContract;
+        }
+        finally {
+            // Unsubscribe from stop signals by calling destructor
+            unsubscribe();
         }
         const finalResults = {
             walkerName: context.walkerName,
@@ -13268,6 +13397,7 @@ async function dumpSignal(signalId, history, signal, outputDir = "./dump/strateg
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
+const BACKTEST_METHOD_NAME_STOP = "BacktestUtils.stop";
 const BACKTEST_METHOD_NAME_GET_REPORT = "BacktestUtils.getReport";
 const BACKTEST_METHOD_NAME_DUMP = "BacktestUtils.dump";
 /**
@@ -13362,7 +13492,7 @@ class BacktestUtils {
             };
             task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, true);
                 backtest$1.strategyGlobalService
                     .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
@@ -13382,6 +13512,30 @@ class BacktestUtils {
                 isStopped = true;
             };
         };
+        /**
+         * Stops the strategy from generating new signals.
+         *
+         * Sets internal flag to prevent strategy from opening new signals.
+         * Current active signal (if any) will complete normally.
+         * Backtest will stop at the next safe point (idle state or after signal closes).
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to stop
+         * @returns Promise that resolves when stop flag is set
+         *
+         * @example
+         * ```typescript
+         * // Stop strategy after some condition
+         * await Backtest.stop("BTCUSDT", "my-strategy");
+         * ```
+         */
+        this.stop = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
+                symbol,
+                strategyName,
+            });
+            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -13470,6 +13624,7 @@ const Backtest = new BacktestUtils();
 
 const LIVE_METHOD_NAME_RUN = "LiveUtils.run";
 const LIVE_METHOD_NAME_BACKGROUND = "LiveUtils.background";
+const LIVE_METHOD_NAME_STOP = "LiveUtils.stop";
 const LIVE_METHOD_NAME_GET_REPORT = "LiveUtils.getReport";
 const LIVE_METHOD_NAME_DUMP = "LiveUtils.dump";
 /**
@@ -13577,7 +13732,7 @@ class LiveUtils {
             };
             task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, false);
                 backtest$1.strategyGlobalService
                     .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
@@ -13597,6 +13752,30 @@ class LiveUtils {
                 isStopped = true;
             };
         };
+        /**
+         * Stops the strategy from generating new signals.
+         *
+         * Sets internal flag to prevent strategy from opening new signals.
+         * Current active signal (if any) will complete normally.
+         * Live trading will stop at the next safe point (idle/closed state).
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to stop
+         * @returns Promise that resolves when stop flag is set
+         *
+         * @example
+         * ```typescript
+         * // Stop live trading gracefully
+         * await Live.stop("BTCUSDT", "my-strategy");
+         * ```
+         */
+        this.stop = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_STOP, {
+                symbol,
+                strategyName,
+            });
+            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, false);
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -13904,6 +14083,7 @@ class Performance {
 
 const WALKER_METHOD_NAME_RUN = "WalkerUtils.run";
 const WALKER_METHOD_NAME_BACKGROUND = "WalkerUtils.background";
+const WALKER_METHOD_NAME_STOP = "WalkerUtils.stop";
 const WALKER_METHOD_NAME_GET_DATA = "WalkerUtils.getData";
 const WALKER_METHOD_NAME_GET_REPORT = "WalkerUtils.getReport";
 const WALKER_METHOD_NAME_DUMP = "WalkerUtils.dump";
@@ -14014,8 +14194,8 @@ class WalkerUtils {
             task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyGlobalService.stop({ symbol, strategyName });
-                    walkerStopSubject.next({ symbol, strategyName });
+                    backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+                    walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
                 }
                 if (!isDone) {
                     doneWalkerSubject.next({
@@ -14029,6 +14209,40 @@ class WalkerUtils {
                 isStopped = true;
             };
         };
+        /**
+         * Stops all strategies in the walker from generating new signals.
+         *
+         * Iterates through all strategies defined in walker schema and:
+         * 1. Sends stop signal via walkerStopSubject (interrupts current running strategy)
+         * 2. Sets internal stop flag for each strategy (prevents new signals)
+         *
+         * Current active signals (if any) will complete normally.
+         * Walker will stop at the next safe point.
+         *
+         * Supports multiple walkers running on the same symbol simultaneously.
+         * Stop signal is filtered by walkerName to prevent interference.
+         *
+         * @param symbol - Trading pair symbol
+         * @param walkerName - Walker name to stop
+         * @returns Promise that resolves when all stop flags are set
+         *
+         * @example
+         * ```typescript
+         * // Stop walker and all its strategies
+         * await Walker.stop("BTCUSDT", "my-walker");
+         * ```
+         */
+        this.stop = async (symbol, walkerName) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_STOP, {
+                symbol,
+                walkerName,
+            });
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            for (const strategyName of walkerSchema.strategies) {
+                await walkerStopSubject.next({ symbol, strategyName, walkerName });
+                await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+            }
+        };
         /**
          * Gets walker results data from all strategy comparisons.
          *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",