backtest-kit 1.5.47 → 1.6.1

package/build/index.mjs

@@ -1744,6 +1744,12 @@ const partialLossSubject = new Subject();
  * Does not emit for allowed signals (prevents spam).
  */
 const riskSubject = new 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 Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1755,6 +1761,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
+    pingSubject: pingSubject,
     progressBacktestEmitter: progressBacktestEmitter,
     progressOptimizerEmitter: progressOptimizerEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
@@ -2243,6 +2250,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);
@@ -2279,7 +2287,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,
@@ -2287,14 +2295,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);
@@ -2369,7 +2382,16 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
     }
     return result;
 };
+const CALL_PING_CALLBACKS_FN = 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);
+    }
+};
 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,
@@ -2597,13 +2619,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) {
@@ -2618,6 +2641,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);
@@ -2733,10 +2757,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;
@@ -2774,7 +2804,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) {
@@ -2786,6 +2816,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,
@@ -2939,8 +2970,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.
          *
@@ -3007,6 +3039,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.
      *
@@ -3066,6 +3110,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);
@@ -3156,6 +3227,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");
         }
@@ -3228,7 +3322,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
@@ -3286,6 +3380,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";
@@ -3612,6 +3747,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.
  *
@@ -3669,6 +3825,7 @@ class StrategyConnectionService {
                 strategyName,
                 getSignal,
                 callbacks,
+                onPing: COMMIT_PING_FN,
             });
         });
         /**
@@ -3690,6 +3847,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.
          *
@@ -3805,6 +3981,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);
+        };
     }
 }
 
@@ -4750,6 +4948,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.
          *
@@ -4852,6 +5070,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.
          *
@@ -7175,12 +7414,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";
@@ -7189,9 +7433,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);
  * ```
@@ -7240,7 +7484,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,
     },
     {
@@ -7267,6 +7511,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,
+    },
 ];
 
 /**
@@ -8447,6 +8703,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
@@ -14727,6 +14985,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.
  *
@@ -15594,6 +15854,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(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";
@@ -15867,6 +16188,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.
@@ -16057,6 +16380,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.
          *
@@ -16081,6 +16452,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.
          *
@@ -16232,6 +16629,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.
          *
@@ -16259,6 +16708,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.
          *
@@ -16380,6 +16857,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.
@@ -16574,6 +17054,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.
          *
@@ -16598,6 +17126,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.
          *
@@ -16760,6 +17314,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.
          *
@@ -16787,6 +17393,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.
          *
@@ -18947,4 +19581,4 @@ class CacheUtils {
  */
 const Cache = new CacheUtils();
 
-export { Backtest, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setColumns, setConfig, setLogger, validate };
+export { Backtest, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setColumns, setConfig, setLogger, validate };