backtest-kit 1.5.2 → 1.5.3

package/types.d.ts

@@ -5205,6 +5205,24 @@ declare class BacktestUtils {
         exchangeName: string;
         frameName: string;
     }) => () => void;
+    /**
+     * 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");
+     * ```
+     */
+    stop: (symbol: string, strategyName: StrategyName) => Promise<void>;
     /**
      * Gets statistical data from all closed signals for a symbol-strategy pair.
      *
@@ -5340,6 +5358,24 @@ declare class LiveUtils {
         strategyName: string;
         exchangeName: string;
     }) => () => void;
+    /**
+     * 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");
+     * ```
+     */
+    stop: (symbol: string, strategyName: StrategyName) => Promise<void>;
     /**
      * Gets statistical data from all live trading events for a symbol-strategy pair.
      *
@@ -5647,6 +5683,30 @@ declare class WalkerUtils {
     background: (symbol: string, context: {
         walkerName: string;
     }) => () => void;
+    /**
+     * 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");
+     * ```
+     */
+    stop: (symbol: string, walkerName: WalkerName) => Promise<void>;
     /**
      * Gets walker results data from all strategy comparisons.
      *
@@ -6222,6 +6282,36 @@ declare class ConstantUtils {
  */
 declare const Constant: ConstantUtils;
 
+/**
+ * Contract for walker stop signal events.
+ *
+ * Emitted when Walker.stop() is called to interrupt a running walker.
+ * Contains metadata about which walker and strategy should be stopped.
+ *
+ * Supports multiple walkers running on the same symbol simultaneously
+ * by including walkerName for filtering.
+ *
+ * @example
+ * ```typescript
+ * import { walkerStopSubject } from "backtest-kit";
+ *
+ * walkerStopSubject
+ *   .filter((event) => event.symbol === "BTCUSDT")
+ *   .connect((event) => {
+ *     console.log("Walker stopped:", event.walkerName);
+ *     console.log("Strategy:", event.strategyName);
+ *   });
+ * ```
+ */
+interface WalkerStopContract {
+    /** symbol - Trading symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** strategyName - Name of the strategy to stop */
+    strategyName: StrategyName;
+    /** walkerName - Name of the walker to stop (for filtering) */
+    walkerName: WalkerName;
+}
+
 /**
  * Global signal emitter for all trading events (live + backtest).
  * Emits all signal events regardless of execution mode.
@@ -6296,11 +6386,10 @@ declare const walkerCompleteSubject: Subject<IWalkerResults>;
 /**
  * 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.
  */
-declare const walkerStopSubject: Subject<{
-    symbol: string;
-    strategyName: StrategyName;
-}>;
+declare const walkerStopSubject: Subject<WalkerStopContract>;
 /**
  * Validation emitter for risk validation errors.
  * Emits when risk validation functions throw errors during signal checking.
@@ -6610,6 +6699,17 @@ declare class StrategyConnectionService {
      * @returns Promise resolving to pending signal or null
      */
     getPendingSignal: (symbol: string, strategyName: StrategyName) => Promise<ISignalRow | null>;
+    /**
+     * 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
+     */
+    getStopped: (symbol: string, strategyName: StrategyName) => Promise<boolean>;
     /**
      * Executes live trading tick for current strategy.
      *
@@ -6646,7 +6746,7 @@ declare class StrategyConnectionService {
     stop: (ctx: {
         symbol: string;
         strategyName: StrategyName;
-    }) => Promise<void>;
+    }, backtest: boolean) => Promise<void>;
     /**
      * Clears the memoized ClientStrategy instance from cache.
      *
@@ -7079,6 +7179,17 @@ declare class StrategyGlobalService {
      * @returns Promise resolving to pending signal or null
      */
     getPendingSignal: (symbol: string, strategyName: StrategyName) => Promise<ISignalRow | null>;
+    /**
+     * 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
+     */
+    getStopped: (symbol: string, strategyName: StrategyName) => Promise<boolean>;
     /**
      * Checks signal status at a specific timestamp.
      *
@@ -7117,7 +7228,7 @@ declare class StrategyGlobalService {
     stop: (ctx: {
         symbol: string;
         strategyName: StrategyName;
-    }) => Promise<void>;
+    }, backtest: boolean) => Promise<void>;
     /**
      * Clears the memoized ClientStrategy instance from cache.
      *