backtest-kit 6.8.1 → 6.10.0

package/build/index.mjs

@@ -888,7 +888,7 @@ const LOGGER_SERVICE$7 = new LoggerService();
 /** Symbol key for the singleshot waitForInit function on PersistBase instances. */
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 // Calculate step in milliseconds for candle close time validation
-const INTERVAL_MINUTES$8 = {
+const INTERVAL_MINUTES$9 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -902,7 +902,7 @@ const INTERVAL_MINUTES$8 = {
     "1d": 1440,
     "1w": 10080,
 };
-const MS_PER_MINUTE$6 = 60000;
+const MS_PER_MINUTE$7 = 60000;
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistSignalUtils.writeSignalData";
@@ -961,8 +961,18 @@ const PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA = "PersistMeasureUtils.readMea
 const PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA = "PersistMeasureUtils.writeMeasureData";
 const PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON = "PersistMeasureUtils.useJson";
 const PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY = "PersistMeasureUtils.useDummy";
+const PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA = "PersistMeasureUtils.removeMeasureData";
+const PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA = "PersistMeasureUtils.listMeasureData";
 const PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR = "PersistMeasureUtils.clear";
 const PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER = "PersistMeasureUtils.usePersistMeasureAdapter";
+const PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA = "PersistIntervalUtils.readIntervalData";
+const PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistIntervalUtils.writeIntervalData";
+const PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON = "PersistIntervalUtils.useJson";
+const PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistIntervalUtils.useDummy";
+const PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA = "PersistIntervalUtils.removeIntervalData";
+const PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA = "PersistIntervalUtils.listIntervalData";
+const PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR = "PersistIntervalUtils.clear";
+const PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER = "PersistIntervalUtils.usePersistIntervalAdapter";
 const PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR = "PersistCandleUtils.clear";
 const PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER = "PersistMemoryUtils.usePersistMemoryAdapter";
 const PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA = "PersistMemoryUtils.readMemoryData";
@@ -1875,7 +1885,7 @@ class PersistCandleUtils {
             const isInitial = !this.getCandlesStorage.has(key);
             const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            const stepMs = INTERVAL_MINUTES$8[interval] * MS_PER_MINUTE$6;
+            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++) {
@@ -1931,7 +1941,7 @@ class PersistCandleUtils {
             const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
             // Calculate step in milliseconds to determine candle close time
-            const stepMs = INTERVAL_MINUTES$8[interval] * MS_PER_MINUTE$6;
+            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) {
@@ -2357,7 +2367,8 @@ class PersistMeasureUtils {
             const stateStorage = this.getMeasureStorage(bucket);
             await stateStorage.waitForInit(isInitial);
             if (await stateStorage.hasValue(key)) {
-                return await stateStorage.readValue(key);
+                const data = await stateStorage.readValue(key);
+                return data.removed ? null : data;
             }
             return null;
         };
@@ -2379,6 +2390,27 @@ class PersistMeasureUtils {
             await stateStorage.waitForInit(isInitial);
             await stateStorage.writeValue(key, data);
         };
+        /**
+         * Marks a cached entry as removed (soft delete — file is kept on disk).
+         * After this call `readMeasureData` for the same key returns `null`.
+         *
+         * @param bucket - Storage bucket
+         * @param key - Dynamic 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,
+            });
+            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 }));
+            }
+        };
     }
     /**
      * Registers a custom persistence adapter.
@@ -2389,6 +2421,27 @@ class PersistMeasureUtils {
         LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
         this.PersistMeasureFactory = Ctor;
     }
+    /**
+     * Async generator yielding all non-removed entity keys for a given bucket.
+     * Used by `CacheFileInstance.clear()` to iterate and soft-delete all entries.
+     *
+     * @param bucket - Storage bucket
+     * @returns AsyncGenerator yielding entity 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);
+        }
+    }
+    ;
     /**
      * Clears the memoized storage cache.
      * Call this when process.cwd() changes between strategy iterations
@@ -2418,6 +2471,140 @@ class PersistMeasureUtils {
  * Used by Cache.file for persistent caching of external API responses.
  */
 const PersistMeasureAdapter = new PersistMeasureUtils();
+/**
+ * Persistence layer for Interval.file once-per-interval signal firing.
+ *
+ * Stores fired-interval markers under `./dump/data/interval/`.
+ * A record's presence means the interval has already fired for that bucket+key;
+ * absence means the function has not yet fired (or returned null last time).
+ */
+class PersistIntervalUtils {
+    constructor() {
+        this.PersistIntervalFactory = PersistBase;
+        this.getIntervalStorage = memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistIntervalFactory, [
+            bucket,
+            `./dump/data/interval/`,
+        ]));
+        /**
+         * Reads interval data for a given bucket and key.
+         *
+         * @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
+         */
+        this.readIntervalData = async (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;
+        };
+        /**
+         * Writes interval data to disk.
+         *
+         * @param data - Data to store
+         * @param bucket - Storage bucket
+         * @param key - Entity 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,
+            });
+            const isInitial = !this.getIntervalStorage.has(bucket);
+            const stateStorage = this.getIntervalStorage(bucket);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(key, data);
+        };
+        /**
+         * 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.
+         *
+         * @param bucket - Storage bucket
+         * @param key - Entity 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,
+            });
+            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 }));
+            }
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     */
+    usePersistIntervalAdapter(Ctor) {
+        LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
+        this.PersistIntervalFactory = Ctor;
+    }
+    /**
+     * Async generator yielding all non-removed entity keys for a given bucket.
+     * Used by `IntervalFileInstance.clear()` to iterate and soft-delete all entries.
+     *
+     * @param bucket - Storage bucket
+     * @returns AsyncGenerator yielding entity 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);
+        }
+    }
+    ;
+    /**
+     * Clears the memoized storage cache.
+     * Call this 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.
+     */
+    useJson() {
+        LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistIntervalAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     */
+    useDummy() {
+        LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistIntervalAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistIntervalUtils.
+ * Used by Interval.file for persistent once-per-interval signal firing.
+ */
+const PersistIntervalAdapter = new PersistIntervalUtils();
 /**
  * Utility class for managing memory entry persistence.
  *
@@ -2765,8 +2952,8 @@ class CandleUtils {
 }
 const Candle = new CandleUtils();
 
-const MS_PER_MINUTE$5 = 60000;
-const INTERVAL_MINUTES$7 = {
+const MS_PER_MINUTE$6 = 60000;
+const INTERVAL_MINUTES$8 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -2798,7 +2985,7 @@ const INTERVAL_MINUTES$7 = {
  * @returns Aligned timestamp rounded down to interval boundary
  */
 const ALIGN_TO_INTERVAL_FN$2 = (timestamp, intervalMinutes) => {
-    const intervalMs = intervalMinutes * MS_PER_MINUTE$5;
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$6;
     return Math.floor(timestamp / intervalMs) * intervalMs;
 };
 /**
@@ -2952,9 +3139,9 @@ const WRITE_CANDLES_CACHE_FN$1 = trycatch(queued(async (candles, dto, self) => {
  * @returns Promise resolving to array of candle data
  */
 const GET_CANDLES_FN$1 = async (dto, since, self) => {
-    const step = INTERVAL_MINUTES$7[dto.interval];
+    const step = INTERVAL_MINUTES$8[dto.interval];
     const sinceTimestamp = since.getTime();
-    const untilTimestamp = sinceTimestamp + dto.limit * step * MS_PER_MINUTE$5;
+    const untilTimestamp = sinceTimestamp + dto.limit * step * MS_PER_MINUTE$6;
     await Candle.acquireLock(`ClientExchange GET_CANDLES_FN symbol=${dto.symbol} interval=${dto.interval} limit=${dto.limit}`);
     try {
         // Try to read from cache first
@@ -3068,11 +3255,11 @@ class ClientExchange {
             interval,
             limit,
         });
-        const step = INTERVAL_MINUTES$7[interval];
+        const step = INTERVAL_MINUTES$8[interval];
         if (!step) {
             throw new Error(`ClientExchange unknown interval=${interval}`);
         }
-        const stepMs = step * MS_PER_MINUTE$5;
+        const stepMs = step * MS_PER_MINUTE$6;
         // Align when down to interval boundary
         const whenTimestamp = this.params.execution.context.when.getTime();
         const alignedWhen = ALIGN_TO_INTERVAL_FN$2(whenTimestamp, step);
@@ -3149,11 +3336,11 @@ class ClientExchange {
         if (!this.params.execution.context.backtest) {
             throw new Error(`ClientExchange getNextCandles: cannot fetch future candles in live mode`);
         }
-        const step = INTERVAL_MINUTES$7[interval];
+        const step = INTERVAL_MINUTES$8[interval];
         if (!step) {
             throw new Error(`ClientExchange getNextCandles: unknown interval=${interval}`);
         }
-        const stepMs = step * MS_PER_MINUTE$5;
+        const stepMs = step * MS_PER_MINUTE$6;
         const now = Date.now();
         // Align when down to interval boundary
         const whenTimestamp = this.params.execution.context.when.getTime();
@@ -3317,11 +3504,11 @@ class ClientExchange {
             sDate,
             eDate,
         });
-        const step = INTERVAL_MINUTES$7[interval];
+        const step = INTERVAL_MINUTES$8[interval];
         if (!step) {
             throw new Error(`ClientExchange getRawCandles: unknown interval=${interval}`);
         }
-        const stepMs = step * MS_PER_MINUTE$5;
+        const stepMs = step * MS_PER_MINUTE$6;
         const whenTimestamp = this.params.execution.context.when.getTime();
         const alignedWhen = ALIGN_TO_INTERVAL_FN$2(whenTimestamp, step);
         let sinceTimestamp;
@@ -3450,7 +3637,7 @@ class ClientExchange {
         const alignedTo = ALIGN_TO_INTERVAL_FN$2(whenTimestamp, GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES);
         const to = new Date(alignedTo);
         const from = new Date(alignedTo -
-            GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$5);
+            GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$6);
         return await this.params.getOrderBook(symbol, depth, from, to, this.params.execution.context.backtest);
     }
     /**
@@ -3479,7 +3666,7 @@ class ClientExchange {
         const whenTimestamp = this.params.execution.context.when.getTime();
         // Align to 1-minute boundary to prevent look-ahead bias
         const alignedTo = ALIGN_TO_INTERVAL_FN$2(whenTimestamp, 1);
-        const windowMs = GLOBAL_CONFIG.CC_AGGREGATED_TRADES_MAX_MINUTES * MS_PER_MINUTE$5 - MS_PER_MINUTE$5;
+        const windowMs = GLOBAL_CONFIG.CC_AGGREGATED_TRADES_MAX_MINUTES * MS_PER_MINUTE$6 - MS_PER_MINUTE$6;
         // No limit: fetch a single window and return as-is
         if (limit === undefined) {
             const to = new Date(alignedTo);
@@ -4458,7 +4645,7 @@ const validateScheduledSignal = (signal, currentPrice) => {
     }
 };
 
-const INTERVAL_MINUTES$6 = {
+const INTERVAL_MINUTES$7 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -4842,7 +5029,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     }
     const currentTime = self.params.execution.context.when.getTime();
     {
-        const intervalMinutes = INTERVAL_MINUTES$6[self.params.interval];
+        const intervalMinutes = INTERVAL_MINUTES$7[self.params.interval];
         const intervalMs = intervalMinutes * 60 * 1000;
         const alignedTime = Math.floor(currentTime / intervalMs) * intervalMs;
         // Проверяем что наступил новый интервал (по aligned timestamp)
@@ -7783,6 +7970,90 @@ class ClientStrategy {
         }
         return this._pendingSignal._fall.pnlCost;
     }
+    /**
+     * Returns the distance in PnL percentage between the current price and the highest profit peak.
+     *
+     * Measures how much PnL% the position has given back from its best point.
+     * Computed as: max(0, peakPnlPercentage - currentPnlPercentage).
+     * Zero when called at the exact moment the peak was set, or when current PnL >= peak PnL.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to drawdown distance in PnL% (≥ 0) or null
+     */
+    async getPositionHighestProfitDistancePnlPercentage(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionHighestProfitDistancePnlPercentage", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return Math.max(0, this._pendingSignal._peak.pnlPercentage - currentPnl.pnlPercentage);
+    }
+    /**
+     * Returns the distance in PnL cost between the current price and the highest profit peak.
+     *
+     * Measures how much PnL cost the position has given back from its best point.
+     * Computed as: max(0, peakPnlCost - currentPnlCost).
+     * Zero when called at the exact moment the peak was set, or when current PnL >= peak PnL.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to drawdown distance in PnL cost (≥ 0) or null
+     */
+    async getPositionHighestProfitDistancePnlCost(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionHighestProfitDistancePnlCost", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return Math.max(0, this._pendingSignal._peak.pnlCost - currentPnl.pnlCost);
+    }
+    /**
+     * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+     *
+     * Measures how much the position has recovered from its deepest loss point.
+     * Computed as: max(0, currentPnlPercentage - fallPnlPercentage).
+     * Zero when called at the exact moment the trough was set, or when current PnL <= trough PnL.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to recovery distance in PnL% (≥ 0) or null
+     */
+    async getPositionHighestMaxDrawdownPnlPercentage(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionHighestMaxDrawdownPnlPercentage", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return Math.max(0, currentPnl.pnlPercentage - this._pendingSignal._fall.pnlPercentage);
+    }
+    /**
+     * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+     *
+     * Measures how much the position has recovered from its deepest loss point.
+     * Computed as: max(0, currentPnlCost - fallPnlCost).
+     * Zero when called at the exact moment the trough was set, or when current PnL <= trough PnL.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to recovery distance in PnL cost (≥ 0) or null
+     */
+    async getPositionHighestMaxDrawdownPnlCost(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionHighestMaxDrawdownPnlCost", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return Math.max(0, currentPnl.pnlCost - this._pendingSignal._fall.pnlCost);
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -9866,7 +10137,7 @@ const GET_RISK_FN = (dto, backtest, exchangeName, frameName, self) => {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$s = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$t = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -10133,7 +10404,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$s(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$t(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -10890,6 +11161,90 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionMaxDrawdownPnlCost(symbol);
         };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getPositionHighestProfitDistancePnlPercentage().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to drawdown distance in PnL% (≥ 0) or null
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestProfitDistancePnlPercentage", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            return await strategy.getPositionHighestProfitDistancePnlPercentage(symbol, currentPrice);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getPositionHighestProfitDistancePnlCost().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to drawdown distance in PnL cost (≥ 0) or null
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestProfitDistancePnlCost", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            return await strategy.getPositionHighestProfitDistancePnlCost(symbol, currentPrice);
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getPositionHighestMaxDrawdownPnlPercentage().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to recovery distance in PnL% (≥ 0) or null
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestMaxDrawdownPnlPercentage", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            return await strategy.getPositionHighestMaxDrawdownPnlPercentage(symbol, currentPrice);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getPositionHighestMaxDrawdownPnlCost().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to recovery distance in PnL cost (≥ 0) or null
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestMaxDrawdownPnlCost", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            return await strategy.getPositionHighestMaxDrawdownPnlCost(symbol, currentPrice);
+        };
         /**
          * Disposes the ClientStrategy instance for the given context.
          *
@@ -10928,7 +11283,7 @@ class StrategyConnectionService {
                 }
                 return;
             }
-            const key = CREATE_KEY_FN$s(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$t(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getStrategy.has(key)) {
                 return;
             }
@@ -11330,7 +11685,7 @@ class StrategyConnectionService {
  * Maps FrameInterval to minutes for timestamp calculation.
  * Used to generate timeframe arrays with proper spacing.
  */
-const INTERVAL_MINUTES$5 = {
+const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -11386,7 +11741,7 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
         symbol,
     });
     const { interval, startDate, endDate } = self.params;
-    const intervalMinutes = INTERVAL_MINUTES$5[interval];
+    const intervalMinutes = INTERVAL_MINUTES$6[interval];
     if (!intervalMinutes) {
         throw new Error(`ClientFrame unknown interval: ${interval}`);
     }
@@ -11751,8 +12106,8 @@ const get = (object, path) => {
     return pathArrayFlat.reduce((obj, key) => obj && obj[key], object);
 };
 
-const MS_PER_MINUTE$4 = 60000;
-const INTERVAL_MINUTES$4 = {
+const MS_PER_MINUTE$5 = 60000;
+const INTERVAL_MINUTES$5 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -11784,11 +12139,11 @@ const INTERVAL_MINUTES$4 = {
  * @returns New Date aligned down to interval boundary
  */
 const alignToInterval = (date, interval) => {
-    const minutes = INTERVAL_MINUTES$4[interval];
+    const minutes = INTERVAL_MINUTES$5[interval];
     if (minutes === undefined) {
         throw new Error(`alignToInterval: unknown interval=${interval}`);
     }
-    const intervalMs = minutes * MS_PER_MINUTE$4;
+    const intervalMs = minutes * MS_PER_MINUTE$5;
     return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
 };
 
@@ -12097,7 +12452,7 @@ class ClientRisk {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$r = (riskName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$s = (riskName, exchangeName, frameName, backtest) => {
     const parts = [riskName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -12197,7 +12552,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$r(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$s(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
@@ -12266,7 +12621,7 @@ class RiskConnectionService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$r(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$s(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -13310,7 +13665,7 @@ class ClientAction {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$q = (actionName, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$r = (actionName, strategyName, exchangeName, frameName, backtest) => {
     const parts = [actionName, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -13362,7 +13717,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$q(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$r(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
             const schema = this.actionSchemaService.get(actionName);
             return new ClientAction({
                 ...schema,
@@ -13573,7 +13928,7 @@ class ActionConnectionService {
                 await Promise.all(actions.map(async (action) => await action.dispose()));
                 return;
             }
-            const key = CREATE_KEY_FN$q(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$r(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getAction.has(key)) {
                 return;
             }
@@ -13591,7 +13946,7 @@ const METHOD_NAME_VALIDATE$2 = "exchangeCoreService validate";
  * @param exchangeName - Exchange name
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$p = (exchangeName) => {
+const CREATE_KEY_FN$q = (exchangeName) => {
     return exchangeName;
 };
 /**
@@ -13615,7 +13970,7 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$p(exchangeName), async (exchangeName) => {
+        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$q(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -13867,7 +14222,7 @@ const METHOD_NAME_VALIDATE$1 = "strategyCoreService validate";
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$o = (context) => {
+const CREATE_KEY_FN$p = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -13899,7 +14254,7 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$p(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -15051,6 +15406,82 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.getPositionMaxDrawdownPnlCost(backtest, symbol, context);
         };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Delegates to StrategyConnectionService.getPositionHighestProfitDistancePnlPercentage().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to drawdown distance in PnL% (≥ 0) or null
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestProfitDistancePnlPercentage", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestProfitDistancePnlPercentage(backtest, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Delegates to StrategyConnectionService.getPositionHighestProfitDistancePnlCost().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to drawdown distance in PnL cost (≥ 0) or null
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestProfitDistancePnlCost", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestProfitDistancePnlCost(backtest, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Delegates to StrategyConnectionService.getPositionHighestMaxDrawdownPnlPercentage().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to recovery distance in PnL% (≥ 0) or null
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestMaxDrawdownPnlPercentage", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestMaxDrawdownPnlPercentage(backtest, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Delegates to StrategyConnectionService.getPositionHighestMaxDrawdownPnlCost().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to recovery distance in PnL cost (≥ 0) or null
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestMaxDrawdownPnlCost", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestMaxDrawdownPnlCost(backtest, symbol, context);
+        };
     }
 }
 
@@ -15123,7 +15554,7 @@ class SizingGlobalService {
  * @param context - Context with riskName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$n = (context) => {
+const CREATE_KEY_FN$o = (context) => {
     const parts = [context.riskName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -15149,7 +15580,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$n(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -15227,7 +15658,7 @@ const METHOD_NAME_VALIDATE = "actionCoreService validate";
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$m = (context) => {
+const CREATE_KEY_FN$n = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -15271,7 +15702,7 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$m(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$n(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -16866,8 +17297,8 @@ class BacktestLogicPrivateService {
 }
 
 const EMITTER_CHECK_INTERVAL = 5000;
-const MS_PER_MINUTE$3 = 60000;
-const INTERVAL_MINUTES$3 = {
+const MS_PER_MINUTE$4 = 60000;
+const INTERVAL_MINUTES$4 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -16883,7 +17314,7 @@ const INTERVAL_MINUTES$3 = {
 };
 const createEmitter = memoize(([interval]) => `${interval}`, (interval) => {
     const tickSubject = new Subject();
-    const intervalMs = INTERVAL_MINUTES$3[interval] * MS_PER_MINUTE$3;
+    const intervalMs = INTERVAL_MINUTES$4[interval] * MS_PER_MINUTE$4;
     {
         let lastAligned = Math.floor(Date.now() / intervalMs) * intervalMs;
         Source.fromInterval(EMITTER_CHECK_INTERVAL)
@@ -20267,7 +20698,7 @@ const ReportWriter = new ReportWriterAdapter();
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$l = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$m = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -20513,7 +20944,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$l(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$a(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$m(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$a(symbol, strategyName, exchangeName, frameName));
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -20670,7 +21101,7 @@ class BacktestMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$l(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$m(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -20732,7 +21163,7 @@ class BacktestMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$k = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$l = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -21227,7 +21658,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$k(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$9(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$l(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$9(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to live signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -21445,7 +21876,7 @@ class LiveMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$k(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$l(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -21465,7 +21896,7 @@ class LiveMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$j = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$k = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -21754,7 +22185,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$j(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$k(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to signal emitter to receive scheduled signal events.
          * Protected against multiple subscriptions.
@@ -21957,7 +22388,7 @@ class ScheduleMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$j(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$k(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -21977,7 +22408,7 @@ class ScheduleMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$i = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$j = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -22222,7 +22653,7 @@ class PerformanceMarkdownService {
          * Memoized function to get or create PerformanceStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$i(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$j(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to performance emitter to receive performance events.
          * Protected against multiple subscriptions.
@@ -22389,7 +22820,7 @@ class PerformanceMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$i(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$j(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -22868,7 +23299,7 @@ class WalkerMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$h = (exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$i = (exchangeName, frameName, backtest) => {
     const parts = [exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -23315,7 +23746,7 @@ class HeatMarkdownService {
          * Memoized function to get or create HeatmapStorage for exchange, frame and backtest mode.
          * Each exchangeName + frameName + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$h(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$i(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
         /**
          * Subscribes to signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -23533,7 +23964,7 @@ class HeatMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$h(payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$i(payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -24564,7 +24995,7 @@ class ClientPartial {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$g = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$h = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting profit events to partialProfitSubject.
  *
@@ -24686,7 +25117,7 @@ class PartialConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$g(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$h(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -24776,7 +25207,7 @@ class PartialConnectionService {
             const partial = this.getPartial(data.id, backtest);
             await partial.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
             await partial.clear(symbol, data, priceClose, backtest);
-            const key = CREATE_KEY_FN$g(data.id, backtest);
+            const key = CREATE_KEY_FN$h(data.id, backtest);
             this.getPartial.clear(key);
         };
     }
@@ -24792,7 +25223,7 @@ class PartialConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$f = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$g = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -25015,7 +25446,7 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$f(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$g(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to partial profit/loss signal emitters to receive events.
          * Protected against multiple subscriptions.
@@ -25225,7 +25656,7 @@ class PartialMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$f(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$g(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -25241,7 +25672,7 @@ class PartialMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$e = (context) => {
+const CREATE_KEY_FN$f = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -25315,7 +25746,7 @@ class PartialGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$e(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$f(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -25770,7 +26201,7 @@ class ClientBreakeven {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$d = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$e = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting breakeven events to breakevenSubject.
  *
@@ -25856,7 +26287,7 @@ class BreakevenConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientBreakeven instance with logger and event emitter
          */
-        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$d(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$e(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -25917,7 +26348,7 @@ class BreakevenConnectionService {
             const breakeven = this.getBreakeven(data.id, backtest);
             await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
             await breakeven.clear(symbol, data, priceClose, backtest);
-            const key = CREATE_KEY_FN$d(data.id, backtest);
+            const key = CREATE_KEY_FN$e(data.id, backtest);
             this.getBreakeven.clear(key);
         };
     }
@@ -25933,7 +26364,7 @@ class BreakevenConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$c = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$d = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -26108,7 +26539,7 @@ class BreakevenMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$c(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$5(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$d(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$5(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to breakeven signal emitter to receive events.
          * Protected against multiple subscriptions.
@@ -26297,7 +26728,7 @@ class BreakevenMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$c(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$d(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -26313,7 +26744,7 @@ class BreakevenMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$b = (context) => {
+const CREATE_KEY_FN$c = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -26387,7 +26818,7 @@ class BreakevenGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$b(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$c(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -26608,7 +27039,7 @@ class ConfigValidationService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$a = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -26775,7 +27206,7 @@ class RiskMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to risk rejection emitter to receive rejection events.
          * Protected against multiple subscriptions.
@@ -26964,7 +27395,7 @@ class RiskMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$a(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$b(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -29343,7 +29774,7 @@ class HighestProfitReportService {
  * @returns Colon-separated key string for memoization
  * @internal
  */
-const CREATE_KEY_FN$9 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$a = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -29585,7 +30016,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
         /**
          * Records a cancel-scheduled event when a scheduled signal is cancelled.
          *
@@ -30153,7 +30584,7 @@ class StrategyMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("strategyMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$9(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$a(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -30261,7 +30692,7 @@ class StrategyMarkdownService {
  * Creates a unique key for memoizing ReportStorage instances.
  * Key format: "symbol:strategyName:exchangeName[:frameName]:backtest|live"
  */
-const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$9 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -30454,7 +30885,7 @@ let ReportStorage$2 = class ReportStorage {
 class SyncMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName, backtest));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName, backtest));
         /**
          * Subscribes to `syncSubject` to start receiving `SignalSyncContract` events.
          * Protected against multiple subscriptions via `singleshot` — subsequent calls
@@ -30650,7 +31081,7 @@ class SyncMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("syncMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$8(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$9(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -30663,7 +31094,7 @@ class SyncMarkdownService {
 /**
  * Creates a unique memoization key for a symbol-strategy-exchange-frame-backtest combination.
  */
-const CREATE_KEY_FN$7 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -30839,7 +31270,7 @@ let ReportStorage$1 = class ReportStorage {
 class HighestProfitMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to `highestProfitSubject` to start receiving `HighestProfitContract`
          * events. Protected against multiple subscriptions via `singleshot` — subsequent
@@ -31005,7 +31436,7 @@ class HighestProfitMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("highestProfitMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$7(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$8(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -31027,7 +31458,7 @@ const LISTEN_TIMEOUT$1 = 120000;
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$7 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -31070,7 +31501,7 @@ class PriceMetaService {
          * Each subject holds the latest currentPrice emitted by the strategy iterator for that key.
          * Instances are cached until clear() is called.
          */
-        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
         /**
          * Returns the current market price for the given symbol and context.
          *
@@ -31099,10 +31530,10 @@ class PriceMetaService {
             if (source.data) {
                 return source.data;
             }
-            console.warn(`PriceMetaService: No currentPrice available for ${CREATE_KEY_FN$6(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
+            console.warn(`PriceMetaService: No currentPrice available for ${CREATE_KEY_FN$7(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
             const currentPrice = await waitForNext(source, (data) => !!data, LISTEN_TIMEOUT$1);
             if (typeof currentPrice === "symbol") {
-                throw new Error(`PriceMetaService: Timeout while waiting for currentPrice for ${CREATE_KEY_FN$6(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
+                throw new Error(`PriceMetaService: Timeout while waiting for currentPrice for ${CREATE_KEY_FN$7(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
             }
             return currentPrice;
         };
@@ -31144,7 +31575,7 @@ class PriceMetaService {
                 this.getSource.clear();
                 return;
             }
-            const key = CREATE_KEY_FN$6(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$7(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             this.getSource.clear(key);
         };
     }
@@ -31162,7 +31593,7 @@ const LISTEN_TIMEOUT = 120000;
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$5 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -31205,7 +31636,7 @@ class TimeMetaService {
          * Each subject holds the latest createdAt timestamp emitted by the strategy iterator for that key.
          * Instances are cached until clear() is called.
          */
-        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
         /**
          * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
          *
@@ -31233,10 +31664,10 @@ class TimeMetaService {
             if (source.data) {
                 return source.data;
             }
-            console.warn(`TimeMetaService: No timestamp available for ${CREATE_KEY_FN$5(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
+            console.warn(`TimeMetaService: No timestamp available for ${CREATE_KEY_FN$6(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
             const timestamp = await waitForNext(source, (data) => !!data, LISTEN_TIMEOUT);
             if (typeof timestamp === "symbol") {
-                throw new Error(`TimeMetaService: Timeout while waiting for timestamp for ${CREATE_KEY_FN$5(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
+                throw new Error(`TimeMetaService: Timeout while waiting for timestamp for ${CREATE_KEY_FN$6(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
             }
             return timestamp;
         };
@@ -31278,7 +31709,7 @@ class TimeMetaService {
                 this.getSource.clear();
                 return;
             }
-            const key = CREATE_KEY_FN$5(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$6(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             this.getSource.clear(key);
         };
     }
@@ -31374,7 +31805,7 @@ class MaxDrawdownReportService {
 /**
  * Creates a unique memoization key for a symbol-strategy-exchange-frame-backtest combination.
  */
-const CREATE_KEY_FN$4 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$5 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -31498,7 +31929,7 @@ class ReportStorage {
 class MaxDrawdownMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$4(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to `maxDrawdownSubject` to start receiving `MaxDrawdownContract`
          * events. Protected against multiple subscriptions via `singleshot`.
@@ -31577,7 +32008,7 @@ class MaxDrawdownMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("maxDrawdownMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$4(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$5(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -31831,7 +32262,7 @@ const EXCHANGE_METHOD_NAME_FORMAT_PRICE = "ExchangeUtils.formatPrice";
 const EXCHANGE_METHOD_NAME_GET_ORDER_BOOK = "ExchangeUtils.getOrderBook";
 const EXCHANGE_METHOD_NAME_GET_RAW_CANDLES = "ExchangeUtils.getRawCandles";
 const EXCHANGE_METHOD_NAME_GET_AGGREGATED_TRADES = "ExchangeUtils.getAggregatedTrades";
-const MS_PER_MINUTE$2 = 60000;
+const MS_PER_MINUTE$3 = 60000;
 /**
  * Gets current timestamp from execution context if available.
  * Returns current Date() if no execution context exists (non-trading GUI).
@@ -31898,7 +32329,7 @@ const DEFAULT_GET_ORDER_BOOK_FN = async (_symbol, _depth, _from, _to, _backtest)
 const DEFAULT_GET_AGGREGATED_TRADES_FN = async (_symbol, _from, _to, _backtest) => {
     throw new Error(`getAggregatedTrades is not implemented for this exchange`);
 };
-const INTERVAL_MINUTES$2 = {
+const INTERVAL_MINUTES$3 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -31930,7 +32361,7 @@ const INTERVAL_MINUTES$2 = {
  * @returns Aligned timestamp rounded down to interval boundary
  */
 const ALIGN_TO_INTERVAL_FN$1 = (timestamp, intervalMinutes) => {
-    const intervalMs = intervalMinutes * MS_PER_MINUTE$2;
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$3;
     return Math.floor(timestamp / intervalMs) * intervalMs;
 };
 /**
@@ -32070,11 +32501,11 @@ class ExchangeInstance {
                 limit,
             });
             const getCandles = this._methods.getCandles;
-            const step = INTERVAL_MINUTES$2[interval];
+            const step = INTERVAL_MINUTES$3[interval];
             if (!step) {
                 throw new Error(`ExchangeInstance unknown interval=${interval}`);
             }
-            const stepMs = step * MS_PER_MINUTE$2;
+            const stepMs = step * MS_PER_MINUTE$3;
             // Align when down to interval boundary
             const when = await GET_TIMESTAMP_FN();
             const whenTimestamp = when.getTime();
@@ -32259,7 +32690,7 @@ class ExchangeInstance {
             const when = await GET_TIMESTAMP_FN();
             const alignedTo = ALIGN_TO_INTERVAL_FN$1(when.getTime(), GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES);
             const to = new Date(alignedTo);
-            const from = new Date(alignedTo - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$2);
+            const from = new Date(alignedTo - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$3);
             const isBacktest = await GET_BACKTEST_FN();
             return await this._methods.getOrderBook(symbol, depth, from, to, isBacktest);
         };
@@ -32291,7 +32722,7 @@ class ExchangeInstance {
             const when = await GET_TIMESTAMP_FN();
             // Align to 1-minute boundary to prevent look-ahead bias
             const alignedTo = ALIGN_TO_INTERVAL_FN$1(when.getTime(), 1);
-            const windowMs = GLOBAL_CONFIG.CC_AGGREGATED_TRADES_MAX_MINUTES * MS_PER_MINUTE$2 - MS_PER_MINUTE$2;
+            const windowMs = GLOBAL_CONFIG.CC_AGGREGATED_TRADES_MAX_MINUTES * MS_PER_MINUTE$3 - MS_PER_MINUTE$3;
             const isBacktest = await GET_BACKTEST_FN();
             // No limit: fetch a single window and return as-is
             if (limit === undefined) {
@@ -32354,11 +32785,11 @@ class ExchangeInstance {
                 sDate,
                 eDate,
             });
-            const step = INTERVAL_MINUTES$2[interval];
+            const step = INTERVAL_MINUTES$3[interval];
             if (!step) {
                 throw new Error(`ExchangeInstance getRawCandles: unknown interval=${interval}`);
             }
-            const stepMs = step * MS_PER_MINUTE$2;
+            const stepMs = step * MS_PER_MINUTE$3;
             const when = await GET_TIMESTAMP_FN();
             const nowTimestamp = when.getTime();
             const alignedNow = ALIGN_TO_INTERVAL_FN$1(nowTimestamp, step);
@@ -32648,8 +33079,8 @@ const Exchange = new ExchangeUtils();
 
 const WARM_CANDLES_METHOD_NAME = "cache.warmCandles";
 const CHECK_CANDLES_METHOD_NAME = "cache.checkCandles";
-const MS_PER_MINUTE$1 = 60000;
-const INTERVAL_MINUTES$1 = {
+const MS_PER_MINUTE$2 = 60000;
+const INTERVAL_MINUTES$2 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -32664,7 +33095,7 @@ const INTERVAL_MINUTES$1 = {
     "1w": 10080,
 };
 const ALIGN_TO_INTERVAL_FN = (timestamp, intervalMinutes) => {
-    const intervalMs = intervalMinutes * MS_PER_MINUTE$1;
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$2;
     return Math.floor(timestamp / intervalMs) * intervalMs;
 };
 const BAR_LENGTH = 30;
@@ -32689,11 +33120,11 @@ const PRINT_PROGRESS_FN = (fetched, total, symbol, interval) => {
 async function checkCandles(params) {
     const { symbol, exchangeName, interval, from, to, baseDir = "./dump/data/candle" } = params;
     backtest.loggerService.info(CHECK_CANDLES_METHOD_NAME, params);
-    const step = INTERVAL_MINUTES$1[interval];
+    const step = INTERVAL_MINUTES$2[interval];
     if (!step) {
         throw new Error(`checkCandles: unsupported interval=${interval}`);
     }
-    const stepMs = step * MS_PER_MINUTE$1;
+    const stepMs = step * MS_PER_MINUTE$2;
     const dir = join(baseDir, exchangeName, symbol, interval);
     const fromTs = ALIGN_TO_INTERVAL_FN(from.getTime(), step);
     const toTs = ALIGN_TO_INTERVAL_FN(to.getTime(), step);
@@ -32763,11 +33194,11 @@ async function warmCandles(params) {
         from,
         to,
     });
-    const step = INTERVAL_MINUTES$1[interval];
+    const step = INTERVAL_MINUTES$2[interval];
     if (!step) {
         throw new Error(`warmCandles: unsupported interval=${interval}`);
     }
-    const stepMs = step * MS_PER_MINUTE$1;
+    const stepMs = step * MS_PER_MINUTE$2;
     const instance = new ExchangeInstance(exchangeName);
     const sinceTimestamp = ALIGN_TO_INTERVAL_FN(from.getTime(), step);
     const untilTimestamp = ALIGN_TO_INTERVAL_FN(to.getTime(), step);
@@ -34706,6 +35137,10 @@ const GET_POSITION_MAX_DRAWDOWN_PRICE_METHOD_NAME = "strategy.getPositionMaxDraw
 const GET_POSITION_MAX_DRAWDOWN_TIMESTAMP_METHOD_NAME = "strategy.getPositionMaxDrawdownTimestamp";
 const GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionMaxDrawdownPnlPercentage";
 const GET_POSITION_MAX_DRAWDOWN_PNL_COST_METHOD_NAME = "strategy.getPositionMaxDrawdownPnlCost";
+const GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionHighestProfitDistancePnlPercentage";
+const GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST_METHOD_NAME = "strategy.getPositionHighestProfitDistancePnlCost";
+const GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionHighestMaxDrawdownPnlPercentage";
+const GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST_METHOD_NAME = "strategy.getPositionHighestMaxDrawdownPnlCost";
 const GET_POSITION_ENTRY_OVERLAP_METHOD_NAME = "strategy.getPositionEntryOverlap";
 const GET_POSITION_PARTIAL_OVERLAP_METHOD_NAME = "strategy.getPositionPartialOverlap";
 const HAS_NO_PENDING_SIGNAL_METHOD_NAME = "strategy.hasNoPendingSignal";
@@ -36340,6 +36775,122 @@ async function getPositionMaxDrawdownPnlCost(symbol) {
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
     return await backtest.strategyCoreService.getPositionMaxDrawdownPnlCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the distance in PnL percentage between the current price and the highest profit peak.
+ *
+ * Computed as: max(0, peakPnlPercentage - currentPnlPercentage).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to drawdown distance in PnL% (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitDistancePnlPercentage } from "backtest-kit";
+ *
+ * const dist = await getPositionHighestProfitDistancePnlPercentage("BTCUSDT");
+ * // e.g. 1.5 (gave back 1.5% from peak)
+ * ```
+ */
+async function getPositionHighestProfitDistancePnlPercentage(symbol) {
+    backtest.loggerService.info(GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitDistancePnlPercentage requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitDistancePnlPercentage requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlPercentage(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the distance in PnL cost between the current price and the highest profit peak.
+ *
+ * Computed as: max(0, peakPnlCost - currentPnlCost).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to drawdown distance in PnL cost (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitDistancePnlCost } from "backtest-kit";
+ *
+ * const dist = await getPositionHighestProfitDistancePnlCost("BTCUSDT");
+ * // e.g. 3.2 (gave back $3.2 from peak)
+ * ```
+ */
+async function getPositionHighestProfitDistancePnlCost(symbol) {
+    backtest.loggerService.info(GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitDistancePnlCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitDistancePnlCost requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+ *
+ * Computed as: max(0, currentPnlPercentage - fallPnlPercentage).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to recovery distance in PnL% (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestMaxDrawdownPnlPercentage } from "backtest-kit";
+ *
+ * const dist = await getPositionHighestMaxDrawdownPnlPercentage("BTCUSDT");
+ * // e.g. 2.1 (recovered 2.1% from trough)
+ * ```
+ */
+async function getPositionHighestMaxDrawdownPnlPercentage(symbol) {
+    backtest.loggerService.info(GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestMaxDrawdownPnlPercentage requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestMaxDrawdownPnlPercentage requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlPercentage(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+ *
+ * Computed as: max(0, currentPnlCost - fallPnlCost).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to recovery distance in PnL cost (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestMaxDrawdownPnlCost } from "backtest-kit";
+ *
+ * const dist = await getPositionHighestMaxDrawdownPnlCost("BTCUSDT");
+ * // e.g. 4.8 (recovered $4.8 from trough)
+ * ```
+ */
+async function getPositionHighestMaxDrawdownPnlCost(symbol) {
+    backtest.loggerService.info(GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestMaxDrawdownPnlCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestMaxDrawdownPnlCost requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
 /**
  * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
  * Use this to prevent duplicate DCA entries at the same price area.
@@ -38009,6 +38560,10 @@ const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE = "BacktestUtils.getP
 const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP = "BacktestUtils.getPositionMaxDrawdownTimestamp";
 const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE = "BacktestUtils.getPositionMaxDrawdownPnlPercentage";
 const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST = "BacktestUtils.getPositionMaxDrawdownPnlCost";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE = "BacktestUtils.getPositionHighestProfitDistancePnlPercentage";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST = "BacktestUtils.getPositionHighestProfitDistancePnlCost";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE = "BacktestUtils.getPositionHighestMaxDrawdownPnlPercentage";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST = "BacktestUtils.getPositionHighestMaxDrawdownPnlCost";
 const BACKTEST_METHOD_NAME_GET_POSITION_ENTRY_OVERLAP = "BacktestUtils.getPositionEntryOverlap";
 const BACKTEST_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "BacktestUtils.getPositionPartialOverlap";
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
@@ -39278,6 +39833,118 @@ class BacktestUtils {
             }
             return await backtest.strategyCoreService.getPositionMaxDrawdownPnlCost(true, symbol, context);
         };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Computed as: max(0, peakPnlPercentage - currentPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns drawdown distance in PnL% (≥ 0) or null if no active position
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlPercentage(true, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Computed as: max(0, peakPnlCost - currentPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns drawdown distance in PnL cost (≥ 0) or null if no active position
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlCost(true, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Computed as: max(0, currentPnlPercentage - fallPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns recovery distance in PnL% (≥ 0) or null if no active position
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlPercentage(true, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Computed as: max(0, currentPnlCost - fallPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns recovery distance in PnL cost (≥ 0) or null if no active position
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(true, symbol, context);
+        };
         /**
          * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
          * Use this to prevent duplicate DCA entries at the same price area.
@@ -40403,6 +41070,10 @@ const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE = "LiveUtils.getPositionM
 const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP = "LiveUtils.getPositionMaxDrawdownTimestamp";
 const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE = "LiveUtils.getPositionMaxDrawdownPnlPercentage";
 const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST = "LiveUtils.getPositionMaxDrawdownPnlCost";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE = "LiveUtils.getPositionHighestProfitDistancePnlPercentage";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST = "LiveUtils.getPositionHighestProfitDistancePnlCost";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE = "LiveUtils.getPositionHighestMaxDrawdownPnlPercentage";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST = "LiveUtils.getPositionHighestMaxDrawdownPnlCost";
 const LIVE_METHOD_NAME_GET_POSITION_ENTRY_OVERLAP = "LiveUtils.getPositionEntryOverlap";
 const LIVE_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "LiveUtils.getPositionPartialOverlap";
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
@@ -41799,6 +42470,134 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Computed as: max(0, peakPnlPercentage - currentPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns drawdown distance in PnL% (≥ 0) or null if no active position
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlPercentage(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Computed as: max(0, peakPnlCost - currentPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns drawdown distance in PnL cost (≥ 0) or null if no active position
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Computed as: max(0, currentPnlPercentage - fallPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns recovery distance in PnL% (≥ 0) or null if no active position
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlPercentage(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Computed as: max(0, currentPnlCost - fallPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns recovery distance in PnL cost (≥ 0) or null if no active position
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
          * Use this to prevent duplicate DCA entries at the same price area.
@@ -44176,7 +44975,7 @@ const createSearchIndex = () => {
     return { upsert, remove, list, search, read };
 };
 
-const CREATE_KEY_FN$3 = (signalId, bucketName) => `${signalId}-${bucketName}`;
+const CREATE_KEY_FN$4 = (signalId, bucketName) => `${signalId}-${bucketName}`;
 const LIST_MEMORY_FN = ({ id, content }) => ({
     memoryId: id,
     content: content,
@@ -44498,7 +45297,7 @@ class MemoryDummyInstance {
 class MemoryAdapter {
     constructor() {
         this.MemoryFactory = MemoryPersistInstance;
-        this.getInstance = memoize(([signalId, bucketName]) => CREATE_KEY_FN$3(signalId, bucketName), (signalId, bucketName) => Reflect.construct(this.MemoryFactory, [signalId, bucketName]));
+        this.getInstance = memoize(([signalId, bucketName]) => CREATE_KEY_FN$4(signalId, bucketName), (signalId, bucketName) => Reflect.construct(this.MemoryFactory, [signalId, bucketName]));
         /**
          * Activates the adapter by subscribing to signal lifecycle events.
          * Clears memoized instances for a signalId when it is cancelled or closed,
@@ -44509,7 +45308,7 @@ class MemoryAdapter {
         this.enable = singleshot(() => {
             backtest.loggerService.info(MEMORY_ADAPTER_METHOD_NAME_ENABLE);
             const handleDispose = (signalId) => {
-                const prefix = CREATE_KEY_FN$3(signalId, "");
+                const prefix = CREATE_KEY_FN$4(signalId, "");
                 for (const key of this.getInstance.keys()) {
                     if (key.startsWith(prefix)) {
                         const instance = this.getInstance.get(key);
@@ -44554,7 +45353,7 @@ class MemoryAdapter {
                 bucketName: dto.bucketName,
                 memoryId: dto.memoryId,
             });
-            const key = CREATE_KEY_FN$3(dto.signalId, dto.bucketName);
+            const key = CREATE_KEY_FN$4(dto.signalId, dto.bucketName);
             const isInitial = !this.getInstance.has(key);
             const instance = this.getInstance(dto.signalId, dto.bucketName);
             await instance.waitForInit(isInitial);
@@ -44576,7 +45375,7 @@ class MemoryAdapter {
                 bucketName: dto.bucketName,
                 query: dto.query,
             });
-            const key = CREATE_KEY_FN$3(dto.signalId, dto.bucketName);
+            const key = CREATE_KEY_FN$4(dto.signalId, dto.bucketName);
             const isInitial = !this.getInstance.has(key);
             const instance = this.getInstance(dto.signalId, dto.bucketName);
             await instance.waitForInit(isInitial);
@@ -44596,7 +45395,7 @@ class MemoryAdapter {
                 signalId: dto.signalId,
                 bucketName: dto.bucketName,
             });
-            const key = CREATE_KEY_FN$3(dto.signalId, dto.bucketName);
+            const key = CREATE_KEY_FN$4(dto.signalId, dto.bucketName);
             const isInitial = !this.getInstance.has(key);
             const instance = this.getInstance(dto.signalId, dto.bucketName);
             await instance.waitForInit(isInitial);
@@ -44617,7 +45416,7 @@ class MemoryAdapter {
                 bucketName: dto.bucketName,
                 memoryId: dto.memoryId,
             });
-            const key = CREATE_KEY_FN$3(dto.signalId, dto.bucketName);
+            const key = CREATE_KEY_FN$4(dto.signalId, dto.bucketName);
             const isInitial = !this.getInstance.has(key);
             const instance = this.getInstance(dto.signalId, dto.bucketName);
             await instance.waitForInit(isInitial);
@@ -44640,7 +45439,7 @@ class MemoryAdapter {
                 bucketName: dto.bucketName,
                 memoryId: dto.memoryId,
             });
-            const key = CREATE_KEY_FN$3(dto.signalId, dto.bucketName);
+            const key = CREATE_KEY_FN$4(dto.signalId, dto.bucketName);
             const isInitial = !this.getInstance.has(key);
             const instance = this.getInstance(dto.signalId, dto.bucketName);
             await instance.waitForInit(isInitial);
@@ -44932,7 +45731,7 @@ async function removeMemory(dto) {
     });
 }
 
-const CREATE_KEY_FN$2 = (signalId, bucketName) => `${signalId}-${bucketName}`;
+const CREATE_KEY_FN$3 = (signalId, bucketName) => `${signalId}-${bucketName}`;
 const DUMP_MEMORY_INSTANCE_METHOD_NAME_AGENT = "DumpMemoryInstance.dumpAgentAnswer";
 const DUMP_MEMORY_INSTANCE_METHOD_NAME_RECORD = "DumpMemoryInstance.dumpRecord";
 const DUMP_MEMORY_INSTANCE_METHOD_NAME_TABLE = "DumpMemoryInstance.dumpTable";
@@ -45552,7 +46351,7 @@ class DumpDummyInstance {
 class DumpAdapter {
     constructor() {
         this.DumpFactory = DumpMarkdownInstance;
-        this.getInstance = memoize(([signalId, bucketName]) => CREATE_KEY_FN$2(signalId, bucketName), (signalId, bucketName) => Reflect.construct(this.DumpFactory, [signalId, bucketName]));
+        this.getInstance = memoize(([signalId, bucketName]) => CREATE_KEY_FN$3(signalId, bucketName), (signalId, bucketName) => Reflect.construct(this.DumpFactory, [signalId, bucketName]));
         /**
          * Activates the adapter by subscribing to signal lifecycle events.
          * Clears memoized instances for a signalId when it is cancelled or closed,
@@ -45563,7 +46362,7 @@ class DumpAdapter {
         this.enable = singleshot(() => {
             backtest.loggerService.info(DUMP_ADAPTER_METHOD_NAME_ENABLE);
             const handleDispose = (signalId) => {
-                const prefix = CREATE_KEY_FN$2(signalId, "");
+                const prefix = CREATE_KEY_FN$3(signalId, "");
                 for (const key of this.getInstance.keys()) {
                     if (key.startsWith(prefix)) {
                         const instance = this.getInstance.get(key);
@@ -48497,6 +49296,49 @@ PositionSizeUtils.atrBased = async (symbol, accountBalance, priceOpen, atr, cont
 };
 const PositionSize = PositionSizeUtils;
 
+const METHOD_NAME_MOONBAG = "Position.moonbag";
+const METHOD_NAME_BRACKET = "Position.bracket";
+/**
+ * Utilities for calculating take profit and stop loss price levels.
+ * Automatically inverts direction based on position type (long/short).
+ */
+class Position {
+}
+/**
+ * Calculates levels for the "moonbag" strategy — fixed TP at 50% from the current price.
+ * @param dto.position - position type: "long" or "short"
+ * @param dto.currentPrice - current asset price
+ * @param dto.percentStopLoss - stop loss percentage from 0 to 100
+ * @returns priceTakeProfit and priceStopLoss in fiat
+ */
+Position.moonbag = (dto) => {
+    backtest.loggerService.log(METHOD_NAME_MOONBAG, { dto });
+    const percentTakeProfit = 50;
+    const sign = dto.position === "long" ? 1 : -1;
+    return {
+        position: dto.position,
+        priceTakeProfit: dto.currentPrice * (1 + sign * percentTakeProfit / 100),
+        priceStopLoss: dto.currentPrice * (1 - sign * dto.percentStopLoss / 100),
+    };
+};
+/**
+ * Calculates levels for a bracket order with custom TP and SL.
+ * @param dto.position - position type: "long" or "short"
+ * @param dto.currentPrice - current asset price
+ * @param dto.percentStopLoss - stop loss percentage from 0 to 100
+ * @param dto.percentTakeProfit - take profit percentage from 0 to 100
+ * @returns priceTakeProfit and priceStopLoss in fiat
+ */
+Position.bracket = (dto) => {
+    backtest.loggerService.log(METHOD_NAME_BRACKET, { dto });
+    const sign = dto.position === "long" ? 1 : -1;
+    return {
+        position: dto.position,
+        priceTakeProfit: dto.currentPrice * (1 + sign * dto.percentTakeProfit / 100),
+        priceStopLoss: dto.currentPrice * (1 - sign * dto.percentStopLoss / 100),
+    };
+};
+
 const PARTIAL_METHOD_NAME_GET_DATA = "PartialUtils.getData";
 const PARTIAL_METHOD_NAME_GET_REPORT = "PartialUtils.getReport";
 const PARTIAL_METHOD_NAME_DUMP = "PartialUtils.dump";
@@ -50699,7 +51541,7 @@ const StorageBacktest = new StorageBacktestAdapter();
  * Generates a unique key for notification identification.
  * @returns Random string identifier
  */
-const CREATE_KEY_FN$1 = () => randomString();
+const CREATE_KEY_FN$2 = () => randomString();
 /**
  * Creates a notification model from signal tick result.
  * Handles opened, closed, scheduled, and cancelled signal actions.
@@ -50710,7 +51552,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
     if (data.action === "opened") {
         return {
             type: "signal.opened",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.signal.pendingAt,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -50744,7 +51586,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
         const durationMin = Math.round(durationMs / 60000);
         return {
             type: "signal.closed",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.closeTimestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -50778,7 +51620,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
     if (data.action === "scheduled") {
         return {
             type: "signal.scheduled",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.signal.scheduledAt,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -50811,7 +51653,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
         const durationMin = Math.round(durationMs / 60000);
         return {
             type: "signal.cancelled",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.closeTimestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -50844,7 +51686,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
  */
 const CREATE_PARTIAL_PROFIT_NOTIFICATION_FN = (data) => ({
     type: "partial_profit.available",
-    id: CREATE_KEY_FN$1(),
+    id: CREATE_KEY_FN$2(),
     timestamp: data.timestamp,
     backtest: data.backtest,
     symbol: data.symbol,
@@ -50879,7 +51721,7 @@ const CREATE_PARTIAL_PROFIT_NOTIFICATION_FN = (data) => ({
  */
 const CREATE_PARTIAL_LOSS_NOTIFICATION_FN = (data) => ({
     type: "partial_loss.available",
-    id: CREATE_KEY_FN$1(),
+    id: CREATE_KEY_FN$2(),
     timestamp: data.timestamp,
     backtest: data.backtest,
     symbol: data.symbol,
@@ -50914,7 +51756,7 @@ const CREATE_PARTIAL_LOSS_NOTIFICATION_FN = (data) => ({
  */
 const CREATE_BREAKEVEN_NOTIFICATION_FN = (data) => ({
     type: "breakeven.available",
-    id: CREATE_KEY_FN$1(),
+    id: CREATE_KEY_FN$2(),
     timestamp: data.timestamp,
     backtest: data.backtest,
     symbol: data.symbol,
@@ -50952,7 +51794,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "partial-profit") {
         return {
             type: "partial_profit.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -50984,7 +51826,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "partial-loss") {
         return {
             type: "partial_loss.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51016,7 +51858,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "breakeven") {
         return {
             type: "breakeven.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51047,7 +51889,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "trailing-stop") {
         return {
             type: "trailing_stop.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51079,7 +51921,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "trailing-take") {
         return {
             type: "trailing_take.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51111,7 +51953,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "activate-scheduled") {
         return {
             type: "activate_scheduled.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51143,7 +51985,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "average-buy") {
         return {
             type: "average_buy.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51176,7 +52018,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "cancel-scheduled") {
         return {
             type: "cancel_scheduled.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51199,7 +52041,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
     if (data.action === "close-pending") {
         return {
             type: "close_pending.commit",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51231,7 +52073,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
     if (data.action === "signal-open") {
         return {
             type: "signal_sync.open",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51263,7 +52105,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
     if (data.action === "signal-close") {
         return {
             type: "signal_sync.close",
-            id: CREATE_KEY_FN$1(),
+            id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
             symbol: data.symbol,
@@ -51301,7 +52143,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
  */
 const CREATE_RISK_NOTIFICATION_FN = (data) => ({
     type: "risk.rejection",
-    id: CREATE_KEY_FN$1(),
+    id: CREATE_KEY_FN$2(),
     timestamp: data.timestamp,
     backtest: data.backtest,
     symbol: data.symbol,
@@ -51327,7 +52169,7 @@ const CREATE_RISK_NOTIFICATION_FN = (data) => ({
  */
 const CREATE_ERROR_NOTIFICATION_FN = (error) => ({
     type: "error.info",
-    id: CREATE_KEY_FN$1(),
+    id: CREATE_KEY_FN$2(),
     error: errorData(error),
     message: getErrorMessage(error),
     backtest: false,
@@ -51339,7 +52181,7 @@ const CREATE_ERROR_NOTIFICATION_FN = (error) => ({
  */
 const CREATE_CRITICAL_ERROR_NOTIFICATION_FN = (error) => ({
     type: "error.critical",
-    id: CREATE_KEY_FN$1(),
+    id: CREATE_KEY_FN$2(),
     error: errorData(error),
     message: getErrorMessage(error),
     backtest: false,
@@ -51351,7 +52193,7 @@ const CREATE_CRITICAL_ERROR_NOTIFICATION_FN = (error) => ({
  */
 const CREATE_VALIDATION_ERROR_NOTIFICATION_FN = (error) => ({
     type: "error.validation",
-    id: CREATE_KEY_FN$1(),
+    id: CREATE_KEY_FN$2(),
     error: errorData(error),
     message: getErrorMessage(error),
     backtest: false,
@@ -52780,7 +53622,7 @@ const NotificationLive = new NotificationLiveAdapter();
  */
 const NotificationBacktest = new NotificationBacktestAdapter();
 
-const CACHE_METHOD_NAME_RUN = "CacheInstance.run";
+const CACHE_METHOD_NAME_RUN = "CacheFnInstance.run";
 const CACHE_METHOD_NAME_FN = "CacheUtils.fn";
 const CACHE_METHOD_NAME_FN_CLEAR = "CacheUtils.fn.clear";
 const CACHE_METHOD_NAME_FN_GC = "CacheUtils.fn.gc";
@@ -52789,8 +53631,8 @@ const CACHE_METHOD_NAME_FILE_CLEAR = "CacheUtils.file.clear";
 const CACHE_METHOD_NAME_DISPOSE = "CacheUtils.dispose";
 const CACHE_METHOD_NAME_CLEAR = "CacheUtils.clear";
 const CACHE_FILE_INSTANCE_METHOD_NAME_RUN = "CacheFileInstance.run";
-const MS_PER_MINUTE = 60000;
-const INTERVAL_MINUTES = {
+const MS_PER_MINUTE$1 = 60000;
+const INTERVAL_MINUTES$1 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -52824,12 +53666,12 @@ const INTERVAL_MINUTES = {
  * // Returns timestamp for 2025-10-01T01:00:00Z
  * ```
  */
-const align = (timestamp, interval) => {
-    const intervalMinutes = INTERVAL_MINUTES[interval];
+const align$1 = (timestamp, interval) => {
+    const intervalMinutes = INTERVAL_MINUTES$1[interval];
     if (!intervalMinutes) {
         throw new Error(`align: unknown interval=${interval}`);
     }
-    const intervalMs = intervalMinutes * MS_PER_MINUTE;
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$1;
     return Math.floor(timestamp / intervalMs) * intervalMs;
 };
 /**
@@ -52840,7 +53682,7 @@ const align = (timestamp, interval) => {
  * @param backtest - Whether running in backtest mode
  * @returns Cache key string
  */
-const CREATE_KEY_FN = (strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$1 = (strategyName, exchangeName, frameName, backtest) => {
     const parts = [strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -52864,16 +53706,16 @@ const NEVER_VALUE = Symbol("never");
  *
  * @example
  * ```typescript
- * const instance = new CacheInstance(myExpensiveFunction, "1h");
+ * const instance = new CacheFnInstance(myExpensiveFunction, "1h");
  * const result = instance.run(arg1, arg2); // Computed
  * const result2 = instance.run(arg1, arg2); // Cached (within same hour)
  * // After 1 hour passes
  * const result3 = instance.run(arg1, arg2); // Recomputed
  * ```
  */
-class CacheInstance {
+class CacheFnInstance {
     /**
-     * Creates a new CacheInstance for a specific function and interval.
+     * Creates a new CacheFnInstance for a specific function and interval.
      *
      * @param fn - Function to cache
      * @param interval - Candle interval for cache invalidation (e.g., "1m", "1h")
@@ -52910,7 +53752,7 @@ class CacheInstance {
          *
          * @example
          * ```typescript
-         * const instance = new CacheInstance(calculateIndicator, "15m");
+         * const instance = new CacheFnInstance(calculateIndicator, "15m");
          * const result = instance.run("BTCUSDT", 100);
          * console.log(result.value); // Calculated value
          * console.log(result.when); // Cache timestamp
@@ -52918,26 +53760,26 @@ class CacheInstance {
          */
         this.run = (...args) => {
             backtest.loggerService.debug(CACHE_METHOD_NAME_RUN, { args });
-            const step = INTERVAL_MINUTES[this.interval];
+            const step = INTERVAL_MINUTES$1[this.interval];
             {
                 if (!MethodContextService.hasContext()) {
-                    throw new Error("CacheInstance run requires method context");
+                    throw new Error("CacheFnInstance run requires method context");
                 }
                 if (!ExecutionContextService.hasContext()) {
-                    throw new Error("CacheInstance run requires execution context");
+                    throw new Error("CacheFnInstance run requires execution context");
                 }
                 if (!step) {
-                    throw new Error(`CacheInstance unknown cache ttl interval=${this.interval}`);
+                    throw new Error(`CacheFnInstance unknown cache ttl interval=${this.interval}`);
                 }
             }
-            const contextKey = CREATE_KEY_FN(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
+            const contextKey = CREATE_KEY_FN$1(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
             const argKey = String(this.key(args));
             const key = `${contextKey}:${argKey}`;
             const currentWhen = backtest.executionContextService.context.when;
             const cached = this._cacheMap.get(key);
             if (cached) {
-                const currentAligned = align(currentWhen.getTime(), this.interval);
-                const cachedAligned = align(cached.when.getTime(), this.interval);
+                const currentAligned = align$1(currentWhen.getTime(), this.interval);
+                const cachedAligned = align$1(cached.when.getTime(), this.interval);
                 if (currentAligned === cachedAligned) {
                     return cached;
                 }
@@ -52960,7 +53802,7 @@ class CacheInstance {
          *
          * @example
          * ```typescript
-         * const instance = new CacheInstance(calculateIndicator, "1h");
+         * const instance = new CacheFnInstance(calculateIndicator, "1h");
          * const result1 = instance.run("BTCUSDT", 14); // Computed
          * const result2 = instance.run("BTCUSDT", 14); // Cached
          *
@@ -52970,7 +53812,7 @@ class CacheInstance {
          * ```
          */
         this.clear = () => {
-            const contextKey = CREATE_KEY_FN(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
+            const contextKey = CREATE_KEY_FN$1(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
             const prefix = `${contextKey}:`;
             for (const key of this._cacheMap.keys()) {
                 if (key.startsWith(prefix)) {
@@ -52990,7 +53832,7 @@ class CacheInstance {
          *
          * @example
          * ```typescript
-         * const instance = new CacheInstance(calculateIndicator, "1h");
+         * const instance = new CacheFnInstance(calculateIndicator, "1h");
          * instance.run("BTCUSDT", 14); // Cached at 10:00
          * instance.run("ETHUSDT", 14); // Cached at 10:00
          * // Time passes to 11:00
@@ -52999,10 +53841,10 @@ class CacheInstance {
          */
         this.gc = () => {
             const currentWhen = backtest.executionContextService.context.when;
-            const currentAligned = align(currentWhen.getTime(), this.interval);
+            const currentAligned = align$1(currentWhen.getTime(), this.interval);
             let removed = 0;
             for (const [key, cached] of this._cacheMap.entries()) {
-                const cachedAligned = align(cached.when.getTime(), this.interval);
+                const cachedAligned = align$1(cached.when.getTime(), this.interval);
                 if (currentAligned !== cachedAligned) {
                     this._cacheMap.delete(key);
                     removed++;
@@ -53077,7 +53919,7 @@ class CacheFileInstance {
          */
         this.run = async (...args) => {
             backtest.loggerService.debug(CACHE_FILE_INSTANCE_METHOD_NAME_RUN, { args });
-            const step = INTERVAL_MINUTES[this.interval];
+            const step = INTERVAL_MINUTES$1[this.interval];
             {
                 if (!MethodContextService.hasContext()) {
                     throw new Error("CacheFileInstance run requires method context");
@@ -53091,7 +53933,7 @@ class CacheFileInstance {
             }
             const [symbol, ...rest] = args;
             const { when } = backtest.executionContextService.context;
-            const alignedTs = align(when.getTime(), this.interval);
+            const alignedTs = align$1(when.getTime(), this.interval);
             const bucket = `${this.name}_${this.interval}_${this.index}`;
             const entityKey = this.key([symbol, alignedTs, ...rest]);
             const cached = await PersistMeasureAdapter.readMeasureData(bucket, entityKey);
@@ -53099,9 +53941,19 @@ class CacheFileInstance {
                 return cached.data;
             }
             const result = await this.fn.call(null, ...args);
-            await PersistMeasureAdapter.writeMeasureData({ id: entityKey, data: result }, bucket, entityKey);
+            await PersistMeasureAdapter.writeMeasureData({ id: entityKey, data: result, removed: false }, bucket, entityKey);
             return result;
         };
+        /**
+         * Soft-delete all persisted records for this instance's bucket.
+         * After this call the next `run()` will recompute and re-cache the value.
+         */
+        this.clear = async () => {
+            const bucket = `${this.name}_${this.interval}_${this.index}`;
+            for await (const key of PersistMeasureAdapter.listMeasureData(bucket)) {
+                await PersistMeasureAdapter.removeMeasureData(bucket, key);
+            }
+        };
         this.index = CacheFileInstance.createIndex();
     }
 }
@@ -53125,10 +53977,10 @@ CacheFileInstance._indexCounter = 0;
 class CacheUtils {
     constructor() {
         /**
-         * Memoized function to get or create CacheInstance for a function.
+         * Memoized function to get or create CacheFnInstance for a function.
          * Each function gets its own isolated cache instance.
          */
-        this._getFnInstance = memoize(([run]) => run, (run, interval, key) => new CacheInstance(run, interval, key));
+        this._getFnInstance = memoize(([run]) => run, (run, interval, key) => new CacheFnInstance(run, interval, key));
         /**
          * Memoized function to get or create CacheFileInstance for an async function.
          * Each function gets its own isolated file-cache instance.
@@ -53237,31 +54089,34 @@ class CacheUtils {
          */
         this.file = (run, context) => {
             backtest.loggerService.info(CACHE_METHOD_NAME_FILE, { context });
+            {
+                this._getFileInstance(run, context.interval, context.name, context.key);
+            }
             const wrappedFn = (...args) => {
                 const instance = this._getFileInstance(run, context.interval, context.name, context.key);
                 return instance.run(...args);
             };
-            wrappedFn.clear = () => {
+            wrappedFn.clear = async () => {
                 backtest.loggerService.info(CACHE_METHOD_NAME_FILE_CLEAR);
-                this._getFileInstance.clear(run);
+                await this._getFileInstance.get(run)?.clear();
             };
             return wrappedFn;
         };
         /**
-         * Dispose (remove) the memoized CacheInstance for a specific function.
+         * Dispose (remove) the memoized CacheFnInstance for a specific function.
          *
-         * Removes the CacheInstance from the internal memoization cache, discarding all cached
+         * Removes the CacheFnInstance from the internal memoization cache, discarding all cached
          * results across all contexts (all strategy/exchange/mode combinations) for that function.
-         * The next call to the wrapped function will create a fresh CacheInstance.
+         * The next call to the wrapped function will create a fresh CacheFnInstance.
          *
          * @template T - Function type
-         * @param run - Function whose CacheInstance should be disposed.
+         * @param run - Function whose CacheFnInstance should be disposed.
          *
          * @example
          * ```typescript
          * const cachedFn = Cache.fn(calculateIndicator, { interval: "1h" });
          *
-         * // Dispose CacheInstance for a specific function
+         * // Dispose CacheFnInstance for a specific function
          * Cache.dispose(calculateIndicator);
          * ```
          */
@@ -53275,7 +54130,7 @@ class CacheUtils {
             }
         };
         /**
-         * Clears all memoized CacheInstance and CacheFileInstance objects.
+         * Clears all memoized CacheFnInstance and CacheFileInstance objects.
          * Call this when process.cwd() changes between strategy iterations
          * so new instances are created with the updated base path.
          */
@@ -53305,6 +54160,425 @@ class CacheUtils {
  */
 const Cache = new CacheUtils();
 
+const INTERVAL_METHOD_NAME_RUN = "IntervalFnInstance.run";
+const INTERVAL_FILE_INSTANCE_METHOD_NAME_RUN = "IntervalFileInstance.run";
+const INTERVAL_METHOD_NAME_FN = "IntervalUtils.fn";
+const INTERVAL_METHOD_NAME_FN_CLEAR = "IntervalUtils.fn.clear";
+const INTERVAL_METHOD_NAME_FILE = "IntervalUtils.file";
+const INTERVAL_METHOD_NAME_FILE_CLEAR = "IntervalUtils.file.clear";
+const INTERVAL_METHOD_NAME_DISPOSE = "IntervalUtils.dispose";
+const INTERVAL_METHOD_NAME_CLEAR = "IntervalUtils.clear";
+const MS_PER_MINUTE = 60000;
+const INTERVAL_MINUTES = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+    "1d": 1440,
+    "1w": 10080,
+};
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * @param timestamp - Timestamp in milliseconds
+ * @param interval - Candle interval
+ * @returns Aligned timestamp rounded down to interval boundary
+ * @throws Error if interval is unknown
+ *
+ * @example
+ * ```typescript
+ * // Align to 15-minute boundary
+ * const aligned = align(new Date("2025-10-01T00:35:00Z").getTime(), "15m");
+ * // Returns timestamp for 2025-10-01T00:30:00Z
+ * ```
+ */
+const align = (timestamp, interval) => {
+    const intervalMinutes = INTERVAL_MINUTES[interval];
+    if (!intervalMinutes) {
+        throw new Error(`align: unknown interval=${interval}`);
+    }
+    const intervalMs = intervalMinutes * MS_PER_MINUTE;
+    return Math.floor(timestamp / intervalMs) * intervalMs;
+};
+/**
+ * Build a context key string from strategy name, exchange name, frame name, and execution mode.
+ *
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Name of the exchange
+ * @param frameName - Name of the backtest frame (omitted in live mode)
+ * @param isBacktest - Whether running in backtest mode
+ * @returns Context key string
+ */
+const CREATE_KEY_FN = (strategyName, exchangeName, frameName, isBacktest) => {
+    const parts = [strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(isBacktest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * Instance class for firing a function exactly once per interval boundary.
+ *
+ * On the first call within a new interval the wrapped function is invoked and
+ * its result is returned. Every subsequent call within the same interval returns
+ * `null` without invoking the function again.
+ * If the function itself returns `null`, the interval countdown does not start —
+ * the next call will retry the function.
+ *
+ * State is kept in memory; use `IntervalFileInstance` for persistence across restarts.
+ *
+ * @example
+ * ```typescript
+ * const instance = new IntervalFnInstance(mySignalFn, "1h");
+ * await instance.run("BTCUSDT"); // → T | null  (fn called)
+ * await instance.run("BTCUSDT"); // → null      (skipped, same interval)
+ * // After 1 hour passes:
+ * await instance.run("BTCUSDT"); // → T | null  (fn called again)
+ * ```
+ */
+class IntervalFnInstance {
+    /**
+     * Creates a new IntervalFnInstance.
+     *
+     * @param fn - Function to fire once per interval
+     * @param interval - Candle interval that controls the firing boundary
+     */
+    constructor(fn, interval) {
+        this.fn = fn;
+        this.interval = interval;
+        /** Stores the last aligned timestamp per context+symbol key. */
+        this._stateMap = new Map();
+        /**
+         * Execute the signal function with once-per-interval enforcement.
+         *
+         * Algorithm:
+         * 1. Align the current execution context `when` to the interval boundary.
+         * 2. If the stored aligned timestamp for this context+symbol equals the current one → return `null`.
+         * 3. Otherwise call `fn`. If it returns a non-null signal, record the aligned timestamp and return
+         *    the signal. If it returns `null`, leave state unchanged so the next call retries.
+         *
+         * Requires active method context and execution context.
+         *
+         * @param symbol - Trading pair symbol (e.g. "BTCUSDT")
+         * @returns The value returned by `fn` on the first non-null fire, `null` on all subsequent calls
+         *   within the same interval or when `fn` itself returned `null`
+         * @throws Error if method context, execution context, or interval is missing
+         */
+        this.run = async (symbol) => {
+            backtest.loggerService.debug(INTERVAL_METHOD_NAME_RUN, { symbol });
+            const step = INTERVAL_MINUTES[this.interval];
+            {
+                if (!MethodContextService.hasContext()) {
+                    throw new Error("IntervalFnInstance run requires method context");
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error("IntervalFnInstance run requires execution context");
+                }
+                if (!step) {
+                    throw new Error(`IntervalFnInstance unknown interval=${this.interval}`);
+                }
+            }
+            const contextKey = CREATE_KEY_FN(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
+            const key = `${contextKey}:${symbol}`;
+            const currentWhen = backtest.executionContextService.context.when;
+            const currentAligned = align(currentWhen.getTime(), this.interval);
+            if (this._stateMap.get(key) === currentAligned) {
+                return null;
+            }
+            const result = await this.fn(symbol, currentWhen);
+            if (result !== null) {
+                this._stateMap.set(key, currentAligned);
+            }
+            return result;
+        };
+        /**
+         * Clear fired-interval state for the current execution context.
+         *
+         * Removes all entries for the current strategy/exchange/frame/mode combination
+         * from this instance's state map. The next `run()` call will invoke the function again.
+         *
+         * Requires active method context and execution context.
+         */
+        this.clear = () => {
+            const contextKey = CREATE_KEY_FN(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
+            const prefix = `${contextKey}:`;
+            for (const key of this._stateMap.keys()) {
+                if (key.startsWith(prefix)) {
+                    this._stateMap.delete(key);
+                }
+            }
+        };
+    }
+}
+/**
+ * Instance class for firing an async function exactly once per interval boundary,
+ * with the fired state persisted to disk via `PersistIntervalAdapter`.
+ *
+ * On the first call within a new interval the wrapped function is invoked.
+ * If it returns a non-null signal, that result is written to disk and returned.
+ * Every subsequent call within the same interval returns `null` (record exists on disk).
+ * If the function returns `null`, nothing is written and the next call retries.
+ *
+ * Fired state survives process restarts — unlike `IntervalFnInstance` which is in-memory only.
+ *
+ * @template T - Async function type: `(symbol: string, ...args) => Promise<R | null>`
+ *
+ * @example
+ * ```typescript
+ * const instance = new IntervalFileInstance(fetchSignal, "1h", "mySignal");
+ * await instance.run("BTCUSDT"); // → R | null  (fn called, result written to disk)
+ * await instance.run("BTCUSDT"); // → null      (record exists, already fired)
+ * ```
+ */
+class IntervalFileInstance {
+    /**
+     * Allocates a new unique index. Called once in the constructor to give each
+     * IntervalFileInstance its own namespace in the persistent key space.
+     */
+    static createIndex() {
+        return IntervalFileInstance._indexCounter++;
+    }
+    /**
+     * Resets the index counter to zero.
+     * Call this when clearing all instances (e.g. on `IntervalUtils.clear()`).
+     */
+    static clearCounter() {
+        IntervalFileInstance._indexCounter = 0;
+    }
+    /**
+     * Creates a new IntervalFileInstance.
+     *
+     * @param fn - Async signal function to fire once per interval
+     * @param interval - Candle interval that controls the firing boundary
+     * @param name - Human-readable bucket name used as the directory prefix
+     */
+    constructor(fn, interval, name) {
+        this.fn = fn;
+        this.interval = interval;
+        this.name = name;
+        /**
+         * Execute the async function with persistent once-per-interval enforcement.
+         *
+         * Algorithm:
+         * 1. Build bucket = `${name}_${interval}_${index}` — fixed per instance, used as directory name.
+         * 2. Align execution context `when` to interval boundary → `alignedTs`.
+         * 3. Build entity key = `${symbol}_${alignedTs}`.
+         * 4. Try to read from `PersistIntervalAdapter` using (bucket, entityKey).
+         * 5. On hit — return `null` (interval already fired).
+         * 6. On miss — call `fn`. If non-null, write to disk and return result. If null, skip write and return null.
+         *
+         * Requires active method context and execution context.
+         *
+         * @param symbol - Trading pair symbol (e.g. "BTCUSDT")
+         * @returns The value on the first non-null fire, `null` if already fired this interval
+         *   or if `fn` itself returned `null`
+         * @throws Error if method context, execution context, or interval is missing
+         */
+        this.run = async (symbol) => {
+            backtest.loggerService.debug(INTERVAL_FILE_INSTANCE_METHOD_NAME_RUN, { symbol });
+            const step = INTERVAL_MINUTES[this.interval];
+            {
+                if (!MethodContextService.hasContext()) {
+                    throw new Error("IntervalFileInstance run requires method context");
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error("IntervalFileInstance run requires execution context");
+                }
+                if (!step) {
+                    throw new Error(`IntervalFileInstance unknown interval=${this.interval}`);
+                }
+            }
+            const { when } = backtest.executionContextService.context;
+            const alignedTs = align(when.getTime(), this.interval);
+            const bucket = `${this.name}_${this.interval}_${this.index}`;
+            const entityKey = `${symbol}_${alignedTs}`;
+            const cached = await PersistIntervalAdapter.readIntervalData(bucket, entityKey);
+            if (cached !== null) {
+                return null;
+            }
+            const result = await this.fn(symbol, when);
+            if (result !== null) {
+                await PersistIntervalAdapter.writeIntervalData({ id: entityKey, data: result, removed: false }, bucket, entityKey);
+            }
+            return result;
+        };
+        /**
+         * Soft-delete all persisted records for this instance's bucket.
+         * After this call the function will fire again on the next `run()`.
+         */
+        this.clear = async () => {
+            const bucket = `${this.name}_${this.interval}_${this.index}`;
+            for await (const key of PersistIntervalAdapter.listIntervalData(bucket)) {
+                await PersistIntervalAdapter.removeIntervalData(bucket, key);
+            }
+        };
+        this.index = IntervalFileInstance.createIndex();
+    }
+}
+/** Global counter — incremented once per IntervalFileInstance construction. */
+IntervalFileInstance._indexCounter = 0;
+/**
+ * Utility class for wrapping signal functions with once-per-interval firing.
+ * Provides two modes: in-memory (`fn`) and persistent file-based (`file`).
+ * Exported as singleton instance `Interval` for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Interval } from "./classes/Interval";
+ *
+ * const fireOncePerHour = Interval.fn(mySignalFn, { interval: "1h" });
+ * await fireOncePerHour("BTCUSDT"); // fn called — returns its result
+ * await fireOncePerHour("BTCUSDT"); // returns null (same interval)
+ * ```
+ */
+class IntervalUtils {
+    constructor() {
+        /**
+         * Memoized factory to get or create an `IntervalFnInstance` for a function.
+         * Each function reference gets its own isolated instance.
+         */
+        this._getInstance = memoize(([run]) => run, (run, interval) => new IntervalFnInstance(run, interval));
+        /**
+         * Memoized factory to get or create an `IntervalFileInstance` for an async function.
+         * Each function reference gets its own isolated persistent instance.
+         */
+        this._getFileInstance = memoize(([run]) => run, (run, interval, name) => new IntervalFileInstance(run, interval, name));
+        /**
+         * Wrap a signal function with in-memory once-per-interval firing.
+         *
+         * Returns a wrapped version of the function that fires at most once per interval boundary.
+         * If the function returns `null`, the countdown does not start and the next call retries.
+         *
+         * The `run` function reference is used as the memoization key for the underlying
+         * `IntervalFnInstance`, so each unique function reference gets its own isolated instance.
+         *
+         * @param run - Signal function to wrap
+         * @param context.interval - Candle interval that controls the firing boundary
+         * @returns Wrapped function with the same signature as `TIntervalFn<T>`, plus a `clear()` method
+         *
+         * @example
+         * ```typescript
+         * const fireOnce = Interval.fn(mySignalFn, { interval: "15m" });
+         *
+         * await fireOnce("BTCUSDT"); // → T or null  (fn called)
+         * await fireOnce("BTCUSDT"); // → null       (same interval, skipped)
+         * ```
+         */
+        this.fn = (run, context) => {
+            backtest.loggerService.info(INTERVAL_METHOD_NAME_FN, { context });
+            const wrappedFn = (symbol) => {
+                const instance = this._getInstance(run, context.interval);
+                return instance.run(symbol);
+            };
+            wrappedFn.clear = () => {
+                backtest.loggerService.info(INTERVAL_METHOD_NAME_FN_CLEAR);
+                if (!MethodContextService.hasContext()) {
+                    backtest.loggerService.warn(`${INTERVAL_METHOD_NAME_FN_CLEAR} called without method context, skipping`);
+                    return;
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    backtest.loggerService.warn(`${INTERVAL_METHOD_NAME_FN_CLEAR} called without execution context, skipping`);
+                    return;
+                }
+                this._getInstance.get(run)?.clear();
+            };
+            return wrappedFn;
+        };
+        /**
+         * Wrap an async signal function with persistent file-based once-per-interval firing.
+         *
+         * Returns a wrapped version of the function that reads from disk on hit (returns `null`)
+         * and writes the fired signal to disk on the first successful fire.
+         * Fired state survives process restarts.
+         *
+         * The `run` function reference is used as the memoization key for the underlying
+         * `IntervalFileInstance`, so each unique function reference gets its own isolated instance.
+         *
+         * @template T - Async function type to wrap
+         * @param run - Async signal function to wrap with persistent once-per-interval firing
+         * @param context.interval - Candle interval that controls the firing boundary
+         * @param context.name - Human-readable bucket name; becomes the directory prefix
+         * @returns Wrapped function with the same signature as `T`, plus an async `clear()` method
+         *   that deletes persisted records from disk and disposes the memoized instance
+         *
+         * @example
+         * ```typescript
+         * const fetchSignal = async (symbol: string, when: Date) => { ... };
+         * const fireOnce = Interval.file(fetchSignal, { interval: "1h", name: "fetchSignal" });
+         * await fireOnce.clear(); // delete disk records so the function fires again next call
+         * ```
+         */
+        this.file = (run, context) => {
+            backtest.loggerService.info(INTERVAL_METHOD_NAME_FILE, { context });
+            {
+                this._getFileInstance(run, context.interval, context.name);
+            }
+            const wrappedFn = (symbol) => {
+                const instance = this._getFileInstance(run, context.interval, context.name);
+                return instance.run(symbol);
+            };
+            wrappedFn.clear = async () => {
+                backtest.loggerService.info(INTERVAL_METHOD_NAME_FILE_CLEAR);
+                await this._getFileInstance.get(run)?.clear();
+            };
+            return wrappedFn;
+        };
+        /**
+         * Dispose (remove) the memoized `IntervalFnInstance` for a specific function.
+         *
+         * Removes the instance from the internal memoization cache, discarding all in-memory
+         * fired-interval state across all contexts for that function.
+         * The next call to the wrapped function will create a fresh `IntervalFnInstance`.
+         *
+         * @param run - Function whose `IntervalFnInstance` should be disposed
+         *
+         * @example
+         * ```typescript
+         * const fireOnce = Interval.fn(mySignalFn, { interval: "1h" });
+         * Interval.dispose(mySignalFn);
+         * ```
+         */
+        this.dispose = (run) => {
+            backtest.loggerService.info(INTERVAL_METHOD_NAME_DISPOSE, { run });
+            this._getInstance.clear(run);
+        };
+        /**
+         * Clears all memoized `IntervalFnInstance` and `IntervalFileInstance` objects and
+         * resets the `IntervalFileInstance` index counter.
+         * Call this when `process.cwd()` changes between strategy iterations
+         * so new instances are created with the updated base path.
+         */
+        this.clear = () => {
+            backtest.loggerService.info(INTERVAL_METHOD_NAME_CLEAR);
+            this._getInstance.clear();
+            this._getFileInstance.clear();
+            IntervalFileInstance.clearCounter();
+        };
+    }
+}
+/**
+ * Singleton instance of `IntervalUtils` for convenient once-per-interval signal firing.
+ *
+ * @example
+ * ```typescript
+ * import { Interval } from "./classes/Interval";
+ *
+ * // In-memory: fires once per hour, resets on process restart
+ * const fireOnce = Interval.fn(mySignalFn, { interval: "1h" });
+ *
+ * // Persistent: fired state survives restarts
+ * const fireOncePersist = Interval.file(mySignalFn, { interval: "1h", name: "mySignal" });
+ * ```
+ */
+const Interval = new IntervalUtils();
+
 const BREAKEVEN_METHOD_NAME_GET_DATA = "BreakevenUtils.getData";
 const BREAKEVEN_METHOD_NAME_GET_REPORT = "BreakevenUtils.getReport";
 const BREAKEVEN_METHOD_NAME_DUMP = "BreakevenUtils.dump";
@@ -54419,4 +55693,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, ReportWriter, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistIntervalAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, Position, PositionSize, Report, ReportBase, ReportWriter, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };