backtest-kit 1.10.2 → 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
@@ -3571,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)
@@ -3639,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);
@@ -3662,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);
@@ -3925,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";
             }
@@ -3940,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";
             }
@@ -3953,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;
@@ -3974,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);
                 }
@@ -3995,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);
                 }
@@ -4981,6 +5090,32 @@ class ClientStrategy {
             });
             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)
@@ -4997,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";
@@ -5785,6 +6050,45 @@ class StrategyConnectionService {
             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.trailingProfit(symbol, percentShift, currentPrice, backtest);
+        };
         /**
          * Delegates to ClientStrategy.breakeven() with current execution context.
          *
@@ -6254,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
@@ -6271,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 */
@@ -7221,6 +7528,41 @@ class StrategyCoreService {
             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.trailingProfit(backtest, symbol, percentShift, currentPrice, context);
+        };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
          * Validates context and delegates to StrategyConnectionService.
@@ -17924,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.
@@ -18119,6 +18462,45 @@ async function trailingStop(symbol, percentShift, currentPrice) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     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.
  *
@@ -20064,6 +20446,7 @@ 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.
@@ -20720,6 +21103,48 @@ class BacktestUtils {
             }
             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.
          *
@@ -20924,6 +21349,7 @@ 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.
@@ -21558,6 +21984,49 @@ class LiveUtils {
                 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: "",
+            });
+        };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
          *
@@ -24407,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 };