backtest-kit 6.8.1 → 6.10.0

package/build/index.cjs

@@ -908,7 +908,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,
@@ -922,7 +922,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";
@@ -981,8 +981,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";
@@ -1895,7 +1905,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++) {
@@ -1951,7 +1961,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) {
@@ -2377,7 +2387,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;
         };
@@ -2399,6 +2410,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.
@@ -2409,6 +2441,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
@@ -2438,6 +2491,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 = functoolsKit.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.
  *
@@ -2785,8 +2972,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,
@@ -2818,7 +3005,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;
 };
 /**
@@ -2972,9 +3159,9 @@ const WRITE_CANDLES_CACHE_FN$1 = functoolsKit.trycatch(functoolsKit.queued(async
  * @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
@@ -3088,11 +3275,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);
@@ -3169,11 +3356,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();
@@ -3337,11 +3524,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;
@@ -3470,7 +3657,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);
     }
     /**
@@ -3499,7 +3686,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);
@@ -4478,7 +4665,7 @@ const validateScheduledSignal = (signal, currentPrice) => {
     }
 };
 
-const INTERVAL_MINUTES$6 = {
+const INTERVAL_MINUTES$7 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -4862,7 +5049,7 @@ const GET_SIGNAL_FN = functoolsKit.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)
@@ -7803,6 +7990,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.
      *
@@ -9886,7 +10157,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);
@@ -10153,7 +10424,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$s(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = functoolsKit.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,
@@ -10910,6 +11181,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.
          *
@@ -10948,7 +11303,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;
             }
@@ -11350,7 +11705,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,
@@ -11406,7 +11761,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}`);
     }
@@ -11771,8 +12126,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,
@@ -11804,11 +12159,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);
 };
 
@@ -12117,7 +12472,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);
@@ -12217,7 +12572,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = functoolsKit.memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$r(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = functoolsKit.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,
@@ -12286,7 +12641,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 {
@@ -13330,7 +13685,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);
@@ -13382,7 +13737,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = functoolsKit.memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$q(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = functoolsKit.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,
@@ -13593,7 +13948,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;
             }
@@ -13611,7 +13966,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;
 };
 /**
@@ -13635,7 +13990,7 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([exchangeName]) => CREATE_KEY_FN$p(exchangeName), async (exchangeName) => {
+        this.validate = functoolsKit.memoize(([exchangeName]) => CREATE_KEY_FN$q(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -13887,7 +14242,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);
@@ -13919,7 +14274,7 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$p(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -15071,6 +15426,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);
+        };
     }
 }
 
@@ -15143,7 +15574,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);
@@ -15169,7 +15600,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$n(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -15247,7 +15678,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);
@@ -15291,7 +15722,7 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$m(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$n(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -16886,8 +17317,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,
@@ -16903,7 +17334,7 @@ const INTERVAL_MINUTES$3 = {
 };
 const createEmitter = functoolsKit.memoize(([interval]) => `${interval}`, (interval) => {
     const tickSubject = new functoolsKit.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;
         functoolsKit.Source.fromInterval(EMITTER_CHECK_INTERVAL)
@@ -20287,7 +20718,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);
@@ -20533,7 +20964,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 = functoolsKit.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 = functoolsKit.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.
@@ -20690,7 +21121,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 {
@@ -20752,7 +21183,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);
@@ -21247,7 +21678,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 = functoolsKit.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 = functoolsKit.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.
@@ -21465,7 +21896,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 {
@@ -21485,7 +21916,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);
@@ -21774,7 +22205,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 = functoolsKit.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 = functoolsKit.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.
@@ -21977,7 +22408,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 {
@@ -21997,7 +22428,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);
@@ -22242,7 +22673,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 = functoolsKit.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 = functoolsKit.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.
@@ -22409,7 +22840,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 {
@@ -22888,7 +23319,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);
@@ -23335,7 +23766,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 = functoolsKit.memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$h(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = functoolsKit.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.
@@ -23553,7 +23984,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 {
@@ -24584,7 +25015,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.
  *
@@ -24706,7 +25137,7 @@ class PartialConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$g(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$h(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -24796,7 +25227,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);
         };
     }
@@ -24812,7 +25243,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);
@@ -25035,7 +25466,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 = functoolsKit.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 = functoolsKit.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.
@@ -25245,7 +25676,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 {
@@ -25261,7 +25692,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);
@@ -25335,7 +25766,7 @@ class PartialGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$e(context), (context, methodName) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$f(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -25790,7 +26221,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.
  *
@@ -25876,7 +26307,7 @@ class BreakevenConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientBreakeven instance with logger and event emitter
          */
-        this.getBreakeven = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$d(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$e(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -25937,7 +26368,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);
         };
     }
@@ -25953,7 +26384,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);
@@ -26128,7 +26559,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 = functoolsKit.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 = functoolsKit.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.
@@ -26317,7 +26748,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 {
@@ -26333,7 +26764,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);
@@ -26407,7 +26838,7 @@ class BreakevenGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$b(context), (context, methodName) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$c(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -26628,7 +27059,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);
@@ -26795,7 +27226,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 = functoolsKit.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 = functoolsKit.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.
@@ -26984,7 +27415,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 {
@@ -29363,7 +29794,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);
@@ -29605,7 +30036,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = functoolsKit.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 = functoolsKit.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.
          *
@@ -30173,7 +30604,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 {
@@ -30281,7 +30712,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);
@@ -30474,7 +30905,7 @@ let ReportStorage$2 = class ReportStorage {
 class SyncMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = functoolsKit.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 = functoolsKit.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
@@ -30670,7 +31101,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 {
@@ -30683,7 +31114,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);
@@ -30859,7 +31290,7 @@ let ReportStorage$1 = class ReportStorage {
 class HighestProfitMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = functoolsKit.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 = functoolsKit.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
@@ -31025,7 +31456,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 {
@@ -31047,7 +31478,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);
@@ -31090,7 +31521,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 = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
+        this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
         /**
          * Returns the current market price for the given symbol and context.
          *
@@ -31119,10 +31550,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 functoolsKit.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;
         };
@@ -31164,7 +31595,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);
         };
     }
@@ -31182,7 +31613,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);
@@ -31225,7 +31656,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 = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
+        this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
         /**
          * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
          *
@@ -31253,10 +31684,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 functoolsKit.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;
         };
@@ -31298,7 +31729,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);
         };
     }
@@ -31394,7 +31825,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);
@@ -31518,7 +31949,7 @@ class ReportStorage {
 class MaxDrawdownMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = functoolsKit.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 = functoolsKit.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`.
@@ -31597,7 +32028,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 {
@@ -31851,7 +32282,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).
@@ -31918,7 +32349,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,
@@ -31950,7 +32381,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;
 };
 /**
@@ -32090,11 +32521,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();
@@ -32279,7 +32710,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);
         };
@@ -32311,7 +32742,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) {
@@ -32374,11 +32805,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);
@@ -32668,8 +33099,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,
@@ -32684,7 +33115,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;
@@ -32709,11 +33140,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 = path.join(baseDir, exchangeName, symbol, interval);
     const fromTs = ALIGN_TO_INTERVAL_FN(from.getTime(), step);
     const toTs = ALIGN_TO_INTERVAL_FN(to.getTime(), step);
@@ -32783,11 +33214,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);
@@ -34726,6 +35157,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";
@@ -36360,6 +36795,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.
@@ -38029,6 +38580,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";
@@ -39298,6 +39853,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.
@@ -40423,6 +41090,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";
@@ -41819,6 +42490,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.
@@ -44196,7 +44995,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,
@@ -44518,7 +45317,7 @@ class MemoryDummyInstance {
 class MemoryAdapter {
     constructor() {
         this.MemoryFactory = MemoryPersistInstance;
-        this.getInstance = functoolsKit.memoize(([signalId, bucketName]) => CREATE_KEY_FN$3(signalId, bucketName), (signalId, bucketName) => Reflect.construct(this.MemoryFactory, [signalId, bucketName]));
+        this.getInstance = functoolsKit.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,
@@ -44529,7 +45328,7 @@ class MemoryAdapter {
         this.enable = functoolsKit.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);
@@ -44574,7 +45373,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);
@@ -44596,7 +45395,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);
@@ -44616,7 +45415,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);
@@ -44637,7 +45436,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);
@@ -44660,7 +45459,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);
@@ -44952,7 +45751,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";
@@ -45572,7 +46371,7 @@ class DumpDummyInstance {
 class DumpAdapter {
     constructor() {
         this.DumpFactory = DumpMarkdownInstance;
-        this.getInstance = functoolsKit.memoize(([signalId, bucketName]) => CREATE_KEY_FN$2(signalId, bucketName), (signalId, bucketName) => Reflect.construct(this.DumpFactory, [signalId, bucketName]));
+        this.getInstance = functoolsKit.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,
@@ -45583,7 +46382,7 @@ class DumpAdapter {
         this.enable = functoolsKit.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);
@@ -48517,6 +49316,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";
@@ -50719,7 +51561,7 @@ const StorageBacktest = new StorageBacktestAdapter();
  * Generates a unique key for notification identification.
  * @returns Random string identifier
  */
-const CREATE_KEY_FN$1 = () => functoolsKit.randomString();
+const CREATE_KEY_FN$2 = () => functoolsKit.randomString();
 /**
  * Creates a notification model from signal tick result.
  * Handles opened, closed, scheduled, and cancelled signal actions.
@@ -50730,7 +51572,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,
@@ -50764,7 +51606,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,
@@ -50798,7 +51640,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,
@@ -50831,7 +51673,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,
@@ -50864,7 +51706,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,
@@ -50899,7 +51741,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,
@@ -50934,7 +51776,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,
@@ -50972,7 +51814,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,
@@ -51004,7 +51846,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,
@@ -51036,7 +51878,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,
@@ -51067,7 +51909,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,
@@ -51099,7 +51941,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,
@@ -51131,7 +51973,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,
@@ -51163,7 +52005,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,
@@ -51196,7 +52038,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,
@@ -51219,7 +52061,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,
@@ -51251,7 +52093,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,
@@ -51283,7 +52125,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,
@@ -51321,7 +52163,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,
@@ -51347,7 +52189,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: functoolsKit.errorData(error),
     message: functoolsKit.getErrorMessage(error),
     backtest: false,
@@ -51359,7 +52201,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: functoolsKit.errorData(error),
     message: functoolsKit.getErrorMessage(error),
     backtest: false,
@@ -51371,7 +52213,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: functoolsKit.errorData(error),
     message: functoolsKit.getErrorMessage(error),
     backtest: false,
@@ -52800,7 +53642,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";
@@ -52809,8 +53651,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,
@@ -52844,12 +53686,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;
 };
 /**
@@ -52860,7 +53702,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);
@@ -52884,16 +53726,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")
@@ -52930,7 +53772,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
@@ -52938,26 +53780,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;
                 }
@@ -52980,7 +53822,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
          *
@@ -52990,7 +53832,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)) {
@@ -53010,7 +53852,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
@@ -53019,10 +53861,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++;
@@ -53097,7 +53939,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");
@@ -53111,7 +53953,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);
@@ -53119,9 +53961,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();
     }
 }
@@ -53145,10 +53997,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 = functoolsKit.memoize(([run]) => run, (run, interval, key) => new CacheInstance(run, interval, key));
+        this._getFnInstance = functoolsKit.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.
@@ -53257,31 +54109,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);
          * ```
          */
@@ -53295,7 +54150,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.
          */
@@ -53325,6 +54180,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 = functoolsKit.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 = functoolsKit.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";
@@ -54451,6 +55725,7 @@ exports.Exchange = Exchange;
 exports.ExecutionContextService = ExecutionContextService;
 exports.Heat = Heat;
 exports.HighestProfit = HighestProfit;
+exports.Interval = Interval;
 exports.Live = Live;
 exports.Log = Log;
 exports.Markdown = Markdown;
@@ -54468,6 +55743,7 @@ exports.Performance = Performance;
 exports.PersistBase = PersistBase;
 exports.PersistBreakevenAdapter = PersistBreakevenAdapter;
 exports.PersistCandleAdapter = PersistCandleAdapter;
+exports.PersistIntervalAdapter = PersistIntervalAdapter;
 exports.PersistLogAdapter = PersistLogAdapter;
 exports.PersistMeasureAdapter = PersistMeasureAdapter;
 exports.PersistMemoryAdapter = PersistMemoryAdapter;
@@ -54477,6 +55753,7 @@ exports.PersistRiskAdapter = PersistRiskAdapter;
 exports.PersistScheduleAdapter = PersistScheduleAdapter;
 exports.PersistSignalAdapter = PersistSignalAdapter;
 exports.PersistStorageAdapter = PersistStorageAdapter;
+exports.Position = Position;
 exports.PositionSize = PositionSize;
 exports.Report = Report;
 exports.ReportBase = ReportBase;
@@ -54546,9 +55823,13 @@ exports.getPositionEffectivePrice = getPositionEffectivePrice;
 exports.getPositionEntries = getPositionEntries;
 exports.getPositionEntryOverlap = getPositionEntryOverlap;
 exports.getPositionEstimateMinutes = getPositionEstimateMinutes;
+exports.getPositionHighestMaxDrawdownPnlCost = getPositionHighestMaxDrawdownPnlCost;
+exports.getPositionHighestMaxDrawdownPnlPercentage = getPositionHighestMaxDrawdownPnlPercentage;
 exports.getPositionHighestPnlCost = getPositionHighestPnlCost;
 exports.getPositionHighestPnlPercentage = getPositionHighestPnlPercentage;
 exports.getPositionHighestProfitBreakeven = getPositionHighestProfitBreakeven;
+exports.getPositionHighestProfitDistancePnlCost = getPositionHighestProfitDistancePnlCost;
+exports.getPositionHighestProfitDistancePnlPercentage = getPositionHighestProfitDistancePnlPercentage;
 exports.getPositionHighestProfitMinutes = getPositionHighestProfitMinutes;
 exports.getPositionHighestProfitPrice = getPositionHighestProfitPrice;
 exports.getPositionHighestProfitTimestamp = getPositionHighestProfitTimestamp;