backtest-kit 5.6.2 → 5.6.4

package/build/index.cjs

@@ -6475,6 +6475,18 @@ class ClientStrategy {
         });
         return this._pendingSignal !== null;
     }
+    /**
+     * Checks if there is a scheduled signal.
+     *
+     * @param symbol - Trading symbol to check for scheduled signal
+     * @returns Promise resolving to true if a scheduled signal exists, false otherwise
+     */
+    async hasScheduledSignal(symbol) {
+        this.params.logger.debug("ClientStrategy hasScheduledSignal", {
+            symbol,
+        });
+        return this._scheduledSignal !== null;
+    }
     /**
      * Updates pending signal and persists to disk in live mode.
      *
@@ -10034,6 +10046,22 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.hasPendingSignal(symbol);
         };
+        /**
+         * Checks if there is an active scheduled signal for the strategy.
+         * Delegates to ClientStrategy.hasScheduledSignal() which checks if there is a waiting position signal
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to true if there is a waiting scheduled signal, false otherwise
+         */
+        this.hasScheduledSignal = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService hasScheduledSignal", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.hasScheduledSignal(symbol);
+        };
         /**
          * Returns the original estimated duration for the current pending signal.
          *
@@ -14385,6 +14413,24 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.hasPendingSignal(backtest, symbol, context);
         };
+        /**
+         * Checks if there is a waiting scheduled signal for the symbol.
+         * Validates strategy existence and delegates to connection service
+         * to check if a scheduled signal exists for the symbol.
+         * Does not require execution context as this is a state query operation.
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if scheduled signal exists, false otherwise
+         */
+        this.hasScheduledSignal = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService hasScheduledSignal", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.hasScheduledSignal(backtest, symbol, context);
+        };
         /**
          * Returns the original estimated duration for the current pending signal.
          *
@@ -36018,6 +36064,13 @@ function listenStrategyCommitOnce(filterFn, fn) {
  */
 function listenSync(fn) {
     bt.loggerService.log(LISTEN_SYNC_METHOD_NAME);
+    {
+        console.error("listenSync is unwanted cause exchange integration should be implemented in Broker.useBrokerAdapter as an infrastructure domain layer");
+        console.error("If you need to implement custom logic on signal open/close, please use signal(), signalBacktest(), signalLive() in addActionSchema handler");
+        console.error("If listenSync throws the exchange will not execute the order!");
+        console.error("");
+        console.error("You have been warned!");
+    }
     return syncSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -36030,6 +36083,13 @@ function listenSync(fn) {
  */
 function listenSyncOnce(filterFn, fn) {
     bt.loggerService.log(LISTEN_SYNC_ONCE_METHOD_NAME);
+    {
+        console.error("listenSyncOnce is unwanted cause exchange integration should be implemented in Broker.useBrokerAdapter as an infrastructure domain layer");
+        console.error("If you need to implement custom logic on signal open/close, please use signal(), signalBacktest(), signalLive() in addActionSchema handler");
+        console.error("If listenSyncOnce throws the exchange WILL EXECUTE the order!");
+        console.error("");
+        console.error("You have been warned!");
+    }
     return syncSubject.filter(filterFn).once(fn);
 }
 /**
@@ -36104,6 +36164,8 @@ const BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST = "BacktestUtils.commitTrailingT
 const BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED = "Backtest.commitActivateScheduled";
 const BACKTEST_METHOD_NAME_AVERAGE_BUY = "Backtest.commitAverageBuy";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
+const BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL = "BacktestUtils.hasNoPendingSignal";
+const BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL = "BacktestUtils.hasNoScheduledSignal";
 /**
  * Internal task function that runs backtest and handles completion.
  * Consumes backtest results and updates instance state flags.
@@ -36607,6 +36669,74 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getScheduledSignal(true, symbol, currentPrice, context);
         };
+        /**
+         * Returns true if there is NO active pending signal for the given symbol.
+         *
+         * Inverse of strategyCoreService.hasPendingSignal. Use to guard signal generation logic.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if no pending signal exists, false if one does
+         *
+         * @example
+         * ```typescript
+         * if (await Backtest.hasNoPendingSignal("BTCUSDT", { strategyName, exchangeName, frameName })) {
+         *   // safe to open a new position
+         * }
+         * ```
+         */
+        this.hasNoPendingSignal = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL));
+            }
+            return await functoolsKit.not(bt.strategyCoreService.hasPendingSignal(true, symbol, context));
+        };
+        /**
+         * Returns true if there is NO active scheduled signal for the given symbol.
+         *
+         * Inverse of strategyCoreService.hasScheduledSignal. Use to guard signal generation logic.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if no scheduled signal exists, false if one does
+         *
+         * @example
+         * ```typescript
+         * if (await Backtest.hasNoScheduledSignal("BTCUSDT", { strategyName, exchangeName, frameName })) {
+         *   // safe to schedule a new signal
+         * }
+         * ```
+         */
+        this.hasNoScheduledSignal = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL));
+            }
+            return await functoolsKit.not(bt.strategyCoreService.hasScheduledSignal(true, symbol, context));
+        };
         /**
          * Checks if breakeven threshold has been reached for the current pending signal.
          *
@@ -38252,6 +38382,8 @@ const LIVE_METHOD_NAME_TRAILING_STOP_COST = "LiveUtils.commitTrailingStopCost";
 const LIVE_METHOD_NAME_TRAILING_PROFIT_COST = "LiveUtils.commitTrailingTakeCost";
 const LIVE_METHOD_NAME_ACTIVATE_SCHEDULED = "Live.commitActivateScheduled";
 const LIVE_METHOD_NAME_AVERAGE_BUY = "Live.commitAverageBuy";
+const LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL = "LiveUtils.hasNoPendingSignal";
+const LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL = "LiveUtils.hasNoScheduledSignal";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -38784,6 +38916,82 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns true if there is NO active pending signal for the given symbol.
+         *
+         * Inverse of strategyCoreService.hasPendingSignal. Use to guard signal generation logic.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if no pending signal exists, false if one does
+         *
+         * @example
+         * ```typescript
+         * if (await Live.hasNoPendingSignal("BTCUSDT", { strategyName, exchangeName })) {
+         *   // safe to open a new position
+         * }
+         * ```
+         */
+        this.hasNoPendingSignal = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL));
+            }
+            return await functoolsKit.not(bt.strategyCoreService.hasPendingSignal(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }));
+        };
+        /**
+         * Returns true if there is NO active scheduled signal for the given symbol.
+         *
+         * Inverse of strategyCoreService.hasScheduledSignal. Use to guard signal generation logic.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if no scheduled signal exists, false if one does
+         *
+         * @example
+         * ```typescript
+         * if (await Live.hasNoScheduledSignal("BTCUSDT", { strategyName, exchangeName })) {
+         *   // safe to schedule a new signal
+         * }
+         * ```
+         */
+        this.hasNoScheduledSignal = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL));
+            }
+            return await functoolsKit.not(bt.strategyCoreService.hasScheduledSignal(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }));
+        };
         /**
          * Checks if breakeven threshold has been reached for the current pending signal.
          *

package/build/index.mjs

@@ -6455,6 +6455,18 @@ class ClientStrategy {
         });
         return this._pendingSignal !== null;
     }
+    /**
+     * Checks if there is a scheduled signal.
+     *
+     * @param symbol - Trading symbol to check for scheduled signal
+     * @returns Promise resolving to true if a scheduled signal exists, false otherwise
+     */
+    async hasScheduledSignal(symbol) {
+        this.params.logger.debug("ClientStrategy hasScheduledSignal", {
+            symbol,
+        });
+        return this._scheduledSignal !== null;
+    }
     /**
      * Updates pending signal and persists to disk in live mode.
      *
@@ -10014,6 +10026,22 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.hasPendingSignal(symbol);
         };
+        /**
+         * Checks if there is an active scheduled signal for the strategy.
+         * Delegates to ClientStrategy.hasScheduledSignal() which checks if there is a waiting position signal
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to true if there is a waiting scheduled signal, false otherwise
+         */
+        this.hasScheduledSignal = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService hasScheduledSignal", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.hasScheduledSignal(symbol);
+        };
         /**
          * Returns the original estimated duration for the current pending signal.
          *
@@ -14365,6 +14393,24 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.hasPendingSignal(backtest, symbol, context);
         };
+        /**
+         * Checks if there is a waiting scheduled signal for the symbol.
+         * Validates strategy existence and delegates to connection service
+         * to check if a scheduled signal exists for the symbol.
+         * Does not require execution context as this is a state query operation.
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if scheduled signal exists, false otherwise
+         */
+        this.hasScheduledSignal = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService hasScheduledSignal", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.hasScheduledSignal(backtest, symbol, context);
+        };
         /**
          * Returns the original estimated duration for the current pending signal.
          *
@@ -35998,6 +36044,13 @@ function listenStrategyCommitOnce(filterFn, fn) {
  */
 function listenSync(fn) {
     bt.loggerService.log(LISTEN_SYNC_METHOD_NAME);
+    {
+        console.error("listenSync is unwanted cause exchange integration should be implemented in Broker.useBrokerAdapter as an infrastructure domain layer");
+        console.error("If you need to implement custom logic on signal open/close, please use signal(), signalBacktest(), signalLive() in addActionSchema handler");
+        console.error("If listenSync throws the exchange will not execute the order!");
+        console.error("");
+        console.error("You have been warned!");
+    }
     return syncSubject.subscribe(queued(async (event) => fn(event)));
 }
 /**
@@ -36010,6 +36063,13 @@ function listenSync(fn) {
  */
 function listenSyncOnce(filterFn, fn) {
     bt.loggerService.log(LISTEN_SYNC_ONCE_METHOD_NAME);
+    {
+        console.error("listenSyncOnce is unwanted cause exchange integration should be implemented in Broker.useBrokerAdapter as an infrastructure domain layer");
+        console.error("If you need to implement custom logic on signal open/close, please use signal(), signalBacktest(), signalLive() in addActionSchema handler");
+        console.error("If listenSyncOnce throws the exchange WILL EXECUTE the order!");
+        console.error("");
+        console.error("You have been warned!");
+    }
     return syncSubject.filter(filterFn).once(fn);
 }
 /**
@@ -36084,6 +36144,8 @@ const BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST = "BacktestUtils.commitTrailingT
 const BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED = "Backtest.commitActivateScheduled";
 const BACKTEST_METHOD_NAME_AVERAGE_BUY = "Backtest.commitAverageBuy";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
+const BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL = "BacktestUtils.hasNoPendingSignal";
+const BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL = "BacktestUtils.hasNoScheduledSignal";
 /**
  * Internal task function that runs backtest and handles completion.
  * Consumes backtest results and updates instance state flags.
@@ -36587,6 +36649,74 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getScheduledSignal(true, symbol, currentPrice, context);
         };
+        /**
+         * Returns true if there is NO active pending signal for the given symbol.
+         *
+         * Inverse of strategyCoreService.hasPendingSignal. Use to guard signal generation logic.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if no pending signal exists, false if one does
+         *
+         * @example
+         * ```typescript
+         * if (await Backtest.hasNoPendingSignal("BTCUSDT", { strategyName, exchangeName, frameName })) {
+         *   // safe to open a new position
+         * }
+         * ```
+         */
+        this.hasNoPendingSignal = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_HAS_NO_PENDING_SIGNAL));
+            }
+            return await not(bt.strategyCoreService.hasPendingSignal(true, symbol, context));
+        };
+        /**
+         * Returns true if there is NO active scheduled signal for the given symbol.
+         *
+         * Inverse of strategyCoreService.hasScheduledSignal. Use to guard signal generation logic.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if no scheduled signal exists, false if one does
+         *
+         * @example
+         * ```typescript
+         * if (await Backtest.hasNoScheduledSignal("BTCUSDT", { strategyName, exchangeName, frameName })) {
+         *   // safe to schedule a new signal
+         * }
+         * ```
+         */
+        this.hasNoScheduledSignal = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL));
+            }
+            return await not(bt.strategyCoreService.hasScheduledSignal(true, symbol, context));
+        };
         /**
          * Checks if breakeven threshold has been reached for the current pending signal.
          *
@@ -38232,6 +38362,8 @@ const LIVE_METHOD_NAME_TRAILING_STOP_COST = "LiveUtils.commitTrailingStopCost";
 const LIVE_METHOD_NAME_TRAILING_PROFIT_COST = "LiveUtils.commitTrailingTakeCost";
 const LIVE_METHOD_NAME_ACTIVATE_SCHEDULED = "Live.commitActivateScheduled";
 const LIVE_METHOD_NAME_AVERAGE_BUY = "Live.commitAverageBuy";
+const LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL = "LiveUtils.hasNoPendingSignal";
+const LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL = "LiveUtils.hasNoScheduledSignal";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -38764,6 +38896,82 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns true if there is NO active pending signal for the given symbol.
+         *
+         * Inverse of strategyCoreService.hasPendingSignal. Use to guard signal generation logic.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if no pending signal exists, false if one does
+         *
+         * @example
+         * ```typescript
+         * if (await Live.hasNoPendingSignal("BTCUSDT", { strategyName, exchangeName })) {
+         *   // safe to open a new position
+         * }
+         * ```
+         */
+        this.hasNoPendingSignal = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_HAS_NO_PENDING_SIGNAL));
+            }
+            return await not(bt.strategyCoreService.hasPendingSignal(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }));
+        };
+        /**
+         * Returns true if there is NO active scheduled signal for the given symbol.
+         *
+         * Inverse of strategyCoreService.hasScheduledSignal. Use to guard signal generation logic.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if no scheduled signal exists, false if one does
+         *
+         * @example
+         * ```typescript
+         * if (await Live.hasNoScheduledSignal("BTCUSDT", { strategyName, exchangeName })) {
+         *   // safe to schedule a new signal
+         * }
+         * ```
+         */
+        this.hasNoScheduledSignal = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_HAS_NO_SCHEDULED_SIGNAL));
+            }
+            return await not(bt.strategyCoreService.hasScheduledSignal(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }));
+        };
         /**
          * Checks if breakeven threshold has been reached for the current pending signal.
          *

package/package.json

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

package/types.d.ts

@@ -1021,7 +1021,7 @@ interface ActivePingContract {
      * Complete pending signal row data.
      * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss, etc.
      */
-    data: ISignalRow;
+    data: IPublicSignalRow;
     /**
      * Current market price of the symbol at the time of the ping.
      * Useful for users to implement custom management logic based on price conditions.
@@ -3399,6 +3399,15 @@ interface IStrategy {
      * @returns Promise resolving to true if pending signal exists, false otherwise
      */
     hasPendingSignal: (symbol: string) => Promise<boolean>;
+    /**
+     * Checks if there is an active scheduled signal for the symbol.
+     *
+     * Used internally to determine if TP/SL monitoring should occur on tick.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to true if scheduled signal exists, false otherwise
+     */
+    hasScheduledSignal: (symbol: string) => Promise<boolean>;
     /**
      * Returns the original estimated duration for the current pending signal.
      *
@@ -12295,6 +12304,48 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<IScheduledSignalRow>;
+    /**
+     * Returns true if there is NO active pending signal for the given symbol.
+     *
+     * Inverse of strategyCoreService.hasPendingSignal. Use to guard signal generation logic.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if no pending signal exists, false if one does
+     *
+     * @example
+     * ```typescript
+     * if (await Backtest.hasNoPendingSignal("BTCUSDT", { strategyName, exchangeName, frameName })) {
+     *   // safe to open a new position
+     * }
+     * ```
+     */
+    hasNoPendingSignal: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Returns true if there is NO active scheduled signal for the given symbol.
+     *
+     * Inverse of strategyCoreService.hasScheduledSignal. Use to guard signal generation logic.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if no scheduled signal exists, false if one does
+     *
+     * @example
+     * ```typescript
+     * if (await Backtest.hasNoScheduledSignal("BTCUSDT", { strategyName, exchangeName, frameName })) {
+     *   // safe to schedule a new signal
+     * }
+     * ```
+     */
+    hasNoScheduledSignal: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Checks if breakeven threshold has been reached for the current pending signal.
      *
@@ -13546,6 +13597,46 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<IScheduledSignalRow>;
+    /**
+     * Returns true if there is NO active pending signal for the given symbol.
+     *
+     * Inverse of strategyCoreService.hasPendingSignal. Use to guard signal generation logic.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Promise<boolean> - true if no pending signal exists, false if one does
+     *
+     * @example
+     * ```typescript
+     * if (await Live.hasNoPendingSignal("BTCUSDT", { strategyName, exchangeName })) {
+     *   // safe to open a new position
+     * }
+     * ```
+     */
+    hasNoPendingSignal: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
+    /**
+     * Returns true if there is NO active scheduled signal for the given symbol.
+     *
+     * Inverse of strategyCoreService.hasScheduledSignal. Use to guard signal generation logic.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Promise<boolean> - true if no scheduled signal exists, false if one does
+     *
+     * @example
+     * ```typescript
+     * if (await Live.hasNoScheduledSignal("BTCUSDT", { strategyName, exchangeName })) {
+     *   // safe to schedule a new signal
+     * }
+     * ```
+     */
+    hasNoScheduledSignal: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
     /**
      * Checks if breakeven threshold has been reached for the current pending signal.
      *
@@ -22432,6 +22523,19 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Checks if there is an active scheduled signal for the strategy.
+     * Delegates to ClientStrategy.hasScheduledSignal() which checks if there is a waiting position signal
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to true if there is a waiting scheduled signal, false otherwise
+     */
+    hasScheduledSignal: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Returns the original estimated duration for the current pending signal.
      *
@@ -24186,6 +24290,21 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Checks if there is a waiting scheduled signal for the symbol.
+     * Validates strategy existence and delegates to connection service
+     * to check if a scheduled signal exists for the symbol.
+     * Does not require execution context as this is a state query operation.
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if scheduled signal exists, false otherwise
+     */
+    hasScheduledSignal: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Returns the original estimated duration for the current pending signal.
      *