backtest-kit 8.5.0 → 9.0.0

package/build/index.cjs

@@ -1221,43 +1221,91 @@ _a$3 = BASE_WAIT_FOR_INIT_SYMBOL;
 // @ts-ignore
 PersistBase = functoolsKit.makeExtendable(PersistBase);
 /**
- * Dummy persist adapter that discards all writes.
- * Used for disabling persistence.
+ * Default file-based implementation of IPersistSignalInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses symbol as entity ID within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistSignalInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeSignalData(signalRow);
+ * const restored = await instance.readSignalData();
+ * ```
  */
-class PersistDummy {
+class PersistSignalInstance {
     /**
-     * No-op initialization function.
-     * @returns Promise that resolves immediately
+     * Creates new signal persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
      */
-    async waitForInit() {
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/signal/`);
     }
     /**
-     * No-op read function.
-     * @returns Promise that resolves with empty object
+     * Initializes the underlying PersistBase storage.
+     * Delegates to PersistBase.waitForInit which uses singleshot.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
      */
-    async readValue() {
-        return {};
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
     }
     /**
-     * No-op has value check.
-     * @returns Promise that resolves to false
+     * Reads the persisted signal using `symbol` as the entity key.
+     *
+     * @returns Promise resolving to the signal or null if not found
      */
-    async hasValue() {
-        return false;
+    async readSignalData() {
+        if (await this._storage.hasValue(this.symbol)) {
+            return await this._storage.readValue(this.symbol);
+        }
+        return null;
     }
     /**
-     * No-op write function.
-     * @returns Promise that resolves immediately
+     * Writes the signal (or null to clear) using `symbol` as the entity key.
+     *
+     * @param signalRow - Signal data to persist, or null to clear
+     * @returns Promise that resolves when write is complete
      */
-    async writeValue() {
+    async writeSignalData(signalRow) {
+        await this._storage.writeValue(this.symbol, signalRow);
     }
+}
+/**
+ * No-op IPersistSignalInstance implementation used by PersistSignalUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistSignalDummyInstance {
     /**
-     * No-op keys generator.
-     * @returns Empty async generator
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistSignalInstanceCtor.
      */
-    async *keys() {
-        // Empty generator - no keys
-    }
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted signal).
+     * @returns Promise resolving to null
+     */
+    async readSignalData() { return null; }
+    /**
+     * No-op write (discards data).
+     * @returns Promise that resolves immediately
+     */
+    async writeSignalData(_signalRow) { }
 }
 /**
  * Utility class for managing signal persistence.
@@ -1272,40 +1320,37 @@ class PersistDummy {
  */
 class PersistSignalUtils {
     constructor() {
-        this.PersistSignalFactory = PersistBase;
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/signal/`,
-        ]));
         /**
-         * Reads persisted signal data for a symbol and strategy.
-         *
-         * Called by ClientStrategy.waitForInit() to restore state.
-         * Returns null if no signal exists.
+         * Constructor used to create per-context signal instances.
+         * Replaceable via usePersistSignalAdapter() / useJson() / useDummy().
+         */
+        this.PersistSignalInstanceCtor = PersistSignalInstance;
+        /**
+         * Memoized factory creating one IPersistSignalInstance per (symbol, strategy, exchange) triple.
+         */
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalInstanceCtor, [symbol, strategyName, exchangeName]));
+        /**
+         * Reads persisted signal for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to signal or null
+         * @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);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
-            }
-            return null;
+            const instance = this.getStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readSignalData();
         };
         /**
-         * Writes signal data to disk with atomic file writes.
+         * Writes signal data (or null to clear) for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * Called by ClientStrategy.setPendingSignal() to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
-         *
-         * @param signalRow - Signal data (null to clear)
+         * @param signalRow - Signal data to persist, or null to clear
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
@@ -1315,53 +1360,43 @@ class PersistSignalUtils {
             LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, signalRow);
+            const instance = this.getStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeSignalData(signalRow);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistSignalInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistSignalInstance constructor
      */
     usePersistSignalAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
-        this.PersistSignalFactory = Ctor;
+        this.PersistSignalInstanceCtor = Ctor;
+        this.getStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistSignalInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistSignalAdapter(PersistBase);
+        this.usePersistSignalAdapter(PersistSignalInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistSignalDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistSignalAdapter(PersistDummy);
+        this.usePersistSignalAdapter(PersistSignalDummyInstance);
     }
 }
 /**
@@ -1381,6 +1416,92 @@ class PersistSignalUtils {
  * ```
  */
 const PersistSignalAdapter = new PersistSignalUtils();
+/**
+ * Default file-based implementation of IPersistRiskInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses fixed entity ID "positions" within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistRiskInstance("my-risk", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writePositionData([["strategy:BTCUSDT", positionData]]);
+ * const positions = await instance.readPositionData();
+ * ```
+ */
+class PersistRiskInstance {
+    /**
+     * Creates new risk positions persistence instance.
+     *
+     * @param riskName - Risk profile identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(riskName, exchangeName) {
+        this.riskName = riskName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${riskName}_${exchangeName}`, `./dump/data/risk/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted positions array using the fixed STORAGE_KEY.
+     *
+     * @returns Promise resolving to positions (empty array if none persisted)
+     */
+    async readPositionData() {
+        if (await this._storage.hasValue(PersistRiskInstance.STORAGE_KEY)) {
+            return await this._storage.readValue(PersistRiskInstance.STORAGE_KEY);
+        }
+        return [];
+    }
+    /**
+     * Writes the positions array using the fixed STORAGE_KEY.
+     *
+     * @param riskRow - Position entries to persist
+     * @returns Promise that resolves when write is complete
+     */
+    async writePositionData(riskRow) {
+        await this._storage.writeValue(PersistRiskInstance.STORAGE_KEY, riskRow);
+    }
+}
+/** Fixed entity key for storing the positions array */
+PersistRiskInstance.STORAGE_KEY = "positions";
+/**
+ * No-op IPersistRiskInstance implementation used by PersistRiskUtils.useDummy().
+ * All reads return empty array, all writes are discarded.
+ */
+class PersistRiskDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistRiskInstanceCtor.
+     */
+    constructor(_riskName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty positions array.
+     * @returns Promise resolving to []
+     */
+    async readPositionData() { return []; }
+    /**
+     * No-op write (discards positions).
+     * @returns Promise that resolves immediately
+     */
+    async writePositionData(_riskRow) { }
+}
 /**
  * Utility class for managing risk active positions persistence.
  *
@@ -1394,40 +1515,36 @@ const PersistSignalAdapter = new PersistSignalUtils();
  */
 class PersistRiskUtils {
     constructor() {
-        this.PersistRiskFactory = PersistBase;
-        this.getRiskStorage = functoolsKit.memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
-            `${riskName}_${exchangeName}`,
-            `./dump/data/risk/`,
-        ]));
         /**
-         * Reads persisted active positions for a risk profile.
-         *
-         * Called by ClientRisk.waitForInit() to restore state.
-         * Returns empty Map if no positions exist.
+         * Constructor used to create per-context risk instances.
+         * Replaceable via usePersistRiskAdapter() / useJson() / useDummy().
+         */
+        this.PersistRiskInstanceCtor = PersistRiskInstance;
+        /**
+         * Memoized factory creating one IPersistRiskInstance per (riskName, exchange) pair.
+         */
+        this.getRiskStorage = functoolsKit.memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskInstanceCtor, [riskName, exchangeName]));
+        /**
+         * Reads persisted active positions for the given risk context.
+         * Lazily initializes the instance on first access.
          *
          * @param riskName - Risk profile identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to Map of active positions
+         * @returns Promise resolving to position entries (empty array if none)
          */
         this.readPositionData = async (riskName, exchangeName) => {
             LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
-            const stateStorage = this.getRiskStorage(riskName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            const RISK_STORAGE_KEY = "positions";
-            if (await stateStorage.hasValue(RISK_STORAGE_KEY)) {
-                return await stateStorage.readValue(RISK_STORAGE_KEY);
-            }
-            return [];
+            const instance = this.getRiskStorage(riskName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readPositionData();
         };
         /**
-         * Writes active positions to disk with atomic file writes.
+         * Writes active positions for the given risk context.
+         * Lazily initializes the instance on first access.
          *
-         * Called by ClientRisk after addSignal/removeSignal to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
-         *
-         * @param positions - Map of active positions
+         * @param riskRow - Position entries to persist
          * @param riskName - Risk profile identifier
          * @param exchangeName - Exchange identifier
          * @returns Promise that resolves when write is complete
@@ -1436,54 +1553,43 @@ class PersistRiskUtils {
             LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
-            const stateStorage = this.getRiskStorage(riskName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            const RISK_STORAGE_KEY = "positions";
-            await stateStorage.writeValue(RISK_STORAGE_KEY, riskRow);
+            const instance = this.getRiskStorage(riskName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writePositionData(riskRow);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistRiskInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistRiskInstance constructor
      */
     usePersistRiskAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
-        this.PersistRiskFactory = Ctor;
+        this.PersistRiskInstanceCtor = Ctor;
+        this.getRiskStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
         this.getRiskStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistRiskInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistRiskAdapter(PersistBase);
+        this.usePersistRiskAdapter(PersistRiskInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistRiskDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistRiskAdapter(PersistDummy);
+        this.usePersistRiskAdapter(PersistRiskDummyInstance);
     }
 }
 /**
@@ -1503,6 +1609,92 @@ class PersistRiskUtils {
  * ```
  */
 const PersistRiskAdapter = new PersistRiskUtils();
+/**
+ * Default file-based implementation of IPersistScheduleInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses symbol as entity ID within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistScheduleInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeScheduleData(scheduledRow);
+ * const restored = await instance.readScheduleData();
+ * ```
+ */
+class PersistScheduleInstance {
+    /**
+     * Creates new scheduled signal persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/schedule/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted scheduled signal using `symbol` as the entity key.
+     *
+     * @returns Promise resolving to scheduled signal or null if not found
+     */
+    async readScheduleData() {
+        if (await this._storage.hasValue(this.symbol)) {
+            return await this._storage.readValue(this.symbol);
+        }
+        return null;
+    }
+    /**
+     * Writes the scheduled signal (or null to clear) using `symbol` as the entity key.
+     *
+     * @param row - Scheduled signal data to persist, or null to clear
+     * @returns Promise that resolves when write is complete
+     */
+    async writeScheduleData(row) {
+        await this._storage.writeValue(this.symbol, row);
+    }
+}
+/**
+ * No-op IPersistScheduleInstance implementation used by PersistScheduleUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistScheduleDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistScheduleInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted scheduled signal).
+     * @returns Promise resolving to null
+     */
+    async readScheduleData() { return null; }
+    /**
+     * No-op write (discards scheduled signal).
+     * @returns Promise that resolves immediately
+     */
+    async writeScheduleData(_row) { }
+}
 /**
  * Utility class for managing scheduled signal persistence.
  *
@@ -1516,40 +1708,37 @@ const PersistRiskAdapter = new PersistRiskUtils();
  */
 class PersistScheduleUtils {
     constructor() {
-        this.PersistScheduleFactory = PersistBase;
-        this.getScheduleStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistScheduleFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/schedule/`,
-        ]));
         /**
-         * Reads persisted scheduled signal data for a symbol and strategy.
-         *
-         * Called by ClientStrategy.waitForInit() to restore scheduled signal state.
-         * Returns null if no scheduled signal exists.
+         * Constructor used to create per-context scheduled signal instances.
+         * Replaceable via usePersistScheduleAdapter() / useJson() / useDummy().
+         */
+        this.PersistScheduleInstanceCtor = PersistScheduleInstance;
+        /**
+         * Memoized factory creating one IPersistScheduleInstance per (symbol, strategy, exchange) triple.
+         */
+        this.getScheduleStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistScheduleInstanceCtor, [symbol, strategyName, exchangeName]));
+        /**
+         * Reads persisted scheduled signal for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to scheduled signal or null
+         * @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);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getScheduleStorage.has(key);
-            const stateStorage = this.getScheduleStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
-            }
-            return null;
+            const instance = this.getScheduleStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readScheduleData();
         };
         /**
-         * Writes scheduled signal data to disk with atomic file writes.
-         *
-         * Called by ClientStrategy.setScheduledSignal() to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes scheduled signal (or null to clear) for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * @param scheduledSignalRow - Scheduled signal data (null to clear)
+         * @param scheduledSignalRow - Scheduled signal data to persist, or null to clear
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
@@ -1559,53 +1748,43 @@ class PersistScheduleUtils {
             LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getScheduleStorage.has(key);
-            const stateStorage = this.getScheduleStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, scheduledSignalRow);
+            const instance = this.getScheduleStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeScheduleData(scheduledSignalRow);
         };
     }
     /**
-     * Registers a custom persistence adapter.
-     *
-     * @param Ctor - Custom PersistBase constructor
+     * Registers a custom IPersistScheduleInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistScheduleInstance constructor
      */
     usePersistScheduleAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
-        this.PersistScheduleFactory = Ctor;
+        this.PersistScheduleInstanceCtor = Ctor;
+        this.getScheduleStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
         this.getScheduleStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistScheduleInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistScheduleAdapter(PersistBase);
+        this.usePersistScheduleAdapter(PersistScheduleInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistScheduleDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistScheduleAdapter(PersistDummy);
+        this.usePersistScheduleAdapter(PersistScheduleDummyInstance);
     }
 }
 /**
@@ -1625,6 +1804,94 @@ class PersistScheduleUtils {
  * ```
  */
 const PersistScheduleAdapter = new PersistScheduleUtils();
+/**
+ * Default file-based implementation of IPersistPartialInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses signalId as entity ID within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistPartialInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writePartialData(partialData, "signal-id-1");
+ * const restored = await instance.readPartialData("signal-id-1");
+ * ```
+ */
+class PersistPartialInstance {
+    /**
+     * Creates new partial data persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/partial/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the partial data for the given signal using `signalId` as the entity key.
+     *
+     * @param signalId - Signal identifier
+     * @returns Promise resolving to partial data record (empty object if not found)
+     */
+    async readPartialData(signalId) {
+        if (await this._storage.hasValue(signalId)) {
+            return await this._storage.readValue(signalId);
+        }
+        return {};
+    }
+    /**
+     * Writes the partial data for the given signal using `signalId` as the entity key.
+     *
+     * @param data - Partial data record to persist
+     * @param signalId - Signal identifier
+     * @returns Promise that resolves when write is complete
+     */
+    async writePartialData(data, signalId) {
+        await this._storage.writeValue(signalId, data);
+    }
+}
+/**
+ * No-op IPersistPartialInstance implementation used by PersistPartialUtils.useDummy().
+ * All reads return empty object, all writes are discarded.
+ */
+class PersistPartialDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistPartialInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty partial data record.
+     * @returns Promise resolving to {}
+     */
+    async readPartialData(_signalId) { return {}; }
+    /**
+     * No-op write (discards partial data).
+     * @returns Promise that resolves immediately
+     */
+    async writePartialData(_data, _signalId) { }
+}
 /**
  * Utility class for managing partial profit/loss levels persistence.
  *
@@ -1638,41 +1905,39 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
  */
 class PersistPartialUtils {
     constructor() {
-        this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/partial/`,
-        ]));
         /**
-         * Reads persisted partial data for a symbol and strategy.
-         *
-         * Called by ClientPartial.waitForInit() to restore state.
-         * Returns empty object if no partial data exists.
+         * Constructor used to create per-context partial data instances.
+         * Replaceable via usePersistPartialAdapter() / useJson() / useDummy().
+         */
+        this.PersistPartialInstanceCtor = PersistPartialInstance;
+        /**
+         * Memoized factory creating one IPersistPartialInstance per (symbol, strategy, exchange) triple.
+         * Each signal's partial data is stored under its own signalId within the instance.
+         */
+        this.getPartialStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialInstanceCtor, [symbol, strategyName, exchangeName]));
+        /**
+         * Reads partial data for the given context and signalId.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to partial data record
+         * @returns Promise resolving to partial data record (empty object if none)
          */
         this.readPartialData = async (symbol, strategyName, signalId, exchangeName) => {
             LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
-            const stateStorage = this.getPartialStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(signalId)) {
-                return await stateStorage.readValue(signalId);
-            }
-            return {};
+            const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readPartialData(signalId);
         };
         /**
-         * Writes partial data to disk with atomic file writes.
+         * Writes partial data for the given context and signalId.
+         * Lazily initializes the instance on first access.
          *
-         * Called by ClientPartial after profit/loss level changes to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
-         *
-         * @param partialData - Record of signal IDs to partial data
+         * @param partialData - Partial data record to persist
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
@@ -1683,53 +1948,43 @@ class PersistPartialUtils {
             LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
-            const stateStorage = this.getPartialStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(signalId, partialData);
+            const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writePartialData(partialData, signalId);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistPartialInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistPartialInstance constructor
      */
     usePersistPartialAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
-        this.PersistPartialFactory = Ctor;
+        this.PersistPartialInstanceCtor = Ctor;
+        this.getPartialStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
         this.getPartialStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistPartialInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistPartialAdapter(PersistBase);
+        this.usePersistPartialAdapter(PersistPartialInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistPartialDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistPartialAdapter(PersistDummy);
+        this.usePersistPartialAdapter(PersistPartialDummyInstance);
     }
 }
 /**
@@ -1749,11 +2004,99 @@ class PersistPartialUtils {
  * ```
  */
 const PersistPartialAdapter = new PersistPartialUtils();
+/**
+ * Default file-based implementation of IPersistBreakevenInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses signalId as entity ID within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistBreakevenInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeBreakevenData(breakevenData, "signal-id-1");
+ * const restored = await instance.readBreakevenData("signal-id-1");
+ * ```
+ */
+class PersistBreakevenInstance {
+    /**
+     * Creates new breakeven persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/breakeven/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the breakeven data for the given signal using `signalId` as the entity key.
+     *
+     * @param signalId - Signal identifier
+     * @returns Promise resolving to breakeven data record (empty object if not found)
+     */
+    async readBreakevenData(signalId) {
+        if (await this._storage.hasValue(signalId)) {
+            return await this._storage.readValue(signalId);
+        }
+        return {};
+    }
+    /**
+     * Writes the breakeven data for the given signal using `signalId` as the entity key.
+     *
+     * @param data - Breakeven data record to persist
+     * @param signalId - Signal identifier
+     * @returns Promise that resolves when write is complete
+     */
+    async writeBreakevenData(data, signalId) {
+        await this._storage.writeValue(signalId, data);
+    }
+}
+/**
+ * No-op IPersistBreakevenInstance implementation used by PersistBreakevenUtils.useDummy().
+ * All reads return empty object, all writes are discarded.
+ */
+class PersistBreakevenDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistBreakevenInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty breakeven data record.
+     * @returns Promise resolving to {}
+     */
+    async readBreakevenData(_signalId) { return {}; }
+    /**
+     * No-op write (discards breakeven data).
+     * @returns Promise that resolves immediately
+     */
+    async writeBreakevenData(_data, _signalId) { }
+}
 /**
  * Persistence utility class for breakeven state management.
  *
  * Handles reading and writing breakeven state to disk.
- * Uses memoized PersistBase instances per symbol-strategy pair.
+ * Uses memoized PersistBreakevenInstance instances per symbol-strategy pair.
  *
  * Features:
  * - Atomic file writes via PersistBase.writeValue()
@@ -1783,53 +2126,36 @@ const PersistPartialAdapter = new PersistPartialUtils();
 class PersistBreakevenUtils {
     constructor() {
         /**
-         * Factory for creating PersistBase instances.
-         * Can be replaced via usePersistBreakevenAdapter().
+         * Constructor used to create per-context breakeven instances.
+         * Replaceable via usePersistBreakevenAdapter() / useJson() / useDummy().
          */
-        this.PersistBreakevenFactory = PersistBase;
+        this.PersistBreakevenInstanceCtor = PersistBreakevenInstance;
         /**
-         * Memoized storage factory for breakeven data.
-         * Creates one PersistBase instance per symbol-strategy-exchange combination.
-         * Key format: "symbol:strategyName:exchangeName"
-         *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @returns PersistBase instance for this symbol-strategy-exchange combination
+         * Memoized factory creating one IPersistBreakevenInstance per (symbol, strategy, exchange) triple.
+         * Each signal's breakeven data is stored under its own signalId within the instance.
          */
-        this.getBreakevenStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/breakeven/`,
-        ]));
+        this.getBreakevenStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenInstanceCtor, [symbol, strategyName, exchangeName]));
         /**
-         * Reads persisted breakeven data for a symbol and strategy.
-         *
-         * Called by ClientBreakeven.waitForInit() to restore state.
-         * Returns empty object if no breakeven data exists.
+         * Reads breakeven data for the given context and signalId.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to breakeven data record
+         * @returns Promise resolving to breakeven data record (empty object if none)
          */
         this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName) => {
             LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
-            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(signalId)) {
-                return await stateStorage.readValue(signalId);
-            }
-            return {};
+            const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readBreakevenData(signalId);
         };
         /**
-         * Writes breakeven data to disk.
-         *
-         * Called by ClientBreakeven._persistState() after state changes.
-         * Creates directory and file if they don't exist.
-         * Uses atomic writes to prevent data corruption.
+         * Writes breakeven data for the given context and signalId.
+         * Lazily initializes the instance on first access.
          *
          * @param breakevenData - Breakeven data record to persist
          * @param symbol - Trading pair symbol
@@ -1842,53 +2168,43 @@ class PersistBreakevenUtils {
             LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
-            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(signalId, breakevenData);
+            const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeBreakevenData(breakevenData, signalId);
         };
     }
     /**
-     * Registers a custom persistence adapter.
-     *
-     * @param Ctor - Custom PersistBase constructor
+     * Registers a custom IPersistBreakevenInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistBreakevenInstance constructor
      */
     usePersistBreakevenAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
-        this.PersistBreakevenFactory = Ctor;
+        this.PersistBreakevenInstanceCtor = Ctor;
+        this.getBreakevenStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
         this.getBreakevenStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistBreakevenInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistBreakevenAdapter(PersistBase);
+        this.usePersistBreakevenAdapter(PersistBreakevenInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistBreakevenDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistBreakevenAdapter(PersistDummy);
+        this.usePersistBreakevenAdapter(PersistBreakevenDummyInstance);
     }
 }
 /**
@@ -1908,6 +2224,140 @@ class PersistBreakevenUtils {
  * ```
  */
 const PersistBreakevenAdapter = new PersistBreakevenUtils();
+/**
+ * Default file-based implementation of IPersistCandleInstance.
+ *
+ * Features:
+ * - Each candle stored as a separate JSON file keyed by its timestamp
+ * - Read returns null on any missing timestamp (cache miss → refetch)
+ * - Write skips incomplete candles (closeTime > now) and existing keys
+ * - Invalid cached candles emit warnings via errorEmitter and treated as miss
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistCandleInstance("BTCUSDT", "1m", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeCandlesData(candles);
+ * const cached = await instance.readCandlesData(100, since, until);
+ * ```
+ */
+class PersistCandleInstance {
+    /**
+     * Creates new candle cache persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval (1m, 5m, 1h, etc.)
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, interval, exchangeName) {
+        this.symbol = symbol;
+        this.interval = interval;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${exchangeName}/${symbol}/${interval}`, `./dump/data/candle/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads cached candles for the requested window.
+     * Computes expected timestamps (sinceTimestamp + i * stepMs) and reads each
+     * by timestamp key. Returns null on ANY missing timestamp (cache miss).
+     * Invalid cached candles emit a warning via errorEmitter and are treated as miss.
+     *
+     * @param limit - Number of candles requested
+     * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+     * @param _untilTimestamp - Reserved for API compatibility, unused
+     * @returns Promise resolving to candles in order, or null on cache miss
+     */
+    async readCandlesData(limit, sinceTimestamp, _untilTimestamp) {
+        const stepMs = INTERVAL_MINUTES$9[this.interval] * MS_PER_MINUTE$7;
+        const cachedCandles = [];
+        for (let i = 0; i < limit; i++) {
+            const expectedTimestamp = sinceTimestamp + i * stepMs;
+            const timestampKey = String(expectedTimestamp);
+            if (await functoolsKit.not(this._storage.hasValue(timestampKey))) {
+                return null;
+            }
+            try {
+                const candle = await this._storage.readValue(timestampKey);
+                cachedCandles.push(candle);
+            }
+            catch (error) {
+                const message = `PersistCandleInstance.readCandlesData found invalid candle symbol=${this.symbol} interval=${this.interval} timestamp=${expectedTimestamp}`;
+                const payload = {
+                    error: functoolsKit.errorData(error),
+                    message: functoolsKit.getErrorMessage(error),
+                };
+                LOGGER_SERVICE$7.warn(message, payload);
+                console.warn(message, payload);
+                errorEmitter.next(error);
+                return null;
+            }
+        }
+        return cachedCandles;
+    }
+    /**
+     * Writes candles to cache.
+     * Skips incomplete candles (closeTime > now) and existing keys to keep
+     * the cache append-only for fully closed candles.
+     *
+     * @param candles - Array of candle data to cache
+     * @returns Promise that resolves when all writes are complete
+     */
+    async writeCandlesData(candles) {
+        const stepMs = INTERVAL_MINUTES$9[this.interval] * MS_PER_MINUTE$7;
+        const now = Date.now();
+        for (const candle of candles) {
+            const candleCloseTime = candle.timestamp + stepMs;
+            if (candleCloseTime > now) {
+                LOGGER_SERVICE$7.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
+                    symbol: this.symbol,
+                    interval: this.interval,
+                    exchangeName: this.exchangeName,
+                    timestamp: candle.timestamp,
+                    closeTime: candleCloseTime,
+                    now,
+                });
+                continue;
+            }
+            if (await functoolsKit.not(this._storage.hasValue(String(candle.timestamp)))) {
+                await this._storage.writeValue(String(candle.timestamp), candle);
+            }
+        }
+    }
+}
+/**
+ * No-op IPersistCandleInstance implementation used by PersistCandleUtils.useDummy().
+ * Always returns null on read (forces refetch), discards writes.
+ */
+class PersistCandleDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistCandleInstanceCtor.
+     */
+    constructor(_symbol, _interval, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (forces refetch via cache miss).
+     * @returns Promise resolving to null
+     */
+    async readCandlesData(_limit, _since, _until) { return null; }
+    /**
+     * No-op write (discards candles).
+     * @returns Promise that resolves immediately
+     */
+    async writeCandlesData(_candles) { }
+}
 /**
  * Utility class for managing candles cache persistence.
  *
@@ -1921,30 +2371,28 @@ const PersistBreakevenAdapter = new PersistBreakevenUtils();
  */
 class PersistCandleUtils {
     constructor() {
-        this.PersistCandlesFactory = PersistBase;
-        this.getCandlesStorage = functoolsKit.memoize(([symbol, interval, exchangeName]) => `${symbol}:${interval}:${exchangeName}`, (symbol, interval, exchangeName) => Reflect.construct(this.PersistCandlesFactory, [
-            `${exchangeName}/${symbol}/${interval}`,
-            `./dump/data/candle/`,
-        ]));
         /**
-         * Reads cached candles for a specific exchange, symbol, and interval.
-         * Returns candles only if cache contains ALL requested candles.
-         *
-         * Algorithm (matches ClientExchange.ts logic):
-         * 1. Calculate expected timestamps: sinceTimestamp, sinceTimestamp + stepMs, ..., sinceTimestamp + (limit-1) * stepMs
-         * 2. Try to read each expected candle by timestamp key
-         * 3. If ANY candle is missing, return null (cache miss)
-         * 4. If all candles found, return them in order
+         * Constructor used to create per-context candle cache instances.
+         * Replaceable via usePersistCandleAdapter() / useJson() / useDummy().
+         */
+        this.PersistCandleInstanceCtor = PersistCandleInstance;
+        /**
+         * Memoized factory creating one IPersistCandleInstance per (symbol, interval, exchange) triple.
+         */
+        this.getCandlesStorage = functoolsKit.memoize(([symbol, interval, exchangeName]) => `${symbol}:${interval}:${exchangeName}`, (symbol, interval, exchangeName) => Reflect.construct(this.PersistCandleInstanceCtor, [symbol, interval, exchangeName]));
+        /**
+         * Reads cached candles for the given context and time window.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
          * @param limit - Number of candles requested
          * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
-         * @param _untilTimestamp - Unused, kept for API compatibility
-         * @returns Promise resolving to array of candles or null if cache is incomplete
+         * @param untilTimestamp - Reserved for API compatibility
+         * @returns Promise resolving to candles in order, or null on cache miss
          */
-        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, _untilTimestamp) => {
+        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
             LOGGER_SERVICE$7.info("PersistCandleUtils.readCandlesData", {
                 symbol,
                 interval,
@@ -1954,47 +2402,15 @@ class PersistCandleUtils {
             });
             const key = `${symbol}:${interval}:${exchangeName}`;
             const isInitial = !this.getCandlesStorage.has(key);
-            const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            const stepMs = INTERVAL_MINUTES$9[interval] * MS_PER_MINUTE$7;
-            // Calculate expected timestamps and fetch each candle directly
-            const cachedCandles = [];
-            for (let i = 0; i < limit; i++) {
-                const expectedTimestamp = sinceTimestamp + i * stepMs;
-                const timestampKey = String(expectedTimestamp);
-                if (await functoolsKit.not(stateStorage.hasValue(timestampKey))) {
-                    // Cache miss - candle not found
-                    return null;
-                }
-                try {
-                    const candle = await stateStorage.readValue(timestampKey);
-                    cachedCandles.push(candle);
-                }
-                catch (error) {
-                    // Invalid candle in cache - treat as cache miss
-                    const message = `PersistCandleUtils.readCandlesData found invalid candle symbol=${symbol} interval=${interval} timestamp=${expectedTimestamp}`;
-                    const payload = {
-                        error: functoolsKit.errorData(error),
-                        message: functoolsKit.getErrorMessage(error),
-                    };
-                    LOGGER_SERVICE$7.warn(message, payload);
-                    console.warn(message, payload);
-                    errorEmitter.next(error);
-                    return null;
-                }
-            }
-            return cachedCandles;
+            const instance = this.getCandlesStorage(symbol, interval, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readCandlesData(limit, sinceTimestamp, untilTimestamp);
         };
         /**
-         * Writes candles to cache with atomic file writes.
-         * Each candle is stored as a separate JSON file named by its timestamp.
+         * Writes candles to cache for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * The candles passed to this function should be validated candles from the adapter:
-         * - First candle.timestamp equals aligned sinceTimestamp (openTime)
-         * - Exact number of candles as requested
-         * - All candles are fully closed (timestamp + stepMs < untilTimestamp)
-         *
-         * @param candles - Array of candle data to cache (validated by the caller)
+         * @param candles - Array of candle data to cache
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
@@ -2009,66 +2425,43 @@ class PersistCandleUtils {
             });
             const key = `${symbol}:${interval}:${exchangeName}`;
             const isInitial = !this.getCandlesStorage.has(key);
-            const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            // Calculate step in milliseconds to determine candle close time
-            const stepMs = INTERVAL_MINUTES$9[interval] * MS_PER_MINUTE$7;
-            const now = Date.now();
-            // Write each candle as a separate file, skipping incomplete candles
-            for (const candle of candles) {
-                // Skip incomplete candles: candle is complete when closeTime <= now
-                // closeTime = timestamp + stepMs
-                const candleCloseTime = candle.timestamp + stepMs;
-                if (candleCloseTime > now) {
-                    LOGGER_SERVICE$7.debug("PersistCandleUtils.writeCandlesData: skipping incomplete candle", {
-                        symbol,
-                        interval,
-                        exchangeName,
-                        timestamp: candle.timestamp,
-                        closeTime: candleCloseTime,
-                        now,
-                    });
-                    continue;
-                }
-                if (await functoolsKit.not(stateStorage.hasValue(String(candle.timestamp)))) {
-                    await stateStorage.writeValue(String(candle.timestamp), candle);
-                }
-            }
+            const instance = this.getCandlesStorage(symbol, interval, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeCandlesData(candles);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistCandleInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistCandleInstance constructor
      */
     usePersistCandleAdapter(Ctor) {
         LOGGER_SERVICE$7.info("PersistCandleUtils.usePersistCandleAdapter");
-        this.PersistCandlesFactory = Ctor;
+        this.PersistCandleInstanceCtor = Ctor;
+        this.getCandlesStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
         this.getCandlesStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistCandleInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log("PersistCandleUtils.useJson");
-        this.usePersistCandleAdapter(PersistBase);
+        this.usePersistCandleAdapter(PersistCandleInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistCandleDummyInstance (always returns null on read, discards writes).
      */
     useDummy() {
         LOGGER_SERVICE$7.log("PersistCandleUtils.useDummy");
-        this.usePersistCandleAdapter(PersistDummy);
+        this.usePersistCandleAdapter(PersistCandleDummyInstance);
     }
 }
 /**
@@ -2087,6 +2480,92 @@ class PersistCandleUtils {
  * ```
  */
 const PersistCandleAdapter = new PersistCandleUtils();
+/**
+ * Default file-based implementation of IPersistStorageInstance.
+ *
+ * Features:
+ * - Each signal stored as separate JSON file keyed by signal.id
+ * - Read iterates all keys via PersistBase.keys()
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistStorageInstance(false);
+ * await instance.waitForInit(true);
+ * await instance.writeStorageData(signals);
+ * const all = await instance.readStorageData();
+ * ```
+ */
+class PersistStorageInstance {
+    /**
+     * Creates new signal storage persistence instance.
+     *
+     * @param backtest - True for backtest mode storage, false for live mode
+     */
+    constructor(backtest) {
+        this.backtest = backtest;
+        this._storage = new PersistBase(backtest ? `backtest` : `live`, `./dump/data/storage/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads all persisted signals by iterating storage keys.
+     *
+     * @returns Promise resolving to array of signal entries
+     */
+    async readStorageData() {
+        const signals = [];
+        for await (const signalId of this._storage.keys()) {
+            const signal = await this._storage.readValue(signalId);
+            signals.push(signal);
+        }
+        return signals;
+    }
+    /**
+     * Writes each signal as a separate entity keyed by `signal.id`.
+     *
+     * @param signals - Signal entries to persist
+     * @returns Promise that resolves when all writes are complete
+     */
+    async writeStorageData(signals) {
+        for (const signal of signals) {
+            await this._storage.writeValue(signal.id, signal);
+        }
+    }
+}
+/**
+ * No-op IPersistStorageInstance implementation used by PersistStorageUtils.useDummy().
+ * All reads return empty array, all writes are discarded.
+ */
+class PersistStorageDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistStorageInstanceCtor.
+     */
+    constructor(_backtest) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty signals array.
+     * @returns Promise resolving to []
+     */
+    async readStorageData() { return []; }
+    /**
+     * No-op write (discards signals).
+     * @returns Promise that resolves immediately
+     */
+    async writeStorageData(_signals) { }
+}
 /**
  * Utility class for managing signal storage persistence.
  *
@@ -2101,89 +2580,80 @@ const PersistCandleAdapter = new PersistCandleUtils();
  */
 class PersistStorageUtils {
     constructor() {
-        this.PersistStorageFactory = PersistBase;
-        this.getStorage = functoolsKit.memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistStorageFactory, [
-            backtest ? `backtest` : `live`,
-            `./dump/data/storage/`,
-        ]));
         /**
-         * Reads persisted signals data.
-         *
-         * Called by StorageLiveUtils/StorageBacktestUtils.waitForInit() to restore state.
-         * Uses keys() from PersistBase to iterate over all stored signals.
-         * Returns empty array if no signals exist.
+         * Constructor used to create per-mode signal storage instances.
+         * Replaceable via usePersistStorageAdapter() / useJson() / useDummy().
+         */
+        this.PersistStorageInstanceCtor = PersistStorageInstance;
+        /**
+         * Memoized factory creating one IPersistStorageInstance per mode (backtest/live).
+         * Key: "backtest" or "live".
+         */
+        this.getStorage = functoolsKit.memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistStorageInstanceCtor, [backtest]));
+        /**
+         * Reads all persisted signals for the given mode.
+         * Lazily initializes the instance on first access.
          *
-         * @param backtest - If true, reads from backtest storage; otherwise from live storage
+         * @param backtest - True for backtest mode storage, false for live mode
          * @returns Promise resolving to array of signal entries
          */
         this.readStorageData = async (backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(backtest);
-            await stateStorage.waitForInit(isInitial);
-            const signals = [];
-            for await (const signalId of stateStorage.keys()) {
-                const signal = await stateStorage.readValue(signalId);
-                signals.push(signal);
-            }
-            return signals;
+            const instance = this.getStorage(backtest);
+            await instance.waitForInit(isInitial);
+            return instance.readStorageData();
         };
         /**
-         * Writes signal data to disk with atomic file writes.
-         *
-         * Called by StorageLiveUtils/StorageBacktestUtils after signal changes to persist state.
-         * Uses signal.id as the storage key for individual file storage.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes signals for the given mode.
+         * Lazily initializes the instance on first access.
          *
          * @param signalData - Signal entries to persist
-         * @param backtest - If true, writes to backtest storage; otherwise to live storage
+         * @param backtest - True for backtest mode storage, false for live mode
          * @returns Promise that resolves when write is complete
          */
         this.writeStorageData = async (signalData, backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(backtest);
-            await stateStorage.waitForInit(isInitial);
-            for (const signal of signalData) {
-                await stateStorage.writeValue(signal.id, signal);
-            }
+            const instance = this.getStorage(backtest);
+            await instance.waitForInit(isInitial);
+            return instance.writeStorageData(signalData);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistStorageInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistStorageInstance constructor
      */
     usePersistStorageAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
-        this.PersistStorageFactory = Ctor;
+        this.PersistStorageInstanceCtor = Ctor;
+        this.getStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistStorageInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistStorageAdapter(PersistBase);
+        this.usePersistStorageAdapter(PersistStorageInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistStorageDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistStorageAdapter(PersistDummy);
+        this.usePersistStorageAdapter(PersistStorageDummyInstance);
     }
 }
 /**
@@ -2191,6 +2661,92 @@ class PersistStorageUtils {
  * Used by SignalLiveUtils for signal storage persistence.
  */
 const PersistStorageAdapter = new PersistStorageUtils();
+/**
+ * Default file-based implementation of IPersistNotificationInstance.
+ *
+ * Features:
+ * - Each notification stored as separate JSON file keyed by id
+ * - Read iterates all keys via PersistBase.keys()
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistNotificationInstance(false);
+ * await instance.waitForInit(true);
+ * await instance.writeNotificationData(notifications);
+ * const all = await instance.readNotificationData();
+ * ```
+ */
+class PersistNotificationInstance {
+    /**
+     * Creates new notification persistence instance.
+     *
+     * @param backtest - True for backtest mode storage, false for live mode
+     */
+    constructor(backtest) {
+        this.backtest = backtest;
+        this._storage = new PersistBase(backtest ? `backtest` : `live`, `./dump/data/notification/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads all persisted notifications by iterating storage keys.
+     *
+     * @returns Promise resolving to array of notification entries
+     */
+    async readNotificationData() {
+        const notifications = [];
+        for await (const notificationId of this._storage.keys()) {
+            const notification = await this._storage.readValue(notificationId);
+            notifications.push(notification);
+        }
+        return notifications;
+    }
+    /**
+     * Writes each notification as a separate entity keyed by `notification.id`.
+     *
+     * @param notifications - Notification entries to persist
+     * @returns Promise that resolves when all writes are complete
+     */
+    async writeNotificationData(notifications) {
+        for (const notification of notifications) {
+            await this._storage.writeValue(notification.id, notification);
+        }
+    }
+}
+/**
+ * No-op IPersistNotificationInstance implementation used by PersistNotificationUtils.useDummy().
+ * All reads return empty array, all writes are discarded.
+ */
+class PersistNotificationDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistNotificationInstanceCtor.
+     */
+    constructor(_backtest) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty notifications array.
+     * @returns Promise resolving to []
+     */
+    async readNotificationData() { return []; }
+    /**
+     * No-op write (discards notifications).
+     * @returns Promise that resolves immediately
+     */
+    async writeNotificationData(_notifications) { }
+}
 /**
  * Utility class for managing notification persistence.
  *
@@ -2205,89 +2761,81 @@ const PersistStorageAdapter = new PersistStorageUtils();
  */
 class PersistNotificationUtils {
     constructor() {
-        this.PersistNotificationFactory = PersistBase;
-        this.getNotificationStorage = functoolsKit.memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistNotificationFactory, [
-            backtest ? `backtest` : `live`,
-            `./dump/data/notification/`,
-        ]));
         /**
-         * Reads persisted notifications data.
-         *
-         * Called by NotificationPersistLiveUtils/NotificationPersistBacktestUtils.waitForInit() to restore state.
-         * Uses keys() from PersistBase to iterate over all stored notifications.
-         * Returns empty array if no notifications exist.
+         * Constructor used to create per-mode notification instances.
+         * Replaceable via usePersistNotificationAdapter() / useJson() / useDummy().
+         */
+        this.PersistNotificationInstanceCtor = PersistNotificationInstance;
+        /**
+         * Memoized factory creating one IPersistNotificationInstance per mode (backtest/live).
+         * Key: "backtest" or "live".
+         */
+        this.getNotificationStorage = functoolsKit.memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistNotificationInstanceCtor, [backtest]));
+        /**
+         * Reads persisted notifications for the given mode.
+         * Lazily initializes the instance on first access.
          *
-         * @param backtest - If true, reads from backtest storage; otherwise from live storage
+         * @param backtest - True for backtest mode storage, false for live mode
          * @returns Promise resolving to array of notification entries
          */
         this.readNotificationData = async (backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
-            const stateStorage = this.getNotificationStorage(backtest);
-            await stateStorage.waitForInit(isInitial);
-            const notifications = [];
-            for await (const notificationId of stateStorage.keys()) {
-                const notification = await stateStorage.readValue(notificationId);
-                notifications.push(notification);
-            }
-            return notifications;
+            const instance = this.getNotificationStorage(backtest);
+            await instance.waitForInit(isInitial);
+            return instance.readNotificationData();
         };
         /**
-         * Writes notification data to disk with atomic file writes.
-         *
-         * Called by NotificationPersistLiveUtils/NotificationPersistBacktestUtils after notification changes to persist state.
-         * Uses notification.id as the storage key for individual file storage.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes notifications for the given mode.
+         * Lazily initializes the instance on first access.
          *
          * @param notificationData - Notification entries to persist
-         * @param backtest - If true, writes to backtest storage; otherwise to live storage
+         * @param backtest - True for backtest mode storage, false for live mode
          * @returns Promise that resolves when write is complete
          */
         this.writeNotificationData = async (notificationData, backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
-            const stateStorage = this.getNotificationStorage(backtest);
-            await stateStorage.waitForInit(isInitial);
-            for (const notification of notificationData) {
-                await stateStorage.writeValue(notification.id, notification);
-            }
+            const instance = this.getNotificationStorage(backtest);
+            await instance.waitForInit(isInitial);
+            return instance.writeNotificationData(notificationData);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistNotificationInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistNotificationInstance constructor
      */
     usePersistNotificationAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
-        this.PersistNotificationFactory = Ctor;
+        this.PersistNotificationInstanceCtor = Ctor;
+        this.getNotificationStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations so new
+     * instances are created with the updated base path.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
         this.getNotificationStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistNotificationInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistNotificationAdapter(PersistBase);
+        this.usePersistNotificationAdapter(PersistNotificationInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistNotificationDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistNotificationAdapter(PersistDummy);
+        this.usePersistNotificationAdapter(PersistNotificationDummyInstance);
     }
 }
 /**
@@ -2295,11 +2843,95 @@ class PersistNotificationUtils {
  * Used by NotificationPersistLiveUtils/NotificationPersistBacktestUtils for notification persistence.
  */
 const PersistNotificationAdapter = new PersistNotificationUtils();
+/**
+ * Default file-based implementation of IPersistLogInstance.
+ *
+ * Features:
+ * - Each log entry stored as separate JSON file keyed by entry.id
+ * - Read iterates all keys via PersistBase.keys()
+ * - Append-only: existing keys are skipped on write
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistLogInstance();
+ * await instance.waitForInit(true);
+ * await instance.writeLogData(entries);
+ * const all = await instance.readLogData();
+ * ```
+ */
+class PersistLogInstance {
+    /**
+     * Creates new log persistence instance.
+     * No context parameters — there is a single global log storage.
+     */
+    constructor() {
+        this._storage = new PersistBase(`log`, `./dump/data/log/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads all persisted log entries by iterating storage keys.
+     *
+     * @returns Promise resolving to array of log entries
+     */
+    async readLogData() {
+        const entries = [];
+        for await (const entryId of this._storage.keys()) {
+            const entry = await this._storage.readValue(entryId);
+            entries.push(entry);
+        }
+        return entries;
+    }
+    /**
+     * Writes log entries append-only — skips entries whose id already exists
+     * so the log file is never overwritten.
+     *
+     * @param logData - Log entries to persist
+     * @returns Promise that resolves when all writes are complete
+     */
+    async writeLogData(logData) {
+        for (const entry of logData) {
+            if (await this._storage.hasValue(entry.id)) {
+                continue;
+            }
+            await this._storage.writeValue(entry.id, entry);
+        }
+    }
+}
+/**
+ * No-op IPersistLogInstance implementation used by PersistLogUtils.useDummy().
+ * All reads return empty array, all writes are discarded.
+ */
+class PersistLogDummyInstance {
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty log entries array.
+     * @returns Promise resolving to []
+     */
+    async readLogData() { return []; }
+    /**
+     * No-op write (discards log entries).
+     * @returns Promise that resolves immediately
+     */
+    async writeLogData(_entries) { }
+}
 /**
  * Utility class for managing log entry persistence.
  *
  * Features:
- * - Memoized storage instance
+ * - Cached storage instance
  * - Custom adapter support
  * - Atomic read/write operations for LogData
  * - Each log entry stored as separate file keyed by id
@@ -2309,94 +2941,87 @@ const PersistNotificationAdapter = new PersistNotificationUtils();
  */
 class PersistLogUtils {
     constructor() {
-        this.PersistLogFactory = PersistBase;
-        this._logStorage = null;
         /**
-         * Reads persisted log entries.
-         *
-         * Called by LogPersistUtils.waitForInit() to restore state.
-         * Uses keys() from PersistBase to iterate over all stored entries.
-         * Returns empty array if no entries exist.
+         * Constructor used to create the global log instance.
+         * Replaceable via usePersistLogAdapter() / useJson() / useDummy().
+         */
+        this.PersistLogInstanceCtor = PersistLogInstance;
+        /**
+         * Cached singleton log instance. Lazily created on first access.
+         * Reset to null by clear() and usePersistLogAdapter().
+         */
+        this._logInstance = null;
+        /**
+         * Reads all persisted log entries.
+         * Lazily initializes the instance on first access.
          *
          * @returns Promise resolving to array of log entries
          */
         this.readLogData = async () => {
             LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
-            const isInitial = !this._logStorage;
-            const stateStorage = this.getLogStorage();
-            await stateStorage.waitForInit(isInitial);
-            const entries = [];
-            for await (const entryId of stateStorage.keys()) {
-                const entry = await stateStorage.readValue(entryId);
-                entries.push(entry);
-            }
-            return entries;
+            const isInitial = !this._logInstance;
+            const instance = this.getLogInstance();
+            await instance.waitForInit(isInitial);
+            return instance.readLogData();
         };
         /**
-         * Writes log entries to disk with atomic file writes.
-         *
-         * Called by LogPersistUtils after each log call to persist state.
-         * Uses entry.id as the storage key for individual file storage.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes log entries (append-only — duplicates by id are skipped).
+         * Lazily initializes the instance on first access.
          *
          * @param logData - Log entries to persist
          * @returns Promise that resolves when write is complete
          */
         this.writeLogData = async (logData) => {
             LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
-            const isInitial = !this._logStorage;
-            const stateStorage = this.getLogStorage();
-            await stateStorage.waitForInit(isInitial);
-            for (const entry of logData) {
-                if (await stateStorage.hasValue(entry.id)) {
-                    continue;
-                }
-                await stateStorage.writeValue(entry.id, entry);
-            }
+            const isInitial = !this._logInstance;
+            const instance = this.getLogInstance();
+            await instance.waitForInit(isInitial);
+            return instance.writeLogData(logData);
         };
     }
-    getLogStorage() {
-        if (!this._logStorage) {
-            this._logStorage = Reflect.construct(this.PersistLogFactory, [
-                `log`,
-                `./dump/data/log/`,
-            ]);
+    /**
+     * Returns the cached log instance, creating it on first access.
+     *
+     * @returns The IPersistLogInstance singleton
+     */
+    getLogInstance() {
+        if (!this._logInstance) {
+            this._logInstance = Reflect.construct(this.PersistLogInstanceCtor, []);
         }
-        return this._logStorage;
+        return this._logInstance;
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistLogInstance constructor.
+     * Drops the cached instance so the next access uses the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistLogInstance constructor
      */
     usePersistLogAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
-        this.PersistLogFactory = Ctor;
+        this.PersistLogInstanceCtor = Ctor;
+        this._logInstance = null;
     }
     /**
-     * Clears the cached storage instance.
-     * Call this when process.cwd() changes between strategy iterations
-     * so a new storage instance is created with the updated base path.
+     * Drops the cached log instance.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
-        this._logStorage = null;
+        this._logInstance = null;
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistLogInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistLogAdapter(PersistBase);
+        this.usePersistLogAdapter(PersistLogInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistLogDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistLogAdapter(PersistDummy);
+        this.usePersistLogAdapter(PersistLogDummyInstance);
     }
 }
 /**
@@ -2404,6 +3029,128 @@ class PersistLogUtils {
  * Used by LogPersistUtils for log entry persistence.
  */
 const PersistLogAdapter = new PersistLogUtils();
+/**
+ * Default file-based implementation of IPersistMeasureInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Soft delete via `removed: true` flag
+ * - listMeasureData filters out removed entries
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistMeasureInstance("my-bucket");
+ * await instance.waitForInit(true);
+ * await instance.writeMeasureData({ id: "x", data: {}, removed: false }, "key1");
+ * const data = await instance.readMeasureData("key1");
+ * await instance.removeMeasureData("key1");
+ * ```
+ */
+class PersistMeasureInstance {
+    /**
+     * Creates new measure cache persistence instance.
+     *
+     * @param bucket - Cache bucket identifier
+     */
+    constructor(bucket) {
+        this.bucket = bucket;
+        this._storage = new PersistBase(bucket, `./dump/data/measure/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads a measure entry by key. Returns null if entry is missing or soft-deleted.
+     *
+     * @param key - Cache key within the bucket
+     * @returns Promise resolving to entry data, or null
+     */
+    async readMeasureData(key) {
+        if (await this._storage.hasValue(key)) {
+            const data = await this._storage.readValue(key);
+            return data.removed ? null : data;
+        }
+        return null;
+    }
+    /**
+     * Writes a measure entry under the given key.
+     *
+     * @param data - Data to cache
+     * @param key - Cache key within the bucket
+     * @returns Promise that resolves when write is complete
+     */
+    async writeMeasureData(data, key) {
+        await this._storage.writeValue(key, data);
+    }
+    /**
+     * Soft-deletes an entry by writing `removed: true` flag while preserving the file.
+     *
+     * @param key - Cache key within the bucket
+     * @returns Promise that resolves when removal is complete
+     */
+    async removeMeasureData(key) {
+        const data = await this._storage.readValue(key);
+        if (data) {
+            await this._storage.writeValue(key, Object.assign({}, data, { removed: true }));
+        }
+    }
+    /**
+     * Iterates all entries in the bucket, yielding keys of non-removed entries only.
+     *
+     * @returns AsyncGenerator yielding entry keys
+     */
+    async *listMeasureData() {
+        for await (const key of this._storage.keys()) {
+            const data = await this._storage.readValue(String(key));
+            if (data === null || data.removed) {
+                continue;
+            }
+            yield String(key);
+        }
+    }
+}
+/**
+ * No-op IPersistMeasureInstance implementation used by PersistMeasureUtils.useDummy().
+ * All reads return null, all writes/removes are discarded, list yields nothing.
+ */
+class PersistMeasureDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistMeasureInstanceCtor.
+     */
+    constructor(_bucket) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no cached entries).
+     * @returns Promise resolving to null
+     */
+    async readMeasureData(_key) { return null; }
+    /**
+     * No-op write (discards entry).
+     * @returns Promise that resolves immediately
+     */
+    async writeMeasureData(_data, _key) { }
+    /**
+     * No-op remove.
+     * @returns Promise that resolves immediately
+     */
+    async removeMeasureData(_key) { }
+    /**
+     * Empty generator — yields no entries.
+     * @returns AsyncGenerator that immediately completes
+     */
+    async *listMeasureData() { }
+}
 /**
  * Utility class for managing external API response cache persistence.
  *
@@ -2417,124 +3164,108 @@ const PersistLogAdapter = new PersistLogUtils();
  */
 class PersistMeasureUtils {
     constructor() {
-        this.PersistMeasureFactory = PersistBase;
-        this.getMeasureStorage = functoolsKit.memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistMeasureFactory, [
-            bucket,
-            `./dump/data/measure/`,
-        ]));
         /**
-         * Reads cached measure data for a given bucket and key.
+         * Constructor used to create per-bucket measure cache instances.
+         * Replaceable via usePersistMeasureAdapter() / useJson() / useDummy().
+         */
+        this.PersistMeasureInstanceCtor = PersistMeasureInstance;
+        /**
+         * Memoized factory creating one IPersistMeasureInstance per bucket.
+         */
+        this.getMeasureStorage = functoolsKit.memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistMeasureInstanceCtor, [bucket]));
+        /**
+         * Reads a measure entry from the given bucket by key.
+         * Lazily initializes the bucket instance on first access.
          *
-         * @param bucket - Storage bucket (e.g. aligned timestamp + symbol)
-         * @param key - Dynamic cache key within the bucket
-         * @returns Promise resolving to cached value or null if not found
+         * @param bucket - Storage bucket identifier
+         * @param key - Cache key within the bucket
+         * @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$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
-            const stateStorage = this.getMeasureStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(key)) {
-                const data = await stateStorage.readValue(key);
-                return data.removed ? null : data;
-            }
-            return null;
+            const instance = this.getMeasureStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.readMeasureData(key);
         };
         /**
-         * Writes measure data to disk with atomic file writes.
+         * Writes a measure entry to the given bucket under the given key.
+         * Lazily initializes the bucket instance on first access.
          *
          * @param data - Data to cache
-         * @param bucket - Storage bucket (e.g. aligned timestamp + symbol)
-         * @param key - Dynamic cache key within the bucket
+         * @param bucket - Storage bucket identifier
+         * @param key - Cache key within the bucket
          * @returns Promise that resolves when write is complete
          */
         this.writeMeasureData = async (data, bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, {
-                bucket,
-                key,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
-            const stateStorage = this.getMeasureStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(key, data);
+            const instance = this.getMeasureStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.writeMeasureData(data, key);
         };
         /**
-         * Marks a cached entry as removed (soft delete — file is kept on disk).
-         * After this call `readMeasureData` for the same key returns `null`.
+         * Soft-deletes a measure entry in the given bucket by setting `removed: true`.
+         * Lazily initializes the bucket instance on first access.
          *
-         * @param bucket - Storage bucket
-         * @param key - Dynamic cache key within the bucket
+         * @param bucket - Storage bucket identifier
+         * @param key - Cache key within the bucket
          * @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$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
-            const stateStorage = this.getMeasureStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            const data = await stateStorage.readValue(key);
-            if (data) {
-                await stateStorage.writeValue(key, Object.assign({}, data, { removed: true }));
-            }
+            const instance = this.getMeasureStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.removeMeasureData(key);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistMeasureInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistMeasureInstance constructor
      */
     usePersistMeasureAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
-        this.PersistMeasureFactory = Ctor;
+        this.PersistMeasureInstanceCtor = Ctor;
+        this.getMeasureStorage.clear();
     }
     /**
-     * Async generator yielding all non-removed entity keys for a given bucket.
-     * Used by `CacheFileInstance.clear()` to iterate and soft-delete all entries.
+     * Iterates all non-removed measure entries for the given bucket.
+     * Lazily initializes the bucket instance on first access.
      *
-     * @param bucket - Storage bucket
-     * @returns AsyncGenerator yielding entity keys
+     * @param bucket - Storage bucket identifier
+     * @returns AsyncGenerator yielding entry keys
      */
     async *listMeasureData(bucket) {
         LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getMeasureStorage.has(bucket);
-        const stateStorage = this.getMeasureStorage(bucket);
-        await stateStorage.waitForInit(isInitial);
-        for await (const key of stateStorage.keys()) {
-            const data = await stateStorage.readValue(String(key));
-            if (data === null || data.removed) {
-                continue;
-            }
-            yield String(key);
-        }
+        const instance = this.getMeasureStorage(bucket);
+        await instance.waitForInit(isInitial);
+        yield* instance.listMeasureData();
     }
-    ;
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized bucket instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
         this.getMeasureStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
+     * Switches to the default file-based PersistMeasureInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistMeasureAdapter(PersistBase);
+        this.usePersistMeasureAdapter(PersistMeasureInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
+     * Switches to PersistMeasureDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistMeasureAdapter(PersistDummy);
+        this.usePersistMeasureAdapter(PersistMeasureDummyInstance);
     }
 }
 /**
@@ -2542,6 +3273,129 @@ class PersistMeasureUtils {
  * Used by Cache.file for persistent caching of external API responses.
  */
 const PersistMeasureAdapter = new PersistMeasureUtils();
+/**
+ * Default file-based implementation of IPersistIntervalInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Soft delete via `removed: true` flag
+ * - listIntervalData filters out removed markers
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistIntervalInstance("my-interval-bucket");
+ * await instance.waitForInit(true);
+ * await instance.writeIntervalData({ id: "x", data: {}, removed: false }, "key1");
+ * const marker = await instance.readIntervalData("key1");
+ * await instance.removeIntervalData("key1");
+ * ```
+ */
+class PersistIntervalInstance {
+    /**
+     * Creates new interval marker persistence instance.
+     *
+     * @param bucket - Marker bucket identifier
+     */
+    constructor(bucket) {
+        this.bucket = bucket;
+        this._storage = new PersistBase(bucket, `./dump/data/interval/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads an interval marker by key. Returns null if marker is missing or soft-deleted.
+     *
+     * @param key - Marker key within the bucket
+     * @returns Promise resolving to stored data, or null
+     */
+    async readIntervalData(key) {
+        if (await this._storage.hasValue(key)) {
+            const data = await this._storage.readValue(key);
+            return data.removed ? null : data;
+        }
+        return null;
+    }
+    /**
+     * Writes an interval marker under the given key.
+     *
+     * @param data - Data to store
+     * @param key - Marker key within the bucket
+     * @returns Promise that resolves when write is complete
+     */
+    async writeIntervalData(data, key) {
+        await this._storage.writeValue(key, data);
+    }
+    /**
+     * Soft-deletes a marker by writing `removed: true` flag while preserving the file.
+     * Subsequent reads will return null, allowing the interval to fire again.
+     *
+     * @param key - Marker key within the bucket
+     * @returns Promise that resolves when removal is complete
+     */
+    async removeIntervalData(key) {
+        const data = await this._storage.readValue(key);
+        if (data) {
+            await this._storage.writeValue(key, Object.assign({}, data, { removed: true }));
+        }
+    }
+    /**
+     * Iterates all markers in the bucket, yielding keys of non-removed markers only.
+     *
+     * @returns AsyncGenerator yielding marker keys
+     */
+    async *listIntervalData() {
+        for await (const key of this._storage.keys()) {
+            const data = await this._storage.readValue(String(key));
+            if (data === null || data.removed) {
+                continue;
+            }
+            yield String(key);
+        }
+    }
+}
+/**
+ * No-op IPersistIntervalInstance implementation used by PersistIntervalUtils.useDummy().
+ * All reads return null, all writes/removes are discarded, list yields nothing.
+ */
+class PersistIntervalDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistIntervalInstanceCtor.
+     */
+    constructor(_bucket) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no interval markers).
+     * @returns Promise resolving to null
+     */
+    async readIntervalData(_key) { return null; }
+    /**
+     * No-op write (discards marker).
+     * @returns Promise that resolves immediately
+     */
+    async writeIntervalData(_data, _key) { }
+    /**
+     * No-op remove.
+     * @returns Promise that resolves immediately
+     */
+    async removeIntervalData(_key) { }
+    /**
+     * Empty generator — yields no markers.
+     * @returns AsyncGenerator that immediately completes
+     */
+    async *listIntervalData() { }
+}
 /**
  * Persistence layer for Interval.file once-per-interval signal firing.
  *
@@ -2551,124 +3405,108 @@ const PersistMeasureAdapter = new PersistMeasureUtils();
  */
 class PersistIntervalUtils {
     constructor() {
-        this.PersistIntervalFactory = PersistBase;
-        this.getIntervalStorage = functoolsKit.memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistIntervalFactory, [
-            bucket,
-            `./dump/data/interval/`,
-        ]));
         /**
-         * Reads interval data for a given bucket and key.
+         * Constructor used to create per-bucket interval marker instances.
+         * Replaceable via usePersistIntervalAdapter() / useJson() / useDummy().
+         */
+        this.PersistIntervalInstanceCtor = PersistIntervalInstance;
+        /**
+         * Memoized factory creating one IPersistIntervalInstance per bucket.
+         */
+        this.getIntervalStorage = functoolsKit.memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistIntervalInstanceCtor, [bucket]));
+        /**
+         * Reads an interval marker from the given bucket by key.
+         * Lazily initializes the bucket instance on first access.
          *
-         * @param bucket - Storage bucket (instance name + interval + index)
-         * @param key - Entity key within the bucket (symbol + aligned timestamp)
-         * @returns Promise resolving to stored value or null if not found
+         * @param bucket - Storage bucket identifier
+         * @param key - Marker key within the bucket
+         * @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$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
-            const stateStorage = this.getIntervalStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(key)) {
-                const data = await stateStorage.readValue(key);
-                return data.removed ? null : data;
-            }
-            return null;
+            const instance = this.getIntervalStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.readIntervalData(key);
         };
         /**
-         * Writes interval data to disk.
+         * Writes an interval marker to the given bucket under the given key.
+         * Lazily initializes the bucket instance on first access.
          *
          * @param data - Data to store
-         * @param bucket - Storage bucket
-         * @param key - Entity key within the bucket
+         * @param bucket - Storage bucket identifier
+         * @param key - Marker key within the bucket
          * @returns Promise that resolves when write is complete
          */
         this.writeIntervalData = async (data, bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, {
-                bucket,
-                key,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
-            const stateStorage = this.getIntervalStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(key, data);
+            const instance = this.getIntervalStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.writeIntervalData(data, key);
         };
         /**
-         * Marks an interval entry as removed (soft delete — file is kept on disk).
-         * After this call `readIntervalData` for the same key returns `null`,
-         * so the function will fire again on the next `IntervalFileInstance.run` call.
+         * Soft-deletes a marker in the given bucket by setting `removed: true`.
+         * Lazily initializes the bucket instance on first access.
          *
-         * @param bucket - Storage bucket
-         * @param key - Entity key within the bucket
+         * @param bucket - Storage bucket identifier
+         * @param key - Marker key within the bucket
          * @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$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
-            const stateStorage = this.getIntervalStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            const data = await stateStorage.readValue(key);
-            if (data) {
-                await stateStorage.writeValue(key, Object.assign({}, data, { removed: true }));
-            }
+            const instance = this.getIntervalStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.removeIntervalData(key);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistIntervalInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistIntervalInstance constructor
      */
     usePersistIntervalAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
-        this.PersistIntervalFactory = Ctor;
+        this.PersistIntervalInstanceCtor = Ctor;
+        this.getIntervalStorage.clear();
     }
     /**
-     * Async generator yielding all non-removed entity keys for a given bucket.
-     * Used by `IntervalFileInstance.clear()` to iterate and soft-delete all entries.
+     * Iterates all non-removed markers for the given bucket.
+     * Lazily initializes the bucket instance on first access.
      *
-     * @param bucket - Storage bucket
-     * @returns AsyncGenerator yielding entity keys
+     * @param bucket - Storage bucket identifier
+     * @returns AsyncGenerator yielding marker keys
      */
     async *listIntervalData(bucket) {
         LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getIntervalStorage.has(bucket);
-        const stateStorage = this.getIntervalStorage(bucket);
-        await stateStorage.waitForInit(isInitial);
-        for await (const key of stateStorage.keys()) {
-            const data = await stateStorage.readValue(String(key));
-            if (data === null || data.removed) {
-                continue;
-            }
-            yield String(key);
-        }
+        const instance = this.getIntervalStorage(bucket);
+        await instance.waitForInit(isInitial);
+        yield* instance.listIntervalData();
     }
-    ;
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations.
+     * Clears the memoized bucket instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
         this.getIntervalStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
+     * Switches to the default file-based PersistIntervalInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistIntervalAdapter(PersistBase);
+        this.usePersistIntervalAdapter(PersistIntervalInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
+     * Switches to PersistIntervalDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistIntervalAdapter(PersistDummy);
+        this.usePersistIntervalAdapter(PersistIntervalDummyInstance);
     }
 }
 /**
@@ -2676,6 +3514,154 @@ class PersistIntervalUtils {
  * Used by Interval.file for persistent once-per-interval signal firing.
  */
 const PersistIntervalAdapter = new PersistIntervalUtils();
+/**
+ * Default file-based implementation of IPersistMemoryInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Soft delete via `removed: true` flag
+ * - listMemoryData filters out removed entries
+ * - dispose is a no-op (memo cache is managed by PersistMemoryUtils)
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistMemoryInstance("signal-1", "context-bucket");
+ * await instance.waitForInit(true);
+ * await instance.writeMemoryData(entryData, "memory-id-1");
+ * const data = await instance.readMemoryData("memory-id-1");
+ * ```
+ */
+class PersistMemoryInstance {
+    /**
+     * Creates new memory persistence instance.
+     *
+     * @param signalId - Signal identifier (entity folder name)
+     * @param bucketName - Bucket name (subfolder under memory/)
+     */
+    constructor(signalId, bucketName) {
+        this.signalId = signalId;
+        this.bucketName = bucketName;
+        this._storage = new PersistBase(bucketName, `./dump/memory/${signalId}/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads a memory entry by id. Returns null if entry is missing or soft-deleted.
+     *
+     * @param memoryId - Memory entry identifier
+     * @returns Promise resolving to entry data, or null
+     */
+    async readMemoryData(memoryId) {
+        if (await this._storage.hasValue(memoryId)) {
+            const data = await this._storage.readValue(memoryId);
+            return data.removed ? null : data;
+        }
+        return null;
+    }
+    /**
+     * Checks whether a memory entry exists on disk (regardless of removed flag).
+     *
+     * @param memoryId - Memory entry identifier
+     * @returns Promise resolving to true if entry file exists
+     */
+    async hasMemoryData(memoryId) {
+        return await this._storage.hasValue(memoryId);
+    }
+    /**
+     * Writes a memory entry under the given id.
+     *
+     * @param data - Entry data to persist
+     * @param memoryId - Memory entry identifier
+     * @returns Promise that resolves when write is complete
+     */
+    async writeMemoryData(data, memoryId) {
+        await this._storage.writeValue(memoryId, data);
+    }
+    /**
+     * Soft-deletes a memory entry by writing `removed: true` flag.
+     *
+     * @param memoryId - Memory entry identifier
+     * @returns Promise that resolves when removal is complete
+     */
+    async removeMemoryData(memoryId) {
+        const data = await this._storage.readValue(memoryId);
+        if (data) {
+            await this._storage.writeValue(memoryId, Object.assign({}, data, { removed: true }));
+        }
+    }
+    /**
+     * Iterates all memory entries in the bucket, yielding id + data tuples
+     * for non-removed entries only.
+     *
+     * @returns AsyncGenerator yielding `{ memoryId, data }` tuples
+     */
+    async *listMemoryData() {
+        for await (const memoryId of this._storage.keys()) {
+            const data = await this._storage.readValue(String(memoryId));
+            if (data === null || data.removed) {
+                continue;
+            }
+            yield { memoryId: String(memoryId), data };
+        }
+    }
+    /**
+     * No-op for the default file-based implementation.
+     * Resource cleanup (memo cache invalidation) is handled by PersistMemoryUtils.dispose().
+     */
+    dispose() { }
+}
+/**
+ * No-op IPersistMemoryInstance implementation used by PersistMemoryUtils.useDummy().
+ * All reads return null/false, all writes/removes are discarded, list yields nothing.
+ */
+class PersistMemoryDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistMemoryInstanceCtor.
+     */
+    constructor(_signalId, _bucketName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no memory entries).
+     * @returns Promise resolving to null
+     */
+    async readMemoryData(_memoryId) { return null; }
+    /**
+     * Always returns false (no memory entries exist).
+     * @returns Promise resolving to false
+     */
+    async hasMemoryData(_memoryId) { return false; }
+    /**
+     * No-op write (discards entry).
+     * @returns Promise that resolves immediately
+     */
+    async writeMemoryData(_data, _memoryId) { }
+    /**
+     * No-op remove.
+     * @returns Promise that resolves immediately
+     */
+    async removeMemoryData(_memoryId) { }
+    /**
+     * Empty generator — yields no entries.
+     * @returns AsyncGenerator that immediately completes
+     */
+    async *listMemoryData() { }
+    /**
+     * No-op dispose.
+     */
+    dispose() { }
+}
 /**
  * Utility class for managing memory entry persistence.
  *
@@ -2691,51 +3677,50 @@ const PersistIntervalAdapter = new PersistIntervalUtils();
  */
 class PersistMemoryUtils {
     constructor() {
-        this.PersistMemoryFactory = PersistBase;
-        this.getMemoryStorage = functoolsKit.memoize(([signalId, bucketName]) => `${signalId}:${bucketName}`, (signalId, bucketName) => Reflect.construct(this.PersistMemoryFactory, [
-            bucketName,
-            `./dump/memory/${signalId}/`,
-        ]));
         /**
-         * Initializes the storage for a given (signalId, bucketName) pair.
+         * Constructor used to create per-context memory instances.
+         * Replaceable via usePersistMemoryAdapter() / useJson() / useDummy().
+         */
+        this.PersistMemoryInstanceCtor = PersistMemoryInstance;
+        /**
+         * Memoized factory creating one IPersistMemoryInstance per (signalId, bucketName) pair.
+         */
+        this.getMemoryStorage = functoolsKit.memoize(([signalId, bucketName]) => `${signalId}:${bucketName}`, (signalId, bucketName) => Reflect.construct(this.PersistMemoryInstanceCtor, [signalId, bucketName]));
+        /**
+         * Initializes the memory storage for the given context.
+         * Skips initialization when `initial` is false (used to gate first-time setup).
          *
-         * @param signalId - Signal identifier (entity folder name)
-         * @param bucketName - Bucket name (subfolder under memory/)
+         * @param signalId - Signal identifier
+         * @param bucketName - Bucket name
          * @param initial - Whether this is the first initialization
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (signalId, bucketName, initial) => {
             const key = `${signalId}:${bucketName}`;
             const isInitial = initial && !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
         };
         /**
-         * Reads a memory entry from persistence storage.
+         * Reads a memory entry for the given context and id.
+         * Lazily initializes the instance on first access.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
          * @param memoryId - Memory entry identifier
-         * @returns Promise resolving to entry data or null if not found
+         * @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$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(memoryId)) {
-                const data = await stateStorage.readValue(memoryId);
-                return data.removed ? null : data;
-            }
-            return null;
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.readMemoryData(memoryId);
         };
         /**
-         * Checks if a memory entry exists in persistence storage.
+         * Checks whether a memory entry exists on disk for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
@@ -2743,19 +3728,16 @@ 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$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            return await stateStorage.hasValue(memoryId);
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.hasMemoryData(memoryId);
         };
         /**
-         * Writes a memory entry to disk with atomic file writes.
+         * Writes a memory entry for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param data - Entry data to persist
          * @param signalId - Signal identifier
@@ -2764,19 +3746,16 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMemoryData = async (data, signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, {
-                signalId,
-                bucketName,
-                memoryId,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(memoryId, data);
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.writeMemoryData(data, memoryId);
         };
         /**
-         * Marks a memory entry as removed (soft delete — file is kept on disk).
+         * Soft-deletes a memory entry for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
@@ -2784,36 +3763,27 @@ 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$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_REMOVE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            const data = await stateStorage.readValue(memoryId);
-            if (data) {
-                await stateStorage.writeValue(memoryId, Object.assign({}, data, { removed: true }));
-            }
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.removeMemoryData(memoryId);
         };
         /**
-         * Clears the memoized storage cache.
-         * Call this when process.cwd() changes between strategy iterations
-         * so new storage instances are created with the updated base path.
+         * Clears the memoized instance cache.
+         * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
             LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
             this.getMemoryStorage.clear();
         };
         /**
-         * Disposes of the memory adapter and releases any resources.
-         * Call this when a signal is removed to clean up its associated storage.
+         * Drops the memoized instance for the given context.
+         * Call when a signal is removed to clean up its associated storage entry.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
-         * @returns void
          */
         this.dispose = (signalId, bucketName) => {
             LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
@@ -2822,64 +3792,46 @@ class PersistMemoryUtils {
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistMemoryInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistMemoryAdapter.usePersistMemoryAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistMemoryInstance constructor
      */
     usePersistMemoryAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
-        this.PersistMemoryFactory = Ctor;
+        this.PersistMemoryInstanceCtor = Ctor;
+        this.getMemoryStorage.clear();
     }
     /**
-     * Lists all memory entry IDs for a given (signalId, bucketName) pair.
+     * Iterates all non-removed memory entries for the given context.
      * Used by MemoryPersistInstance to rebuild the BM25 index on init.
+     * Lazily initializes the instance on first access.
      *
      * @param signalId - Signal identifier
      * @param bucketName - Bucket name
-     * @returns AsyncGenerator yielding memory entry IDs
+     * @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$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA, { signalId, bucketName });
         const key = `${signalId}:${bucketName}`;
         const isInitial = !this.getMemoryStorage.has(key);
-        const stateStorage = this.getMemoryStorage(signalId, bucketName);
-        await stateStorage.waitForInit(isInitial);
-        for await (const memoryId of stateStorage.keys()) {
-            const data = await stateStorage.readValue(String(memoryId));
-            if (data === null || data.removed) {
-                continue;
-            }
-            yield { memoryId: String(memoryId), data };
-        }
+        const instance = this.getMemoryStorage(signalId, bucketName);
+        await instance.waitForInit(isInitial);
+        yield* instance.listMemoryData();
     }
-    ;
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistMemoryInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistMemoryAdapter(PersistBase);
+        this.usePersistMemoryAdapter(PersistMemoryInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistMemoryDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistMemoryAdapter(PersistDummy);
+        this.usePersistMemoryAdapter(PersistMemoryDummyInstance);
     }
 }
 /**
@@ -2899,6 +3851,100 @@ class PersistMemoryUtils {
  * ```
  */
 const PersistMemoryAdapter = new PersistMemoryUtils();
+/**
+ * Default file-based implementation of IPersistRecentInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses symbol as entity ID within a per-context PersistBase
+ * - Context key includes backtest/live mode and optional frameName
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistRecentInstance("BTCUSDT", "my-strategy", "binance", "frame-1", false);
+ * await instance.waitForInit(true);
+ * await instance.writeRecentData(publicSignalRow);
+ * const recent = await instance.readRecentData();
+ * ```
+ */
+class PersistRecentInstance {
+    /**
+     * Creates new recent signal persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     * @param frameName - Frame identifier (may be empty for live mode)
+     * @param backtest - True for backtest mode, false for live mode
+     */
+    constructor(symbol, strategyName, exchangeName, frameName, backtest) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        this.backtest = backtest;
+        const parts = [symbol, strategyName, exchangeName];
+        if (frameName)
+            parts.push(frameName);
+        parts.push(backtest ? "backtest" : "live");
+        this._storage = new PersistBase(parts.join("_"), `./dump/data/recent/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted recent signal using `symbol` as the entity key.
+     *
+     * @returns Promise resolving to recent signal or null if not found
+     */
+    async readRecentData() {
+        if (await this._storage.hasValue(this.symbol)) {
+            return await this._storage.readValue(this.symbol);
+        }
+        return null;
+    }
+    /**
+     * Writes the recent signal using `symbol` as the entity key.
+     *
+     * @param signalRow - Recent signal data to persist
+     * @returns Promise that resolves when write is complete
+     */
+    async writeRecentData(signalRow) {
+        await this._storage.writeValue(this.symbol, signalRow);
+    }
+}
+/**
+ * No-op IPersistRecentInstance implementation used by PersistRecentUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistRecentDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistRecentInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName, _frameName, _backtest) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no recent signal).
+     * @returns Promise resolving to null
+     */
+    async readRecentData() { return null; }
+    /**
+     * No-op write (discards recent signal).
+     * @returns Promise that resolves immediately
+     */
+    async writeRecentData(_signalRow) { }
+}
 /**
  * Utility class for managing recent signal persistence.
  *
@@ -2912,95 +3958,105 @@ const PersistMemoryAdapter = new PersistMemoryUtils();
  */
 class PersistRecentUtils {
     constructor() {
-        this.PersistRecentFactory = PersistBase;
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":"), (symbol, strategyName, exchangeName, frameName, backtest) => Reflect.construct(this.PersistRecentFactory, [
-            this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join("_"),
-            `./dump/data/recent/`,
-        ]));
         /**
-         * Reads the latest persisted recent signal for a given context.
-         *
-         * Returns null if no recent signal exists.
+         * Constructor used to create per-context recent signal instances.
+         * Replaceable via usePersistRecentAdapter() / useJson() / useDummy().
+         */
+        this.PersistRecentInstanceCtor = PersistRecentInstance;
+        /**
+         * Memoized factory creating one IPersistRecentInstance per context tuple.
+         */
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => this.createKey(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => Reflect.construct(this.PersistRecentInstanceCtor, [symbol, strategyName, exchangeName, frameName, backtest]));
+        /**
+         * Reads the latest recent signal for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
-         * @param frameName - Frame identifier
-         * @returns Promise resolving to recent signal or null
+         * @param frameName - Frame identifier (may be empty)
+         * @param backtest - True for backtest mode, false for live mode
+         * @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);
-            const key = this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":");
+            const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
-            }
-            return null;
+            const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await instance.waitForInit(isInitial);
+            return instance.readRecentData();
         };
         /**
-         * Writes the latest recent signal to disk with atomic file writes.
-         *
-         * Uses symbol as the entity ID within the per-context storage instance.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes the latest recent signal for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param signalRow - Recent signal data to persist
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
-         * @param frameName - Frame identifier
+         * @param frameName - Frame identifier (may be empty)
+         * @param backtest - True for backtest mode, false for live mode
          * @returns Promise that resolves when write is complete
          */
         this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
-            const key = this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":");
+            const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, signalRow);
+            const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await instance.waitForInit(isInitial);
+            return instance.writeRecentData(signalRow);
         };
     }
-    createKeyParts(symbol, strategyName, exchangeName, frameName, backtest) {
+    /**
+     * Builds the composite memoization key for a recent signal context.
+     * Includes optional frameName and the backtest/live mode flag.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     * @param frameName - Frame identifier (omitted from key if empty)
+     * @param backtest - True for backtest mode, false for live mode
+     * @returns Composite key string
+     */
+    createKey(symbol, strategyName, exchangeName, frameName, backtest) {
         const parts = [symbol, strategyName, exchangeName];
         if (frameName)
             parts.push(frameName);
         parts.push(backtest ? "backtest" : "live");
-        return parts;
+        return parts.join(":");
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistRecentInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistRecentInstance constructor
      */
     usePersistRecentAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
-        this.PersistRecentFactory = Ctor;
+        this.PersistRecentInstanceCtor = Ctor;
+        this.getStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistRecentInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistRecentAdapter(PersistBase);
+        this.usePersistRecentAdapter(PersistRecentInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistRecentDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistRecentAdapter(PersistDummy);
+        this.usePersistRecentAdapter(PersistRecentDummyInstance);
     }
 }
 /**
@@ -3008,6 +4064,99 @@ class PersistRecentUtils {
  * Used by RecentPersistBacktestUtils/RecentPersistLiveUtils for recent signal persistence.
  */
 const PersistRecentAdapter = new PersistRecentUtils();
+/**
+ * Default file-based implementation of IPersistStateInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses bucketName as entity ID within a per-signal PersistBase
+ * - dispose is a no-op (memo cache is managed by PersistStateUtils)
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistStateInstance("signal-1", "counter");
+ * await instance.waitForInit(true);
+ * await instance.writeStateData({ id: "counter", data: { count: 1 } });
+ * const state = await instance.readStateData();
+ * ```
+ */
+class PersistStateInstance {
+    /**
+     * Creates new state persistence instance.
+     *
+     * @param signalId - Signal identifier (folder name under state/)
+     * @param bucketName - Bucket name (file name)
+     */
+    constructor(signalId, bucketName) {
+        this.signalId = signalId;
+        this.bucketName = bucketName;
+        this._storage = new PersistBase(bucketName, `./dump/state/${signalId}/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted state using `bucketName` as the entity key.
+     *
+     * @returns Promise resolving to state data or null if not found
+     */
+    async readStateData() {
+        if (await this._storage.hasValue(this.bucketName)) {
+            return await this._storage.readValue(this.bucketName);
+        }
+        return null;
+    }
+    /**
+     * Writes the state using `bucketName` as the entity key.
+     *
+     * @param data - State data to persist
+     * @returns Promise that resolves when write is complete
+     */
+    async writeStateData(data) {
+        await this._storage.writeValue(this.bucketName, data);
+    }
+    /**
+     * No-op for the default file-based implementation.
+     * Resource cleanup (memo cache invalidation) is handled by PersistStateUtils.dispose().
+     */
+    dispose() { }
+}
+/**
+ * No-op IPersistStateInstance implementation used by PersistStateUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistStateDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistStateInstanceCtor.
+     */
+    constructor(_signalId, _bucketName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted state).
+     * @returns Promise resolving to null
+     */
+    async readStateData() { return null; }
+    /**
+     * No-op write (discards state).
+     * @returns Promise that resolves immediately
+     */
+    async writeStateData(_data) { }
+    /**
+     * No-op dispose.
+     */
+    dispose() { }
+}
 /**
  * Utility class for managing state persistence.
  *
@@ -3022,96 +4171,89 @@ const PersistRecentAdapter = new PersistRecentUtils();
  */
 class PersistStateUtils {
     constructor() {
-        this.PersistStateFactory = PersistBase;
-        this.getStateStorage = functoolsKit.memoize(([signalId, bucketName]) => `${signalId}:${bucketName}`, (signalId, bucketName) => Reflect.construct(this.PersistStateFactory, [
-            bucketName,
-            `./dump/state/${signalId}/`,
-        ]));
         /**
-         * Initializes the storage for a given (signalId, bucketName) pair.
+         * Constructor used to create per-context state instances.
+         * Replaceable via usePersistStateAdapter() / useJson() / useDummy().
+         */
+        this.PersistStateInstanceCtor = PersistStateInstance;
+        /**
+         * Memoized factory creating one IPersistStateInstance per (signalId, bucketName) pair.
+         */
+        this.getStateStorage = functoolsKit.memoize(([signalId, bucketName]) => `${signalId}:${bucketName}`, (signalId, bucketName) => Reflect.construct(this.PersistStateInstanceCtor, [signalId, bucketName]));
+        /**
+         * Initializes the state storage for the given context.
+         * Skips initialization when `initial` is false (used to gate first-time setup).
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
          * @param initial - Whether this is the first initialization
+         * @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$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WAIT_FOR_INIT, { signalId, bucketName, initial });
             const key = `${signalId}:${bucketName}`;
             const isInitial = initial && !this.getStateStorage.has(key);
-            const stateStorage = this.getStateStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
+            const instance = this.getStateStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
         };
         /**
-         * Reads a state entry from persistence storage.
+         * Reads persisted state for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
-         * @returns Promise resolving to entry data or null if not found
+         * @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$7.info(PERSIST_STATE_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
-            const stateStorage = this.getStateStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(bucketName)) {
-                return await stateStorage.readValue(bucketName);
-            }
-            return null;
+            const instance = this.getStateStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.readStateData();
         };
         /**
-         * Writes a state entry to disk with atomic file writes.
+         * Writes state for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * @param data - Entry data to persist
+         * @param data - State data to persist
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
+         * @returns Promise that resolves when write is complete
          */
         this.writeStateData = async (data, signalId, bucketName) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, {
-                signalId,
-                bucketName,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
-            const stateStorage = this.getStateStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(bucketName, data);
+            const instance = this.getStateStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.writeStateData(data);
         };
         /**
-         * Switches to a dummy persist adapter that discards all writes.
-         * All future persistence writes will be no-ops.
+         * Switches to PersistStateDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
             LOGGER_SERVICE$7.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
-            this.usePersistStateAdapter(PersistDummy);
+            this.usePersistStateAdapter(PersistStateDummyInstance);
         };
         /**
-         * Switches to the default JSON persist adapter.
-         * All future persistence writes will use JSON storage.
+         * Switches to the default file-based PersistStateInstance.
          */
         this.useJson = () => {
             LOGGER_SERVICE$7.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
-            this.usePersistStateAdapter(PersistBase);
+            this.usePersistStateAdapter(PersistStateInstance);
         };
         /**
-         * Clears the memoized storage cache.
-         * Call this when process.cwd() changes between strategy iterations
-         * so new storage instances are created with the updated base path.
+         * Clears the memoized instance cache.
+         * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
             LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
             this.getStateStorage.clear();
         };
         /**
-         * Disposes of the state adapter and releases any resources.
-         * Call this when a signal is removed to clean up its associated storage.
+         * Drops the memoized instance for the given context.
+         * Call when a signal is removed to clean up its associated storage entry.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
@@ -3123,13 +4265,15 @@ class PersistStateUtils {
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistStateInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistStateInstance constructor
      */
     usePersistStateAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
-        this.PersistStateFactory = Ctor;
+        this.PersistStateInstanceCtor = Ctor;
+        this.getStateStorage.clear();
     }
 }
 /**
@@ -3137,6 +4281,101 @@ class PersistStateUtils {
  * Used by StatePersistInstance for crash-safe state persistence.
  */
 const PersistStateAdapter = new PersistStateUtils();
+/**
+ * Default file-based implementation of IPersistSessionInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses frameName as entity ID within a per-strategy/exchange PersistBase
+ * - dispose is a no-op (memo cache is managed by PersistSessionUtils)
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistSessionInstance("my-strategy", "binance", "frame-1");
+ * await instance.waitForInit(true);
+ * await instance.writeSessionData({ id: "frame-1", data: { session: "state" } });
+ * const session = await instance.readSessionData();
+ * ```
+ */
+class PersistSessionInstance {
+    /**
+     * Creates new session persistence instance.
+     *
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     * @param frameName - Frame identifier (also used as entity ID)
+     */
+    constructor(strategyName, exchangeName, frameName) {
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        this._storage = new PersistBase(frameName, `./dump/session/${strategyName}/${exchangeName}/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted session data using `frameName` as the entity key.
+     *
+     * @returns Promise resolving to session data or null if not found
+     */
+    async readSessionData() {
+        if (await this._storage.hasValue(this.frameName)) {
+            return await this._storage.readValue(this.frameName);
+        }
+        return null;
+    }
+    /**
+     * Writes the session data using `frameName` as the entity key.
+     *
+     * @param data - Session data to persist
+     * @returns Promise that resolves when write is complete
+     */
+    async writeSessionData(data) {
+        await this._storage.writeValue(this.frameName, data);
+    }
+    /**
+     * No-op for the default file-based implementation.
+     * Resource cleanup (memo cache invalidation) is handled by PersistSessionUtils.dispose().
+     */
+    dispose() { }
+}
+/**
+ * No-op IPersistSessionInstance implementation used by PersistSessionUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistSessionDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistSessionInstanceCtor.
+     */
+    constructor(_strategyName, _exchangeName, _frameName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted session).
+     * @returns Promise resolving to null
+     */
+    async readSessionData() { return null; }
+    /**
+     * No-op write (discards session data).
+     * @returns Promise that resolves immediately
+     */
+    async writeSessionData(_data) { }
+    /**
+     * No-op dispose.
+     */
+    dispose() { }
+}
 /**
  * Utility class for managing session persistence.
  *
@@ -3151,102 +4390,93 @@ const PersistStateAdapter = new PersistStateUtils();
  */
 class PersistSessionUtils {
     constructor() {
-        this.PersistSessionFactory = PersistBase;
-        this.getSessionStorage = functoolsKit.memoize(([strategyName, exchangeName, frameName]) => `${strategyName}:${exchangeName}:${frameName}`, (strategyName, exchangeName, frameName) => Reflect.construct(this.PersistSessionFactory, [
-            frameName,
-            `./dump/session/${strategyName}/${exchangeName}/`,
-        ]));
         /**
-         * Initializes the storage for a given (strategyName, exchangeName, frameName) triple.
+         * Constructor used to create per-context session instances.
+         * Replaceable via usePersistSessionAdapter() / useJson() / useDummy().
+         */
+        this.PersistSessionInstanceCtor = PersistSessionInstance;
+        /**
+         * Memoized factory creating one IPersistSessionInstance per
+         * (strategyName, exchangeName, frameName) triple.
+         */
+        this.getSessionStorage = functoolsKit.memoize(([strategyName, exchangeName, frameName]) => `${strategyName}:${exchangeName}:${frameName}`, (strategyName, exchangeName, frameName) => Reflect.construct(this.PersistSessionInstanceCtor, [strategyName, exchangeName, frameName]));
+        /**
+         * Initializes the session storage for the given context.
+         * Skips initialization when `initial` is false (used to gate first-time setup).
          *
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
          * @param frameName - Frame identifier
          * @param initial - Whether this is the first initialization
+         * @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$7.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 sessionStorage = this.getSessionStorage(strategyName, exchangeName, frameName);
-            await sessionStorage.waitForInit(isInitial);
+            const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
+            await instance.waitForInit(isInitial);
         };
         /**
-         * Reads a session entry from persistence storage.
+         * Reads persisted session data for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
          * @param frameName - Frame identifier
-         * @returns Promise resolving to entry data or null if not found
+         * @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$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_READ_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
-            const sessionStorage = this.getSessionStorage(strategyName, exchangeName, frameName);
-            await sessionStorage.waitForInit(isInitial);
-            if (await sessionStorage.hasValue(frameName)) {
-                return await sessionStorage.readValue(frameName);
-            }
-            return null;
+            const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
+            await instance.waitForInit(isInitial);
+            return instance.readSessionData();
         };
         /**
-         * Writes a session entry to disk with atomic file writes.
+         * Writes session data for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * @param data - Entry data to persist
+         * @param data - Session data to persist
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
          * @param frameName - Frame identifier
+         * @returns Promise that resolves when write is complete
          */
         this.writeSessionData = async (data, strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, {
-                strategyName,
-                exchangeName,
-                frameName,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
-            const sessionStorage = this.getSessionStorage(strategyName, exchangeName, frameName);
-            await sessionStorage.waitForInit(isInitial);
-            await sessionStorage.writeValue(frameName, data);
+            const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
+            await instance.waitForInit(isInitial);
+            return instance.writeSessionData(data);
         };
         /**
-         * Switches to a dummy persist adapter that discards all writes.
-         * All future persistence writes will be no-ops.
+         * Switches to PersistSessionDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
             LOGGER_SERVICE$7.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
-            this.usePersistSessionAdapter(PersistDummy);
+            this.usePersistSessionAdapter(PersistSessionDummyInstance);
         };
         /**
-         * Switches to the default JSON persist adapter.
-         * All future persistence writes will use JSON storage.
+         * Switches to the default file-based PersistSessionInstance.
          */
         this.useJson = () => {
             LOGGER_SERVICE$7.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
-            this.usePersistSessionAdapter(PersistBase);
+            this.usePersistSessionAdapter(PersistSessionInstance);
         };
         /**
-         * Clears the memoized storage cache.
-         * Call this when process.cwd() changes between strategy iterations
-         * so new storage instances are created with the updated base path.
+         * Clears the memoized instance cache.
+         * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
             LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
             this.getSessionStorage.clear();
         };
         /**
-         * Disposes of the session adapter and releases any resources.
-         * Call this when a session is removed to clean up its associated storage.
+         * Drops the memoized instance for the given context.
+         * Call when a session is removed to clean up its associated storage entry.
          *
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
@@ -3259,13 +4489,15 @@ class PersistSessionUtils {
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistSessionInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistSessionInstance constructor
      */
     usePersistSessionAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
-        this.PersistSessionFactory = Ctor;
+        this.PersistSessionInstanceCtor = Ctor;
+        this.getSessionStorage.clear();
     }
 }
 /**
@@ -6697,7 +7929,7 @@ const CALL_PARTIAL_CLEAR_FN = functoolsKit.trycatch(beginTime(async (self, symbo
 });
 const CALL_RISK_CHECK_SIGNAL_FN = functoolsKit.trycatch(beginTime(async (self, symbol, pendingSignal, currentPrice, timestamp, backtest) => {
     return await ExecutionContextService.runInContext(async () => {
-        return await self.params.risk.checkSignal({
+        return await self.params.risk.checkSignalAndReserve({
             currentSignal: TO_PUBLIC_SIGNAL("scheduled", pendingSignal, currentPrice),
             symbol: symbol,
             strategyName: self.params.method.context.strategyName,
@@ -10578,6 +11810,7 @@ class ClientStrategy {
 }
 
 const RISK_METHOD_NAME_CHECK_SIGNAL = "MergeRisk.checkSignal";
+const RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE = "MergeRisk.checkSignalAndReserve";
 const RISK_METHOD_NAME_ADD_SIGNAL = "MergeRisk.addSignal";
 const RISK_METHOD_NAME_REMOVE_SIGNAL = "MergeRisk.removeSignal";
 /** Logger service injected as DI singleton */
@@ -10636,7 +11869,7 @@ class MergeRisk {
      * @param params - Risk check parameters (symbol, strategy, position, exchange)
      * @returns Promise resolving to true if all risks approve, false if any risk rejects
      */
-    async checkSignal(params) {
+    async checkSignal(params, options = {}) {
         LOGGER_SERVICE$5.info(RISK_METHOD_NAME_CHECK_SIGNAL, {
             params,
         });
@@ -10644,6 +11877,36 @@ class MergeRisk {
             if (await functoolsKit.not(risk.checkSignal({
                 ...params,
                 riskName,
+            }, options))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Concurrency-safe variant of {@link checkSignal} — validates the signal AND
+     * reserves a placeholder in every child risk's active position map atomically.
+     *
+     * Iterates child risks sequentially. On the first rejection it returns false
+     * immediately; child risks checked earlier in the loop are left with their
+     * reservations in place — `removeSignal` on the parent will roll them back
+     * (it propagates to all children unconditionally).
+     *
+     * Use from strategy execution paths where the caller will follow up with
+     * `addSignal` on success. See {@link IRisk.checkSignalAndReserve} for the
+     * full rationale on why reserving inside the lock is necessary.
+     *
+     * @param params - Risk check parameters (symbol, strategy, position, exchange)
+     * @returns Promise resolving to true if all risks approve (and reserved), false if any risk rejects
+     */
+    async checkSignalAndReserve(params) {
+        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE, {
+            params,
+        });
+        for (const [riskName, risk] of Object.entries(this._riskMap)) {
+            if (await functoolsKit.not(risk.checkSignalAndReserve({
+                ...params,
+                riskName,
             }))) {
                 return false;
             }
@@ -10753,6 +12016,7 @@ const CALL_SIGNAL_EMIT_FN = functoolsKit.trycatch(beginTime(async (self, tick, c
  */
 const NOOP_RISK = {
     checkSignal: () => Promise.resolve(true),
+    checkSignalAndReserve: () => Promise.resolve(true),
     addSignal: () => Promise.resolve(),
     removeSignal: () => Promise.resolve(),
 };
@@ -12928,6 +14192,8 @@ const alignToInterval = (date, interval) => {
     return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
 };
 
+/** Used to prevent race confition between concurent strategies */
+const RISK_LOCK = new Lock();
 /** Symbol indicating that positions need to be fetched from persistence */
 const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
 /** Get timestamp from execution context or fallback to aligned current time */
@@ -13113,60 +14379,115 @@ class ClientRisk {
          * @param params - Risk check arguments (passthrough from ClientStrategy)
          * @returns Promise resolving to true if allowed, false if rejected
          */
-        this.checkSignal = async (params) => {
+        this.checkSignal = async (params, options = {}) => {
             this.params.logger.debug("ClientRisk checkSignal", {
                 symbol: params.symbol,
                 strategyName: params.strategyName,
                 backtest: this.params.backtest,
             });
-            if (this._activePositions === POSITION_NEED_FETCH) {
-                await this.waitForInit();
-            }
-            const riskMap = this._activePositions;
-            const timestamp = GET_CONTEXT_TIMESTAMP_FN(this);
-            const payload = {
-                ...params,
-                currentSignal: TO_RISK_SIGNAL(params.currentSignal, params.currentPrice, timestamp),
-                activePositionCount: riskMap.size,
-                activePositions: Array.from(riskMap.values()),
-            };
-            let rejectionResult = null;
-            if (this.params.validations) {
-                for (const validation of this.params.validations) {
-                    const rejection = await DO_VALIDATION_FN(this, typeof validation === "function" ? validation : validation.validate, payload);
-                    if (!rejection) {
-                        continue;
-                    }
-                    if (typeof rejection === "string") {
-                        rejectionResult = {
-                            id: null,
-                            note: rejection
-                                ? rejection
-                                : "note" in validation
-                                    ? validation.note
-                                    : "Validation failed",
-                        };
-                        break;
-                    }
-                    if (functoolsKit.isObject(rejection)) {
-                        rejectionResult = {
-                            id: get(rejection, "id") || null,
-                            note: get(rejection, "note") || "Validation rejected the signal",
-                        };
-                        break;
+            await RISK_LOCK.acquireLock();
+            try {
+                if (this._activePositions === POSITION_NEED_FETCH) {
+                    await this.waitForInit();
+                }
+                const riskMap = this._activePositions;
+                const timestamp = GET_CONTEXT_TIMESTAMP_FN(this);
+                const payload = {
+                    ...params,
+                    currentSignal: TO_RISK_SIGNAL(params.currentSignal, params.currentPrice, timestamp),
+                    activePositionCount: riskMap.size,
+                    activePositions: Array.from(riskMap.values()),
+                };
+                let rejectionResult = null;
+                if (this.params.validations) {
+                    for (const validation of this.params.validations) {
+                        const rejection = await DO_VALIDATION_FN(this, typeof validation === "function" ? validation : validation.validate, payload);
+                        if (!rejection) {
+                            continue;
+                        }
+                        if (typeof rejection === "string") {
+                            rejectionResult = {
+                                id: null,
+                                note: rejection
+                                    ? rejection
+                                    : "note" in validation
+                                        ? validation.note
+                                        : "Validation failed",
+                            };
+                            break;
+                        }
+                        if (functoolsKit.isObject(rejection)) {
+                            rejectionResult = {
+                                id: get(rejection, "id") || null,
+                                note: get(rejection, "note") || "Validation rejected the signal",
+                            };
+                            break;
+                        }
                     }
                 }
+                if (rejectionResult) {
+                    // Call params.onRejected for riskSubject emission
+                    await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, params.timestamp, this.params.backtest);
+                    // Call schema callbacks.onRejected if defined
+                    await CALL_REJECTED_CALLBACKS_FN(this, params.symbol, params);
+                    return false;
+                }
+                // Optional placeholder reservation: when caller plans to addSignal next,
+                // pre-write into riskMap inside the same critical section so concurrent
+                // checkSignal calls observe the incremented size before addSignal lands.
+                // The placeholder shares the same key as the future addSignal — it will
+                // be overwritten with real position data, not duplicated.
+                if (options?.reserve) {
+                    const reserveKey = CREATE_NAME_FN(params.strategyName, params.exchangeName, params.symbol);
+                    const signal = params.currentSignal;
+                    riskMap.set(reserveKey, {
+                        strategyName: params.strategyName,
+                        exchangeName: params.exchangeName,
+                        frameName: params.frameName,
+                        symbol: params.symbol,
+                        position: signal.position,
+                        priceOpen: signal.priceOpen ?? params.currentPrice,
+                        priceStopLoss: signal.priceStopLoss,
+                        priceTakeProfit: signal.priceTakeProfit,
+                        minuteEstimatedTime: signal.minuteEstimatedTime,
+                        openTimestamp: timestamp,
+                    });
+                }
+                // All checks passed
+                await CALL_ALLOWED_CALLBACKS_FN(this, params.symbol, params);
+                return true;
             }
-            if (rejectionResult) {
-                // Call params.onRejected for riskSubject emission
-                await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, params.timestamp, this.params.backtest);
-                // Call schema callbacks.onRejected if defined
-                await CALL_REJECTED_CALLBACKS_FN(this, params.symbol, params);
-                return false;
+            finally {
+                await RISK_LOCK.releaseLock();
             }
-            // All checks passed
-            await CALL_ALLOWED_CALLBACKS_FN(this, params.symbol, params);
-            return true;
+        };
+        /**
+         * Concurrency-safe variant of {@link checkSignal}: validates the signal AND
+         * reserves a placeholder slot in the active position map atomically.
+         *
+         * **Why this exists.** `checkSignal` followed later by `addSignal` is not
+         * atomic — between the two calls the caller does signal setup work that
+         * yields to the event loop (sync-open callback, persist writes, etc.). When
+         * several strategies sharing the same risk profile run in parallel, all of
+         * them can pass `checkSignal` while the active position map is still empty,
+         * then each call `addSignal` and blow past the limit. Reserving inside the
+         * lock guarantees the next concurrent caller observes the incremented size
+         * before its own validation runs.
+         *
+         * The reservation uses the same map key as the eventual `addSignal` call
+         * (`strategyName + exchangeName + symbol`), so `addSignal` overwrites the
+         * placeholder rather than appending a duplicate.
+         *
+         * Callers MUST ensure that every successful return is followed by either
+         * `addSignal` (overwrites the placeholder with real data) or `removeSignal`
+         * (clears the placeholder if opening is aborted). Otherwise the riskMap
+         * accumulates stale reservations.
+         *
+         * @param params - Risk check arguments (passthrough from ClientStrategy)
+         * @returns Promise resolving to true if allowed (and reserved), false if rejected (no reservation)
+         */
+        this.checkSignalAndReserve = async (params) => {
+            return await this.checkSignal(params, { reserve: true });
         };
     }
     /**
@@ -13193,24 +14514,30 @@ class ClientRisk {
             positionData,
             backtest: this.params.backtest,
         });
-        if (this._activePositions === POSITION_NEED_FETCH) {
-            await this.waitForInit();
+        await RISK_LOCK.acquireLock();
+        try {
+            if (this._activePositions === POSITION_NEED_FETCH) {
+                await this.waitForInit();
+            }
+            const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
+            const riskMap = this._activePositions;
+            riskMap.set(key, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                symbol,
+                position: positionData.position,
+                priceOpen: positionData.priceOpen,
+                priceStopLoss: positionData.priceStopLoss,
+                priceTakeProfit: positionData.priceTakeProfit,
+                minuteEstimatedTime: positionData.minuteEstimatedTime,
+                openTimestamp: positionData.openTimestamp,
+            });
+            await this._updatePositions();
+        }
+        finally {
+            await RISK_LOCK.releaseLock();
         }
-        const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
-        const riskMap = this._activePositions;
-        riskMap.set(key, {
-            strategyName: context.strategyName,
-            exchangeName: context.exchangeName,
-            frameName: context.frameName,
-            symbol,
-            position: positionData.position,
-            priceOpen: positionData.priceOpen,
-            priceStopLoss: positionData.priceStopLoss,
-            priceTakeProfit: positionData.priceTakeProfit,
-            minuteEstimatedTime: positionData.minuteEstimatedTime,
-            openTimestamp: positionData.openTimestamp,
-        });
-        await this._updatePositions();
     }
     /**
      * Removes a closed signal.
@@ -13222,13 +14549,19 @@ class ClientRisk {
             context,
             backtest: this.params.backtest,
         });
-        if (this._activePositions === POSITION_NEED_FETCH) {
-            await this.waitForInit();
+        await RISK_LOCK.acquireLock();
+        try {
+            if (this._activePositions === POSITION_NEED_FETCH) {
+                await this.waitForInit();
+            }
+            const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
+            const riskMap = this._activePositions;
+            riskMap.delete(key);
+            await this._updatePositions();
+        }
+        finally {
+            await RISK_LOCK.releaseLock();
         }
-        const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
-        const riskMap = this._activePositions;
-        riskMap.delete(key);
-        await this._updatePositions();
     }
 }
 
@@ -13363,12 +14696,33 @@ class RiskConnectionService {
          * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
          * @returns Promise resolving to risk check result
          */
-        this.checkSignal = async (params, payload) => {
+        this.checkSignal = async (params, payload, options = {}) => {
             this.loggerService.log("riskConnectionService checkSignal", {
                 symbol: params.symbol,
                 payload,
             });
-            return await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).checkSignal(params);
+            return await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).checkSignal(params, options);
+        };
+        /**
+         * Concurrency-safe variant of {@link checkSignal} — validates the signal AND
+         * reserves a placeholder in the active position map atomically.
+         *
+         * Routes to the same ClientRisk instance as {@link checkSignal} but delegates
+         * to its `checkSignalAndReserve` method. Use from execution paths where the
+         * caller will follow up with `addSignal` on success — guarantees concurrent
+         * callers cannot all pass validation against a stale empty map. See
+         * {@link IRisk.checkSignalAndReserve} for the full rationale.
+         *
+         * @param params - Risk check arguments (portfolio state, position details)
+         * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
+         * @returns Promise resolving to true if allowed (and reserved), false if rejected (no reservation)
+         */
+        this.checkSignalAndReserve = async (params, payload) => {
+            this.loggerService.log("riskConnectionService checkSignalAndReserve", {
+                symbol: params.symbol,
+                payload,
+            });
+            return await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).checkSignalAndReserve(params);
         };
         /**
          * Registers an opened signal with the risk management system.
@@ -16572,13 +17926,34 @@ class RiskGlobalService {
          * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
          * @returns Promise resolving to risk check result
          */
-        this.checkSignal = async (params, payload) => {
+        this.checkSignal = async (params, payload, options = {}) => {
             this.loggerService.log("riskGlobalService checkSignal", {
                 symbol: params.symbol,
                 payload,
             });
             await this.validate(payload);
-            return await this.riskConnectionService.checkSignal(params, payload);
+            return await this.riskConnectionService.checkSignal(params, payload, options);
+        };
+        /**
+         * Concurrency-safe variant of {@link checkSignal} — validates the signal AND
+         * reserves a placeholder in the active position map atomically.
+         *
+         * Use from strategy execution paths where the caller will follow up with
+         * `addSignal` on success — guarantees concurrent callers cannot all pass
+         * validation against a stale empty map. See {@link IRisk.checkSignalAndReserve}
+         * for the full rationale.
+         *
+         * @param params - Risk check arguments (portfolio state, position details)
+         * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
+         * @returns Promise resolving to true if allowed (and reserved), false if rejected (no reservation)
+         */
+        this.checkSignalAndReserve = async (params, payload) => {
+            this.loggerService.log("riskGlobalService checkSignalAndReserve", {
+                symbol: params.symbol,
+                payload,
+            });
+            await this.validate(payload);
+            return await this.riskConnectionService.checkSignalAndReserve(params, payload);
         };
         /**
          * Registers an opened signal with the risk management system.
@@ -61977,20 +63352,35 @@ exports.Partial = Partial;
 exports.Performance = Performance;
 exports.PersistBase = PersistBase;
 exports.PersistBreakevenAdapter = PersistBreakevenAdapter;
+exports.PersistBreakevenInstance = PersistBreakevenInstance;
 exports.PersistCandleAdapter = PersistCandleAdapter;
+exports.PersistCandleInstance = PersistCandleInstance;
 exports.PersistIntervalAdapter = PersistIntervalAdapter;
+exports.PersistIntervalInstance = PersistIntervalInstance;
 exports.PersistLogAdapter = PersistLogAdapter;
+exports.PersistLogInstance = PersistLogInstance;
 exports.PersistMeasureAdapter = PersistMeasureAdapter;
+exports.PersistMeasureInstance = PersistMeasureInstance;
 exports.PersistMemoryAdapter = PersistMemoryAdapter;
+exports.PersistMemoryInstance = PersistMemoryInstance;
 exports.PersistNotificationAdapter = PersistNotificationAdapter;
+exports.PersistNotificationInstance = PersistNotificationInstance;
 exports.PersistPartialAdapter = PersistPartialAdapter;
+exports.PersistPartialInstance = PersistPartialInstance;
 exports.PersistRecentAdapter = PersistRecentAdapter;
+exports.PersistRecentInstance = PersistRecentInstance;
 exports.PersistRiskAdapter = PersistRiskAdapter;
+exports.PersistRiskInstance = PersistRiskInstance;
 exports.PersistScheduleAdapter = PersistScheduleAdapter;
+exports.PersistScheduleInstance = PersistScheduleInstance;
 exports.PersistSessionAdapter = PersistSessionAdapter;
+exports.PersistSessionInstance = PersistSessionInstance;
 exports.PersistSignalAdapter = PersistSignalAdapter;
+exports.PersistSignalInstance = PersistSignalInstance;
 exports.PersistStateAdapter = PersistStateAdapter;
+exports.PersistStateInstance = PersistStateInstance;
 exports.PersistStorageAdapter = PersistStorageAdapter;
+exports.PersistStorageInstance = PersistStorageInstance;
 exports.Position = Position;
 exports.PositionSize = PositionSize;
 exports.Recent = Recent;