backtest-kit 1.10.1 → 1.10.3

package/build/index.mjs

@@ -2122,8 +2122,10 @@ const TIMEOUT_SYMBOL = Symbol('timeout');
  * It hides internal implementation details while exposing effective values:
  *
  * - Replaces internal _trailingPriceStopLoss with effective priceStopLoss
+ * - Replaces internal _trailingPriceTakeProfit with effective priceTakeProfit
  * - Preserves original stop-loss in originalPriceStopLoss for reference
- * - Ensures external code never sees private _trailingPriceStopLoss field
+ * - Preserves original take-profit in originalPriceTakeProfit for reference
+ * - Ensures external code never sees private _trailing* fields
  * - Maintains backward compatibility with non-trailing positions
  *
  * Key differences from TO_RISK_SIGNAL (in ClientRisk.ts):
@@ -2138,34 +2140,37 @@ const TIMEOUT_SYMBOL = Symbol('timeout');
  * - Event emissions and logging
  * - Integration with ClientPartial and ClientRisk
  *
- * @param signal - Internal signal row with optional trailing stop-loss
- * @returns Signal in IPublicSignalRow format with effective stop-loss and hidden internals
+ * @param signal - Internal signal row with optional trailing stop-loss/take-profit
+ * @returns Signal in IPublicSignalRow format with effective SL/TP and hidden internals
  *
  * @example
  * ```typescript
- * // Signal without trailing SL
+ * // Signal without trailing SL/TP
  * const publicSignal = TO_PUBLIC_SIGNAL(signal);
  * // publicSignal.priceStopLoss = signal.priceStopLoss
+ * // publicSignal.priceTakeProfit = signal.priceTakeProfit
  * // publicSignal.originalPriceStopLoss = signal.priceStopLoss
+ * // publicSignal.originalPriceTakeProfit = signal.priceTakeProfit
  *
- * // Signal with trailing SL
+ * // Signal with trailing SL/TP
  * const publicSignal = TO_PUBLIC_SIGNAL(signalWithTrailing);
  * // publicSignal.priceStopLoss = signal._trailingPriceStopLoss (effective)
+ * // publicSignal.priceTakeProfit = signal._trailingPriceTakeProfit (effective)
  * // publicSignal.originalPriceStopLoss = signal.priceStopLoss (original)
+ * // publicSignal.originalPriceTakeProfit = signal.priceTakeProfit (original)
  * // publicSignal._trailingPriceStopLoss = undefined (hidden from external API)
+ * // publicSignal._trailingPriceTakeProfit = undefined (hidden from external API)
  * ```
  */
 const TO_PUBLIC_SIGNAL = (signal) => {
-    if (signal._trailingPriceStopLoss !== undefined) {
-        return {
-            ...structuredClone(signal),
-            priceStopLoss: signal._trailingPriceStopLoss,
-            originalPriceStopLoss: signal.priceStopLoss,
-        };
-    }
+    const hasTrailingSL = signal._trailingPriceStopLoss !== undefined;
+    const hasTrailingTP = signal._trailingPriceTakeProfit !== undefined;
     return {
         ...structuredClone(signal),
+        priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
+        priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
         originalPriceStopLoss: signal.priceStopLoss,
+        originalPriceTakeProfit: signal.priceTakeProfit,
     };
 };
 const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
@@ -2670,33 +2675,29 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
     });
 };
 const TRAILING_STOP_FN = (self, signal, percentShift) => {
-    // Calculate distance between entry and original stop-loss AS PERCENTAGE of entry price
-    const slDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
-    // Calculate new stop-loss distance percentage by adding shift
+    // Get current effective stop-loss (trailing or original)
+    const currentStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+    // Calculate distance between entry and CURRENT stop-loss AS PERCENTAGE of entry price
+    const currentSlDistancePercent = Math.abs((signal.priceOpen - currentStopLoss) / signal.priceOpen * 100);
+    // Calculate new stop-loss distance percentage by adding shift to CURRENT distance
     // Negative percentShift: reduces distance % (tightens stop, moves SL toward entry or beyond)
     // Positive percentShift: increases distance % (loosens stop, moves SL away from entry)
-    const newSlDistancePercent = slDistancePercent + percentShift;
+    const newSlDistancePercent = currentSlDistancePercent + percentShift;
     // Calculate new stop-loss price based on new distance percentage
     // Negative newSlDistancePercent means SL crosses entry into profit zone
     let newStopLoss;
     if (signal.position === "long") {
         // LONG: SL is below entry (or above entry if in profit zone)
         // Formula: entry * (1 - newDistance%)
-        // Example: entry=100, originalSL=90 (10%), shift=-15% → newDistance=-5% → 100 * 1.05 = 105 (profit zone)
-        // Example: entry=100, originalSL=90 (10%), shift=-5% → newDistance=5% → 100 * 0.95 = 95 (tighter)
-        // Example: entry=100, originalSL=90 (10%), shift=+5% → newDistance=15% → 100 * 0.85 = 85 (looser)
+        // Example: entry=100, currentSL=95 (5%), shift=-3% → newDistance=2% → 100 * 0.98 = 98 (tighter)
         newStopLoss = signal.priceOpen * (1 - newSlDistancePercent / 100);
     }
     else {
         // SHORT: SL is above entry (or below entry if in profit zone)
         // Formula: entry * (1 + newDistance%)
-        // Example: entry=100, originalSL=110 (10%), shift=-15% → newDistance=-5% → 100 * 0.95 = 95 (profit zone)
-        // Example: entry=100, originalSL=110 (10%), shift=-5% → newDistance=5% → 100 * 1.05 = 105 (tighter)
-        // Example: entry=100, originalSL=110 (10%), shift=+5% → newDistance=15% → 100 * 1.15 = 115 (looser)
+        // Example: entry=100, currentSL=105 (5%), shift=-3% → newDistance=2% → 100 * 1.02 = 102 (tighter)
         newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
     }
-    // Get current effective stop-loss (trailing or original)
-    const currentStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
     // Determine if this is the first trailing stop call (direction not set yet)
     const isFirstCall = signal._trailingPriceStopLoss === undefined;
     if (isFirstCall) {
@@ -2707,7 +2708,7 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
             position: signal.position,
             priceOpen: signal.priceOpen,
             originalStopLoss: signal.priceStopLoss,
-            originalDistancePercent: slDistancePercent,
+            currentDistancePercent: currentSlDistancePercent,
             previousStopLoss: currentStopLoss,
             newStopLoss,
             newDistancePercent: newSlDistancePercent,
@@ -2718,19 +2719,28 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
     }
     else {
         // Subsequent calls: only update if new SL continues in the same direction
-        const movingUp = newStopLoss > currentStopLoss;
-        const movingDown = newStopLoss < currentStopLoss;
-        // Determine initial direction based on first trailing SL vs original SL
-        const initialDirection = signal._trailingPriceStopLoss > signal.priceStopLoss ? "up" : "down";
-        let shouldUpdate = false;
-        if (initialDirection === "up" && movingUp) {
-            // Direction is UP, and new SL continues moving up
-            shouldUpdate = true;
-        }
-        else if (initialDirection === "down" && movingDown) {
-            // Direction is DOWN, and new SL continues moving down
-            shouldUpdate = true;
+        // Determine initial direction: "closer" or "farther" relative to entry
+        let initialDirection;
+        if (signal.position === "long") {
+            // LONG: closer = SL closer to entry = higher SL value (moving up)
+            initialDirection = signal._trailingPriceStopLoss > signal.priceStopLoss ? "closer" : "farther";
+        }
+        else {
+            // SHORT: closer = SL closer to entry = lower SL value (moving down)
+            initialDirection = signal._trailingPriceStopLoss < signal.priceStopLoss ? "closer" : "farther";
+        }
+        // Determine new direction
+        let newDirection;
+        if (signal.position === "long") {
+            // LONG: closer = higher SL value
+            newDirection = newStopLoss > currentStopLoss ? "closer" : "farther";
+        }
+        else {
+            // SHORT: closer = lower SL value
+            newDirection = newStopLoss < currentStopLoss ? "closer" : "farther";
         }
+        // Only allow continuation in same direction
+        const shouldUpdate = initialDirection === newDirection;
         if (!shouldUpdate) {
             self.params.logger.debug("TRAILING_STOP_FN: new SL not in same direction, skipping", {
                 signalId: signal.id,
@@ -2739,7 +2749,7 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
                 newStopLoss,
                 percentShift,
                 initialDirection,
-                attemptedDirection: movingUp ? "up" : movingDown ? "down" : "same",
+                attemptedDirection: newDirection,
             });
             return;
         }
@@ -2750,7 +2760,7 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
             position: signal.position,
             priceOpen: signal.priceOpen,
             originalStopLoss: signal.priceStopLoss,
-            originalDistancePercent: slDistancePercent,
+            currentDistancePercent: currentSlDistancePercent,
             previousStopLoss: currentStopLoss,
             newStopLoss,
             newDistancePercent: newSlDistancePercent,
@@ -2760,6 +2770,99 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
         });
     }
 };
+const TRAILING_PROFIT_FN = (self, signal, percentShift) => {
+    // Get current effective take-profit (trailing or original)
+    const currentTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+    // Calculate distance between entry and CURRENT take-profit AS PERCENTAGE of entry price
+    const currentTpDistancePercent = Math.abs((currentTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+    // Calculate new take-profit distance percentage by adding shift to CURRENT distance
+    // Negative percentShift: reduces distance % (brings TP closer to entry)
+    // Positive percentShift: increases distance % (moves TP further from entry)
+    const newTpDistancePercent = currentTpDistancePercent + percentShift;
+    // Calculate new take-profit price based on new distance percentage
+    let newTakeProfit;
+    if (signal.position === "long") {
+        // LONG: TP is above entry
+        // Formula: entry * (1 + newDistance%)
+        // Example: entry=100, currentTP=115 (15%), shift=-3% → newDistance=12% → 100 * 1.12 = 112 (closer)
+        newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
+    }
+    else {
+        // SHORT: TP is below entry
+        // Formula: entry * (1 - newDistance%)
+        // Example: entry=100, currentTP=85 (15%), shift=-3% → newDistance=12% → 100 * 0.88 = 88 (closer)
+        newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
+    }
+    // Determine if this is the first trailing profit call (direction not set yet)
+    const isFirstCall = signal._trailingPriceTakeProfit === undefined;
+    if (isFirstCall) {
+        // First call: set the direction and update TP unconditionally
+        signal._trailingPriceTakeProfit = newTakeProfit;
+        self.params.logger.info("TRAILING_PROFIT_FN executed (first call - direction set)", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            originalTakeProfit: signal.priceTakeProfit,
+            currentDistancePercent: currentTpDistancePercent,
+            previousTakeProfit: currentTakeProfit,
+            newTakeProfit,
+            newDistancePercent: newTpDistancePercent,
+            percentShift,
+            direction: newTakeProfit > currentTakeProfit ? "up" : "down",
+        });
+    }
+    else {
+        // Subsequent calls: only update if new TP continues in the same direction
+        // Determine initial direction: "closer" or "farther" relative to entry
+        let initialDirection;
+        if (signal.position === "long") {
+            // LONG: closer = TP closer to entry = lower TP value
+            initialDirection = signal._trailingPriceTakeProfit < signal.priceTakeProfit ? "closer" : "farther";
+        }
+        else {
+            // SHORT: closer = TP closer to entry = higher TP value  
+            initialDirection = signal._trailingPriceTakeProfit > signal.priceTakeProfit ? "closer" : "farther";
+        }
+        // Determine new direction
+        let newDirection;
+        if (signal.position === "long") {
+            // LONG: closer = lower TP value
+            newDirection = newTakeProfit < currentTakeProfit ? "closer" : "farther";
+        }
+        else {
+            // SHORT: closer = higher TP value
+            newDirection = newTakeProfit > currentTakeProfit ? "closer" : "farther";
+        }
+        // Only allow continuation in same direction
+        const shouldUpdate = initialDirection === newDirection;
+        if (!shouldUpdate) {
+            self.params.logger.debug("TRAILING_PROFIT_FN: new TP not in same direction, skipping", {
+                signalId: signal.id,
+                position: signal.position,
+                currentTakeProfit,
+                newTakeProfit,
+                percentShift,
+                initialDirection,
+                attemptedDirection: newDirection,
+            });
+            return;
+        }
+        // Update trailing take-profit
+        signal._trailingPriceTakeProfit = newTakeProfit;
+        self.params.logger.info("TRAILING_PROFIT_FN executed", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            originalTakeProfit: signal.priceTakeProfit,
+            currentDistancePercent: currentTpDistancePercent,
+            previousTakeProfit: currentTakeProfit,
+            newTakeProfit,
+            newDistancePercent: newTpDistancePercent,
+            percentShift,
+            direction: initialDirection,
+        });
+    }
+};
 const BREAKEVEN_FN = (self, signal, currentPrice) => {
     // Calculate breakeven threshold based on slippage and fees
     // Need to cover: entry slippage + entry fee + exit slippage + exit fee
@@ -2790,6 +2893,19 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
                 const thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice >= thresholdPrice;
                 if (isThresholdReached && breakevenPrice > trailingStopLoss) {
+                    // Check for price intrusion before setting new SL
+                    if (currentPrice < breakevenPrice) {
+                        // Price already crossed the breakeven level - skip setting SL
+                        self.params.logger.debug("BREAKEVEN_FN: price intrusion detected, skipping SL update", {
+                            signalId: signal.id,
+                            position: signal.position,
+                            priceOpen: signal.priceOpen,
+                            breakevenPrice,
+                            currentPrice,
+                            reason: "currentPrice below breakevenPrice (LONG position)"
+                        });
+                        return false;
+                    }
                     // Breakeven is better than current trailing SL - upgrade to breakeven
                     signal._trailingPriceStopLoss = breakevenPrice;
                     self.params.logger.info("BREAKEVEN_FN: upgraded negative trailing stop to breakeven", {
@@ -2842,6 +2958,19 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
                 const thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice <= thresholdPrice;
                 if (isThresholdReached && breakevenPrice < trailingStopLoss) {
+                    // Check for price intrusion before setting new SL
+                    if (currentPrice > breakevenPrice) {
+                        // Price already crossed the breakeven level - skip setting SL
+                        self.params.logger.debug("BREAKEVEN_FN: price intrusion detected, skipping SL update", {
+                            signalId: signal.id,
+                            position: signal.position,
+                            priceOpen: signal.priceOpen,
+                            breakevenPrice,
+                            currentPrice,
+                            reason: "currentPrice above breakevenPrice (SHORT position)"
+                        });
+                        return false;
+                    }
                     // Breakeven is better than current trailing SL - upgrade to breakeven
                     signal._trailingPriceStopLoss = breakevenPrice;
                     self.params.logger.info("BREAKEVEN_FN: upgraded negative trailing stop to breakeven", {
@@ -2912,6 +3041,31 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
         });
         return false;
     }
+    // Check for price intrusion before setting new SL
+    if (signal.position === "long" && currentPrice < breakevenPrice) {
+        // LONG: Price already crossed the breakeven level - skip setting SL
+        self.params.logger.debug("BREAKEVEN_FN: price intrusion detected, skipping SL update", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            breakevenPrice,
+            currentPrice,
+            reason: "currentPrice below breakevenPrice (LONG position)"
+        });
+        return false;
+    }
+    if (signal.position === "short" && currentPrice > breakevenPrice) {
+        // SHORT: Price already crossed the breakeven level - skip setting SL
+        self.params.logger.debug("BREAKEVEN_FN: price intrusion detected, skipping SL update", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            breakevenPrice,
+            currentPrice,
+            reason: "currentPrice above breakevenPrice (SHORT position)"
+        });
+        return false;
+    }
     // Move SL to breakeven (entry price)
     signal._trailingPriceStopLoss = breakevenPrice;
     self.params.logger.info("BREAKEVEN_FN executed", {
@@ -3520,13 +3674,14 @@ const CHECK_PENDING_SIGNAL_COMPLETION_FN = async (self, signal, averagePrice) =>
     if (elapsedTime >= maxTimeToWait) {
         return await CLOSE_PENDING_SIGNAL_FN(self, signal, averagePrice, "time_expired");
     }
-    // Check take profit
-    if (signal.position === "long" && averagePrice >= signal.priceTakeProfit) {
-        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceTakeProfit, // КРИТИЧНО: используем точную цену TP
+    // Check take profit (use trailing TP if set, otherwise original TP)
+    const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+    if (signal.position === "long" && averagePrice >= effectiveTakeProfit) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, effectiveTakeProfit, // КРИТИЧНО: используем точную цену TP
         "take_profit");
     }
-    if (signal.position === "short" && averagePrice <= signal.priceTakeProfit) {
-        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceTakeProfit, // КРИТИЧНО: используем точную цену TP
+    if (signal.position === "short" && averagePrice <= effectiveTakeProfit) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, effectiveTakeProfit, // КРИТИЧНО: используем точную цену TP
         "take_profit");
     }
     // Check stop loss (use trailing SL if set, otherwise original SL)
@@ -3588,8 +3743,9 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
             }
             if (currentDistance > 0) {
-                // Moving towards TP
-                const tpDistance = signal.priceTakeProfit - signal.priceOpen;
+                // Moving towards TP (use trailing TP if set)
+                const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+                const tpDistance = effectiveTakeProfit - signal.priceOpen;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
@@ -3611,8 +3767,9 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
             }
             if (currentDistance > 0) {
-                // Moving towards TP
-                const tpDistance = signal.priceOpen - signal.priceTakeProfit;
+                // Moving towards TP (use trailing TP if set)
+                const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+                const tpDistance = signal.priceOpen - effectiveTakeProfit;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
@@ -3874,11 +4031,12 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         }
         // Check TP/SL only if not expired
         // КРИТИЧНО: используем averagePrice (VWAP) для проверки достижения TP/SL (как в live mode)
-        // КРИТИЧНО: используем trailing SL если установлен
+        // КРИТИЧНО: используем trailing SL и TP если установлены
         const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+        const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
         if (!shouldClose && signal.position === "long") {
             // Для LONG: TP срабатывает если VWAP >= TP, SL если VWAP <= SL
-            if (averagePrice >= signal.priceTakeProfit) {
+            if (averagePrice >= effectiveTakeProfit) {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
@@ -3889,7 +4047,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         }
         if (!shouldClose && signal.position === "short") {
             // Для SHORT: TP срабатывает если VWAP <= TP, SL если VWAP >= SL
-            if (averagePrice <= signal.priceTakeProfit) {
+            if (averagePrice <= effectiveTakeProfit) {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
@@ -3902,7 +4060,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
             // КРИТИЧНО: используем точную цену TP/SL для закрытия (как в live mode)
             let closePrice;
             if (closeReason === "take_profit") {
-                closePrice = signal.priceTakeProfit;
+                closePrice = effectiveTakeProfit; // используем trailing TP если установлен
             }
             else if (closeReason === "stop_loss") {
                 closePrice = effectiveStopLoss;
@@ -3923,8 +4081,9 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, averagePrice, currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 if (currentDistance > 0) {
-                    // Moving towards TP
-                    const tpDistance = signal.priceTakeProfit - signal.priceOpen;
+                    // Moving towards TP (use trailing TP if set)
+                    const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+                    const tpDistance = effectiveTakeProfit - signal.priceOpen;
                     const progressPercent = (currentDistance / tpDistance) * 100;
                     await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
@@ -3944,8 +4103,9 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, averagePrice, currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 if (currentDistance > 0) {
-                    // Moving towards TP
-                    const tpDistance = signal.priceOpen - signal.priceTakeProfit;
+                    // Moving towards TP (use trailing TP if set)
+                    const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+                    const tpDistance = signal.priceOpen - effectiveTakeProfit;
                     const progressPercent = (currentDistance / tpDistance) * 100;
                     await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
@@ -4073,6 +4233,112 @@ class ClientStrategy {
         });
         return this._scheduledSignal ? TO_PUBLIC_SIGNAL(this._scheduledSignal) : null;
     }
+    /**
+     * Checks if breakeven threshold has been reached for the current pending signal.
+     *
+     * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+     * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+     * Threshold: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2 transactions
+     *
+     * For LONG position:
+     * - Returns true when: currentPrice >= priceOpen * (1 + threshold%)
+     * - Example: entry=100, threshold=0.4% → true when price >= 100.4
+     *
+     * For SHORT position:
+     * - Returns true when: currentPrice <= priceOpen * (1 - threshold%)
+     * - Example: entry=100, threshold=0.4% → true when price <= 99.6
+     *
+     * Special cases:
+     * - Returns false if no pending signal exists
+     * - Returns true if trailing stop is already in profit zone (breakeven already achieved)
+     * - Returns false if threshold not reached yet
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price to check against threshold
+     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+     * const canBreakeven = await strategy.getBreakeven("BTCUSDT", 100.5);
+     * // Returns true (price >= 100.4)
+     *
+     * if (canBreakeven) {
+     *   await strategy.breakeven("BTCUSDT", 100.5, false);
+     * }
+     * ```
+     */
+    async getBreakeven(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getBreakeven", {
+            symbol,
+            currentPrice,
+        });
+        // No pending signal - breakeven not available
+        if (!this._pendingSignal) {
+            return false;
+        }
+        const signal = this._pendingSignal;
+        // Calculate breakeven threshold based on slippage and fees
+        // Need to cover: entry slippage + entry fee + exit slippage + exit fee
+        // Total: (slippage + fee) * 2 transactions
+        const breakevenThresholdPercent = (GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE + GLOBAL_CONFIG.CC_PERCENT_FEE) * 2 + GLOBAL_CONFIG.CC_BREAKEVEN_THRESHOLD;
+        // Check if trailing stop is already set
+        if (signal._trailingPriceStopLoss !== undefined) {
+            const trailingStopLoss = signal._trailingPriceStopLoss;
+            if (signal.position === "long") {
+                // LONG: trailing SL is positive if it's above entry (in profit zone)
+                const isPositiveTrailing = trailingStopLoss > signal.priceOpen;
+                if (isPositiveTrailing) {
+                    // Trailing stop is already protecting profit - breakeven achieved
+                    return true;
+                }
+                // Trailing stop is negative (below entry)
+                // Check if we can upgrade it to breakeven
+                const thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+                const isThresholdReached = currentPrice >= thresholdPrice;
+                const breakevenPrice = signal.priceOpen;
+                // Can upgrade to breakeven if threshold reached and breakeven is better than current trailing SL
+                return isThresholdReached && breakevenPrice > trailingStopLoss;
+            }
+            else {
+                // SHORT: trailing SL is positive if it's below entry (in profit zone)
+                const isPositiveTrailing = trailingStopLoss < signal.priceOpen;
+                if (isPositiveTrailing) {
+                    // Trailing stop is already protecting profit - breakeven achieved
+                    return true;
+                }
+                // Trailing stop is negative (above entry)
+                // Check if we can upgrade it to breakeven
+                const thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+                const isThresholdReached = currentPrice <= thresholdPrice;
+                const breakevenPrice = signal.priceOpen;
+                // Can upgrade to breakeven if threshold reached and breakeven is better than current trailing SL
+                return isThresholdReached && breakevenPrice < trailingStopLoss;
+            }
+        }
+        // No trailing stop set - proceed with normal breakeven logic
+        const currentStopLoss = signal.priceStopLoss;
+        const breakevenPrice = signal.priceOpen;
+        // Calculate threshold price
+        let thresholdPrice;
+        let isThresholdReached;
+        let canMoveToBreakeven;
+        if (signal.position === "long") {
+            // LONG: threshold reached when price goes UP by breakevenThresholdPercent from entry
+            thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+            isThresholdReached = currentPrice >= thresholdPrice;
+            // Can move to breakeven only if threshold reached and SL is below entry
+            canMoveToBreakeven = isThresholdReached && currentStopLoss < breakevenPrice;
+        }
+        else {
+            // SHORT: threshold reached when price goes DOWN by breakevenThresholdPercent from entry
+            thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+            isThresholdReached = currentPrice <= thresholdPrice;
+            // Can move to breakeven only if threshold reached and SL is above entry
+            canMoveToBreakeven = isThresholdReached && currentStopLoss > breakevenPrice;
+        }
+        return canMoveToBreakeven;
+    }
     /**
      * Returns the stopped state of the strategy.
      *
@@ -4736,30 +5002,38 @@ class ClientStrategy {
      * - Throws if percentShift is not a finite number
      * - Throws if percentShift < -100 or > 100
      * - Throws if percentShift === 0
+     * - Throws if currentPrice is not a positive finite number
      * - Skips if new SL would cross entry price
+     * - Skips if currentPrice already crossed new SL level (price intrusion protection)
      *
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
      * @param percentShift - Percentage shift of SL distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to check for intrusion
      * @param backtest - Whether running in backtest mode (controls persistence)
      * @returns Promise that resolves when trailing SL is updated and persisted
      *
      * @example
      * ```typescript
-     * // LONG position: entry=100, originalSL=90, distance=10
+     * // LONG position: entry=100, originalSL=90, distance=10%, currentPrice=102
      *
-     * // Move SL 50% closer to entry (tighten)
-     * await strategy.trailingStop("BTCUSDT", -50, false);
-     * // newSL = 100 - 10*(1-0.5) = 95
+     * // Move SL 50% closer to entry (tighten): reduces distance by 50%
+     * await strategy.trailingStop("BTCUSDT", -50, 102, false);
+     * // newDistance = 10% - 50% = 5%, newSL = 100 * (1 - 0.05) = 95
      *
-     * // Move SL 30% away from entry (loosen, allow more drawdown)
-     * await strategy.trailingStop("BTCUSDT", 30, false);
-     * // newSL = 100 - 10*(1+0.3) = 87 (SKIPPED: worse than current 95)
+     * // Move SL 30% away from entry (loosen): increases distance by 30%
+     * await strategy.trailingStop("BTCUSDT", 30, 102, false);
+     * // newDistance = 10% + 30% = 40%, newSL = 100 * (1 - 0.4) = 60
+     *
+     * // Price intrusion example: currentPrice=92, trying to set SL=95
+     * await strategy.trailingStop("BTCUSDT", -50, 92, false);
+     * // SKIPPED: currentPrice (92) < newSL (95) - would trigger immediate stop
      * ```
      */
-    async trailingStop(symbol, percentShift, backtest) {
+    async trailingStop(symbol, percentShift, currentPrice, backtest) {
         this.params.logger.debug("ClientStrategy trailingStop", {
             symbol,
             percentShift,
+            currentPrice,
             hasPendingSignal: this._pendingSignal !== null,
         });
         // Validation: must have pending signal
@@ -4776,6 +5050,72 @@ class ClientStrategy {
         if (percentShift === 0) {
             throw new Error(`ClientStrategy trailingStop: percentShift cannot be 0`);
         }
+        // Validation: currentPrice must be valid
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
+            throw new Error(`ClientStrategy trailingStop: currentPrice must be a positive finite number, got ${currentPrice}`);
+        }
+        // Calculate what the new stop loss would be
+        const signal = this._pendingSignal;
+        const slDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
+        const newSlDistancePercent = slDistancePercent + percentShift;
+        let newStopLoss;
+        if (signal.position === "long") {
+            newStopLoss = signal.priceOpen * (1 - newSlDistancePercent / 100);
+        }
+        else {
+            newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
+        }
+        // Check for price intrusion before executing trailing logic
+        if (signal.position === "long" && currentPrice < newStopLoss) {
+            // LONG: Price already crossed the new stop loss level - skip setting SL
+            this.params.logger.debug("ClientStrategy trailingStop: price intrusion detected, skipping SL update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newStopLoss,
+                currentPrice,
+                reason: "currentPrice below newStopLoss (LONG position)"
+            });
+            return;
+        }
+        if (signal.position === "short" && currentPrice > newStopLoss) {
+            // SHORT: Price already crossed the new stop loss level - skip setting SL
+            this.params.logger.debug("ClientStrategy trailingStop: price intrusion detected, skipping SL update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newStopLoss,
+                currentPrice,
+                reason: "currentPrice above newStopLoss (SHORT position)"
+            });
+            return;
+        }
+        // Check for conflict with existing trailing take profit
+        const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+        if (signal.position === "long" && newStopLoss >= effectiveTakeProfit) {
+            // LONG: New SL would be at or above current TP - invalid configuration
+            this.params.logger.debug("ClientStrategy trailingStop: SL/TP conflict detected, skipping SL update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newStopLoss,
+                effectiveTakeProfit,
+                reason: "newStopLoss >= effectiveTakeProfit (LONG position)"
+            });
+            return;
+        }
+        if (signal.position === "short" && newStopLoss <= effectiveTakeProfit) {
+            // SHORT: New SL would be at or below current TP - invalid configuration
+            this.params.logger.debug("ClientStrategy trailingStop: SL/TP conflict detected, skipping SL update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newStopLoss,
+                effectiveTakeProfit,
+                reason: "newStopLoss <= effectiveTakeProfit (SHORT position)"
+            });
+            return;
+        }
         // Execute trailing logic
         TRAILING_STOP_FN(this, this._pendingSignal, percentShift);
         // Persist updated signal state (inline setPendingSignal content)
@@ -4792,6 +5132,136 @@ class ClientStrategy {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
     }
+    /**
+     * Adjusts the trailing take-profit distance for an active pending signal.
+     *
+     * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+     * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+     * Once direction is set on first call, subsequent calls must continue in same direction.
+     *
+     * Price intrusion protection: If current price has already crossed the new TP level,
+     * the update is skipped to prevent immediate TP triggering.
+     *
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise that resolves when trailing TP is updated
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+     * // Move TP further by 50%: newTP = 100 + 15% = 115
+     * await strategy.trailingProfit("BTCUSDT", 50, 102, false);
+     *
+     * // SHORT: entry=100, originalTP=90, distance=10%, currentPrice=98
+     * // Move TP closer by 30%: newTP = 100 - 7% = 93
+     * await strategy.trailingProfit("BTCUSDT", -30, 98, false);
+     * ```
+     */
+    async trailingProfit(symbol, percentShift, currentPrice, backtest) {
+        this.params.logger.debug("ClientStrategy trailingProfit", {
+            symbol,
+            percentShift,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        // Validation: must have pending signal
+        if (!this._pendingSignal) {
+            throw new Error(`ClientStrategy trailingProfit: No pending signal exists for symbol=${symbol}`);
+        }
+        // Validation: percentShift must be valid
+        if (typeof percentShift !== "number" || !isFinite(percentShift)) {
+            throw new Error(`ClientStrategy trailingProfit: percentShift must be a finite number, got ${percentShift} (${typeof percentShift})`);
+        }
+        if (percentShift < -100 || percentShift > 100) {
+            throw new Error(`ClientStrategy trailingProfit: percentShift must be in range [-100, 100], got ${percentShift}`);
+        }
+        if (percentShift === 0) {
+            throw new Error(`ClientStrategy trailingProfit: percentShift cannot be 0`);
+        }
+        // Validation: currentPrice must be valid
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
+            throw new Error(`ClientStrategy trailingProfit: currentPrice must be a positive finite number, got ${currentPrice}`);
+        }
+        // Calculate what the new take profit would be
+        const signal = this._pendingSignal;
+        const tpDistancePercent = Math.abs((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+        const newTpDistancePercent = tpDistancePercent + percentShift;
+        let newTakeProfit;
+        if (signal.position === "long") {
+            newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
+        }
+        else {
+            newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
+        }
+        // Check for price intrusion before executing trailing logic
+        if (signal.position === "long" && currentPrice > newTakeProfit) {
+            // LONG: Price already crossed the new take profit level - skip setting TP
+            this.params.logger.debug("ClientStrategy trailingProfit: price intrusion detected, skipping TP update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newTakeProfit,
+                currentPrice,
+                reason: "currentPrice above newTakeProfit (LONG position)"
+            });
+            return;
+        }
+        if (signal.position === "short" && currentPrice < newTakeProfit) {
+            // SHORT: Price already crossed the new take profit level - skip setting TP
+            this.params.logger.debug("ClientStrategy trailingProfit: price intrusion detected, skipping TP update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newTakeProfit,
+                currentPrice,
+                reason: "currentPrice below newTakeProfit (SHORT position)"
+            });
+            return;
+        }
+        // Check for conflict with existing trailing stop loss
+        const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+        if (signal.position === "long" && newTakeProfit <= effectiveStopLoss) {
+            // LONG: New TP would be at or below current SL - invalid configuration
+            this.params.logger.debug("ClientStrategy trailingProfit: TP/SL conflict detected, skipping TP update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newTakeProfit,
+                effectiveStopLoss,
+                reason: "newTakeProfit <= effectiveStopLoss (LONG position)"
+            });
+            return;
+        }
+        if (signal.position === "short" && newTakeProfit >= effectiveStopLoss) {
+            // SHORT: New TP would be at or above current SL - invalid configuration
+            this.params.logger.debug("ClientStrategy trailingProfit: TP/SL conflict detected, skipping TP update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newTakeProfit,
+                effectiveStopLoss,
+                reason: "newTakeProfit >= effectiveStopLoss (SHORT position)"
+            });
+            return;
+        }
+        // Execute trailing logic
+        TRAILING_PROFIT_FN(this, this._pendingSignal, percentShift);
+        // Persist updated signal state (inline setPendingSignal content)
+        // Note: this._pendingSignal already mutated by TRAILING_PROFIT_FN, no reassignment needed
+        this.params.logger.debug("ClientStrategy setPendingSignal (inline)", {
+            pendingSignal: this._pendingSignal,
+        });
+        // Call onWrite callback for testing persist storage
+        if (this.params.callbacks?.onWrite) {
+            const publicSignal = TO_PUBLIC_SIGNAL(this._pendingSignal);
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
+        }
+        if (!backtest) {
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+        }
+    }
 }
 
 const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
@@ -4961,6 +5431,7 @@ class RiskUtils {
                 strategyName: context.strategyName,
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -5017,6 +5488,7 @@ class RiskUtils {
                 strategyName: context.strategyName,
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -5065,6 +5537,7 @@ class RiskUtils {
                 path,
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -5275,6 +5748,46 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getScheduledSignal(symbol);
         };
+        /**
+         * Checks if breakeven threshold has been reached for the current pending signal.
+         *
+         * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+         * to cover transaction costs and allow breakeven to be set.
+         *
+         * Delegates to ClientStrategy.getBreakeven() with current execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to check against threshold
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+         *
+         * @example
+         * ```typescript
+         * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+         * const canBreakeven = await strategyConnectionService.getBreakeven(
+         *   false,
+         *   "BTCUSDT",
+         *   100.5,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * // Returns true (price >= 100.4)
+         *
+         * if (canBreakeven) {
+         *   await strategyConnectionService.breakeven(false, "BTCUSDT", 100.5, context);
+         * }
+         * ```
+         */
+        this.getBreakeven = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService getBreakeven", {
+                symbol,
+                context,
+                currentPrice,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getBreakeven(symbol, currentPrice);
+        };
         /**
          * Retrieves the stopped state of the strategy.
          *
@@ -5509,30 +6022,72 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when trailing SL is updated
          *
          * @example
          * ```typescript
-         * // LONG: entry=100, originalSL=90, distance=10
-         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+         * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+         * // Tighten stop by 50%: newSL = 100 - 5% = 95
          * await strategyConnectionService.trailingStop(
          *   false,
          *   "BTCUSDT",
          *   -50,
+         *   102,
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
          * );
          * ```
          */
-        this.trailingStop = async (backtest, symbol, percentShift, context) => {
+        this.trailingStop = async (backtest, symbol, percentShift, currentPrice, context) => {
             this.loggerService.log("strategyConnectionService trailingStop", {
                 symbol,
                 context,
                 percentShift,
+                currentPrice,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.trailingStop(symbol, percentShift, currentPrice, backtest);
+        };
+        /**
+         * Adjusts the trailing take-profit distance for an active pending signal.
+         *
+         * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+         * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+         *
+         * Delegates to ClientStrategy.trailingProfit() with current execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when trailing TP is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+         * // Move TP further by 50%: newTP = 100 + 15% = 115
+         * await strategyConnectionService.trailingProfit(
+         *   false,
+         *   "BTCUSDT",
+         *   50,
+         *   102,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * ```
+         */
+        this.trailingProfit = async (backtest, symbol, percentShift, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService trailingProfit", {
+                symbol,
+                context,
+                percentShift,
+                currentPrice,
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.trailingStop(symbol, percentShift, backtest);
+            await strategy.trailingProfit(symbol, percentShift, currentPrice, backtest);
         };
         /**
          * Delegates to ClientStrategy.breakeven() with current execution context.
@@ -6003,16 +6558,19 @@ const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
  *
  * - Falls back to currentPrice if priceOpen is not set (for ISignalDto/scheduled signals)
  * - Replaces priceStopLoss with trailing SL if active (for positions with trailing stops)
+ * - Replaces priceTakeProfit with trailing TP if active (for positions with trailing take-profit)
  * - Preserves original stop-loss in originalPriceStopLoss for reference
+ * - Preserves original take-profit in originalPriceTakeProfit for reference
  *
  * Use cases:
  * - Risk validation before opening a position (checkSignal)
  * - Pre-flight validation of scheduled signals
  * - Calculating position size based on stop-loss distance
+ * - Calculating risk-reward ratio using effective SL/TP
  *
  * @param signal - Signal DTO or row (may not have priceOpen for scheduled signals)
  * @param currentPrice - Current market price, used as fallback for priceOpen if not set
- * @returns Signal in IRiskSignalRow format with guaranteed priceOpen and effective stop-loss
+ * @returns Signal in IRiskSignalRow format with guaranteed priceOpen and effective SL/TP
  *
  * @example
  * ```typescript
@@ -6020,24 +6578,24 @@ const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
  * const riskSignal = TO_RISK_SIGNAL(scheduledSignal, 45000);
  * // riskSignal.priceOpen = 45000 (fallback to currentPrice)
  *
- * // For signal with trailing SL
+ * // For signal with trailing SL/TP
  * const riskSignal = TO_RISK_SIGNAL(activeSignal, 46000);
- * // riskSignal.priceStopLoss = activeSignal._trailingPriceStopLoss
+ * // riskSignal.priceStopLoss = activeSignal._trailingPriceStopLoss (effective)
+ * // riskSignal.priceTakeProfit = activeSignal._trailingPriceTakeProfit (effective)
+ * // riskSignal.originalPriceStopLoss = activeSignal.priceStopLoss (original)
+ * // riskSignal.originalPriceTakeProfit = activeSignal.priceTakeProfit (original)
  * ```
  */
 const TO_RISK_SIGNAL = (signal, currentPrice) => {
-    if ("_trailingPriceStopLoss" in signal) {
-        return {
-            ...structuredClone(signal),
-            priceOpen: signal.priceOpen ?? currentPrice,
-            priceStopLoss: signal._trailingPriceStopLoss,
-            originalPriceStopLoss: signal.priceStopLoss,
-        };
-    }
+    const hasTrailingSL = "_trailingPriceStopLoss" in signal && signal._trailingPriceStopLoss !== undefined;
+    const hasTrailingTP = "_trailingPriceTakeProfit" in signal && signal._trailingPriceTakeProfit !== undefined;
     return {
         ...structuredClone(signal),
         priceOpen: signal.priceOpen ?? currentPrice,
+        priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
+        priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
         originalPriceStopLoss: signal.priceStopLoss,
+        originalPriceTakeProfit: signal.priceTakeProfit,
     };
 };
 /** Key generator for active position map */
@@ -6673,6 +7231,46 @@ class StrategyCoreService {
             await this.validate(symbol, context);
             return await this.strategyConnectionService.getScheduledSignal(backtest, symbol, context);
         };
+        /**
+         * Checks if breakeven threshold has been reached for the current pending signal.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to check if price has moved far enough to cover transaction costs.
+         *
+         * Does not require execution context as this is a state query operation.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to check against threshold
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+         *
+         * @example
+         * ```typescript
+         * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+         * const canBreakeven = await strategyCoreService.getBreakeven(
+         *   false,
+         *   "BTCUSDT",
+         *   100.5,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * // Returns true (price >= 100.4)
+         *
+         * if (canBreakeven) {
+         *   await strategyCoreService.breakeven(false, "BTCUSDT", 100.5, context);
+         * }
+         * ```
+         */
+        this.getBreakeven = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService getBreakeven", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.getBreakeven(backtest, symbol, currentPrice, context);
+        };
         /**
          * Checks if the strategy has been stopped.
          *
@@ -6902,30 +7500,68 @@ class StrategyCoreService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when trailing SL is updated
          *
          * @example
          * ```typescript
-         * // LONG: entry=100, originalSL=90, distance=10
-         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+         * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+         * // Tighten stop by 50%: newSL = 100 - 5% = 95
          * await strategyCoreService.trailingStop(
          *   false,
          *   "BTCUSDT",
          *   -50,
+         *   102,
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
          * );
          * ```
          */
-        this.trailingStop = async (backtest, symbol, percentShift, context) => {
+        this.trailingStop = async (backtest, symbol, percentShift, currentPrice, context) => {
             this.loggerService.log("strategyCoreService trailingStop", {
                 symbol,
                 percentShift,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, currentPrice, context);
+        };
+        /**
+         * Adjusts the trailing take-profit distance for an active pending signal.
+         * Validates context and delegates to StrategyConnectionService.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when trailing TP is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+         * // Move TP further by 50%: newTP = 100 + 15% = 115
+         * await strategyCoreService.trailingProfit(
+         *   false,
+         *   "BTCUSDT",
+         *   50,
+         *   102,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * ```
+         */
+        this.trailingProfit = async (backtest, symbol, percentShift, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService trailingProfit", {
+                symbol,
+                percentShift,
+                currentPrice,
                 context,
                 backtest,
             });
             await this.validate(symbol, context);
-            return await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, context);
+            return await this.strategyConnectionService.trailingProfit(backtest, symbol, percentShift, currentPrice, context);
         };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
@@ -7034,6 +7670,7 @@ class RiskGlobalService {
         this.loggerService = inject(TYPES.loggerService);
         this.riskConnectionService = inject(TYPES.riskConnectionService);
         this.riskValidationService = inject(TYPES.riskValidationService);
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         /**
          * Validates risk configuration.
          * Memoized to avoid redundant validations for the same risk-exchange-frame combination.
@@ -7046,6 +7683,7 @@ class RiskGlobalService {
                 payload,
             });
             this.riskValidationService.validate(payload.riskName, "riskGlobalService validate");
+            this.exchangeValidationService.validate(payload.exchangeName, "riskGlobalService validate");
         });
         /**
          * Checks if a signal should be allowed based on risk limits.
@@ -15318,6 +15956,10 @@ class PartialGlobalService {
          * Risk validation service for validating risk existence.
          */
         this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * Exchange validation service for validating exchange existence.
+         */
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -15331,6 +15973,7 @@ class PartialGlobalService {
                 methodName,
             });
             this.strategyValidationService.validate(context.strategyName, methodName);
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
             const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
@@ -16292,6 +16935,10 @@ class BreakevenGlobalService {
          * Risk validation service for validating risk existence.
          */
         this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * Exchange validation service for validating exchange existence.
+         */
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -16305,6 +16952,7 @@ class BreakevenGlobalService {
                 methodName,
             });
             this.strategyValidationService.validate(context.strategyName, methodName);
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
             const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
@@ -17618,6 +18266,7 @@ const CANCEL_METHOD_NAME = "strategy.cancel";
 const PARTIAL_PROFIT_METHOD_NAME = "strategy.partialProfit";
 const PARTIAL_LOSS_METHOD_NAME = "strategy.partialLoss";
 const TRAILING_STOP_METHOD_NAME = "strategy.trailingStop";
+const TRAILING_PROFIT_METHOD_NAME = "strategy.trailingProfit";
 const BREAKEVEN_METHOD_NAME = "strategy.breakeven";
 /**
  * Stops the strategy from generating new signals.
@@ -17785,21 +18434,23 @@ async function partialLoss(symbol, percentToClose) {
  *
  * @param symbol - Trading pair symbol
  * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+ * @param currentPrice - Current market price to check for intrusion
  * @returns Promise that resolves when trailing SL is updated
  *
  * @example
  * ```typescript
  * import { trailingStop } from "backtest-kit";
  *
- * // LONG: entry=100, originalSL=90, distance=10
- * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
- * await trailingStop("BTCUSDT", -50);
+ * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+ * // Tighten stop by 50%: newSL = 100 - 5% = 95
+ * await trailingStop("BTCUSDT", -50, 102);
  * ```
  */
-async function trailingStop(symbol, percentShift) {
+async function trailingStop(symbol, percentShift, currentPrice) {
     bt.loggerService.info(TRAILING_STOP_METHOD_NAME, {
         symbol,
         percentShift,
+        currentPrice,
     });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("trailingStop requires an execution context");
@@ -17809,7 +18460,46 @@ async function trailingStop(symbol, percentShift) {
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, { exchangeName, frameName, strategyName });
+    await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
+}
+/**
+ * Adjusts the trailing take-profit distance for an active pending signal.
+ *
+ * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+ * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+ * Once direction is set on first call, subsequent calls must continue in same direction.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+ * @param currentPrice - Current market price to check for intrusion
+ * @returns Promise that resolves when trailing TP is updated
+ *
+ * @example
+ * ```typescript
+ * import { trailingProfit } from "backtest-kit";
+ *
+ * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+ * // Move TP further by 50%: newTP = 100 + 15% = 115
+ * await trailingProfit("BTCUSDT", 50, 102);
+ * ```
+ */
+async function trailingProfit(symbol, percentShift, currentPrice) {
+    bt.loggerService.info(TRAILING_PROFIT_METHOD_NAME, {
+        symbol,
+        percentShift,
+        currentPrice,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("trailingProfit requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("trailingProfit requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.trailingProfit(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
  * Moves stop-loss to breakeven when price reaches threshold.
@@ -19751,10 +20441,12 @@ const BACKTEST_METHOD_NAME_TASK = "BacktestUtils.task";
 const BACKTEST_METHOD_NAME_GET_STATUS = "BacktestUtils.getStatus";
 const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal";
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
+const BACKTEST_METHOD_NAME_GET_BREAKEVEN = "BacktestUtils.getBreakeven";
 const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.cancel";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.partialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.partialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.trailingStop";
+const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.trailingProfit";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -20121,6 +20813,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20152,6 +20845,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20161,6 +20855,47 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getScheduledSignal(true, symbol, context);
         };
+        /**
+         * Checks if breakeven threshold has been reached for the current pending signal.
+         *
+         * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+         * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to check against threshold
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+         *
+         * @example
+         * ```typescript
+         * const canBreakeven = await Backtest.getBreakeven("BTCUSDT", 100.5, {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "backtest_frame"
+         * });
+         * if (canBreakeven) {
+         *   console.log("Breakeven threshold reached");
+         *   await Backtest.breakeven("BTCUSDT", 100.5, context);
+         * }
+         * ```
+         */
+        this.getBreakeven = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_BREAKEVEN, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_BREAKEVEN);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_BREAKEVEN);
+            {
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_BREAKEVEN);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_BREAKEVEN));
+            }
+            return await bt.strategyCoreService.getBreakeven(true, symbol, currentPrice, context);
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -20189,6 +20924,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_STOP);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_STOP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20228,6 +20964,7 @@ class BacktestUtils {
                 cancelId,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20271,6 +21008,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20314,6 +21052,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_PARTIAL_LOSS);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_PARTIAL_LOSS);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20331,27 +21070,30 @@ class BacktestUtils {
          *
          * @param symbol - Trading pair symbol
          * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
          * @param context - Execution context with strategyName, exchangeName, and frameName
          * @returns Promise that resolves when trailing SL is updated
          *
          * @example
          * ```typescript
-         * // LONG: entry=100, originalSL=90, distance=10
-         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
-         * await Backtest.trailingStop("BTCUSDT", -50, {
+         * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+         * // Tighten stop by 50%: newSL = 100 - 5% = 95
+         * await Backtest.trailingStop("BTCUSDT", -50, 102, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
          * });
          * ```
          */
-        this.trailingStop = async (symbol, percentShift, context) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_STOP, {
                 symbol,
                 percentShift,
+                currentPrice,
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_TRAILING_STOP);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_TRAILING_STOP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20359,7 +21101,49 @@ class BacktestUtils {
                 riskList &&
                     riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_STOP));
             }
-            await bt.strategyCoreService.trailingStop(true, symbol, percentShift, context);
+            await bt.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
+        };
+        /**
+         * Adjusts the trailing take-profit distance for an active pending signal.
+         *
+         * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+         * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+         * Once direction is set on first call, subsequent calls must continue in same direction.
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise that resolves when trailing TP is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+         * // Move TP further by 50%: newTP = 100 + 15% = 115
+         * await Backtest.trailingProfit("BTCUSDT", 50, 102, {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.trailingProfit = async (symbol, percentShift, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_PROFIT, {
+                symbol,
+                percentShift,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_TRAILING_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_TRAILING_PROFIT);
+            {
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_PROFIT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_PROFIT));
+            }
+            await bt.strategyCoreService.trailingProfit(true, symbol, percentShift, currentPrice, context);
         };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
@@ -20389,6 +21173,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, "Backtest.breakeven");
+            bt.exchangeValidationService.validate(context.exchangeName, "Backtest.breakeven");
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20422,6 +21207,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20456,6 +21242,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20498,6 +21285,7 @@ class BacktestUtils {
                 path,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20556,10 +21344,12 @@ const LIVE_METHOD_NAME_TASK = "LiveUtils.task";
 const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
 const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
 const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
+const LIVE_METHOD_NAME_GET_BREAKEVEN = "LiveUtils.getBreakeven";
 const LIVE_METHOD_NAME_CANCEL = "LiveUtils.cancel";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.partialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.partialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.trailingStop";
+const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.trailingProfit";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -20897,6 +21687,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
@@ -20930,6 +21721,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
@@ -20941,6 +21733,48 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Checks if breakeven threshold has been reached for the current pending signal.
+         *
+         * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+         * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to check against threshold
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+         *
+         * @example
+         * ```typescript
+         * const canBreakeven = await Live.getBreakeven("BTCUSDT", 100.5, {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance"
+         * });
+         * if (canBreakeven) {
+         *   console.log("Breakeven threshold reached");
+         *   await Live.breakeven("BTCUSDT", 100.5, context);
+         * }
+         * ```
+         */
+        this.getBreakeven = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_BREAKEVEN, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_BREAKEVEN);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_BREAKEVEN);
+            {
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_BREAKEVEN);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_BREAKEVEN));
+            }
+            return await bt.strategyCoreService.getBreakeven(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -20964,6 +21798,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_STOP);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_STOP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
@@ -21005,6 +21840,7 @@ class LiveUtils {
                 cancelId,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL);
@@ -21049,6 +21885,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
@@ -21093,6 +21930,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_LOSS);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_LOSS);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS);
@@ -21112,32 +21950,78 @@ class LiveUtils {
          *
          * @param symbol - Trading pair symbol
          * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
          * @param context - Execution context with strategyName and exchangeName
          * @returns Promise that resolves when trailing SL is updated
          *
          * @example
          * ```typescript
-         * // LONG: entry=100, originalSL=90, distance=10
-         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
-         * await Live.trailingStop("BTCUSDT", -50, {
+         * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+         * // Tighten stop by 50%: newSL = 100 - 5% = 95
+         * await Live.trailingStop("BTCUSDT", -50, 102, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
          * ```
          */
-        this.trailingStop = async (symbol, percentShift, context) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, context) => {
             bt.loggerService.info(LIVE_METHOD_NAME_TRAILING_STOP, {
                 symbol,
                 percentShift,
+                currentPrice,
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_TRAILING_STOP);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_TRAILING_STOP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP);
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP));
             }
-            await bt.strategyCoreService.trailingStop(false, symbol, percentShift, {
+            await bt.strategyCoreService.trailingStop(false, symbol, percentShift, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Adjusts the trailing take-profit distance for an active pending signal.
+         *
+         * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+         * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+         * Once direction is set on first call, subsequent calls must continue in same direction.
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise that resolves when trailing TP is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+         * // Move TP further by 50%: newTP = 100 + 15% = 115
+         * await Live.trailingProfit("BTCUSDT", 50, 102, {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.trailingProfit = async (symbol, percentShift, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_TRAILING_PROFIT, {
+                symbol,
+                percentShift,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_TRAILING_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_TRAILING_PROFIT);
+            {
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT));
+            }
+            await bt.strategyCoreService.trailingProfit(false, symbol, percentShift, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -21171,6 +22055,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, "Live.breakeven");
+            bt.exchangeValidationService.validate(context.exchangeName, "Live.breakeven");
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, "Live.breakeven");
@@ -21206,6 +22091,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
@@ -21238,6 +22124,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
@@ -21278,6 +22165,7 @@ class LiveUtils {
                 path,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
@@ -21371,6 +22259,7 @@ class ScheduleUtils {
                 backtest,
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA);
@@ -21399,6 +22288,7 @@ class ScheduleUtils {
                 backtest,
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
@@ -21431,6 +22321,7 @@ class ScheduleUtils {
                 path,
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
@@ -21519,6 +22410,7 @@ class Performance {
      */
     static async getData(symbol, context, backtest = false) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
+        bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_GET_DATA);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA);
@@ -21551,6 +22443,7 @@ class Performance {
      */
     static async getReport(symbol, context, backtest = false, columns) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
+        bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
@@ -21580,6 +22473,7 @@ class Performance {
      */
     static async dump(symbol, context, backtest = false, path = "./dump/performance", columns) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_DUMP);
+        bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_DUMP);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
@@ -22170,6 +23064,7 @@ class HeatUtils {
         this.getData = async (context, backtest = false) => {
             bt.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA);
@@ -22211,6 +23106,7 @@ class HeatUtils {
         this.getReport = async (context, backtest = false, columns) => {
             bt.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
@@ -22249,6 +23145,7 @@ class HeatUtils {
         this.dump = async (context, backtest = false, path, columns) => {
             bt.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
@@ -22581,6 +23478,7 @@ class PartialUtils {
         this.getData = async (symbol, context, backtest = false) => {
             bt.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA);
@@ -22630,6 +23528,7 @@ class PartialUtils {
         this.getReport = async (symbol, context, backtest = false, columns) => {
             bt.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
@@ -22672,6 +23571,7 @@ class PartialUtils {
         this.dump = async (symbol, context, backtest = false, path, columns) => {
             bt.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
@@ -23861,6 +24761,7 @@ class BreakevenUtils {
         this.getData = async (symbol, context, backtest = false) => {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_GET_DATA);
@@ -23906,6 +24807,7 @@ class BreakevenUtils {
         this.getReport = async (symbol, context, backtest = false, columns) => {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_GET_REPORT);
@@ -23948,6 +24850,7 @@ class BreakevenUtils {
         this.dump = async (symbol, context, backtest = false, path, columns) => {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_DUMP);
@@ -23973,4 +24876,4 @@ class BreakevenUtils {
  */
 const Breakeven = new BreakevenUtils();
 
-export { Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, breakeven, cancel, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenBreakeven, listenBreakevenOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, partialLoss, partialProfit, setColumns, setConfig, setLogger, stop, trailingStop, validate };
+export { Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, breakeven, cancel, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenBreakeven, listenBreakevenOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, partialLoss, partialProfit, setColumns, setConfig, setLogger, stop, trailingProfit, trailingStop, validate };