backtest-kit 1.4.7 → 1.4.9

package/build/index.cjs

@@ -399,10 +399,12 @@ const GET_CANDLES_FN = async (dto, since, self) => {
             return result;
         }
         catch (err) {
-            self.params.logger.warn(`ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`, {
+            const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
+            self.params.logger.warn(message, {
                 error: functoolsKit.errorData(err),
                 message: functoolsKit.getErrorMessage(err),
             });
+            console.warn(message);
             lastError = err;
             await functoolsKit.sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
         }
@@ -1602,6 +1604,12 @@ const signalBacktestEmitter = new functoolsKit.Subject();
  * Emits errors caught in background tasks (Live.background, Backtest.background).
  */
 const errorEmitter = new functoolsKit.Subject();
+/**
+ * Exit emitter for critical errors that require process termination.
+ * Emits errors that should terminate the current execution (Backtest, Live, Walker).
+ * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
+ */
+const exitEmitter = new functoolsKit.Subject();
 /**
  * Done emitter for live background execution completion.
  * Emits when live background tasks complete (Live.background).
@@ -1674,6 +1682,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     doneLiveSubject: doneLiveSubject,
     doneWalkerSubject: doneWalkerSubject,
     errorEmitter: errorEmitter,
+    exitEmitter: exitEmitter,
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
@@ -1831,6 +1840,9 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
     if (signal.minuteEstimatedTime <= 0) {
         errors.push(`minuteEstimatedTime must be positive, got ${signal.minuteEstimatedTime}`);
     }
+    if (!Number.isInteger(signal.minuteEstimatedTime)) {
+        errors.push(`minuteEstimatedTime must be an integer (whole number), got ${signal.minuteEstimatedTime}`);
+    }
     // ЗАЩИТА ОТ ВЕЧНЫХ СИГНАЛОВ: ограничиваем максимальное время жизни сигнала
     if (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES && GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
         if (signal.minuteEstimatedTime > GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
@@ -3017,6 +3029,7 @@ class StrategyConnectionService {
         this.getStrategy = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => {
             const { riskName, getSignal, interval, callbacks } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
+                symbol,
                 interval,
                 execution: this.executionContextService,
                 method: this.methodContextService,
@@ -4750,7 +4763,21 @@ class BacktestLogicPrivateService {
                     progress: totalFrames > 0 ? i / totalFrames : 0,
                 });
             }
-            const result = await this.strategyGlobalService.tick(symbol, when, true);
+            let result;
+            try {
+                result = await this.strategyGlobalService.tick(symbol, when, true);
+            }
+            catch (error) {
+                console.warn(`backtestLogicPrivateService tick failed, skipping timeframe when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                this.loggerService.warn("backtestLogicPrivateService tick failed, skipping timeframe", {
+                    symbol,
+                    when: when.toISOString(),
+                    error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                });
+                await errorEmitter.next(error);
+                i++;
+                continue;
+            }
             // Если scheduled signal создан - обрабатываем через backtest()
             if (result.action === "scheduled") {
                 const signalStartTime = performance.now();
@@ -4766,7 +4793,22 @@ class BacktestLogicPrivateService {
                 // + minuteEstimatedTime для работы сигнала ПОСЛЕ активации
                 // +1 потому что when включается как первая свеча (timestamp начинается с when, а не after when)
                 const candlesNeeded = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
-                const candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", candlesNeeded, when, true);
+                let candles;
+                try {
+                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", candlesNeeded, when, true);
+                }
+                catch (error) {
+                    console.warn(`backtestLogicPrivateService getNextCandles failed for scheduled signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                    this.loggerService.warn("backtestLogicPrivateService getNextCandles failed for scheduled signal", {
+                        symbol,
+                        signalId: signal.id,
+                        candlesNeeded,
+                        error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    i++;
+                    continue;
+                }
                 if (!candles.length) {
                     i++;
                     continue;
@@ -4779,7 +4821,21 @@ class BacktestLogicPrivateService {
                 });
                 // backtest() сам обработает scheduled signal: найдет активацию/отмену
                 // и если активируется - продолжит с TP/SL мониторингом
-                const backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                let backtestResult;
+                try {
+                    backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                }
+                catch (error) {
+                    console.warn(`backtestLogicPrivateService backtest failed for scheduled signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                    this.loggerService.warn("backtestLogicPrivateService backtest failed for scheduled signal", {
+                        symbol,
+                        signalId: signal.id,
+                        error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    i++;
+                    continue;
+                }
                 this.loggerService.info("backtestLogicPrivateService scheduled signal closed", {
                     symbol,
                     signalId: backtestResult.signal.id,
@@ -4820,9 +4876,24 @@ class BacktestLogicPrivateService {
                     minuteEstimatedTime: signal.minuteEstimatedTime,
                 });
                 // Получаем свечи для бектеста
-                const candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", signal.minuteEstimatedTime, when, true);
+                let candles;
+                try {
+                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", signal.minuteEstimatedTime, when, true);
+                }
+                catch (error) {
+                    console.warn(`backtestLogicPrivateService getNextCandles failed for opened signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                    this.loggerService.warn("backtestLogicPrivateService getNextCandles failed for opened signal", {
+                        symbol,
+                        signalId: signal.id,
+                        error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    i++;
+                    continue;
+                }
                 if (!candles.length) {
-                    return;
+                    i++;
+                    continue;
                 }
                 this.loggerService.info("backtestLogicPrivateService candles fetched", {
                     symbol,
@@ -4830,7 +4901,21 @@ class BacktestLogicPrivateService {
                     candlesCount: candles.length,
                 });
                 // Вызываем backtest - всегда возвращает closed
-                const backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                let backtestResult;
+                try {
+                    backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                }
+                catch (error) {
+                    console.warn(`backtestLogicPrivateService backtest failed for opened signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                    this.loggerService.warn("backtestLogicPrivateService backtest failed for opened signal", {
+                        symbol,
+                        signalId: signal.id,
+                        error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    i++;
+                    continue;
+                }
                 this.loggerService.info("backtestLogicPrivateService signal closed", {
                     symbol,
                     signalId: backtestResult.signal.id,
@@ -4954,7 +5039,21 @@ class LiveLogicPrivateService {
         while (true) {
             const tickStartTime = performance.now();
             const when = new Date();
-            const result = await this.strategyGlobalService.tick(symbol, when, false);
+            let result;
+            try {
+                result = await this.strategyGlobalService.tick(symbol, when, false);
+            }
+            catch (error) {
+                console.warn(`backtestLogicPrivateService tick failed when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                this.loggerService.warn("liveLogicPrivateService tick failed, retrying after sleep", {
+                    symbol,
+                    when: when.toISOString(),
+                    error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                });
+                await errorEmitter.next(error);
+                await functoolsKit.sleep(TICK_TTL);
+                continue;
+            }
             this.loggerService.info("liveLogicPrivateService tick result", {
                 symbol,
                 action: result.action,
@@ -5076,10 +5175,27 @@ class WalkerLogicPrivateService {
                 frameName: context.frameName,
             });
             pendingStrategy = strategyName;
-            const result = await Promise.race([
-                await functoolsKit.resolveDocuments(iterator),
-                listenStop,
-            ]);
+            let result;
+            try {
+                result = await Promise.race([
+                    await functoolsKit.resolveDocuments(iterator),
+                    listenStop,
+                ]);
+            }
+            catch (error) {
+                console.warn(`walkerLogicPrivateService backtest failed symbol=${symbol} strategyName=${strategyName} exchangeName=${context.exchangeName}`);
+                this.loggerService.warn("walkerLogicPrivateService backtest failed for strategy, skipping", {
+                    strategyName,
+                    symbol,
+                    error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                });
+                await errorEmitter.next(error);
+                // Call onStrategyError callback if provided
+                if (walkerSchema.callbacks?.onStrategyError) {
+                    walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+                }
+                continue;
+            }
             if (result === CANCEL_SYMBOL) {
                 this.loggerService.info("walkerLogicPrivateService received stop signal, cancelling walker", {
                     context,
@@ -11437,6 +11553,7 @@ const LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME = "event.listenSignalLiveOnce";
 const LISTEN_SIGNAL_BACKTEST_METHOD_NAME = "event.listenSignalBacktest";
 const LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME = "event.listenSignalBacktestOnce";
 const LISTEN_ERROR_METHOD_NAME = "event.listenError";
+const LISTEN_EXIT_METHOD_NAME = "event.listenExit";
 const LISTEN_DONE_LIVE_METHOD_NAME = "event.listenDoneLive";
 const LISTEN_DONE_LIVE_ONCE_METHOD_NAME = "event.listenDoneLiveOnce";
 const LISTEN_DONE_BACKTEST_METHOD_NAME = "event.listenDoneBacktest";
@@ -11619,9 +11736,10 @@ function listenSignalBacktestOnce(filterFn, fn) {
     return signalBacktestEmitter.filter(filterFn).once(fn);
 }
 /**
- * Subscribes to background execution errors with queued async processing.
+ * Subscribes to recoverable execution errors with queued async processing.
  *
- * Listens to errors caught in Live.background() and Backtest.background() execution.
+ * Listens to recoverable errors during strategy execution (e.g., failed API calls).
+ * These errors are caught and handled gracefully - execution continues.
  * Events are processed sequentially in order received, even if callback is async.
  * Uses queued wrapper to prevent concurrent execution of the callback.
  *
@@ -11633,7 +11751,7 @@ function listenSignalBacktestOnce(filterFn, fn) {
  * import { listenError } from "./function/event";
  *
  * const unsubscribe = listenError((error) => {
- *   console.error("Background execution error:", error.message);
+ *   console.error("Recoverable error (execution continues):", error.message);
  *   // Log to monitoring service, send alerts, etc.
  * });
  *
@@ -11645,6 +11763,34 @@ function listenError(fn) {
     backtest$1.loggerService.log(LISTEN_ERROR_METHOD_NAME);
     return errorEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
+/**
+ * Subscribes to fatal execution errors with queued async processing.
+ *
+ * Listens to critical errors that terminate execution (Live.background, Backtest.background, Walker.background).
+ * Unlike listenError (recoverable errors), these errors stop the current process.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle fatal error events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenExit } from "./function/event";
+ *
+ * const unsubscribe = listenExit((error) => {
+ *   console.error("Fatal error (execution terminated):", error.message);
+ *   // Log to monitoring, send alerts, restart process, etc.
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenExit(fn) {
+    backtest$1.loggerService.log(LISTEN_EXIT_METHOD_NAME);
+    return exitEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
+}
 /**
  * Subscribes to live background execution completion events with queued async processing.
  *
@@ -12458,7 +12604,7 @@ class BacktestUtils {
                 }
                 isDone = true;
             };
-            task().catch((error) => errorEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
+            task().catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(symbol, context.strategyName);
                 backtest$1.strategyGlobalService
@@ -12671,7 +12817,7 @@ class LiveUtils {
                 }
                 isDone = true;
             };
-            task().catch((error) => errorEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
+            task().catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(symbol, context.strategyName);
                 backtest$1.strategyGlobalService
@@ -13102,7 +13248,7 @@ class WalkerUtils {
                 }
                 isDone = true;
             };
-            task().catch((error) => errorEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
+            task().catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
                     backtest$1.strategyGlobalService.stop(symbol, strategyName);
@@ -13855,6 +14001,7 @@ exports.listenDoneLiveOnce = listenDoneLiveOnce;
 exports.listenDoneWalker = listenDoneWalker;
 exports.listenDoneWalkerOnce = listenDoneWalkerOnce;
 exports.listenError = listenError;
+exports.listenExit = listenExit;
 exports.listenOptimizerProgress = listenOptimizerProgress;
 exports.listenPartialLoss = listenPartialLoss;
 exports.listenPartialLossOnce = listenPartialLossOnce;

package/build/index.mjs

@@ -397,10 +397,12 @@ const GET_CANDLES_FN = async (dto, since, self) => {
             return result;
         }
         catch (err) {
-            self.params.logger.warn(`ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`, {
+            const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
+            self.params.logger.warn(message, {
                 error: errorData(err),
                 message: getErrorMessage(err),
             });
+            console.warn(message);
             lastError = err;
             await sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
         }
@@ -1600,6 +1602,12 @@ const signalBacktestEmitter = new Subject();
  * Emits errors caught in background tasks (Live.background, Backtest.background).
  */
 const errorEmitter = new Subject();
+/**
+ * Exit emitter for critical errors that require process termination.
+ * Emits errors that should terminate the current execution (Backtest, Live, Walker).
+ * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
+ */
+const exitEmitter = new Subject();
 /**
  * Done emitter for live background execution completion.
  * Emits when live background tasks complete (Live.background).
@@ -1672,6 +1680,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     doneLiveSubject: doneLiveSubject,
     doneWalkerSubject: doneWalkerSubject,
     errorEmitter: errorEmitter,
+    exitEmitter: exitEmitter,
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
@@ -1829,6 +1838,9 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
     if (signal.minuteEstimatedTime <= 0) {
         errors.push(`minuteEstimatedTime must be positive, got ${signal.minuteEstimatedTime}`);
     }
+    if (!Number.isInteger(signal.minuteEstimatedTime)) {
+        errors.push(`minuteEstimatedTime must be an integer (whole number), got ${signal.minuteEstimatedTime}`);
+    }
     // ЗАЩИТА ОТ ВЕЧНЫХ СИГНАЛОВ: ограничиваем максимальное время жизни сигнала
     if (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES && GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
         if (signal.minuteEstimatedTime > GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
@@ -3015,6 +3027,7 @@ class StrategyConnectionService {
         this.getStrategy = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => {
             const { riskName, getSignal, interval, callbacks } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
+                symbol,
                 interval,
                 execution: this.executionContextService,
                 method: this.methodContextService,
@@ -4748,7 +4761,21 @@ class BacktestLogicPrivateService {
                     progress: totalFrames > 0 ? i / totalFrames : 0,
                 });
             }
-            const result = await this.strategyGlobalService.tick(symbol, when, true);
+            let result;
+            try {
+                result = await this.strategyGlobalService.tick(symbol, when, true);
+            }
+            catch (error) {
+                console.warn(`backtestLogicPrivateService tick failed, skipping timeframe when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                this.loggerService.warn("backtestLogicPrivateService tick failed, skipping timeframe", {
+                    symbol,
+                    when: when.toISOString(),
+                    error: errorData(error), message: getErrorMessage(error),
+                });
+                await errorEmitter.next(error);
+                i++;
+                continue;
+            }
             // Если scheduled signal создан - обрабатываем через backtest()
             if (result.action === "scheduled") {
                 const signalStartTime = performance.now();
@@ -4764,7 +4791,22 @@ class BacktestLogicPrivateService {
                 // + minuteEstimatedTime для работы сигнала ПОСЛЕ активации
                 // +1 потому что when включается как первая свеча (timestamp начинается с when, а не after when)
                 const candlesNeeded = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
-                const candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", candlesNeeded, when, true);
+                let candles;
+                try {
+                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", candlesNeeded, when, true);
+                }
+                catch (error) {
+                    console.warn(`backtestLogicPrivateService getNextCandles failed for scheduled signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                    this.loggerService.warn("backtestLogicPrivateService getNextCandles failed for scheduled signal", {
+                        symbol,
+                        signalId: signal.id,
+                        candlesNeeded,
+                        error: errorData(error), message: getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    i++;
+                    continue;
+                }
                 if (!candles.length) {
                     i++;
                     continue;
@@ -4777,7 +4819,21 @@ class BacktestLogicPrivateService {
                 });
                 // backtest() сам обработает scheduled signal: найдет активацию/отмену
                 // и если активируется - продолжит с TP/SL мониторингом
-                const backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                let backtestResult;
+                try {
+                    backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                }
+                catch (error) {
+                    console.warn(`backtestLogicPrivateService backtest failed for scheduled signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                    this.loggerService.warn("backtestLogicPrivateService backtest failed for scheduled signal", {
+                        symbol,
+                        signalId: signal.id,
+                        error: errorData(error), message: getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    i++;
+                    continue;
+                }
                 this.loggerService.info("backtestLogicPrivateService scheduled signal closed", {
                     symbol,
                     signalId: backtestResult.signal.id,
@@ -4818,9 +4874,24 @@ class BacktestLogicPrivateService {
                     minuteEstimatedTime: signal.minuteEstimatedTime,
                 });
                 // Получаем свечи для бектеста
-                const candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", signal.minuteEstimatedTime, when, true);
+                let candles;
+                try {
+                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", signal.minuteEstimatedTime, when, true);
+                }
+                catch (error) {
+                    console.warn(`backtestLogicPrivateService getNextCandles failed for opened signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                    this.loggerService.warn("backtestLogicPrivateService getNextCandles failed for opened signal", {
+                        symbol,
+                        signalId: signal.id,
+                        error: errorData(error), message: getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    i++;
+                    continue;
+                }
                 if (!candles.length) {
-                    return;
+                    i++;
+                    continue;
                 }
                 this.loggerService.info("backtestLogicPrivateService candles fetched", {
                     symbol,
@@ -4828,7 +4899,21 @@ class BacktestLogicPrivateService {
                     candlesCount: candles.length,
                 });
                 // Вызываем backtest - всегда возвращает closed
-                const backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                let backtestResult;
+                try {
+                    backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                }
+                catch (error) {
+                    console.warn(`backtestLogicPrivateService backtest failed for opened signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                    this.loggerService.warn("backtestLogicPrivateService backtest failed for opened signal", {
+                        symbol,
+                        signalId: signal.id,
+                        error: errorData(error), message: getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    i++;
+                    continue;
+                }
                 this.loggerService.info("backtestLogicPrivateService signal closed", {
                     symbol,
                     signalId: backtestResult.signal.id,
@@ -4952,7 +5037,21 @@ class LiveLogicPrivateService {
         while (true) {
             const tickStartTime = performance.now();
             const when = new Date();
-            const result = await this.strategyGlobalService.tick(symbol, when, false);
+            let result;
+            try {
+                result = await this.strategyGlobalService.tick(symbol, when, false);
+            }
+            catch (error) {
+                console.warn(`backtestLogicPrivateService tick failed when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
+                this.loggerService.warn("liveLogicPrivateService tick failed, retrying after sleep", {
+                    symbol,
+                    when: when.toISOString(),
+                    error: errorData(error), message: getErrorMessage(error),
+                });
+                await errorEmitter.next(error);
+                await sleep(TICK_TTL);
+                continue;
+            }
             this.loggerService.info("liveLogicPrivateService tick result", {
                 symbol,
                 action: result.action,
@@ -5074,10 +5173,27 @@ class WalkerLogicPrivateService {
                 frameName: context.frameName,
             });
             pendingStrategy = strategyName;
-            const result = await Promise.race([
-                await resolveDocuments(iterator),
-                listenStop,
-            ]);
+            let result;
+            try {
+                result = await Promise.race([
+                    await resolveDocuments(iterator),
+                    listenStop,
+                ]);
+            }
+            catch (error) {
+                console.warn(`walkerLogicPrivateService backtest failed symbol=${symbol} strategyName=${strategyName} exchangeName=${context.exchangeName}`);
+                this.loggerService.warn("walkerLogicPrivateService backtest failed for strategy, skipping", {
+                    strategyName,
+                    symbol,
+                    error: errorData(error), message: getErrorMessage(error),
+                });
+                await errorEmitter.next(error);
+                // Call onStrategyError callback if provided
+                if (walkerSchema.callbacks?.onStrategyError) {
+                    walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+                }
+                continue;
+            }
             if (result === CANCEL_SYMBOL) {
                 this.loggerService.info("walkerLogicPrivateService received stop signal, cancelling walker", {
                     context,
@@ -11435,6 +11551,7 @@ const LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME = "event.listenSignalLiveOnce";
 const LISTEN_SIGNAL_BACKTEST_METHOD_NAME = "event.listenSignalBacktest";
 const LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME = "event.listenSignalBacktestOnce";
 const LISTEN_ERROR_METHOD_NAME = "event.listenError";
+const LISTEN_EXIT_METHOD_NAME = "event.listenExit";
 const LISTEN_DONE_LIVE_METHOD_NAME = "event.listenDoneLive";
 const LISTEN_DONE_LIVE_ONCE_METHOD_NAME = "event.listenDoneLiveOnce";
 const LISTEN_DONE_BACKTEST_METHOD_NAME = "event.listenDoneBacktest";
@@ -11617,9 +11734,10 @@ function listenSignalBacktestOnce(filterFn, fn) {
     return signalBacktestEmitter.filter(filterFn).once(fn);
 }
 /**
- * Subscribes to background execution errors with queued async processing.
+ * Subscribes to recoverable execution errors with queued async processing.
  *
- * Listens to errors caught in Live.background() and Backtest.background() execution.
+ * Listens to recoverable errors during strategy execution (e.g., failed API calls).
+ * These errors are caught and handled gracefully - execution continues.
  * Events are processed sequentially in order received, even if callback is async.
  * Uses queued wrapper to prevent concurrent execution of the callback.
  *
@@ -11631,7 +11749,7 @@ function listenSignalBacktestOnce(filterFn, fn) {
  * import { listenError } from "./function/event";
  *
  * const unsubscribe = listenError((error) => {
- *   console.error("Background execution error:", error.message);
+ *   console.error("Recoverable error (execution continues):", error.message);
  *   // Log to monitoring service, send alerts, etc.
  * });
  *
@@ -11643,6 +11761,34 @@ function listenError(fn) {
     backtest$1.loggerService.log(LISTEN_ERROR_METHOD_NAME);
     return errorEmitter.subscribe(queued(async (error) => fn(error)));
 }
+/**
+ * Subscribes to fatal execution errors with queued async processing.
+ *
+ * Listens to critical errors that terminate execution (Live.background, Backtest.background, Walker.background).
+ * Unlike listenError (recoverable errors), these errors stop the current process.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle fatal error events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenExit } from "./function/event";
+ *
+ * const unsubscribe = listenExit((error) => {
+ *   console.error("Fatal error (execution terminated):", error.message);
+ *   // Log to monitoring, send alerts, restart process, etc.
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenExit(fn) {
+    backtest$1.loggerService.log(LISTEN_EXIT_METHOD_NAME);
+    return exitEmitter.subscribe(queued(async (error) => fn(error)));
+}
 /**
  * Subscribes to live background execution completion events with queued async processing.
  *
@@ -12456,7 +12602,7 @@ class BacktestUtils {
                 }
                 isDone = true;
             };
-            task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
+            task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(symbol, context.strategyName);
                 backtest$1.strategyGlobalService
@@ -12669,7 +12815,7 @@ class LiveUtils {
                 }
                 isDone = true;
             };
-            task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
+            task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 backtest$1.strategyGlobalService.stop(symbol, context.strategyName);
                 backtest$1.strategyGlobalService
@@ -13100,7 +13246,7 @@ class WalkerUtils {
                 }
                 isDone = true;
             };
-            task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
+            task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
                     backtest$1.strategyGlobalService.stop(symbol, strategyName);
@@ -13806,4 +13952,4 @@ class ConstantUtils {
  */
 const Constant = new ConstantUtils();
 
-export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };
+export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };

package/package.json

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

package/types.d.ts

@@ -1201,6 +1201,8 @@ interface IWalkerCallbacks {
     onStrategyStart: (strategyName: StrategyName, symbol: string) => void;
     /** Called when a strategy backtest completes */
     onStrategyComplete: (strategyName: StrategyName, symbol: string, stats: BacktestStatistics, metric: number | null) => void;
+    /** Called when a strategy backtest fails with an error */
+    onStrategyError: (strategyName: StrategyName, symbol: string, error: Error | unknown) => void;
     /** Called when all strategies have been tested */
     onComplete: (results: IWalkerResults) => void;
 }
@@ -2938,9 +2940,10 @@ declare function listenSignalBacktest(fn: (event: IStrategyTickResult) => void):
  */
 declare function listenSignalBacktestOnce(filterFn: (event: IStrategyTickResult) => boolean, fn: (event: IStrategyTickResult) => void): () => void;
 /**
- * Subscribes to background execution errors with queued async processing.
+ * Subscribes to recoverable execution errors with queued async processing.
  *
- * Listens to errors caught in Live.background() and Backtest.background() execution.
+ * Listens to recoverable errors during strategy execution (e.g., failed API calls).
+ * These errors are caught and handled gracefully - execution continues.
  * Events are processed sequentially in order received, even if callback is async.
  * Uses queued wrapper to prevent concurrent execution of the callback.
  *
@@ -2952,7 +2955,7 @@ declare function listenSignalBacktestOnce(filterFn: (event: IStrategyTickResult)
  * import { listenError } from "./function/event";
  *
  * const unsubscribe = listenError((error) => {
- *   console.error("Background execution error:", error.message);
+ *   console.error("Recoverable error (execution continues):", error.message);
  *   // Log to monitoring service, send alerts, etc.
  * });
  *
@@ -2961,6 +2964,31 @@ declare function listenSignalBacktestOnce(filterFn: (event: IStrategyTickResult)
  * ```
  */
 declare function listenError(fn: (error: Error) => void): () => void;
