backtest-kit 1.5.3 → 1.5.4

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, and, 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, singlerun } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
@@ -13400,17 +13400,50 @@ 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";
+const BACKTEST_METHOD_NAME_TASK = "BacktestUtils.task";
+const BACKTEST_METHOD_NAME_GET_STATUS = "BacktestUtils.getStatus";
 /**
- * Utility class for backtest operations.
+ * Internal task function that runs backtest and handles completion.
+ * Consumes backtest results and updates instance state flags.
  *
- * Provides simplified access to backtestCommandService.run() with logging.
- * Exported as singleton instance for convenient usage.
+ * @param symbol - Trading pair symbol
+ * @param context - Execution context with strategy, exchange, and frame names
+ * @param self - BacktestInstance reference for state management
+ * @returns Promise that resolves when backtest completes
+ *
+ * @internal
+ */
+const INSTANCE_TASK_FN$2 = async (symbol, context, self) => {
+    {
+        self._isStopped = false;
+        self._isDone = false;
+    }
+    for await (const _ of self.run(symbol, context)) {
+        if (self._isStopped) {
+            break;
+        }
+    }
+    if (!self._isDone) {
+        await doneBacktestSubject.next({
+            exchangeName: context.exchangeName,
+            strategyName: context.strategyName,
+            backtest: true,
+            symbol,
+        });
+    }
+    self._isDone = true;
+};
+/**
+ * Instance class for backtest operations on a specific symbol-strategy pair.
+ *
+ * Provides isolated backtest execution and reporting for a single symbol-strategy combination.
+ * Each instance maintains its own state and context.
  *
  * @example
  * ```typescript
- * import { Backtest } from "./classes/Backtest";
+ * const instance = new BacktestInstance("BTCUSDT", "my-strategy");
  *
- * for await (const result of Backtest.run("BTCUSDT", {
+ * for await (const result of instance.run("BTCUSDT", {
  *   strategyName: "my-strategy",
  *   exchangeName: "my-exchange",
  *   frameName: "1d-backtest"
@@ -13419,8 +13452,57 @@ const BACKTEST_METHOD_NAME_DUMP = "BacktestUtils.dump";
  * }
  * ```
  */
-class BacktestUtils {
-    constructor() {
+class BacktestInstance {
+    /**
+     * Creates a new BacktestInstance for a specific symbol-strategy pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Strategy name for this backtest instance
+     */
+    constructor(symbol, strategyName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        /** Internal flag indicating if backtest was stopped manually */
+        this._isStopped = false;
+        /** Internal flag indicating if backtest task completed */
+        this._isDone = false;
+        /**
+         * Internal singlerun task that executes the backtest.
+         * Ensures only one backtest run per instance using singlerun wrapper.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategy, exchange, and frame names
+         * @returns Promise that resolves when backtest completes
+         *
+         * @internal
+         */
+        this.task = singlerun(async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
+                symbol,
+                context,
+            });
+            return await INSTANCE_TASK_FN$2(symbol, context, this);
+        });
+        /**
+         * Gets the current status of this backtest instance.
+         *
+         * @returns Promise resolving to status object with symbol, strategyName, and task status
+         *
+         * @example
+         * ```typescript
+         * const instance = new BacktestInstance("BTCUSDT", "my-strategy");
+         * const status = await instance.getStatus();
+         * console.log(status.status); // "idle", "running", or "done"
+         * ```
+         */
+        this.getStatus = async () => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_STATUS);
+            return {
+                symbol: this.symbol,
+                strategyName: this.strategyName,
+                status: this.task.getStatus(),
+            };
+        };
         /**
          * Runs backtest for a symbol with context propagation.
          *
@@ -13458,13 +13540,12 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * // Run backtest silently, only callbacks will fire
-         * await Backtest.background("BTCUSDT", {
+         * const instance = new BacktestInstance();
+         * const cancel = instance.background("BTCUSDT", {
          *   strategyName: "my-strategy",
          *   exchangeName: "my-exchange",
          *   frameName: "1d-backtest"
          * });
-         * console.log("Backtest completed");
          * ```
          */
         this.background = (symbol, context) => {
@@ -13472,25 +13553,7 @@ class BacktestUtils {
                 symbol,
                 context,
             });
-            let isStopped = false;
-            let isDone = false;
-            const task = async () => {
-                for await (const _ of this.run(symbol, context)) {
-                    if (isStopped) {
-                        break;
-                    }
-                }
-                if (!isDone) {
-                    await doneBacktestSubject.next({
-                        exchangeName: context.exchangeName,
-                        strategyName: context.strategyName,
-                        backtest: true,
-                        symbol,
-                    });
-                }
-                isDone = true;
-            };
-            task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, true);
                 backtest$1.strategyGlobalService
@@ -13499,7 +13562,7 @@ class BacktestUtils {
                     if (pendingSignal) {
                         return;
                     }
-                    if (!isDone) {
+                    if (!this._isDone) {
                         await doneBacktestSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
@@ -13507,9 +13570,9 @@ class BacktestUtils {
                             symbol,
                         });
                     }
-                    isDone = true;
+                    this._isDone = true;
                 });
-                isStopped = true;
+                this._isStopped = true;
             };
         };
         /**
@@ -13525,8 +13588,8 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * // Stop strategy after some condition
-         * await Backtest.stop("BTCUSDT", "my-strategy");
+         * const instance = new BacktestInstance();
+         * await instance.stop("BTCUSDT", "my-strategy");
          * ```
          */
         this.stop = async (symbol, strategyName) => {
@@ -13545,7 +13608,8 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * const stats = await Backtest.getData("BTCUSDT", "my-strategy");
+         * const instance = new BacktestInstance();
+         * const stats = await instance.getData("BTCUSDT", "my-strategy");
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
@@ -13565,7 +13629,8 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * const markdown = await Backtest.getReport("BTCUSDT", "my-strategy");
+         * const instance = new BacktestInstance();
+         * const markdown = await instance.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
@@ -13585,11 +13650,12 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
+         * const instance = new BacktestInstance();
          * // Save to default path: ./dump/backtest/my-strategy.md
-         * await Backtest.dump("BTCUSDT", "my-strategy");
+         * await instance.dump("BTCUSDT", "my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await Backtest.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
         this.dump = async (symbol, strategyName, path) => {
@@ -13602,6 +13668,162 @@ class BacktestUtils {
         };
     }
 }
+/**
+ * Utility class for backtest operations.
+ *
+ * Provides simplified access to backtestCommandService.run() with logging.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Backtest } from "./classes/Backtest";
+ *
+ * for await (const result of Backtest.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ *   frameName: "1d-backtest"
+ * })) {
+ *   console.log("Closed signal PNL:", result.pnl.pnlPercentage);
+ * }
+ * ```
+ */
+class BacktestUtils {
+    constructor() {
+        /**
+         * Memoized function to get or create BacktestInstance for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated instance.
+         */
+        this._getInstance = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => new BacktestInstance(symbol, strategyName));
+        /**
+         * Runs backtest for a symbol with context propagation.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with strategy, exchange, and frame names
+         * @returns Async generator yielding closed signals with PNL
+         */
+        this.run = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.run(symbol, context);
+        };
+        /**
+         * Runs backtest in background without yielding results.
+         *
+         * Consumes all backtest results internally without exposing them.
+         * Useful for running backtests for side effects only (callbacks, logging).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with strategy, exchange, and frame names
+         * @returns Cancellation closure
+         *
+         * @example
+         * ```typescript
+         * // Run backtest silently, only callbacks will fire
+         * await Backtest.background("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "my-exchange",
+         *   frameName: "1d-backtest"
+         * });
+         * console.log("Backtest completed");
+         * ```
+         */
+        this.background = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.background(symbol, context);
+        };
+        /**
+         * 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) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.stop(symbol, strategyName);
+        };
+        /**
+         * Gets statistical data from all closed signals for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to get data for
+         * @returns Promise resolving to statistical data object
+         *
+         * @example
+         * ```typescript
+         * const stats = await Backtest.getData("BTCUSDT", "my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (symbol, strategyName) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getData(symbol, strategyName);
+        };
+        /**
+         * Generates markdown report with all closed signals for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to generate report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Backtest.getReport("BTCUSDT", "my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, strategyName) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName);
+        };
+        /**
+         * Saves strategy report to disk.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to save report for
+         * @param path - Optional directory path to save report (default: "./dump/backtest")
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./dump/backtest/my-strategy.md
+         * await Backtest.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./custom/path/my-strategy.md
+         * await Backtest.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, strategyName, path) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.dump(symbol, strategyName, path);
+        };
+        /**
+         * 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}`);
+         * });
+         * ```
+         */
+        this.list = async () => {
+            const instanceList = this._getInstance.values();
+            return await Promise.all(instanceList.map((instance) => instance.getStatus()));
+        };
+    }
+}
 /**
  * Singleton instance of BacktestUtils for convenient backtest operations.
  *
@@ -13627,37 +13849,110 @@ 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";
+const LIVE_METHOD_NAME_TASK = "LiveUtils.task";
+const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
 /**
- * Utility class for live trading operations.
+ * Internal task function that runs live trading and handles completion.
+ * Consumes live trading results and updates instance state flags.
  *
- * Provides simplified access to liveCommandService.run() with logging.
- * Exported as singleton instance for convenient usage.
+ * @param symbol - Trading pair symbol
+ * @param context - Execution context with strategy and exchange names
+ * @param self - LiveInstance reference for state management
+ * @returns Promise that resolves when live trading completes
  *
- * Features:
- * - Infinite async generator (never completes)
- * - Crash recovery via persisted state
- * - Real-time progression with Date.now()
+ * @internal
+ */
+const INSTANCE_TASK_FN$1 = async (symbol, context, self) => {
+    {
+        self._isStopped = false;
+        self._isDone = false;
+    }
+    for await (const signal of self.run(symbol, context)) {
+        if (signal?.action === "closed" && self._isStopped) {
+            break;
+        }
+    }
+    if (!self._isDone) {
+        await doneLiveSubject.next({
+            exchangeName: context.exchangeName,
+            strategyName: context.strategyName,
+            backtest: false,
+            symbol,
+        });
+    }
+    self._isDone = true;
+};
+/**
+ * Instance class for live trading operations on a specific symbol-strategy pair.
+ *
+ * Provides isolated live trading execution and reporting for a single symbol-strategy combination.
+ * Each instance maintains its own state and context.
  *
  * @example
  * ```typescript
- * import { Live } from "./classes/Live";
+ * const instance = new LiveInstance("BTCUSDT", "my-strategy");
  *
- * // Infinite loop - use Ctrl+C to stop
- * for await (const result of Live.run("BTCUSDT", {
+ * for await (const result of instance.run("BTCUSDT", {
  *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- *   frameName: ""
+ *   exchangeName: "my-exchange"
  * })) {
- *   if (result.action === "opened") {
- *     console.log("Signal opened:", result.signal);
- *   } else if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.pnlPercentage);
+ *   if (result.action === "closed") {
+ *     console.log("Signal closed, PNL:", result.pnl.pnlPercentage);
  *   }
  * }
  * ```
  */
-class LiveUtils {
-    constructor() {
+class LiveInstance {
+    /**
+     * Creates a new LiveInstance for a specific symbol-strategy pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Strategy name for this live trading instance
+     */
+    constructor(symbol, strategyName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        /** Internal flag indicating if live trading was stopped manually */
+        this._isStopped = false;
+        /** Internal flag indicating if live trading task completed */
+        this._isDone = false;
+        /**
+         * Internal singlerun task that executes the live trading.
+         * Ensures only one live trading run per instance using singlerun wrapper.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategy and exchange names
+         * @returns Promise that resolves when live trading completes
+         *
+         * @internal
+         */
+        this.task = singlerun(async (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_TASK, {
+                symbol,
+                context,
+            });
+            return await INSTANCE_TASK_FN$1(symbol, context, this);
+        });
+        /**
+         * Gets the current status of this live trading instance.
+         *
+         * @returns Promise resolving to status object with symbol, strategyName, and task status
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance("BTCUSDT", "my-strategy");
+         * const status = await instance.getStatus();
+         * console.log(status.status); // "idle", "running", or "done"
+         * ```
+         */
+        this.getStatus = async () => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_STATUS);
+            return {
+                symbol: this.symbol,
+                strategyName: this.strategyName,
+                status: this.task.getStatus(),
+            };
+        };
         /**
          * Runs live trading for a symbol with context propagation.
          *
@@ -13699,9 +13994,8 @@ class LiveUtils {
          *
          * @example
          * ```typescript
-         * // Run live trading silently in background, only callbacks will fire
-         * // This will run forever until Ctrl+C
-         * await Live.background("BTCUSDT", {
+         * const instance = new LiveInstance();
+         * const cancel = instance.background("BTCUSDT", {
          *   strategyName: "my-strategy",
          *   exchangeName: "my-exchange"
          * });
@@ -13712,25 +14006,7 @@ class LiveUtils {
                 symbol,
                 context,
             });
-            let isStopped = false;
-            let isDone = false;
-            const task = async () => {
-                for await (const signal of this.run(symbol, context)) {
-                    if (signal?.action === "closed" && isStopped) {
-                        break;
-                    }
-                }
-                if (!isDone) {
-                    await doneLiveSubject.next({
-                        exchangeName: context.exchangeName,
-                        strategyName: context.strategyName,
-                        backtest: false,
-                        symbol,
-                    });
-                }
-                isDone = true;
-            };
-            task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, false);
                 backtest$1.strategyGlobalService
@@ -13739,7 +14015,7 @@ class LiveUtils {
                     if (pendingSignal) {
                         return;
                     }
-                    if (!isDone) {
+                    if (!this._isDone) {
                         await doneLiveSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
@@ -13747,11 +14023,179 @@ class LiveUtils {
                             symbol,
                         });
                     }
-                    isDone = true;
+                    this._isDone = true;
                 });
-                isStopped = true;
+                this._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
+         * const instance = new LiveInstance();
+         * await instance.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.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to get data for
+         * @returns Promise resolving to statistical data object
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * const stats = await instance.getData("BTCUSDT", "my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (symbol, strategyName) => {
+            backtest$1.loggerService.info("LiveUtils.getData", {
+                symbol,
+                strategyName,
+            });
+            return await backtest$1.liveMarkdownService.getData(symbol, strategyName);
+        };
+        /**
+         * Generates markdown report with all events for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to generate report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * const markdown = await instance.getReport("BTCUSDT", "my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
+                symbol,
+                strategyName,
+            });
+            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName);
+        };
+        /**
+         * Saves strategy report to disk.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to save report for
+         * @param path - Optional directory path to save report (default: "./dump/live")
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * // Save to default path: ./dump/live/my-strategy.md
+         * await instance.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./custom/path/my-strategy.md
+         * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, strategyName, path) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
+                symbol,
+                strategyName,
+                path,
+            });
+            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path);
+        };
+    }
+}
+/**
+ * Utility class for live trading operations.
+ *
+ * Provides simplified access to liveCommandService.run() with logging.
+ * Exported as singleton instance for convenient usage.
+ *
+ * Features:
+ * - Infinite async generator (never completes)
+ * - Crash recovery via persisted state
+ * - Real-time progression with Date.now()
+ *
+ * @example
+ * ```typescript
+ * import { Live } from "./classes/Live";
+ *
+ * // Infinite loop - use Ctrl+C to stop
+ * for await (const result of Live.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ *   frameName: ""
+ * })) {
+ *   if (result.action === "opened") {
+ *     console.log("Signal opened:", result.signal);
+ *   } else if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.pnlPercentage);
+ *   }
+ * }
+ * ```
+ */
+class LiveUtils {
+    constructor() {
+        /**
+         * Memoized function to get or create LiveInstance for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated instance.
+         */
+        this._getInstance = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => new LiveInstance(symbol, strategyName));
+        /**
+         * Runs live trading for a symbol with context propagation.
+         *
+         * Infinite async generator with crash recovery support.
+         * Process can crash and restart - state will be recovered from disk.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with strategy and exchange names
+         * @returns Infinite async generator yielding opened and closed signals
+         */
+        this.run = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.run(symbol, context);
+        };
+        /**
+         * Runs live trading in background without yielding results.
+         *
+         * Consumes all live trading results internally without exposing them.
+         * Infinite loop - will run until process is stopped or crashes.
+         * Useful for running live trading for side effects only (callbacks, persistence).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with strategy and exchange names
+         * @returns Cancellation closure
+         *
+         * @example
+         * ```typescript
+         * // Run live trading silently in background, only callbacks will fire
+         * // This will run forever until Ctrl+C
+         * await Live.background("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "my-exchange"
+         * });
+         * ```
+         */
+        this.background = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.background(symbol, context);
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -13770,11 +14214,8 @@ class LiveUtils {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_STOP, {
-                symbol,
-                strategyName,
-            });
-            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, false);
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.stop(symbol, strategyName);
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
@@ -13790,11 +14231,8 @@ class LiveUtils {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info("LiveUtils.getData", {
-                symbol,
-                strategyName,
-            });
-            return await backtest$1.liveMarkdownService.getData(symbol, strategyName);
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getData(symbol, strategyName);
         };
         /**
          * Generates markdown report with all events for a symbol-strategy pair.
@@ -13810,11 +14248,8 @@ class LiveUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
-                symbol,
-                strategyName,
-            });
-            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName);
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName);
         };
         /**
          * Saves strategy report to disk.
@@ -13833,12 +14268,25 @@ class LiveUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, path) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
-                symbol,
-                strategyName,
-                path,
-            });
-            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path);
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.dump(symbol, strategyName, path);
+        };
+        /**
+         * 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}`);
+         * });
+         * ```
+         */
+        this.list = async () => {
+            const instanceList = this._getInstance.values();
+            return await Promise.all(instanceList.map((instance) => instance.getStatus()));
         };
     }
 }
@@ -14087,27 +14535,108 @@ 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";
+const WALKER_METHOD_NAME_TASK = "WalkerUtils.task";
+const WALKER_METHOD_NAME_GET_STATUS = "WalkerUtils.getStatus";
 /**
- * Utility class for walker operations.
+ * Internal task function that runs walker and handles completion.
+ * Consumes walker results and updates instance state flags.
  *
- * Provides simplified access to walkerCommandService.run() with logging.
- * Automatically pulls exchangeName and frameName from walker schema.
- * Exported as singleton instance for convenient usage.
+ * @param symbol - Trading pair symbol
+ * @param context - Execution context with walker name
+ * @param self - WalkerInstance reference for state management
+ * @returns Promise that resolves when walker completes
+ *
+ * @internal
+ */
+const INSTANCE_TASK_FN = async (symbol, context, self) => {
+    {
+        self._isStopped = false;
+        self._isDone = false;
+    }
+    for await (const _ of self.run(symbol, context)) {
+        if (self._isStopped) {
+            break;
+        }
+    }
+    if (!self._isDone) {
+        const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+        await doneWalkerSubject.next({
+            exchangeName: walkerSchema.exchangeName,
+            strategyName: context.walkerName,
+            backtest: true,
+            symbol,
+        });
+    }
+    self._isDone = true;
+};
+/**
+ * Instance class for walker operations on a specific symbol-walker pair.
+ *
+ * Provides isolated walker execution and reporting for a single symbol-walker combination.
+ * Each instance maintains its own state and context.
  *
  * @example
  * ```typescript
- * import { Walker } from "./classes/Walker";
+ * const instance = new WalkerInstance("BTCUSDT", "my-walker");
  *
- * for await (const result of Walker.run("BTCUSDT", {
+ * for await (const result of instance.run("BTCUSDT", {
  *   walkerName: "my-walker"
  * })) {
  *   console.log("Progress:", result.strategiesTested, "/", result.totalStrategies);
- *   console.log("Best strategy:", result.bestStrategy, result.bestMetric);
  * }
  * ```
  */
-class WalkerUtils {
-    constructor() {
+class WalkerInstance {
+    /**
+     * Creates a new WalkerInstance for a specific symbol-walker pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param walkerName - Walker name for this walker instance
+     */
+    constructor(symbol, walkerName) {
+        this.symbol = symbol;
+        this.walkerName = walkerName;
+        /** Internal flag indicating if walker was stopped manually */
+        this._isStopped = false;
+        /** Internal flag indicating if walker task completed */
+        this._isDone = false;
+        /**
+         * Internal singlerun task that executes the walker.
+         * Ensures only one walker run per instance using singlerun wrapper.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with walker name
+         * @returns Promise that resolves when walker completes
+         *
+         * @internal
+         */
+        this.task = singlerun(async (symbol, context) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_TASK, {
+                symbol,
+                context,
+            });
+            return await INSTANCE_TASK_FN(symbol, context, this);
+        });
+        /**
+         * Gets the current status of this walker instance.
+         *
+         * @returns Promise resolving to status object with symbol, walkerName, and task status
+         *
+         * @example
+         * ```typescript
+         * const instance = new WalkerInstance("BTCUSDT", "my-walker");
+         * const status = await instance.getStatus();
+         * console.log(status.status); // "idle", "running", or "done"
+         * ```
+         */
+        this.getStatus = async () => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_STATUS);
+            return {
+                symbol: this.symbol,
+                walkerName: this.walkerName,
+                status: this.task.getStatus(),
+            };
+        };
         /**
          * Runs walker comparison for a symbol with context propagation.
          *
@@ -14160,11 +14689,10 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
-         * // Run walker silently, only callbacks will fire
-         * await Walker.background("BTCUSDT", {
+         * const instance = new WalkerInstance();
+         * const cancel = instance.background("BTCUSDT", {
          *   walkerName: "my-walker"
          * });
-         * console.log("Walker comparison completed");
          * ```
          */
         this.background = (symbol, context) => {
@@ -14173,31 +14701,13 @@ class WalkerUtils {
                 context,
             });
             const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
-            let isStopped = false;
-            let isDone = false;
-            const task = async () => {
-                for await (const _ of this.run(symbol, context)) {
-                    if (isStopped) {
-                        break;
-                    }
-                }
-                if (!isDone) {
-                    await doneWalkerSubject.next({
-                        exchangeName: walkerSchema.exchangeName,
-                        strategyName: context.walkerName,
-                        backtest: true,
-                        symbol,
-                    });
-                }
-                isDone = true;
-            };
-            task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
                     backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
                     walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
                 }
-                if (!isDone) {
+                if (!this._isDone) {
                     doneWalkerSubject.next({
                         exchangeName: walkerSchema.exchangeName,
                         strategyName: context.walkerName,
@@ -14205,8 +14715,8 @@ class WalkerUtils {
                         symbol,
                     });
                 }
-                isDone = true;
-                isStopped = true;
+                this._isDone = true;
+                this._isStopped = true;
             };
         };
         /**
@@ -14228,8 +14738,8 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
-         * // Stop walker and all its strategies
-         * await Walker.stop("BTCUSDT", "my-walker");
+         * const instance = new WalkerInstance();
+         * await instance.stop("BTCUSDT", "my-walker");
          * ```
          */
         this.stop = async (symbol, walkerName) => {
@@ -14252,7 +14762,8 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
-         * const results = await Walker.getData("BTCUSDT", "my-walker");
+         * const instance = new WalkerInstance();
+         * const results = await instance.getData("BTCUSDT", "my-walker");
          * console.log(results.bestStrategy, results.bestMetric);
          * ```
          */
@@ -14276,7 +14787,8 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
-         * const markdown = await Walker.getReport("BTCUSDT", "my-walker");
+         * const instance = new WalkerInstance();
+         * const markdown = await instance.getReport("BTCUSDT", "my-walker");
          * console.log(markdown);
          * ```
          */
@@ -14300,11 +14812,12 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
+         * const instance = new WalkerInstance();
          * // Save to default path: ./dump/walker/my-walker.md
-         * await Walker.dump("BTCUSDT", "my-walker");
+         * await instance.dump("BTCUSDT", "my-walker");
          *
          * // Save to custom path: ./custom/path/my-walker.md
-         * await Walker.dump("BTCUSDT", "my-walker", "./custom/path");
+         * await instance.dump("BTCUSDT", "my-walker", "./custom/path");
          * ```
          */
         this.dump = async (symbol, walkerName, path) => {
@@ -14321,6 +14834,166 @@ class WalkerUtils {
         };
     }
 }
+/**
+ * Utility class for walker operations.
+ *
+ * Provides simplified access to walkerCommandService.run() with logging.
+ * Automatically pulls exchangeName and frameName from walker schema.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Walker } from "./classes/Walker";
+ *
+ * for await (const result of Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker"
+ * })) {
+ *   console.log("Progress:", result.strategiesTested, "/", result.totalStrategies);
+ *   console.log("Best strategy:", result.bestStrategy, result.bestMetric);
+ * }
+ * ```
+ */
+class WalkerUtils {
+    constructor() {
+        /**
+         * Memoized function to get or create WalkerInstance for a symbol-walker pair.
+         * Each symbol-walker combination gets its own isolated instance.
+         */
+        this._getInstance = memoize(([symbol, walkerName]) => `${symbol}:${walkerName}`, (symbol, walkerName) => new WalkerInstance(symbol, walkerName));
+        /**
+         * Runs walker comparison for a symbol with context propagation.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with walker name
+         * @returns Async generator yielding progress updates after each strategy
+         */
+        this.run = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.walkerName);
+            return instance.run(symbol, context);
+        };
+        /**
+         * Runs walker comparison in background without yielding results.
+         *
+         * Consumes all walker progress updates internally without exposing them.
+         * Useful for running walker comparison for side effects only (callbacks, logging).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with walker name
+         * @returns Cancellation closure
+         *
+         * @example
+         * ```typescript
+         * // Run walker silently, only callbacks will fire
+         * await Walker.background("BTCUSDT", {
+         *   walkerName: "my-walker"
+         * });
+         * console.log("Walker comparison completed");
+         * ```
+         */
+        this.background = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.walkerName);
+            return instance.background(symbol, context);
+        };
+        /**
+         * 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) => {
+            const instance = this._getInstance(symbol, walkerName);
+            return await instance.stop(symbol, walkerName);
+        };
+        /**
+         * Gets walker results data from all strategy comparisons.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to get data for
+         * @returns Promise resolving to walker results data object
+         *
+         * @example
+         * ```typescript
+         * const results = await Walker.getData("BTCUSDT", "my-walker");
+         * console.log(results.bestStrategy, results.bestMetric);
+         * ```
+         */
+        this.getData = async (symbol, walkerName) => {
+            const instance = this._getInstance(symbol, walkerName);
+            return await instance.getData(symbol, walkerName);
+        };
+        /**
+         * Generates markdown report with all strategy comparisons for a walker.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to generate report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Walker.getReport("BTCUSDT", "my-walker");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, walkerName) => {
+            const instance = this._getInstance(symbol, walkerName);
+            return await instance.getReport(symbol, walkerName);
+        };
+        /**
+         * Saves walker report to disk.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to save report for
+         * @param path - Optional directory path to save report (default: "./dump/walker")
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./dump/walker/my-walker.md
+         * await Walker.dump("BTCUSDT", "my-walker");
+         *
+         * // Save to custom path: ./custom/path/my-walker.md
+         * await Walker.dump("BTCUSDT", "my-walker", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, walkerName, path) => {
+            const instance = this._getInstance(symbol, walkerName);
+            return await instance.dump(symbol, walkerName, path);
+        };
+        /**
+         * 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}`);
+         * });
+         * ```
+         */
+        this.list = async () => {
+            const instanceList = this._getInstance.values();
+            return await Promise.all(instanceList.map((instance) => instance.getStatus()));
+        };
+    }
+}
 /**
  * Singleton instance of WalkerUtils for convenient walker operations.
  *