backtest-kit 9.8.1 → 9.8.2

package/build/index.cjs

@@ -574,6 +574,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.
@@ -934,7 +950,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
@@ -1057,7 +1073,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,
     });
@@ -1115,7 +1131,7 @@ class PersistBase {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a$3] = functoolsKit.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,
         });
@@ -1131,14 +1147,14 @@ class PersistBase {
         return path.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,
         });
@@ -1155,7 +1171,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,
         });
@@ -1172,7 +1188,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,
         });
@@ -1194,7 +1210,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 {
@@ -1339,7 +1355,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);
@@ -1357,7 +1373,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);
@@ -1372,7 +1388,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();
     }
@@ -1381,21 +1397,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);
     }
 }
@@ -1535,7 +1551,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);
@@ -1553,7 +1569,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);
@@ -1568,7 +1584,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();
     }
@@ -1577,21 +1593,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);
     }
 }
@@ -1730,7 +1746,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);
@@ -1748,7 +1764,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);
@@ -1763,7 +1779,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();
     }
@@ -1772,21 +1788,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);
     }
 }
@@ -1931,7 +1947,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);
@@ -1951,7 +1967,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);
@@ -1966,7 +1982,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();
     }
@@ -1975,21 +1991,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);
     }
 }
@@ -2154,7 +2170,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);
@@ -2174,7 +2190,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);
@@ -2189,7 +2205,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();
     }
@@ -2198,21 +2214,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);
     }
 }
@@ -2303,7 +2319,7 @@ class PersistCandleInstance {
                     error: functoolsKit.errorData(error),
                     message: functoolsKit.getErrorMessage(error),
                 };
-                LOGGER_SERVICE$7.warn(message, payload);
+                LOGGER_SERVICE$8.warn(message, payload);
                 console.warn(message, payload);
                 errorEmitter.next(error);
                 return null;
@@ -2325,7 +2341,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,
@@ -2402,7 +2418,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,
@@ -2426,7 +2442,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,
@@ -2446,7 +2462,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();
     }
@@ -2455,21 +2471,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);
     }
 }
@@ -2607,7 +2623,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);
@@ -2623,7 +2639,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);
@@ -2638,7 +2654,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();
     }
@@ -2647,21 +2663,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);
     }
 }
@@ -2788,7 +2804,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);
@@ -2804,7 +2820,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);
@@ -2819,7 +2835,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();
     }
@@ -2829,21 +2845,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);
     }
 }
@@ -2967,7 +2983,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);
@@ -2981,7 +2997,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);
@@ -3006,7 +3022,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;
     }
@@ -3015,21 +3031,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);
     }
 }
@@ -3191,7 +3207,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);
@@ -3207,7 +3223,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);
@@ -3222,7 +3238,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);
@@ -3236,7 +3252,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();
     }
@@ -3248,7 +3264,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);
@@ -3259,21 +3275,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);
     }
 }
@@ -3432,7 +3448,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);
@@ -3448,7 +3464,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);
@@ -3463,7 +3479,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);
@@ -3477,7 +3493,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();
     }
@@ -3489,7 +3505,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);
@@ -3500,21 +3516,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);
     }
 }
@@ -3720,7 +3736,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);
@@ -3737,7 +3753,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);
@@ -3756,7 +3772,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);
@@ -3773,7 +3789,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);
@@ -3785,7 +3801,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();
         };
         /**
@@ -3796,7 +3812,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);
         };
@@ -3808,7 +3824,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();
     }
@@ -3822,7 +3838,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);
@@ -3833,14 +3849,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);
     }
 }
@@ -3989,7 +4005,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);
@@ -4010,7 +4026,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);
@@ -4043,7 +4059,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();
     }
@@ -4052,21 +4068,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);
     }
 }
@@ -4201,7 +4217,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);
@@ -4216,7 +4232,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);
@@ -4234,7 +4250,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);
@@ -4245,14 +4261,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);
         };
         /**
@@ -4260,7 +4276,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();
         };
         /**
@@ -4271,7 +4287,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);
         };
@@ -4283,7 +4299,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();
     }
@@ -4423,7 +4439,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);
@@ -4439,7 +4455,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);
@@ -4458,7 +4474,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);
@@ -4469,14 +4485,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);
         };
         /**
@@ -4484,7 +4500,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();
         };
         /**
@@ -4496,7 +4512,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);
         };
@@ -4508,7 +4524,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();
     }
@@ -4520,28 +4536,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 functoolsKit.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 {
@@ -4556,7 +4583,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 functoolsKit.Subject();
         this[_a$2] = functoolsKit.queued(ACQUIRE_LOCK_FN);
         this[_b$2] = () => this[SET_BUSY_SYMBOL](false);
         /**
@@ -4577,16 +4615,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) {
@@ -4601,18 +4642,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 functoolsKit.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, {
@@ -4621,13 +4810,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, {
@@ -4638,8 +4828,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(),
+                functoolsKit.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;
@@ -19173,9 +19402,28 @@ const TICK_FN = async (self, symbol, when) => {
         return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "TICK_FN", message: functoolsKit.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}`);
@@ -20061,6 +20309,15 @@ class WalkerLogicPrivateService {
                     exchangeName: context.exchangeName,
                     frameName: context.frameName,
                 });
+                Lookup.addActivity({
+                    symbol,
+                    context: {
+                        strategyName,
+                        exchangeName: context.exchangeName,
+                        frameName: context.frameName,
+                    },
+                    backtest: true,
+                });
                 try {
                     await functoolsKit.resolveDocuments(iterator);
                 }
@@ -20076,6 +20333,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,
@@ -36095,6 +36363,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,
@@ -36126,6 +36395,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 = functoolsKit.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,
@@ -36201,6 +36498,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";
 /**
@@ -41986,11 +42311,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,
@@ -44637,11 +44972,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,
@@ -63767,6 +64112,7 @@ exports.HighestProfit = HighestProfit;
 exports.Interval = Interval;
 exports.Live = Live;
 exports.Log = Log;
+exports.Lookup = Lookup;
 exports.Markdown = Markdown;
 exports.MarkdownFileBase = MarkdownFileBase;
 exports.MarkdownFolderBase = MarkdownFolderBase;
@@ -63848,6 +64194,7 @@ exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
 exports.alignToInterval = alignToInterval;
+exports.cacheCandles = cacheCandles;
 exports.checkCandles = checkCandles;
 exports.commitActivateScheduled = commitActivateScheduled;
 exports.commitAverageBuy = commitAverageBuy;