+/**
+ * Subscribes to fatal execution errors with queued async processing.
+ *
+ * Listens to critical errors that terminate execution (Live.background, Backtest.background, Walker.background).
+ * Unlike listenError (recoverable errors), these errors stop the current process.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle fatal error events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenExit } from "./function/event";
+ *
+ * const unsubscribe = listenExit((error) => {
+ *   console.error("Fatal error (execution terminated):", error.message);
+ *   // Log to monitoring, send alerts, restart process, etc.
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenExit(fn: (error: Error) => void): () => void;
 /**
  * Subscribes to live background execution completion events with queued async processing.
  *
@@ -5035,7 +5063,7 @@ declare class BacktestUtils {
         strategyName: string;
         exchangeName: string;
         frameName: string;
-    }) => AsyncGenerator<IStrategyBacktestResult, void, unknown>;
+    }) => AsyncGenerator<any, void, unknown>;
     /**
      * Runs backtest in background without yielding results.
      *
@@ -5170,7 +5198,7 @@ declare class LiveUtils {
     run: (symbol: string, context: {
         strategyName: string;
         exchangeName: string;
-    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
+    }) => AsyncGenerator<any, void, unknown>;
     /**
      * Runs live trading in background without yielding results.
      *
@@ -6091,6 +6119,12 @@ declare const signalBacktestEmitter: Subject<IStrategyTickResult>;
  * Emits errors caught in background tasks (Live.background, Backtest.background).
  */
 declare const errorEmitter: Subject<Error>;
+/**
+ * Exit emitter for critical errors that require process termination.
+ * Emits errors that should terminate the current execution (Backtest, Live, Walker).
+ * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
+ */
+declare const exitEmitter: Subject<Error>;
 /**
  * Done emitter for live background execution completion.
  * Emits when live background tasks complete (Live.background).
@@ -6164,6 +6198,7 @@ declare const emitters_doneBacktestSubject: typeof doneBacktestSubject;
 declare const emitters_doneLiveSubject: typeof doneLiveSubject;
 declare const emitters_doneWalkerSubject: typeof doneWalkerSubject;
 declare const emitters_errorEmitter: typeof errorEmitter;
+declare const emitters_exitEmitter: typeof exitEmitter;
 declare const emitters_partialLossSubject: typeof partialLossSubject;
 declare const emitters_partialProfitSubject: typeof partialProfitSubject;
 declare const emitters_performanceEmitter: typeof performanceEmitter;
@@ -6178,7 +6213,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressOptimizerEmitter as progressOptimizerEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressOptimizerEmitter as progressOptimizerEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -7416,7 +7451,7 @@ declare class BacktestLogicPrivateService {
      * }
      * ```
      */
-    run(symbol: string): AsyncGenerator<IStrategyBacktestResult, void, unknown>;
+    run(symbol: string): AsyncGenerator<any, void, unknown>;
 }
 
 /**
@@ -7461,7 +7496,7 @@ declare class LiveLogicPrivateService {
      * }
      * ```
      */
-    run(symbol: string): AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
+    run(symbol: string): AsyncGenerator<any, void, unknown>;
 }
 
 /**
@@ -7555,7 +7590,7 @@ declare class BacktestLogicPublicService {
         strategyName: string;
         exchangeName: string;
         frameName: string;
-    }) => AsyncGenerator<IStrategyBacktestResult, void, unknown>;
+    }) => AsyncGenerator<any, void, unknown>;
 }
 
 /**
@@ -7606,7 +7641,7 @@ declare class LiveLogicPublicService {
     run: (symbol: string, context: {
         strategyName: string;
         exchangeName: string;
-    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
+    }) => AsyncGenerator<any, void, unknown>;
 }
 
 /**
@@ -7674,7 +7709,7 @@ declare class LiveCommandService {
     run: (symbol: string, context: {
         strategyName: string;
         exchangeName: string;
-    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
+    }) => AsyncGenerator<any, void, unknown>;
 }
 
 /**
@@ -7702,7 +7737,7 @@ declare class BacktestCommandService {
         strategyName: string;
         exchangeName: string;
         frameName: string;
-    }) => AsyncGenerator<IStrategyBacktestResult, void, unknown>;
+    }) => AsyncGenerator<any, void, unknown>;
 }
 
 /**
@@ -8659,4 +8694,4 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { Backtest, type BacktestStatistics, type CandleInterval, Constant, type DoneContract, type EntityId, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type ICandleData, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type IHeatmapStatistics, type IOptimizerCallbacks, type IOptimizerData, type IOptimizerFetchArgs, type IOptimizerFilterArgs, type IOptimizerRange, type IOptimizerSchema, type IOptimizerSource, type IOptimizerStrategy, type IOptimizerTemplate, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, Live, type LiveStatistics, type MessageModel, type MessageRole, MethodContextService, Optimizer, Partial$1 as Partial, type PartialData, type PartialLossContract, type PartialProfitContract, type PartialStatistics, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatistics, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, type ProgressBacktestContract, type ProgressOptimizerContract, type ProgressWalkerContract, type RiskData, Schedule, type ScheduleData, type ScheduleStatistics, type SignalData, type SignalInterval, type TPersistBase, type TPersistBaseCtor, Walker, type WalkerContract, type WalkerMetric, type WalkerStatistics, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };
+export { Backtest, type BacktestStatistics, type CandleInterval, Constant, type DoneContract, type EntityId, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type ICandleData, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type IHeatmapStatistics, type IOptimizerCallbacks, type IOptimizerData, type IOptimizerFetchArgs, type IOptimizerFilterArgs, type IOptimizerRange, type IOptimizerSchema, type IOptimizerSource, type IOptimizerStrategy, type IOptimizerTemplate, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, Live, type LiveStatistics, type MessageModel, type MessageRole, MethodContextService, Optimizer, Partial$1 as Partial, type PartialData, type PartialLossContract, type PartialProfitContract, type PartialStatistics, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatistics, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, type ProgressBacktestContract, type ProgressOptimizerContract, type ProgressWalkerContract, type RiskData, Schedule, type ScheduleData, type ScheduleStatistics, type SignalData, type SignalInterval, type TPersistBase, type TPersistBaseCtor, Walker, type WalkerContract, type WalkerMetric, type WalkerStatistics, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };