backtest-kit 1.5.47 → 1.6.2

package/build/index.cjs

@@ -1746,6 +1746,12 @@ const partialLossSubject = new functoolsKit.Subject();
  * Does not emit for allowed signals (prevents spam).
  */
 const riskSubject = new functoolsKit.Subject();
+/**
+ * Ping emitter for scheduled signal monitoring events.
+ * Emits every minute when a scheduled signal is being monitored (waiting for activation).
+ * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
+ */
+const pingSubject = new functoolsKit.Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1757,6 +1763,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
+    pingSubject: pingSubject,
     progressBacktestEmitter: progressBacktestEmitter,
     progressOptimizerEmitter: progressOptimizerEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
@@ -2160,7 +2167,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
 }, {
     defaultValue: null,
     fallback: (error) => {
-        const message = "ClientStrategy exception thrown";
+        const message = "ClientStrategy GET_SIGNAL_FN thrown";
         const payload = {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
@@ -2245,6 +2252,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
+        reason: "timeout",
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -2281,7 +2289,7 @@ const CHECK_SCHEDULED_SIGNAL_PRICE_ACTIVATION_FN = (scheduled, currentPrice) =>
     return { shouldActivate, shouldCancel };
 };
 const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPrice) => {
-    self.params.logger.info("ClientStrategy scheduled signal cancelled", {
+    self.params.logger.info("ClientStrategy scheduled signal cancelled by StopLoss", {
         symbol: self.params.execution.context.symbol,
         signalId: scheduled.id,
         position: scheduled.position,
@@ -2289,14 +2297,19 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
         priceStopLoss: scheduled.priceStopLoss,
     });
     await self.setScheduledSignal(null);
+    if (self.params.callbacks?.onCancel) {
+        self.params.callbacks.onCancel(self.params.execution.context.symbol, scheduled, currentPrice, self.params.execution.context.backtest);
+    }
     const result = {
-        action: "idle",
-        signal: null,
+        action: "cancelled",
+        signal: scheduled,
+        currentPrice: currentPrice,
+        closeTimestamp: self.params.execution.context.when.getTime(),
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
-        currentPrice: currentPrice,
         backtest: self.params.execution.context.backtest,
+        reason: "price_reject",
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -2371,7 +2384,27 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
     }
     return result;
 };
+const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, scheduled, timestamp) => {
+    // Call system onPing callback first (emits to pingSubject)
+    await self.params.onPing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, scheduled, self.params.execution.context.backtest, timestamp);
+    // Call user onPing callback only if signal is still active (not cancelled, not activated)
+    if (self.params.callbacks?.onPing) {
+        await self.params.callbacks.onPing(self.params.execution.context.symbol, scheduled, new Date(timestamp), self.params.execution.context.backtest);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_PING_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    }
+});
 const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice) => {
+    await CALL_PING_CALLBACKS_FN(self, scheduled, self.params.execution.context.when.getTime());
     const result = {
         action: "active",
         signal: scheduled,
@@ -2599,13 +2632,14 @@ const RETURN_IDLE_FN = async (self, currentPrice) => {
     }
     return result;
 };
-const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePrice, closeTimestamp) => {
+const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePrice, closeTimestamp, reason) => {
     self.params.logger.info("ClientStrategy backtest scheduled signal cancelled", {
         symbol: self.params.execution.context.symbol,
         signalId: scheduled.id,
         closeTimestamp,
         averagePrice,
         priceStopLoss: scheduled.priceStopLoss,
+        reason,
     });
     await self.setScheduledSignal(null);
     if (self.params.callbacks?.onCancel) {
@@ -2620,6 +2654,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         exchangeName: self.params.method.context.exchangeName,
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
+        reason,
     };
     if (self.params.callbacks?.onTick) {
         self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
@@ -2735,10 +2770,16 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         }
         const recentCandles = candles.slice(Math.max(0, i - (candlesCount - 1)), i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // КРИТИЧНО: Проверяем был ли сигнал отменен пользователем через cancel()
+        if (self._cancelledSignal) {
+            // Сигнал был отменен через cancel() в onPing
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user");
+            return { activated: false, cancelled: true, activationIndex: i, result };
+        }
         // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
         const elapsedTime = candle.timestamp - scheduled.scheduledAt;
         if (elapsedTime >= maxTimeToWait) {
-            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp);
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "timeout");
             return { activated: false, cancelled: true, activationIndex: i, result };
         }
         let shouldActivate = false;
@@ -2776,7 +2817,7 @@ 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);
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "price_reject");
             return { activated: false, cancelled: true, activationIndex: i, result };
         }
         if (shouldActivate) {
@@ -2788,6 +2829,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                 result: null,
             };
         }
+        await CALL_PING_CALLBACKS_FN(self, scheduled, candle.timestamp);
     }
     return {
         activated: false,
@@ -2941,8 +2983,9 @@ class ClientStrategy {
         this.params = params;
         this._isStopped = false;
         this._pendingSignal = null;
-        this._scheduledSignal = null;
         this._lastSignalTimestamp = null;
+        this._scheduledSignal = null;
+        this._cancelledSignal = null;
         /**
          * Initializes strategy state by loading persisted signal from disk.
          *
@@ -3009,6 +3052,18 @@ class ClientStrategy {
         });
         return this._pendingSignal;
     }
+    /**
+     * Retrieves the current scheduled signal.
+     * If no scheduled signal exists, returns null.
+     * @returns Promise resolving to the scheduled signal or null.
+     */
+    async getScheduledSignal(symbol, strategyName) {
+        this.params.logger.debug("ClientStrategy getScheduledSignal", {
+            symbol,
+            strategyName,
+        });
+        return this._scheduledSignal;
+    }
     /**
      * Returns the stopped state of the strategy.
      *
@@ -3068,6 +3123,33 @@ class ClientStrategy {
             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
+        if (this._cancelledSignal) {
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            const cancelledSignal = this._cancelledSignal;
+            this._cancelledSignal = null; // Clear after emitting
+            this.params.logger.info("ClientStrategy tick: scheduled signal was cancelled", {
+                symbol: this.params.execution.context.symbol,
+                signalId: cancelledSignal.id,
+            });
+            // Call onCancel callback
+            if (this.params.callbacks?.onCancel) {
+                this.params.callbacks.onCancel(this.params.execution.context.symbol, cancelledSignal, currentPrice, this.params.execution.context.backtest);
+            }
+            const result = {
+                action: "cancelled",
+                signal: cancelledSignal,
+                currentPrice,
+                closeTimestamp: currentTime,
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                symbol: this.params.execution.context.symbol,
+                backtest: this.params.execution.context.backtest,
+                reason: "user",
+                cancelId: cancelledSignal.cancelId,
+            };
+            return result;
+        }
         // Monitor scheduled signal
         if (this._scheduledSignal && !this._pendingSignal) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
@@ -3158,6 +3240,29 @@ class ClientStrategy {
         if (!this.params.execution.context.backtest) {
             throw new Error("ClientStrategy backtest: running in live context");
         }
+        // If signal was cancelled - return cancelled
+        if (this._cancelledSignal) {
+            this.params.logger.debug("ClientStrategy backtest: no signal (cancelled or not created)");
+            const currentPrice = await this.params.exchange.getAveragePrice(symbol);
+            const cancelledSignal = this._cancelledSignal;
+            this._cancelledSignal = null; // Clear after using
+            if (this.params.callbacks?.onCancel) {
+                this.params.callbacks.onCancel(this.params.execution.context.symbol, cancelledSignal, currentPrice, this.params.execution.context.backtest);
+            }
+            const cancelledResult = {
+                action: "cancelled",
+                signal: cancelledSignal,
+                currentPrice,
+                closeTimestamp: this.params.execution.context.when.getTime(),
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                symbol: this.params.execution.context.symbol,
+                backtest: true,
+                reason: "user",
+                cancelId: cancelledSignal.cancelId,
+            };
+            return cancelledResult;
+        }
         if (!this._pendingSignal && !this._scheduledSignal) {
             throw new Error("ClientStrategy backtest: no pending or scheduled signal");
         }
@@ -3230,7 +3335,7 @@ class ClientStrategy {
                     maxMinutes: GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES,
                     reason: "timeout - price never reached priceOpen",
                 });
-                return await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(this, scheduled, lastPrice, lastCandleTimestamp);
+                return await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(this, scheduled, lastPrice, lastCandleTimestamp, "timeout");
             }
         }
         // Process pending signal
@@ -3288,6 +3393,47 @@ class ClientStrategy {
         }
         await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, strategyName);
     }
+    /**
+     * Cancels the scheduled signal without stopping the strategy.
+     *
+     * Clears the scheduled signal (waiting for priceOpen activation).
+     * Does NOT affect active pending signals or strategy operation.
+     * Does NOT set stop flag - strategy can continue generating new signals.
+     *
+     * Use case: Cancel a scheduled entry that is no longer desired without stopping the entire strategy.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Name of the strategy
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise that resolves when scheduled signal is cleared
+     *
+     * @example
+     * ```typescript
+     * // Cancel scheduled signal without stopping strategy
+     * await strategy.cancel("BTCUSDT", "my-strategy", false);
+     * // Strategy continues, can generate new signals
+     * ```
+     */
+    async cancel(symbol, strategyName, backtest, cancelId) {
+        this.params.logger.debug("ClientStrategy cancel", {
+            symbol,
+            strategyName,
+            hasScheduledSignal: this._scheduledSignal !== null,
+            backtest,
+            cancelId,
+        });
+        // Save cancelled signal for next tick to emit cancelled event
+        if (this._scheduledSignal) {
+            this._cancelledSignal = Object.assign({}, this._scheduledSignal, {
+                cancelId,
+            });
+            this._scheduledSignal = null;
+        }
+        if (backtest) {
+            return;
+        }
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, strategyName);
+    }
 }
 
 const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
@@ -3614,6 +3760,27 @@ const GET_RISK_FN = (dto, backtest, self) => {
         ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)),
     ]);
 };
+/**
+ * Callback function for emitting ping events to pingSubject.
+ *
+ * Called by ClientStrategy when a scheduled signal is being monitored every minute.
+ * Emits PingContract event to all subscribers.
+ *
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy name that is monitoring this scheduled signal
+ * @param exchangeName - Exchange name where this scheduled signal is being executed
+ * @param data - Scheduled signal row data
+ * @param backtest - True if backtest mode
+ * @param timestamp - Event timestamp in milliseconds
+ */
+const COMMIT_PING_FN = async (symbol, strategyName, exchangeName, data, backtest, timestamp) => await pingSubject.next({
+    symbol,
+    strategyName,
+    exchangeName,
+    data,
+    backtest,
+    timestamp,
+});
 /**
  * Connection service routing strategy operations to correct ClientStrategy instance.
  *
@@ -3671,6 +3838,7 @@ class StrategyConnectionService {
                 strategyName,
                 getSignal,
                 callbacks,
+                onPing: COMMIT_PING_FN,
             });
         });
         /**
@@ -3692,6 +3860,25 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, strategyName, backtest);
             return await strategy.getPendingSignal(symbol, strategyName);
         };
+        /**
+         * Retrieves the currently active scheduled signal for the strategy.
+         * If no scheduled signal exists, returns null.
+         * Used internally for monitoring scheduled signal activation.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get scheduled signal for
+         *
+         * @returns Promise resolving to scheduled signal or null
+         */
+        this.getScheduledSignal = async (backtest, symbol, strategyName) => {
+            this.loggerService.log("strategyConnectionService getScheduledSignal", {
+                symbol,
+                strategyName,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
+            return await strategy.getScheduledSignal(symbol, strategyName);
+        };
         /**
          * Retrieves the stopped state of the strategy.
          *
@@ -3807,6 +3994,28 @@ class StrategyConnectionService {
                 this.getStrategy.clear();
             }
         };
+        /**
+         * Cancels the scheduled signal for the specified strategy.
+         *
+         * Delegates to ClientStrategy.cancel() which clears the scheduled signal
+         * without stopping the strategy or affecting pending signals.
+         *
+         * Note: Cancelled event will be emitted on next tick() call when strategy
+         * detects the scheduled signal was cancelled.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param ctx - Context with symbol and strategyName
+         * @param cancelId - Optional cancellation ID for user-initiated cancellations
+         * @returns Promise that resolves when scheduled signal is cancelled
+         */
+        this.cancel = async (backtest, ctx, cancelId) => {
+            this.loggerService.log("strategyConnectionService cancel", {
+                ctx,
+                cancelId,
+            });
+            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName, backtest);
+            await strategy.cancel(ctx.symbol, ctx.strategyName, backtest, cancelId);
+        };
     }
 }
 
@@ -4752,6 +4961,26 @@ class StrategyCoreService {
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getPendingSignal(backtest, symbol, strategyName);
         };
+        /**
+         * Retrieves the currently active scheduled signal for the symbol.
+         * If no scheduled signal exists, returns null.
+         * Used internally for monitoring scheduled signal activation.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of the strategy
+         * @returns Promise resolving to scheduled signal or null
+         */
+        this.getScheduledSignal = async (backtest, symbol, strategyName) => {
+            this.loggerService.log("strategyCoreService getScheduledSignal", {
+                symbol,
+                strategyName,
+            });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("strategyCoreService getScheduledSignal requires a method context");
+            }
+            await this.validate(symbol, strategyName);
+            return await this.strategyConnectionService.getScheduledSignal(backtest, symbol, strategyName);
+        };
         /**
          * Checks if the strategy has been stopped.
          *
@@ -4854,6 +5083,27 @@ class StrategyCoreService {
             await this.validate(ctx.symbol, ctx.strategyName);
             return await this.strategyConnectionService.stop(backtest, ctx);
         };
+        /**
+         * Cancels the scheduled signal without stopping the strategy.
+         *
+         * Delegates to StrategyConnectionService.cancel() to clear scheduled signal
+         * and emit cancelled event through emitters.
+         * Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param ctx - Context with symbol and strategyName
+         * @param cancelId - Optional cancellation ID for user-initiated cancellations
+         * @returns Promise that resolves when scheduled signal is cancelled
+         */
+        this.cancel = async (backtest, ctx, cancelId) => {
+            this.loggerService.log("strategyCoreService cancel", {
+                ctx,
+                backtest,
+                cancelId,
+            });
+            await this.validate(ctx.symbol, ctx.strategyName);
+            return await this.strategyConnectionService.cancel(backtest, ctx, cancelId);
+        };
         /**
          * Clears the memoized ClientStrategy instance from cache.
          *
@@ -7177,12 +7427,17 @@ const risk_columns = [
  * - Signal identification (symbol, signal ID, position)
  * - Price data (current price, entry price, take profit, stop loss)
  * - Timing information (wait time in minutes before activation or cancellation)
+ * - Cancellation details (reason: timeout/stoploss/user, optional user cancel ID)
  *
  * @remarks
  * This configuration tracks the lifecycle of scheduled signals from creation to activation or cancellation.
  * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
  * Helps analyze signal scheduling effectiveness and cancellation patterns.
  *
+ * Cancellation tracking includes:
+ * - cancelReason: "timeout" (expired wait time), "price_reject" (price hit SL), "user" (manual cancellation)
+ * - cancelId: Optional ID provided when calling Backtest.cancel() or Live.cancel()
+ *
  * @example
  * ```typescript
  * import { schedule_columns } from "./assets/schedule.columns";
@@ -7191,9 +7446,9 @@ const risk_columns = [
  * const service = new ScheduleMarkdownService();
  * await service.getReport("BTCUSDT", "my-strategy", schedule_columns);
  *
- * // Or customize for timing analysis
+ * // Or customize for cancellation analysis
  * const customColumns = schedule_columns.filter(col =>
- *   ["timestamp", "action", "symbol", "duration"].includes(col.key)
+ *   ["timestamp", "action", "cancelReason", "cancelId"].includes(col.key)
  * );
  * await service.getReport("BTCUSDT", "my-strategy", customColumns);
  * ```
@@ -7242,7 +7497,7 @@ const schedule_columns = [
     {
         key: "currentPrice",
         label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        format: (data) => data.currentPrice ? `${data.currentPrice.toFixed(8)} USD` : "N/A",
         isVisible: () => true,
     },
     {
@@ -7269,6 +7524,18 @@ const schedule_columns = [
         format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "cancelReason",
+        label: "Cancel Reason",
+        format: (data) => data.cancelReason ? data.cancelReason.toUpperCase() : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "cancelId",
+        label: "Cancel ID",
+        format: (data) => data.cancelId ?? "N/A",
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -8449,6 +8716,8 @@ let ReportStorage$3 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
             closeTimestamp: data.closeTimestamp,
             duration: durationMin,
+            cancelReason: data.reason,
+            cancelId: data.cancelId,
         };
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
@@ -14729,6 +14998,8 @@ const LISTEN_PARTIAL_LOSS_METHOD_NAME = "event.listenPartialLoss";
 const LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME = "event.listenPartialLossOnce";
 const LISTEN_RISK_METHOD_NAME = "event.listenRisk";
 const LISTEN_RISK_ONCE_METHOD_NAME = "event.listenRiskOnce";
+const LISTEN_PING_METHOD_NAME = "event.listenPing";
+const LISTEN_PING_ONCE_METHOD_NAME = "event.listenPingOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -15596,6 +15867,67 @@ function listenRiskOnce(filterFn, fn) {
     backtest$1.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
     return riskSubject.filter(filterFn).once(fn);
 }
+/**
+ * Subscribes to ping events during scheduled signal monitoring with queued async processing.
+ *
+ * Events are emitted every minute when a scheduled signal is being monitored (waiting for activation).
+ * Allows tracking of scheduled signal lifecycle and custom monitoring logic.
+ *
+ * @param fn - Callback function to handle ping events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenPing } from "./function/event";
+ *
+ * const unsubscribe = listenPing((event) => {
+ *   console.log(`Ping for ${event.symbol} at ${new Date(event.timestamp).toISOString()}`);
+ *   console.log(`Strategy: ${event.strategyName}, Exchange: ${event.exchangeName}`);
+ *   console.log(`Mode: ${event.backtest ? "Backtest" : "Live"}`);
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenPing(fn) {
+    backtest$1.loggerService.log(LISTEN_PING_METHOD_NAME);
+    return pingSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered ping events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific ping conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenPingOnce } from "./function/event";
+ *
+ * // Wait for first ping on BTCUSDT
+ * listenPingOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => console.log("First BTCUSDT ping received")
+ * );
+ *
+ * // Wait for ping in backtest mode
+ * const cancel = listenPingOnce(
+ *   (event) => event.backtest === true,
+ *   (event) => console.log("Backtest ping received at", new Date(event.timestamp))
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
+ * ```
+ */
+function listenPingOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_PING_ONCE_METHOD_NAME);
+    return pingSubject.filter(filterFn).once(fn);
+}
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
@@ -15869,6 +16201,8 @@ const BACKTEST_METHOD_NAME_GET_REPORT = "BacktestUtils.getReport";
 const BACKTEST_METHOD_NAME_DUMP = "BacktestUtils.dump";
 const BACKTEST_METHOD_NAME_TASK = "BacktestUtils.task";
 const BACKTEST_METHOD_NAME_GET_STATUS = "BacktestUtils.getStatus";
