backtest-kit 6.14.0 → 6.15.0

package/build/index.mjs

@@ -7963,6 +7963,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.
      *
@@ -11064,6 +11098,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.
          *
@@ -15384,6 +15458,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.
          *
@@ -32390,7 +32496,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} `);
@@ -35530,6 +35636,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";
@@ -36830,6 +36938,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.
  *
@@ -39100,6 +39264,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";
@@ -40055,6 +40221,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.
          *
@@ -41696,6 +41916,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";
@@ -42730,6 +42952,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.
          *
@@ -48183,7 +48467,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,
@@ -48234,7 +48518,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,
@@ -48326,7 +48610,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,
@@ -48450,7 +48734,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,
@@ -48501,7 +48785,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,
@@ -48595,7 +48879,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,
@@ -48676,7 +48960,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,
@@ -51088,6 +51372,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";
@@ -51362,6 +51648,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.
          *
@@ -53638,6 +53970,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
@@ -55693,64 +56042,152 @@ class NotificationAdapter {
          *
          * @returns Cleanup function that unsubscribes from all emitters
          */
-        this.enable = singleshot(() => {
+        this.enable = 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 = 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 = compose(() => unLiveSignal(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveSync(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation(), () => unLiveSignalNotify());
             }
             return () => {
@@ -58141,4 +58578,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistIntervalAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRecentAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistIntervalAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRecentAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };