backtest-kit 6.14.0 → 6.15.0

package/build/index.cjs

@@ -7983,6 +7983,40 @@ class ClientStrategy {
         }
         return Math.floor((timestamp - this._pendingSignal._peak.timestamp) / 60000);
     }
+    /**
+     * Returns the number of minutes the position has been active since it opened.
+     *
+     * Computed as elapsed minutes since `pendingAt` (the moment the signal was activated).
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to active minutes (≥ 0) or null
+     */
+    async getPositionActiveMinutes(symbol, timestamp) {
+        this.params.logger.debug("ClientStrategy getPositionActiveMinutes", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return Math.floor((timestamp - this._pendingSignal.pendingAt) / 60000);
+    }
+    /**
+     * Returns the number of minutes the scheduled signal has been waiting for activation.
+     *
+     * Computed as elapsed minutes since `scheduledAt` (the moment the scheduled signal was created).
+     * Returns null if no scheduled signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to waiting minutes (≥ 0) or null
+     */
+    async getPositionWaitingMinutes(symbol, timestamp) {
+        this.params.logger.debug("ClientStrategy getPositionWaitingMinutes", { symbol });
+        if (!this._scheduledSignal) {
+            return null;
+        }
+        return Math.floor((timestamp - this._scheduledSignal.scheduledAt) / 60000);
+    }
     /**
      * Returns the number of minutes elapsed since the highest profit price was recorded.
      *
@@ -11084,6 +11118,46 @@ class StrategyConnectionService {
             const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
             return await strategy.getPositionCountdownMinutes(symbol, timestamp);
         };
+        /**
+         * Returns the number of minutes the position has been active since it opened.
+         *
+         * Delegates to ClientStrategy.getPositionActiveMinutes().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to active minutes (≥ 0) or null
+         */
+        this.getPositionActiveMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionActiveMinutes", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.getPositionActiveMinutes(symbol, timestamp);
+        };
+        /**
+         * Returns the number of minutes the scheduled signal has been waiting for activation.
+         *
+         * Delegates to ClientStrategy.getPositionWaitingMinutes().
+         * Returns null if no scheduled signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to waiting minutes (≥ 0) or null
+         */
+        this.getPositionWaitingMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionWaitingMinutes", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.getPositionWaitingMinutes(symbol, timestamp);
+        };
         /**
          * Returns the best price reached in the profit direction during this position's life.
          *
@@ -15404,6 +15478,38 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.getPositionCountdownMinutes(backtest, symbol, context);
         };
+        /**
+         * Returns the number of minutes the position has been active since it opened.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to active minutes (≥ 0) or null
+         */
+        this.getPositionActiveMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionActiveMinutes", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionActiveMinutes(backtest, symbol, context);
+        };
+        /**
+         * Returns the number of minutes the scheduled signal has been waiting for activation.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to waiting minutes (≥ 0) or null
+         */
+        this.getPositionWaitingMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionWaitingMinutes", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionWaitingMinutes(backtest, symbol, context);
+        };
         /**
          * Returns the best price reached in the profit direction during this position's life.
          *
@@ -32410,7 +32516,7 @@ class NotificationHelperService {
             const pendingSignal = await this.strategyCoreService.getPendingSignal(backtest, symbol, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
-                frameName: "",
+                frameName: context.frameName,
             });
             if (!pendingSignal) {
                 throw new Error(`SignalUtils notify No pending signal found symbol=${symbol} `);
@@ -35550,6 +35656,8 @@ const GET_POSITION_PARTIALS_METHOD_NAME = "strategy.getPositionPartials";
 const GET_POSITION_ENTRIES_METHOD_NAME = "strategy.getPositionEntries";
 const GET_POSITION_ESTIMATE_MINUTES_METHOD_NAME = "strategy.getPositionEstimateMinutes";
 const GET_POSITION_COUNTDOWN_MINUTES_METHOD_NAME = "strategy.getPositionCountdownMinutes";
+const GET_POSITION_ACTIVE_MINUTES_METHOD_NAME = "strategy.getPositionActiveMinutes";
+const GET_POSITION_WAITING_MINUTES_METHOD_NAME = "strategy.getPositionWaitingMinutes";
 const GET_POSITION_HIGHEST_PROFIT_PRICE_METHOD_NAME = "strategy.getPositionHighestProfitPrice";
 const GET_POSITION_HIGHEST_PROFIT_TIMESTAMP_METHOD_NAME = "strategy.getPositionHighestProfitTimestamp";
 const GET_POSITION_HIGHEST_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionHighestPnlPercentage";
@@ -36850,6 +36958,62 @@ async function getPositionCountdownMinutes(symbol) {
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
     return await backtest.strategyCoreService.getPositionCountdownMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the number of minutes the position has been active since it opened.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to active minutes (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionActiveMinutes } from "backtest-kit";
+ *
+ * const minutes = await getPositionActiveMinutes("BTCUSDT");
+ * // e.g. 120 (position has been open for 2 hours)
+ * ```
+ */
+async function getPositionActiveMinutes(symbol) {
+    backtest.loggerService.info(GET_POSITION_ACTIVE_MINUTES_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionActiveMinutes requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionActiveMinutes requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionActiveMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the number of minutes the scheduled signal has been waiting for activation.
+ *
+ * Returns null if no scheduled signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to waiting minutes (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionWaitingMinutes } from "backtest-kit";
+ *
+ * const minutes = await getPositionWaitingMinutes("BTCUSDT");
+ * // e.g. 15 (scheduled signal has been waiting 15 minutes for activation)
+ * ```
+ */
+async function getPositionWaitingMinutes(symbol) {
+    backtest.loggerService.info(GET_POSITION_WAITING_MINUTES_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionWaitingMinutes requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionWaitingMinutes requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionWaitingMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
 /**
  * Returns the best price reached in the profit direction during this position's life.
  *
@@ -39120,6 +39284,8 @@ const BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS = "BacktestUtils.getPositionPar
 const BACKTEST_METHOD_NAME_GET_POSITION_ENTRIES = "BacktestUtils.getPositionEntries";
 const BACKTEST_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES = "BacktestUtils.getPositionEstimateMinutes";
 const BACKTEST_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES = "BacktestUtils.getPositionCountdownMinutes";
+const BACKTEST_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES = "BacktestUtils.getPositionActiveMinutes";
+const BACKTEST_METHOD_NAME_GET_POSITION_WAITING_MINUTES = "BacktestUtils.getPositionWaitingMinutes";
 const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE = "BacktestUtils.getPositionHighestProfitPrice";
 const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP = "BacktestUtils.getPositionHighestProfitTimestamp";
 const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE = "BacktestUtils.getPositionHighestPnlPercentage";
@@ -40075,6 +40241,60 @@ class BacktestUtils {
             }
             return await backtest.strategyCoreService.getPositionCountdownMinutes(true, symbol, context);
         };
+        /**
+         * Returns the number of minutes the position has been active since it opened.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Active minutes (≥ 0), or null if no active position
+         */
+        this.getPositionActiveMinutes = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionActiveMinutes(true, symbol, context);
+        };
+        /**
+         * Returns the number of minutes the scheduled signal has been waiting for activation.
+         *
+         * Returns null if no scheduled signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Waiting minutes (≥ 0), or null if no scheduled signal
+         */
+        this.getPositionWaitingMinutes = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_WAITING_MINUTES, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_WAITING_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_WAITING_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionWaitingMinutes(true, symbol, context);
+        };
         /**
          * Returns the best price reached in the profit direction during this position's life.
          *
@@ -41716,6 +41936,8 @@ const LIVE_METHOD_NAME_GET_POSITION_PARTIALS = "LiveUtils.getPositionPartials";
 const LIVE_METHOD_NAME_GET_POSITION_ENTRIES = "LiveUtils.getPositionEntries";
 const LIVE_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES = "LiveUtils.getPositionEstimateMinutes";
 const LIVE_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES = "LiveUtils.getPositionCountdownMinutes";
+const LIVE_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES = "LiveUtils.getPositionActiveMinutes";
+const LIVE_METHOD_NAME_GET_POSITION_WAITING_MINUTES = "LiveUtils.getPositionWaitingMinutes";
 const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE = "LiveUtils.getPositionHighestProfitPrice";
 const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP = "LiveUtils.getPositionHighestProfitTimestamp";
 const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE = "LiveUtils.getPositionHighestPnlPercentage";
@@ -42750,6 +42972,68 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the number of minutes the position has been active since it opened.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Active minutes (≥ 0), or null if no active position
+         */
+        this.getPositionActiveMinutes = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionActiveMinutes(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the number of minutes the scheduled signal has been waiting for activation.
+         *
+         * Returns null if no scheduled signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Waiting minutes (≥ 0), or null if no scheduled signal
+         */
+        this.getPositionWaitingMinutes = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_WAITING_MINUTES, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_WAITING_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_WAITING_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionWaitingMinutes(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Returns the best price reached in the profit direction during this position's life.
          *
@@ -48203,7 +48487,7 @@ const LOGGER_SERVICE$2 = new LoggerService();
  * Default configuration that enables all report services.
  * Used when no specific configuration is provided to enable().
  */
-const WILDCARD_TARGET$1 = {
+const WILDCARD_TARGET$2 = {
     backtest: true,
     strategy: true,
     breakeven: true,
@@ -48254,7 +48538,7 @@ class ReportUtils {
          *
          * @returns Cleanup function that unsubscribes from all enabled services
          */
-        this.enable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
+        this.enable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$2) => {
             LOGGER_SERVICE$2.debug(REPORT_UTILS_METHOD_NAME_ENABLE, {
                 backtest: bt,
                 breakeven,
@@ -48346,7 +48630,7 @@ class ReportUtils {
          * Report.disable();
          * ```
          */
-        this.disable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
+        this.disable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$2) => {
             LOGGER_SERVICE$2.debug(REPORT_UTILS_METHOD_NAME_DISABLE, {
                 backtest: bt,
                 breakeven,
@@ -48470,7 +48754,7 @@ const LOGGER_SERVICE$1 = new LoggerService();
  * Default configuration that enables all markdown services.
  * Used when no specific configuration is provided to `enable()`.
  */
-const WILDCARD_TARGET = {
+const WILDCARD_TARGET$1 = {
     backtest: true,
     breakeven: true,
     heat: true,
@@ -48521,7 +48805,7 @@ class MarkdownUtils {
          *
          * @returns Cleanup function that unsubscribes from all enabled services
          */
-        this.enable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, strategy = false, risk = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET) => {
+        this.enable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, strategy = false, risk = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
             LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_ENABLE, {
                 backtest: bt,
                 breakeven,
@@ -48615,7 +48899,7 @@ class MarkdownUtils {
          * Markdown.disable();
          * ```
          */
-        this.disable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET) => {
+        this.disable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
             LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_DISABLE, {
                 backtest: bt,
                 breakeven,
@@ -48696,7 +48980,7 @@ class MarkdownUtils {
          * @param config.highest_profit - Clear highest profit report data
          * @param config.max_drawdown - Clear max drawdown report data
          */
-        this.clear = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET) => {
+        this.clear = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
             LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_CLEAR, {
                 backtest: bt,
                 breakeven,
@@ -51108,6 +51392,8 @@ const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP = "ReflectUtils.
 const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE = "ReflectUtils.getPositionHighestPnlPercentage";
 const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST = "ReflectUtils.getPositionHighestPnlCost";
 const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN = "ReflectUtils.getPositionHighestProfitBreakeven";
+const REFLECT_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES = "ReflectUtils.getPositionActiveMinutes";
+const REFLECT_METHOD_NAME_GET_POSITION_WAITING_MINUTES = "ReflectUtils.getPositionWaitingMinutes";
 const REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES = "ReflectUtils.getPositionDrawdownMinutes";
 const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES = "ReflectUtils.getPositionHighestProfitMinutes";
 const REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES = "ReflectUtils.getPositionMaxDrawdownMinutes";
@@ -51382,6 +51668,52 @@ class ReflectUtils {
             }
             return await backtest.strategyCoreService.getPositionHighestProfitBreakeven(backtest$1, symbol, context);
         };
+        /**
+         * Returns the number of minutes the position has been active since it opened.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to active minutes (≥ 0) or null
+         */
+        this.getPositionActiveMinutes = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_ACTIVE_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionActiveMinutes(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the number of minutes the scheduled signal has been waiting for activation.
+         *
+         * Returns null if no scheduled signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to waiting minutes (≥ 0) or null
+         */
+        this.getPositionWaitingMinutes = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_WAITING_MINUTES, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_WAITING_MINUTES);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_WAITING_MINUTES));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_WAITING_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionWaitingMinutes(backtest$1, symbol, context);
+        };
         /**
          * Returns the number of minutes elapsed since the highest profit price was recorded.
          *
@@ -53658,6 +53990,23 @@ const StorageLive = new StorageLiveAdapter();
  */
 const StorageBacktest = new StorageBacktestAdapter();
 
+/**
+ * Default configuration that enables all notification types.
+ * Used when no specific configuration is provided to enable().
+ */
+const WILDCARD_TARGET = {
+    signal: true,
+    partial_profit: true,
+    partial_loss: true,
+    breakeven: true,
+    strategy_commit: true,
+    signal_sync: true,
+    risk: true,
+    info: true,
+    common_error: true,
+    critical_error: true,
+    validation_error: true,
+};
 /**
  * Generates a unique key for notification identification.
  * @returns Random string identifier
@@ -55713,64 +56062,152 @@ class NotificationAdapter {
          *
          * @returns Cleanup function that unsubscribes from all emitters
          */
-        this.enable = functoolsKit.singleshot(() => {
+        this.enable = functoolsKit.singleshot(({ signal = false, info = false, partial_profit = false, partial_loss = false, breakeven = false, strategy_commit = false, signal_sync = false, risk = false, common_error = false, critical_error = false, validation_error = false, } = WILDCARD_TARGET) => {
             backtest.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_ENABLE);
             let unLive;
             let unBacktest;
             {
-                const unBacktestSignal = signalBacktestEmitter.subscribe((data) => NotificationBacktest.handleSignal(data));
+                const unBacktestSignal = signalBacktestEmitter.subscribe(async (data) => {
+                    if (signal) {
+                        await NotificationBacktest.handleSignal(data);
+                    }
+                });
                 const unBacktestPartialProfit = partialProfitSubject
                     .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handlePartialProfit(data));
+                    .connect(async (data) => {
+                    if (partial_profit) {
+                        await NotificationBacktest.handlePartialProfit(data);
+                    }
+                });
                 const unBacktestPartialLoss = partialLossSubject
                     .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handlePartialLoss(data));
+                    .connect(async (data) => {
+                    if (partial_loss) {
+                        await NotificationBacktest.handlePartialLoss(data);
+                    }
+                });
                 const unBacktestBreakeven = breakevenSubject
                     .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handleBreakeven(data));
+                    .connect(async (data) => {
+                    if (breakeven) {
+                        await NotificationBacktest.handleBreakeven(data);
+                    }
+                });
                 const unBacktestStrategyCommit = strategyCommitSubject
                     .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handleStrategyCommit(data));
+                    .connect(async (data) => {
+                    if (strategy_commit) {
+                        await NotificationBacktest.handleStrategyCommit(data);
+                    }
+                });
                 const unBacktestSync = syncSubject
                     .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handleSync(data));
+                    .connect(async (data) => {
+                    if (signal_sync) {
+                        await NotificationBacktest.handleSync(data);
+                    }
+                });
                 const unBacktestRisk = riskSubject
                     .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handleRisk(data));
-                const unBacktestError = errorEmitter.subscribe((error) => NotificationBacktest.handleError(error));
-                const unBacktestExit = exitEmitter.subscribe((error) => NotificationBacktest.handleCriticalError(error));
-                const unBacktestValidation = validationSubject.subscribe((error) => NotificationBacktest.handleValidationError(error));
+                    .connect(async (data) => {
+                    if (risk) {
+                        await NotificationBacktest.handleRisk(data);
+                    }
+                });
+                const unBacktestError = errorEmitter.subscribe(async (error) => {
+                    if (common_error) {
+                        await NotificationBacktest.handleError(error);
+                    }
+                });
+                const unBacktestExit = exitEmitter.subscribe(async (error) => {
+                    if (critical_error) {
+                        await NotificationBacktest.handleCriticalError(error);
+                    }
+                });
+                const unBacktestValidation = validationSubject.subscribe(async (error) => {
+                    if (validation_error) {
+                        await NotificationBacktest.handleValidationError(error);
+                    }
+                });
                 const unBacktestSignalNotify = signalNotifySubject
                     .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handleSignalNotify(data));
+                    .connect(async (data) => {
+                    if (info) {
+                        await NotificationBacktest.handleSignalNotify(data);
+                    }
+                });
                 unBacktest = functoolsKit.compose(() => unBacktestSignal(), () => unBacktestPartialProfit(), () => unBacktestPartialLoss(), () => unBacktestBreakeven(), () => unBacktestStrategyCommit(), () => unBacktestSync(), () => unBacktestRisk(), () => unBacktestError(), () => unBacktestExit(), () => unBacktestValidation(), () => unBacktestSignalNotify());
             }
             {
-                const unLiveSignal = signalLiveEmitter.subscribe((data) => NotificationLive.handleSignal(data));
+                const unLiveSignal = signalLiveEmitter.subscribe(async (data) => {
+                    if (signal) {
+                        await NotificationLive.handleSignal(data);
+                    }
+                });
                 const unLivePartialProfit = partialProfitSubject
                     .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handlePartialProfit(data));
+                    .connect(async (data) => {
+                    if (partial_profit) {
+                        await NotificationLive.handlePartialProfit(data);
+                    }
+                });
                 const unLivePartialLoss = partialLossSubject
                     .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handlePartialLoss(data));
+                    .connect(async (data) => {
+                    if (partial_loss) {
+                        await NotificationLive.handlePartialLoss(data);
+                    }
+                });
                 const unLiveBreakeven = breakevenSubject
                     .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handleBreakeven(data));
+                    .connect(async (data) => {
+                    if (breakeven) {
+                        await NotificationLive.handleBreakeven(data);
+                    }
+                });
                 const unLiveStrategyCommit = strategyCommitSubject
                     .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handleStrategyCommit(data));
+                    .connect(async (data) => {
+                    if (strategy_commit) {
+                        await NotificationLive.handleStrategyCommit(data);
+                    }
+                });
                 const unLiveSync = syncSubject
                     .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handleSync(data));
+                    .connect(async (data) => {
+                    if (signal_sync) {
+                        await NotificationLive.handleSync(data);
+                    }
+                });
                 const unLiveRisk = riskSubject
                     .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handleRisk(data));
-                const unLiveError = errorEmitter.subscribe((error) => NotificationLive.handleError(error));
-                const unLiveExit = exitEmitter.subscribe((error) => NotificationLive.handleCriticalError(error));
-                const unLiveValidation = validationSubject.subscribe((error) => NotificationLive.handleValidationError(error));
+                    .connect(async (data) => {
+                    if (risk) {
+                        await NotificationLive.handleRisk(data);
+                    }
+                });
+                const unLiveError = errorEmitter.subscribe(async (error) => {
+                    if (common_error) {
+                        await NotificationLive.handleError(error);
+                    }
+                });
+                const unLiveExit = exitEmitter.subscribe(async (error) => {
+                    if (critical_error) {
+                        await NotificationLive.handleCriticalError(error);
+                    }
+                });
+                const unLiveValidation = validationSubject.subscribe(async (error) => {
+                    if (validation_error) {
+                        await NotificationLive.handleValidationError(error);
+                    }
+                });
                 const unLiveSignalNotify = signalNotifySubject
                     .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handleSignalNotify(data));
+                    .connect(async (data) => {
+                    if (info) {
+                        await NotificationLive.handleSignalNotify(data);
+                    }
+                });
                 unLive = functoolsKit.compose(() => unLiveSignal(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveSync(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation(), () => unLiveSignalNotify());
             }
             return () => {
@@ -58275,6 +58712,7 @@ exports.getMode = getMode;
 exports.getNextCandles = getNextCandles;
 exports.getOrderBook = getOrderBook;
 exports.getPendingSignal = getPendingSignal;
+exports.getPositionActiveMinutes = getPositionActiveMinutes;
 exports.getPositionCountdownMinutes = getPositionCountdownMinutes;
 exports.getPositionDrawdownMinutes = getPositionDrawdownMinutes;
 exports.getPositionEffectivePrice = getPositionEffectivePrice;
@@ -58303,6 +58741,7 @@ exports.getPositionPartialOverlap = getPositionPartialOverlap;
 exports.getPositionPartials = getPositionPartials;
 exports.getPositionPnlCost = getPositionPnlCost;
 exports.getPositionPnlPercent = getPositionPnlPercent;
+exports.getPositionWaitingMinutes = getPositionWaitingMinutes;
 exports.getRawCandles = getRawCandles;
 exports.getRiskSchema = getRiskSchema;
 exports.getScheduledSignal = getScheduledSignal;