backtest-kit 6.14.0 → 6.16.0

package/build/index.mjs

@@ -714,6 +714,11 @@ const schedulePingSubject = new Subject();
  * Allows users to track active signal lifecycle and implement custom dynamic management logic.
  */
 const activePingSubject = new Subject();
+/**
+ * Idle ping emitter for strategy idle state events.
+ * Emits every tick when there is no pending or scheduled signal being monitored.
+ */
+const idlePingSubject = new Subject();
 /**
  * Strategy management signal emitter.
  * Emits when strategy management actions are executed:
@@ -765,6 +770,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     errorEmitter: errorEmitter,
     exitEmitter: exitEmitter,
     highestProfitSubject: highestProfitSubject,
+    idlePingSubject: idlePingSubject,
     maxDrawdownSubject: maxDrawdownSubject,
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
@@ -6028,6 +6034,27 @@ const CALL_ACTIVE_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, pe
         errorEmitter.next(error);
     },
 });
+const CALL_IDLE_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, timestamp, backtest, currentPrice) => {
+    await ExecutionContextService.runInContext(async () => {
+        // Call system onIdlePing callback (emits to idlePingSubject)
+        await self.params.onIdlePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, currentPrice, self.params.execution.context.backtest, timestamp);
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}), {
+    fallback: (error, self) => {
+        const message = "ClientStrategy CALL_IDLE_PING_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 const CALL_ACTIVE_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onActive) {
@@ -6683,6 +6710,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice, backt
 };
 const RETURN_IDLE_FN = async (self, currentPrice) => {
     const currentTime = self.params.execution.context.when.getTime();
+    await CALL_IDLE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, currentTime, self.params.execution.context.backtest, currentPrice);
     await CALL_IDLE_CALLBACKS_FN(self, self.params.execution.context.symbol, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "idle",
@@ -7963,6 +7991,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.
      *
@@ -10321,11 +10383,44 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strateg
     },
     defaultValue: null,
 });
+/**
+ * Creates a callback function for emitting idle ping events.
+ *
+ * Called by ClientStrategy when no active or scheduled signals are present.
+ *
+ * @param self - Reference to StrategyConnectionService instance
+ * @returns Callback function for idle ping events
+ */
+const CREATE_COMMIT_IDLE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, currentPrice, backtest, timestamp) => {
+    const frameName = self.methodContextService.context.frameName;
+    const event = {
+        symbol,
+        strategyName,
+        exchangeName,
+        frameName,
+        currentPrice,
+        backtest,
+        timestamp,
+    };
+    await idlePingSubject.next(event);
+    await self.actionCoreService.pingIdle(backtest, event, { strategyName, exchangeName, frameName });
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_COMMIT_IDLE_PING_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting active ping events.
  *
  * Called by ClientStrategy when an active pending signal is being monitored every minute.
- * Placeholder for future activePingSubject implementation.
  *
  * @param self - Reference to StrategyConnectionService instance
  * @returns Callback function for active ping events
@@ -10572,6 +10667,7 @@ class StrategyConnectionService {
                 onInit: CREATE_COMMIT_INIT_FN(this),
                 onSchedulePing: CREATE_COMMIT_SCHEDULE_PING_FN(this),
                 onActivePing: CREATE_COMMIT_ACTIVE_PING_FN(this),
+                onIdlePing: CREATE_COMMIT_IDLE_PING_FN(this),
                 onDispose: CREATE_COMMIT_DISPOSE_FN(this),
                 onCommit: CREATE_COMMIT_FN(this),
                 onSignalSync: CREATE_SYNC_FN(this, strategyName, exchangeName, frameName, backtest),
@@ -11064,6 +11160,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.
          *
@@ -13010,6 +13146,34 @@ const CALL_PING_SCHEDULED_FN = trycatch(async (event, self) => {
     },
     defaultValue: null,
 });
+/**
+ * Wrapper to call pingIdle method with error capture.
+ */
+const CALL_PING_IDLE_FN = trycatch(async (event, self) => {
+    if (!self._target.pingIdle) {
+        return;
+    }
+    if (await self.params.strategy.hasPendingSignal(event.backtest, event.symbol, {
+        strategyName: event.strategyName,
+        exchangeName: event.exchangeName,
+        frameName: event.frameName,
+    })) {
+        return;
+    }
+    return await self._target.pingIdle(event);
+}, {
+    fallback: (error) => {
+        const message = "ActionProxy.pingIdle thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        LOGGER_SERVICE$4.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Wrapper to call pingActive method with error capture.
  */
@@ -13248,6 +13412,18 @@ class ActionProxy {
     async pingActive(event) {
         return await CALL_PING_ACTIVE_FN(event, this);
     }
+    /**
+     * Handles idle ping events with error capture.
+     *
+     * Wraps the user's pingIdle() method to catch and log any errors.
+     * Called every tick while no signal is pending or scheduled.
+     *
+     * @param event - Idle ping data with symbol, strategy info, current price, timestamp
+     * @returns Promise resolving to user's pingIdle() result or null on error
+     */
+    async pingIdle(event) {
+        return await CALL_PING_IDLE_FN(event, this);
+    }
     /**
      * Handles risk rejection events with error capture.
      *
@@ -13435,6 +13611,23 @@ const CALL_PING_SCHEDULED_CALLBACK_FN = trycatch(async (self, event, strategyNam
         errorEmitter.next(error);
     },
 });
+/** Wrapper to call idle ping callback with error handling */
+const CALL_PING_IDLE_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
+    if (self.params.callbacks?.onPingIdle) {
+        await self.params.callbacks.onPingIdle(event, self.params.actionName, strategyName, frameName, backtest);
+    }
+}, {
+    fallback: (error, self) => {
+        const message = "ClientAction CALL_PING_IDLE_CALLBACK_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /** Wrapper to call active ping callback with error handling */
 const CALL_PING_ACTIVE_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
     if (self.params.callbacks?.onPingActive) {
@@ -13801,6 +13994,24 @@ class ClientAction {
         await CALL_PING_ACTIVE_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
     }
     ;
+    /**
+     * Handles idle ping events when no signal is active.
+     */
+    async pingIdle(event) {
+        this.params.logger.debug("ClientAction pingIdle", {
+            actionName: this.params.actionName,
+            strategyName: this.params.strategyName,
+            frameName: this.params.frameName,
+        });
+        if (!this._handlerInstance) {
+            await this.waitForInit();
+        }
+        // Call handler method if defined
+        await this._handlerInstance?.pingIdle(event);
+        // Call callback if defined
+        await CALL_PING_IDLE_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
+    }
+    ;
     /**
      * Handles risk rejection events when signals fail risk validation.
      */
@@ -14053,6 +14264,21 @@ class ActionConnectionService {
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
             await action.pingActive(event);
         };
+        /**
+         * Routes idle ping event to appropriate ClientAction instance.
+         *
+         * @param event - Idle ping event data
+         * @param backtest - Whether running in backtest mode
+         * @param context - Execution context with action name, strategy name, exchange name, frame name
+         */
+        this.pingIdle = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService pingIdle", {
+                backtest,
+                context,
+            });
+            const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await action.pingIdle(event);
+        };
         /**
          * Routes riskRejection event to appropriate ClientAction instance.
          *
@@ -15384,6 +15610,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.
          *
@@ -16124,6 +16382,27 @@ class ActionCoreService {
                 await this.actionConnectionService.pingActive(event, backtest, { actionName, ...context });
             }
         };
+        /**
+         * Routes idle ping event to all registered actions for the strategy.
+         *
+         * Retrieves action list from strategy schema (IStrategySchema.actions)
+         * and invokes the pingIdle handler on each ClientAction instance sequentially.
+         * Called every tick when there is no pending or scheduled signal being monitored.
+         *
+         * @param backtest - Whether running in backtest mode (true) or live mode (false)
+         * @param event - Idle state monitoring data
+         * @param context - Strategy execution context with strategyName, exchangeName, frameName
+         */
+        this.pingIdle = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService pingIdle", {
+                context,
+            });
+            await this.validate(context);
+            const { actions = [] } = this.strategySchemaService.get(context.strategyName);
+            for (const actionName of actions) {
+                await this.actionConnectionService.pingIdle(event, backtest, { actionName, ...context });
+            }
+        };
         /**
          * Routes risk rejection event to all registered actions for the strategy.
          *
@@ -32390,7 +32669,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 +35809,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 +37111,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.
  *
@@ -37636,6 +37973,8 @@ const LISTEN_SCHEDULE_PING_METHOD_NAME = "event.listenSchedulePing";
 const LISTEN_SCHEDULE_PING_ONCE_METHOD_NAME = "event.listenSchedulePingOnce";
 const LISTEN_ACTIVE_PING_METHOD_NAME = "event.listenActivePing";
 const LISTEN_ACTIVE_PING_ONCE_METHOD_NAME = "event.listenActivePingOnce";
+const LISTEN_IDLE_PING_METHOD_NAME = "event.listenIdlePing";
+const LISTEN_IDLE_PING_ONCE_METHOD_NAME = "event.listenIdlePingOnce";
 const LISTEN_STRATEGY_COMMIT_METHOD_NAME = "event.listenStrategyCommit";
 const LISTEN_STRATEGY_COMMIT_ONCE_METHOD_NAME = "event.listenStrategyCommitOnce";
 const LISTEN_SYNC_METHOD_NAME = "event.listenSync";
@@ -38811,6 +39150,45 @@ function listenActivePingOnce(filterFn, fn) {
     };
     return disposeFn = listenActivePing(wrappedFn);
 }
+/**
+ * Subscribes to idle ping events with queued async processing.
+ *
+ * Emits every tick when there is no pending or scheduled signal being monitored.
+ *
+ * @param fn - Callback function to handle idle ping events
+ * @returns Unsubscribe function to stop listening
+ */
+function listenIdlePing(fn) {
+    backtest.loggerService.log(LISTEN_IDLE_PING_METHOD_NAME);
+    const wrappedFn = async (event) => {
+        if (await not(backtest.strategyCoreService.hasPendingSignal(event.backtest, event.symbol, {
+            strategyName: event.strategyName,
+            exchangeName: event.exchangeName,
+            frameName: event.frameName,
+        }))) {
+            await fn(event);
+        }
+    };
+    return idlePingSubject.subscribe(queued(wrappedFn));
+}
+/**
+ * Subscribes to filtered idle ping events with one-time execution.
+ *
+ * @param filterFn - Predicate to filter events
+ * @param fn - Callback function to handle the matching event
+ * @returns Unsubscribe function to cancel the listener before it fires
+ */
+function listenIdlePingOnce(filterFn, fn) {
+    backtest.loggerService.log(LISTEN_IDLE_PING_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenIdlePing(wrappedFn);
+}
 /**
  * Subscribes to strategy management events with queued async processing.
  *
@@ -39100,6 +39478,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 +40435,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 +42130,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 +43166,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.
          *
@@ -45648,6 +46146,7 @@ const RECENT_LIVE_ADAPTER_METHOD_NAME_CLEAR = "RecentLiveAdapter.clear";
 const RECENT_ADAPTER_METHOD_NAME_ENABLE = "RecentAdapter.enable";
 const RECENT_ADAPTER_METHOD_NAME_DISABLE = "RecentAdapter.disable";
 const RECENT_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL = "RecentAdapter.getLatestSignal";
+const RECENT_ADAPTER_METHOD_NAME_GET_MINUTES_SINCE_LATEST_SIGNAL = "RecentAdapter.getMinutesSinceLatestSignalCreated";
 /**
  * Builds a composite storage key from context parts.
  * Includes backtest flag as the last segment to prevent live/backtest collisions.
@@ -45706,6 +46205,23 @@ class RecentPersistBacktestUtils {
             });
             return await PersistRecentAdapter.readRecentData(symbol, strategyName, exchangeName, frameName, backtest$1);
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest) => {
+            const signal = await this.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -45748,6 +46264,23 @@ class RecentMemoryBacktestUtils {
             backtest.loggerService.info(RECENT_MEMORY_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL, { key });
             return this._signals.get(key) ?? null;
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest) => {
+            const signal = await this.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -45791,6 +46324,23 @@ class RecentPersistLiveUtils {
             });
             return await PersistRecentAdapter.readRecentData(symbol, strategyName, exchangeName, frameName, backtest$1);
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest) => {
+            const signal = await this.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -45833,6 +46383,23 @@ class RecentMemoryLiveUtils {
             backtest.loggerService.info(RECENT_MEMORY_LIVE_METHOD_NAME_GET_LATEST_SIGNAL, { key });
             return this._signals.get(key) ?? null;
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest) => {
+            const signal = await this.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -45879,6 +46446,32 @@ class RecentBacktestAdapter {
             });
             return await this._recentBacktestUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * Proxies call to the underlying storage adapter.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest: backtest$1,
+                timestamp,
+            });
+            const signal = await this._recentBacktestUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
         /**
          * Sets the storage adapter constructor.
          * All future storage operations will use this adapter.
@@ -45957,6 +46550,32 @@ class RecentLiveAdapter {
             });
             return await this._recentLiveUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * Proxies call to the underlying storage adapter.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest: backtest$1,
+                timestamp,
+            });
+            const signal = await this._recentLiveUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
         /**
          * Sets the storage adapter constructor.
          * All future storage operations will use this adapter.
@@ -46065,6 +46684,27 @@ class RecentAdapter {
             }
             return null;
         };
+        /**
+         * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+         * Searches backtest storage first, then live storage.
+         * @param timestamp - Current timestamp in milliseconds
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Whole minutes since the latest signal was created, or null if no signal found
+         * @throws Error if RecentAdapter is not enabled
+         */
+        this.getMinutesSinceLatestSignalCreated = async (timestamp, symbol, context) => {
+            backtest.loggerService.info(RECENT_ADAPTER_METHOD_NAME_GET_MINUTES_SINCE_LATEST_SIGNAL, {
+                symbol,
+                context,
+                timestamp,
+            });
+            const signal = await this.getLatestSignal(symbol, context);
+            if (!signal) {
+                return null;
+            }
+            return Math.floor((timestamp - signal.timestamp) / (1000 * 60));
+        };
     }
 }
 /**
@@ -46084,6 +46724,7 @@ const RecentLive = new RecentLiveAdapter();
 const RecentBacktest = new RecentBacktestAdapter();
 
 const GET_LATEST_SIGNAL_METHOD_NAME = "signal.getLatestSignal";
+const GET_MINUTES_SINCE_LATEST_SIGNAL_CREATED_METHOD_NAME = "signal.getMinutesSinceLatestSignalCreated";
 /**
  * Returns the latest signal (pending or closed) for the current strategy context.
  *
@@ -46121,6 +46762,42 @@ async function getLatestSignal(symbol) {
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
     return await Recent.getLatestSignal(symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
+ *
+ * Does not distinguish between active and closed signals — measures time since
+ * whichever signal was recorded last. Useful for cooldown logic after a stop-loss.
+ *
+ * Searches backtest storage first, then live storage.
+ * Returns null if no signal exists at all.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param timestamp - Current timestamp in milliseconds
+ * @returns Promise resolving to whole minutes since the latest signal was created, or null
+ *
+ * @example
+ * ```typescript
+ * import { getMinutesSinceLatestSignalCreated } from "backtest-kit";
+ *
+ * const minutes = await getMinutesSinceLatestSignalCreated("BTCUSDT", Date.now());
+ * if (minutes !== null && minutes < 24 * 60) {
+ *   return; // cooldown — skip new signal for 24 hours after last signal
+ * }
+ * ```
+ */
+async function getMinutesSinceLatestSignalCreated(symbol, timestamp) {
+    backtest.loggerService.info(GET_MINUTES_SINCE_LATEST_SIGNAL_CREATED_METHOD_NAME, { symbol, timestamp });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getMinutesSinceLatestSignalCreated requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getMinutesSinceLatestSignalCreated requires a method context");
+    }
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await Recent.getMinutesSinceLatestSignalCreated(timestamp, symbol, { exchangeName, frameName, strategyName });
+}
 
 const DEFAULT_BM25_K1 = 1.5;
 const DEFAULT_BM25_B = 0.75;
