backtest-kit 6.5.2 → 6.7.0

package/build/index.mjs

@@ -108,6 +108,7 @@ const markdownServices$1 = {
     strategyMarkdownService: Symbol('strategyMarkdownService'),
     syncMarkdownService: Symbol('syncMarkdownService'),
     highestProfitMarkdownService: Symbol('highestProfitMarkdownService'),
+    maxDrawdownMarkdownService: Symbol('maxDrawdownMarkdownService'),
 };
 const reportServices$1 = {
     backtestReportService: Symbol('backtestReportService'),
@@ -122,6 +123,7 @@ const reportServices$1 = {
     strategyReportService: Symbol('strategyReportService'),
     syncReportService: Symbol('syncReportService'),
     highestProfitReportService: Symbol('highestProfitReportService'),
+    maxDrawdownReportService: Symbol('maxDrawdownReportService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -453,6 +455,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.
@@ -727,6 +736,12 @@ const backtestScheduleOpenSubject = new Subject();
  * Allows users to track profit milestones and implement custom management logic based on profit levels.
  */
 const highestProfitSubject = new 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 Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -739,6 +754,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     errorEmitter: errorEmitter,
     exitEmitter: exitEmitter,
     highestProfitSubject: highestProfitSubject,
+    maxDrawdownSubject: maxDrawdownSubject,
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
@@ -4868,6 +4884,7 @@ const GET_SIGNAL_FN = 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);
@@ -4893,6 +4910,7 @@ const GET_SIGNAL_FN = 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);
@@ -4915,6 +4933,7 @@ const GET_SIGNAL_FN = 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);
@@ -5626,6 +5645,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);
@@ -6300,6 +6320,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);
             }
         }
@@ -6333,6 +6362,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);
             }
         }
@@ -6453,6 +6491,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);
@@ -6639,6 +6678,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);
@@ -6863,6 +6903,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);
                 }
             }
@@ -6893,6 +6941,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);
                 }
             }
@@ -7614,6 +7670,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.
      *
@@ -7790,6 +7944,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) {
@@ -9906,7 +10061,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);
@@ -10067,6 +10222,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) => 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting dispose events.
  *
@@ -10137,7 +10328,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$r(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = 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,
@@ -10166,6 +10357,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),
             });
         });
         /**
@@ -10769,6 +10961,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.
          *
@@ -10807,7 +11123,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;
             }
@@ -11983,7 +12299,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);
@@ -12082,7 +12398,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$q(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = 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,
@@ -12150,7 +12466,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 {
@@ -13657,7 +13973,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);
@@ -13708,7 +14024,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$p(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = 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,
@@ -13918,7 +14234,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;
             }
@@ -13936,7 +14252,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;
 };
 /**
@@ -13960,7 +14276,7 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$o(exchangeName), async (exchangeName) => {
+        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$p(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -14212,7 +14528,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);
@@ -14244,7 +14560,7 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$n(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -15288,6 +15604,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);
+        };
     }
 }
 
@@ -15360,7 +15784,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);
@@ -15386,7 +15810,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$m(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$n(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -15464,7 +15888,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);
@@ -15508,7 +15932,7 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$l(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$m(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -18055,6 +18479,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,
+    },
 ];
 
 /**
@@ -18165,6 +18604,18 @@ const heat_columns = [
         format: (data) => data.totalTrades.toString(),
         isVisible: () => true,
     },
+    {
+        key: "avgPeakPnl",
+        label: "Avg Peak PNL",
+        format: (data) => data.avgPeakPnl !== null ? str(data.avgPeakPnl, "%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgFallPnl",
+        label: "Avg DD PNL",
+        format: (data) => data.avgFallPnl !== null ? str(data.avgFallPnl, "%") : "N/A",
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -18362,6 +18813,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,
+    },
 ];
 
 /**
@@ -19523,6 +19990,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.
  *
@@ -19758,6 +20312,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 */
@@ -19802,6 +20358,7 @@ const WILDCARD_TARGET$1 = {
     walker: true,
     sync: true,
     highest_profit: true,
+    max_drawdown: true,
 };
 /**
  * JSONL-based markdown adapter with append-only writes.
@@ -20029,7 +20586,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,
@@ -20081,6 +20638,9 @@ class MarkdownUtils {
             if (highest_profit) {
                 unList.push(bt.highestProfitMarkdownService.subscribe());
             }
+            if (max_drawdown) {
+                unList.push(bt.maxDrawdownMarkdownService.subscribe());
+            }
             return compose(...unList.map((un) => () => void un()));
         };
         /**
@@ -20120,7 +20680,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,
@@ -20171,6 +20731,9 @@ class MarkdownUtils {
             if (highest_profit) {
                 bt.highestProfitMarkdownService.unsubscribe();
             }
+            if (max_drawdown) {
+                bt.maxDrawdownMarkdownService.unsubscribe();
+            }
         };
     }
 }
@@ -20286,7 +20849,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);
@@ -20303,7 +20866,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);
@@ -20335,7 +20898,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;
@@ -20377,6 +20940,8 @@ let ReportStorage$9 = class ReportStorage {
                 annualizedSharpeRatio: null,
                 certaintyRatio: null,
                 expectedYearlyReturns: null,
+                avgPeakPnl: null,
+                avgFallPnl: null,
             };
         }
         const totalSignals = this._signalList.length;
@@ -20407,6 +20972,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,
@@ -20420,6 +20988,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,
         };
     }
     /**
@@ -20464,6 +21034,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");
     }
     /**
@@ -20476,7 +21048,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,
@@ -20523,7 +21095,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$k(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$9(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$l(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$a(symbol, strategyName, exchangeName, frameName));
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -20680,7 +21252,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 {
@@ -20742,7 +21314,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);
@@ -20759,7 +21331,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);
@@ -20791,7 +21363,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;
@@ -20931,6 +21503,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
@@ -21060,6 +21634,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");
@@ -21103,6 +21679,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,
@@ -21117,6 +21699,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,
         };
     }
     /**
@@ -21161,6 +21745,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");
     }
     /**
@@ -21173,7 +21759,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: "",
@@ -21223,7 +21809,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$j(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$k(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$9(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to live signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -21441,7 +22027,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 {
@@ -21461,7 +22047,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);
@@ -21478,7 +22064,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);
@@ -21492,7 +22078,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;
@@ -21709,7 +22295,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,
@@ -21750,7 +22336,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$i(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$7(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$j(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to signal emitter to receive scheduled signal events.
          * Protected against multiple subscriptions.
@@ -21953,7 +22539,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 {
@@ -21973,7 +22559,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);
@@ -21990,7 +22576,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);
@@ -22171,7 +22757,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,
@@ -22218,7 +22804,7 @@ class PerformanceMarkdownService {
          * Memoized function to get or create PerformanceStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$h(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$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.
@@ -22385,7 +22971,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 {
@@ -22399,7 +22985,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`;
 };
 /**
@@ -22434,7 +23020,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) */
@@ -22631,7 +23217,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,
@@ -22667,7 +23253,7 @@ class WalkerMarkdownService {
          * Memoized function to get or create ReportStorage for a walker.
          * Each walker gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$6(walkerName));
+        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$7(walkerName));
         /**
          * Subscribes to walker emitter to receive walker progress events.
          * Protected against multiple subscriptions.
@@ -22864,7 +23450,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);
@@ -22875,7 +23461,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);
@@ -23065,6 +23651,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;
@@ -23086,6 +23679,10 @@ class HeatmapStorage {
             avgLoss = null;
         if (isUnsafe(expectancy))
             expectancy = null;
+        if (isUnsafe(avgPeakPnl))
+            avgPeakPnl = null;
+        if (isUnsafe(avgFallPnl))
+            avgFallPnl = null;
         return {
             symbol,
             totalPnl,
@@ -23103,6 +23700,8 @@ class HeatmapStorage {
             maxWinStreak,
             maxLossStreak,
             expectancy,
+            avgPeakPnl,
+            avgFallPnl,
         };
     }
     /**
@@ -23152,17 +23751,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,
         };
     }
     /**
@@ -23211,7 +23827,7 @@ class HeatmapStorage {
         return [
             `# Portfolio Heatmap: ${strategyName}`,
             "",
-            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`,
+            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades} | **Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? str(data.portfolioAvgPeakPnl, "%") : "N/A"} | **Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
             "",
             table
         ].join("\n");
@@ -23235,7 +23851,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,
@@ -23281,7 +23897,7 @@ class HeatMarkdownService {
          * Memoized function to get or create HeatmapStorage for exchange, frame and backtest mode.
          * Each exchangeName + frameName + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$g(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = 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.
@@ -23499,7 +24115,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 {
@@ -24530,7 +25146,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.
  *
@@ -24652,7 +25268,7 @@ class PartialConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$f(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$g(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -24742,7 +25358,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);
         };
     }
@@ -24758,7 +25374,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);
@@ -24769,7 +25385,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);
@@ -24783,7 +25399,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;
@@ -24940,7 +25556,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,
@@ -24981,7 +25597,7 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$e(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$5(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$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.
@@ -25191,7 +25807,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 {
@@ -25207,7 +25823,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);
@@ -25281,7 +25897,7 @@ class PartialGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$d(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$e(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -25736,7 +26352,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.
  *
@@ -25822,7 +26438,7 @@ class BreakevenConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientBreakeven instance with logger and event emitter
          */
-        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$c(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$d(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -25883,7 +26499,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);
         };
     }
@@ -25899,7 +26515,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);
@@ -25910,7 +26526,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);
@@ -25924,7 +26540,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;
@@ -26033,7 +26649,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,
@@ -26074,7 +26690,7 @@ class BreakevenMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$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.
@@ -26263,7 +26879,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 {
@@ -26279,7 +26895,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);
@@ -26353,7 +26969,7 @@ class BreakevenGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$a(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$b(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -26574,7 +27190,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);
@@ -26585,7 +27201,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);
@@ -26599,7 +27215,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;
@@ -26700,7 +27316,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,
@@ -26741,7 +27357,7 @@ class RiskMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to risk rejection emitter to receive rejection events.
          * Protected against multiple subscriptions.
@@ -26930,7 +27546,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 {
@@ -27232,6 +27848,7 @@ const WILDCARD_TARGET = {
     walker: true,
     sync: true,
     highest_profit: true,
+    max_drawdown: true,
 };
 /**
  * Utility class for managing report services.
@@ -27269,7 +27886,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,
@@ -27320,6 +27937,9 @@ class ReportUtils {
             if (highest_profit) {
                 unList.push(bt.highestProfitReportService.subscribe());
             }
+            if (max_drawdown) {
+                unList.push(bt.maxDrawdownReportService.subscribe());
+            }
             return compose(...unList.map((un) => () => void un()));
         };
         /**
@@ -27358,7 +27978,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,
@@ -27408,6 +28028,9 @@ class ReportUtils {
             if (highest_profit) {
                 bt.highestProfitReportService.unsubscribe();
             }
+            if (max_drawdown) {
+                bt.maxDrawdownReportService.unsubscribe();
+            }
         };
     }
 }
@@ -27619,6 +28242,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") {
@@ -27651,6 +28276,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 });
             }
         };
@@ -27813,6 +28440,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") {
@@ -27863,6 +28492,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") {
@@ -27895,6 +28526,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") {
@@ -28486,6 +29119,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,
@@ -29749,7 +30384,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);
@@ -29769,7 +30404,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);
@@ -29791,7 +30426,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.
      *
@@ -29922,7 +30557,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,
@@ -29991,7 +30626,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = 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 = 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.
          *
@@ -30559,7 +31194,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 {
@@ -30667,7 +31302,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);
@@ -30678,7 +31313,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);
@@ -30692,7 +31327,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;
@@ -30826,7 +31461,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,
@@ -30860,7 +31495,7 @@ let ReportStorage$1 = class ReportStorage {
 class SyncMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName, backtest));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName, backtest));
         /**
          * Subscribes to `syncSubject` to start receiving `SignalSyncContract` events.
          * Protected against multiple subscriptions via `singleshot` — subsequent calls
@@ -31056,7 +31691,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 {
@@ -31069,7 +31704,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);
@@ -31079,7 +31714,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);
@@ -31092,7 +31727,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;
@@ -31223,7 +31858,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,
@@ -31234,7 +31869,7 @@ class ReportStorage {
             frameName: this.frameName,
         });
     }
-}
+};
 /**
  * Service for generating and saving highest profit markdown reports.
  *
@@ -31245,7 +31880,7 @@ class ReportStorage {
 class HighestProfitMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = 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 = 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
@@ -31411,7 +32046,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 {
@@ -31433,7 +32068,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);
@@ -31476,7 +32111,7 @@ class PriceMetaService {
          * Each subject holds the latest currentPrice emitted by the strategy iterator for that key.
          * Instances are cached until clear() is called.
          */
-        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
         /**
          * Returns the current market price for the given symbol and context.
          *
@@ -31505,10 +32140,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 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;
         };
@@ -31550,7 +32185,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);
         };
     }
@@ -31568,7 +32203,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);
@@ -31611,7 +32246,7 @@ class TimeMetaService {
          * Each subject holds the latest createdAt timestamp emitted by the strategy iterator for that key.
          * Instances are cached until clear() is called.
          */
-        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$4(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
         /**
          * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
          *
@@ -31639,10 +32274,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 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;
         };
@@ -31684,12 +32319,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 = 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 = 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 = 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());
 }
@@ -31760,6 +32698,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());
@@ -31774,6 +32713,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());
@@ -31857,6 +32797,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),
@@ -31871,6 +32812,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),
@@ -34798,6 +35740,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";
@@ -36257,6 +37205,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.
@@ -36498,6 +37621,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.
  *
@@ -37848,6 +38973,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(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";
@@ -37877,6 +39043,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";
@@ -38977,6 +40149,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.
@@ -40096,6 +41437,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";
@@ -41299,6 +42646,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.
@@ -47736,6 +49276,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.
  *
@@ -52600,4 +54232,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, Memory, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MaxDrawdown, Memory, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };