backtest-kit 6.15.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",
@@ -10355,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
@@ -10606,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),
@@ -13084,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.
  */
@@ -13322,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.
      *
@@ -13509,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) {
@@ -13875,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.
      */
@@ -14127,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.
          *
@@ -16230,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.
          *
@@ -37800,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";
@@ -38975,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.
  *
@@ -45932,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.
@@ -45990,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));
+        };
     }
 }
 /**
@@ -46032,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));
+        };
     }
 }
 /**
@@ -46075,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));
+        };
     }
 }
 /**
@@ -46117,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));
+        };
     }
 }
 /**
@@ -46163,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.
@@ -46241,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.
@@ -46349,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));
+        };
     }
 }
 /**
@@ -46368,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.
  *
@@ -46405,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;
@@ -49732,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,
@@ -57852,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";
@@ -58245,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.
      *
@@ -58578,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, 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 };
+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 };

package/package.json

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