backtest-kit 9.8.4 → 10.1.0

package/build/index.mjs

@@ -942,7 +942,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
@@ -1065,7 +1065,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,
     });
@@ -1123,7 +1123,7 @@ class PersistBase {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a$3] = 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,
         });
@@ -1139,14 +1139,14 @@ class PersistBase {
         return 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,
         });
@@ -1163,7 +1163,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,
         });
@@ -1180,7 +1180,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,
         });
@@ -1202,7 +1202,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 {
@@ -1347,7 +1347,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);
@@ -1365,7 +1365,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);
@@ -1380,7 +1380,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();
     }
@@ -1389,21 +1389,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);
     }
 }
@@ -1543,7 +1543,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);
@@ -1561,7 +1561,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);
@@ -1576,7 +1576,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();
     }
@@ -1585,21 +1585,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);
     }
 }
@@ -1738,7 +1738,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);
@@ -1756,7 +1756,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);
@@ -1771,7 +1771,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();
     }
@@ -1780,21 +1780,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);
     }
 }
@@ -1939,7 +1939,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);
@@ -1959,7 +1959,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);
@@ -1974,7 +1974,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();
     }
@@ -1983,21 +1983,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);
     }
 }
@@ -2162,7 +2162,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);
@@ -2182,7 +2182,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);
@@ -2197,7 +2197,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();
     }
@@ -2206,21 +2206,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);
     }
 }
@@ -2311,7 +2311,7 @@ class PersistCandleInstance {
                     error: errorData(error),
                     message: getErrorMessage(error),
                 };
-                LOGGER_SERVICE$8.warn(message, payload);
+                LOGGER_SERVICE$9.warn(message, payload);
                 console.warn(message, payload);
                 errorEmitter.next(error);
                 return null;
@@ -2333,7 +2333,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,
@@ -2410,7 +2410,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,
@@ -2434,7 +2434,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,
@@ -2454,7 +2454,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();
     }
@@ -2463,21 +2463,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);
     }
 }
@@ -2615,7 +2615,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);
@@ -2631,7 +2631,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);
@@ -2646,7 +2646,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();
     }
@@ -2655,21 +2655,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);
     }
 }
@@ -2796,7 +2796,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);
@@ -2812,7 +2812,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);
@@ -2827,7 +2827,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();
     }
@@ -2837,21 +2837,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);
     }
 }
@@ -2975,7 +2975,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);
@@ -2989,7 +2989,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);
@@ -3014,7 +3014,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;
     }
@@ -3023,21 +3023,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);
     }
 }
@@ -3199,7 +3199,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);
@@ -3215,7 +3215,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);
@@ -3230,7 +3230,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);
@@ -3244,7 +3244,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();
     }
@@ -3256,7 +3256,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);
@@ -3267,21 +3267,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);
     }
 }
@@ -3440,7 +3440,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);
@@ -3456,7 +3456,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);
@@ -3471,7 +3471,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);
@@ -3485,7 +3485,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();
     }
@@ -3497,7 +3497,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);
@@ -3508,21 +3508,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);
     }
 }
@@ -3728,7 +3728,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);
@@ -3745,7 +3745,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);
@@ -3764,7 +3764,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);
@@ -3781,7 +3781,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);
@@ -3793,7 +3793,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();
         };
         /**
@@ -3804,7 +3804,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);
         };
@@ -3816,7 +3816,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();
     }
@@ -3830,7 +3830,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);
@@ -3841,14 +3841,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);
     }
 }
@@ -3997,7 +3997,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);
@@ -4018,7 +4018,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);
@@ -4051,7 +4051,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();
     }
@@ -4060,21 +4060,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);
     }
 }
@@ -4209,7 +4209,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);
@@ -4224,7 +4224,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);
@@ -4242,7 +4242,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);
@@ -4253,14 +4253,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);
         };
         /**
@@ -4268,7 +4268,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();
         };
         /**
@@ -4279,7 +4279,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);
         };
@@ -4291,7 +4291,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();
     }
@@ -4431,7 +4431,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);
@@ -4447,7 +4447,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);
@@ -4466,7 +4466,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);
@@ -4477,14 +4477,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);
         };
         /**
@@ -4492,7 +4492,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();
         };
         /**
@@ -4504,7 +4504,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);
         };
@@ -4516,7 +4516,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();
     }
@@ -4638,7 +4638,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`.
  *
@@ -4692,7 +4692,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);
@@ -4706,7 +4706,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);
@@ -4718,7 +4718,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());
         };
     }
@@ -4747,7 +4747,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.
@@ -4796,7 +4796,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) {
@@ -4812,7 +4812,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) {
@@ -4837,7 +4837,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) {
@@ -6347,7 +6347,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")}`);
     }
 };
 
@@ -6400,7 +6400,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);
     // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
@@ -6448,7 +6448,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")}`);
     }
 };
 
@@ -6501,7 +6501,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 сигналов
@@ -6547,7 +6547,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")}`);
     }
 };
 
@@ -6994,6 +6994,13 @@ const GET_SIGNAL_FN = 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;
     }
@@ -7037,6 +7044,9 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             }
             // Валидируем сигнал перед возвратом
             validatePendingSignal(signalRow, currentPrice);
+            if (signal.id) {
+                self._lastPendingId = signal.id;
+            }
             return signalRow;
         }
         // ОЖИДАНИЕ АКТИВАЦИИ: создаем scheduled signal (risk check при активации)
@@ -7063,6 +7073,9 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         };
         // Валидируем сигнал перед возвратом
         validateScheduledSignal(scheduledSignalRow, currentPrice);
+        if (signal.id) {
+            self._lastPendingId = signal.id;
+        }
         return scheduledSignalRow;
     }
     const signalRow = {
@@ -7090,6 +7103,9 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     }
     // Валидируем сигнал перед возвратом
     validatePendingSignal(signalRow, currentPrice);
+    if (signal.id) {
+        self._lastPendingId = signal.id;
+    }
     return signalRow;
 }, {
     defaultValue: null,
@@ -7119,6 +7135,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) {
@@ -9259,6 +9282,7 @@ class ClientStrategy {
         this._isStopped = false;
         this._pendingSignal = null;
         this._lastSignalTimestamp = null;
+        this._lastPendingId = null;
         this._scheduledSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
@@ -12048,7 +12072,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.
  *
@@ -12104,7 +12128,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)) {
@@ -12134,7 +12158,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)) {
@@ -12158,7 +12182,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,
         });
@@ -12175,7 +12199,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,
         });
@@ -14968,7 +14992,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.
  */
@@ -14983,7 +15007,7 @@ const CALL_INIT_FN = trycatch(async (self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15003,7 +15027,7 @@ const CALL_SIGNAL_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: 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_LIVE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: 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_BACKTEST_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15071,7 +15095,7 @@ const CALL_BREAKEVEN_AVAILABLE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15099,7 +15123,7 @@ const CALL_PARTIAL_PROFIT_AVAILABLE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15127,7 +15151,7 @@ const CALL_PARTIAL_LOSS_AVAILABLE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15155,7 +15179,7 @@ const CALL_PING_SCHEDULED_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15183,7 +15207,7 @@ const CALL_PING_IDLE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15211,7 +15235,7 @@ const CALL_PING_ACTIVE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: 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_RISK_REJECTION_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: 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_DISPOSE_FN = trycatch(async (self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -23115,7 +23139,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. */
@@ -23196,7 +23220,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,
         });
@@ -23276,7 +23300,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,
         });
@@ -23341,7 +23365,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;
     }
     /**
@@ -23355,7 +23379,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,
         });
@@ -23369,7 +23393,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);
     }
     /**
@@ -23377,7 +23401,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);
     }
     /**
@@ -23386,7 +23410,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();
     }
     /**
@@ -23394,7 +23418,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);
     }
 }
@@ -23455,7 +23479,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,
         });
@@ -23469,7 +23493,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,
         });
@@ -23488,7 +23512,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,
         });
@@ -23585,7 +23609,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,
             });
@@ -23602,7 +23626,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;
     }
     /**
@@ -23611,7 +23635,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();
     }
     /**
@@ -23619,7 +23643,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);
     }
     /**
@@ -23627,7 +23651,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);
     }
 }
@@ -53928,7 +53952,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().
@@ -53985,7 +54009,7 @@ class ReportUtils {
          * @returns Cleanup function that unsubscribes from all enabled services
          */
         this.enable = 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,
@@ -54080,7 +54104,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,
@@ -54160,7 +54184,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);
     }
     /**
@@ -54169,7 +54193,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();
     }
     /**
@@ -54177,7 +54201,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();
     }
     /**
@@ -54185,7 +54209,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();
     }
 }
@@ -54203,7 +54227,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()`.
@@ -54260,7 +54284,7 @@ class MarkdownUtils {
          * @returns Cleanup function that unsubscribes from all enabled services
          */
         this.enable = 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,
@@ -54357,7 +54381,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,
@@ -54443,7 +54467,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,
@@ -54518,7 +54542,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);
     }
     /**
@@ -54527,7 +54551,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();
     }
     /**
@@ -54536,7 +54560,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();
     }
     /**
@@ -54544,7 +54568,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();
     }
 }
@@ -63233,6 +63257,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 = singleshot(() => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_ENABLE);
+            const handleTick = 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 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";
@@ -64315,7 +64803,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 {
@@ -64388,9 +64876,9 @@ 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;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };