backtest-kit 1.5.3 → 1.5.5

package/build/index.cjs

@@ -3179,15 +3179,17 @@ class ClientStrategy {
             backtest,
         });
         this._isStopped = true;
-        // Clear scheduled signal if exists
-        if (!this._scheduledSignal) {
+        if (!this._pendingSignal) {
             return;
         }
-        this._scheduledSignal = null;
+        this._pendingSignal = null;
+        if (this.params.callbacks?.onWrite) {
+            this.params.callbacks.onWrite(symbol, this._pendingSignal, backtest);
+        }
         if (backtest) {
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, this.params.execution.context.symbol, this.params.strategyName);
+        await PersistScheduleAdapter.writeScheduleData(this._pendingSignal, symbol, strategyName);
     }
 }
 
@@ -13402,17 +13404,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"
@@ -13421,8 +13456,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 = functoolsKit.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.
          *
@@ -13460,13 +13544,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) => {
@@ -13474,25 +13557,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(functoolsKit.getErrorMessage(error))));
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, true);
                 backtest$1.strategyGlobalService
@@ -13501,7 +13566,7 @@ class BacktestUtils {
                     if (pendingSignal) {
                         return;
                     }
-                    if (!isDone) {
+                    if (!this._isDone) {
                         await doneBacktestSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
@@ -13509,9 +13574,9 @@ class BacktestUtils {
                             symbol,
                         });
                     }
-                    isDone = true;
+                    this._isDone = true;
                 });
-                isStopped = true;
+                this._isStopped = true;
             };
         };
         /**
@@ -13527,8 +13592,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) => {
@@ -13547,7 +13612,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);
          * ```
          */
@@ -13567,7 +13633,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);
          * ```
          */
@@ -13587,11 +13654,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) => {
@@ -13605,7 +13673,10 @@ class BacktestUtils {
     }
 }
 /**
- * Singleton instance of BacktestUtils for convenient backtest operations.
+ * Utility class for backtest operations.
+ *
+ * Provides simplified access to backtestCommandService.run() with logging.
+ * Exported as singleton instance for convenient usage.
  *
  * @example
  * ```typescript
@@ -13616,150 +13687,59 @@ class BacktestUtils {
  *   exchangeName: "my-exchange",
  *   frameName: "1d-backtest"
  * })) {
- *   if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.pnlPercentage);
- *   }
- * }
- * ```
- */
-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";
-/**
- * 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);
- *   }
+ *   console.log("Closed signal PNL:", result.pnl.pnlPercentage);
  * }
  * ```
  */
-class LiveUtils {
+class BacktestUtils {
     constructor() {
         /**
-         * 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.
+         * Memoized function to get or create BacktestInstance for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated instance.
+         */
+        this._getInstance = functoolsKit.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 and exchange names
-         * @returns Infinite async generator yielding opened and closed signals
+         * @param context - Execution context with strategy, exchange, and frame names
+         * @returns Async generator yielding closed signals with PNL
          */
         this.run = (symbol, context) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_RUN, {
-                symbol,
-                context,
-            });
-            {
-                backtest$1.liveMarkdownService.clear({ symbol, strategyName: context.strategyName });
-                backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
-            }
-            {
-                backtest$1.strategyGlobalService.clear({ symbol, strategyName: context.strategyName });
-            }
-            {
-                const { riskName } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(riskName);
-            }
-            return backtest$1.liveCommandService.run(symbol, context);
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.run(symbol, context);
         };
         /**
-         * Runs live trading in background without yielding results.
+         * Runs backtest 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).
+         * 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 and exchange names
+         * @param context - Execution context with strategy, exchange, and frame 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", {
+         * // Run backtest silently, only callbacks will fire
+         * await Backtest.background("BTCUSDT", {
          *   strategyName: "my-strategy",
-         *   exchangeName: "my-exchange"
+         *   exchangeName: "my-exchange",
+         *   frameName: "1d-backtest"
          * });
+         * console.log("Backtest completed");
          * ```
          */
         this.background = (symbol, context) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_BACKGROUND, {
-                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(functoolsKit.getErrorMessage(error))));
-            return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, false);
-                backtest$1.strategyGlobalService
-                    .getPendingSignal(symbol, context.strategyName)
-                    .then(async (pendingSignal) => {
-                    if (pendingSignal) {
-                        return;
-                    }
-                    if (!isDone) {
-                        await doneLiveSubject.next({
-                            exchangeName: context.exchangeName,
-                            strategyName: context.strategyName,
-                            backtest: false,
-                            symbol,
-                        });
-                    }
-                    isDone = true;
-                });
-                isStopped = true;
-            };
+            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.
-         * Live trading will stop at the next safe point (idle/closed state).
+         * 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
@@ -13767,19 +13747,16 @@ class LiveUtils {
          *
          * @example
          * ```typescript
-         * // Stop live trading gracefully
-         * await Live.stop("BTCUSDT", "my-strategy");
+         * // Stop strategy after some condition
+         * await Backtest.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);
+            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.
+         * 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
@@ -13787,19 +13764,16 @@ class LiveUtils {
          *
          * @example
          * ```typescript
-         * const stats = await Live.getData("BTCUSDT", "my-strategy");
+         * const stats = await Backtest.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);
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getData(symbol, strategyName);
         };
         /**
-         * Generates markdown report with all events for a symbol-strategy pair.
+         * 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
@@ -13807,59 +13781,535 @@ class LiveUtils {
          *
          * @example
          * ```typescript
-         * const markdown = await Live.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await Backtest.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);
+            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/live")
+         * @param path - Optional directory path to save report (default: "./dump/backtest")
          *
          * @example
          * ```typescript
-         * // Save to default path: ./dump/live/my-strategy.md
-         * await Live.dump("BTCUSDT", "my-strategy");
+         * // 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 Live.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await Backtest.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);
+            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 LiveUtils for convenient live trading operations.
+ * Singleton instance of BacktestUtils for convenient backtest operations.
  *
  * @example
  * ```typescript
- * import { Live } from "./classes/Live";
+ * import { Backtest } from "./classes/Backtest";
  *
- * for await (const result of Live.run("BTCUSDT", {
+ * for await (const result of Backtest.run("BTCUSDT", {
  *   strategyName: "my-strategy",
  *   exchangeName: "my-exchange",
+ *   frameName: "1d-backtest"
  * })) {
- *   console.log("Result:", result.action);
+ *   if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.pnlPercentage);
+ *   }
  * }
  * ```
  */
-const Live = new LiveUtils();
+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";
+const LIVE_METHOD_NAME_TASK = "LiveUtils.task";
+const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
+/**
+ * Internal task function that runs live trading and handles completion.
+ * Consumes live trading results and updates instance state flags.
+ *
+ * @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
+ *
+ * @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
+ * const instance = new LiveInstance("BTCUSDT", "my-strategy");
+ *
+ * for await (const result of instance.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange"
+ * })) {
+ *   if (result.action === "closed") {
+ *     console.log("Signal closed, PNL:", result.pnl.pnlPercentage);
+ *   }
+ * }
+ * ```
+ */
+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 = functoolsKit.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.
+         *
+         * 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) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_RUN, {
+                symbol,
+                context,
+            });
+            {
+                backtest$1.liveMarkdownService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
+            }
+            {
+                backtest$1.strategyGlobalService.clear({ symbol, strategyName: context.strategyName });
+            }
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskGlobalService.clear(riskName);
+            }
+            return backtest$1.liveCommandService.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
+         * const instance = new LiveInstance();
+         * const cancel = instance.background("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "my-exchange"
+         * });
+         * ```
+         */
+        this.background = (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_BACKGROUND, {
+                symbol,
+                context,
+            });
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
+            return () => {
+                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, false);
+                backtest$1.strategyGlobalService
+                    .getPendingSignal(symbol, context.strategyName)
+                    .then(async (pendingSignal) => {
+                    if (pendingSignal) {
+                        return;
+                    }
+                    if (!this._isDone) {
+                        await doneLiveSubject.next({
+                            exchangeName: context.exchangeName,
+                            strategyName: context.strategyName,
+                            backtest: false,
+                            symbol,
+                        });
+                    }
+                    this._isDone = 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 = functoolsKit.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.
+         *
+         * 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) => {
+            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.
+         *
+         * @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 Live.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 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 markdown = await Live.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/live")
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./dump/live/my-strategy.md
+         * await Live.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./custom/path/my-strategy.md
+         * await Live.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 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()));
+        };
+    }
+}
+/**
+ * Singleton instance of LiveUtils for convenient live trading operations.
+ *
+ * @example
+ * ```typescript
+ * import { Live } from "./classes/Live";
+ *
+ * for await (const result of Live.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ * })) {
+ *   console.log("Result:", result.action);
+ * }
+ * ```
+ */
+const Live = new LiveUtils();
 
 const SCHEDULE_METHOD_NAME_GET_DATA = "ScheduleUtils.getData";
 const SCHEDULE_METHOD_NAME_GET_REPORT = "ScheduleUtils.getReport";
@@ -14089,27 +14539,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 = functoolsKit.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.
          *
@@ -14162,11 +14693,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) => {
@@ -14175,31 +14705,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(functoolsKit.getErrorMessage(error))));
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.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,
@@ -14207,8 +14719,8 @@ class WalkerUtils {
                         symbol,
                     });
                 }
-                isDone = true;
-                isStopped = true;
+                this._isDone = true;
+                this._isStopped = true;
             };
         };
         /**
@@ -14230,8 +14742,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) => {
@@ -14254,7 +14766,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);
          * ```
          */
@@ -14278,7 +14791,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);
          * ```
          */
@@ -14302,11 +14816,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) => {
@@ -14323,6 +14838,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 = functoolsKit.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.
  *