backtest-kit 5.1.0 → 5.2.0

package/build/index.cjs

@@ -5064,7 +5064,7 @@ const CALL_SCHEDULE_PING_CALLBACKS_FN = functoolsKit.trycatch(beginTime(async (s
     await ExecutionContextService.runInContext(async () => {
         const publicSignal = TO_PUBLIC_SIGNAL(scheduled, currentPrice);
         // Call system onSchedulePing callback first (emits to pingSubject)
-        await self.params.onSchedulePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, self.params.execution.context.backtest, timestamp);
+        await self.params.onSchedulePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, currentPrice, self.params.execution.context.backtest, timestamp);
         // Call user onSchedulePing callback only if signal is still active (not cancelled, not activated)
         if (self.params.callbacks?.onSchedulePing) {
             await self.params.callbacks.onSchedulePing(self.params.execution.context.symbol, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
@@ -5090,7 +5090,7 @@ const CALL_ACTIVE_PING_CALLBACKS_FN = functoolsKit.trycatch(beginTime(async (sel
     await ExecutionContextService.runInContext(async () => {
         const publicSignal = TO_PUBLIC_SIGNAL(pending, currentPrice);
         // Call system onActivePing callback first (emits to activePingSubject)
-        await self.params.onActivePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, self.params.execution.context.backtest, timestamp);
+        await self.params.onActivePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, currentPrice, self.params.execution.context.backtest, timestamp);
         // Call user onActivePing callback only if signal is still active (not closed)
         if (self.params.callbacks?.onActivePing) {
             await self.params.callbacks.onActivePing(self.params.execution.context.symbol, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
@@ -5888,6 +5888,57 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
+const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, averagePrice, closeTimestamp) => {
+    const syncCloseAllowed = await CALL_SIGNAL_SYNC_CLOSE_FN(closeTimestamp, averagePrice, "closed", closedSignal, self);
+    if (!syncCloseAllowed) {
+        self.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry", {
+            symbol: self.params.execution.context.symbol,
+            signalId: closedSignal.id,
+        });
+        self._closedSignal = null;
+        self._pendingSignal = closedSignal;
+        throw new Error(`ClientStrategy backtest: signal close rejected by sync (signalId=${closedSignal.id}). ` +
+            `Retry backtest() with new candle data.`);
+    }
+    self._closedSignal = null;
+    await CALL_COMMIT_FN(self, {
+        action: "close-pending",
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.strategyName,
+        exchangeName: self.params.exchangeName,
+        frameName: self.params.frameName,
+        signalId: closedSignal.id,
+        backtest: true,
+        closeId: closedSignal.closeId,
+        timestamp: closeTimestamp,
+        totalEntries: closedSignal._entry?.length ?? 1,
+        totalPartials: closedSignal._partial?.length ?? 0,
+        originalPriceOpen: closedSignal.priceOpen,
+        pnl: toProfitLossDto(closedSignal, averagePrice),
+    });
+    await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_BREAKEVEN_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_RISK_REMOVE_SIGNAL_FN(self, self.params.execution.context.symbol, closeTimestamp, self.params.execution.context.backtest);
+    const pnl = toProfitLossDto(closedSignal, averagePrice);
+    const result = {
+        action: "closed",
+        signal: TO_PUBLIC_SIGNAL(closedSignal, averagePrice),
+        currentPrice: averagePrice,
+        closeReason: "closed",
+        closeTimestamp,
+        pnl,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
+        symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
+        closeId: closedSignal.closeId,
+        createdAt: closeTimestamp,
+    };
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
+    return result;
+};
 const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
@@ -5905,7 +5956,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         if (self._cancelledSignal) {
             // Сигнал был отменен через cancel() в onSchedulePing
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         // КРИТИЧНО: Проверяем был ли сигнал активирован пользователем через activateScheduled()
         // Обрабатываем inline (как в tick()) с риск-проверкой по averagePrice
@@ -5919,7 +5970,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     signalId: activatedSignal.id,
                 });
                 await self.setScheduledSignal(null);
-                return { activated: false, cancelled: false, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             // Риск-проверка по averagePrice (симметрия с LIVE tick())
             if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, averagePrice, candle.timestamp, self.params.execution.context.backtest))) {
@@ -5928,7 +5979,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     signalId: activatedSignal.id,
                 });
                 await self.setScheduledSignal(null);
-                return { activated: false, cancelled: false, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             const pendingSignal = {
                 ...activatedSignal,
@@ -5957,7 +6008,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     originalPriceOpen: activatedSignal.priceOpen,
                     pnl: toProfitLossDto(activatedSignal, averagePrice),
                 });
-                return { activated: false, cancelled: true, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             await self.setScheduledSignal(null);
             await self.setPendingSignal(pendingSignal);
@@ -5990,18 +6041,13 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
             });
             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,
-            };
+            return { outcome: "activated", activationIndex: i };
         }
         // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
         const elapsedTime = candle.timestamp - scheduled.scheduledAt;
         if (elapsedTime >= maxTimeToWait) {
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "timeout");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         let shouldActivate = false;
         let shouldCancel = false;
@@ -6039,27 +6085,17 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         }
         if (shouldCancel) {
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "price_reject");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         if (shouldActivate) {
             await ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, candle.timestamp);
-            return {
-                activated: true,
-                cancelled: false,
-                activationIndex: i,
-                result: null,
-            };
+            return { outcome: "activated", activationIndex: i };
         }
         await CALL_SCHEDULE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, candle.timestamp, true, averagePrice);
         // Process queued commit events with candle timestamp
         await PROCESS_COMMIT_QUEUE_FN(self, averagePrice, candle.timestamp);
     }
-    return {
-        activated: false,
-        cancelled: false,
-        activationIndex: -1,
-        result: null,
-    };
+    return { outcome: "pending" };
 };
 const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
@@ -6078,6 +6114,10 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         const startIndex = Math.max(0, i - (candlesCount - 1));
         const recentCandles = candles.slice(startIndex, i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // КРИТИЧНО: Проверяем был ли сигнал закрыт пользователем через closePending()
+        if (self._closedSignal) {
+            return await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
+        }
         await CALL_ACTIVE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentCandleTimestamp, true, averagePrice);
         let shouldClose = false;
         let closeReason;
@@ -6182,7 +6222,32 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         // Process queued commit events with candle timestamp
         await PROCESS_COMMIT_QUEUE_FN(self, averagePrice, currentCandleTimestamp);
     }
-    return null;
+    // Loop exhausted without closing — check if we have enough data
+    const lastCandles = candles.slice(-GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
+    const lastPrice = GET_AVG_PRICE_FN(lastCandles);
+    const closeTimestamp = lastCandles[lastCandles.length - 1].timestamp;
+    const signalTime = signal.pendingAt;
+    const maxTimeToWait = signal.minuteEstimatedTime * 60 * 1000;
+    const elapsedTime = closeTimestamp - signalTime;
+    if (elapsedTime < maxTimeToWait) {
+        const bufferCandlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+        const requiredCandlesCount = signal.minuteEstimatedTime + bufferCandlesCount + 1;
+        throw new Error(functoolsKit.str.newline(`ClientStrategy backtest: Insufficient candle data for pending signal. ` +
+            `Signal opened at ${new Date(signal.pendingAt).toISOString()}, ` +
+            `last candle at ${new Date(closeTimestamp).toISOString()}. ` +
+            `Elapsed: ${Math.floor(elapsedTime / 60000)}min of ${signal.minuteEstimatedTime}min required. ` +
+            `Provided ${candles.length} candles, but need at least ${requiredCandlesCount} candles. ` +
+            `\nBreakdown: ${signal.minuteEstimatedTime} candles for signal lifetime + ${bufferCandlesCount} buffer candles. ` +
+            `\nBuffer explanation: VWAP calculation requires ${GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT} candles, ` +
+            `so first ${bufferCandlesCount} candles are skipped to ensure accurate price averaging. ` +
+            `Provide complete candle range: [pendingAt - ${bufferCandlesCount}min, pendingAt + ${signal.minuteEstimatedTime}min].`));
+    }
+    const timeExpiredResult = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, lastPrice, "time_expired", closeTimestamp);
+    if (!timeExpiredResult) {
+        throw new Error(`ClientStrategy backtest: time_expired close rejected by sync (signalId=${signal.id}). ` +
+            `Retry backtest() with new candle data.`);
+    }
+    return timeExpiredResult;
 };
 /**
  * Client implementation for trading strategy lifecycle management.
@@ -7129,11 +7194,12 @@ class ClientStrategy {
                 priceOpen: scheduled.priceOpen,
                 position: scheduled.position,
             });
-            const { activated, cancelled, activationIndex, result } = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles);
-            if (cancelled && result) {
-                return result;
+            const scheduledResult = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles);
+            if (scheduledResult.outcome === "cancelled") {
+                return scheduledResult.result;
             }
-            if (activated) {
+            if (scheduledResult.outcome === "activated") {
+                const { activationIndex } = scheduledResult;
                 // КРИТИЧНО: activationIndex - индекс свечи активации в массиве candles
                 // BacktestLogicPrivateService включил буфер в начало массива, поэтому перед activationIndex достаточно свечей
                 // PROCESS_PENDING_SIGNAL_CANDLES_FN пропустит первые bufferCandlesCount свечей для VWAP
@@ -7205,40 +7271,7 @@ class ClientStrategy {
         if (candles.length < candlesCount) {
             this.params.logger.warn(`ClientStrategy backtest: Expected at least ${candlesCount} candles for VWAP, got ${candles.length}`);
         }
-        const closedResult = await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
-        if (closedResult) {
-            return closedResult;
-        }
-        // Signal didn't close during candle processing - check if we have enough data
-        const lastCandles = candles.slice(-GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
-        const lastPrice = GET_AVG_PRICE_FN(lastCandles);
-        const closeTimestamp = lastCandles[lastCandles.length - 1].timestamp;
-        const signalTime = signal.pendingAt;
-        const maxTimeToWait = signal.minuteEstimatedTime * 60 * 1000;
-        const elapsedTime = closeTimestamp - signalTime;
-        // Check if we actually reached time expiration or just ran out of candles
-        if (elapsedTime < maxTimeToWait) {
-            // EDGE CASE: backtest() called with insufficient candle data
-            const bufferCandlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
-            const requiredCandlesCount = signal.minuteEstimatedTime + bufferCandlesCount + 1;
-            throw new Error(functoolsKit.str.newline(`ClientStrategy backtest: Insufficient candle data for pending signal. ` +
-                `Signal opened at ${new Date(signal.pendingAt).toISOString()}, ` +
-                `last candle at ${new Date(closeTimestamp).toISOString()}. ` +
-                `Elapsed: ${Math.floor(elapsedTime / 60000)}min of ${signal.minuteEstimatedTime}min required. ` +
-                `Provided ${candles.length} candles, but need at least ${requiredCandlesCount} candles. ` +
-                `\nBreakdown: ${signal.minuteEstimatedTime} candles for signal lifetime + ${bufferCandlesCount} buffer candles. ` +
-                `\nBuffer explanation: VWAP calculation requires ${GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT} candles, ` +
-                `so first ${bufferCandlesCount} candles are skipped to ensure accurate price averaging. ` +
-                `Provide complete candle range: [pendingAt - ${bufferCandlesCount}min, pendingAt + ${signal.minuteEstimatedTime}min].`));
-        }
-        // Time actually expired - close with time_expired
-        const timeExpiredResult = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(this, signal, lastPrice, "time_expired", closeTimestamp);
-        if (!timeExpiredResult) {
-            // Sync rejected the close — signal remains in _pendingSignal, caller must retry
-            throw new Error(`ClientStrategy backtest: time_expired close rejected by sync (signalId=${signal.id}). ` +
-                `Retry backtest() with new candle data.`);
-        }
-        return timeExpiredResult;
+        return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
     }
     /**
      * Stops the strategy from generating new signals.
@@ -9009,11 +9042,12 @@ const CREATE_KEY_FN$o = (symbol, strategyName, exchangeName, frameName, backtest
  * @param self - Reference to StrategyConnectionService instance
  * @returns Callback function for schedule ping events
  */
-const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => functoolsKit.trycatch(async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
+const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => functoolsKit.trycatch(async (symbol, strategyName, exchangeName, data, currentPrice, backtest, timestamp) => {
     const event = {
         symbol,
         strategyName,
         exchangeName,
+        currentPrice,
         data,
         backtest,
         timestamp,
@@ -9042,11 +9076,12 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => functoolsKit.trycatch(async (sy
  * @param self - Reference to StrategyConnectionService instance
  * @returns Callback function for active ping events
  */
-const CREATE_COMMIT_ACTIVE_PING_FN = (self) => functoolsKit.trycatch(async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
+const CREATE_COMMIT_ACTIVE_PING_FN = (self) => functoolsKit.trycatch(async (symbol, strategyName, exchangeName, data, currentPrice, backtest, timestamp) => {
     const event = {
         symbol,
         strategyName,
         exchangeName,
+        currentPrice,
         data,
         backtest,
         timestamp,

package/build/index.mjs

@@ -5044,7 +5044,7 @@ const CALL_SCHEDULE_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol,
     await ExecutionContextService.runInContext(async () => {
         const publicSignal = TO_PUBLIC_SIGNAL(scheduled, currentPrice);
         // Call system onSchedulePing callback first (emits to pingSubject)
-        await self.params.onSchedulePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, self.params.execution.context.backtest, timestamp);
+        await self.params.onSchedulePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, currentPrice, self.params.execution.context.backtest, timestamp);
         // Call user onSchedulePing callback only if signal is still active (not cancelled, not activated)
         if (self.params.callbacks?.onSchedulePing) {
             await self.params.callbacks.onSchedulePing(self.params.execution.context.symbol, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
@@ -5070,7 +5070,7 @@ const CALL_ACTIVE_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, pe
     await ExecutionContextService.runInContext(async () => {
         const publicSignal = TO_PUBLIC_SIGNAL(pending, currentPrice);
         // Call system onActivePing callback first (emits to activePingSubject)
-        await self.params.onActivePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, self.params.execution.context.backtest, timestamp);
+        await self.params.onActivePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, currentPrice, self.params.execution.context.backtest, timestamp);
         // Call user onActivePing callback only if signal is still active (not closed)
         if (self.params.callbacks?.onActivePing) {
             await self.params.callbacks.onActivePing(self.params.execution.context.symbol, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
@@ -5868,6 +5868,57 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
+const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, averagePrice, closeTimestamp) => {
+    const syncCloseAllowed = await CALL_SIGNAL_SYNC_CLOSE_FN(closeTimestamp, averagePrice, "closed", closedSignal, self);
+    if (!syncCloseAllowed) {
+        self.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry", {
+            symbol: self.params.execution.context.symbol,
+            signalId: closedSignal.id,
+        });
+        self._closedSignal = null;
+        self._pendingSignal = closedSignal;
+        throw new Error(`ClientStrategy backtest: signal close rejected by sync (signalId=${closedSignal.id}). ` +
+            `Retry backtest() with new candle data.`);
+    }
+    self._closedSignal = null;
+    await CALL_COMMIT_FN(self, {
+        action: "close-pending",
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.strategyName,
+        exchangeName: self.params.exchangeName,
+        frameName: self.params.frameName,
+        signalId: closedSignal.id,
+        backtest: true,
+        closeId: closedSignal.closeId,
+        timestamp: closeTimestamp,
+        totalEntries: closedSignal._entry?.length ?? 1,
+        totalPartials: closedSignal._partial?.length ?? 0,
+        originalPriceOpen: closedSignal.priceOpen,
+        pnl: toProfitLossDto(closedSignal, averagePrice),
+    });
+    await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_BREAKEVEN_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_RISK_REMOVE_SIGNAL_FN(self, self.params.execution.context.symbol, closeTimestamp, self.params.execution.context.backtest);
+    const pnl = toProfitLossDto(closedSignal, averagePrice);
+    const result = {
+        action: "closed",
+        signal: TO_PUBLIC_SIGNAL(closedSignal, averagePrice),
+        currentPrice: averagePrice,
+        closeReason: "closed",
+        closeTimestamp,
+        pnl,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
+        symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
+        closeId: closedSignal.closeId,
+        createdAt: closeTimestamp,
+    };
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
+    return result;
+};
 const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
@@ -5885,7 +5936,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         if (self._cancelledSignal) {
             // Сигнал был отменен через cancel() в onSchedulePing
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         // КРИТИЧНО: Проверяем был ли сигнал активирован пользователем через activateScheduled()
         // Обрабатываем inline (как в tick()) с риск-проверкой по averagePrice
@@ -5899,7 +5950,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     signalId: activatedSignal.id,
                 });
                 await self.setScheduledSignal(null);
-                return { activated: false, cancelled: false, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             // Риск-проверка по 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))) {
@@ -5908,7 +5959,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     signalId: activatedSignal.id,
                 });
                 await self.setScheduledSignal(null);
-                return { activated: false, cancelled: false, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             const pendingSignal = {
                 ...activatedSignal,
@@ -5937,7 +5988,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     originalPriceOpen: activatedSignal.priceOpen,
                     pnl: toProfitLossDto(activatedSignal, averagePrice),
                 });
-                return { activated: false, cancelled: true, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             await self.setScheduledSignal(null);
             await self.setPendingSignal(pendingSignal);
@@ -5970,18 +6021,13 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
             });
             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,
-            };
+            return { outcome: "activated", activationIndex: i };
         }
         // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
         const elapsedTime = candle.timestamp - scheduled.scheduledAt;
         if (elapsedTime >= maxTimeToWait) {
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "timeout");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         let shouldActivate = false;
         let shouldCancel = false;
@@ -6019,27 +6065,17 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         }
         if (shouldCancel) {
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "price_reject");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         if (shouldActivate) {
             await ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, candle.timestamp);
-            return {
-                activated: true,
-                cancelled: false,
-                activationIndex: i,
-                result: null,
-            };
+            return { outcome: "activated", activationIndex: i };
         }
         await CALL_SCHEDULE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, candle.timestamp, true, averagePrice);
         // Process queued commit events with candle timestamp
         await PROCESS_COMMIT_QUEUE_FN(self, averagePrice, candle.timestamp);
     }
-    return {
-        activated: false,
-        cancelled: false,
-        activationIndex: -1,
-        result: null,
-    };
+    return { outcome: "pending" };
 };
 const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
@@ -6058,6 +6094,10 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         const startIndex = Math.max(0, i - (candlesCount - 1));
         const recentCandles = candles.slice(startIndex, i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // КРИТИЧНО: Проверяем был ли сигнал закрыт пользователем через closePending()
+        if (self._closedSignal) {
+            return await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
+        }
         await CALL_ACTIVE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentCandleTimestamp, true, averagePrice);
         let shouldClose = false;
         let closeReason;
@@ -6162,7 +6202,32 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         // Process queued commit events with candle timestamp
         await PROCESS_COMMIT_QUEUE_FN(self, averagePrice, currentCandleTimestamp);
     }
-    return null;
+    // Loop exhausted without closing — check if we have enough data
+    const lastCandles = candles.slice(-GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
+    const lastPrice = GET_AVG_PRICE_FN(lastCandles);
+    const closeTimestamp = lastCandles[lastCandles.length - 1].timestamp;
+    const signalTime = signal.pendingAt;
+    const maxTimeToWait = signal.minuteEstimatedTime * 60 * 1000;
+    const elapsedTime = closeTimestamp - signalTime;
+    if (elapsedTime < maxTimeToWait) {
+        const bufferCandlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+        const requiredCandlesCount = signal.minuteEstimatedTime + bufferCandlesCount + 1;
+        throw new Error(str.newline(`ClientStrategy backtest: Insufficient candle data for pending signal. ` +
+            `Signal opened at ${new Date(signal.pendingAt).toISOString()}, ` +
+            `last candle at ${new Date(closeTimestamp).toISOString()}. ` +
+            `Elapsed: ${Math.floor(elapsedTime / 60000)}min of ${signal.minuteEstimatedTime}min required. ` +
+            `Provided ${candles.length} candles, but need at least ${requiredCandlesCount} candles. ` +
+            `\nBreakdown: ${signal.minuteEstimatedTime} candles for signal lifetime + ${bufferCandlesCount} buffer candles. ` +
+            `\nBuffer explanation: VWAP calculation requires ${GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT} candles, ` +
+            `so first ${bufferCandlesCount} candles are skipped to ensure accurate price averaging. ` +
+            `Provide complete candle range: [pendingAt - ${bufferCandlesCount}min, pendingAt + ${signal.minuteEstimatedTime}min].`));
+    }
+    const timeExpiredResult = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, lastPrice, "time_expired", closeTimestamp);
+    if (!timeExpiredResult) {
+        throw new Error(`ClientStrategy backtest: time_expired close rejected by sync (signalId=${signal.id}). ` +
+            `Retry backtest() with new candle data.`);
+    }
+    return timeExpiredResult;
 };
 /**
  * Client implementation for trading strategy lifecycle management.
@@ -7109,11 +7174,12 @@ class ClientStrategy {
                 priceOpen: scheduled.priceOpen,
                 position: scheduled.position,
             });
-            const { activated, cancelled, activationIndex, result } = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles);
-            if (cancelled && result) {
-                return result;
+            const scheduledResult = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles);
+            if (scheduledResult.outcome === "cancelled") {
+                return scheduledResult.result;
             }
-            if (activated) {
+            if (scheduledResult.outcome === "activated") {
+                const { activationIndex } = scheduledResult;
                 // КРИТИЧНО: activationIndex - индекс свечи активации в массиве candles
                 // BacktestLogicPrivateService включил буфер в начало массива, поэтому перед activationIndex достаточно свечей
                 // PROCESS_PENDING_SIGNAL_CANDLES_FN пропустит первые bufferCandlesCount свечей для VWAP
@@ -7185,40 +7251,7 @@ class ClientStrategy {
         if (candles.length < candlesCount) {
             this.params.logger.warn(`ClientStrategy backtest: Expected at least ${candlesCount} candles for VWAP, got ${candles.length}`);
         }
-        const closedResult = await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
-        if (closedResult) {
-            return closedResult;
-        }
-        // Signal didn't close during candle processing - check if we have enough data
-        const lastCandles = candles.slice(-GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
-        const lastPrice = GET_AVG_PRICE_FN(lastCandles);
-        const closeTimestamp = lastCandles[lastCandles.length - 1].timestamp;
-        const signalTime = signal.pendingAt;
-        const maxTimeToWait = signal.minuteEstimatedTime * 60 * 1000;
-        const elapsedTime = closeTimestamp - signalTime;
-        // Check if we actually reached time expiration or just ran out of candles
-        if (elapsedTime < maxTimeToWait) {
-            // EDGE CASE: backtest() called with insufficient candle data
-            const bufferCandlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
-            const requiredCandlesCount = signal.minuteEstimatedTime + bufferCandlesCount + 1;
-            throw new Error(str.newline(`ClientStrategy backtest: Insufficient candle data for pending signal. ` +
-                `Signal opened at ${new Date(signal.pendingAt).toISOString()}, ` +
-                `last candle at ${new Date(closeTimestamp).toISOString()}. ` +
-                `Elapsed: ${Math.floor(elapsedTime / 60000)}min of ${signal.minuteEstimatedTime}min required. ` +
-                `Provided ${candles.length} candles, but need at least ${requiredCandlesCount} candles. ` +
-                `\nBreakdown: ${signal.minuteEstimatedTime} candles for signal lifetime + ${bufferCandlesCount} buffer candles. ` +
-                `\nBuffer explanation: VWAP calculation requires ${GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT} candles, ` +
-                `so first ${bufferCandlesCount} candles are skipped to ensure accurate price averaging. ` +
-                `Provide complete candle range: [pendingAt - ${bufferCandlesCount}min, pendingAt + ${signal.minuteEstimatedTime}min].`));
-        }
-        // Time actually expired - close with time_expired
-        const timeExpiredResult = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(this, signal, lastPrice, "time_expired", closeTimestamp);
-        if (!timeExpiredResult) {
-            // Sync rejected the close — signal remains in _pendingSignal, caller must retry
-            throw new Error(`ClientStrategy backtest: time_expired close rejected by sync (signalId=${signal.id}). ` +
-                `Retry backtest() with new candle data.`);
-        }
-        return timeExpiredResult;
+        return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
     }
     /**
      * Stops the strategy from generating new signals.
@@ -8989,11 +9022,12 @@ const CREATE_KEY_FN$o = (symbol, strategyName, exchangeName, frameName, backtest
  * @param self - Reference to StrategyConnectionService instance
  * @returns Callback function for schedule ping events
  */
-const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
+const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, data, currentPrice, backtest, timestamp) => {
     const event = {
         symbol,
         strategyName,
         exchangeName,
+        currentPrice,
         data,
         backtest,
         timestamp,
@@ -9022,11 +9056,12 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strateg
  * @param self - Reference to StrategyConnectionService instance
  * @returns Callback function for active ping events
  */
-const CREATE_COMMIT_ACTIVE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
+const CREATE_COMMIT_ACTIVE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, data, currentPrice, backtest, timestamp) => {
     const event = {
         symbol,
         strategyName,
         exchangeName,
+        currentPrice,
         data,
         backtest,
         timestamp,

package/package.json

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

package/types.d.ts

@@ -941,6 +941,13 @@ interface SchedulePingContract {
      * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss, etc.
      */
     data: IScheduledSignalRow;
+    /**
+     * Current market price of the symbol at the time of the ping.
+     * Useful for users to implement custom monitoring logic based on price conditions.
+     * For example, users can choose to cancel the scheduled signal if the price moves too far from priceOpen.
+     * Note: This is the current price at the time of the ping, not necessarily the priceOpen of the signal.
+     */
+    currentPrice: number;
     /**
      * Execution mode flag.
      * - true: Event from backtest execution (historical candle data)
@@ -1015,6 +1022,13 @@ interface ActivePingContract {
      * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss, etc.
      */
     data: ISignalRow;
+    /**
+     * Current market price of the symbol at the time of the ping.
+     * Useful for users to implement custom management logic based on price conditions.
+     * For example, users can choose to close the pending signal if the price moves too far from priceOpen.
+     * Note: This is the current price at the time of the ping, not necessarily the priceOpen of the signal.
+     */
+    currentPrice: number;
     /**
      * Execution mode flag.
      * - true: Event from backtest execution (historical candle data)