backtest-kit 6.5.2 → 6.7.0

package/build/index.cjs

@@ -128,6 +128,7 @@ const markdownServices$1 = {
     strategyMarkdownService: Symbol('strategyMarkdownService'),
     syncMarkdownService: Symbol('syncMarkdownService'),
     highestProfitMarkdownService: Symbol('highestProfitMarkdownService'),
+    maxDrawdownMarkdownService: Symbol('maxDrawdownMarkdownService'),
 };
 const reportServices$1 = {
     backtestReportService: Symbol('backtestReportService'),
@@ -142,6 +143,7 @@ const reportServices$1 = {
     strategyReportService: Symbol('strategyReportService'),
     syncReportService: Symbol('syncReportService'),
     highestProfitReportService: Symbol('highestProfitReportService'),
+    maxDrawdownReportService: Symbol('maxDrawdownReportService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -473,6 +475,13 @@ const GLOBAL_CONFIG = {
      * Default: 250 events
      */
     CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: 250,
+    /**
+     * Maximum number of events to keep in max drawdown markdown report storage.
+     * Older events are removed (FIFO) when this limit is exceeded.
+     *
+     * Default: 250 events
+     */
+    CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS: 250,
     /**
      * Maximum number of events to keep in live markdown report storage.
      * Older events are removed (FIFO) when this limit is exceeded.
@@ -747,6 +756,12 @@ const backtestScheduleOpenSubject = new functoolsKit.Subject();
  * Allows users to track profit milestones and implement custom management logic based on profit levels.
  */
 const highestProfitSubject = new functoolsKit.Subject();
+/**
+ * Max drawdown emitter for real-time risk tracking.
+ * Emits updates on the maximum drawdown experienced for an open position.
+ * Allows users to track drawdown levels and implement custom risk management logic based on drawdown thresholds.
+ */
+const maxDrawdownSubject = new functoolsKit.Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -759,6 +774,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     errorEmitter: errorEmitter,
     exitEmitter: exitEmitter,
     highestProfitSubject: highestProfitSubject,
+    maxDrawdownSubject: maxDrawdownSubject,
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
@@ -4888,6 +4904,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
                 _isScheduled: false,
                 _entry: [{ price: signal.priceOpen, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
                 _peak: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
+                _fall: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
             };
             // Валидируем сигнал перед возвратом
             validatePendingSignal(signalRow, currentPrice);
@@ -4913,6 +4930,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             _isScheduled: true,
             _entry: [{ price: signal.priceOpen, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
             _peak: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
+            _fall: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
         };
         // Валидируем сигнал перед возвратом
         validateScheduledSignal(scheduledSignalRow, currentPrice);
@@ -4935,6 +4953,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         _isScheduled: false,
         _entry: [{ price: currentPrice, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
         _peak: { price: currentPrice, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
+        _fall: { price: currentPrice, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
     };
     // Валидируем сигнал перед возвратом
     validatePendingSignal(signalRow, currentPrice);
@@ -5646,6 +5665,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         pendingAt: activationTime,
         _isScheduled: false,
         _peak: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0 },
+        _fall: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0 },
     };
     // Sync open: if external system rejects — cancel scheduled signal instead of opening
     const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(activationTime, activatedSignal.priceOpen, activatedSignal, self);
@@ -6320,6 +6340,15 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice, backt
                 const slDistance = effectivePriceOpen - effectiveStopLoss;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
+                if (currentPrice < signal._fall.price) {
+                    const { pnl } = TO_PUBLIC_SIGNAL(signal, currentPrice);
+                    signal._fall = { price: currentPrice, timestamp: currentTime, pnlCost: pnl.pnlCost, pnlPercentage: pnl.pnlPercentage };
+                    if (self.params.callbacks?.onWrite) {
+                        self.params.callbacks.onWrite(signal.symbol, signal, backtest);
+                    }
+                    !backtest && await PersistSignalAdapter.writeSignalData(signal, self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
+                    await self.params.onMaxDrawdown(TO_PUBLIC_SIGNAL(signal, currentPrice), currentPrice, currentTime);
+                }
                 await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
             }
         }
@@ -6353,6 +6382,15 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice, backt
                 const slDistance = effectiveStopLoss - effectivePriceOpen;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
+                if (currentPrice > signal._fall.price) {
+                    const { pnl } = TO_PUBLIC_SIGNAL(signal, currentPrice);
+                    signal._fall = { price: currentPrice, timestamp: currentTime, pnlCost: pnl.pnlCost, pnlPercentage: pnl.pnlPercentage };
+                    if (self.params.callbacks?.onWrite) {
+                        self.params.callbacks.onWrite(signal.symbol, signal, backtest);
+                    }
+                    !backtest && await PersistSignalAdapter.writeSignalData(signal, self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
+                    await self.params.onMaxDrawdown(TO_PUBLIC_SIGNAL(signal, currentPrice), currentPrice, currentTime);
+                }
                 await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
             }
         }
@@ -6473,6 +6511,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         pendingAt: activationTime,
         _isScheduled: false,
         _peak: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0 },
+        _fall: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0 },
     };
     // Sync open: if external system rejects — cancel scheduled signal instead of opening
     const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(activationTime, activatedSignal.priceOpen, activatedSignal, self);
@@ -6659,6 +6698,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
                 pendingAt: candle.timestamp,
                 _isScheduled: false,
                 _peak: { price: activatedSignal.priceOpen, timestamp: candle.timestamp, pnlPercentage: 0, pnlCost: 0 },
+                _fall: { price: activatedSignal.priceOpen, timestamp: candle.timestamp, pnlPercentage: 0, pnlCost: 0 },
             };
             // Sync open: if external system rejects — cancel scheduled signal instead of opening
             const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(candle.timestamp, pendingSignal.priceOpen, pendingSignal, self);
@@ -6883,6 +6923,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEnd
                     const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
                     const slDistance = effectivePriceOpen - effectiveStopLoss;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
+                    if (averagePrice < signal._fall.price) {
+                        const { pnl } = TO_PUBLIC_SIGNAL(signal, averagePrice);
+                        signal._fall = { price: averagePrice, timestamp: currentCandleTimestamp, pnlCost: pnl.pnlCost, pnlPercentage: pnl.pnlPercentage };
+                        if (self.params.callbacks?.onWrite) {
+                            self.params.callbacks.onWrite(signal.symbol, signal, true);
+                        }
+                        await self.params.onMaxDrawdown(TO_PUBLIC_SIGNAL(signal, averagePrice), averagePrice, currentCandleTimestamp);
+                    }
                     await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
             }
@@ -6913,6 +6961,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEnd
                     const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
                     const slDistance = effectiveStopLoss - effectivePriceOpen;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
+                    if (averagePrice > signal._fall.price) {
+                        const { pnl } = TO_PUBLIC_SIGNAL(signal, averagePrice);
+                        signal._fall = { price: averagePrice, timestamp: currentCandleTimestamp, pnlCost: pnl.pnlCost, pnlPercentage: pnl.pnlPercentage };
+                        if (self.params.callbacks?.onWrite) {
+                            self.params.callbacks.onWrite(signal.symbol, signal, true);
+                        }
+                        await self.params.onMaxDrawdown(TO_PUBLIC_SIGNAL(signal, averagePrice), averagePrice, currentCandleTimestamp);
+                    }
                     await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
             }
@@ -7634,6 +7690,104 @@ class ClientStrategy {
         }
         return Math.floor((timestamp - this._pendingSignal._peak.timestamp) / 60000);
     }
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to minutes since last profit peak or null
+     */
+    async getPositionHighestProfitMinutes(symbol, timestamp) {
+        this.params.logger.debug("ClientStrategy getPositionHighestProfitMinutes", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return Math.floor((timestamp - this._pendingSignal._peak.timestamp) / 60000);
+    }
+    /**
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to minutes since last drawdown trough or null
+     */
+    async getPositionMaxDrawdownMinutes(symbol, timestamp) {
+        this.params.logger.debug("ClientStrategy getPositionMaxDrawdownMinutes", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return Math.floor((timestamp - this._pendingSignal._fall.timestamp) / 60000);
+    }
+    /**
+     * Returns the worst price reached in the loss direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to price or null
+     */
+    async getPositionMaxDrawdownPrice(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionMaxDrawdownPrice", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._fall.price;
+    }
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    async getPositionMaxDrawdownTimestamp(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionMaxDrawdownTimestamp", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._fall.timestamp;
+    }
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL percentage or null
+     */
+    async getPositionMaxDrawdownPnlPercentage(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionMaxDrawdownPnlPercentage", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._fall.pnlPercentage;
+    }
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL cost or null
+     */
+    async getPositionMaxDrawdownPnlCost(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionMaxDrawdownPnlCost", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._fall.pnlCost;
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -7810,6 +7964,7 @@ class ClientStrategy {
                 pendingAt: currentTime,
                 _isScheduled: false,
                 _peak: { price: activatedSignal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
+                _fall: { price: activatedSignal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
             };
             const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(currentTime, currentPrice, pendingSignal, this);
             if (!syncOpenAllowed) {
@@ -9926,7 +10081,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$r = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$s = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -10087,6 +10242,42 @@ const CREATE_HIGHEST_PROFIT_FN = (self, strategyName, exchangeName, frameName, i
     },
     defaultValue: null,
 });
+/**
+ * Creates a callback function for emitting max drawdown updates to maxDrawdownSubject.
+ * Called by ClientStrategy when the maximum drawdown for an open position is updated.
+ * Emits MaxDrawdownContract event to all subscribers with the current price and timestamp.
+ * Used for real-time risk tracking and management logic based on drawdown levels.
+ * @param self - Reference to StrategyConnectionService instance
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Name of the exchange
+ * @param frameName - Name of the frame
+ * @param isBacktest - Flag indicating if the operation is for backtesting
+ * @return Callback function for max drawdown updates
+ */
+const CREATE_MAX_DRAWDOWN_FN = (self, strategyName, exchangeName, frameName, isBacktest) => functoolsKit.trycatch(async (signal, currentPrice, timestamp) => {
+    await maxDrawdownSubject.next({
+        symbol: signal.symbol,
+        signal,
+        currentPrice,
+        timestamp,
+        strategyName,
+        exchangeName,
+        frameName,
+        backtest: isBacktest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_MAX_DRAWDOWN_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting dispose events.
  *
@@ -10157,7 +10348,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$r(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$s(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -10186,6 +10377,7 @@ class StrategyConnectionService {
                 onCommit: CREATE_COMMIT_FN(),
                 onSignalSync: CREATE_SYNC_FN(this, strategyName, exchangeName, frameName, backtest),
                 onHighestProfit: CREATE_HIGHEST_PROFIT_FN(this, strategyName, exchangeName, frameName, backtest),
+                onMaxDrawdown: CREATE_MAX_DRAWDOWN_FN(this, strategyName, exchangeName, frameName, backtest),
             });
         });
         /**
@@ -10789,6 +10981,130 @@ class StrategyConnectionService {
             const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
             return await strategy.getPositionDrawdownMinutes(symbol, timestamp);
         };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Alias for getPositionDrawdownMinutes — measures how long the position has been
+         * pulling back from its peak profit level.
+         *
+         * Resolves current timestamp via timeMetaService and delegates to
+         * ClientStrategy.getPositionHighestProfitMinutes().
+         * 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 minutes since last profit peak or null
+         */
+        this.getPositionHighestProfitMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestProfitMinutes", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.getPositionHighestProfitMinutes(symbol, timestamp);
+        };
+        /**
+         * Returns the number of minutes elapsed since the worst loss price was recorded.
+         *
+         * Measures how long ago the deepest drawdown point occurred.
+         * Zero when called at the exact moment the trough was set.
+         *
+         * Resolves current timestamp via timeMetaService and delegates to
+         * ClientStrategy.getPositionMaxDrawdownMinutes().
+         * 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 minutes since last drawdown trough or null
+         */
+        this.getPositionMaxDrawdownMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionMaxDrawdownMinutes", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.getPositionMaxDrawdownMinutes(symbol, timestamp);
+        };
+        /**
+         * Returns the worst price reached in the loss direction during this position's life.
+         *
+         * Delegates to ClientStrategy.getPositionMaxDrawdownPrice().
+         * 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 price or null
+         */
+        this.getPositionMaxDrawdownPrice = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionMaxDrawdownPrice", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionMaxDrawdownPrice(symbol);
+        };
+        /**
+         * Returns the timestamp when the worst loss price was recorded during this position's life.
+         *
+         * Delegates to ClientStrategy.getPositionMaxDrawdownTimestamp().
+         * 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 timestamp in milliseconds or null
+         */
+        this.getPositionMaxDrawdownTimestamp = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionMaxDrawdownTimestamp", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionMaxDrawdownTimestamp(symbol);
+        };
+        /**
+         * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+         *
+         * Delegates to ClientStrategy.getPositionMaxDrawdownPnlPercentage().
+         * 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 PnL percentage or null
+         */
+        this.getPositionMaxDrawdownPnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionMaxDrawdownPnlPercentage", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionMaxDrawdownPnlPercentage(symbol);
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+         *
+         * Delegates to ClientStrategy.getPositionMaxDrawdownPnlCost().
+         * 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 PnL cost or null
+         */
+        this.getPositionMaxDrawdownPnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionMaxDrawdownPnlCost", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionMaxDrawdownPnlCost(symbol);
+        };
         /**
          * Disposes the ClientStrategy instance for the given context.
          *
@@ -10827,7 +11143,7 @@ class StrategyConnectionService {
                 }
                 return;
             }
-            const key = CREATE_KEY_FN$r(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$s(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getStrategy.has(key)) {
                 return;
             }
@@ -12003,7 +12319,7 @@ class ClientRisk {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$q = (riskName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$r = (riskName, exchangeName, frameName, backtest) => {
     const parts = [riskName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -12102,7 +12418,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$q(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = functoolsKit.memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$r(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
@@ -12170,7 +12486,7 @@ class RiskConnectionService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$q(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$r(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -13677,7 +13993,7 @@ class ClientAction {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$p = (actionName, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$q = (actionName, strategyName, exchangeName, frameName, backtest) => {
     const parts = [actionName, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -13728,7 +14044,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$p(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = functoolsKit.memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$q(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
             const schema = this.actionSchemaService.get(actionName);
             return new ClientAction({
                 ...schema,
@@ -13938,7 +14254,7 @@ class ActionConnectionService {
                 await Promise.all(actions.map(async (action) => await action.dispose()));
                 return;
             }
-            const key = CREATE_KEY_FN$p(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$q(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getAction.has(key)) {
                 return;
             }
@@ -13956,7 +14272,7 @@ const METHOD_NAME_VALIDATE$2 = "exchangeCoreService validate";
  * @param exchangeName - Exchange name
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$o = (exchangeName) => {
+const CREATE_KEY_FN$p = (exchangeName) => {
     return exchangeName;
 };
 /**
@@ -13980,7 +14296,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$o(exchangeName), async (exchangeName) => {
+        this.validate = functoolsKit.memoize(([exchangeName]) => CREATE_KEY_FN$p(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -14232,7 +14548,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$n = (context) => {
+const CREATE_KEY_FN$o = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -14264,7 +14580,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$n(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -15308,6 +15624,114 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.getPositionDrawdownMinutes(backtest, symbol, context);
         };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Alias for getPositionDrawdownMinutes — measures how long the position has been
+         * pulling back from its peak profit level.
+         *
+         * Validates strategy existence and delegates to connection service.
+         * 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 minutes since last profit peak or null
+         */
+        this.getPositionHighestProfitMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestProfitMinutes", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestProfitMinutes(backtest, symbol, context);
+        };
+        /**
+         * Returns the number of minutes elapsed since the worst loss price was recorded.
+         *
+         * Measures how long ago the deepest drawdown point occurred.
+         * Zero when called at the exact moment the trough was set.
+         *
+         * Validates strategy existence and delegates to connection service.
+         * 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 minutes since last drawdown trough or null
+         */
+        this.getPositionMaxDrawdownMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionMaxDrawdownMinutes", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionMaxDrawdownMinutes(backtest, symbol, context);
+        };
+        /**
+         * Returns the worst price reached in the loss direction during this position's life.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to price or null
+         */
+        this.getPositionMaxDrawdownPrice = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionMaxDrawdownPrice", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionMaxDrawdownPrice(backtest, symbol, context);
+        };
+        /**
+         * Returns the timestamp when the worst loss price was recorded during this position's life.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to timestamp in milliseconds or null
+         */
+        this.getPositionMaxDrawdownTimestamp = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionMaxDrawdownTimestamp", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionMaxDrawdownTimestamp(backtest, symbol, context);
+        };
+        /**
+         * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to PnL percentage or null
+         */
+        this.getPositionMaxDrawdownPnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionMaxDrawdownPnlPercentage", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionMaxDrawdownPnlPercentage(backtest, symbol, context);
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to PnL cost or null
+         */
+        this.getPositionMaxDrawdownPnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionMaxDrawdownPnlCost", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionMaxDrawdownPnlCost(backtest, symbol, context);
+        };
     }
 }
 
@@ -15380,7 +15804,7 @@ class SizingGlobalService {
  * @param context - Context with riskName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$m = (context) => {
+const CREATE_KEY_FN$n = (context) => {
     const parts = [context.riskName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -15406,7 +15830,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$m(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$n(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -15484,7 +15908,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$l = (context) => {
+const CREATE_KEY_FN$m = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -15528,7 +15952,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$l(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$m(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -18075,6 +18499,21 @@ const backtest_columns = [
         format: (data) => new Date(data.closeTimestamp).toISOString(),
         isVisible: () => true,
     },
+    {
+        key: "peakPnl",
+        label: "Peak PNL",
+        format: (data) => {
+            const v = data.signal._peak?.pnlPercentage;
+            return `${v > 0 ? "+" : ""}${v.toFixed(2)}%`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "fallPnl",
+        label: "Max DD PNL",
+        format: (data) => `${data.signal._fall?.pnlPercentage.toFixed(2)}%`,
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -18185,6 +18624,18 @@ const heat_columns = [
         format: (data) => data.totalTrades.toString(),
         isVisible: () => true,
     },
+    {
+        key: "avgPeakPnl",
+        label: "Avg Peak PNL",
+        format: (data) => data.avgPeakPnl !== null ? functoolsKit.str(data.avgPeakPnl, "%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgFallPnl",
+        label: "Avg DD PNL",
+        format: (data) => data.avgFallPnl !== null ? functoolsKit.str(data.avgFallPnl, "%") : "N/A",
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -18382,6 +18833,22 @@ const live_columns = [
         format: (data) => data.scheduledAt !== undefined ? new Date(data.scheduledAt).toISOString() : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "peakPnl",
+        label: "Peak PNL",
+        format: (data) => {
+            if (data.peakPnl === undefined)
+                return "N/A";
+            return `${data.peakPnl > 0 ? "+" : ""}${data.peakPnl.toFixed(2)}%`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "fallPnl",
+        label: "Max DD PNL",
+        format: (data) => data.fallPnl !== undefined ? `${data.fallPnl.toFixed(2)}%` : "N/A",
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -19543,6 +20010,93 @@ const highest_profit_columns = [
     },
 ];
 
+/**
+ * Column configuration for max drawdown markdown reports.
+ *
+ * Defines the table structure for displaying max-drawdown-record events.
+ *
+ * @see MaxDrawdownMarkdownService
+ * @see ColumnModel
+ * @see MaxDrawdownEvent
+ */
+const max_drawdown_columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "pnl",
+        label: "PNL (net)",
+        format: (data) => {
+            const pnlPercentage = data.pnl.pnlPercentage;
+            return `${pnlPercentage > 0 ? "+" : ""}${pnlPercentage.toFixed(2)}%`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "pnlCost",
+        label: "PNL (USD)",
+        format: (data) => `${data.pnl.pnlCost > 0 ? "+" : ""}${data.pnl.pnlCost.toFixed(2)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "currentPrice",
+        label: "DD Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "priceOpen",
+        label: "Entry Price",
+        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "priceTakeProfit",
+        label: "Take Profit",
+        format: (data) => `${data.priceTakeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "priceStopLoss",
+        label: "Stop Loss",
+        format: (data) => `${data.priceStopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "mode",
+        label: "Mode",
+        format: (data) => (data.backtest ? "Backtest" : "Live"),
+        isVisible: () => true,
+    },
+];
+
 /**
  * Column configuration for walker strategy comparison table in markdown reports.
  *
@@ -19778,6 +20332,8 @@ const COLUMN_CONFIG = {
     sync_columns,
     /** Columns for highest profit milestone tracking events */
     highest_profit_columns,
+    /** Columns for max drawdown milestone tracking events */
+    max_drawdown_columns,
     /** Walker: PnL summary columns */
     walker_pnl_columns,
     /** Walker: strategy-level summary columns */
@@ -19822,6 +20378,7 @@ const WILDCARD_TARGET$1 = {
     walker: true,
     sync: true,
     highest_profit: true,
+    max_drawdown: true,
 };
 /**
  * JSONL-based markdown adapter with append-only writes.
@@ -20049,7 +20606,7 @@ class MarkdownUtils {
          *
          * @returns Cleanup function that unsubscribes from all enabled services
          */
-        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, strategy = false, risk = false, schedule = false, walker = false, sync = false, highest_profit = false, } = WILDCARD_TARGET$1) => {
+        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, strategy = false, risk = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
             bt.loggerService.debug(MARKDOWN_METHOD_NAME_ENABLE, {
                 backtest: bt$1,
                 breakeven,
@@ -20101,6 +20658,9 @@ class MarkdownUtils {
             if (highest_profit) {
                 unList.push(bt.highestProfitMarkdownService.subscribe());
             }
+            if (max_drawdown) {
+                unList.push(bt.maxDrawdownMarkdownService.subscribe());
+            }
             return functoolsKit.compose(...unList.map((un) => () => void un()));
         };
         /**
@@ -20140,7 +20700,7 @@ class MarkdownUtils {
          * Markdown.disable();
          * ```
          */
-        this.disable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, } = WILDCARD_TARGET$1) => {
+        this.disable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
             bt.loggerService.debug(MARKDOWN_METHOD_NAME_DISABLE, {
                 backtest: bt$1,
                 breakeven,
@@ -20191,6 +20751,9 @@ class MarkdownUtils {
             if (highest_profit) {
                 bt.highestProfitMarkdownService.unsubscribe();
             }
+            if (max_drawdown) {
+                bt.maxDrawdownMarkdownService.unsubscribe();
+            }
         };
     }
 }
@@ -20306,7 +20869,7 @@ const Markdown = new MarkdownAdapter();
  * @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);
@@ -20323,7 +20886,7 @@ const CREATE_KEY_FN$k = (symbol, strategyName, exchangeName, frameName, backtest
  * @param timestamp - Unix timestamp in milliseconds
  * @returns Filename string
  */
-const CREATE_FILE_NAME_FN$b = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$c = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -20355,7 +20918,7 @@ function isUnsafe$3(value) {
  * Storage class for accumulating closed signals per strategy.
  * Maintains a list of all closed signals and provides methods to generate reports.
  */
-let ReportStorage$9 = class ReportStorage {
+let ReportStorage$a = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -20397,6 +20960,8 @@ let ReportStorage$9 = class ReportStorage {
                 annualizedSharpeRatio: null,
                 certaintyRatio: null,
                 expectedYearlyReturns: null,
+                avgPeakPnl: null,
+                avgFallPnl: null,
             };
         }
         const totalSignals = this._signalList.length;
@@ -20427,6 +20992,9 @@ let ReportStorage$9 = class ReportStorage {
         const avgDurationDays = avgDurationMs / (1000 * 60 * 60 * 24);
         const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
         const expectedYearlyReturns = avgPnl * tradesPerYear;
+        // Calculate average peak and fall PNL across all signals
+        const avgPeakPnl = this._signalList.reduce((sum, s) => sum + (s.signal._peak?.pnlPercentage ?? 0), 0) / totalSignals;
+        const avgFallPnl = this._signalList.reduce((sum, s) => sum + (s.signal._fall?.pnlPercentage ?? 0), 0) / totalSignals;
         return {
             signalList: this._signalList,
             totalSignals,
@@ -20440,6 +21008,8 @@ let ReportStorage$9 = class ReportStorage {
             annualizedSharpeRatio: isUnsafe$3(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
             certaintyRatio: isUnsafe$3(certaintyRatio) ? null : certaintyRatio,
             expectedYearlyReturns: isUnsafe$3(expectedYearlyReturns) ? null : expectedYearlyReturns,
+            avgPeakPnl: isUnsafe$3(avgPeakPnl) ? null : avgPeakPnl,
+            avgFallPnl: isUnsafe$3(avgFallPnl) ? null : avgFallPnl,
         };
     }
     /**
@@ -20484,6 +21054,8 @@ let ReportStorage$9 = class ReportStorage {
             `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`,
             `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`,
             `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`,
+            `**Avg Peak PNL:** ${stats.avgPeakPnl === null ? "N/A" : `${stats.avgPeakPnl > 0 ? "+" : ""}${stats.avgPeakPnl.toFixed(2)}% (higher is better)`}`,
+            `**Avg Max Drawdown PNL:** ${stats.avgFallPnl === null ? "N/A" : `${stats.avgFallPnl.toFixed(2)}% (closer to 0 is better)`}`,
         ].join("\n");
     }
     /**
@@ -20496,7 +21068,7 @@ let ReportStorage$9 = class ReportStorage {
     async dump(strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$b(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$c(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("backtest", markdown, {
             path,
             file: filename,
@@ -20543,7 +21115,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$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$a(symbol, strategyName, exchangeName, frameName));
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -20700,7 +21272,7 @@ class BacktestMarkdownService {
                 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 {
@@ -20762,7 +21334,7 @@ class BacktestMarkdownService {
  * @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);
@@ -20779,7 +21351,7 @@ const CREATE_KEY_FN$j = (symbol, strategyName, exchangeName, frameName, backtest
  * @param timestamp - Unix timestamp in milliseconds
  * @returns Filename string
  */
-const CREATE_FILE_NAME_FN$a = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$b = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -20811,7 +21383,7 @@ function isUnsafe$2(value) {
  * Storage class for accumulating all tick events per strategy.
  * Maintains a chronological list of all events (idle, opened, active, closed).
  */
-let ReportStorage$8 = class ReportStorage {
+let ReportStorage$9 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -20951,6 +21523,8 @@ let ReportStorage$8 = class ReportStorage {
             duration: durationMin,
             pendingAt: data.signal.pendingAt,
             scheduledAt: data.signal.scheduledAt,
+            peakPnl: data.signal._peak?.pnlPercentage,
+            fallPnl: data.signal._fall?.pnlPercentage,
         };
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded GLOBAL_CONFIG.CC_MAX_LIVE_MARKDOWN_ROWS
@@ -21080,6 +21654,8 @@ let ReportStorage$8 = class ReportStorage {
                 annualizedSharpeRatio: null,
                 certaintyRatio: null,
                 expectedYearlyReturns: null,
+                avgPeakPnl: null,
+                avgFallPnl: null,
             };
         }
         const closedEvents = this._eventList.filter((e) => e.action === "closed");
@@ -21123,6 +21699,12 @@ let ReportStorage$8 = class ReportStorage {
             const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
             expectedYearlyReturns = avgPnl * tradesPerYear;
         }
+        const avgPeakPnl = totalClosed > 0
+            ? closedEvents.reduce((sum, e) => sum + (e.peakPnl || 0), 0) / totalClosed
+            : 0;
+        const avgFallPnl = totalClosed > 0
+            ? closedEvents.reduce((sum, e) => sum + (e.fallPnl || 0), 0) / totalClosed
+            : 0;
         return {
             eventList: this._eventList,
             totalEvents: this._eventList.length,
@@ -21137,6 +21719,8 @@ let ReportStorage$8 = class ReportStorage {
             annualizedSharpeRatio: isUnsafe$2(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
             certaintyRatio: isUnsafe$2(certaintyRatio) ? null : certaintyRatio,
             expectedYearlyReturns: isUnsafe$2(expectedYearlyReturns) ? null : expectedYearlyReturns,
+            avgPeakPnl: isUnsafe$2(avgPeakPnl) ? null : avgPeakPnl,
+            avgFallPnl: isUnsafe$2(avgFallPnl) ? null : avgFallPnl,
         };
     }
     /**
@@ -21181,6 +21765,8 @@ let ReportStorage$8 = class ReportStorage {
             `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`,
             `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`,
             `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`,
+            `**Avg Peak PNL:** ${stats.avgPeakPnl === null ? "N/A" : `${stats.avgPeakPnl > 0 ? "+" : ""}${stats.avgPeakPnl.toFixed(2)}% (higher is better)`}`,
+            `**Avg Max Drawdown PNL:** ${stats.avgFallPnl === null ? "N/A" : `${stats.avgFallPnl.toFixed(2)}% (closer to 0 is better)`}`,
         ].join("\n");
     }
     /**
@@ -21193,7 +21779,7 @@ let ReportStorage$8 = class ReportStorage {
     async dump(strategyName, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$a(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$b(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("live", markdown, {
             path,
             signalId: "",
@@ -21243,7 +21829,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$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$9(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to live signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -21461,7 +22047,7 @@ class LiveMarkdownService {
                 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 {
@@ -21481,7 +22067,7 @@ class LiveMarkdownService {
  * @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);
@@ -21498,7 +22084,7 @@ const CREATE_KEY_FN$i = (symbol, strategyName, exchangeName, frameName, backtest
  * @param timestamp - Unix timestamp in milliseconds
  * @returns Filename string
  */
-const CREATE_FILE_NAME_FN$9 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$a = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -21512,7 +22098,7 @@ const CREATE_FILE_NAME_FN$9 = (symbol, strategyName, exchangeName, frameName, ti
  * Storage class for accumulating scheduled signal events per strategy.
  * Maintains a chronological list of scheduled and cancelled events.
  */
-let ReportStorage$7 = class ReportStorage {
+let ReportStorage$8 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -21729,7 +22315,7 @@ let ReportStorage$7 = class ReportStorage {
     async dump(strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$9(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$a(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("schedule", markdown, {
             path,
             file: filename,
@@ -21770,7 +22356,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$i(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$7(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 ReportStorage$8(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to signal emitter to receive scheduled signal events.
          * Protected against multiple subscriptions.
@@ -21973,7 +22559,7 @@ class ScheduleMarkdownService {
                 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 {
@@ -21993,7 +22579,7 @@ class ScheduleMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$h = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$i = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -22010,7 +22596,7 @@ const CREATE_KEY_FN$h = (symbol, strategyName, exchangeName, frameName, backtest
  * @param timestamp - Unix timestamp in milliseconds
  * @returns Filename string
  */
-const CREATE_FILE_NAME_FN$8 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$9 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -22191,7 +22777,7 @@ class PerformanceStorage {
     async dump(strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$8(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$9(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("performance", markdown, {
             path,
             file: filename,
@@ -22238,7 +22824,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$h(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$i(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.
@@ -22405,7 +22991,7 @@ class PerformanceMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$h(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$i(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -22419,7 +23005,7 @@ class PerformanceMarkdownService {
  * Creates a filename for markdown report based on walker name.
  * Filename format: "walkerName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$7 = (walkerName, timestamp) => {
+const CREATE_FILE_NAME_FN$8 = (walkerName, timestamp) => {
     return `${walkerName}-${timestamp}.md`;
 };
 /**
@@ -22454,7 +23040,7 @@ function formatMetric(value) {
  * Storage class for accumulating walker results.
  * Maintains a list of all strategy results and provides methods to generate reports.
  */
-let ReportStorage$6 = class ReportStorage {
+let ReportStorage$7 = class ReportStorage {
     constructor(walkerName) {
         this.walkerName = walkerName;
         /** Walker metadata (set from first addResult call) */
@@ -22651,7 +23237,7 @@ let ReportStorage$6 = class ReportStorage {
     async dump(symbol, metric, context, path = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
         const markdown = await this.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$7(this.walkerName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$8(this.walkerName, timestamp);
         await Markdown.writeData("walker", markdown, {
             path,
             file: filename,
@@ -22687,7 +23273,7 @@ class WalkerMarkdownService {
          * Memoized function to get or create ReportStorage for a walker.
          * Each walker gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$6(walkerName));
+        this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$7(walkerName));
         /**
          * Subscribes to walker emitter to receive walker progress events.
          * Protected against multiple subscriptions.
@@ -22884,7 +23470,7 @@ class WalkerMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$g = (exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$h = (exchangeName, frameName, backtest) => {
     const parts = [exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -22895,7 +23481,7 @@ const CREATE_KEY_FN$g = (exchangeName, frameName, backtest) => {
  * Creates a filename for markdown report based on memoization key components.
  * Filename format: "strategyName_exchangeName_frameName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$6 = (strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$7 = (strategyName, exchangeName, frameName, timestamp) => {
     const parts = [strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -23085,6 +23671,13 @@ class HeatmapStorage {
             const lossRate = 100 - winRate;
             expectancy = (winRate / 100) * avgWin + (lossRate / 100) * avgLoss;
         }
+        // Calculate average peak and fall PNL
+        let avgPeakPnl = null;
+        let avgFallPnl = null;
+        if (signals.length > 0) {
+            avgPeakPnl = signals.reduce((acc, s) => acc + (s.signal._peak?.pnlPercentage ?? 0), 0) / signals.length;
+            avgFallPnl = signals.reduce((acc, s) => acc + (s.signal._fall?.pnlPercentage ?? 0), 0) / signals.length;
+        }
         // Apply safe math checks
         if (isUnsafe(winRate))
             winRate = null;
@@ -23106,6 +23699,10 @@ class HeatmapStorage {
             avgLoss = null;
         if (isUnsafe(expectancy))
             expectancy = null;
+        if (isUnsafe(avgPeakPnl))
+            avgPeakPnl = null;
+        if (isUnsafe(avgFallPnl))
+            avgFallPnl = null;
         return {
             symbol,
             totalPnl,
@@ -23123,6 +23720,8 @@ class HeatmapStorage {
             maxWinStreak,
             maxLossStreak,
             expectancy,
+            avgPeakPnl,
+            avgFallPnl,
         };
     }
     /**
@@ -23172,17 +23771,34 @@ class HeatmapStorage {
             const weightedSum = validSharpes.reduce((acc, s) => acc + s.sharpeRatio * s.totalTrades, 0);
             portfolioSharpeRatio = weightedSum / portfolioTotalTrades;
         }
+        // Calculate portfolio-wide weighted average peak/fall PNL
+        let portfolioAvgPeakPnl = null;
+        let portfolioAvgFallPnl = null;
+        const validPeak = symbols.filter((s) => s.avgPeakPnl !== null);
+        const validFall = symbols.filter((s) => s.avgFallPnl !== null);
+        if (validPeak.length > 0 && portfolioTotalTrades > 0) {
+            portfolioAvgPeakPnl = validPeak.reduce((acc, s) => acc + s.avgPeakPnl * s.totalTrades, 0) / portfolioTotalTrades;
+        }
+        if (validFall.length > 0 && portfolioTotalTrades > 0) {
+            portfolioAvgFallPnl = validFall.reduce((acc, s) => acc + s.avgFallPnl * s.totalTrades, 0) / portfolioTotalTrades;
+        }
         // Apply safe math
         if (isUnsafe(portfolioTotalPnl))
             portfolioTotalPnl = null;
         if (isUnsafe(portfolioSharpeRatio))
             portfolioSharpeRatio = null;
+        if (isUnsafe(portfolioAvgPeakPnl))
+            portfolioAvgPeakPnl = null;
+        if (isUnsafe(portfolioAvgFallPnl))
+            portfolioAvgFallPnl = null;
         return {
             symbols,
             totalSymbols,
             portfolioTotalPnl,
             portfolioSharpeRatio,
             portfolioTotalTrades,
+            portfolioAvgPeakPnl,
+            portfolioAvgFallPnl,
         };
     }
     /**
@@ -23231,7 +23847,7 @@ class HeatmapStorage {
         return [
             `# Portfolio Heatmap: ${strategyName}`,
             "",
-            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`,
+            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades} | **Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? functoolsKit.str(data.portfolioAvgPeakPnl, "%") : "N/A"} | **Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? functoolsKit.str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
             "",
             table
         ].join("\n");
@@ -23255,7 +23871,7 @@ class HeatmapStorage {
     async dump(strategyName, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$6(strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$7(strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("heat", markdown, {
             path,
             file: filename,
@@ -23301,7 +23917,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$g(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = functoolsKit.memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$h(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
         /**
          * Subscribes to signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -23519,7 +24135,7 @@ class HeatMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$g(payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$h(payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -24550,7 +25166,7 @@ class ClientPartial {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$f = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$g = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting profit events to partialProfitSubject.
  *
@@ -24672,7 +25288,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$f(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$g(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -24762,7 +25378,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$f(data.id, backtest);
+            const key = CREATE_KEY_FN$g(data.id, backtest);
             this.getPartial.clear(key);
         };
     }
@@ -24778,7 +25394,7 @@ class PartialConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$e = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$f = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -24789,7 +25405,7 @@ const CREATE_KEY_FN$e = (symbol, strategyName, exchangeName, frameName, backtest
  * Creates a filename for markdown report based on memoization key components.
  * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$5 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$6 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -24803,7 +25419,7 @@ const CREATE_FILE_NAME_FN$5 = (symbol, strategyName, exchangeName, frameName, ti
  * Storage class for accumulating partial profit/loss events per symbol-strategy pair.
  * Maintains a chronological list of profit and loss level events.
  */
-let ReportStorage$5 = class ReportStorage {
+let ReportStorage$6 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -24960,7 +25576,7 @@ let ReportStorage$5 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$5(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$6(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("partial", markdown, {
             path,
             file: filename,
@@ -25001,7 +25617,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$e(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$f(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.
@@ -25211,7 +25827,7 @@ class PartialMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$e(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$f(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -25227,7 +25843,7 @@ class PartialMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$d = (context) => {
+const CREATE_KEY_FN$e = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -25301,7 +25917,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$d(context), (context, methodName) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$e(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -25756,7 +26372,7 @@ class ClientBreakeven {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$c = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$d = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting breakeven events to breakevenSubject.
  *
@@ -25842,7 +26458,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$c(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$d(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -25903,7 +26519,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$c(data.id, backtest);
+            const key = CREATE_KEY_FN$d(data.id, backtest);
             this.getBreakeven.clear(key);
         };
     }
@@ -25919,7 +26535,7 @@ class BreakevenConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$c = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -25930,7 +26546,7 @@ const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest
  * Creates a filename for markdown report based on memoization key components.
  * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$4 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$5 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -25944,7 +26560,7 @@ const CREATE_FILE_NAME_FN$4 = (symbol, strategyName, exchangeName, frameName, ti
  * Storage class for accumulating breakeven events per symbol-strategy pair.
  * Maintains a chronological list of breakeven events.
  */
-let ReportStorage$4 = class ReportStorage {
+let ReportStorage$5 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -26053,7 +26669,7 @@ let ReportStorage$4 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/breakeven", columns = COLUMN_CONFIG.breakeven_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$4(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$5(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("breakeven", markdown, {
             path,
             file: filename,
@@ -26094,7 +26710,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$b(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$c(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.
@@ -26283,7 +26899,7 @@ class BreakevenMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$b(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$c(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -26299,7 +26915,7 @@ class BreakevenMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$a = (context) => {
+const CREATE_KEY_FN$b = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -26373,7 +26989,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$a(context), (context, methodName) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$b(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -26594,7 +27210,7 @@ class ConfigValidationService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-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);
@@ -26605,7 +27221,7 @@ const CREATE_KEY_FN$9 = (symbol, strategyName, exchangeName, frameName, backtest
  * Creates a filename for markdown report based on memoization key components.
  * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$3 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$4 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -26619,7 +27235,7 @@ const CREATE_FILE_NAME_FN$3 = (symbol, strategyName, exchangeName, frameName, ti
  * Storage class for accumulating risk rejection events per symbol-strategy pair.
  * Maintains a chronological list of rejected signals due to risk limits.
  */
-let ReportStorage$3 = class ReportStorage {
+let ReportStorage$4 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -26720,7 +27336,7 @@ let ReportStorage$3 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$3(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$4(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("risk", markdown, {
             path,
             file: filename,
@@ -26761,7 +27377,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$9(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => 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, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to risk rejection emitter to receive rejection events.
          * Protected against multiple subscriptions.
@@ -26950,7 +27566,7 @@ class RiskMarkdownService {
                 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 {
@@ -27252,6 +27868,7 @@ const WILDCARD_TARGET = {
     walker: true,
     sync: true,
     highest_profit: true,
+    max_drawdown: true,
 };
 /**
  * Utility class for managing report services.
@@ -27289,7 +27906,7 @@ class ReportUtils {
          *
          * @returns Cleanup function that unsubscribes from all enabled services
          */
-        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, } = WILDCARD_TARGET) => {
+        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET) => {
             bt.loggerService.debug(REPORT_UTILS_METHOD_NAME_ENABLE, {
                 backtest: bt$1,
                 breakeven,
@@ -27340,6 +27957,9 @@ class ReportUtils {
             if (highest_profit) {
                 unList.push(bt.highestProfitReportService.subscribe());
             }
+            if (max_drawdown) {
+                unList.push(bt.maxDrawdownReportService.subscribe());
+            }
             return functoolsKit.compose(...unList.map((un) => () => void un()));
         };
         /**
@@ -27378,7 +27998,7 @@ class ReportUtils {
          * Report.disable();
          * ```
          */
-        this.disable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, } = WILDCARD_TARGET) => {
+        this.disable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET) => {
             bt.loggerService.debug(REPORT_UTILS_METHOD_NAME_DISABLE, {
                 backtest: bt$1,
                 breakeven,
@@ -27428,6 +28048,9 @@ class ReportUtils {
             if (highest_profit) {
                 bt.highestProfitReportService.unsubscribe();
             }
+            if (max_drawdown) {
+                bt.maxDrawdownReportService.unsubscribe();
+            }
         };
     }
 }
@@ -27639,6 +28262,8 @@ class BacktestReportService {
                     pnlPriceClose: data.pnl.priceClose,
                     totalPartials: data.signal?.totalPartials,
                     cost: data.signal?.cost,
+                    peakPnl: data.signal?._peak?.pnlPercentage,
+                    fallPnl: data.signal?._fall?.pnlPercentage,
                 }, { ...searchOptions, signalId: data.signal?.id });
             }
             else if (data.action === "closed") {
@@ -27671,6 +28296,8 @@ class BacktestReportService {
                     closeReason: data.closeReason,
                     closeTime: data.closeTimestamp,
                     duration: durationMin,
+                    peakPnl: data.signal?._peak?.pnlPercentage,
+                    fallPnl: data.signal?._fall?.pnlPercentage,
                 }, { ...searchOptions, signalId: data.signal?.id });
             }
         };
@@ -27833,6 +28460,8 @@ class LiveReportService {
                     pnlPriceClose: data.pnl.priceClose,
                     totalPartials: data.signal?.totalPartials,
                     cost: data.signal?.cost,
+                    peakPnl: data.signal?._peak?.pnlPercentage,
+                    fallPnl: data.signal?._fall?.pnlPercentage,
                 }, { ...searchOptions, signalId: data.signal?.id });
             }
             else if (data.action === "opened") {
@@ -27883,6 +28512,8 @@ class LiveReportService {
                     pnlPriceClose: data.pnl.priceClose,
                     totalPartials: data.signal?.totalPartials,
                     cost: data.signal?.cost,
+                    peakPnl: data.signal?._peak?.pnlPercentage,
+                    fallPnl: data.signal?._fall?.pnlPercentage,
                 }, { ...searchOptions, signalId: data.signal?.id });
             }
             else if (data.action === "closed") {
@@ -27915,6 +28546,8 @@ class LiveReportService {
                     closeReason: data.closeReason,
                     duration: durationMin,
                     closeTime: data.closeTimestamp,
+                    peakPnl: data.signal?._peak?.pnlPercentage,
+                    fallPnl: data.signal?._fall?.pnlPercentage,
                 }, { ...searchOptions, signalId: data.signal?.id });
             }
             else if (data.action === "cancelled") {
@@ -28506,6 +29139,8 @@ class HeatReportService {
                 openTime: data.signal?.pendingAt,
                 scheduledAt: data.signal?.scheduledAt,
                 closeTime: data.closeTimestamp,
+                peakPnl: data.signal?._peak?.pnlPercentage,
+                fallPnl: data.signal?._fall?.pnlPercentage,
             }, {
                 symbol: data.symbol,
                 strategyName: data.strategyName,
@@ -29769,7 +30404,7 @@ class HighestProfitReportService {
  * @returns Colon-separated key string for memoization
  * @internal
  */
-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);
@@ -29789,7 +30424,7 @@ const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest
  * @returns Underscore-separated filename with .md extension
  * @internal
  */
-const CREATE_FILE_NAME_FN$2 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$3 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -29811,7 +30446,7 @@ const CREATE_FILE_NAME_FN$2 = (symbol, strategyName, exchangeName, frameName, ti
  *
  * @internal
  */
-let ReportStorage$2 = class ReportStorage {
+let ReportStorage$3 = class ReportStorage {
     /**
      * Creates a new ReportStorage instance.
      *
@@ -29942,7 +30577,7 @@ let ReportStorage$2 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/strategy", columns = COLUMN_CONFIG.strategy_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$2(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$3(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("strategy", markdown, {
             path,
             file: filename,
@@ -30011,7 +30646,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName));
+        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));
         /**
          * Records a cancel-scheduled event when a scheduled signal is cancelled.
          *
@@ -30579,7 +31214,7 @@ class StrategyMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("strategyMarkdownService 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 {
@@ -30687,7 +31322,7 @@ class StrategyMarkdownService {
  * Creates a unique key for memoizing ReportStorage instances.
  * Key format: "symbol:strategyName:exchangeName[:frameName]:backtest|live"
  */
-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);
@@ -30698,7 +31333,7 @@ const CREATE_KEY_FN$7 = (symbol, strategyName, exchangeName, frameName, backtest
  * Creates a filename for the markdown report.
  * Filename format: "symbol_strategyName_exchangeName[_frameName_backtest|_live]-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$1 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$2 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -30712,7 +31347,7 @@ const CREATE_FILE_NAME_FN$1 = (symbol, strategyName, exchangeName, frameName, ti
  * Storage class for accumulating signal sync events per symbol-strategy-exchange-frame-backtest combination.
  * Maintains a chronological list of signal-open and signal-close events.
  */
-let ReportStorage$1 = class ReportStorage {
+let ReportStorage$2 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName, backtest) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -30846,7 +31481,7 @@ let ReportStorage$1 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/sync", columns = COLUMN_CONFIG.sync_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$1(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$2(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("sync", markdown, {
             path,
             file: filename,
@@ -30880,7 +31515,7 @@ let ReportStorage$1 = class ReportStorage {
 class SyncMarkdownService {
     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, backtest) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName, backtest));
+        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));
         /**
          * Subscribes to `syncSubject` to start receiving `SignalSyncContract` events.
          * Protected against multiple subscriptions via `singleshot` — subsequent calls
@@ -31076,7 +31711,7 @@ class SyncMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("syncMarkdownService 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 {
@@ -31089,7 +31724,7 @@ class SyncMarkdownService {
 /**
  * Creates a unique memoization key for a symbol-strategy-exchange-frame-backtest combination.
  */
-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);
@@ -31099,7 +31734,7 @@ const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest
 /**
  * Creates a filename for the markdown report.
  */
-const CREATE_FILE_NAME_FN = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$1 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -31112,7 +31747,7 @@ const CREATE_FILE_NAME_FN = (symbol, strategyName, exchangeName, frameName, time
 /**
  * Accumulates highest profit events per symbol-strategy-exchange-frame combination.
  */
-class ReportStorage {
+let ReportStorage$1 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -31243,7 +31878,7 @@ class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/highest_profit", columns = COLUMN_CONFIG.highest_profit_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$1(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("highest_profit", markdown, {
             path,
             file: filename,
@@ -31254,7 +31889,7 @@ class ReportStorage {
             frameName: this.frameName,
         });
     }
-}
+};
 /**
  * Service for generating and saving highest profit markdown reports.
  *
@@ -31265,7 +31900,7 @@ class ReportStorage {
 class HighestProfitMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(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$7(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
@@ -31431,7 +32066,7 @@ class HighestProfitMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("highestProfitMarkdownService clear", { payload });
             if (payload) {
-                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.getStorage.clear(key);
             }
             else {
@@ -31453,7 +32088,7 @@ const LISTEN_TIMEOUT$1 = 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);
@@ -31496,7 +32131,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$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 market price for the given symbol and context.
          *
@@ -31525,10 +32160,10 @@ class PriceMetaService {
             if (source.data) {
                 return source.data;
             }
-            console.warn(`PriceMetaService: No currentPrice 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(`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...`);
             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$5(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
+                throw new Error(`PriceMetaService: Timeout while waiting for currentPrice for ${CREATE_KEY_FN$6(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
             }
             return currentPrice;
         };
@@ -31570,7 +32205,7 @@ class PriceMetaService {
                 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);
         };
     }
@@ -31588,7 +32223,7 @@ const LISTEN_TIMEOUT = 120000;
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-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);
@@ -31631,7 +32266,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$4(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
+        this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
         /**
          * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
          *
@@ -31659,10 +32294,10 @@ class TimeMetaService {
             if (source.data) {
                 return source.data;
             }
-            console.warn(`TimeMetaService: No timestamp available for ${CREATE_KEY_FN$4(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$5(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$4(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
+                throw new Error(`TimeMetaService: Timeout while waiting for timestamp for ${CREATE_KEY_FN$5(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
             }
             return timestamp;
         };
@@ -31704,12 +32339,315 @@ class TimeMetaService {
                 this.getSource.clear();
                 return;
             }
-            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.getSource.clear(key);
         };
     }
 }
 
+const MAX_DRAWDOWN_REPORT_METHOD_NAME_SUBSCRIBE = "MaxDrawdownReportService.subscribe";
+const MAX_DRAWDOWN_REPORT_METHOD_NAME_UNSUBSCRIBE = "MaxDrawdownReportService.unsubscribe";
+const MAX_DRAWDOWN_REPORT_METHOD_NAME_TICK = "MaxDrawdownReportService.tick";
+/**
+ * Service for logging max drawdown events to the JSONL report database.
+ *
+ * Listens to maxDrawdownSubject and writes each new drawdown record to
+ * Report.writeData() for persistence and analytics.
+ */
+class MaxDrawdownReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Handles a single `MaxDrawdownContract` event emitted by `maxDrawdownSubject`.
+         *
+         * Writes a JSONL record to the `"max_drawdown"` report database via
+         * `Report.writeData`, capturing the full signal snapshot at the moment
+         * the new drawdown record was set:
+         * - `timestamp`, `symbol`, `strategyName`, `exchangeName`, `frameName`, `backtest`
+         * - `signalId`, `position`, `currentPrice`
+         * - `priceOpen`, `priceTakeProfit`, `priceStopLoss` (effective values from the signal)
+         *
+         * `strategyName` and signal-level fields are sourced from `data.signal`
+         * rather than the contract root.
+         *
+         * @param data - `MaxDrawdownContract` payload containing `symbol`,
+         *   `signal`, `currentPrice`, `backtest`, `timestamp`, `exchangeName`,
+         *   `frameName`
+         */
+        this.tick = async (data) => {
+            this.loggerService.log(MAX_DRAWDOWN_REPORT_METHOD_NAME_TICK, { data });
+            await Report.writeData("max_drawdown", {
+                timestamp: data.timestamp,
+                symbol: data.symbol,
+                strategyName: data.signal.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: data.backtest,
+                signalId: data.signal.id,
+                position: data.signal.position,
+                currentPrice: data.currentPrice,
+                priceOpen: data.signal.priceOpen,
+                priceTakeProfit: data.signal.priceTakeProfit,
+                priceStopLoss: data.signal.priceStopLoss,
+            }, {
+                symbol: data.symbol,
+                strategyName: data.signal.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.signal.id,
+                walkerName: "",
+            });
+        };
+        /**
+         * Subscribes to `maxDrawdownSubject` to start persisting drawdown records.
+         * Protected against multiple subscriptions via `singleshot` — subsequent
+         * calls return the same unsubscribe function without re-subscribing.
+         *
+         * The returned unsubscribe function clears the `singleshot` state and
+         * detaches from `maxDrawdownSubject`.
+         *
+         * @returns Unsubscribe function; calling it tears down the subscription
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(MAX_DRAWDOWN_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsub = maxDrawdownSubject.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                unsub();
+            };
+        });
+        /**
+         * Detaches from `maxDrawdownSubject`, stopping further JSONL writes.
+         *
+         * Calls the unsubscribe closure returned by `subscribe()`.
+         * If `subscribe()` was never called, does nothing.
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log(MAX_DRAWDOWN_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+    }
+}
+
+/**
+ * Creates a unique memoization key for a symbol-strategy-exchange-frame-backtest combination.
+ */
+const CREATE_KEY_FN$4 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * Creates a filename for the markdown report.
+ */
+const CREATE_FILE_NAME_FN = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
+/**
+ * Accumulates max drawdown events per symbol-strategy-exchange-frame combination.
+ */
+class ReportStorage {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        this._eventList = [];
+    }
+    /**
+     * Constructs a `MaxDrawdownEvent` from the given signal snapshot and
+     * prepends it to the internal queue (most recent first).
+     *
+     * Once the queue exceeds `GLOBAL_CONFIG.CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS`
+     * entries, the oldest entry is dropped from the tail.
+     */
+    addEvent(data, currentPrice, backtest, timestamp) {
+        this._eventList.unshift({
+            timestamp,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            signalId: data.id,
+            position: data.position,
+            pnl: data.pnl,
+            currentPrice,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            backtest,
+        });
+        if (this._eventList.length > GLOBAL_CONFIG.CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS) {
+            this._eventList.pop();
+        }
+    }
+    /**
+     * Returns the accumulated event list with a total count.
+     */
+    async getData() {
+        return {
+            eventList: this._eventList,
+            totalEvents: this._eventList.length,
+        };
+    }
+    /**
+     * Renders a markdown max drawdown report for this storage instance.
+     */
+    async getReport(symbol, strategyName, columns = COLUMN_CONFIG.max_drawdown_columns) {
+        const stats = await this.getData();
+        if (stats.totalEvents === 0) {
+            return [
+                `# Max Drawdown Report: ${symbol}:${strategyName}`,
+                "",
+                "No max drawdown events recorded yet.",
+            ].join("\n");
+        }
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
+        const tableData = [header, separator, ...rows];
+        const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
+        return [
+            `# Max Drawdown Report: ${symbol}:${strategyName}`,
+            "",
+            table,
+            "",
+            `**Total events:** ${stats.totalEvents}`,
+        ].join("\n");
+    }
+    /**
+     * Generates the markdown report and persists it via `Markdown.writeData`.
+     */
+    async dump(symbol, strategyName, path = "./dump/max_drawdown", columns = COLUMN_CONFIG.max_drawdown_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
+        const timestamp = getContextTimestamp();
+        const filename = CREATE_FILE_NAME_FN(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("max_drawdown", markdown, {
+            path,
+            file: filename,
+            symbol: this.symbol,
+            signalId: "",
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            frameName: this.frameName,
+        });
+    }
+}
+/**
+ * Service for generating and saving max drawdown markdown reports.
+ *
+ * Listens to maxDrawdownSubject and accumulates events per
+ * symbol-strategy-exchange-frame combination. Provides getData(),
+ * getReport(), and dump() methods matching the HighestProfit pattern.
+ */
+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));
+        /**
+         * Subscribes to `maxDrawdownSubject` to start receiving `MaxDrawdownContract`
+         * events. Protected against multiple subscriptions via `singleshot`.
+         *
+         * @returns Unsubscribe function; calling it tears down the subscription and
+         *   clears all accumulated data
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("maxDrawdownMarkdownService init");
+            const unsub = maxDrawdownSubject.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsub();
+            };
+        });
+        /**
+         * Detaches from `maxDrawdownSubject` and clears all accumulated data.
+         *
+         * If `subscribe()` was never called, does nothing.
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("maxDrawdownMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+        /**
+         * Handles a single `MaxDrawdownContract` event emitted by `maxDrawdownSubject`.
+         */
+        this.tick = async (data) => {
+            this.loggerService.log("maxDrawdownMarkdownService tick", { data });
+            const storage = this.getStorage(data.symbol, data.signal.strategyName, data.exchangeName, data.frameName, data.backtest);
+            storage.addEvent(data.signal, data.currentPrice, data.backtest, data.timestamp);
+        };
+        /**
+         * Returns accumulated max drawdown statistics for the given context.
+         */
+        this.getData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("maxDrawdownMarkdownService getData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("MaxDrawdownMarkdownService not initialized. Call subscribe() before getting data.");
+            }
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            return storage.getData();
+        };
+        /**
+         * Generates a markdown max drawdown report for the given context.
+         */
+        this.getReport = async (symbol, strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.max_drawdown_columns) => {
+            this.loggerService.log("maxDrawdownMarkdownService getReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("MaxDrawdownMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            return storage.getReport(symbol, strategyName, columns);
+        };
+        /**
+         * Generates the max drawdown report and writes it to disk.
+         */
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/max_drawdown", columns = COLUMN_CONFIG.max_drawdown_columns) => {
+            this.loggerService.log("maxDrawdownMarkdownService dump", { symbol, strategyName, exchangeName, frameName, backtest, path });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("MaxDrawdownMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await storage.dump(symbol, strategyName, path, columns);
+        };
+        /**
+         * Evicts memoized `ReportStorage` instances, releasing all accumulated event data.
+         *
+         * - With `payload` — clears only the storage bucket for that combination.
+         * - Without `payload` — clears **all** storage buckets.
+         */
+        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);
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -31780,6 +32718,7 @@ class TimeMetaService {
     provide(TYPES.strategyMarkdownService, () => new StrategyMarkdownService());
     provide(TYPES.syncMarkdownService, () => new SyncMarkdownService());
     provide(TYPES.highestProfitMarkdownService, () => new HighestProfitMarkdownService());
+    provide(TYPES.maxDrawdownMarkdownService, () => new MaxDrawdownMarkdownService());
 }
 {
     provide(TYPES.backtestReportService, () => new BacktestReportService());
@@ -31794,6 +32733,7 @@ class TimeMetaService {
     provide(TYPES.strategyReportService, () => new StrategyReportService());
     provide(TYPES.syncReportService, () => new SyncReportService());
     provide(TYPES.highestProfitReportService, () => new HighestProfitReportService());
+    provide(TYPES.maxDrawdownReportService, () => new MaxDrawdownReportService());
 }
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
@@ -31877,6 +32817,7 @@ const markdownServices = {
     strategyMarkdownService: inject(TYPES.strategyMarkdownService),
     syncMarkdownService: inject(TYPES.syncMarkdownService),
     highestProfitMarkdownService: inject(TYPES.highestProfitMarkdownService),
+    maxDrawdownMarkdownService: inject(TYPES.maxDrawdownMarkdownService),
 };
 const reportServices = {
     backtestReportService: inject(TYPES.backtestReportService),
@@ -31891,6 +32832,7 @@ const reportServices = {
     strategyReportService: inject(TYPES.strategyReportService),
     syncReportService: inject(TYPES.syncReportService),
     highestProfitReportService: inject(TYPES.highestProfitReportService),
+    maxDrawdownReportService: inject(TYPES.maxDrawdownReportService),
 };
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
@@ -34818,6 +35760,12 @@ const GET_POSITION_HIGHEST_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionHig
 const GET_POSITION_HIGHEST_PNL_COST_METHOD_NAME = "strategy.getPositionHighestPnlCost";
 const GET_POSITION_HIGHEST_PROFIT_BREAKEVEN_METHOD_NAME = "strategy.getPositionHighestProfitBreakeven";
 const GET_POSITION_DRAWDOWN_MINUTES_METHOD_NAME = "strategy.getPositionDrawdownMinutes";
+const GET_POSITION_HIGHEST_PROFIT_MINUTES_METHOD_NAME = "strategy.getPositionHighestProfitMinutes";
+const GET_POSITION_MAX_DRAWDOWN_MINUTES_METHOD_NAME = "strategy.getPositionMaxDrawdownMinutes";
+const GET_POSITION_MAX_DRAWDOWN_PRICE_METHOD_NAME = "strategy.getPositionMaxDrawdownPrice";
+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_ENTRY_OVERLAP_METHOD_NAME = "strategy.getPositionEntryOverlap";
 const GET_POSITION_PARTIAL_OVERLAP_METHOD_NAME = "strategy.getPositionPartialOverlap";
 const HAS_NO_PENDING_SIGNAL_METHOD_NAME = "strategy.hasNoPendingSignal";
@@ -36277,6 +37225,181 @@ async function getPositionDrawdownMinutes(symbol) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     return await bt.strategyCoreService.getPositionDrawdownMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the number of minutes elapsed since the highest profit price was recorded.
+ *
+ * Alias for getPositionDrawdownMinutes — measures how long the position has been
+ * pulling back from its peak profit level.
+ * Zero when called at the exact moment the peak was set.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to minutes since last profit peak or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitMinutes } from "backtest-kit";
+ *
+ * const minutes = await getPositionHighestProfitMinutes("BTCUSDT");
+ * // e.g. 30 (30 minutes since the highest profit price)
+ * ```
+ */
+async function getPositionHighestProfitMinutes(symbol) {
+    bt.loggerService.info(GET_POSITION_HIGHEST_PROFIT_MINUTES_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitMinutes requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitMinutes requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionHighestProfitMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the number of minutes elapsed since the worst loss price was recorded.
+ *
+ * Measures how long ago the deepest drawdown point occurred.
+ * Zero when called at the exact moment the trough was set.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to minutes since last drawdown trough or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownMinutes } from "backtest-kit";
+ *
+ * const minutes = await getPositionMaxDrawdownMinutes("BTCUSDT");
+ * // e.g. 15 (15 minutes since the worst loss price)
+ * ```
+ */
+async function getPositionMaxDrawdownMinutes(symbol) {
+    bt.loggerService.info(GET_POSITION_MAX_DRAWDOWN_MINUTES_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownMinutes requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownMinutes requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionMaxDrawdownMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the worst price reached in the loss direction during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to price or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPrice } from "backtest-kit";
+ *
+ * const price = await getPositionMaxDrawdownPrice("BTCUSDT");
+ * // e.g. 41000 (lowest price seen for a LONG position)
+ * ```
+ */
+async function getPositionMaxDrawdownPrice(symbol) {
+    bt.loggerService.info(GET_POSITION_MAX_DRAWDOWN_PRICE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownPrice requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownPrice requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionMaxDrawdownPrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the timestamp when the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to timestamp in milliseconds or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownTimestamp } from "backtest-kit";
+ *
+ * const ts = await getPositionMaxDrawdownTimestamp("BTCUSDT");
+ * // e.g. 1700000000000
+ * ```
+ */
+async function getPositionMaxDrawdownTimestamp(symbol) {
+    bt.loggerService.info(GET_POSITION_MAX_DRAWDOWN_TIMESTAMP_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownTimestamp requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownTimestamp requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionMaxDrawdownTimestamp(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL percentage or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPnlPercentage } from "backtest-kit";
+ *
+ * const pnl = await getPositionMaxDrawdownPnlPercentage("BTCUSDT");
+ * // e.g. -5.2 (deepest PnL percentage reached)
+ * ```
+ */
+async function getPositionMaxDrawdownPnlPercentage(symbol) {
+    bt.loggerService.info(GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownPnlPercentage requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownPnlPercentage requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionMaxDrawdownPnlPercentage(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL cost or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPnlCost } from "backtest-kit";
+ *
+ * const cost = await getPositionMaxDrawdownPnlCost("BTCUSDT");
+ * // e.g. -52 (deepest PnL in quote currency)
+ * ```
+ */
+async function getPositionMaxDrawdownPnlCost(symbol) {
+    bt.loggerService.info(GET_POSITION_MAX_DRAWDOWN_PNL_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownPnlCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionMaxDrawdownPnlCost requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionMaxDrawdownPnlCost(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.
@@ -36518,6 +37641,8 @@ const LISTEN_SYNC_METHOD_NAME = "event.listenSync";
 const LISTEN_SYNC_ONCE_METHOD_NAME = "event.listenSyncOnce";
 const LISTEN_HIGHEST_PROFIT_METHOD_NAME = "event.listenHighestProfit";
 const LISTEN_HIGHEST_PROFIT_ONCE_METHOD_NAME = "event.listenHighestProfitOnce";
+const LISTEN_MAX_DRAWDOWN_METHOD_NAME = "event.listenMaxDrawdown";
+const LISTEN_MAX_DRAWDOWN_ONCE_METHOD_NAME = "event.listenMaxDrawdownOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -37868,6 +38993,47 @@ function listenHighestProfitOnce(filterFn, fn) {
     };
     return disposeFn = listenHighestProfit(wrappedFn);
 }
+/**
+ * Subscribes to max drawdown events with queued async processing.
+ * Emits when a signal reaches a new maximum drawdown level during its lifecycle.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * Useful for tracking drawdown milestones and implementing dynamic risk management logic.
+ * @param fn - Callback function to handle max drawdown events
+ * @return Unsubscribe function to stop listening to events
+ */
+function listenMaxDrawdown(fn) {
+    bt.loggerService.log(LISTEN_MAX_DRAWDOWN_METHOD_NAME);
+    const wrappedFn = async (event) => {
+        if (await bt.strategyCoreService.hasPendingSignal(event.backtest, event.symbol, {
+            strategyName: event.strategyName,
+            exchangeName: event.exchangeName,
+            frameName: event.frameName,
+        })) {
+            await fn(event);
+        }
+    };
+    return maxDrawdownSubject.subscribe(functoolsKit.queued(wrappedFn));
+}
+/**
+ * Subscribes to filtered max drawdown events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific drawdown conditions.
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @return Unsubscribe function to cancel the listener before it fires
+ */
+function listenMaxDrawdownOnce(filterFn, fn) {
+    bt.loggerService.log(LISTEN_MAX_DRAWDOWN_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenMaxDrawdown(wrappedFn);
+}
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
@@ -37897,6 +39063,12 @@ const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE = "BacktestUtils.
 const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST = "BacktestUtils.getPositionHighestPnlCost";
 const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN = "BacktestUtils.getPositionHighestProfitBreakeven";
 const BACKTEST_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES = "BacktestUtils.getPositionDrawdownMinutes";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES = "BacktestUtils.getPositionHighestProfitMinutes";
+const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES = "BacktestUtils.getPositionMaxDrawdownMinutes";
+const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE = "BacktestUtils.getPositionMaxDrawdownPrice";
+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_ENTRY_OVERLAP = "BacktestUtils.getPositionEntryOverlap";
 const BACKTEST_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "BacktestUtils.getPositionPartialOverlap";
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
@@ -38997,6 +40169,175 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPositionDrawdownMinutes(true, symbol, context);
         };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Alias for getPositionDrawdownMinutes — measures how long the position has been
+         * pulling back from its peak profit level.
+         * Zero when called at the exact moment the peak was set.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Minutes since last profit peak, or null if no active position
+         */
+        this.getPositionHighestProfitMinutes = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionHighestProfitMinutes(true, symbol, context);
+        };
+        /**
+         * Returns the number of minutes elapsed since the worst loss price was recorded.
+         *
+         * Measures how long ago the deepest drawdown point occurred.
+         * Zero when called at the exact moment the trough was set.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Minutes since last drawdown trough, or null if no active position
+         */
+        this.getPositionMaxDrawdownMinutes = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownMinutes(true, symbol, context);
+        };
+        /**
+         * Returns the worst price reached in the loss direction during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns price or null if no active position
+         */
+        this.getPositionMaxDrawdownPrice = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownPrice(true, symbol, context);
+        };
+        /**
+         * Returns the timestamp when the worst loss price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns timestamp in milliseconds or null if no active position
+         */
+        this.getPositionMaxDrawdownTimestamp = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownTimestamp(true, symbol, context);
+        };
+        /**
+         * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns PnL percentage or null if no active position
+         */
+        this.getPositionMaxDrawdownPnlPercentage = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownPnlPercentage(true, symbol, context);
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns PnL cost or null if no active position
+         */
+        this.getPositionMaxDrawdownPnlCost = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownPnlCost(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.
@@ -40116,6 +41457,12 @@ const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE = "LiveUtils.getPosit
 const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST = "LiveUtils.getPositionHighestPnlCost";
 const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN = "LiveUtils.getPositionHighestProfitBreakeven";
 const LIVE_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES = "LiveUtils.getPositionDrawdownMinutes";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES = "LiveUtils.getPositionHighestProfitMinutes";
+const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES = "LiveUtils.getPositionMaxDrawdownMinutes";
+const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE = "LiveUtils.getPositionMaxDrawdownPrice";
+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_ENTRY_OVERLAP = "LiveUtils.getPositionEntryOverlap";
 const LIVE_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "LiveUtils.getPositionPartialOverlap";
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
@@ -41319,6 +42666,199 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Alias for getPositionDrawdownMinutes — measures how long the position has been
+         * pulling back from its peak profit level.
+         * Zero when called at the exact moment the peak was set.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Minutes since last profit peak, or null if no active position
+         */
+        this.getPositionHighestProfitMinutes = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionHighestProfitMinutes(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the number of minutes elapsed since the worst loss price was recorded.
+         *
+         * Measures how long ago the deepest drawdown point occurred.
+         * Zero when called at the exact moment the trough was set.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Minutes since last drawdown trough, or null if no active position
+         */
+        this.getPositionMaxDrawdownMinutes = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownMinutes(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the worst price reached in the loss direction during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns price or null if no active position
+         */
+        this.getPositionMaxDrawdownPrice = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownPrice(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the timestamp when the worst loss price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns timestamp in milliseconds or null if no active position
+         */
+        this.getPositionMaxDrawdownTimestamp = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownTimestamp(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns PnL percentage or null if no active position
+         */
+        this.getPositionMaxDrawdownPnlPercentage = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownPnlPercentage(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns PnL cost or null if no active position
+         */
+        this.getPositionMaxDrawdownPnlCost = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST));
+            }
+            return await bt.strategyCoreService.getPositionMaxDrawdownPnlCost(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.
@@ -47756,6 +49296,98 @@ class HighestProfitUtils {
  */
 const HighestProfit = new HighestProfitUtils();
 
+const MAX_DRAWDOWN_METHOD_NAME_GET_DATA = "MaxDrawdownUtils.getData";
+const MAX_DRAWDOWN_METHOD_NAME_GET_REPORT = "MaxDrawdownUtils.getReport";
+const MAX_DRAWDOWN_METHOD_NAME_DUMP = "MaxDrawdownUtils.dump";
+/**
+ * Utility class for accessing max drawdown reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by MaxDrawdownMarkdownService from maxDrawdownSubject events.
+ *
+ * @example
+ * ```typescript
+ * import { MaxDrawdown } from "backtest-kit";
+ *
+ * const stats = await MaxDrawdown.getData("BTCUSDT", { strategyName, exchangeName, frameName });
+ * const report = await MaxDrawdown.getReport("BTCUSDT", { strategyName, exchangeName, frameName });
+ * await MaxDrawdown.dump("BTCUSDT", { strategyName, exchangeName, frameName });
+ * ```
+ */
+class MaxDrawdownUtils {
+    constructor() {
+        /**
+         * Retrieves statistical data from accumulated max drawdown events.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context
+         * @param backtest - Whether to query backtest data
+         * @returns Promise resolving to MaxDrawdownStatisticsModel
+         */
+        this.getData = async (symbol, context, backtest = false) => {
+            bt.loggerService.info(MAX_DRAWDOWN_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
+            bt.strategyValidationService.validate(context.strategyName, MAX_DRAWDOWN_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, MAX_DRAWDOWN_METHOD_NAME_GET_DATA);
+            context.frameName && bt.frameValidationService.validate(context.frameName, MAX_DRAWDOWN_METHOD_NAME_GET_DATA);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, MAX_DRAWDOWN_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, MAX_DRAWDOWN_METHOD_NAME_GET_DATA));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, MAX_DRAWDOWN_METHOD_NAME_GET_DATA));
+            }
+            return await bt.maxDrawdownMarkdownService.getData(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+        };
+        /**
+         * Generates a markdown report with all max drawdown events for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context
+         * @param backtest - Whether to query backtest data
+         * @param columns - Optional column configuration
+         * @returns Promise resolving to markdown formatted report string
+         */
+        this.getReport = async (symbol, context, backtest = false, columns) => {
+            bt.loggerService.info(MAX_DRAWDOWN_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
+            bt.strategyValidationService.validate(context.strategyName, MAX_DRAWDOWN_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, MAX_DRAWDOWN_METHOD_NAME_GET_REPORT);
+            context.frameName && bt.frameValidationService.validate(context.frameName, MAX_DRAWDOWN_METHOD_NAME_GET_REPORT);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, MAX_DRAWDOWN_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, MAX_DRAWDOWN_METHOD_NAME_GET_REPORT));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, MAX_DRAWDOWN_METHOD_NAME_GET_REPORT));
+            }
+            return await bt.maxDrawdownMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, columns);
+        };
+        /**
+         * Generates and saves a markdown report to file.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context
+         * @param backtest - Whether to query backtest data
+         * @param path - Output directory path (default: "./dump/max_drawdown")
+         * @param columns - Optional column configuration
+         */
+        this.dump = async (symbol, context, backtest = false, path, columns) => {
+            bt.loggerService.info(MAX_DRAWDOWN_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
+            bt.strategyValidationService.validate(context.strategyName, MAX_DRAWDOWN_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, MAX_DRAWDOWN_METHOD_NAME_DUMP);
+            context.frameName && bt.frameValidationService.validate(context.frameName, MAX_DRAWDOWN_METHOD_NAME_DUMP);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, MAX_DRAWDOWN_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, MAX_DRAWDOWN_METHOD_NAME_DUMP));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, MAX_DRAWDOWN_METHOD_NAME_DUMP));
+            }
+            await bt.maxDrawdownMarkdownService.dump(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, path, columns);
+        };
+    }
+}
+/**
+ * Global singleton instance of MaxDrawdownUtils.
+ */
+const MaxDrawdown = new MaxDrawdownUtils();
+
 /**
  * Utility class containing predefined trading constants for take-profit and stop-loss levels.
  *
@@ -52637,6 +54269,7 @@ exports.Log = Log;
 exports.Markdown = Markdown;
 exports.MarkdownFileBase = MarkdownFileBase;
 exports.MarkdownFolderBase = MarkdownFolderBase;
+exports.MaxDrawdown = MaxDrawdown;
 exports.Memory = Memory;
 exports.MethodContextService = MethodContextService;
 exports.Notification = Notification;
@@ -52727,11 +54360,17 @@ exports.getPositionEstimateMinutes = getPositionEstimateMinutes;
 exports.getPositionHighestPnlCost = getPositionHighestPnlCost;
 exports.getPositionHighestPnlPercentage = getPositionHighestPnlPercentage;
 exports.getPositionHighestProfitBreakeven = getPositionHighestProfitBreakeven;
+exports.getPositionHighestProfitMinutes = getPositionHighestProfitMinutes;
 exports.getPositionHighestProfitPrice = getPositionHighestProfitPrice;
 exports.getPositionHighestProfitTimestamp = getPositionHighestProfitTimestamp;
 exports.getPositionInvestedCost = getPositionInvestedCost;
 exports.getPositionInvestedCount = getPositionInvestedCount;
 exports.getPositionLevels = getPositionLevels;
+exports.getPositionMaxDrawdownMinutes = getPositionMaxDrawdownMinutes;
+exports.getPositionMaxDrawdownPnlCost = getPositionMaxDrawdownPnlCost;
+exports.getPositionMaxDrawdownPnlPercentage = getPositionMaxDrawdownPnlPercentage;
+exports.getPositionMaxDrawdownPrice = getPositionMaxDrawdownPrice;
+exports.getPositionMaxDrawdownTimestamp = getPositionMaxDrawdownTimestamp;
 exports.getPositionPartialOverlap = getPositionPartialOverlap;
 exports.getPositionPartials = getPositionPartials;
 exports.getPositionPnlCost = getPositionPnlCost;
@@ -52774,6 +54413,8 @@ exports.listenError = listenError;
 exports.listenExit = listenExit;
 exports.listenHighestProfit = listenHighestProfit;
 exports.listenHighestProfitOnce = listenHighestProfitOnce;
+exports.listenMaxDrawdown = listenMaxDrawdown;
+exports.listenMaxDrawdownOnce = listenMaxDrawdownOnce;
 exports.listenPartialLossAvailable = listenPartialLossAvailable;
 exports.listenPartialLossAvailableOnce = listenPartialLossAvailableOnce;
 exports.listenPartialProfitAvailable = listenPartialProfitAvailable;