backtest-kit 9.8.4 → 10.1.0

package/build/index.cjs

@@ -962,7 +962,7 @@ async function writeFileAtomic(file, data, options = {}) {
 
 var _a$3;
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$8 = new LoggerService();
+const LOGGER_SERVICE$9 = new LoggerService();
 /** Symbol key for the singleshot waitForInit function on PersistBase instances. */
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 // Calculate step in milliseconds for candle close time validation
@@ -1085,7 +1085,7 @@ const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
 const BASE_WAIT_FOR_INIT_FN = async (self) => {
-    LOGGER_SERVICE$8.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+    LOGGER_SERVICE$9.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
         entityName: self.entityName,
         directory: self._directory,
     });
@@ -1143,7 +1143,7 @@ class PersistBase {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a$3] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
             entityName: this.entityName,
             baseDir,
         });
@@ -1159,14 +1159,14 @@ class PersistBase {
         return path.join(this.baseDir, this.entityName, `${entityId}.json`);
     }
     async waitForInit(initial) {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             entityName: this.entityName,
             initial,
         });
         await this[BASE_WAIT_FOR_INIT_SYMBOL]();
     }
     async readValue(entityId) {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1183,7 +1183,7 @@ class PersistBase {
         }
     }
     async hasValue(entityId) {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1200,7 +1200,7 @@ class PersistBase {
         }
     }
     async writeValue(entityId, entity) {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1222,7 +1222,7 @@ class PersistBase {
      * @throws Error if reading fails
      */
     async *keys() {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
             entityName: this.entityName,
         });
         try {
@@ -1367,7 +1367,7 @@ class PersistSignalUtils {
          * @returns Promise resolving to signal or null if none persisted
          */
         this.readSignalData = async (symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName);
@@ -1385,7 +1385,7 @@ class PersistSignalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName);
@@ -1400,7 +1400,7 @@ class PersistSignalUtils {
      * @param Ctor - Custom IPersistSignalInstance constructor
      */
     usePersistSignalAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
         this.PersistSignalInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -1409,21 +1409,21 @@ class PersistSignalUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistSignalInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistSignalAdapter(PersistSignalInstance);
     }
     /**
      * Switches to PersistSignalDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistSignalAdapter(PersistSignalDummyInstance);
     }
 }
@@ -1563,7 +1563,7 @@ class PersistRiskUtils {
          * @returns Promise resolving to position entries (empty array if none)
          */
         this.readPositionData = async (riskName, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
@@ -1581,7 +1581,7 @@ class PersistRiskUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePositionData = async (riskRow, riskName, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
@@ -1596,7 +1596,7 @@ class PersistRiskUtils {
      * @param Ctor - Custom IPersistRiskInstance constructor
      */
     usePersistRiskAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
         this.PersistRiskInstanceCtor = Ctor;
         this.getRiskStorage.clear();
     }
@@ -1605,21 +1605,21 @@ class PersistRiskUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
         this.getRiskStorage.clear();
     }
     /**
      * Switches to the default file-based PersistRiskInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistRiskAdapter(PersistRiskInstance);
     }
     /**
      * Switches to PersistRiskDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistRiskAdapter(PersistRiskDummyInstance);
     }
 }
@@ -1758,7 +1758,7 @@ class PersistScheduleUtils {
          * @returns Promise resolving to scheduled signal or null if none persisted
          */
         this.readScheduleData = async (symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const instance = this.getScheduleStorage(symbol, strategyName, exchangeName);
@@ -1776,7 +1776,7 @@ class PersistScheduleUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const instance = this.getScheduleStorage(symbol, strategyName, exchangeName);
@@ -1791,7 +1791,7 @@ class PersistScheduleUtils {
      * @param Ctor - Custom IPersistScheduleInstance constructor
      */
     usePersistScheduleAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
         this.PersistScheduleInstanceCtor = Ctor;
         this.getScheduleStorage.clear();
     }
@@ -1800,21 +1800,21 @@ class PersistScheduleUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
         this.getScheduleStorage.clear();
     }
     /**
      * Switches to the default file-based PersistScheduleInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistScheduleAdapter(PersistScheduleInstance);
     }
     /**
      * Switches to PersistScheduleDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistScheduleAdapter(PersistScheduleDummyInstance);
     }
 }
@@ -1959,7 +1959,7 @@ class PersistPartialUtils {
          * @returns Promise resolving to partial data record (empty object if none)
          */
         this.readPartialData = async (symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
             const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
@@ -1979,7 +1979,7 @@ class PersistPartialUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
             const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
@@ -1994,7 +1994,7 @@ class PersistPartialUtils {
      * @param Ctor - Custom IPersistPartialInstance constructor
      */
     usePersistPartialAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
         this.PersistPartialInstanceCtor = Ctor;
         this.getPartialStorage.clear();
     }
@@ -2003,21 +2003,21 @@ class PersistPartialUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
         this.getPartialStorage.clear();
     }
     /**
      * Switches to the default file-based PersistPartialInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistPartialAdapter(PersistPartialInstance);
     }
     /**
      * Switches to PersistPartialDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistPartialAdapter(PersistPartialDummyInstance);
     }
 }
@@ -2182,7 +2182,7 @@ class PersistBreakevenUtils {
          * @returns Promise resolving to breakeven data record (empty object if none)
          */
         this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
             const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
@@ -2202,7 +2202,7 @@ class PersistBreakevenUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
             const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
@@ -2217,7 +2217,7 @@ class PersistBreakevenUtils {
      * @param Ctor - Custom IPersistBreakevenInstance constructor
      */
     usePersistBreakevenAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
         this.PersistBreakevenInstanceCtor = Ctor;
         this.getBreakevenStorage.clear();
     }
@@ -2226,21 +2226,21 @@ class PersistBreakevenUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
         this.getBreakevenStorage.clear();
     }
     /**
      * Switches to the default file-based PersistBreakevenInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistBreakevenAdapter(PersistBreakevenInstance);
     }
     /**
      * Switches to PersistBreakevenDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistBreakevenAdapter(PersistBreakevenDummyInstance);
     }
 }
@@ -2331,7 +2331,7 @@ class PersistCandleInstance {
                     error: functoolsKit.errorData(error),
                     message: functoolsKit.getErrorMessage(error),
                 };
-                LOGGER_SERVICE$8.warn(message, payload);
+                LOGGER_SERVICE$9.warn(message, payload);
                 console.warn(message, payload);
                 errorEmitter.next(error);
                 return null;
@@ -2353,7 +2353,7 @@ class PersistCandleInstance {
         for (const candle of candles) {
             const candleCloseTime = candle.timestamp + stepMs;
             if (candleCloseTime > now) {
-                LOGGER_SERVICE$8.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
+                LOGGER_SERVICE$9.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
                     symbol: this.symbol,
                     interval: this.interval,
                     exchangeName: this.exchangeName,
@@ -2430,7 +2430,7 @@ class PersistCandleUtils {
          * @returns Promise resolving to candles in order, or null on cache miss
          */
         this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
-            LOGGER_SERVICE$8.info("PersistCandleUtils.readCandlesData", {
+            LOGGER_SERVICE$9.info("PersistCandleUtils.readCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
@@ -2454,7 +2454,7 @@ class PersistCandleUtils {
          * @returns Promise that resolves when all writes are complete
          */
         this.writeCandlesData = async (candles, symbol, interval, exchangeName) => {
-            LOGGER_SERVICE$8.info("PersistCandleUtils.writeCandlesData", {
+            LOGGER_SERVICE$9.info("PersistCandleUtils.writeCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
@@ -2474,7 +2474,7 @@ class PersistCandleUtils {
      * @param Ctor - Custom IPersistCandleInstance constructor
      */
     usePersistCandleAdapter(Ctor) {
-        LOGGER_SERVICE$8.info("PersistCandleUtils.usePersistCandleAdapter");
+        LOGGER_SERVICE$9.info("PersistCandleUtils.usePersistCandleAdapter");
         this.PersistCandleInstanceCtor = Ctor;
         this.getCandlesStorage.clear();
     }
@@ -2483,21 +2483,21 @@ class PersistCandleUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
         this.getCandlesStorage.clear();
     }
     /**
      * Switches to the default file-based PersistCandleInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log("PersistCandleUtils.useJson");
+        LOGGER_SERVICE$9.log("PersistCandleUtils.useJson");
         this.usePersistCandleAdapter(PersistCandleInstance);
     }
     /**
      * Switches to PersistCandleDummyInstance (always returns null on read, discards writes).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log("PersistCandleUtils.useDummy");
+        LOGGER_SERVICE$9.log("PersistCandleUtils.useDummy");
         this.usePersistCandleAdapter(PersistCandleDummyInstance);
     }
 }
@@ -2635,7 +2635,7 @@ class PersistStorageUtils {
          * @returns Promise resolving to array of signal entries
          */
         this.readStorageData = async (backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(backtest);
@@ -2651,7 +2651,7 @@ class PersistStorageUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeStorageData = async (signalData, backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(backtest);
@@ -2666,7 +2666,7 @@ class PersistStorageUtils {
      * @param Ctor - Custom IPersistStorageInstance constructor
      */
     usePersistStorageAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
         this.PersistStorageInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -2675,21 +2675,21 @@ class PersistStorageUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistStorageInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistStorageAdapter(PersistStorageInstance);
     }
     /**
      * Switches to PersistStorageDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistStorageAdapter(PersistStorageDummyInstance);
     }
 }
@@ -2816,7 +2816,7 @@ class PersistNotificationUtils {
          * @returns Promise resolving to array of notification entries
          */
         this.readNotificationData = async (backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
             const instance = this.getNotificationStorage(backtest);
@@ -2832,7 +2832,7 @@ class PersistNotificationUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeNotificationData = async (notificationData, backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
             const instance = this.getNotificationStorage(backtest);
@@ -2847,7 +2847,7 @@ class PersistNotificationUtils {
      * @param Ctor - Custom IPersistNotificationInstance constructor
      */
     usePersistNotificationAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
         this.PersistNotificationInstanceCtor = Ctor;
         this.getNotificationStorage.clear();
     }
@@ -2857,21 +2857,21 @@ class PersistNotificationUtils {
      * instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
         this.getNotificationStorage.clear();
     }
     /**
      * Switches to the default file-based PersistNotificationInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistNotificationAdapter(PersistNotificationInstance);
     }
     /**
      * Switches to PersistNotificationDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistNotificationAdapter(PersistNotificationDummyInstance);
     }
 }
@@ -2995,7 +2995,7 @@ class PersistLogUtils {
          * @returns Promise resolving to array of log entries
          */
         this.readLogData = async () => {
-            LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
             const isInitial = !this._logInstance;
             const instance = this.getLogInstance();
             await instance.waitForInit(isInitial);
@@ -3009,7 +3009,7 @@ class PersistLogUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeLogData = async (logData) => {
-            LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
             const isInitial = !this._logInstance;
             const instance = this.getLogInstance();
             await instance.waitForInit(isInitial);
@@ -3034,7 +3034,7 @@ class PersistLogUtils {
      * @param Ctor - Custom IPersistLogInstance constructor
      */
     usePersistLogAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
         this.PersistLogInstanceCtor = Ctor;
         this._logInstance = null;
     }
@@ -3043,21 +3043,21 @@ class PersistLogUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
         this._logInstance = null;
     }
     /**
      * Switches to the default file-based PersistLogInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistLogAdapter(PersistLogInstance);
     }
     /**
      * Switches to PersistLogDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistLogAdapter(PersistLogDummyInstance);
     }
 }
@@ -3219,7 +3219,7 @@ class PersistMeasureUtils {
          * @returns Promise resolving to cached value, or null if not found / soft-deleted
          */
         this.readMeasureData = async (bucket, key) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
             const instance = this.getMeasureStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3235,7 +3235,7 @@ class PersistMeasureUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMeasureData = async (data, bucket, key, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
             const instance = this.getMeasureStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3250,7 +3250,7 @@ class PersistMeasureUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeMeasureData = async (bucket, key) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
             const instance = this.getMeasureStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3264,7 +3264,7 @@ class PersistMeasureUtils {
      * @param Ctor - Custom IPersistMeasureInstance constructor
      */
     usePersistMeasureAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
         this.PersistMeasureInstanceCtor = Ctor;
         this.getMeasureStorage.clear();
     }
@@ -3276,7 +3276,7 @@ class PersistMeasureUtils {
      * @returns AsyncGenerator yielding entry keys
      */
     async *listMeasureData(bucket) {
-        LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
+        LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getMeasureStorage.has(bucket);
         const instance = this.getMeasureStorage(bucket);
         await instance.waitForInit(isInitial);
@@ -3287,21 +3287,21 @@ class PersistMeasureUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
         this.getMeasureStorage.clear();
     }
     /**
      * Switches to the default file-based PersistMeasureInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistMeasureAdapter(PersistMeasureInstance);
     }
     /**
      * Switches to PersistMeasureDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistMeasureAdapter(PersistMeasureDummyInstance);
     }
 }
@@ -3460,7 +3460,7 @@ class PersistIntervalUtils {
          * @returns Promise resolving to marker data, or null if not found / soft-deleted
          */
         this.readIntervalData = async (bucket, key) => {
-            LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
             const instance = this.getIntervalStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3476,7 +3476,7 @@ class PersistIntervalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeIntervalData = async (data, bucket, key, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
             const instance = this.getIntervalStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3491,7 +3491,7 @@ class PersistIntervalUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeIntervalData = async (bucket, key) => {
-            LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
             const instance = this.getIntervalStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3505,7 +3505,7 @@ class PersistIntervalUtils {
      * @param Ctor - Custom IPersistIntervalInstance constructor
      */
     usePersistIntervalAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
         this.PersistIntervalInstanceCtor = Ctor;
         this.getIntervalStorage.clear();
     }
@@ -3517,7 +3517,7 @@ class PersistIntervalUtils {
      * @returns AsyncGenerator yielding marker keys
      */
     async *listIntervalData(bucket) {
-        LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
+        LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getIntervalStorage.has(bucket);
         const instance = this.getIntervalStorage(bucket);
         await instance.waitForInit(isInitial);
@@ -3528,21 +3528,21 @@ class PersistIntervalUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
         this.getIntervalStorage.clear();
     }
     /**
      * Switches to the default file-based PersistIntervalInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistIntervalAdapter(PersistIntervalInstance);
     }
     /**
      * Switches to PersistIntervalDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistIntervalAdapter(PersistIntervalDummyInstance);
     }
 }
@@ -3748,7 +3748,7 @@ class PersistMemoryUtils {
          * @returns Promise resolving to entry data, or null if not found / soft-deleted
          */
         this.readMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3765,7 +3765,7 @@ class PersistMemoryUtils {
          * @returns Promise resolving to true if entry exists
          */
         this.hasMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3784,7 +3784,7 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMemoryData = async (data, signalId, bucketName, memoryId, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3801,7 +3801,7 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_REMOVE_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_REMOVE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3813,7 +3813,7 @@ class PersistMemoryUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
             this.getMemoryStorage.clear();
         };
         /**
@@ -3824,7 +3824,7 @@ class PersistMemoryUtils {
          * @param bucketName - Bucket name
          */
         this.dispose = (signalId, bucketName) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
             const key = `${signalId}:${bucketName}`;
             this.getMemoryStorage.clear(key);
         };
@@ -3836,7 +3836,7 @@ class PersistMemoryUtils {
      * @param Ctor - Custom IPersistMemoryInstance constructor
      */
     usePersistMemoryAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
         this.PersistMemoryInstanceCtor = Ctor;
         this.getMemoryStorage.clear();
     }
@@ -3850,7 +3850,7 @@ class PersistMemoryUtils {
      * @returns AsyncGenerator yielding `{ memoryId, data }` tuples
      */
     async *listMemoryData(signalId, bucketName) {
-        LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA, { signalId, bucketName });
+        LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA, { signalId, bucketName });
         const key = `${signalId}:${bucketName}`;
         const isInitial = !this.getMemoryStorage.has(key);
         const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3861,14 +3861,14 @@ class PersistMemoryUtils {
      * Switches to the default file-based PersistMemoryInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistMemoryAdapter(PersistMemoryInstance);
     }
     /**
      * Switches to PersistMemoryDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistMemoryAdapter(PersistMemoryDummyInstance);
     }
 }
@@ -4017,7 +4017,7 @@ class PersistRecentUtils {
          * @returns Promise resolving to recent signal or null if none persisted
          */
         this.readRecentData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_RECENT_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_RECENT_UTILS_METHOD_NAME_READ_DATA);
             const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
@@ -4038,7 +4038,7 @@ class PersistRecentUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
             const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
@@ -4071,7 +4071,7 @@ class PersistRecentUtils {
      * @param Ctor - Custom IPersistRecentInstance constructor
      */
     usePersistRecentAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
         this.PersistRecentInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -4080,21 +4080,21 @@ class PersistRecentUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistRecentInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistRecentAdapter(PersistRecentInstance);
     }
     /**
      * Switches to PersistRecentDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistRecentAdapter(PersistRecentDummyInstance);
     }
 }
@@ -4229,7 +4229,7 @@ class PersistStateUtils {
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (signalId, bucketName, initial) => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_WAIT_FOR_INIT, { signalId, bucketName, initial });
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_WAIT_FOR_INIT, { signalId, bucketName, initial });
             const key = `${signalId}:${bucketName}`;
             const isInitial = initial && !this.getStateStorage.has(key);
             const instance = this.getStateStorage(signalId, bucketName);
@@ -4244,7 +4244,7 @@ class PersistStateUtils {
          * @returns Promise resolving to state data or null if none persisted
          */
         this.readStateData = async (signalId, bucketName) => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName });
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
             const instance = this.getStateStorage(signalId, bucketName);
@@ -4262,7 +4262,7 @@ class PersistStateUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeStateData = async (data, signalId, bucketName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
             const instance = this.getStateStorage(signalId, bucketName);
@@ -4273,14 +4273,14 @@ class PersistStateUtils {
          * Switches to PersistStateDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
-            LOGGER_SERVICE$8.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
+            LOGGER_SERVICE$9.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
             this.usePersistStateAdapter(PersistStateDummyInstance);
         };
         /**
          * Switches to the default file-based PersistStateInstance.
          */
         this.useJson = () => {
-            LOGGER_SERVICE$8.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
+            LOGGER_SERVICE$9.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
             this.usePersistStateAdapter(PersistStateInstance);
         };
         /**
@@ -4288,7 +4288,7 @@ class PersistStateUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
             this.getStateStorage.clear();
         };
         /**
@@ -4299,7 +4299,7 @@ class PersistStateUtils {
          * @param bucketName - Bucket name
          */
         this.dispose = (signalId, bucketName) => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_DISPOSE);
             const key = `${signalId}:${bucketName}`;
             this.getStateStorage.clear(key);
         };
@@ -4311,7 +4311,7 @@ class PersistStateUtils {
      * @param Ctor - Custom IPersistStateInstance constructor
      */
     usePersistStateAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
         this.PersistStateInstanceCtor = Ctor;
         this.getStateStorage.clear();
     }
@@ -4451,7 +4451,7 @@ class PersistSessionUtils {
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (strategyName, exchangeName, frameName, initial) => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_WAIT_FOR_INIT, { strategyName, exchangeName, frameName, initial });
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_WAIT_FOR_INIT, { strategyName, exchangeName, frameName, initial });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = initial && !this.getSessionStorage.has(key);
             const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
@@ -4467,7 +4467,7 @@ class PersistSessionUtils {
          * @returns Promise resolving to session data or null if none persisted
          */
         this.readSessionData = async (strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_READ_DATA, { strategyName, exchangeName, frameName });
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_READ_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
             const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
@@ -4486,7 +4486,7 @@ class PersistSessionUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSessionData = async (data, strategyName, exchangeName, frameName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
             const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
@@ -4497,14 +4497,14 @@ class PersistSessionUtils {
          * Switches to PersistSessionDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
-            LOGGER_SERVICE$8.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
+            LOGGER_SERVICE$9.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
             this.usePersistSessionAdapter(PersistSessionDummyInstance);
         };
         /**
          * Switches to the default file-based PersistSessionInstance.
          */
         this.useJson = () => {
-            LOGGER_SERVICE$8.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
+            LOGGER_SERVICE$9.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
             this.usePersistSessionAdapter(PersistSessionInstance);
         };
         /**
@@ -4512,7 +4512,7 @@ class PersistSessionUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
             this.getSessionStorage.clear();
         };
         /**
@@ -4524,7 +4524,7 @@ class PersistSessionUtils {
          * @param frameName - Frame identifier
          */
         this.dispose = (strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_DISPOSE);
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             this.getSessionStorage.clear(key);
         };
@@ -4536,7 +4536,7 @@ class PersistSessionUtils {
      * @param Ctor - Custom IPersistSessionInstance constructor
      */
     usePersistSessionAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
         this.PersistSessionInstanceCtor = Ctor;
         this.getSessionStorage.clear();
     }
@@ -4658,7 +4658,7 @@ const METHOD_NAME_ADD_ACTIVITY = "LookupUtils.addActivity";
 const METHOD_NAME_REMOVE_ACTIVITY = "LookupUtils.removeActivity";
 const METHOD_NAME_LIST_ACTIVITY = "LookupUtils.listActivity";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$7 = new LoggerService();
+const LOGGER_SERVICE$8 = new LoggerService();
 /**
  * Builds the composite {@link Key} used to register an activity in `_lookupMap`.
  *
@@ -4712,7 +4712,7 @@ class LookupUtils {
          * @param activity - Activity descriptor identifying the running workload.
          */
         this.addActivity = (activity) => {
-            LOGGER_SERVICE$7.info(METHOD_NAME_ADD_ACTIVITY, {
+            LOGGER_SERVICE$8.info(METHOD_NAME_ADD_ACTIVITY, {
                 activity,
             });
             const key = CREATE_KEY_FN$y(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
@@ -4726,7 +4726,7 @@ class LookupUtils {
          * @param activity - Activity descriptor matching the one passed to {@link addActivity}.
          */
         this.removeActivity = (activity) => {
-            LOGGER_SERVICE$7.info(METHOD_NAME_REMOVE_ACTIVITY, {
+            LOGGER_SERVICE$8.info(METHOD_NAME_REMOVE_ACTIVITY, {
                 activity,
             });
             const key = CREATE_KEY_FN$y(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
@@ -4738,7 +4738,7 @@ class LookupUtils {
          * @returns Array of all activities present in the lookup map at call time.
          */
         this.listActivity = () => {
-            LOGGER_SERVICE$7.info(METHOD_NAME_LIST_ACTIVITY);
+            LOGGER_SERVICE$8.info(METHOD_NAME_LIST_ACTIVITY);
             return Array.from(this._lookupMap.values());
         };
     }
@@ -4767,7 +4767,7 @@ const METHOD_NAME_SPIN_LOCK = "CandleUtils.spinLock";
  */
 const ROTATE_DELAY = 50;
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$6 = new LoggerService();
+const LOGGER_SERVICE$7 = new LoggerService();
 /**
  * Process-wide coordinator for candle-fetch serialization and cooperative
  * yielding between parallel backtests.
@@ -4816,7 +4816,7 @@ class CandleUtils {
          * @param source - Caller identifier for logging.
          */
         this.acquireLock = async (source) => {
-            LOGGER_SERVICE$6.info(METHOD_NAME_ACQUIRE_LOCK, {
+            LOGGER_SERVICE$7.info(METHOD_NAME_ACQUIRE_LOCK, {
                 source,
             });
             if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
@@ -4832,7 +4832,7 @@ class CandleUtils {
          * @param source - Caller identifier for logging.
          */
         this.releaseLock = async (source) => {
-            LOGGER_SERVICE$6.info(METHOD_NAME_RELEASE_LOCK, {
+            LOGGER_SERVICE$7.info(METHOD_NAME_RELEASE_LOCK, {
                 source,
             });
             if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
@@ -4857,7 +4857,7 @@ class CandleUtils {
          * @param source - Caller identifier for logging.
          */
         this.spinLock = async (source) => {
-            LOGGER_SERVICE$6.info(METHOD_NAME_SPIN_LOCK, {
+            LOGGER_SERVICE$7.info(METHOD_NAME_SPIN_LOCK, {
                 source,
             });
             if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
@@ -6367,7 +6367,7 @@ const validateCommonSignal = (signal) => {
     }
     // Кидаем ошибку если есть проблемы
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
 };
 
@@ -6420,7 +6420,7 @@ const validatePendingSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
     validateCommonSignal(signal);
     // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
@@ -6468,7 +6468,7 @@ const validatePendingSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
 };
 
@@ -6521,7 +6521,7 @@ const validateScheduledSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
     validateCommonSignal(signal);
     // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ scheduled сигналов
@@ -6567,7 +6567,7 @@ const validateScheduledSignal = (signal, currentPrice) => {
         // pendingAt === 0 is allowed for scheduled signals (set to SCHEDULED_SIGNAL_PENDING_MOCK until activation)
     }
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
 };
 
@@ -7014,6 +7014,13 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     if (!signal) {
         return null;
     }
+    if (signal?.symbol && signal?.symbol !== self.params.execution.context.symbol) {
+        throw new Error(`Symbol mismatch: expected ${self.params.execution.context.symbol}, got ${signal.symbol}`);
+    }
+    // Whipsaw protection: skip signal if its id matches the last accepted pending id
+    if (signal.id && signal.id === self._lastPendingId) {
+        return null;
+    }
     if (self._isStopped) {
         return null;
     }
@@ -7057,6 +7064,9 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             }
             // Валидируем сигнал перед возвратом
             validatePendingSignal(signalRow, currentPrice);
+            if (signal.id) {
+                self._lastPendingId = signal.id;
+            }
             return signalRow;
         }
         // ОЖИДАНИЕ АКТИВАЦИИ: создаем scheduled signal (risk check при активации)
@@ -7083,6 +7093,9 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         };
         // Валидируем сигнал перед возвратом
         validateScheduledSignal(scheduledSignalRow, currentPrice);
+        if (signal.id) {
+            self._lastPendingId = signal.id;
+        }
         return scheduledSignalRow;
     }
     const signalRow = {
@@ -7110,6 +7123,9 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     }
     // Валидируем сигнал перед возвратом
     validatePendingSignal(signalRow, currentPrice);
+    if (signal.id) {
+        self._lastPendingId = signal.id;
+    }
     return signalRow;
 }, {
     defaultValue: null,
@@ -7139,6 +7155,13 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
     if (self.params.execution.context.backtest) {
         return;
     }
+    // Restore last pending signal id for whipsaw protection in GET_SIGNAL_FN
+    {
+        const recentSignal = await PersistRecentAdapter.readRecentData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName, self.params.method.context.frameName, false);
+        if (recentSignal?.id) {
+            self._lastPendingId = recentSignal.id;
+        }
+    }
     // Restore pending signal
     const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
     if (pendingSignal) {
@@ -9279,6 +9302,7 @@ class ClientStrategy {
         this._isStopped = false;
         this._pendingSignal = null;
         this._lastSignalTimestamp = null;
+        this._lastPendingId = null;
         this._scheduledSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
@@ -12068,7 +12092,7 @@ const RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE = "MergeRisk.checkSignalAndReser
 const RISK_METHOD_NAME_ADD_SIGNAL = "MergeRisk.addSignal";
 const RISK_METHOD_NAME_REMOVE_SIGNAL = "MergeRisk.removeSignal";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$5 = new LoggerService();
+const LOGGER_SERVICE$6 = new LoggerService();
 /**
  * Composite risk management class that combines multiple risk profiles.
  *
@@ -12124,7 +12148,7 @@ class MergeRisk {
      * @returns Promise resolving to true if all risks approve, false if any risk rejects
      */
     async checkSignal(params, options = {}) {
-        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_CHECK_SIGNAL, {
+        LOGGER_SERVICE$6.info(RISK_METHOD_NAME_CHECK_SIGNAL, {
             params,
         });
         for (const [riskName, risk] of Object.entries(this._riskMap)) {
@@ -12154,7 +12178,7 @@ class MergeRisk {
      * @returns Promise resolving to true if all risks approve (and reserved), false if any risk rejects
      */
     async checkSignalAndReserve(params) {
-        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE, {
+        LOGGER_SERVICE$6.info(RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE, {
             params,
         });
         for (const [riskName, risk] of Object.entries(this._riskMap)) {
@@ -12178,7 +12202,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have registered the signal
      */
     async addSignal(symbol, context, positionData) {
-        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_ADD_SIGNAL, {
+        LOGGER_SERVICE$6.info(RISK_METHOD_NAME_ADD_SIGNAL, {
             symbol,
             context,
         });
@@ -12195,7 +12219,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have removed the signal
      */
     async removeSignal(symbol, context) {
-        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_REMOVE_SIGNAL, {
+        LOGGER_SERVICE$6.info(RISK_METHOD_NAME_REMOVE_SIGNAL, {
             symbol,
             context,
         });
@@ -14988,7 +15012,7 @@ class RiskConnectionService {
 }
 
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$4 = new LoggerService();
+const LOGGER_SERVICE$5 = new LoggerService();
 /**
  * Wrapper to call init method with error capture.
  */
@@ -15003,7 +15027,7 @@ const CALL_INIT_FN = functoolsKit.trycatch(async (self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15023,7 +15047,7 @@ const CALL_SIGNAL_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15043,7 +15067,7 @@ const CALL_SIGNAL_LIVE_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15063,7 +15087,7 @@ const CALL_SIGNAL_BACKTEST_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15091,7 +15115,7 @@ const CALL_BREAKEVEN_AVAILABLE_FN = functoolsKit.trycatch(async (event, self) =>
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15119,7 +15143,7 @@ const CALL_PARTIAL_PROFIT_AVAILABLE_FN = functoolsKit.trycatch(async (event, sel
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15147,7 +15171,7 @@ const CALL_PARTIAL_LOSS_AVAILABLE_FN = functoolsKit.trycatch(async (event, self)
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15175,7 +15199,7 @@ const CALL_PING_SCHEDULED_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15203,7 +15227,7 @@ const CALL_PING_IDLE_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15231,7 +15255,7 @@ const CALL_PING_ACTIVE_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15251,7 +15275,7 @@ const CALL_RISK_REJECTION_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15271,7 +15295,7 @@ const CALL_DISPOSE_FN = functoolsKit.trycatch(async (self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -23135,7 +23159,7 @@ const REPORT_UTILS_METHOD_NAME_USE_DUMMY$1 = "ReportUtils.useDummy";
 const REPORT_UTILS_METHOD_NAME_USE_JSONL$1 = "ReportUtils.useJsonl";
 const REPORT_UTILS_METHOD_NAME_CLEAR$1 = "ReportUtils.clear";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$3 = new LoggerService();
+const LOGGER_SERVICE$4 = new LoggerService();
 /** Symbol key for the singleshot waitForInit function on MarkdownFileBase instances. */
 const WAIT_FOR_INIT_SYMBOL$1 = Symbol("wait-for-init");
 /** Symbol key for the timeout-protected write function on MarkdownFileBase instances. */
@@ -23216,7 +23240,7 @@ class MarkdownFileBase {
      * @throws Error if stream not initialized or write timeout exceeded
      */
     async dump(data, options) {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_FILE_DUMP, {
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_FILE_DUMP, {
             markdownName: this.markdownName,
             options,
         });
@@ -23296,7 +23320,7 @@ class MarkdownFolderBase {
      * @throws Error if directory creation or file write fails
      */
     async dump(content, options) {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_FOLDER_DUMP, {
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_FOLDER_DUMP, {
             markdownName: this.markdownName,
             options,
         });
@@ -23361,7 +23385,7 @@ class MarkdownWriterAdapter {
      * @param Ctor - Constructor for markdown storage adapter
      */
     useMarkdownAdapter(Ctor) {
-        LOGGER_SERVICE$3.info(MARKDOWN_METHOD_NAME_USE_ADAPTER$1);
+        LOGGER_SERVICE$4.info(MARKDOWN_METHOD_NAME_USE_ADAPTER$1);
         this.MarkdownFactory = Ctor;
     }
     /**
@@ -23375,7 +23399,7 @@ class MarkdownWriterAdapter {
      * @throws Error if write fails or storage initialization fails
      */
     async writeData(markdownName, content, options) {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_WRITE_DATA, {
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_WRITE_DATA, {
             markdownName,
             options,
         });
@@ -23389,7 +23413,7 @@ class MarkdownWriterAdapter {
      * Each report is written as a separate .md file.
      */
     useMd() {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_USE_MD$1);
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_USE_MD$1);
         this.useMarkdownAdapter(MarkdownFolderBase);
     }
     /**
@@ -23397,7 +23421,7 @@ class MarkdownWriterAdapter {
      * All reports are appended to a single .jsonl file per markdown type.
      */
     useJsonl() {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_USE_JSONL$1);
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_USE_JSONL$1);
         this.useMarkdownAdapter(MarkdownFileBase);
     }
     /**
@@ -23406,7 +23430,7 @@ class MarkdownWriterAdapter {
      * so new storage instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$3.log(MARKDOWN_METHOD_NAME_CLEAR$1);
+        LOGGER_SERVICE$4.log(MARKDOWN_METHOD_NAME_CLEAR$1);
         this.getMarkdownStorage.clear();
     }
     /**
@@ -23414,7 +23438,7 @@ class MarkdownWriterAdapter {
      * All future markdown writes will be no-ops.
      */
     useDummy() {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_USE_DUMMY$1);
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_USE_DUMMY$1);
         this.useMarkdownAdapter(MarkdownDummy);
     }
 }
@@ -23475,7 +23499,7 @@ class ReportBase {
                 });
             }
         }, 15000));
-        LOGGER_SERVICE$3.debug(REPORT_BASE_METHOD_NAME_CTOR, {
+        LOGGER_SERVICE$4.debug(REPORT_BASE_METHOD_NAME_CTOR, {
             reportName: this.reportName,
             baseDir,
         });
@@ -23489,7 +23513,7 @@ class ReportBase {
      * @returns Promise that resolves when initialization is complete
      */
     async waitForInit(initial) {
-        LOGGER_SERVICE$3.debug(REPORT_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        LOGGER_SERVICE$4.debug(REPORT_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             reportName: this.reportName,
             initial,
         });
@@ -23508,7 +23532,7 @@ class ReportBase {
      * @throws Error if stream not initialized or write timeout exceeded
      */
     async write(data, options) {
-        LOGGER_SERVICE$3.debug(REPORT_BASE_METHOD_NAME_WRITE, {
+        LOGGER_SERVICE$4.debug(REPORT_BASE_METHOD_NAME_WRITE, {
             reportName: this.reportName,
             options,
         });
@@ -23605,7 +23629,7 @@ class ReportWriterAdapter {
          * @internal - Automatically called by report services, not for direct use
          */
         this.writeData = async (reportName, data, options) => {
-            LOGGER_SERVICE$3.info(REPORT_UTILS_METHOD_NAME_WRITE_DATA, {
+            LOGGER_SERVICE$4.info(REPORT_UTILS_METHOD_NAME_WRITE_DATA, {
                 reportName,
                 options,
             });
@@ -23622,7 +23646,7 @@ class ReportWriterAdapter {
      * @param Ctor - Constructor for report storage adapter
      */
     useReportAdapter(Ctor) {
-        LOGGER_SERVICE$3.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER$1);
+        LOGGER_SERVICE$4.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER$1);
         this.ReportFactory = Ctor;
     }
     /**
@@ -23631,7 +23655,7 @@ class ReportWriterAdapter {
      * so new storage instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_CLEAR$1);
+        LOGGER_SERVICE$4.log(REPORT_UTILS_METHOD_NAME_CLEAR$1);
         this.getReportStorage.clear();
     }
     /**
@@ -23639,7 +23663,7 @@ class ReportWriterAdapter {
      * All future report writes will be no-ops.
      */
     useDummy() {
-        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY$1);
+        LOGGER_SERVICE$4.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY$1);
         this.useReportAdapter(ReportDummy);
     }
     /**
@@ -23647,7 +23671,7 @@ class ReportWriterAdapter {
      * All future report writes will use JSONL storage.
      */
     useJsonl() {
-        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_USE_JSONL$1);
+        LOGGER_SERVICE$4.log(REPORT_UTILS_METHOD_NAME_USE_JSONL$1);
         this.useReportAdapter(ReportBase);
     }
 }
@@ -53948,7 +53972,7 @@ const REPORT_UTILS_METHOD_NAME_USE_DUMMY = "ReportUtils.useDummy";
 const REPORT_UTILS_METHOD_NAME_USE_JSONL = "ReportUtils.useJsonl";
 const REPORT_UTILS_METHOD_NAME_CLEAR = "ReportUtils.clear";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$2 = new LoggerService();
+const LOGGER_SERVICE$3 = new LoggerService();
 /**
  * Default configuration that enables all report services.
  * Used when no specific configuration is provided to enable().
@@ -54005,7 +54029,7 @@ class ReportUtils {
          * @returns Cleanup function that unsubscribes from all enabled services
          */
         this.enable = functoolsKit.singleshot(({ 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, {
+            LOGGER_SERVICE$3.debug(REPORT_UTILS_METHOD_NAME_ENABLE, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54100,7 +54124,7 @@ class ReportUtils {
          * ```
          */
         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, {
+            LOGGER_SERVICE$3.debug(REPORT_UTILS_METHOD_NAME_DISABLE, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54180,7 +54204,7 @@ class ReportAdapter extends ReportUtils {
      * @param Ctor - Constructor for report storage adapter
      */
     useReportAdapter(Ctor) {
-        LOGGER_SERVICE$2.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER);
+        LOGGER_SERVICE$3.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER);
         ReportWriter.useReportAdapter(Ctor);
     }
     /**
@@ -54189,7 +54213,7 @@ class ReportAdapter extends ReportUtils {
      * so new storage instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$2.log(REPORT_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_CLEAR);
         ReportWriter.clear();
     }
     /**
@@ -54197,7 +54221,7 @@ class ReportAdapter extends ReportUtils {
      * All future report writes will be no-ops.
      */
     useDummy() {
-        LOGGER_SERVICE$2.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY);
         ReportWriter.useDummy();
     }
     /**
@@ -54205,7 +54229,7 @@ class ReportAdapter extends ReportUtils {
      * All future report writes will use JSONL storage.
      */
     useJsonl() {
-        LOGGER_SERVICE$2.log(REPORT_UTILS_METHOD_NAME_USE_JSONL);
+        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_USE_JSONL);
         ReportWriter.useJsonl();
     }
 }
@@ -54223,7 +54247,7 @@ const MARKDOWN_METHOD_NAME_USE_JSONL = "MarkdownAdapter.useJsonl";
 const MARKDOWN_METHOD_NAME_USE_DUMMY = "MarkdownAdapter.useDummy";
 const MARKDOWN_METHOD_NAME_CLEAR = "MarkdownAdapter.clear";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$1 = new LoggerService();
+const LOGGER_SERVICE$2 = new LoggerService();
 /**
  * Default configuration that enables all markdown services.
  * Used when no specific configuration is provided to `enable()`.
@@ -54280,7 +54304,7 @@ class MarkdownUtils {
          * @returns Cleanup function that unsubscribes from all enabled services
          */
         this.enable = functoolsKit.singleshot(({ 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, {
+            LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_ENABLE, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54377,7 +54401,7 @@ class MarkdownUtils {
          * ```
          */
         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, {
+            LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_DISABLE, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54463,7 +54487,7 @@ class MarkdownUtils {
          * @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$1) => {
-            LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_CLEAR, {
+            LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_CLEAR, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54538,7 +54562,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * @param Ctor - Constructor for markdown storage adapter
      */
     useMarkdownAdapter(Ctor) {
-        LOGGER_SERVICE$1.info(MARKDOWN_METHOD_NAME_USE_ADAPTER);
+        LOGGER_SERVICE$2.info(MARKDOWN_METHOD_NAME_USE_ADAPTER);
         return MarkdownWriter.useMarkdownAdapter(Ctor);
     }
     /**
@@ -54547,7 +54571,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * Each dump creates a separate .md file.
      */
     useMd() {
-        LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_USE_MD);
+        LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_USE_MD);
         MarkdownWriter.useMd();
     }
     /**
@@ -54556,7 +54580,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * All dumps append to a single .jsonl file per markdown type.
      */
     useJsonl() {
-        LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_USE_JSONL);
+        LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_USE_JSONL);
         MarkdownWriter.useJsonl();
     }
     /**
@@ -54564,7 +54588,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * All future markdown writes will be no-ops.
      */
     useDummy() {
-        LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_USE_DUMMY);
         MarkdownWriter.useDummy();
     }
 }
@@ -63253,6 +63277,470 @@ class IntervalUtils {
  */
 const Interval = new IntervalUtils();
 
+const CRON_METHOD_NAME_REGISTER = "CronUtils.register";
+const CRON_METHOD_NAME_UNREGISTER = "CronUtils.unregister";
+const CRON_METHOD_NAME_CLEAR = "CronUtils.clear";
+const CRON_METHOD_NAME_TICK = "CronUtils._tick";
+const CRON_METHOD_NAME_ENABLE = "CronUtils.enable";
+const CRON_METHOD_NAME_DISABLE = "CronUtils.disable";
+/**
+ * Local logger instance.
+ *
+ * Created directly rather than resolved from the DI container so that
+ * `CronUtils` has no compile-time dependency on the rest of the framework
+ * being bootstrapped — `Cron` can be imported and used in isolation.
+ */
+const LOGGER_SERVICE$1 = new LoggerService();
+/**
+ * Utility class for registering periodic tasks that fire on candle-interval
+ * boundaries of the virtual time produced by parallel backtests.
+ *
+ * Exported as singleton instance `Cron` for convenient usage.
+ *
+ * Key property — **singleshot coordination across parallel backtests**:
+ * when several `Backtest.background(symbol, ...)` runs hit the same aligned
+ * boundary concurrently, the handler is invoked exactly once. Every parallel
+ * `tick` for that boundary awaits the same in-flight promise and is released
+ * together when the promise settles. After settlement the slot is cleared and
+ * the next boundary produces a fresh promise.
+ *
+ * Typical wiring:
+ *
+ * @example
+ * ```typescript
+ * import { Cron, Backtest } from "backtest-kit";
+ *
+ * Cron.register({
+ *   name: "tg-signal-parser",
+ *   interval: "1h",
+ *   handler: async (symbol, when, backtest) => {
+ *     await parseTelegramSignalsToMongo(when);
+ *   },
+ * });
+ *
+ * // Subscribe Cron to the engine's lifecycle subjects (beforeStart,
+ * // idlePing, activePing, schedulePing) once at startup. After this every
+ * // strategy tick is forwarded into Cron automatically.
+ * Cron.enable();
+ *
+ * for (const symbol of ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "TRXUSDT"]) {
+ *   Backtest.background(symbol, { strategyName, exchangeName, frameName });
+ * }
+ *
+ * // On shutdown:
+ * // Cron.disable();
+ * ```
+ */
+class CronUtils {
+    constructor() {
+        /**
+         * Registered entries by `name`.
+         *
+         * Each record carries a monotonically increasing `generation` counter that
+         * is bumped on every `register(entry)` call for the same name. The
+         * generation participates in `firedKey` so writes from a still-in-flight
+         * handler of a previous incarnation cannot poison `_firedOnce` for the
+         * current incarnation — their key has a different generation suffix and
+         * is simply ignored on lookup.
+         */
+        this._entries = new Map();
+        /** Monotonic counter used to mint new entry generations on `register`. */
+        this._generationCounter = 0;
+        /**
+         * In-flight handler slots.
+         *
+         * Slot key shape (always includes the generation suffix `:g${generation}`;
+         * the `:${symbol}` scope is present only in fan-out mode):
+         * - Periodic global: `${name}:${alignedMs}:g${generation}`.
+         * - Periodic fan-out: `${name}:${alignedMs}:${symbol}:g${generation}`.
+         * - Fire-once global: `${name}:once:g${generation}`.
+         * - Fire-once fan-out: `${name}:once:${symbol}:g${generation}`.
+         *
+         * Value is the shared in-flight handler promise. Every parallel `tick` for
+         * the same slot key awaits this exact promise (mutex semantics) and is
+         * released together when it settles. `_inFlight` is owned exclusively by
+         * `_runEntry` — `clear()` does **not** touch it, so the singleshot promise
+         * survives concurrent `clear` calls and continues to coordinate parallel
+         * ticks until it settles.
+         */
+        this._inFlight = new Map();
+        /**
+         * Keys of fire-once entries whose handler has already settled successfully.
+         *
+         * Key shape (always includes the entry generation suffix `:g${generation}`):
+         * - Global fire-once: `${name}:g${generation}`.
+         * - Fan-out fire-once: `${name}:${symbol}:g${generation}` — one entry per
+         *   whitelisted symbol.
+         *
+         * The generation suffix isolates incarnations of the same `name`: writes
+         * landing from a still-in-flight handler of a previous `register()` carry
+         * the old generation and are never matched by the new entry's lookup.
+         * Stale entries are pruned by `_clearFiredOnceFor` on `register`/`unregister`
+         * and wiped by `clear()`.
+         *
+         * Looked up by `_tick` to decide whether to skip; written by `_runEntry`
+         * on successful settle.
+         */
+        this._firedOnce = new Set();
+        /**
+         * Register a periodic cron entry.
+         *
+         * Idempotent on `name`: re-registering the same name replaces the previous
+         * entry (interval/symbols/handler can all change). Re-registration does
+         * **not** clear in-flight promises — entries still resolving complete with
+         * the previous handler.
+         *
+         * @param entry - Entry configuration; see {@link CronEntry}.
+         * @returns Disposer function — call it to unregister the entry.
+         *
+         * @example
+         * ```typescript
+         * const dispose = Cron.register({
+         *   name: "fetch-funding",
+         *   interval: "8h",
+         *   symbols: ["BTCUSDT", "ETHUSDT"],
+         *   handler: async (symbol, when, backtest) => { ... },
+         * });
+         * // Later:
+         * dispose();
+         * ```
+         */
+        this.register = (entry) => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_REGISTER, {
+                name: entry.name,
+                interval: entry.interval,
+                symbols: entry.symbols,
+            });
+            if (!entry.name) {
+                throw new Error("CronUtils.register requires a non-empty name");
+            }
+            if (entry.name.includes(":")) {
+                throw new Error(`CronUtils.register: name must not contain ':' (got "${entry.name}"). ` +
+                    `':' is reserved as the segment separator in slot keys.`);
+            }
+            if (entry.symbols) {
+                for (const symbol of entry.symbols) {
+                    if (symbol.includes(":")) {
+                        throw new Error(`CronUtils.register: symbols[] entry must not contain ':' (got "${symbol}"). ` +
+                            `':' is reserved as the segment separator in slot keys.`);
+                    }
+                }
+            }
+            this._clearFiredOnceFor(entry.name);
+            const generation = ++this._generationCounter;
+            this._entries.set(entry.name, { entry, generation });
+            return () => this.unregister(entry.name);
+        };
+        /**
+         * Remove a registered entry by name.
+         *
+         * Does not cancel handlers already in flight — those resolve on their own
+         * and clear their slot via `.finally()`.
+         *
+         * @param name - Name passed to `register`.
+         */
+        this.unregister = (name) => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_UNREGISTER, { name });
+            this._entries.delete(name);
+            this._clearFiredOnceFor(name);
+        };
+        /**
+         * Clear fire-once marks so that fire-once entries can fire again.
+         *
+         * Does **not** touch `_inFlight` — that map holds shared in-flight handler
+         * promises through which parallel `tick`s coordinate. Wiping it mid-flight
+         * would let a new `tick` start a second handler for a boundary that's
+         * already running, breaking the singleshot contract.
+         *
+         * Two modes:
+         * - **Per-symbol** (`symbol` provided): clears only fan-out fire-once
+         *   marks for that symbol — keys of the shape `${name}:${symbol}:g${gen}`.
+         *   Global fire-once marks (`${name}:g${gen}`, no symbol component) are
+         *   left intact, since they are not attributable to a single symbol.
+         *   Useful for re-arming fan-out fire-once entries when a particular
+         *   symbol's run finishes and you want a future re-run to fire again.
+         * - **All** (no argument): wipes every fire-once mark across all entries
+         *   and symbols. Registered entries are not removed — use `unregister`
+         *   (or the disposer returned by `register`) for that.
+         *
+         * **Race with in-flight handlers.** `_firedOnce` is written in
+         * `_runEntry`'s `.finally()`, which can run *after* a concurrent
+         * `clear()` call. In that case the fire-once mark reappears immediately
+         * after being wiped, and the next tick will treat the entry as already
+         * fired. This is consistent with the singleshot promise itself surviving
+         * `clear()` — the handler is allowed to finish — and the entry's
+         * generation suffix in `firedKey` guarantees the stale mark cannot
+         * outlive a subsequent `register()` of the same name. If you need a hard
+         * re-arm, `unregister` + `register` bumps the generation and makes any
+         * late write a no-op.
+         *
+         * @param symbol - Optional symbol filter; if omitted, clears all fire-once
+         *   marks.
+         */
+        this.clear = (symbol) => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_CLEAR, { symbol });
+            if (!symbol) {
+                this._firedOnce.clear();
+                return;
+            }
+            const symbolSegment = `:${symbol}:`;
+            for (const key of this._firedOnce) {
+                if (key.includes(symbolSegment)) {
+                    this._firedOnce.delete(key);
+                }
+            }
+        };
+        /**
+         * Process a virtual-time tick for `symbol` and fire any due cron entries.
+         *
+         * **Private.** Invoked exclusively by the lifecycle bridge installed in
+         * {@link enable} — `beforeStart` / `idlePing` / `activePing` / `schedulePing`
+         * are funneled here through a shared `singlerun` queue, so calls to
+         * `_tick` are serialised end-to-end. Do not call directly.
+         *
+         * Algorithm (per registered entry):
+         * 0. Base-align the incoming `when` down to the 1-minute boundary (`ts`).
+         *    Lifecycle subjects may emit with sub-second jitter; rounding here
+         *    guarantees that `beforeStart` / `idlePing` / `activePing` /
+         *    `schedulePing` for the same virtual minute all hash to the same
+         *    slot key.
+         * 1. If `entry.symbols` is non-empty and does not include `symbol`, skip.
+         * 2. Decide scope from `entry.symbols`:
+         *    - Empty/undefined → **global** (slot key has no symbol component).
+         *    - Non-empty → **fan-out**, slot key carries `:${symbol}` so each
+         *      whitelisted symbol gets its own slot and handler invocation.
+         * 3. Append the current entry generation suffix `:g${generation}` to both
+         *    slot key and fired-once key. This isolates incarnations of the same
+         *    `name`: a `register()` after an in-flight handler bumps the
+         *    generation, so the late `_firedOnce` write from the old handler can
+         *    never block the new entry.
+         * 4. **Fire-once** (`entry.interval === undefined`):
+         *    - If the entry's fired-once key is already in `_firedOnce`, skip.
+         *    - Slot key: `${name}:once` (+ scope) (+ gen).
+         *    - `aligned` = the 1-minute-aligned `when` from step 0.
+         * 5. **Periodic** (`entry.interval` set):
+         *    - Align `when` further to the entry's interval via {@link alignToInterval}.
+         *    - If `ts !== alignedMs`, the tick is mid-interval — skip.
+         *      (This is the "remainder === 0" boundary check from the spec;
+         *      since `ts` is already on the 1-minute boundary, the check is exact
+         *      for `1m` and consistent for higher intervals.)
+         *    - Slot key: `${name}:${alignedMs}` (+ scope) (+ gen).
+         * 6. Singleshot per slot key: look up the slot in `_inFlight`. If a promise
+         *    already exists, `await` the same promise. Otherwise invoke
+         *    `entry.handler`, store the promise, and `await` it. The slot is
+         *    removed in `.finally()` so the next boundary creates a fresh promise;
+         *    for fire-once entries the fired-once key is also added to
+         *    `_firedOnce` on success so subsequent ticks skip it.
+         *
+         * Errors thrown by `handler` are caught, logged via `console.error`, and
+         * **not** rethrown — a failing handler must not break the per-symbol
+         * tick loop or unblock other parallel backtests with an unhandled
+         * rejection. A failed fire-once handler is **not** marked as fired and
+         * will retry on the next tick.
+         *
+         * Requires active method context and execution context.
+         *
+         * @param symbol - Trading symbol from the current tick.
+         * @param when - Virtual time of the current tick.
+         * @param backtest - `true` for backtest ticks, `false` for live ticks.
+         *   Forwarded as the third argument to `entry.handler`. Only the value
+         *   from the tick that **opens** a given slot is observed by all parallel
+         *   awaiters of that slot.
+         * @throws Error if method or execution context is missing.
+         */
+        this._tick = async (symbol, when, backtest) => {
+            LOGGER_SERVICE$1.debug(CRON_METHOD_NAME_TICK, {
+                symbol,
+                when,
+            });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("CronUtils _tick requires method context");
+            }
+            if (!ExecutionContextService.hasContext()) {
+                throw new Error("CronUtils _tick requires execution context");
+            }
+            const ts = alignToInterval(when, "1m").getTime();
+            const taskList = [];
+            for (const { entry, generation } of this._entries.values()) {
+                if (entry.symbols?.length && !entry.symbols.includes(symbol)) {
+                    continue;
+                }
+                const perSymbol = !!entry.symbols?.length;
+                const scope = perSymbol ? `:${symbol}` : "";
+                const genSuffix = `:g${generation}`;
+                let aligned;
+                let alignedMs;
+                let slotKey;
+                let firedKey;
+                if (entry.interval === undefined) {
+                    const onceKey = `${entry.name}${scope}${genSuffix}`;
+                    if (this._firedOnce.has(onceKey)) {
+                        continue;
+                    }
+                    aligned = alignToInterval(when, "1m");
+                    alignedMs = ts;
+                    slotKey = `${entry.name}:once${scope}${genSuffix}`;
+                    firedKey = onceKey;
+                }
+                else {
+                    aligned = alignToInterval(when, entry.interval);
+                    alignedMs = aligned.getTime();
+                    if (ts !== alignedMs) {
+                        continue;
+                    }
+                    slotKey = `${entry.name}:${alignedMs}${scope}${genSuffix}`;
+                    firedKey = null;
+                }
+                let pending = this._inFlight.get(slotKey);
+                if (!pending) {
+                    pending = this._runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest);
+                    this._inFlight.set(slotKey, pending);
+                }
+                taskList.push(pending);
+            }
+            await Promise.all(taskList);
+        };
+        /**
+         * Subscribe `Cron` to the engine's strategy lifecycle subjects so registered
+         * entries fire automatically — no manual wiring of `listenTickBacktest` /
+         * `listenSchedulePing` etc. needed.
+         *
+         * Subjects funneled into {@link _tick}:
+         * - `beforeStartSubject` — first event of every run.
+         * - `idlePingSubject` — every tick when no signal is pending or scheduled.
+         * - `activePingSubject` — every tick while a pending signal is being monitored.
+         * - `schedulePingSubject` — every tick while a scheduled signal is being monitored.
+         *
+         * All four subjects are subscribed to a single `singlerun`-wrapped
+         * handler that builds `_tick(event.symbol, new Date(event.timestamp),
+         * event.backtest)`. `singlerun` merges the four streams into one serial
+         * queue: at most one `_tick` runs at a time, the next waits. This matters
+         * because the engine can emit `beforeStart` and an immediate `idlePing`
+         * on the very same minute, and concurrent `_tick`s on the same
+         * `(symbol, minute)` would otherwise race to open the same `_inFlight`
+         * slot before either commit. Together these four sources cover every
+         * tick the engine processes for every `(symbol, virtual-minute)` pair
+         * regardless of whether the strategy is idle, active, or scheduled.
+         *
+         * `enable` itself is wrapped in `singleshot`, so calling it repeatedly is
+         * a no-op — subsequent calls return the same disposer. The disposer
+         * unsubscribes from every subject and resets the singleshot so a future
+         * `enable()` can re-subscribe cleanly. Equivalent to the
+         * `RecentAdapter.enable` pattern.
+         *
+         * The `.subscribe` callbacks are synchronous wrappers around the
+         * `singlerun`-async handler; `_tick`'s returned promise is awaited inside
+         * `singlerun` to enforce ordering but not bubbled back to the subject.
+         * Errors are caught and logged inside `_runEntry`.
+         *
+         * @returns Cleanup function that unsubscribes from all four subjects and
+         *   resets the singleshot. Idempotent.
+         *
+         * @example
+         * ```typescript
+         * import { Cron } from "backtest-kit";
+         *
+         * Cron.register({ name: "tg-parser", interval: "1h", handler });
+         * Cron.enable(); // wire once at startup
+         * // ... run backtests / live as usual
+         * Cron.disable(); // on shutdown
+         * ```
+         */
+        this.enable = functoolsKit.singleshot(() => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_ENABLE);
+            const handleTick = functoolsKit.singlerun(async (event) => {
+                return await this._tick(event.symbol, new Date(event.timestamp), event.backtest);
+            });
+            const unBeforeStart = beforeStartSubject.subscribe(handleTick);
+            const unIdlePing = idlePingSubject.subscribe(handleTick);
+            const unActivePing = activePingSubject.subscribe(handleTick);
+            const unSchedulePing = schedulePingSubject.subscribe(handleTick);
+            return functoolsKit.compose(() => unBeforeStart(), () => unIdlePing(), () => unActivePing(), () => unSchedulePing(), () => this.enable.clear());
+        });
+        /**
+         * Tear down the lifecycle subscriptions installed by {@link enable}.
+         *
+         * Safe to call multiple times and safe to call before `enable()` — both
+         * are no-ops. Does **not** unregister entries, does **not** touch
+         * `_inFlight`, and does **not** wipe `_firedOnce` (use `unregister` or
+         * `clear()` for those).
+         */
+        this.disable = () => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_DISABLE);
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+    }
+    /**
+     * Garbage-collect every `_firedOnce` key that belongs to the entry `name`
+     * (any generation, global or fan-out).
+     *
+     * Called from `register`/`unregister` to free memory; **not** required
+     * for correctness — the generation suffix already isolates re-registrations,
+     * so leftover keys from old generations can never block a new entry.
+     * They just sit unused until they are GC'd here or wiped by `clear()`.
+     */
+    _clearFiredOnceFor(name) {
+        if (!name) {
+            return;
+        }
+        const prefix = `${name}:`;
+        for (const key of this._firedOnce) {
+            if (key === name || key.startsWith(prefix)) {
+                this._firedOnce.delete(key);
+            }
+        }
+    }
+    /**
+     * Build the singleshot promise for a single in-flight slot.
+     *
+     * Invokes `entry.handler(symbol, aligned, backtest)`, swallows and logs
+     * any error via `console.error`, and clears the `_inFlight` slot
+     * in `.finally()` so the next boundary produces a fresh promise. For
+     * fire-once entries `firedKey` is added to `_firedOnce` on success so
+     * subsequent ticks skip it.
+     *
+     * @param firedKey - Key to add to `_firedOnce` on success, or `null` for
+     *   periodic entries (which never populate `_firedOnce`).
+     * @param backtest - Value forwarded as the third handler argument; the
+     *   "winner" tick's flag is what all parallel awaiters of this slot see.
+     */
+    async _runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest) {
+        let failed = false;
+        try {
+            await entry.handler(symbol, aligned, backtest);
+        }
+        catch (err) {
+            failed = true;
+            console.error(`${CRON_METHOD_NAME_TICK} entry "${entry.name}" failed`, { symbol, alignedMs, err });
+        }
+        finally {
+            this._inFlight.delete(slotKey);
+            if (!failed && firedKey !== null) {
+                this._firedOnce.add(firedKey);
+            }
+        }
+    }
+}
+/**
+ * Singleton instance of {@link CronUtils} for registering periodic tasks
+ * coordinated across parallel `Backtest.background` runs.
+ *
+ * @example
+ * ```typescript
+ * import { Cron } from "backtest-kit";
+ *
+ * Cron.register({
+ *   name: "tg-parser",
+ *   interval: "1h",
+ *   handler: async (symbol, when, backtest) => { ... },
+ * });
+ * ```
+ */
+const Cron = new CronUtils();
+
 const BREAKEVEN_METHOD_NAME_GET_DATA = "BreakevenUtils.getData";
 const BREAKEVEN_METHOD_NAME_GET_REPORT = "BreakevenUtils.getReport";
 const BREAKEVEN_METHOD_NAME_DUMP = "BreakevenUtils.dump";
@@ -64335,7 +64823,7 @@ const validateSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        console.error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
         return false;
     }
     try {
@@ -64408,7 +64896,7 @@ const validateSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        console.error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
     return !errors.length;
 };
@@ -64420,6 +64908,7 @@ exports.Broker = Broker;
 exports.BrokerBase = BrokerBase;
 exports.Cache = Cache;
 exports.Constant = Constant;
+exports.Cron = Cron;
 exports.Dump = Dump;
 exports.Exchange = Exchange;
 exports.ExecutionContextService = ExecutionContextService;
@@ -64510,6 +64999,8 @@ exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
 exports.alignToInterval = alignToInterval;
+exports.beginContext = beginContext;
+exports.beginTime = beginTime;
 exports.cacheCandles = cacheCandles;
 exports.checkCandles = checkCandles;
 exports.commitActivateScheduled = commitActivateScheduled;
@@ -64692,6 +65183,7 @@ exports.shutdown = shutdown;
 exports.slPercentShiftToPrice = slPercentShiftToPrice;
 exports.slPriceToPercentShift = slPriceToPercentShift;
 exports.stopStrategy = stopStrategy;
+exports.toPlainString = toPlainString;
 exports.toProfitLossDto = toProfitLossDto;
 exports.tpPercentShiftToPrice = tpPercentShiftToPrice;
 exports.tpPriceToPercentShift = tpPriceToPercentShift;