+const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal";
+const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
 /**
  * Internal task function that runs backtest and handles completion.
  * Consumes backtest results and updates instance state flags.
@@ -16059,6 +16393,54 @@ class BacktestInstance {
                 this._isStopped = true;
             };
         };
+        /**
+         * Retrieves the currently active pending signal for the strategy.
+         * If no active signal exists, returns null.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get pending signal for
+         * @returns Promise resolving to pending signal or null
+         *
+         * @example
+         * ```typescript
+         * const instance = new BacktestInstance();
+         * const pending = await instance.getPendingSignal("BTCUSDT", "my-strategy");
+         * if (pending) {
+         *   console.log("Active signal:", pending.id);
+         * }
+         * ```
+         */
+        this.getPendingSignal = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL, {
+                symbol,
+                strategyName,
+            });
+            return await backtest$1.strategyCoreService.getPendingSignal(true, symbol, strategyName);
+        };
+        /**
+         * Retrieves the currently active scheduled signal for the strategy.
+         * If no scheduled signal exists, returns null.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get scheduled signal for
+         * @returns Promise resolving to scheduled signal or null
+         *
+         * @example
+         * ```typescript
+         * const instance = new BacktestInstance();
+         * const scheduled = await instance.getScheduledSignal("BTCUSDT", "my-strategy");
+         * if (scheduled) {
+         *   console.log("Scheduled signal:", scheduled.id);
+         * }
+         * ```
+         */
+        this.getScheduledSignal = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL, {
+                symbol,
+                strategyName,
+            });
+            return await backtest$1.strategyCoreService.getScheduledSignal(true, symbol, strategyName);
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -16083,6 +16465,32 @@ class BacktestInstance {
             });
             await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
         };
+        /**
+         * Cancels the scheduled signal without stopping the strategy.
+         *
+         * Clears the scheduled signal (waiting for priceOpen activation).
+         * Does NOT affect active pending signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name
+         * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
+         * @returns Promise that resolves when scheduled signal is cancelled
+         *
+         * @example
+         * ```typescript
+         * const instance = new BacktestInstance();
+         * await instance.cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+         * ```
+         */
+        this.cancel = async (symbol, strategyName, cancelId) => {
+            backtest$1.loggerService.info("BacktestInstance.cancel", {
+                symbol,
+                strategyName,
+                cancelId,
+            });
+            await backtest$1.strategyCoreService.cancel(true, { symbol, strategyName }, cancelId);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -16234,6 +16642,58 @@ class BacktestUtils {
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.background(symbol, context);
         };
+        /**
+         * Retrieves the currently active pending signal for the strategy.
+         * If no active signal exists, returns null.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get pending signal for
+         * @returns Promise resolving to pending signal or null
+         *
+         * @example
+         * ```typescript
+         * const pending = await Backtest.getPendingSignal("BTCUSDT", "my-strategy");
+         * if (pending) {
+         *   console.log("Active signal:", pending.id);
+         * }
+         * ```
+         */
+        this.getPendingSignal = async (symbol, strategyName) => {
+            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL));
+            }
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getPendingSignal(symbol, strategyName);
+        };
+        /**
+         * Retrieves the currently active scheduled signal for the strategy.
+         * If no scheduled signal exists, returns null.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get scheduled signal for
+         * @returns Promise resolving to scheduled signal or null
+         *
+         * @example
+         * ```typescript
+         * const scheduled = await Backtest.getScheduledSignal("BTCUSDT", "my-strategy");
+         * if (scheduled) {
+         *   console.log("Scheduled signal:", scheduled.id);
+         * }
+         * ```
+         */
+        this.getScheduledSignal = async (symbol, strategyName) => {
+            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL));
+            }
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getScheduledSignal(symbol, strategyName);
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -16261,6 +16721,34 @@ class BacktestUtils {
             const instance = this._getInstance(symbol, strategyName);
             return await instance.stop(symbol, strategyName);
         };
+        /**
+         * Cancels the scheduled signal without stopping the strategy.
+         *
+         * Clears the scheduled signal (waiting for priceOpen activation).
+         * Does NOT affect active pending signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name
+         * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
+         * @returns Promise that resolves when scheduled signal is cancelled
+         *
+         * @example
+         * ```typescript
+         * // Cancel scheduled signal with custom ID
+         * await Backtest.cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+         * ```
+         */
+        this.cancel = async (symbol, strategyName, cancelId) => {
+            backtest$1.strategyValidationService.validate(strategyName, "BacktestUtils.cancel");
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, "BacktestUtils.cancel");
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, "BacktestUtils.cancel"));
+            }
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.cancel(symbol, strategyName, cancelId);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -16382,6 +16870,9 @@ const LIVE_METHOD_NAME_GET_DATA = "LiveUtils.getData";
 const LIVE_METHOD_NAME_DUMP = "LiveUtils.dump";
 const LIVE_METHOD_NAME_TASK = "LiveUtils.task";
 const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
+const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
+const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
+const LIVE_METHOD_NAME_CANCEL = "LiveUtils.cancel";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -16576,6 +17067,54 @@ class LiveInstance {
                 this._isStopped = true;
             };
         };
+        /**
+         * Retrieves the currently active pending signal for the strategy.
+         * If no active signal exists, returns null.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get pending signal for
+         * @returns Promise resolving to pending signal or null
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * const pending = await instance.getPendingSignal("BTCUSDT", "my-strategy");
+         * if (pending) {
+         *   console.log("Active signal:", pending.id);
+         * }
+         * ```
+         */
+        this.getPendingSignal = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_PENDING_SIGNAL, {
+                symbol,
+                strategyName,
+            });
+            return await backtest$1.strategyCoreService.getPendingSignal(false, symbol, strategyName);
+        };
+        /**
+         * Retrieves the currently active scheduled signal for the strategy.
+         * If no scheduled signal exists, returns null.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get scheduled signal for
+         * @returns Promise resolving to scheduled signal or null
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * const scheduled = await instance.getScheduledSignal("BTCUSDT", "my-strategy");
+         * if (scheduled) {
+         *   console.log("Scheduled signal:", scheduled.id);
+         * }
+         * ```
+         */
+        this.getScheduledSignal = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL, {
+                symbol,
+                strategyName,
+            });
+            return await backtest$1.strategyCoreService.getScheduledSignal(false, symbol, strategyName);
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -16600,6 +17139,32 @@ class LiveInstance {
             });
             await backtest$1.strategyCoreService.stop(false, { symbol, strategyName });
         };
+        /**
+         * Cancels the scheduled signal without stopping the strategy.
+         *
+         * Clears the scheduled signal (waiting for priceOpen activation).
+         * Does NOT affect active pending signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name
+         * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
+         * @returns Promise that resolves when scheduled signal is cancelled
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * await instance.cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+         * ```
+         */
+        this.cancel = async (symbol, strategyName, cancelId) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_CANCEL, {
+                symbol,
+                strategyName,
+                cancelId,
+            });
+            await backtest$1.strategyCoreService.cancel(false, { symbol, strategyName }, cancelId);
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -16762,6 +17327,58 @@ class LiveUtils {
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.background(symbol, context);
         };
+        /**
+         * Retrieves the currently active pending signal for the strategy.
+         * If no active signal exists, returns null.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get pending signal for
+         * @returns Promise resolving to pending signal or null
+         *
+         * @example
+         * ```typescript
+         * const pending = await Live.getPendingSignal("BTCUSDT", "my-strategy");
+         * if (pending) {
+         *   console.log("Active signal:", pending.id);
+         * }
+         * ```
+         */
+        this.getPendingSignal = async (symbol, strategyName) => {
+            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL));
+            }
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getPendingSignal(symbol, strategyName);
+        };
+        /**
+         * Retrieves the currently active scheduled signal for the strategy.
+         * If no scheduled signal exists, returns null.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to get scheduled signal for
+         * @returns Promise resolving to scheduled signal or null
+         *
+         * @example
+         * ```typescript
+         * const scheduled = await Live.getScheduledSignal("BTCUSDT", "my-strategy");
+         * if (scheduled) {
+         *   console.log("Scheduled signal:", scheduled.id);
+         * }
+         * ```
+         */
+        this.getScheduledSignal = async (symbol, strategyName) => {
+            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL));
+            }
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getScheduledSignal(symbol, strategyName);
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -16789,6 +17406,34 @@ class LiveUtils {
             const instance = this._getInstance(symbol, strategyName);
             return await instance.stop(symbol, strategyName);
         };
+        /**
+         * Cancels the scheduled signal without stopping the strategy.
+         *
+         * Clears the scheduled signal (waiting for priceOpen activation).
+         * Does NOT affect active pending signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name
+         * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
+         * @returns Promise that resolves when scheduled signal is cancelled
+         *
+         * @example
+         * ```typescript
+         * // Cancel scheduled signal in live trading with custom ID
+         * await Live.cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+         * ```
+         */
+        this.cancel = async (symbol, strategyName, cancelId) => {
+            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_CANCEL);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL));
+            }
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.cancel(symbol, strategyName, cancelId);
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -19012,6 +19657,8 @@ exports.listenPartialLossOnce = listenPartialLossOnce;
 exports.listenPartialProfit = listenPartialProfit;
 exports.listenPartialProfitOnce = listenPartialProfitOnce;
 exports.listenPerformance = listenPerformance;
+exports.listenPing = listenPing;
+exports.listenPingOnce = listenPingOnce;
 exports.listenRisk = listenRisk;
 exports.listenRiskOnce = listenRiskOnce;
 exports.listenSignal = listenSignal;