@@ -48183,7 +48860,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 +48911,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 +49003,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 +49127,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 +49178,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 +49272,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 +49353,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,
@@ -49448,6 +50125,7 @@ const METHOD_NAME_CREATE_SNAPSHOT = "SessionUtils.createSnapshot";
 /** List of all global subjects whose listeners should be snapshotted for session isolation */
 const SUBJECT_ISOLATION_LIST = [
     activePingSubject,
+    idlePingSubject,
     backtestScheduleOpenSubject,
     breakevenSubject,
     doneBacktestSubject,
@@ -51088,6 +51766,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 +52042,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 +54364,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 +56436,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 () => {
@@ -57415,6 +58246,7 @@ const METHOD_NAME_PARTIAL_PROFIT_AVAILABLE = "ActionBase.partialProfitAvailable"
 const METHOD_NAME_PARTIAL_LOSS_AVAILABLE = "ActionBase.partialLossAvailable";
 const METHOD_NAME_PING_SCHEDULED = "ActionBase.pingScheduled";
 const METHOD_NAME_PING_ACTIVE = "ActionBase.pingActive";
+const METHOD_NAME_PING_IDLE = "ActionBase.pingIdle";
 const METHOD_NAME_RISK_REJECTION = "ActionBase.riskRejection";
 const METHOD_NAME_DISPOSE = "ActionBase.dispose";
 const DEFAULT_SOURCE = "default";
@@ -57808,6 +58640,26 @@ class ActionBase {
             source,
         });
     }
+    /**
+     * Handles idle ping events when no signal is active.
+     *
+     * Called every tick while no signal is pending or scheduled.
+     * Use to monitor idle strategy state and implement entry condition logic.
+     *
+     * Triggered by: ActionCoreService.pingIdle() via StrategyConnectionService
+     * Source: idlePingSubject.next() in CREATE_COMMIT_IDLE_PING_FN callback
+     * Frequency: Every tick while no signal is pending or scheduled
+     *
+     * Default implementation: Logs idle ping event.
+     *
+     * @param event - Idle ping data with symbol, strategy info, current price, timestamp
+     */
+    pingIdle(event, source = DEFAULT_SOURCE) {
+        LOGGER_SERVICE.info(METHOD_NAME_PING_IDLE, {
+            event,
+            source,
+        });
+    }
     /**
      * Handles risk rejection events when signals fail risk validation.
      *
@@ -58141,4 +58993,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, getMinutesSinceLatestSignalCreated, 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, listenIdlePing, listenIdlePingOnce, 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 };