backtest-kit 1.5.2 → 1.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",
@@ -74,7 +74,7 @@
   "dependencies": {
     "di-kit": "^1.0.18",
     "di-scoped": "^1.0.20",
-    "functools-kit": "^1.0.93",
+    "functools-kit": "^1.0.94",
     "get-moment-stamp": "^1.1.1",
     "ollama": "^0.6.3"
   }

package/types.d.ts

@@ -5167,6 +5167,11 @@ declare const PersistPartialAdapter: PersistPartialUtils;
  * ```
  */
 declare class BacktestUtils {
+    /**
+     * Memoized function to get or create BacktestInstance for a symbol-strategy pair.
+     * Each symbol-strategy combination gets its own isolated instance.
+     */
+    private _getInstance;
     /**
      * Runs backtest for a symbol with context propagation.
      *
@@ -5205,6 +5210,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.
      *
@@ -5250,6 +5273,24 @@ declare class BacktestUtils {
      * ```
      */
     dump: (symbol: string, strategyName: StrategyName, path?: string) => Promise<void>;
+    /**
+     * Lists all active backtest instances with their current status.
+     *
+     * @returns Promise resolving to array of status objects for all instances
+     *
+     * @example
+     * ```typescript
+     * const statusList = await Backtest.list();
+     * statusList.forEach(status => {
+     *   console.log(`${status.symbol} - ${status.strategyName}: ${status.status}`);
+     * });
+     * ```
+     */
+    list: () => Promise<{
+        symbol: string;
+        strategyName: string;
+        status: "pending" | "fulfilled" | "rejected" | "ready";
+    }[]>;
 }
 /**
  * Singleton instance of BacktestUtils for convenient backtest operations.
@@ -5301,6 +5342,11 @@ declare const Backtest: BacktestUtils;
  * ```
  */
 declare class LiveUtils {
+    /**
+     * Memoized function to get or create LiveInstance for a symbol-strategy pair.
+     * Each symbol-strategy combination gets its own isolated instance.
+     */
+    private _getInstance;
     /**
      * Runs live trading for a symbol with context propagation.
      *
@@ -5340,6 +5386,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.
      *
@@ -5385,6 +5449,24 @@ declare class LiveUtils {
      * ```
      */
     dump: (symbol: string, strategyName: StrategyName, path?: string) => Promise<void>;
+    /**
+     * Lists all active live trading instances with their current status.
+     *
+     * @returns Promise resolving to array of status objects for all instances
+     *
+     * @example
+     * ```typescript
+     * const statusList = await Live.list();
+     * statusList.forEach(status => {
+     *   console.log(`${status.symbol} - ${status.strategyName}: ${status.status}`);
+     * });
+     * ```
+     */
+    list: () => Promise<{
+        symbol: string;
+        strategyName: string;
+        status: "pending" | "fulfilled" | "rejected" | "ready";
+    }[]>;
 }
 /**
  * Singleton instance of LiveUtils for convenient live trading operations.
@@ -5615,6 +5697,11 @@ declare class Performance {
  * ```
  */
 declare class WalkerUtils {
+    /**
+     * Memoized function to get or create WalkerInstance for a symbol-walker pair.
+     * Each symbol-walker combination gets its own isolated instance.
+     */
+    private _getInstance;
     /**
      * Runs walker comparison for a symbol with context propagation.
      *
@@ -5647,6 +5734,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.
      *
@@ -5692,6 +5803,24 @@ declare class WalkerUtils {
      * ```
      */
     dump: (symbol: string, walkerName: WalkerName, path?: string) => Promise<void>;
+    /**
+     * Lists all active walker instances with their current status.
+     *
+     * @returns Promise resolving to array of status objects for all instances
+     *
+     * @example
+     * ```typescript
+     * const statusList = await Walker.list();
+     * statusList.forEach(status => {
+     *   console.log(`${status.symbol} - ${status.walkerName}: ${status.status}`);
+     * });
+     * ```
+     */
+    list: () => Promise<{
+        symbol: string;
+        walkerName: string;
+        status: "pending" | "fulfilled" | "rejected" | "ready";
+    }[]>;
 }
 /**
  * Singleton instance of WalkerUtils for convenient walker operations.
@@ -6222,6 +6351,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 +6455,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 +6768,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 +6815,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 +7248,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 +7297,7 @@ declare class StrategyGlobalService {
     stop: (ctx: {
         symbol: string;
         strategyName: StrategyName;
-    }) => Promise<void>;
+    }, backtest: boolean) => Promise<void>;
     /**
      * Clears the memoized ClientStrategy instance from cache.
      *