backtest-kit 9.8.0 → 9.8.2

package/build/index.mjs

@@ -554,6 +554,22 @@ const GLOBAL_CONFIG = {
      * Default: true (mutex locking enabled for candle fetching)
      */
     CC_ENABLE_CANDLE_FETCH_MUTEX: true,
+    /**
+     * Enables cooperative interleaving of concurrently running backtests after each candle fetch.
+     *
+     * Mechanism (implemented in `Candle.spinLock`):
+     * - After `getNextCandles` resolves, the current backtest awaits
+     *   `Promise.race([_spin.toPromise(), sleep(50)])`, where `_spin` is emitted whenever
+     *   another caller acquires the candle-fetch mutex.
+     * - This hands the event loop to a peer backtest waiting on the same mutex, so multiple
+     *   parallel `Backtest.run` / `Walker` workloads progress in round-robin fashion instead
+     *   of one monopolizing the event loop until completion.
+     * - The spin is skipped entirely when `Lookup.isParallel` is `false` (single active workload —
+     *   no peer to yield to) or when `CC_ENABLE_CANDLE_FETCH_MUTEX` is disabled.
+     *
+     * Default: true (parallel backtests are interleaved on each candle fetch boundary)
+     */
+    CC_ENABLE_BACKTEST_PARALLEL_SPIN: true,
     /**
      * Enables DCA (Dollar-Cost Averaging) logic even if antirecord is not broken.
      * Allows to commitAverageBuy if currentPrice is not the lowest price since entry, but still lower than priceOpen.
@@ -914,7 +930,7 @@ async function writeFileAtomic(file, data, options = {}) {
 
 var _a$3;
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$7 = new LoggerService();
+const LOGGER_SERVICE$8 = 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
@@ -1037,7 +1053,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$7.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+    LOGGER_SERVICE$8.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
         entityName: self.entityName,
         directory: self._directory,
     });
@@ -1095,7 +1111,7 @@ class PersistBase {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a$3] = singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
             entityName: this.entityName,
             baseDir,
         });
@@ -1111,14 +1127,14 @@ class PersistBase {
         return join(this.baseDir, this.entityName, `${entityId}.json`);
     }
     async waitForInit(initial) {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             entityName: this.entityName,
             initial,
         });
         await this[BASE_WAIT_FOR_INIT_SYMBOL]();
     }
     async readValue(entityId) {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1135,7 +1151,7 @@ class PersistBase {
         }
     }
     async hasValue(entityId) {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1152,7 +1168,7 @@ class PersistBase {
         }
     }
     async writeValue(entityId, entity) {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1174,7 +1190,7 @@ class PersistBase {
      * @throws Error if reading fails
      */
     async *keys() {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
             entityName: this.entityName,
         });
         try {
@@ -1319,7 +1335,7 @@ class PersistSignalUtils {
          * @returns Promise resolving to signal or null if none persisted
          */
         this.readSignalData = async (symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1337,7 +1353,7 @@ class PersistSignalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1352,7 +1368,7 @@ class PersistSignalUtils {
      * @param Ctor - Custom IPersistSignalInstance constructor
      */
     usePersistSignalAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
         this.PersistSignalInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -1361,21 +1377,21 @@ class PersistSignalUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistSignalInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistSignalAdapter(PersistSignalInstance);
     }
     /**
      * Switches to PersistSignalDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistSignalAdapter(PersistSignalDummyInstance);
     }
 }
@@ -1515,7 +1531,7 @@ class PersistRiskUtils {
          * @returns Promise resolving to position entries (empty array if none)
          */
         this.readPositionData = async (riskName, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
@@ -1533,7 +1549,7 @@ class PersistRiskUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePositionData = async (riskRow, riskName, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
@@ -1548,7 +1564,7 @@ class PersistRiskUtils {
      * @param Ctor - Custom IPersistRiskInstance constructor
      */
     usePersistRiskAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
         this.PersistRiskInstanceCtor = Ctor;
         this.getRiskStorage.clear();
     }
@@ -1557,21 +1573,21 @@ class PersistRiskUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
         this.getRiskStorage.clear();
     }
     /**
      * Switches to the default file-based PersistRiskInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistRiskAdapter(PersistRiskInstance);
     }
     /**
      * Switches to PersistRiskDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistRiskAdapter(PersistRiskDummyInstance);
     }
 }
@@ -1710,7 +1726,7 @@ class PersistScheduleUtils {
          * @returns Promise resolving to scheduled signal or null if none persisted
          */
         this.readScheduleData = async (symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1728,7 +1744,7 @@ class PersistScheduleUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1743,7 +1759,7 @@ class PersistScheduleUtils {
      * @param Ctor - Custom IPersistScheduleInstance constructor
      */
     usePersistScheduleAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
         this.PersistScheduleInstanceCtor = Ctor;
         this.getScheduleStorage.clear();
     }
@@ -1752,21 +1768,21 @@ class PersistScheduleUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
         this.getScheduleStorage.clear();
     }
     /**
      * Switches to the default file-based PersistScheduleInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistScheduleAdapter(PersistScheduleInstance);
     }
     /**
      * Switches to PersistScheduleDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistScheduleAdapter(PersistScheduleDummyInstance);
     }
 }
@@ -1911,7 +1927,7 @@ class PersistPartialUtils {
          * @returns Promise resolving to partial data record (empty object if none)
          */
         this.readPartialData = async (symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1931,7 +1947,7 @@ class PersistPartialUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1946,7 +1962,7 @@ class PersistPartialUtils {
      * @param Ctor - Custom IPersistPartialInstance constructor
      */
     usePersistPartialAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
         this.PersistPartialInstanceCtor = Ctor;
         this.getPartialStorage.clear();
     }
@@ -1955,21 +1971,21 @@ class PersistPartialUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
         this.getPartialStorage.clear();
     }
     /**
      * Switches to the default file-based PersistPartialInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistPartialAdapter(PersistPartialInstance);
     }
     /**
      * Switches to PersistPartialDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistPartialAdapter(PersistPartialDummyInstance);
     }
 }
@@ -2134,7 +2150,7 @@ class PersistBreakevenUtils {
          * @returns Promise resolving to breakeven data record (empty object if none)
          */
         this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -2154,7 +2170,7 @@ class PersistBreakevenUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -2169,7 +2185,7 @@ class PersistBreakevenUtils {
      * @param Ctor - Custom IPersistBreakevenInstance constructor
      */
     usePersistBreakevenAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
         this.PersistBreakevenInstanceCtor = Ctor;
         this.getBreakevenStorage.clear();
     }
@@ -2178,21 +2194,21 @@ class PersistBreakevenUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
         this.getBreakevenStorage.clear();
     }
     /**
      * Switches to the default file-based PersistBreakevenInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistBreakevenAdapter(PersistBreakevenInstance);
     }
     /**
      * Switches to PersistBreakevenDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistBreakevenAdapter(PersistBreakevenDummyInstance);
     }
 }
@@ -2283,7 +2299,7 @@ class PersistCandleInstance {
                     error: errorData(error),
                     message: getErrorMessage(error),
                 };
-                LOGGER_SERVICE$7.warn(message, payload);
+                LOGGER_SERVICE$8.warn(message, payload);
                 console.warn(message, payload);
                 errorEmitter.next(error);
                 return null;
@@ -2305,7 +2321,7 @@ class PersistCandleInstance {
         for (const candle of candles) {
             const candleCloseTime = candle.timestamp + stepMs;
             if (candleCloseTime > now) {
-                LOGGER_SERVICE$7.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
+                LOGGER_SERVICE$8.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
                     symbol: this.symbol,
                     interval: this.interval,
                     exchangeName: this.exchangeName,
@@ -2382,7 +2398,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$7.info("PersistCandleUtils.readCandlesData", {
+            LOGGER_SERVICE$8.info("PersistCandleUtils.readCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
@@ -2406,7 +2422,7 @@ class PersistCandleUtils {
          * @returns Promise that resolves when all writes are complete
          */
         this.writeCandlesData = async (candles, symbol, interval, exchangeName) => {
-            LOGGER_SERVICE$7.info("PersistCandleUtils.writeCandlesData", {
+            LOGGER_SERVICE$8.info("PersistCandleUtils.writeCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
@@ -2426,7 +2442,7 @@ class PersistCandleUtils {
      * @param Ctor - Custom IPersistCandleInstance constructor
      */
     usePersistCandleAdapter(Ctor) {
-        LOGGER_SERVICE$7.info("PersistCandleUtils.usePersistCandleAdapter");
+        LOGGER_SERVICE$8.info("PersistCandleUtils.usePersistCandleAdapter");
         this.PersistCandleInstanceCtor = Ctor;
         this.getCandlesStorage.clear();
     }
@@ -2435,21 +2451,21 @@ class PersistCandleUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
         this.getCandlesStorage.clear();
     }
     /**
      * Switches to the default file-based PersistCandleInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log("PersistCandleUtils.useJson");
+        LOGGER_SERVICE$8.log("PersistCandleUtils.useJson");
         this.usePersistCandleAdapter(PersistCandleInstance);
     }
     /**
      * Switches to PersistCandleDummyInstance (always returns null on read, discards writes).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log("PersistCandleUtils.useDummy");
+        LOGGER_SERVICE$8.log("PersistCandleUtils.useDummy");
         this.usePersistCandleAdapter(PersistCandleDummyInstance);
     }
 }
@@ -2587,7 +2603,7 @@ class PersistStorageUtils {
          * @returns Promise resolving to array of signal entries
          */
         this.readStorageData = async (backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(backtest);
@@ -2603,7 +2619,7 @@ class PersistStorageUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeStorageData = async (signalData, backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(backtest);
@@ -2618,7 +2634,7 @@ class PersistStorageUtils {
      * @param Ctor - Custom IPersistStorageInstance constructor
      */
     usePersistStorageAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
         this.PersistStorageInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -2627,21 +2643,21 @@ class PersistStorageUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistStorageInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistStorageAdapter(PersistStorageInstance);
     }
     /**
      * Switches to PersistStorageDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistStorageAdapter(PersistStorageDummyInstance);
     }
 }
@@ -2768,7 +2784,7 @@ class PersistNotificationUtils {
          * @returns Promise resolving to array of notification entries
          */
         this.readNotificationData = async (backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
             const instance = this.getNotificationStorage(backtest);
@@ -2784,7 +2800,7 @@ class PersistNotificationUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeNotificationData = async (notificationData, backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
             const instance = this.getNotificationStorage(backtest);
@@ -2799,7 +2815,7 @@ class PersistNotificationUtils {
      * @param Ctor - Custom IPersistNotificationInstance constructor
      */
     usePersistNotificationAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
         this.PersistNotificationInstanceCtor = Ctor;
         this.getNotificationStorage.clear();
     }
@@ -2809,21 +2825,21 @@ class PersistNotificationUtils {
      * instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
         this.getNotificationStorage.clear();
     }
     /**
      * Switches to the default file-based PersistNotificationInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistNotificationAdapter(PersistNotificationInstance);
     }
     /**
      * Switches to PersistNotificationDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistNotificationAdapter(PersistNotificationDummyInstance);
     }
 }
@@ -2947,7 +2963,7 @@ class PersistLogUtils {
          * @returns Promise resolving to array of log entries
          */
         this.readLogData = async () => {
-            LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
             const isInitial = !this._logInstance;
             const instance = this.getLogInstance();
             await instance.waitForInit(isInitial);
@@ -2961,7 +2977,7 @@ class PersistLogUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeLogData = async (logData) => {
-            LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
             const isInitial = !this._logInstance;
             const instance = this.getLogInstance();
             await instance.waitForInit(isInitial);
@@ -2986,7 +3002,7 @@ class PersistLogUtils {
      * @param Ctor - Custom IPersistLogInstance constructor
      */
     usePersistLogAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
         this.PersistLogInstanceCtor = Ctor;
         this._logInstance = null;
     }
@@ -2995,21 +3011,21 @@ class PersistLogUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
         this._logInstance = null;
     }
     /**
      * Switches to the default file-based PersistLogInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistLogAdapter(PersistLogInstance);
     }
     /**
      * Switches to PersistLogDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistLogAdapter(PersistLogDummyInstance);
     }
 }
@@ -3171,7 +3187,7 @@ class PersistMeasureUtils {
          * @returns Promise resolving to cached value, or null if not found / soft-deleted
          */
         this.readMeasureData = async (bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3187,7 +3203,7 @@ class PersistMeasureUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMeasureData = async (data, bucket, key, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3202,7 +3218,7 @@ class PersistMeasureUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeMeasureData = async (bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3216,7 +3232,7 @@ class PersistMeasureUtils {
      * @param Ctor - Custom IPersistMeasureInstance constructor
      */
     usePersistMeasureAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
         this.PersistMeasureInstanceCtor = Ctor;
         this.getMeasureStorage.clear();
     }
@@ -3228,7 +3244,7 @@ class PersistMeasureUtils {
      * @returns AsyncGenerator yielding entry keys
      */
     async *listMeasureData(bucket) {
-        LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
+        LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getMeasureStorage.has(bucket);
         const instance = this.getMeasureStorage(bucket);
         await instance.waitForInit(isInitial);
@@ -3239,21 +3255,21 @@ class PersistMeasureUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
         this.getMeasureStorage.clear();
     }
     /**
      * Switches to the default file-based PersistMeasureInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistMeasureAdapter(PersistMeasureInstance);
     }
     /**
      * Switches to PersistMeasureDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistMeasureAdapter(PersistMeasureDummyInstance);
     }
 }
@@ -3412,7 +3428,7 @@ class PersistIntervalUtils {
          * @returns Promise resolving to marker data, or null if not found / soft-deleted
          */
         this.readIntervalData = async (bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3428,7 +3444,7 @@ class PersistIntervalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeIntervalData = async (data, bucket, key, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3443,7 +3459,7 @@ class PersistIntervalUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeIntervalData = async (bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3457,7 +3473,7 @@ class PersistIntervalUtils {
      * @param Ctor - Custom IPersistIntervalInstance constructor
      */
     usePersistIntervalAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
         this.PersistIntervalInstanceCtor = Ctor;
         this.getIntervalStorage.clear();
     }
@@ -3469,7 +3485,7 @@ class PersistIntervalUtils {
      * @returns AsyncGenerator yielding marker keys
      */
     async *listIntervalData(bucket) {
-        LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
+        LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getIntervalStorage.has(bucket);
         const instance = this.getIntervalStorage(bucket);
         await instance.waitForInit(isInitial);
@@ -3480,21 +3496,21 @@ class PersistIntervalUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
         this.getIntervalStorage.clear();
     }
     /**
      * Switches to the default file-based PersistIntervalInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistIntervalAdapter(PersistIntervalInstance);
     }
     /**
      * Switches to PersistIntervalDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistIntervalAdapter(PersistIntervalDummyInstance);
     }
 }
@@ -3700,7 +3716,7 @@ class PersistMemoryUtils {
          * @returns Promise resolving to entry data, or null if not found / soft-deleted
          */
         this.readMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$8.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);
@@ -3717,7 +3733,7 @@ class PersistMemoryUtils {
          * @returns Promise resolving to true if entry exists
          */
         this.hasMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$8.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);
@@ -3736,7 +3752,7 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMemoryData = async (data, signalId, bucketName, memoryId, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$8.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);
@@ -3753,7 +3769,7 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_REMOVE_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$8.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);
@@ -3765,7 +3781,7 @@ class PersistMemoryUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
             this.getMemoryStorage.clear();
         };
         /**
@@ -3776,7 +3792,7 @@ class PersistMemoryUtils {
          * @param bucketName - Bucket name
          */
         this.dispose = (signalId, bucketName) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
             const key = `${signalId}:${bucketName}`;
             this.getMemoryStorage.clear(key);
         };
@@ -3788,7 +3804,7 @@ class PersistMemoryUtils {
      * @param Ctor - Custom IPersistMemoryInstance constructor
      */
     usePersistMemoryAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
         this.PersistMemoryInstanceCtor = Ctor;
         this.getMemoryStorage.clear();
     }
@@ -3802,7 +3818,7 @@ class PersistMemoryUtils {
      * @returns AsyncGenerator yielding `{ memoryId, data }` tuples
      */
     async *listMemoryData(signalId, bucketName) {
-        LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA, { signalId, bucketName });
+        LOGGER_SERVICE$8.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);
@@ -3813,14 +3829,14 @@ class PersistMemoryUtils {
      * Switches to the default file-based PersistMemoryInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistMemoryAdapter(PersistMemoryInstance);
     }
     /**
      * Switches to PersistMemoryDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistMemoryAdapter(PersistMemoryDummyInstance);
     }
 }
@@ -3969,7 +3985,7 @@ class PersistRecentUtils {
          * @returns Promise resolving to recent signal or null if none persisted
          */
         this.readRecentData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -3990,7 +4006,7 @@ class PersistRecentUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -4023,7 +4039,7 @@ class PersistRecentUtils {
      * @param Ctor - Custom IPersistRecentInstance constructor
      */
     usePersistRecentAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
         this.PersistRecentInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -4032,21 +4048,21 @@ class PersistRecentUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistRecentInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistRecentAdapter(PersistRecentInstance);
     }
     /**
      * Switches to PersistRecentDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistRecentAdapter(PersistRecentDummyInstance);
     }
 }
@@ -4181,7 +4197,7 @@ class PersistStateUtils {
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (signalId, bucketName, initial) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WAIT_FOR_INIT, { signalId, bucketName, initial });
+            LOGGER_SERVICE$8.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);
@@ -4196,7 +4212,7 @@ class PersistStateUtils {
          * @returns Promise resolving to state data or null if none persisted
          */
         this.readStateData = async (signalId, bucketName) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName });
+            LOGGER_SERVICE$8.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);
@@ -4214,7 +4230,7 @@ class PersistStateUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeStateData = async (data, signalId, bucketName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
+            LOGGER_SERVICE$8.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);
@@ -4225,14 +4241,14 @@ class PersistStateUtils {
          * Switches to PersistStateDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
-            LOGGER_SERVICE$7.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
+            LOGGER_SERVICE$8.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
             this.usePersistStateAdapter(PersistStateDummyInstance);
         };
         /**
          * Switches to the default file-based PersistStateInstance.
          */
         this.useJson = () => {
-            LOGGER_SERVICE$7.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
+            LOGGER_SERVICE$8.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
             this.usePersistStateAdapter(PersistStateInstance);
         };
         /**
@@ -4240,7 +4256,7 @@ class PersistStateUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
             this.getStateStorage.clear();
         };
         /**
@@ -4251,7 +4267,7 @@ class PersistStateUtils {
          * @param bucketName - Bucket name
          */
         this.dispose = (signalId, bucketName) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_DISPOSE);
             const key = `${signalId}:${bucketName}`;
             this.getStateStorage.clear(key);
         };
@@ -4263,7 +4279,7 @@ class PersistStateUtils {
      * @param Ctor - Custom IPersistStateInstance constructor
      */
     usePersistStateAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
         this.PersistStateInstanceCtor = Ctor;
         this.getStateStorage.clear();
     }
@@ -4403,7 +4419,7 @@ class PersistSessionUtils {
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (strategyName, exchangeName, frameName, initial) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WAIT_FOR_INIT, { strategyName, exchangeName, frameName, initial });
+            LOGGER_SERVICE$8.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);
@@ -4419,7 +4435,7 @@ class PersistSessionUtils {
          * @returns Promise resolving to session data or null if none persisted
          */
         this.readSessionData = async (strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_READ_DATA, { strategyName, exchangeName, frameName });
+            LOGGER_SERVICE$8.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);
@@ -4438,7 +4454,7 @@ class PersistSessionUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSessionData = async (data, strategyName, exchangeName, frameName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
+            LOGGER_SERVICE$8.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);
@@ -4449,14 +4465,14 @@ class PersistSessionUtils {
          * Switches to PersistSessionDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
-            LOGGER_SERVICE$7.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
+            LOGGER_SERVICE$8.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
             this.usePersistSessionAdapter(PersistSessionDummyInstance);
         };
         /**
          * Switches to the default file-based PersistSessionInstance.
          */
         this.useJson = () => {
-            LOGGER_SERVICE$7.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
+            LOGGER_SERVICE$8.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
             this.usePersistSessionAdapter(PersistSessionInstance);
         };
         /**
@@ -4464,7 +4480,7 @@ class PersistSessionUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
             this.getSessionStorage.clear();
         };
         /**
@@ -4476,7 +4492,7 @@ class PersistSessionUtils {
          * @param frameName - Frame identifier
          */
         this.dispose = (strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_DISPOSE);
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             this.getSessionStorage.clear(key);
         };
@@ -4488,7 +4504,7 @@ class PersistSessionUtils {
      * @param Ctor - Custom IPersistSessionInstance constructor
      */
     usePersistSessionAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
         this.PersistSessionInstanceCtor = Ctor;
         this.getSessionStorage.clear();
     }
@@ -4500,28 +4516,39 @@ class PersistSessionUtils {
 const PersistSessionAdapter = new PersistSessionUtils();
 
 var _a$2, _b$2;
-const BUSY_DELAY = 100;
 const SET_BUSY_SYMBOL = Symbol("setBusy");
 const GET_BUSY_SYMBOL = Symbol("getBusy");
 const ACQUIRE_LOCK_SYMBOL = Symbol("acquireLock");
 const RELEASE_LOCK_SYMBOL = Symbol("releaseLock");
+/**
+ * Body of the queued acquire operation.
+ *
+ * Parks the caller on `self._tick` whenever the lock is already busy: each
+ * `releaseLock` emits on `_tick`, waking exactly the next queued acquirer
+ * instead of polling on a fixed delay. The busy counter is bumped only after
+ * the loop exits, so re-entry checks remain coherent under contention.
+ *
+ * @param self - The owning {@link Lock} instance.
+ */
 const ACQUIRE_LOCK_FN = async (self) => {
     while (self[GET_BUSY_SYMBOL]()) {
-        await sleep(BUSY_DELAY);
+        // @ts-ignore
+        await self._tick.toPromise();
     }
     self[SET_BUSY_SYMBOL](true);
 };
 /**
  * Mutual exclusion primitive for async TypeScript code.
  *
- * Provides a reentrant-safe, queued lock that serializes access to a critical
- * section across concurrent async callers. Internally tracks a busy counter so
- * nested acquire/release pairs are detected and mis-matched releases throw
- * immediately.
+ * Provides a queued lock that serializes access to a critical section across
+ * concurrent async callers. Wake-ups are event-driven (via an internal
+ * `_tick` subject emitted on every `releaseLock`) rather than polling,
+ * so contention does not incur a fixed delay.
  *
- * Three usage styles are supported:
+ * The busy counter detects mis-matched releases and throws immediately on
+ * extra `releaseLock` calls.
  *
- * **Manual acquire / release**
+ * **Usage**
  * ```ts
  * await lock.acquireLock();
  * try {
@@ -4536,7 +4563,18 @@ const ACQUIRE_LOCK_FN = async (self) => {
  */
 class Lock {
     constructor() {
+        /**
+         * Outstanding acquires that have not yet been released.
+         * Incremented in `[SET_BUSY_SYMBOL](true)`, decremented in `[SET_BUSY_SYMBOL](false)`.
+         * A negative value indicates an extra `releaseLock` and throws on detection.
+         */
         this._isBusy = 0;
+        /**
+         * Wake-up channel for {@link ACQUIRE_LOCK_FN}.
+         * Every {@link releaseLock} emits a single tick that unblocks the next
+         * queued acquirer parked on `toPromise()`.
+         */
+        this._tick = new Subject();
         this[_a$2] = queued(ACQUIRE_LOCK_FN);
         this[_b$2] = () => this[SET_BUSY_SYMBOL](false);
         /**
@@ -4557,16 +4595,19 @@ class Lock {
             await this[ACQUIRE_LOCK_SYMBOL](this);
         };
         /**
-         * Releases the lock previously acquired with {@link acquireLock}.
+         * Releases the lock previously acquired with {@link acquireLock} and emits
+         * on the internal `_tick` subject to wake the next queued acquirer.
+         *
          * Must be called exactly once per successful {@link acquireLock} call,
-         * typically inside a `finally` block. Throws if called more times
-         * than the lock was acquired.
+         * typically inside a `finally` block. Throws if called more times than
+         * the lock was acquired.
          *
          * @returns {Promise<void>} Resolves once the lock has been released.
          * @throws {Error} If the lock is released more times than it was acquired.
          */
         this.releaseLock = async () => {
             await this[RELEASE_LOCK_SYMBOL]();
+            await this._tick.next();
         };
     }
     [SET_BUSY_SYMBOL](isBusy) {
@@ -4581,18 +4622,166 @@ class Lock {
 }
 _a$2 = ACQUIRE_LOCK_SYMBOL, _b$2 = RELEASE_LOCK_SYMBOL;
 
+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();
+/**
+ * Builds the composite {@link Key} used to register an activity in `_lookupMap`.
+ *
+ * Mirrors the {@link Key} type construction: appends `frameName` only when provided
+ * (typical for backtest), then a `"backtest"` / `"live"` discriminator suffix.
+ *
+ * @param symbol - Trading pair symbol.
+ * @param strategyName - Strategy schema name.
+ * @param exchangeName - Exchange schema name.
+ * @param frameName - Frame schema name; omitted from the key when falsy.
+ * @param backtest - `true` for backtest, `false` for live.
+ * @returns Colon-joined composite key.
+ */
+const CREATE_KEY_FN$y = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * In-memory registry of currently running backtest and live activities.
+ *
+ * Purpose:
+ * - Each `Backtest.run` / `Live.run` / per-strategy walker iteration registers an
+ *   {@link IActivityEntry} on start and removes it on completion.
+ * - `Candle.spinLock` consults {@link isParallel} to decide whether the event-loop
+ *   hand-off (post-candle-fetch spin) is worth performing. With a single active
+ *   workload there is no peer to yield to, so the spin is skipped entirely.
+ *
+ * Exposed as the `Lookup` singleton; no constructor parameters.
+ *
+ * @example
+ * ```typescript
+ * Lookup.addActivity({ symbol: "BTCUSDT", context, backtest: true });
+ * try {
+ *   for await (const _ of run(symbol, context)) { ... }
+ * } finally {
+ *   Lookup.removeActivity({ symbol: "BTCUSDT", context, backtest: true });
+ * }
+ * ```
+ */
+class LookupUtils {
+    constructor() {
+        /** Active entries keyed by their composite {@link Key}. */
+        this._lookupMap = new Map();
+        /**
+         * Registers a backtest or live activity in the lookup map.
+         * Idempotent for identical keys — duplicate calls overwrite the existing entry.
+         *
+         * @param activity - Activity descriptor identifying the running workload.
+         */
+        this.addActivity = (activity) => {
+            LOGGER_SERVICE$7.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);
+            this._lookupMap.set(key, activity);
+        };
+        /**
+         * Removes a previously registered activity from the lookup map.
+         * Must be paired with a prior {@link addActivity}, typically in a `finally` block,
+         * so a thrown error in the underlying run does not leave a stale entry behind.
+         *
+         * @param activity - Activity descriptor matching the one passed to {@link addActivity}.
+         */
+        this.removeActivity = (activity) => {
+            LOGGER_SERVICE$7.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);
+            this._lookupMap.delete(key);
+        };
+        /**
+         * Returns a snapshot of currently active entries.
+         *
+         * @returns Array of all activities present in the lookup map at call time.
+         */
+        this.listActivity = () => {
+            LOGGER_SERVICE$7.info(METHOD_NAME_LIST_ACTIVITY);
+            return Array.from(this._lookupMap.values());
+        };
+    }
+    /**
+     * `true` when more than one activity is currently registered.
+     * Used by `Candle.spinLock` to decide whether yielding the event loop is useful.
+     */
+    get isParallel() {
+        return this._lookupMap.size > 1;
+    }
+}
+/**
+ * Process-wide singleton instance of {@link LookupUtils}.
+ * Imported by `Backtest`, `Live`, `WalkerLogicPrivateService` (registration sites)
+ * and by `Candle` (read-only consumer via `isParallel`).
+ */
+const Lookup = new LookupUtils();
+
 const METHOD_NAME_ACQUIRE_LOCK = "CandleUtils.acquireLock";
 const METHOD_NAME_RELEASE_LOCK = "CandleUtils.releaseLock";
+const METHOD_NAME_SPIN_LOCK = "CandleUtils.spinLock";
+/**
+ * Upper bound (ms) on how long `spinLock` may park before falling through.
+ * If no peer backtest acquires the candle-fetch mutex within this window,
+ * the spinner proceeds without further yielding.
+ */
+const ROTATE_DELAY = 50;
 /** Logger service injected as DI singleton */
 const LOGGER_SERVICE$6 = new LoggerService();
+/**
+ * Process-wide coordinator for candle-fetch serialization and cooperative
+ * yielding between parallel backtests.
+ *
+ * Two complementary primitives are exposed:
+ * - **Mutex** via {@link acquireLock} / {@link releaseLock}: prevents concurrent
+ *   candle fetches from racing on the same exchange.
+ * - **Spin hand-off** via {@link spinLock}: invoked after a fetch completes to
+ *   give peer backtests waiting on the mutex a chance to run, so multiple
+ *   `Backtest.run` workloads interleave instead of one monopolizing the loop.
+ *
+ * All three operations are no-ops when `CC_ENABLE_CANDLE_FETCH_MUTEX` is `false`.
+ * The spin additionally requires `CC_ENABLE_BACKTEST_PARALLEL_SPIN` and at least
+ * two registered activities in `Lookup` (see `Lookup.isParallel`).
+ *
+ * @example
+ * ```typescript
+ * await Candle.acquireLock("ClientExchange GET_CANDLES_FN");
+ * try {
+ *   const candles = await fetchFromExchange(...);
+ *   return candles;
+ * } finally {
+ *   await Candle.releaseLock("ClientExchange GET_CANDLES_FN");
+ * }
+ * // Elsewhere, after a fetch completes inside a backtest loop:
+ * await Candle.spinLock("BacktestLogicPrivateService GET_CANDLES_FN");
+ * ```
+ */
 class CandleUtils {
     constructor() {
+        /** Underlying mutex serializing candle fetches across concurrent callers. */
         this._lock = new Lock();
         /**
-         * Acquires the candle fetch mutex if CC_ENABLE_CANDLE_FETCH_MUTEX is enabled.
+         * Emits whenever {@link acquireLock} successfully takes the mutex.
+         * Awaited by {@link spinLock} to detect that a peer backtest has just
+         * started its own fetch — the signal that yielding now will be productive.
+         */
+        this._spin = new Subject();
+        /**
+         * Acquires the candle fetch mutex if `CC_ENABLE_CANDLE_FETCH_MUTEX` is enabled.
          * Prevents concurrent candle fetches from the same exchange.
          *
-         * @param source - Caller identifier for logging
+         * On successful acquisition, emits on the internal spin subject so any
+         * peer parked inside {@link spinLock} can wake up and proceed.
+         *
+         * @param source - Caller identifier for logging.
          */
         this.acquireLock = async (source) => {
             LOGGER_SERVICE$6.info(METHOD_NAME_ACQUIRE_LOCK, {
@@ -4601,13 +4790,14 @@ class CandleUtils {
             if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
                 return;
             }
-            return await this._lock.acquireLock();
+            await this._lock.acquireLock();
+            await this._spin.next();
         };
         /**
-         * Releases the candle fetch mutex if CC_ENABLE_CANDLE_FETCH_MUTEX is enabled.
-         * Must be called after acquireLock, typically in a finally block.
+         * Releases the candle fetch mutex if `CC_ENABLE_CANDLE_FETCH_MUTEX` is enabled.
+         * Must be called after {@link acquireLock}, typically in a `finally` block.
          *
-         * @param source - Caller identifier for logging
+         * @param source - Caller identifier for logging.
          */
         this.releaseLock = async (source) => {
             LOGGER_SERVICE$6.info(METHOD_NAME_RELEASE_LOCK, {
@@ -4618,8 +4808,47 @@ class CandleUtils {
             }
             return await this._lock.releaseLock();
         };
+        /**
+         * Cooperative event-loop hand-off invoked by `BacktestLogicPrivateService`
+         * after a successful `getNextCandles`. Allows peer backtests waiting on the
+         * candle-fetch mutex to run before the current backtest fetches the next chunk.
+         *
+         * Waits for one of:
+         * - a peer calling {@link acquireLock} (signalled via the spin subject), or
+         * - a `ROTATE_DELAY` ms timeout, so the caller never parks indefinitely.
+         *
+         * Returns immediately as a no-op when any of these is true:
+         * - `CC_ENABLE_CANDLE_FETCH_MUTEX` is disabled (mutex is off entirely),
+         * - `CC_ENABLE_BACKTEST_PARALLEL_SPIN` is disabled (cooperative yielding off),
+         * - `Lookup.isParallel` is `false` (only one active workload — no peer to yield to).
+         *
+         * @param source - Caller identifier for logging.
+         */
+        this.spinLock = async (source) => {
+            LOGGER_SERVICE$6.info(METHOD_NAME_SPIN_LOCK, {
+                source,
+            });
+            if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
+                return;
+            }
+            if (!GLOBAL_CONFIG.CC_ENABLE_BACKTEST_PARALLEL_SPIN) {
+                return;
+            }
+            if (!Lookup.isParallel) {
+                return;
+            }
+            await Promise.race([
+                this._spin.toPromise(),
+                sleep(ROTATE_DELAY),
+            ]);
+        };
     }
 }
+/**
+ * Process-wide singleton instance of {@link CandleUtils}.
+ * Imported by `ClientExchange` (mutex around exchange fetches) and by
+ * `BacktestLogicPrivateService` (spin hand-off between parallel backtests).
+ */
 const Candle = new CandleUtils();
 
 const MS_PER_MINUTE$7 = 60000;
@@ -19153,9 +19382,28 @@ const TICK_FN = async (self, symbol, when) => {
         return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "TICK_FN", message: getErrorMessage(error) };
     }
 };
+/**
+ * Wraps `exchangeCoreService.getNextCandles` with error capture and a cooperative
+ * event-loop hand-off after a successful fetch.
+ *
+ * Calls `Candle.spinLock(...)` on success: when multiple backtests run in parallel
+ * (`Lookup.isParallel === true`), this yields the event loop so a peer waiting on
+ * the candle-fetch mutex can take its turn, producing round-robin interleaving
+ * instead of one backtest monopolizing the loop until completion. The spin is a
+ * no-op for single-workload runs.
+ *
+ * @param self - Owning service instance, used for logging and exchange access.
+ * @param symbol - Trading pair symbol.
+ * @param candlesNeeded - Number of 1m candles to request.
+ * @param bufferStartTime - Inclusive start time for the fetch window.
+ * @param logMeta - Extra structured fields appended to the warn log on failure.
+ * @returns Fetched candles, or a {@link TFnError} discriminated union on failure.
+ */
 const GET_CANDLES_FN = async (self, symbol, candlesNeeded, bufferStartTime, logMeta) => {
     try {
-        return await self.exchangeCoreService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
+        const result = await self.exchangeCoreService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
+        await Candle.spinLock("BacktestLogicPrivateService GET_CANDLES_FN");
+        return result;
     }
     catch (error) {
         console.error(`backtestLogicPrivateService getNextCandles failed symbol=${symbol} strategyName=${self.methodContextService.context.strategyName} exchangeName=${self.methodContextService.context.exchangeName}`);
@@ -20041,6 +20289,15 @@ class WalkerLogicPrivateService {
                     exchangeName: context.exchangeName,
                     frameName: context.frameName,
                 });
+                Lookup.addActivity({
+                    symbol,
+                    context: {
+                        strategyName,
+                        exchangeName: context.exchangeName,
+                        frameName: context.frameName,
+                    },
+                    backtest: true,
+                });
                 try {
                     await resolveDocuments(iterator);
                 }
@@ -20056,6 +20313,17 @@ class WalkerLogicPrivateService {
                     await CALL_STRATEGY_ERROR_CALLBACKS_FN(this, walkerSchema, strategyName, symbol, error);
                     continue;
                 }
+                finally {
+                    Lookup.removeActivity({
+                        symbol,
+                        context: {
+                            strategyName,
+                            exchangeName: context.exchangeName,
+                            frameName: context.frameName,
+                        },
+                        backtest: true,
+                    });
+                }
                 this.loggerService.info("walkerLogicPrivateService backtest complete", {
                     strategyName,
                     symbol,
@@ -36075,6 +36343,7 @@ const Exchange = new ExchangeUtils();
 
 const WARM_CANDLES_METHOD_NAME = "cache.warmCandles";
 const CHECK_CANDLES_METHOD_NAME = "cache.checkCandles";
+const CACHE_CANDLES_METHOD_NAME = "cache.cacheCandles";
 const MS_PER_MINUTE$3 = 60000;
 const INTERVAL_MINUTES$3 = {
     "1m": 1,
@@ -36106,6 +36375,34 @@ const PRINT_PROGRESS_FN = (fetched, total, symbol, interval) => {
         process.stdout.write("\n");
     }
 };
+/**
+ * Retry-wrapped pipeline: validates the cache via `checkCandles` and, on miss,
+ * fills it via `warmCandles` and rethrows to trigger a retry pass that
+ * re-validates the freshly cached range. Limited to 2 attempts.
+ */
+const CACHE_CANDLES_FN = retry(async (interval, dto, onWarmStart, onCheckStart) => {
+    try {
+        onWarmStart && onWarmStart(dto.symbol, interval, dto.from, dto.to);
+        await checkCandles({
+            exchangeName: dto.exchangeName,
+            from: dto.from,
+            to: dto.to,
+            symbol: dto.symbol,
+            interval: interval,
+        });
+    }
+    catch (error) {
+        onCheckStart && onCheckStart(dto.symbol, interval, dto.from, dto.to);
+        await warmCandles({
+            symbol: dto.symbol,
+            exchangeName: dto.exchangeName,
+            from: dto.from,
+            to: dto.to,
+            interval: interval,
+        });
+        throw error;
+    }
+}, 2);
 /**
  * Checks cached candle presence via the persist adapter.
  * Issues one ranged read; adapter-side `hasValue` covers each expected timestamp,
@@ -36181,6 +36478,34 @@ async function warmCandles(params) {
         PRINT_PROGRESS_FN(fetched, totalCandles, symbol, interval);
     }
 }
+/**
+ * Ensures candles for the given range are present in persist storage.
+ * Runs a check-then-warm pipeline with one retry: validates the cache first
+ * and, on a miss, downloads the missing data and re-validates.
+ *
+ * @param params - Combined cache parameters with optional lifecycle callbacks
+ */
+async function cacheCandles({ symbol, interval, from, to, exchangeName, onCheckStart = (symbol, interval, from, to) => {
+    process.stdout.write("\n");
+    process.stdout.write(`Checking candles cache for ${symbol} ${interval} from ${from} to ${to}\n`);
+}, onWarmStart = (symbol, interval, from, to) => {
+    process.stdout.write("\n\n");
+    process.stdout.write(`Caching candles for ${symbol} ${interval} from ${from} to ${to}\n`);
+}, }) {
+    backtest.loggerService.info(CACHE_CANDLES_METHOD_NAME, {
+        symbol,
+        exchangeName,
+        interval,
+        from,
+        to,
+    });
+    await CACHE_CANDLES_FN(interval, {
+        exchangeName,
+        from,
+        to,
+        symbol,
+    }, onWarmStart, onCheckStart);
+}
 
 const METHOD_NAME = "validate.validate";
 /**
@@ -37392,7 +37717,19 @@ class BrokerProxy {
  */
 class BrokerAdapter {
     constructor() {
-        this._brokerInstance = null;
+        /** Factory producing the active `BrokerProxy` instance */
+        this._brokerFactory = () => null;
+        /**
+         * Lazily constructs the `BrokerProxy` from the registered factory and
+         * memoizes the result via `singleshot`.
+         *
+         * The proxy is built on the first call and cached for all subsequent calls.
+         * Returns `null` when no adapter has been registered via `useBrokerAdapter()`.
+         *
+         * Reset via `clear()` so the next call rebuilds from the current factory
+         * (e.g. when `process.cwd()` changes between strategy iterations).
+         */
+        this.getInstance = singleshot(() => this._brokerFactory());
         /**
          * Forwards a signal-open event to the registered broker adapter.
          *
@@ -37426,7 +37763,10 @@ class BrokerAdapter {
             if (payload.backtest) {
                 return;
             }
-            await this._brokerInstance?.onSignalOpenCommit(payload);
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalOpenCommit(payload);
+            }
         };
         /**
          * Forwards a signal-close event to the registered broker adapter.
@@ -37464,7 +37804,10 @@ class BrokerAdapter {
             if (payload.backtest) {
                 return;
             }
-            await this._brokerInstance?.onSignalCloseCommit(payload);
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalCloseCommit(payload);
+            }
         };
         /**
          * Intercepts a partial-profit close before DI-core mutation.
@@ -37500,7 +37843,10 @@ class BrokerAdapter {
             if (payload.backtest) {
                 return;
             }
-            await this._brokerInstance?.onPartialProfitCommit(payload);
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onPartialProfitCommit(payload);
+            }
         };
         /**
          * Intercepts a partial-loss close before DI-core mutation.
@@ -37536,7 +37882,10 @@ class BrokerAdapter {
             if (payload.backtest) {
                 return;
             }
-            await this._brokerInstance?.onPartialLossCommit(payload);
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onPartialLossCommit(payload);
+            }
         };
         /**
          * Intercepts a trailing stop-loss update before DI-core mutation.
@@ -37572,7 +37921,10 @@ class BrokerAdapter {
             if (payload.backtest) {
                 return;
             }
-            await this._brokerInstance?.onTrailingStopCommit(payload);
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onTrailingStopCommit(payload);
+            }
         };
         /**
          * Intercepts a trailing take-profit update before DI-core mutation.
@@ -37608,7 +37960,10 @@ class BrokerAdapter {
             if (payload.backtest) {
                 return;
             }
-            await this._brokerInstance?.onTrailingTakeCommit(payload);
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onTrailingTakeCommit(payload);
+            }
         };
         /**
          * Intercepts a breakeven operation before DI-core mutation.
@@ -37645,7 +38000,10 @@ class BrokerAdapter {
             if (payload.backtest) {
                 return;
             }
-            await this._brokerInstance?.onBreakevenCommit(payload);
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onBreakevenCommit(payload);
+            }
         };
         /**
          * Intercepts a DCA average-buy entry before DI-core mutation.
@@ -37681,7 +38039,10 @@ class BrokerAdapter {
             if (payload.backtest) {
                 return;
             }
-            await this._brokerInstance?.onAverageBuyCommit(payload);
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onAverageBuyCommit(payload);
+            }
         };
         /**
          * Registers a broker adapter instance or constructor to receive commit* callbacks.
@@ -37705,11 +38066,12 @@ class BrokerAdapter {
         this.useBrokerAdapter = (broker) => {
             backtest.loggerService.info(BROKER_METHOD_NAME_USE_BROKER_ADAPTER, {});
             if (typeof broker === "function") {
-                const instance = Reflect.construct(broker, []);
-                this._brokerInstance = new BrokerProxy(instance);
-                return;
+                this._brokerFactory = () => new BrokerProxy(Reflect.construct(broker, []));
             }
-            this._brokerInstance = new BrokerProxy(broker);
+            else {
+                this._brokerFactory = () => new BrokerProxy(broker);
+            }
+            this.getInstance.clear();
         };
         /**
          * Activates the broker: subscribes to syncSubject for signal-open / signal-close routing.
@@ -37736,7 +38098,8 @@ class BrokerAdapter {
          */
         this.enable = singleshot(() => {
             backtest.loggerService.info(BROKER_METHOD_NAME_ENABLE, {});
-            if (!this._brokerInstance) {
+            const instance = this.getInstance();
+            if (!instance) {
                 this.enable.clear();
                 throw new Error("No broker instance provided. Call Broker.useBrokerAdapter first.");
             }
@@ -37824,7 +38187,7 @@ class BrokerAdapter {
          */
         this.clear = () => {
             backtest.loggerService.info(BROKER_METHOD_NAME_CLEAR, {});
-            this._brokerInstance = null;
+            this.getInstance.clear();
             this.enable.clear();
         };
     }
@@ -41928,11 +42291,21 @@ const INSTANCE_TASK_FN$2 = async (symbol, context, self) => {
         self._isStopped = false;
         self._isDone = false;
     }
+    Lookup.addActivity({
+        symbol,
+        context,
+        backtest: true,
+    });
     for await (const _ of self.run(symbol, context)) {
         if (self._isStopped) {
             break;
         }
     }
+    Lookup.removeActivity({
+        symbol,
+        context,
+        backtest: true,
+    });
     if (!self._isDone) {
         await doneBacktestSubject.next({
             exchangeName: context.exchangeName,
@@ -44579,11 +44952,21 @@ const INSTANCE_TASK_FN$1 = async (symbol, context, self) => {
         self._isStopped = false;
         self._isDone = false;
     }
+    Lookup.addActivity({
+        symbol,
+        context,
+        backtest: false,
+    });
     for await (const signal of self.run(symbol, context)) {
         if (signal?.action === "closed" && self._isStopped) {
             break;
         }
     }
+    Lookup.removeActivity({
+        symbol,
+        context,
+        backtest: false,
+    });
     if (!self._isDone) {
         await doneLiveSubject.next({
             exchangeName: context.exchangeName,
@@ -48844,8 +49227,16 @@ class RecentMemoryLiveUtils {
  */
 class RecentBacktestAdapter {
     constructor() {
-        /** Internal storage utils instance */
-        this._recentBacktestUtils = new RecentMemoryBacktestUtils();
+        /** Factory producing the active storage utils instance */
+        this._recentBacktestFactory = () => new RecentMemoryBacktestUtils();
+        /**
+         * Lazily constructs the storage utils from the registered factory and memoizes
+         * the result via `singleshot`.
+         *
+         * The instance is built on the first call and cached for all subsequent calls.
+         * Reset via `clear()` so the next call rebuilds from the current factory.
+         */
+        this.getInstance = singleshot(() => this._recentBacktestFactory());
         /**
          * Handles active ping event.
          * Proxies call to the underlying storage adapter.
@@ -48855,7 +49246,7 @@ class RecentBacktestAdapter {
             backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_HANDLE_ACTIVE_PING, {
                 signalId: event.data.id,
             });
-            return await this._recentBacktestUtils.handleActivePing(event);
+            return await this.getInstance().handleActivePing(event);
         };
         /**
          * Retrieves the latest signal for the given context.
@@ -48876,7 +49267,7 @@ class RecentBacktestAdapter {
                 frameName,
                 backtest: backtest$1,
             });
-            return await this._recentBacktestUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1, when);
+            return await this.getInstance().getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1, when);
         };
         /**
          * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
@@ -48900,7 +49291,7 @@ class RecentBacktestAdapter {
                 backtest: backtest$1,
                 timestamp,
             });
-            const signal = await this._recentBacktestUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1, new Date(timestamp));
+            const signal = await this.getInstance().getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1, new Date(timestamp));
             if (!signal) {
                 return null;
             }
@@ -48913,7 +49304,8 @@ class RecentBacktestAdapter {
          */
         this.useRecentAdapter = (Ctor) => {
             backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
-            this._recentBacktestUtils = Reflect.construct(Ctor, []);
+            this._recentBacktestFactory = () => Reflect.construct(Ctor, []);
+            this.getInstance.clear();
         };
         /**
          * Switches to persistent storage adapter.
@@ -48921,7 +49313,8 @@ class RecentBacktestAdapter {
          */
         this.usePersist = () => {
             backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._recentBacktestUtils = new RecentPersistBacktestUtils();
+            this._recentBacktestFactory = () => new RecentPersistBacktestUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to in-memory storage adapter (default).
@@ -48929,14 +49322,17 @@ class RecentBacktestAdapter {
          */
         this.useMemory = () => {
             backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._recentBacktestUtils = new RecentMemoryBacktestUtils();
+            this._recentBacktestFactory = () => new RecentMemoryBacktestUtils();
+            this.getInstance.clear();
         };
         /**
-         * Clears the cached utils instance by resetting to the default in-memory adapter.
+         * Clears the memoized utils instance.
+         * Call this when process.cwd() changes between strategy iterations
+         * so a new instance is created with the updated base path.
          */
         this.clear = () => {
             backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_CLEAR);
-            this._recentBacktestUtils = new RecentMemoryBacktestUtils();
+            this.getInstance.clear();
         };
     }
 }
@@ -48951,8 +49347,16 @@ class RecentBacktestAdapter {
  */
 class RecentLiveAdapter {
     constructor() {
-        /** Internal storage utils instance */
-        this._recentLiveUtils = new RecentPersistLiveUtils();
+        /** Factory producing the active storage utils instance */
+        this._recentLiveFactory = () => new RecentPersistLiveUtils();
+        /**
+         * Lazily constructs the storage utils from the registered factory and memoizes
+         * the result via `singleshot`.
+         *
+         * The instance is built on the first call and cached for all subsequent calls.
+         * Reset via `clear()` so the next call rebuilds from the current factory.
+         */
+        this.getInstance = singleshot(() => this._recentLiveFactory());
         /**
          * Handles active ping event.
          * Proxies call to the underlying storage adapter.
@@ -48962,7 +49366,7 @@ class RecentLiveAdapter {
             backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_HANDLE_ACTIVE_PING, {
                 signalId: event.data.id,
             });
-            return await this._recentLiveUtils.handleActivePing(event);
+            return await this.getInstance().handleActivePing(event);
         };
         /**
          * Retrieves the latest signal for the given context.
@@ -48983,7 +49387,7 @@ class RecentLiveAdapter {
                 frameName,
                 backtest: backtest$1,
             });
-            return await this._recentLiveUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1, when);
+            return await this.getInstance().getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1, when);
         };
         /**
          * Returns the number of whole minutes elapsed since the latest signal's creation timestamp.
@@ -49007,7 +49411,7 @@ class RecentLiveAdapter {
                 backtest: backtest$1,
                 timestamp,
             });
-            const signal = await this._recentLiveUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1, new Date(timestamp));
+            const signal = await this.getInstance().getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1, new Date(timestamp));
             if (!signal) {
                 return null;
             }
@@ -49020,7 +49424,8 @@ class RecentLiveAdapter {
          */
         this.useRecentAdapter = (Ctor) => {
             backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
-            this._recentLiveUtils = Reflect.construct(Ctor, []);
+            this._recentLiveFactory = () => Reflect.construct(Ctor, []);
+            this.getInstance.clear();
         };
         /**
          * Switches to persistent storage adapter (default).
@@ -49028,7 +49433,8 @@ class RecentLiveAdapter {
          */
         this.usePersist = () => {
             backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._recentLiveUtils = new RecentPersistLiveUtils();
+            this._recentLiveFactory = () => new RecentPersistLiveUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to in-memory storage adapter.
@@ -49036,14 +49442,17 @@ class RecentLiveAdapter {
          */
         this.useMemory = () => {
             backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._recentLiveUtils = new RecentMemoryLiveUtils();
+            this._recentLiveFactory = () => new RecentMemoryLiveUtils();
+            this.getInstance.clear();
         };
         /**
-         * Clears the cached utils instance by resetting to the default persistent adapter.
+         * Clears the memoized utils instance.
+         * Call this when process.cwd() changes between strategy iterations
+         * so a new instance is created with the updated base path.
          */
         this.clear = () => {
             backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_CLEAR);
-            this._recentLiveUtils = new RecentPersistLiveUtils();
+            this.getInstance.clear();
         };
     }
 }
@@ -54368,16 +54777,26 @@ class LogDummyUtils {
  */
 class LogAdapter {
     constructor() {
-        /** Internal log utils instance */
-        this._log = new LogMemoryUtils();
+        /** Factory producing the active log utils instance */
+        this._logFactory = () => new LogMemoryUtils();
+        /**
+         * Lazily constructs the log utils from the registered factory and memoizes
+         * the result via `singleshot`.
+         *
+         * The instance is built on the first call and cached for all subsequent calls.
+         * Reset via `clear()` so the next call rebuilds from the current factory
+         * (e.g. when `process.cwd()` changes between strategy iterations).
+         */
+        this.getInstance = singleshot(() => this._logFactory());
         /**
          * Lists all stored log entries.
          * Proxies call to the underlying log adapter.
          * @returns Array of all log entries
          */
         this.getList = async () => {
-            if (this._log.getList) {
-                return await this._log.getList();
+            const log = this.getInstance();
+            if (log.getList) {
+                return await log.getList();
             }
             return [];
         };
@@ -54388,8 +54807,9 @@ class LogAdapter {
          * @param args - Additional arguments
          */
         this.log = (topic, ...args) => {
-            if (this._log.log) {
-                this._log.log(topic, ...args);
+            const log = this.getInstance();
+            if (log.log) {
+                log.log(topic, ...args);
             }
         };
         /**
@@ -54399,8 +54819,9 @@ class LogAdapter {
          * @param args - Additional arguments
          */
         this.debug = (topic, ...args) => {
-            if (this._log.debug) {
-                this._log.debug(topic, ...args);
+            const log = this.getInstance();
+            if (log.debug) {
+                log.debug(topic, ...args);
             }
         };
         /**
@@ -54410,8 +54831,9 @@ class LogAdapter {
          * @param args - Additional arguments
          */
         this.info = (topic, ...args) => {
-            if (this._log.info) {
-                this._log.info(topic, ...args);
+            const log = this.getInstance();
+            if (log.info) {
+                log.info(topic, ...args);
             }
         };
         /**
@@ -54421,8 +54843,9 @@ class LogAdapter {
          * @param args - Additional arguments
          */
         this.warn = (topic, ...args) => {
-            if (this._log.warn) {
-                this._log.warn(topic, ...args);
+            const log = this.getInstance();
+            if (log.warn) {
+                log.warn(topic, ...args);
             }
         };
         /**
@@ -54432,7 +54855,8 @@ class LogAdapter {
          */
         this.useLogger = (Ctor) => {
             backtest.loggerService.info(LOG_ADAPTER_METHOD_NAME_USE_LOGGER);
-            this._log = Reflect.construct(Ctor, []);
+            this._logFactory = () => Reflect.construct(Ctor, []);
+            this.getInstance.clear();
         };
         /**
          * Switches to persistent log adapter.
@@ -54440,7 +54864,8 @@ class LogAdapter {
          */
         this.usePersist = () => {
             backtest.loggerService.info(LOG_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._log = new LogPersistUtils();
+            this._logFactory = () => new LogPersistUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to in-memory log adapter (default).
@@ -54448,7 +54873,8 @@ class LogAdapter {
          */
         this.useMemory = () => {
             backtest.loggerService.info(LOG_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._log = new LogMemoryUtils();
+            this._logFactory = () => new LogMemoryUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to dummy log adapter.
@@ -54456,7 +54882,8 @@ class LogAdapter {
          */
         this.useDummy = () => {
             backtest.loggerService.info(LOG_ADAPTER_METHOD_NAME_USE_DUMMY);
-            this._log = new LogDummyUtils();
+            this._logFactory = () => new LogDummyUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to JSONL file log adapter.
@@ -54466,18 +54893,22 @@ class LogAdapter {
          * @param fileName - Base file name without extension (default: "log")
          * @param dirName - Directory for the JSONL file (default: ./dump/log)
          */
-        this.useJsonl = (fileName = "log.jsonl", dirName = join(process.cwd(), "./dump/log")) => {
+        this.useJsonl = (fileName = "log.jsonl", dirName) => {
             backtest.loggerService.info(LOG_ADAPTER_METHOD_NAME_USE_JSONL);
-            this._log = new LogJsonlUtils(fileName, dirName);
+            this._logFactory = () => {
+                const dir = dirName || join(process.cwd(), "./dump/log");
+                return new LogJsonlUtils(fileName, dir);
+            };
+            this.getInstance.clear();
         };
         /**
-         * Clears the cached log instance by resetting to the default in-memory adapter.
+         * Clears the memoized log instance.
          * Call this when process.cwd() changes between strategy iterations
          * so a new adapter instance is created with the updated base path.
          */
         this.clear = () => {
             backtest.loggerService.info(LOG_ADAPTER_METHOD_NAME_CLEAR);
-            this._log = new LogMemoryUtils();
+            this.getInstance.clear();
         };
     }
 }
@@ -58369,15 +58800,23 @@ class StorageDummyLiveUtils {
  */
 class StorageBacktestAdapter {
     constructor() {
-        /** Internal storage utils instance */
-        this._signalBacktestUtils = new StorageMemoryBacktestUtils();
+        /** Factory producing the active storage utils instance */
+        this._signalBacktestFactory = () => new StorageMemoryBacktestUtils();
+        /**
+         * Lazily constructs the storage utils from the registered factory and memoizes
+         * the result via `singleshot`.
+         *
+         * The instance is built on the first call and cached for all subsequent calls.
+         * Reset via `clear()` so the next call rebuilds from the current factory.
+         */
+        this.getInstance = singleshot(() => this._signalBacktestFactory());
         /**
          * Handles signal opened event.
          * Proxies call to the underlying storage adapter.
          * @param tick - The opened signal tick data
          */
         this.handleOpened = async (tick) => {
-            return await this._signalBacktestUtils.handleOpened(tick);
+            return await this.getInstance().handleOpened(tick);
         };
         /**
          * Handles signal closed event.
@@ -58385,7 +58824,7 @@ class StorageBacktestAdapter {
          * @param tick - The closed signal tick data
          */
         this.handleClosed = async (tick) => {
-            return await this._signalBacktestUtils.handleClosed(tick);
+            return await this.getInstance().handleClosed(tick);
         };
         /**
          * Handles signal scheduled event.
@@ -58393,7 +58832,7 @@ class StorageBacktestAdapter {
          * @param tick - The scheduled signal tick data
          */
         this.handleScheduled = async (tick) => {
-            return await this._signalBacktestUtils.handleScheduled(tick);
+            return await this.getInstance().handleScheduled(tick);
         };
         /**
          * Handles signal cancelled event.
@@ -58401,7 +58840,7 @@ class StorageBacktestAdapter {
          * @param tick - The cancelled signal tick data
          */
         this.handleCancelled = async (tick) => {
-            return await this._signalBacktestUtils.handleCancelled(tick);
+            return await this.getInstance().handleCancelled(tick);
         };
         /**
          * Finds a signal by its ID.
@@ -58410,7 +58849,7 @@ class StorageBacktestAdapter {
          * @returns The signal row or null if not found
          */
         this.findById = async (id) => {
-            return await this._signalBacktestUtils.findById(id);
+            return await this.getInstance().findById(id);
         };
         /**
          * Lists all stored signals.
@@ -58418,13 +58857,13 @@ class StorageBacktestAdapter {
          * @returns Array of all signal rows
          */
         this.list = async () => {
-            return await this._signalBacktestUtils.list();
+            return await this.getInstance().list();
         };
         this.handleActivePing = async (event) => {
-            return await this._signalBacktestUtils.handleActivePing(event);
+            return await this.getInstance().handleActivePing(event);
         };
         this.handleSchedulePing = async (event) => {
-            return await this._signalBacktestUtils.handleSchedulePing(event);
+            return await this.getInstance().handleSchedulePing(event);
         };
         /**
          * Sets the storage adapter constructor.
@@ -58434,7 +58873,8 @@ class StorageBacktestAdapter {
          */
         this.useStorageAdapter = (Ctor) => {
             backtest.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
-            this._signalBacktestUtils = Reflect.construct(Ctor, []);
+            this._signalBacktestFactory = () => Reflect.construct(Ctor, []);
+            this.getInstance.clear();
         };
         /**
          * Switches to dummy storage adapter.
@@ -58442,7 +58882,8 @@ class StorageBacktestAdapter {
          */
         this.useDummy = () => {
             backtest.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY);
-            this._signalBacktestUtils = new StorageDummyBacktestUtils();
+            this._signalBacktestFactory = () => new StorageDummyBacktestUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to persistent storage adapter (default).
@@ -58450,7 +58891,8 @@ class StorageBacktestAdapter {
          */
         this.usePersist = () => {
             backtest.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._signalBacktestUtils = new StoragePersistBacktestUtils();
+            this._signalBacktestFactory = () => new StoragePersistBacktestUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to in-memory storage adapter.
@@ -58458,16 +58900,17 @@ class StorageBacktestAdapter {
          */
         this.useMemory = () => {
             backtest.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._signalBacktestUtils = new StorageMemoryBacktestUtils();
+            this._signalBacktestFactory = () => new StorageMemoryBacktestUtils();
+            this.getInstance.clear();
         };
         /**
-         * Clears the cached utils instance by resetting to the default in-memory adapter.
+         * Clears the memoized utils instance.
          * Call this when process.cwd() changes between strategy iterations
          * so a new instance is created with the updated base path.
          */
         this.clear = () => {
             backtest.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_CLEAR);
-            this._signalBacktestUtils = new StorageMemoryBacktestUtils();
+            this.getInstance.clear();
         };
     }
 }
@@ -58482,15 +58925,23 @@ class StorageBacktestAdapter {
  */
 class StorageLiveAdapter {
     constructor() {
-        /** Internal storage utils instance */
-        this._signalLiveUtils = new StoragePersistLiveUtils();
+        /** Factory producing the active storage utils instance */
+        this._signalLiveFactory = () => new StoragePersistLiveUtils();
+        /**
+         * Lazily constructs the storage utils from the registered factory and memoizes
+         * the result via `singleshot`.
+         *
+         * The instance is built on the first call and cached for all subsequent calls.
+         * Reset via `clear()` so the next call rebuilds from the current factory.
+         */
+        this.getInstance = singleshot(() => this._signalLiveFactory());
         /**
          * Handles signal opened event.
          * Proxies call to the underlying storage adapter.
          * @param tick - The opened signal tick data
          */
         this.handleOpened = async (tick) => {
-            return await this._signalLiveUtils.handleOpened(tick);
+            return await this.getInstance().handleOpened(tick);
         };
         /**
          * Handles signal closed event.
@@ -58498,7 +58949,7 @@ class StorageLiveAdapter {
          * @param tick - The closed signal tick data
          */
         this.handleClosed = async (tick) => {
-            return await this._signalLiveUtils.handleClosed(tick);
+            return await this.getInstance().handleClosed(tick);
         };
         /**
          * Handles signal scheduled event.
@@ -58506,7 +58957,7 @@ class StorageLiveAdapter {
          * @param tick - The scheduled signal tick data
          */
         this.handleScheduled = async (tick) => {
-            return await this._signalLiveUtils.handleScheduled(tick);
+            return await this.getInstance().handleScheduled(tick);
         };
         /**
          * Handles signal cancelled event.
@@ -58514,7 +58965,7 @@ class StorageLiveAdapter {
          * @param tick - The cancelled signal tick data
          */
         this.handleCancelled = async (tick) => {
-            return await this._signalLiveUtils.handleCancelled(tick);
+            return await this.getInstance().handleCancelled(tick);
         };
         /**
          * Finds a signal by its ID.
@@ -58523,7 +58974,7 @@ class StorageLiveAdapter {
          * @returns The signal row or null if not found
          */
         this.findById = async (id) => {
-            return await this._signalLiveUtils.findById(id);
+            return await this.getInstance().findById(id);
         };
         /**
          * Lists all stored signals.
@@ -58531,13 +58982,13 @@ class StorageLiveAdapter {
          * @returns Array of all signal rows
          */
         this.list = async () => {
-            return await this._signalLiveUtils.list();
+            return await this.getInstance().list();
         };
         this.handleActivePing = async (event) => {
-            return await this._signalLiveUtils.handleActivePing(event);
+            return await this.getInstance().handleActivePing(event);
         };
         this.handleSchedulePing = async (event) => {
-            return await this._signalLiveUtils.handleSchedulePing(event);
+            return await this.getInstance().handleSchedulePing(event);
         };
         /**
          * Sets the storage adapter constructor.
@@ -58547,7 +58998,8 @@ class StorageLiveAdapter {
          */
         this.useStorageAdapter = (Ctor) => {
             backtest.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
-            this._signalLiveUtils = Reflect.construct(Ctor, []);
+            this._signalLiveFactory = () => Reflect.construct(Ctor, []);
+            this.getInstance.clear();
         };
         /**
          * Switches to dummy storage adapter.
@@ -58555,7 +59007,8 @@ class StorageLiveAdapter {
          */
         this.useDummy = () => {
             backtest.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY);
-            this._signalLiveUtils = new StorageDummyLiveUtils();
+            this._signalLiveFactory = () => new StorageDummyLiveUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to persistent storage adapter (default).
@@ -58563,7 +59016,8 @@ class StorageLiveAdapter {
          */
         this.usePersist = () => {
             backtest.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._signalLiveUtils = new StoragePersistLiveUtils();
+            this._signalLiveFactory = () => new StoragePersistLiveUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to in-memory storage adapter.
@@ -58571,16 +59025,17 @@ class StorageLiveAdapter {
          */
         this.useMemory = () => {
             backtest.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._signalLiveUtils = new StorageMemoryLiveUtils();
+            this._signalLiveFactory = () => new StorageMemoryLiveUtils();
+            this.getInstance.clear();
         };
         /**
-         * Clears the cached utils instance by resetting to the default persistent adapter.
+         * Clears the memoized utils instance.
          * Call this when process.cwd() changes between strategy iterations
          * so a new instance is created with the updated base path.
          */
         this.clear = () => {
             backtest.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_CLEAR);
-            this._signalLiveUtils = new StoragePersistLiveUtils();
+            this.getInstance.clear();
         };
     }
 }
@@ -60696,18 +61151,26 @@ class NotificationPersistLiveUtils {
  */
 class NotificationBacktestAdapter {
     constructor() {
-        /** Internal notification utils instance */
-        this._notificationBacktestUtils = new NotificationMemoryBacktestUtils();
+        /** Factory producing the active notification utils instance */
+        this._notificationBacktestFactory = () => new NotificationMemoryBacktestUtils();
+        /**
+         * Lazily constructs the notification utils from the registered factory and
+         * memoizes the result via `singleshot`.
+         *
+         * The instance is built on the first call and cached for all subsequent calls.
+         * Reset via `clear()` so the next call rebuilds from the current factory.
+         */
+        this.getInstance = singleshot(() => this._notificationBacktestFactory());
         /**
          * Handles signal events.
          * Proxies call to the underlying notification adapter.
          * @param data - The strategy tick result data
          */
         this.handleSignal = async (data) => {
-            return await this._notificationBacktestUtils.handleSignal(data);
+            return await this.getInstance().handleSignal(data);
         };
         this.handleSignalNotify = async (data) => {
-            return await this._notificationBacktestUtils.handleSignalNotify(data);
+            return await this.getInstance().handleSignalNotify(data);
         };
         /**
          * Handles partial profit availability event.
@@ -60715,7 +61178,7 @@ class NotificationBacktestAdapter {
          * @param data - The partial profit contract data
          */
         this.handlePartialProfit = async (data) => {
-            return await this._notificationBacktestUtils.handlePartialProfit(data);
+            return await this.getInstance().handlePartialProfit(data);
         };
         /**
          * Handles partial loss availability event.
@@ -60723,7 +61186,7 @@ class NotificationBacktestAdapter {
          * @param data - The partial loss contract data
          */
         this.handlePartialLoss = async (data) => {
-            return await this._notificationBacktestUtils.handlePartialLoss(data);
+            return await this.getInstance().handlePartialLoss(data);
         };
         /**
          * Handles breakeven availability event.
@@ -60731,7 +61194,7 @@ class NotificationBacktestAdapter {
          * @param data - The breakeven contract data
          */
         this.handleBreakeven = async (data) => {
-            return await this._notificationBacktestUtils.handleBreakeven(data);
+            return await this.getInstance().handleBreakeven(data);
         };
         /**
          * Handles strategy commit events.
@@ -60739,7 +61202,7 @@ class NotificationBacktestAdapter {
          * @param data - The strategy commit contract data
          */
         this.handleStrategyCommit = async (data) => {
-            return await this._notificationBacktestUtils.handleStrategyCommit(data);
+            return await this.getInstance().handleStrategyCommit(data);
         };
         /**
          * Handles signal sync events (signal-open, signal-close).
@@ -60747,7 +61210,7 @@ class NotificationBacktestAdapter {
          * @param data - The signal sync contract data
          */
         this.handleSync = trycatch(async (data) => {
-            return await this._notificationBacktestUtils.handleSync(data);
+            return await this.getInstance().handleSync(data);
         }, {
             defaultValue: null,
         });
@@ -60757,7 +61220,7 @@ class NotificationBacktestAdapter {
          * @param data - The risk contract data
          */
         this.handleRisk = async (data) => {
-            return await this._notificationBacktestUtils.handleRisk(data);
+            return await this.getInstance().handleRisk(data);
         };
         /**
          * Handles error event.
@@ -60765,7 +61228,7 @@ class NotificationBacktestAdapter {
          * @param error - The error object
          */
         this.handleError = async (error) => {
-            return await this._notificationBacktestUtils.handleError(error);
+            return await this.getInstance().handleError(error);
         };
         /**
          * Handles critical error event.
@@ -60773,7 +61236,7 @@ class NotificationBacktestAdapter {
          * @param error - The error object
          */
         this.handleCriticalError = async (error) => {
-            return await this._notificationBacktestUtils.handleCriticalError(error);
+            return await this.getInstance().handleCriticalError(error);
         };
         /**
          * Handles validation error event.
@@ -60781,7 +61244,7 @@ class NotificationBacktestAdapter {
          * @param error - The error object
          */
         this.handleValidationError = async (error) => {
-            return await this._notificationBacktestUtils.handleValidationError(error);
+            return await this.getInstance().handleValidationError(error);
         };
         /**
          * Gets all stored notifications.
@@ -60789,14 +61252,14 @@ class NotificationBacktestAdapter {
          * @returns Array of all notification models
          */
         this.getData = async () => {
-            return await this._notificationBacktestUtils.getData();
+            return await this.getInstance().getData();
         };
         /**
          * Clears all stored notifications.
          * Proxies call to the underlying notification adapter.
          */
         this.dispose = async () => {
-            return await this._notificationBacktestUtils.dispose();
+            return await this.getInstance().dispose();
         };
         /**
          * Sets the notification adapter constructor.
@@ -60806,7 +61269,8 @@ class NotificationBacktestAdapter {
          */
         this.useNotificationAdapter = (Ctor) => {
             backtest.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
-            this._notificationBacktestUtils = Reflect.construct(Ctor, []);
+            this._notificationBacktestFactory = () => Reflect.construct(Ctor, []);
+            this.getInstance.clear();
         };
         /**
          * Switches to dummy notification adapter.
@@ -60814,7 +61278,8 @@ class NotificationBacktestAdapter {
          */
         this.useDummy = () => {
             backtest.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY);
-            this._notificationBacktestUtils = new NotificationDummyBacktestUtils();
+            this._notificationBacktestFactory = () => new NotificationDummyBacktestUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to in-memory notification adapter (default).
@@ -60822,7 +61287,8 @@ class NotificationBacktestAdapter {
          */
         this.useMemory = () => {
             backtest.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._notificationBacktestUtils = new NotificationMemoryBacktestUtils();
+            this._notificationBacktestFactory = () => new NotificationMemoryBacktestUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to persistent notification adapter.
@@ -60830,16 +61296,17 @@ class NotificationBacktestAdapter {
          */
         this.usePersist = () => {
             backtest.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._notificationBacktestUtils = new NotificationPersistBacktestUtils();
+            this._notificationBacktestFactory = () => new NotificationPersistBacktestUtils();
+            this.getInstance.clear();
         };
         /**
-         * Resets the cached utils instance to the default in-memory adapter.
+         * Clears the memoized utils instance.
          * Call this when process.cwd() changes between strategy iterations
          * so a new instance is created with the updated base path.
          */
         this.clear = () => {
             backtest.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_CLEAR);
-            this._notificationBacktestUtils = new NotificationMemoryBacktestUtils();
+            this.getInstance.clear();
         };
     }
 }
@@ -60854,18 +61321,26 @@ class NotificationBacktestAdapter {
  */
 class NotificationLiveAdapter {
     constructor() {
-        /** Internal notification utils instance */
-        this._notificationLiveUtils = new NotificationMemoryLiveUtils();
+        /** Factory producing the active notification utils instance */
+        this._notificationLiveFactory = () => new NotificationMemoryLiveUtils();
+        /**
+         * Lazily constructs the notification utils from the registered factory and
+         * memoizes the result via `singleshot`.
+         *
+         * The instance is built on the first call and cached for all subsequent calls.
+         * Reset via `clear()` so the next call rebuilds from the current factory.
+         */
+        this.getInstance = singleshot(() => this._notificationLiveFactory());
         /**
          * Handles signal events.
          * Proxies call to the underlying notification adapter.
          * @param data - The strategy tick result data
          */
         this.handleSignal = async (data) => {
-            return await this._notificationLiveUtils.handleSignal(data);
+            return await this.getInstance().handleSignal(data);
         };
         this.handleSignalNotify = async (data) => {
-            return await this._notificationLiveUtils.handleSignalNotify(data);
+            return await this.getInstance().handleSignalNotify(data);
         };
         /**
          * Handles partial profit availability event.
@@ -60873,7 +61348,7 @@ class NotificationLiveAdapter {
          * @param data - The partial profit contract data
          */
         this.handlePartialProfit = async (data) => {
-            return await this._notificationLiveUtils.handlePartialProfit(data);
+            return await this.getInstance().handlePartialProfit(data);
         };
         /**
          * Handles partial loss availability event.
@@ -60881,7 +61356,7 @@ class NotificationLiveAdapter {
          * @param data - The partial loss contract data
          */
         this.handlePartialLoss = async (data) => {
-            return await this._notificationLiveUtils.handlePartialLoss(data);
+            return await this.getInstance().handlePartialLoss(data);
         };
         /**
          * Handles breakeven availability event.
@@ -60889,7 +61364,7 @@ class NotificationLiveAdapter {
          * @param data - The breakeven contract data
          */
         this.handleBreakeven = async (data) => {
-            return await this._notificationLiveUtils.handleBreakeven(data);
+            return await this.getInstance().handleBreakeven(data);
         };
         /**
          * Handles strategy commit events.
@@ -60897,7 +61372,7 @@ class NotificationLiveAdapter {
          * @param data - The strategy commit contract data
          */
         this.handleStrategyCommit = async (data) => {
-            return await this._notificationLiveUtils.handleStrategyCommit(data);
+            return await this.getInstance().handleStrategyCommit(data);
         };
         /**
          * Handles signal sync events (signal-open, signal-close).
@@ -60905,7 +61380,7 @@ class NotificationLiveAdapter {
          * @param data - The signal sync contract data
          */
         this.handleSync = trycatch(async (data) => {
-            return await this._notificationLiveUtils.handleSync(data);
+            return await this.getInstance().handleSync(data);
         }, {
             defaultValue: null,
         });
@@ -60915,7 +61390,7 @@ class NotificationLiveAdapter {
          * @param data - The risk contract data
          */
         this.handleRisk = async (data) => {
-            return await this._notificationLiveUtils.handleRisk(data);
+            return await this.getInstance().handleRisk(data);
         };
         /**
          * Handles error event.
@@ -60923,7 +61398,7 @@ class NotificationLiveAdapter {
          * @param error - The error object
          */
         this.handleError = async (error) => {
-            return await this._notificationLiveUtils.handleError(error);
+            return await this.getInstance().handleError(error);
         };
         /**
          * Handles critical error event.
@@ -60931,7 +61406,7 @@ class NotificationLiveAdapter {
          * @param error - The error object
          */
         this.handleCriticalError = async (error) => {
-            return await this._notificationLiveUtils.handleCriticalError(error);
+            return await this.getInstance().handleCriticalError(error);
         };
         /**
          * Handles validation error event.
@@ -60939,7 +61414,7 @@ class NotificationLiveAdapter {
          * @param error - The error object
          */
         this.handleValidationError = async (error) => {
-            return await this._notificationLiveUtils.handleValidationError(error);
+            return await this.getInstance().handleValidationError(error);
         };
         /**
          * Gets all stored notifications.
@@ -60947,14 +61422,14 @@ class NotificationLiveAdapter {
          * @returns Array of all notification models
          */
         this.getData = async () => {
-            return await this._notificationLiveUtils.getData();
+            return await this.getInstance().getData();
         };
         /**
          * Clears all stored notifications.
          * Proxies call to the underlying notification adapter.
          */
         this.dispose = async () => {
-            return await this._notificationLiveUtils.dispose();
+            return await this.getInstance().dispose();
         };
         /**
          * Sets the notification adapter constructor.
@@ -60964,7 +61439,8 @@ class NotificationLiveAdapter {
          */
         this.useNotificationAdapter = (Ctor) => {
             backtest.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
-            this._notificationLiveUtils = Reflect.construct(Ctor, []);
+            this._notificationLiveFactory = () => Reflect.construct(Ctor, []);
+            this.getInstance.clear();
         };
         /**
          * Switches to dummy notification adapter.
@@ -60972,7 +61448,8 @@ class NotificationLiveAdapter {
          */
         this.useDummy = () => {
             backtest.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY);
-            this._notificationLiveUtils = new NotificationDummyLiveUtils();
+            this._notificationLiveFactory = () => new NotificationDummyLiveUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to in-memory notification adapter (default).
@@ -60980,7 +61457,8 @@ class NotificationLiveAdapter {
          */
         this.useMemory = () => {
             backtest.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._notificationLiveUtils = new NotificationMemoryLiveUtils();
+            this._notificationLiveFactory = () => new NotificationMemoryLiveUtils();
+            this.getInstance.clear();
         };
         /**
          * Switches to persistent notification adapter.
@@ -60988,16 +61466,17 @@ class NotificationLiveAdapter {
          */
         this.usePersist = () => {
             backtest.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._notificationLiveUtils = new NotificationPersistLiveUtils();
+            this._notificationLiveFactory = () => new NotificationPersistLiveUtils();
+            this.getInstance.clear();
         };
         /**
-         * Resets the cached utils instance to the default in-memory adapter.
+         * Clears the memoized utils instance.
          * Call this when process.cwd() changes between strategy iterations
          * so a new instance is created with the updated base path.
          */
         this.clear = () => {
             backtest.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_CLEAR);
-            this._notificationLiveUtils = new NotificationMemoryLiveUtils();
+            this.getInstance.clear();
         };
     }
 }
@@ -63598,4 +64077,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, 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, 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, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, 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, 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, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };