backtest-kit 2.3.2 → 2.3.3

package/build/index.mjs

@@ -5004,6 +5004,68 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user");
             return { activated: false, cancelled: true, activationIndex: i, result };
         }
+        // КРИТИЧНО: Проверяем был ли сигнал активирован пользователем через activateScheduled()
+        // Обрабатываем inline (как в tick()) с риск-проверкой по averagePrice
+        if (self._activatedSignal) {
+            const activatedSignal = self._activatedSignal;
+            self._activatedSignal = null;
+            // Check if strategy was stopped
+            if (self._isStopped) {
+                self.params.logger.info("ClientStrategy backtest user-activated signal cancelled (stopped)", {
+                    symbol: self.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await self.setScheduledSignal(null);
+                return { activated: false, cancelled: false, activationIndex: i, result: null };
+            }
+            // Риск-проверка по averagePrice (симметрия с LIVE tick())
+            if (await not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, averagePrice, candle.timestamp, self.params.execution.context.backtest))) {
+                self.params.logger.info("ClientStrategy backtest user-activated signal rejected by risk", {
+                    symbol: self.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await self.setScheduledSignal(null);
+                return { activated: false, cancelled: false, activationIndex: i, result: null };
+            }
+            await self.setScheduledSignal(null);
+            const pendingSignal = {
+                ...activatedSignal,
+                pendingAt: candle.timestamp,
+                _isScheduled: false,
+            };
+            await self.setPendingSignal(pendingSignal);
+            await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
+            // Emit commit AFTER successful risk check
+            const publicSignalForCommit = TO_PUBLIC_SIGNAL(pendingSignal);
+            await CALL_COMMIT_FN(self, {
+                action: "activate-scheduled",
+                symbol: self.params.execution.context.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                signalId: activatedSignal.id,
+                backtest: self.params.execution.context.backtest,
+                activateId: activatedSignal.activateId,
+                timestamp: candle.timestamp,
+                currentPrice: averagePrice,
+                position: publicSignalForCommit.position,
+                priceOpen: publicSignalForCommit.priceOpen,
+                priceTakeProfit: publicSignalForCommit.priceTakeProfit,
+                priceStopLoss: publicSignalForCommit.priceStopLoss,
+                originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                scheduledAt: publicSignalForCommit.scheduledAt,
+                pendingAt: publicSignalForCommit.pendingAt,
+            });
+            await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, pendingSignal.priceOpen, candle.timestamp, self.params.execution.context.backtest);
+            await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
+            return {
+                activated: true,
+                cancelled: false,
+                activationIndex: i,
+                result: null,
+            };
+        }
         // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
         const elapsedTime = candle.timestamp - scheduled.scheduledAt;
         if (elapsedTime >= maxTimeToWait) {
@@ -5226,6 +5288,7 @@ class ClientStrategy {
         this._scheduledSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
+        this._activatedSignal = null;
         /** Queue for commit events to be processed in tick()/backtest() with proper timestamp */
         this._commitQueue = [];
         /**
@@ -5263,6 +5326,16 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy setPendingSignal", {
             pendingSignal,
         });
+        // КРИТИЧНО: Очищаем флаг закрытия при любом изменении pending signal
+        // - при null: сигнал закрыт по TP/SL/timeout, флаг больше не нужен
+        // - при новом сигнале: флаг от предыдущего сигнала не должен влиять на новый
+        this._closedSignal = null;
+        // ЗАЩИТА ИНВАРИАНТА: При установке нового pending сигнала очищаем scheduled
+        // Не может быть одновременно pending И scheduled (взаимоисключающие состояния)
+        // При null: scheduled может существовать (новый сигнал после закрытия позиции)
+        if (pendingSignal !== null) {
+            this._scheduledSignal = null;
+        }
         this._pendingSignal = pendingSignal;
         // КРИТИЧНО: Всегда вызываем коллбек onWrite для тестирования persist storage
         // даже в backtest режиме, чтобы тесты могли перехватывать вызовы через mock adapter
@@ -5288,6 +5361,11 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy setScheduledSignal", {
             scheduledSignal,
         });
+        // КРИТИЧНО: Очищаем флаги отмены и активации при любом изменении scheduled signal
+        // - при null: сигнал отменен/активирован по timeout/SL/user, флаги больше не нужны
+        // - при новом сигнале: флаги от предыдущего сигнала не должны влиять на новый
+        this._cancelledSignal = null;
+        this._activatedSignal = null;
         this._scheduledSignal = scheduledSignal;
         if (this.params.execution.context.backtest) {
             return;
@@ -5477,12 +5555,8 @@ class ClientStrategy {
         const currentTime = this.params.execution.context.when.getTime();
         // Process queued commit events with proper timestamp
         await PROCESS_COMMIT_QUEUE_FN(this, currentTime);
-        // Early return if strategy was stopped
-        if (this._isStopped) {
-            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
-            return await RETURN_IDLE_FN(this, currentPrice);
-        }
         // Check if scheduled signal was cancelled - emit cancelled event once
+        // NOTE: No _isStopped check here - cancellation must work for graceful shutdown
         if (this._cancelledSignal) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
             const cancelledSignal = this._cancelledSignal;
@@ -5491,6 +5565,18 @@ class ClientStrategy {
                 symbol: this.params.execution.context.symbol,
                 signalId: cancelledSignal.id,
             });
+            // Emit commit with correct timestamp from tick context
+            await CALL_COMMIT_FN(this, {
+                action: "cancel-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: cancelledSignal.id,
+                backtest: this.params.execution.context.backtest,
+                cancelId: cancelledSignal.cancelId,
+                timestamp: currentTime,
+            });
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             const result = {
@@ -5519,6 +5605,18 @@ class ClientStrategy {
                 symbol: this.params.execution.context.symbol,
                 signalId: closedSignal.id,
             });
+            // Emit commit with correct timestamp from tick context
+            await CALL_COMMIT_FN(this, {
+                action: "close-pending",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: closedSignal.id,
+                backtest: this.params.execution.context.backtest,
+                closeId: closedSignal.closeId,
+                timestamp: currentTime,
+            });
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -5545,6 +5643,78 @@ class ClientStrategy {
             await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
             return result;
         }
+        // Check if scheduled signal was activated - emit opened event once
+        if (this._activatedSignal) {
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            const activatedSignal = this._activatedSignal;
+            this._activatedSignal = null; // Clear after emitting
+            this.params.logger.info("ClientStrategy tick: scheduled signal was activated", {
+                symbol: this.params.execution.context.symbol,
+                signalId: activatedSignal.id,
+            });
+            // Check if strategy was stopped (symmetry with backtest PROCESS_SCHEDULED_SIGNAL_CANDLES_FN)
+            if (this._isStopped) {
+                this.params.logger.info("ClientStrategy tick: user-activated signal cancelled (stopped)", {
+                    symbol: this.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await this.setScheduledSignal(null);
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
+            // Check risk before activation
+            if (await not(CALL_RISK_CHECK_SIGNAL_FN(this, this.params.execution.context.symbol, activatedSignal, currentPrice, currentTime, this.params.execution.context.backtest))) {
+                this.params.logger.info("ClientStrategy tick: activated signal rejected by risk", {
+                    symbol: this.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
+            // КРИТИЧЕСКИ ВАЖНО: обновляем pendingAt при активации
+            const pendingSignal = {
+                ...activatedSignal,
+                pendingAt: currentTime,
+                _isScheduled: false,
+            };
+            await this.setPendingSignal(pendingSignal);
+            await CALL_RISK_ADD_SIGNAL_FN(this, this.params.execution.context.symbol, pendingSignal, currentTime, this.params.execution.context.backtest);
+            // Emit commit AFTER successful risk check
+            const publicSignalForCommit = TO_PUBLIC_SIGNAL(pendingSignal);
+            await CALL_COMMIT_FN(this, {
+                action: "activate-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: activatedSignal.id,
+                backtest: this.params.execution.context.backtest,
+                activateId: activatedSignal.activateId,
+                timestamp: currentTime,
+                currentPrice,
+                position: publicSignalForCommit.position,
+                priceOpen: publicSignalForCommit.priceOpen,
+                priceTakeProfit: publicSignalForCommit.priceTakeProfit,
+                priceStopLoss: publicSignalForCommit.priceStopLoss,
+                originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                scheduledAt: publicSignalForCommit.scheduledAt,
+                pendingAt: publicSignalForCommit.pendingAt,
+            });
+            // Call onOpen callback
+            await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            const result = {
+                action: "opened",
+                signal: TO_PUBLIC_SIGNAL(pendingSignal),
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                currentPrice,
+                backtest: this.params.execution.context.backtest,
+                createdAt: currentTime,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
+            return result;
+        }
         // Monitor scheduled signal
         if (this._scheduledSignal && !this._pendingSignal) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
@@ -5568,7 +5738,12 @@ class ClientStrategy {
             return await RETURN_SCHEDULED_SIGNAL_ACTIVE_FN(this, this._scheduledSignal, currentPrice);
         }
         // Generate new signal if none exists
+        // NOTE: _isStopped blocks NEW signal generation but allows existing positions to continue
         if (!this._pendingSignal && !this._scheduledSignal) {
+            if (this._isStopped) {
+                const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
             const signal = await GET_SIGNAL_FN(this);
             if (signal) {
                 if (signal._isScheduled === true) {
@@ -5642,6 +5817,18 @@ class ClientStrategy {
             const cancelledSignal = this._cancelledSignal;
             this._cancelledSignal = null; // Clear after using
             const closeTimestamp = this.params.execution.context.when.getTime();
+            // Emit commit with correct timestamp from backtest context
+            await CALL_COMMIT_FN(this, {
+                action: "cancel-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: cancelledSignal.id,
+                backtest: true,
+                cancelId: cancelledSignal.cancelId,
+                timestamp: closeTimestamp,
+            });
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
                 action: "cancelled",
@@ -5667,6 +5854,18 @@ class ClientStrategy {
             const closedSignal = this._closedSignal;
             this._closedSignal = null; // Clear after using
             const closeTimestamp = this.params.execution.context.when.getTime();
+            // Emit commit with correct timestamp from backtest context
+            await CALL_COMMIT_FN(this, {
+                action: "close-pending",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: closedSignal.id,
+                backtest: true,
+                closeId: closedSignal.closeId,
+                timestamp: closeTimestamp,
+            });
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
             await CALL_PARTIAL_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
@@ -5827,8 +6026,18 @@ class ClientStrategy {
             symbol,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
+            hasActivatedSignal: this._activatedSignal !== null,
+            hasCancelledSignal: this._cancelledSignal !== null,
+            hasClosedSignal: this._closedSignal !== null,
         });
         this._isStopped = true;
+        // Clear pending flags to start from clean state
+        // NOTE: _isStopped blocks NEW position opening, but allows:
+        // - cancelScheduled() / closePending() for graceful shutdown
+        // - Monitoring existing _pendingSignal until TP/SL/timeout
+        this._activatedSignal = null;
+        this._cancelledSignal = null;
+        this._closedSignal = null;
         // Clear scheduled signal if exists
         if (!this._scheduledSignal) {
             return;
@@ -5866,8 +6075,9 @@ class ClientStrategy {
             hasScheduledSignal: this._scheduledSignal !== null,
             cancelId,
         });
-        // Save cancelled signal for next tick to emit cancelled event
-        const hadScheduledSignal = this._scheduledSignal !== null;
+        // NOTE: No _isStopped check - cancellation must work for graceful shutdown
+        // (cancelling scheduled signal is not opening new position)
+        // Save cancelled signal for next tick/backtest to emit cancelled event with correct timestamp
         if (this._scheduledSignal) {
             this._cancelledSignal = Object.assign({}, this._scheduledSignal, {
                 cancelId,
@@ -5875,37 +6085,60 @@ class ClientStrategy {
             this._scheduledSignal = null;
         }
         if (backtest) {
-            // Emit commit event only if signal was actually cancelled
-            if (hadScheduledSignal) {
-                await CALL_COMMIT_FN(this, {
-                    action: "cancel-scheduled",
-                    symbol,
-                    strategyName: this.params.strategyName,
-                    exchangeName: this.params.exchangeName,
-                    frameName: this.params.frameName,
-                    signalId: this._cancelledSignal.id,
-                    backtest,
-                    cancelId,
-                    timestamp: this.params.execution.context.when.getTime(),
-                });
-            }
+            // Commit will be emitted in backtest() with correct candle timestamp
             return;
         }
         await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
-        // Emit commit event only if signal was actually cancelled
-        if (hadScheduledSignal) {
-            await CALL_COMMIT_FN(this, {
-                action: "cancel-scheduled",
+        // Commit will be emitted in tick() with correct currentTime
+    }
+    /**
+     * Activates the scheduled signal without waiting for price to reach priceOpen.
+     *
+     * Forces immediate activation of the scheduled signal at the current price.
+     * Does NOT affect active pending signals or strategy operation.
+     * Does NOT set stop flag - strategy can continue generating new signals.
+     *
+     * Use case: User-initiated early activation of a scheduled entry.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param activateId - Optional identifier for this activation operation
+     * @returns Promise that resolves when scheduled signal is activated
+     *
+     * @example
+     * ```typescript
+     * // Activate scheduled signal without waiting for priceOpen
+     * await strategy.activateScheduled("BTCUSDT", false, "user-activate-123");
+     * // Scheduled signal becomes pending signal immediately
+     * ```
+     */
+    async activateScheduled(symbol, backtest, activateId) {
+        this.params.logger.debug("ClientStrategy activateScheduled", {
+            symbol,
+            hasScheduledSignal: this._scheduledSignal !== null,
+            activateId,
+        });
+        // Block activation if strategy stopped - activation = opening NEW position
+        // (unlike cancelScheduled/closePending which handle existing signals for graceful shutdown)
+        if (this._isStopped) {
+            this.params.logger.debug("ClientStrategy activateScheduled: strategy stopped, skipping", {
                 symbol,
-                strategyName: this.params.strategyName,
-                exchangeName: this.params.exchangeName,
-                frameName: this.params.frameName,
-                signalId: this._cancelledSignal.id,
-                backtest,
-                cancelId,
-                timestamp: this.params.execution.context.when.getTime(),
             });
+            return;
+        }
+        // Save activated signal for next tick to emit opened event
+        if (this._scheduledSignal) {
+            this._activatedSignal = Object.assign({}, this._scheduledSignal, {
+                activateId,
+            });
+            this._scheduledSignal = null;
+        }
+        if (backtest) {
+            // Commit will be emitted AFTER successful risk check in PROCESS_SCHEDULED_SIGNAL_CANDLES_FN
+            return;
         }
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        // Commit will be emitted AFTER successful risk check in tick()
     }
     /**
      * Closes the pending signal without stopping the strategy.
@@ -5934,8 +6167,8 @@ class ClientStrategy {
             hasPendingSignal: this._pendingSignal !== null,
             closeId,
         });
-        // Save closed signal for next tick to emit closed event
-        const hadPendingSignal = this._pendingSignal !== null;
+        // NOTE: No _isStopped check - closing position must work for graceful shutdown
+        // Save closed signal for next tick/backtest to emit closed event with correct timestamp
         if (this._pendingSignal) {
             this._closedSignal = Object.assign({}, this._pendingSignal, {
                 closeId,
@@ -5943,37 +6176,11 @@ class ClientStrategy {
             this._pendingSignal = null;
         }
         if (backtest) {
-            // Emit commit event only if signal was actually closed
-            if (hadPendingSignal) {
-                await CALL_COMMIT_FN(this, {
-                    action: "close-pending",
-                    symbol,
-                    strategyName: this.params.strategyName,
-                    exchangeName: this.params.exchangeName,
-                    frameName: this.params.frameName,
-                    signalId: this._closedSignal.id,
-                    backtest,
-                    closeId,
-                    timestamp: this.params.execution.context.when.getTime(),
-                });
-            }
+            // Commit will be emitted in backtest() with correct candle timestamp
             return;
         }
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
-        // Emit commit event only if signal was actually closed
-        if (hadPendingSignal) {
-            await CALL_COMMIT_FN(this, {
-                action: "close-pending",
-                symbol,
-                strategyName: this.params.strategyName,
-                exchangeName: this.params.exchangeName,
-                frameName: this.params.frameName,
-                signalId: this._closedSignal.id,
-                backtest,
-                closeId,
-                timestamp: this.params.execution.context.when.getTime(),
-            });
-        }
+        // Commit will be emitted in tick() with correct currentTime
     }
     /**
      * Executes partial close at profit level (moving toward TP).
@@ -7812,6 +8019,39 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.breakeven(symbol, currentPrice, backtest);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Delegates to ClientStrategy.activateScheduled() which sets _activatedSignal flag.
+         * The actual activation happens on next tick() when strategy detects the flag.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @param activateId - Optional identifier for the activation reason
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early
+         * await strategyConnectionService.activateScheduled(
+         *   false,
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
+         *   "manual-activation"
+         * );
+         * ```
+         */
+        this.activateScheduled = async (backtest, symbol, context, activateId) => {
+            this.loggerService.log("strategyConnectionService activateScheduled", {
+                symbol,
+                context,
+                backtest,
+                activateId,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.activateScheduled(symbol, backtest, activateId);
+        };
     }
 }
 
@@ -11124,6 +11364,39 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.breakeven(backtest, symbol, currentPrice, context);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to set the activation flag. The actual activation happens on next tick().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @param activateId - Optional identifier for the activation reason
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early
+         * await strategyCoreService.activateScheduled(
+         *   false,
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
+         *   "manual-activation"
+         * );
+         * ```
+         */
+        this.activateScheduled = async (backtest, symbol, context, activateId) => {
+            this.loggerService.log("strategyCoreService activateScheduled", {
+                symbol,
+                context,
+                backtest,
+                activateId,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.activateScheduled(backtest, symbol, context, activateId);
+        };
     }
 }
 
@@ -12403,6 +12676,8 @@ class WalkerSchemaService {
     }
 }
 
+const ACTIVE_CANDLE_INCLUDED = 1;
+const SCHEDULE_ACTIVATION_CANDLE_SKIP = 1;
 /**
  * Private service for backtest orchestration using async generators.
  *
@@ -12526,9 +12801,9 @@ class BacktestLogicPrivateService {
                 // - CC_SCHEDULE_AWAIT_MINUTES для ожидания активации
                 // - minuteEstimatedTime для работы сигнала ПОСЛЕ активации
                 // - +1 потому что when включается как первая свеча
-                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - ACTIVE_CANDLE_INCLUDED;
                 const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
-                const candlesNeeded = bufferMinutes + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
+                const candlesNeeded = bufferMinutes + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + SCHEDULE_ACTIVATION_CANDLE_SKIP;
                 let candles;
                 try {
                     candles = await this.exchangeCoreService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
@@ -12666,7 +12941,7 @@ class BacktestLogicPrivateService {
                 // КРИТИЧНО: Получаем свечи включая буфер для VWAP
                 // Сдвигаем начало назад на CC_AVG_PRICE_CANDLES_COUNT-1 минут для буфера VWAP
                 // Запрашиваем minuteEstimatedTime + буфер свечей одним запросом
-                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - ACTIVE_CANDLE_INCLUDED;
                 const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
                 const totalCandles = signal.minuteEstimatedTime + GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
                 let candles;
@@ -24356,6 +24631,67 @@ class StrategyReportService {
                 walkerName: "",
             });
         };
+        /**
+         * Logs an activate-scheduled event when a scheduled signal is activated early.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Current market price at time of activation
+         * @param isBacktest - Whether this is a backtest or live trading event
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         * @param activateId - Optional identifier for the activation reason
+         */
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, activateId) => {
+            this.loggerService.log("strategyReportService activateScheduled", {
+                symbol,
+                currentPrice,
+                isBacktest,
+                activateId,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const scheduledRow = await this.strategyCoreService.getScheduledSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!scheduledRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            await Report.writeData("strategy", {
+                action: "activate-scheduled",
+                activateId,
+                currentPrice,
+                symbol,
+                timestamp,
+                createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
+            }, {
+                signalId: scheduledRow.id,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                strategyName: context.strategyName,
+                symbol,
+                walkerName: "",
+            });
+        };
         /**
          * Initializes the service for event logging.
          *
@@ -24415,7 +24751,14 @@ class StrategyReportService {
                 frameName: event.frameName,
                 strategyName: event.strategyName,
             }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
-            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
+            const unActivateScheduled = strategyCommitSubject
+                .filter(({ action }) => action === "activate-scheduled")
+                .connect(async (event) => await this.activateScheduled(event.symbol, event.currentPrice, event.backtest, {
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                strategyName: event.strategyName,
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.activateId));
+            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -24546,6 +24889,7 @@ class ReportStorage {
                 trailingStopCount: 0,
                 trailingTakeCount: 0,
                 breakevenCount: 0,
+                activateScheduledCount: 0,
             };
         }
         return {
@@ -24558,6 +24902,7 @@ class ReportStorage {
             trailingStopCount: this._eventList.filter(e => e.action === "trailing-stop").length,
             trailingTakeCount: this._eventList.filter(e => e.action === "trailing-take").length,
             breakevenCount: this._eventList.filter(e => e.action === "breakeven").length,
+            activateScheduledCount: this._eventList.filter(e => e.action === "activate-scheduled").length,
         };
     }
     /**
@@ -24606,6 +24951,7 @@ class ReportStorage {
             `- Trailing stop: ${stats.trailingStopCount}`,
             `- Trailing take: ${stats.trailingTakeCount}`,
             `- Breakeven: ${stats.breakevenCount}`,
+            `- Activate scheduled: ${stats.activateScheduledCount}`,
         ].join("\n");
     }
     /**
@@ -25072,6 +25418,66 @@ class StrategyMarkdownService {
                 pendingAt,
             });
         };
+        /**
+         * Records an activate-scheduled event when a scheduled signal is activated early.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Current market price at time of activation
+         * @param isBacktest - Whether this is a backtest or live trading event
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         * @param activateId - Optional identifier for the activation reason
+         */
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, activateId) => {
+            this.loggerService.log("strategyMarkdownService activateScheduled", {
+                symbol,
+                currentPrice,
+                isBacktest,
+                activateId,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const scheduledRow = await this.strategyCoreService.getScheduledSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!scheduledRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
+            storage.addEvent({
+                timestamp,
+                symbol,
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                signalId: scheduledRow.id,
+                action: "activate-scheduled",
+                activateId,
+                currentPrice,
+                createdAt,
+                backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
+            });
+        };
         /**
          * Retrieves aggregated statistics from accumulated strategy events.
          *
@@ -25245,7 +25651,14 @@ class StrategyMarkdownService {
                 frameName: event.frameName,
                 strategyName: event.strategyName,
             }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
-            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
+            const unActivateScheduled = strategyCommitSubject
+                .filter(({ action }) => action === "activate-scheduled")
+                .connect(async (event) => await this.activateScheduled(event.symbol, event.currentPrice, event.backtest, {
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                strategyName: event.strategyName,
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.activateId));
+            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -26171,6 +26584,7 @@ const PARTIAL_LOSS_METHOD_NAME = "strategy.commitPartialLoss";
 const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
 const TRAILING_PROFIT_METHOD_NAME = "strategy.commitTrailingTake";
 const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
+const ACTIVATE_SCHEDULED_METHOD_NAME = "strategy.commitActivateScheduled";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -26488,6 +26902,41 @@ async function commitBreakeven(symbol) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     return await bt.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
+/**
+ * Activates a scheduled signal early without waiting for price to reach priceOpen.
+ *
+ * Sets the activation flag on the scheduled signal. The actual activation
+ * happens on the next tick() when strategy detects the flag.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param activateId - Optional activation ID for tracking user-initiated activations
+ * @returns Promise that resolves when activation flag is set
+ *
+ * @example
+ * ```typescript
+ * import { commitActivateScheduled } from "backtest-kit";
+ *
+ * // Activate scheduled signal early with custom ID
+ * await commitActivateScheduled("BTCUSDT", "manual-activate-001");
+ * ```
+ */
+async function commitActivateScheduled(symbol, activateId) {
+    bt.loggerService.info(ACTIVATE_SCHEDULED_METHOD_NAME, {
+        symbol,
+        activateId,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitActivateScheduled requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitActivateScheduled requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.activateScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, activateId);
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -28658,6 +29107,7 @@ const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
 const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.commitTrailingTake";
+const BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED = "Backtest.commitActivateScheduled";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -29514,6 +29964,46 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.breakeven(true, symbol, currentPrice, context);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Sets the activation flag on the scheduled signal. The actual activation
+         * happens on the next tick() when strategy detects the flag.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param activateId - Optional activation ID for tracking user-initiated activations
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early with custom ID
+         * await Backtest.commitActivateScheduled("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "1h"
+         * }, "manual-activate-001");
+         * ```
+         */
+        this.commitActivateScheduled = async (symbol, context, activateId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED, {
+                symbol,
+                context,
+                activateId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED));
+            }
+            await bt.strategyCoreService.activateScheduled(true, symbol, context, activateId);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -29689,6 +30179,7 @@ const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
 const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.commitTrailingTake";
+const LIVE_METHOD_NAME_ACTIVATE_SCHEDULED = "Live.commitActivateScheduled";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -30513,6 +31004,46 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Sets the activation flag on the scheduled signal. The actual activation
+         * happens on the next tick() when strategy detects the flag.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param activateId - Optional activation ID for tracking user-initiated activations
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early with custom ID
+         * await Live.commitActivateScheduled("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance"
+         * }, "manual-activate-001");
+         * ```
+         */
+        this.commitActivateScheduled = async (symbol, context, activateId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_ACTIVATE_SCHEDULED, {
+                symbol,
+                context,
+                activateId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
+            }
+            await bt.strategyCoreService.activateScheduled(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, activateId);
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -34448,6 +34979,29 @@ class NotificationInstance {
                     createdAt: data.timestamp,
                 });
             }
+            else if (data.action === "activate-scheduled") {
+                this._addNotification({
+                    type: "activate_scheduled.commit",
+                    id: CREATE_KEY_FN(),
+                    timestamp: data.timestamp,
+                    backtest: data.backtest,
+                    symbol: data.symbol,
+                    strategyName: data.strategyName,
+                    exchangeName: data.exchangeName,
+                    signalId: data.signalId,
+                    activateId: data.activateId,
+                    currentPrice: data.currentPrice,
+                    position: data.position,
+                    priceOpen: data.priceOpen,
+                    priceTakeProfit: data.priceTakeProfit,
+                    priceStopLoss: data.priceStopLoss,
+                    originalPriceTakeProfit: data.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.originalPriceStopLoss,
+                    scheduledAt: data.scheduledAt,
+                    pendingAt: data.pendingAt,
+                    createdAt: data.timestamp,
+                });
+            }
         };
         /**
          * Processes risk rejection events.
@@ -35252,4 +35806,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitActivateScheduled, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };