backtest-kit 3.8.1 → 4.0.1

package/types.d.ts

@@ -1,5 +1,4 @@
 import * as di_scoped from 'di-scoped';
-import SignalSyncContract$1 from 'src/contract/SignalSync.contract';
 import * as functools_kit from 'functools-kit';
 import { Subject } from 'functools-kit';
 import { WriteStream } from 'fs';
@@ -2986,6 +2985,25 @@ interface IStrategy {
      * ```
      */
     partialProfit: (symbol: string, percentToClose: number, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    /**
+     * Checks whether `partialProfit` would succeed without executing it.
+     *
+     * Returns `true` if all preconditions for a profitable partial close are met:
+     * - Active pending signal exists
+     * - `percentToClose` is a finite number in range (0, 100]
+     * - `currentPrice` is a positive finite number
+     * - Price is moving toward TP (not toward SL) relative to effective entry
+     * - Price has not already crossed the TP level
+     * - Closing the given percentage would not exceed 100% total closed
+     *
+     * Never throws. Safe to call at any time as a pre-flight check.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentToClose - Percentage of position to check (0-100]
+     * @param currentPrice - Current market price to validate against
+     * @returns `true` if `partialProfit` would execute, `false` otherwise
+     */
+    validatePartialProfit: (symbol: string, percentToClose: number, currentPrice: number) => Promise<boolean>;
     /**
      * Executes partial close at loss level (moving toward SL).
      *
@@ -3022,6 +3040,25 @@ interface IStrategy {
      * ```
      */
     partialLoss: (symbol: string, percentToClose: number, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    /**
+     * Checks whether `partialLoss` would succeed without executing it.
+     *
+     * Returns `true` if all preconditions for a loss-side partial close are met:
+     * - Active pending signal exists
+     * - `percentToClose` is a finite number in range (0, 100]
+     * - `currentPrice` is a positive finite number
+     * - Price is moving toward SL (not toward TP) relative to effective entry
+     * - Price has not already crossed the SL level
+     * - Closing the given percentage would not exceed 100% total closed
+     *
+     * Never throws. Safe to call at any time as a pre-flight check.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentToClose - Percentage of position to check (0-100]
+     * @param currentPrice - Current market price to validate against
+     * @returns `true` if `partialLoss` would execute, `false` otherwise
+     */
+    validatePartialLoss: (symbol: string, percentToClose: number, currentPrice: number) => Promise<boolean>;
     /**
      * Adjusts trailing stop-loss by shifting distance between entry and original SL.
      *
@@ -3087,6 +3124,25 @@ interface IStrategy {
      * ```
      */
     trailingStop: (symbol: string, percentShift: number, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    /**
+     * Checks whether `trailingStop` would succeed without executing it.
+     *
+     * Returns `true` if all preconditions for a trailing SL update are met:
+     * - Active pending signal exists
+     * - `percentShift` is a finite number in [-100, 100], non-zero
+     * - `currentPrice` is a positive finite number
+     * - Computed new SL does not intrude current price (price hasn't crossed it)
+     * - New SL does not conflict with effective TP (SL must remain on the safe side)
+     * - If a trailing SL already exists, new SL offers better protection (absorption rule)
+     *
+     * Never throws. Safe to call at any time as a pre-flight check.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentShift - Percentage shift of ORIGINAL SL distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to validate against
+     * @returns `true` if `trailingStop` would execute, `false` otherwise
+     */
+    validateTrailingStop: (symbol: string, percentShift: number, currentPrice: number) => Promise<boolean>;
     /**
      * Adjusts the trailing take-profit distance for an active pending signal.
      *
@@ -3136,6 +3192,26 @@ interface IStrategy {
      * ```
      */
     trailingTake: (symbol: string, percentShift: number, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    /**
+     * Checks whether `trailingTake` would succeed without executing it.
+     *
+     * Returns `true` if all preconditions for a trailing TP update are met:
+     * - Active pending signal exists
+     * - `percentShift` is a finite number in [-100, 100], non-zero
+     * - `currentPrice` is a positive finite number
+     * - Computed new TP does not intrude current price (price hasn't crossed it)
+     * - New TP does not conflict with effective SL (TP must remain on the profit side)
+     * - If a trailing TP already exists, new TP is more conservative (absorption rule:
+     *   LONG accepts only lower TP, SHORT accepts only higher TP)
+     *
+     * Never throws. Safe to call at any time as a pre-flight check.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentShift - Percentage adjustment to ORIGINAL TP distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to validate against
+     * @returns `true` if `trailingTake` would execute, `false` otherwise
+     */
+    validateTrailingTake: (symbol: string, percentShift: number, currentPrice: number) => Promise<boolean>;
     /**
      * Moves stop-loss to breakeven (entry price) when price reaches threshold.
      *
@@ -3186,6 +3262,24 @@ interface IStrategy {
      * ```
      */
     breakeven: (symbol: string, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    /**
+     * Checks whether `breakeven` would succeed without executing it.
+     *
+     * Returns `true` if all preconditions for moving SL to breakeven are met:
+     * - Active pending signal exists
+     * - `currentPrice` is a positive finite number
+     * - Price has moved far enough in profit direction to cover costs
+     *   (threshold: `(CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2`)
+     * - Breakeven SL would not conflict with effective TP
+     * - Breakeven has not already been set (idempotent — returns `false` on repeat)
+     *
+     * Never throws. Safe to call at any time as a pre-flight check.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price to validate against
+     * @returns `true` if `breakeven` would execute, `false` otherwise
+     */
+    validateBreakeven: (symbol: string, currentPrice: number) => Promise<boolean>;
     /**
      * Adds a new averaging entry to an open position (DCA — Dollar Cost Averaging).
      *
@@ -3207,6 +3301,24 @@ interface IStrategy {
      * @returns Promise<boolean> - true if entry added, false if rejected by direction check
      */
     averageBuy: (symbol: string, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    /**
+     * Checks whether `averageBuy` would succeed without executing it.
+     *
+     * Returns `true` if all preconditions for a DCA entry are met:
+     * - Active pending signal exists
+     * - `currentPrice` is a positive finite number
+     * - LONG: `currentPrice` is below the all-time lowest entry price
+     *   (or `CC_ENABLE_DCA_EVERYWHERE` is set)
+     * - SHORT: `currentPrice` is above the all-time highest entry price
+     *   (or `CC_ENABLE_DCA_EVERYWHERE` is set)
+     *
+     * Never throws. Safe to call at any time as a pre-flight check.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - New entry price to validate
+     * @returns `true` if `averageBuy` would execute, `false` otherwise
+     */
+    validateAverageBuy: (symbol: string, currentPrice: number) => Promise<boolean>;
     /**
      * Checks if there is an active pending signal for the symbol.
      *
@@ -4430,6 +4542,34 @@ declare function commitTrailingStop(symbol: string, percentShift: number, curren
  * ```
  */
 declare function commitTrailingTake(symbol: string, percentShift: number, currentPrice: number): Promise<boolean>;
+/**
+ * Adjusts the trailing stop-loss to an absolute price level.
+ *
+ * Convenience wrapper around commitTrailingStop that converts an absolute
+ * stop-loss price to a percentShift relative to the ORIGINAL SL distance.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @param newStopLossPrice - Desired absolute stop-loss price
+ * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected
+ */
+declare function commitTrailingStopCost(symbol: string, newStopLossPrice: number): Promise<boolean>;
+/**
+ * Adjusts the trailing take-profit to an absolute price level.
+ *
+ * Convenience wrapper around commitTrailingTake that converts an absolute
+ * take-profit price to a percentShift relative to the ORIGINAL TP distance.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @param newTakeProfitPrice - Desired absolute take-profit price
+ * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected
+ */
+declare function commitTrailingTakeCost(symbol: string, newTakeProfitPrice: number): Promise<boolean>;
 /**
  * Moves stop-loss to breakeven when price reaches threshold.
  *
@@ -4690,6 +4830,34 @@ declare function getPositionPnlCost(symbol: string): Promise<number | null>;
  * ```
  */
 declare function getPositionLevels(symbol: string): Promise<number[] | null>;
+/**
+ * Returns the list of partial close events for the current pending signal.
+ *
+ * Each element represents a partial profit or loss close executed via
+ * commitPartialProfit / commitPartialLoss (or their Cost variants).
+ *
+ * Returns null if no pending signal exists.
+ * Returns an empty array if no partials were executed yet.
+ *
+ * Each entry contains:
+ * - `type` — "profit" or "loss"
+ * - `percent` — percentage of position closed at this partial
+ * - `currentPrice` — execution price of the partial close
+ * - `costBasisAtClose` — accounting cost basis at the moment of this partial
+ * - `entryCountAtClose` — number of DCA entries accumulated at this partial
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to array of partial close records or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionPartials } from "backtest-kit";
+ *
+ * const partials = await getPositionPartials("BTCUSDT");
+ * // No partials yet: []
+ * // After one partial profit: [{ type: "profit", percent: 50, currentPrice: 45000, ... }]
+ * ```
+ */
 declare function getPositionPartials(symbol: string): Promise<{
     type: "profit" | "loss";
     percent: number;
@@ -7277,7 +7445,7 @@ declare function listenStrategyCommitOnce(filterFn: (event: StrategyCommitContra
  * @param fn - Callback function to handle sync events. If the function returns a promise, signal processing will wait until it resolves.
  * @returns Unsubscribe function to stop listening
  */
-declare function listenSync(fn: (event: SignalSyncContract$1) => void): () => void;
+declare function listenSync(fn: (event: SignalSyncContract) => void): () => void;
 /**
  * Subscribes to filtered signal synchronization events with one-time execution.
  * If throws position is not being opened/closed until the async function completes. Useful for synchronizing with external systems.
@@ -7286,7 +7454,7 @@ declare function listenSync(fn: (event: SignalSyncContract$1) => void): () => vo
  * @param fn - Callback function to handle the filtered event (called only once). If the function returns a promise, signal processing will wait until it resolves.
  * @returns Unsubscribe function to cancel the listener before it fires
  */
-declare function listenSyncOnce(filterFn: (event: SignalSyncContract$1) => boolean, fn: (event: SignalSyncContract$1) => void): () => void;
+declare function listenSyncOnce(filterFn: (event: SignalSyncContract) => boolean, fn: (event: SignalSyncContract) => void): () => void;
 
 /**
  * Checks if trade context is active (execution and method contexts).
@@ -11340,36 +11508,117 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Returns the effective (weighted average) entry price for the current pending signal.
+     *
+     * Accounts for all DCA entries via commitAverageBuy.
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Effective entry price, or null if no active position
+     */
     getPositionAveragePrice: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the total number of base-asset units currently held in the position.
+     *
+     * Includes units from all DCA entries. Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Total units held, or null if no active position
+     */
     getPositionInvestedCount: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the total dollar cost invested in the current position.
+     *
+     * Sum of all entry costs across DCA entries. Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Total invested cost in quote currency, or null if no active position
+     */
     getPositionInvestedCost: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the current unrealized PnL as a percentage of the invested cost.
+     *
+     * Calculated relative to the effective (weighted average) entry price.
+     * Positive for profit, negative for loss. Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns PnL percentage, or null if no active position
+     */
     getPositionPnlPercent: (symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the current unrealized PnL in quote currency (dollar amount).
+     *
+     * Calculated as (currentPrice - effectiveEntry) * units for LONG,
+     * reversed for SHORT. Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns PnL in quote currency, or null if no active position
+     */
     getPositionPnlCost: (symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the list of DCA entry prices for the current pending signal.
+     *
+     * The first element is always the original priceOpen (initial entry).
+     * Each subsequent element is a price added by commitAverageBuy().
+     * Returns null if no pending signal exists.
+     * Returns a single-element array [priceOpen] if no DCA entries were made.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Array of entry prices, or null if no active position
+     */
     getPositionLevels: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number[] | null>;
+    /**
+     * Returns the list of partial close events for the current pending signal.
+     *
+     * Each element represents a partial profit or loss close executed via
+     * commitPartialProfit / commitPartialLoss (or their Cost variants).
+     * Returns null if no pending signal exists.
+     * Returns an empty array if no partials were executed yet.
+     *
+     * Each entry contains:
+     * - `type` — "profit" or "loss"
+     * - `percent` — percentage of position closed at this partial
+     * - `currentPrice` — execution price of the partial close
+     * - `costBasisAtClose` — accounting cost basis at the moment of this partial
+     * - `entryCountAtClose` — number of DCA entries accumulated at this partial
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Array of partial close records, or null if no active position
+     */
     getPositionPartials: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -11700,6 +11949,40 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Adjusts the trailing stop-loss to an absolute price level.
+     *
+     * Convenience wrapper around commitTrailingStop that converts an absolute
+     * stop-loss price to a percentShift relative to the ORIGINAL SL distance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param newStopLossPrice - Desired absolute stop-loss price
+     * @param currentPrice - Current market price to check for intrusion
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected
+     */
+    commitTrailingStopCost: (symbol: string, newStopLossPrice: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Adjusts the trailing take-profit to an absolute price level.
+     *
+     * Convenience wrapper around commitTrailingTake that converts an absolute
+     * take-profit price to a percentShift relative to the ORIGINAL TP distance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param newTakeProfitPrice - Desired absolute take-profit price
+     * @param currentPrice - Current market price to check for intrusion
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected
+     */
+    commitTrailingTakeCost: (symbol: string, newTakeProfitPrice: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Moves stop-loss to breakeven when price reaches threshold.
      *
@@ -12290,30 +12573,111 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<boolean>;
+    /**
+     * Returns the effective (weighted average) entry price for the current pending signal.
+     *
+     * Accounts for all DCA entries via commitAverageBuy.
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Effective entry price, or null if no active position
+     */
     getPositionAveragePrice: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number | null>;
+    /**
+     * Returns the total number of base-asset units currently held in the position.
+     *
+     * Includes units from all DCA entries. Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Total units held, or null if no active position
+     */
     getPositionInvestedCount: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number | null>;
+    /**
+     * Returns the total dollar cost invested in the current position.
+     *
+     * Sum of all entry costs across DCA entries. Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Total invested cost in quote currency, or null if no active position
+     */
     getPositionInvestedCost: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number | null>;
+    /**
+     * Returns the current unrealized PnL as a percentage of the invested cost.
+     *
+     * Calculated relative to the effective (weighted average) entry price.
+     * Positive for profit, negative for loss. Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns PnL percentage, or null if no active position
+     */
     getPositionPnlPercent: (symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number | null>;
+    /**
+     * Returns the current unrealized PnL in quote currency (dollar amount).
+     *
+     * Calculated as (currentPrice - effectiveEntry) * units for LONG,
+     * reversed for SHORT. Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns PnL in quote currency, or null if no active position
+     */
     getPositionPnlCost: (symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number | null>;
+    /**
+     * Returns the list of DCA entry prices for the current pending signal.
+     *
+     * The first element is always the original priceOpen (initial entry).
+     * Each subsequent element is a price added by commitAverageBuy().
+     * Returns null if no pending signal exists.
+     * Returns a single-element array [priceOpen] if no DCA entries were made.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Array of entry prices, or null if no active position
+     */
     getPositionLevels: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number[] | null>;
+    /**
+     * Returns the list of partial close events for the current pending signal.
+     *
+     * Each element represents a partial profit or loss close executed via
+     * commitPartialProfit / commitPartialLoss (or their Cost variants).
+     * Returns null if no pending signal exists.
+     * Returns an empty array if no partials were executed yet.
+     *
+     * Each entry contains:
+     * - `type` — "profit" or "loss"
+     * - `percent` — percentage of position closed at this partial
+     * - `currentPrice` — execution price of the partial close
+     * - `costBasisAtClose` — accounting cost basis at the moment of this partial
+     * - `entryCountAtClose` — number of DCA entries accumulated at this partial
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Array of partial close records, or null if no active position
+     */
     getPositionPartials: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -12622,6 +12986,38 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<boolean>;
+    /**
+     * Adjusts the trailing stop-loss to an absolute price level.
+     *
+     * Convenience wrapper around commitTrailingStop that converts an absolute
+     * stop-loss price to a percentShift relative to the ORIGINAL SL distance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param newStopLossPrice - Desired absolute stop-loss price
+     * @param currentPrice - Current market price to check for intrusion
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected
+     */
+    commitTrailingStopCost: (symbol: string, newStopLossPrice: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
+    /**
+     * Adjusts the trailing take-profit to an absolute price level.
+     *
+     * Convenience wrapper around commitTrailingTake that converts an absolute
+     * take-profit price to a percentShift relative to the ORIGINAL TP distance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param newTakeProfitPrice - Desired absolute take-profit price
+     * @param currentPrice - Current market price to check for intrusion
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected
+     */
+    commitTrailingTakeCost: (symbol: string, newTakeProfitPrice: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
     /**
      * Moves stop-loss to breakeven when price reaches threshold.
      *
@@ -17816,47 +18212,983 @@ declare class ActionBase implements IPublicAction {
 }
 
 /**
- * Contract for walker stop signal events.
- *
- * Emitted when Walker.stop() is called to interrupt a running walker.
- * Contains metadata about which walker and strategy should be stopped.
+ * Payload for the signal-open broker event.
  *
- * Supports multiple walkers running on the same symbol simultaneously
- * by including walkerName for filtering.
+ * Emitted automatically via syncSubject when a new pending signal is activated.
+ * Forwarded to the registered IBroker adapter via `onSignalOpenCommit`.
  *
  * @example
  * ```typescript
- * import { walkerStopSubject } from "backtest-kit";
- *
- * walkerStopSubject
- *   .filter((event) => event.symbol === "BTCUSDT")
- *   .connect((event) => {
- *     console.log("Walker stopped:", event.walkerName);
- *     console.log("Strategy:", event.strategyName);
- *   });
+ * const payload: BrokerSignalOpenPayload = {
+ *   symbol: "BTCUSDT",
+ *   cost: 100,
+ *   position: "long",
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
  * ```
  */
-interface WalkerStopContract {
-    /** symbol - Trading symbol (e.g., "BTCUSDT") */
+type BrokerSignalOpenPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
     symbol: string;
-    /** strategyName - Name of the strategy to stop */
-    strategyName: StrategyName;
-    /** walkerName - Name of the walker to stop (for filtering) */
-    walkerName: WalkerName;
-}
-
+    /** Dollar cost of the position entry (CC_POSITION_ENTRY_COST) */
+    cost: number;
+    /** Position direction */
+    position: "long" | "short";
+    /** Activation price — the price at which the signal became active */
+    priceOpen: number;
+    /** Original take-profit price from the signal */
+    priceTakeProfit: number;
+    /** Original stop-loss price from the signal */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
 /**
- * Exchange signal synchronization emitter.
- * If listenner throws, it means the signal was not properly synchronized to the exchange (e.g. limit order failed to fill).
+ * Payload for the signal-close broker event.
  *
- * The framework will skip position open/close and will try again on the next tick until successful synchronization.
- * This ensures that the framework's internal state remains consistent with the exchange's state.
- * Consumers should implement retry logic in their listeners to handle transient synchronization failures.
+ * Emitted automatically via syncSubject when a pending signal is closed (SL/TP hit or manual close).
+ * Forwarded to the registered IBroker adapter via `onSignalCloseCommit`.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerSignalClosePayload = {
+ *   symbol: "BTCUSDT",
+ *   cost: 100,
+ *   position: "long",
+ *   currentPrice: 54000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   totalEntries: 2,
+ *   totalPartials: 1,
+ *   pnl: { profit: 80, loss: 0, volume: 100 },
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
  */
-declare const syncSubject: Subject<SignalSyncContract$1>;
-/**
- * Global signal emitter for all trading events (live + backtest).
- * Emits all signal events regardless of execution mode.
+type BrokerSignalClosePayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Total dollar cost basis of the position at close */
+    cost: number;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of close */
+    currentPrice: number;
+    /** Original take-profit price from the signal */
+    priceTakeProfit: number;
+    /** Original stop-loss price from the signal */
+    priceStopLoss: number;
+    /** Total number of DCA entries (including initial open) */
+    totalEntries: number;
+    /** Total number of partial closes executed before final close */
+    totalPartials: number;
+    /** Realized PnL breakdown for the closed position */
+    pnl: IStrategyPnL;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for a partial-profit close broker event.
+ *
+ * Forwarded to the registered IBroker adapter via `onPartialProfitCommit`.
+ * Called explicitly after all validations pass, before `strategyCoreService.partialProfit()`.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerPartialProfitPayload = {
+ *   symbol: "BTCUSDT",
+ *   percentToClose: 30,
+ *   cost: 30,
+ *   currentPrice: 52000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerPartialProfitPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Percentage of the position to close (0–100) */
+    percentToClose: number;
+    /** Dollar value of the portion being closed */
+    cost: number;
+    /** Current market price at which the partial close executes */
+    currentPrice: number;
+    /** Position direction */
+    position: "long" | "short";
+    /** Active take profit price at the time of the partial close */
+    priceTakeProfit: number;
+    /** Active stop loss price at the time of the partial close */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for a partial-loss close broker event.
+ *
+ * Forwarded to the registered IBroker adapter via `onPartialLossCommit`.
+ * Called explicitly after all validations pass, before `strategyCoreService.partialLoss()`.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerPartialLossPayload = {
+ *   symbol: "BTCUSDT",
+ *   percentToClose: 40,
+ *   cost: 40,
+ *   currentPrice: 48500,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerPartialLossPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Percentage of the position to close (0–100) */
+    percentToClose: number;
+    /** Dollar value of the portion being closed */
+    cost: number;
+    /** Current market price at which the partial close executes */
+    currentPrice: number;
+    /** Position direction */
+    position: "long" | "short";
+    /** Active take profit price at the time of the partial close */
+    priceTakeProfit: number;
+    /** Active stop loss price at the time of the partial close */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for a trailing stop-loss update broker event.
+ *
+ * Forwarded to the registered IBroker adapter via `onTrailingStopCommit`.
+ * Called explicitly after all validations pass, before `strategyCoreService.trailingStop()`.
+ * `newStopLossPrice` is the absolute SL price computed from percentShift + original SL + effectivePriceOpen.
+ *
+ * @example
+ * ```typescript
+ * // LONG: entry=100, originalSL=90, percentShift=-5 → newSL=95
+ * const payload: BrokerTrailingStopPayload = {
+ *   symbol: "BTCUSDT",
+ *   percentShift: -5,
+ *   currentPrice: 102,
+ *   newStopLossPrice: 95,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerTrailingStopPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Percentage shift applied to the ORIGINAL SL distance (-100 to 100) */
+    percentShift: number;
+    /** Current market price used for intrusion validation */
+    currentPrice: number;
+    /** Absolute stop-loss price after applying percentShift */
+    newStopLossPrice: number;
+    /** Position direction */
+    position: "long" | "short";
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for a trailing take-profit update broker event.
+ *
+ * Forwarded to the registered IBroker adapter via `onTrailingTakeCommit`.
+ * Called explicitly after all validations pass, before `strategyCoreService.trailingTake()`.
+ * `newTakeProfitPrice` is the absolute TP price computed from percentShift + original TP + effectivePriceOpen.
+ *
+ * @example
+ * ```typescript
+ * // LONG: entry=100, originalTP=110, percentShift=-3 → newTP=107
+ * const payload: BrokerTrailingTakePayload = {
+ *   symbol: "BTCUSDT",
+ *   percentShift: -3,
+ *   currentPrice: 102,
+ *   newTakeProfitPrice: 107,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerTrailingTakePayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Percentage shift applied to the ORIGINAL TP distance (-100 to 100) */
+    percentShift: number;
+    /** Current market price used for intrusion validation */
+    currentPrice: number;
+    /** Absolute take-profit price after applying percentShift */
+    newTakeProfitPrice: number;
+    /** Position direction */
+    position: "long" | "short";
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for a breakeven operation broker event.
+ *
+ * Forwarded to the registered IBroker adapter via `onBreakevenCommit`.
+ * Called explicitly after all validations pass, before `strategyCoreService.breakeven()`.
+ * `newStopLossPrice` equals `effectivePriceOpen` (entry price).
+ * `newTakeProfitPrice` equals `_trailingPriceTakeProfit ?? priceTakeProfit` (TP is unchanged).
+ *
+ * @example
+ * ```typescript
+ * // LONG: entry=100, currentPrice=100.5, newSL=100 (entry), newTP=110 (unchanged)
+ * const payload: BrokerBreakevenPayload = {
+ *   symbol: "BTCUSDT",
+ *   currentPrice: 100.5,
+ *   newStopLossPrice: 100,
+ *   newTakeProfitPrice: 110,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerBreakevenPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Current market price at the moment breakeven is triggered */
+    currentPrice: number;
+    /** New stop-loss price = effectivePriceOpen (the position's effective entry price) */
+    newStopLossPrice: number;
+    /** Effective take-profit price = _trailingPriceTakeProfit ?? priceTakeProfit (unchanged by breakeven) */
+    newTakeProfitPrice: number;
+    /** Position direction */
+    position: "long" | "short";
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for a DCA average-buy entry broker event.
+ *
+ * Forwarded to the registered IBroker adapter via `onAverageBuyCommit`.
+ * Called explicitly after all validations pass, before `strategyCoreService.averageBuy()`.
+ * `currentPrice` is the market price at which the new DCA entry is added.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerAverageBuyPayload = {
+ *   symbol: "BTCUSDT",
+ *   currentPrice: 42000,
+ *   cost: 100,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerAverageBuyPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Market price at which the DCA entry is placed */
+    currentPrice: number;
+    /** Dollar amount of the new DCA entry (default: CC_POSITION_ENTRY_COST) */
+    cost: number;
+    /** Position direction */
+    position: "long" | "short";
+    /** Active take profit price at the time of the DCA entry */
+    priceTakeProfit: number;
+    /** Active stop loss price at the time of the DCA entry */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+interface IBroker {
+    waitForInit(): Promise<void>;
+    onSignalCloseCommit(payload: BrokerSignalClosePayload): Promise<void>;
+    onSignalOpenCommit(payload: BrokerSignalOpenPayload): Promise<void>;
+    onPartialProfitCommit(payload: BrokerPartialProfitPayload): Promise<void>;
+    onPartialLossCommit(payload: BrokerPartialLossPayload): Promise<void>;
+    onTrailingStopCommit(payload: BrokerTrailingStopPayload): Promise<void>;
+    onTrailingTakeCommit(payload: BrokerTrailingTakePayload): Promise<void>;
+    onBreakevenCommit(payload: BrokerBreakevenPayload): Promise<void>;
+    onAverageBuyCommit(payload: BrokerAverageBuyPayload): Promise<void>;
+}
+type TBrokerCtor = new () => Partial<IBroker>;
+/**
+ * Facade for broker integration — intercepts all commit* operations before DI-core mutations.
+ *
+ * Acts as a transaction control point: if any commit* method throws, the DI-core mutation
+ * is never reached and the state remains unchanged.
+ *
+ * In backtest mode all commit* calls are silently skipped (payload.backtest === true).
+ * In live mode the call is forwarded to the registered IBroker adapter via BrokerProxy.
+ *
+ * signal-open and signal-close events are routed automatically via syncSubject subscription
+ * (activated on `enable()`). All other commit* methods are called explicitly from
+ * Live.ts / Backtest.ts / strategy.ts before the corresponding strategyCoreService call.
+ *
+ * @example
+ * ```typescript
+ * import { Broker } from "backtest-kit";
+ *
+ * // Register a custom broker adapter
+ * Broker.useBrokerAdapter(MyBrokerAdapter);
+ *
+ * // Activate syncSubject subscription (signal-open / signal-close routing)
+ * const dispose = Broker.enable();
+ *
+ * // ... run strategy ...
+ *
+ * // Deactivate when done
+ * Broker.disable();
+ * ```
+ */
+declare class BrokerAdapter {
+    private _brokerInstance;
+    /**
+     * Forwards a signal-open event to the registered broker adapter.
+     *
+     * Called automatically via syncSubject when `enable()` is active.
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Signal open details: symbol, cost, position, prices, context, backtest flag
+     *
+     * @example
+     * ```typescript
+     * await Broker.commitSignalOpen({
+     *   symbol: "BTCUSDT",
+     *   cost: 100,
+     *   position: "long",
+     *   priceOpen: 50000,
+     *   priceTakeProfit: 55000,
+     *   priceStopLoss: 48000,
+     *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+     *   backtest: false,
+     * });
+     * ```
+     */
+    commitSignalOpen: (payload: BrokerSignalOpenPayload) => Promise<void>;
+    /**
+     * Forwards a signal-close event to the registered broker adapter.
+     *
+     * Called automatically via syncSubject when `enable()` is active.
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Signal close details: symbol, cost, position, currentPrice, pnl, context, backtest flag
+     *
+     * @example
+     * ```typescript
+     * await Broker.commitSignalClose({
+     *   symbol: "BTCUSDT",
+     *   cost: 100,
+     *   position: "long",
+     *   currentPrice: 54000,
+     *   priceTakeProfit: 55000,
+     *   priceStopLoss: 48000,
+     *   totalEntries: 2,
+     *   totalPartials: 1,
+     *   pnl: { profit: 80, loss: 0, volume: 100 },
+     *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+     *   backtest: false,
+     * });
+     * ```
+     */
+    commitSignalClose: (payload: BrokerSignalClosePayload) => Promise<void>;
+    /**
+     * Intercepts a partial-profit close before DI-core mutation.
+     *
+     * Called explicitly from Live.ts / Backtest.ts / strategy.ts after all validations pass,
+     * but before `strategyCoreService.partialProfit()`. If this method throws, the DI mutation
+     * is skipped and state remains unchanged.
+     *
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Partial profit details: symbol, percentToClose, cost (dollar value), currentPrice, context, backtest flag
+     *
+     * @example
+     * ```typescript
+     * await Broker.commitPartialProfit({
+     *   symbol: "BTCUSDT",
+     *   percentToClose: 30,
+     *   cost: 30,
+     *   currentPrice: 52000,
+     *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+     *   backtest: false,
+     * });
+     * ```
+     */
+    commitPartialProfit: (payload: BrokerPartialProfitPayload) => Promise<void>;
+    /**
+     * Intercepts a partial-loss close before DI-core mutation.
+     *
+     * Called explicitly from Live.ts / Backtest.ts / strategy.ts after all validations pass,
+     * but before `strategyCoreService.partialLoss()`. If this method throws, the DI mutation
+     * is skipped and state remains unchanged.
+     *
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Partial loss details: symbol, percentToClose, cost (dollar value), currentPrice, context, backtest flag
+     *
+     * @example
+     * ```typescript
+     * await Broker.commitPartialLoss({
+     *   symbol: "BTCUSDT",
+     *   percentToClose: 40,
+     *   cost: 40,
+     *   currentPrice: 48500,
+     *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+     *   backtest: false,
+     * });
+     * ```
+     */
+    commitPartialLoss: (payload: BrokerPartialLossPayload) => Promise<void>;
+    /**
+     * Intercepts a trailing stop-loss update before DI-core mutation.
+     *
+     * Called explicitly after all validations pass, but before `strategyCoreService.trailingStop()`.
+     * `newStopLossPrice` is the absolute price computed from percentShift + original SL + effectivePriceOpen.
+     *
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Trailing stop details: symbol, percentShift, currentPrice, newStopLossPrice, context, backtest flag
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, originalSL=90, percentShift=-5 → newSL=95
+     * await Broker.commitTrailingStop({
+     *   symbol: "BTCUSDT",
+     *   percentShift: -5,
+     *   currentPrice: 102,
+     *   newStopLossPrice: 95,
+     *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+     *   backtest: false,
+     * });
+     * ```
+     */
+    commitTrailingStop: (payload: BrokerTrailingStopPayload) => Promise<void>;
+    /**
+     * Intercepts a trailing take-profit update before DI-core mutation.
+     *
+     * Called explicitly after all validations pass, but before `strategyCoreService.trailingTake()`.
+     * `newTakeProfitPrice` is the absolute price computed from percentShift + original TP + effectivePriceOpen.
+     *
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Trailing take details: symbol, percentShift, currentPrice, newTakeProfitPrice, context, backtest flag
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, originalTP=110, percentShift=-3 → newTP=107
+     * await Broker.commitTrailingTake({
+     *   symbol: "BTCUSDT",
+     *   percentShift: -3,
+     *   currentPrice: 102,
+     *   newTakeProfitPrice: 107,
+     *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+     *   backtest: false,
+     * });
+     * ```
+     */
+    commitTrailingTake: (payload: BrokerTrailingTakePayload) => Promise<void>;
+    /**
+     * Intercepts a breakeven operation before DI-core mutation.
+     *
+     * Called explicitly after all validations pass, but before `strategyCoreService.breakeven()`.
+     * `newStopLossPrice` equals effectivePriceOpen (entry price).
+     * `newTakeProfitPrice` equals `_trailingPriceTakeProfit ?? priceTakeProfit` (TP is unchanged by breakeven).
+     *
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Breakeven details: symbol, currentPrice, newStopLossPrice, newTakeProfitPrice, context, backtest flag
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, currentPrice=100.5, newSL=100 (entry), newTP=110 (unchanged)
+     * await Broker.commitBreakeven({
+     *   symbol: "BTCUSDT",
+     *   currentPrice: 100.5,
+     *   newStopLossPrice: 100,
+     *   newTakeProfitPrice: 110,
+     *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+     *   backtest: false,
+     * });
+     * ```
+     */
+    commitBreakeven: (payload: BrokerBreakevenPayload) => Promise<void>;
+    /**
+     * Intercepts a DCA average-buy entry before DI-core mutation.
+     *
+     * Called explicitly after all validations pass, but before `strategyCoreService.averageBuy()`.
+     * `currentPrice` is the market price at which the new DCA entry is added.
+     * `cost` is the dollar amount of the new entry (default: CC_POSITION_ENTRY_COST).
+     *
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Average buy details: symbol, currentPrice, cost, context, backtest flag
+     *
+     * @example
+     * ```typescript
+     * // Add DCA entry at current market price
+     * await Broker.commitAverageBuy({
+     *   symbol: "BTCUSDT",
+     *   currentPrice: 42000,
+     *   cost: 100,
+     *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+     *   backtest: false,
+     * });
+     * ```
+     */
+    commitAverageBuy: (payload: BrokerAverageBuyPayload) => Promise<void>;
+    /**
+     * Registers a broker adapter instance or constructor to receive commit* callbacks.
+     *
+     * Must be called before `enable()`. Accepts either a class constructor (called with `new`)
+     * or an already-instantiated object implementing `Partial<IBroker>`.
+     *
+     * @param broker - IBroker constructor or instance
+     *
+     * @example
+     * ```typescript
+     * import { Broker } from "backtest-kit";
+     *
+     * // Register via constructor
+     * Broker.useBrokerAdapter(MyBrokerAdapter);
+     *
+     * // Register via instance
+     * Broker.useBrokerAdapter(new MyBrokerAdapter());
+     * ```
+     */
+    useBrokerAdapter: (broker: TBrokerCtor | Partial<IBroker>) => void;
+    /**
+     * Activates the broker: subscribes to syncSubject for signal-open / signal-close routing.
+     *
+     * Must be called after `useBrokerAdapter()`. Returns a dispose function that unsubscribes
+     * from syncSubject (equivalent to calling `disable()`).
+     *
+     * Calling `enable()` without a registered adapter throws immediately.
+     * Calling `enable()` more than once is idempotent (singleshot guard).
+     *
+     * @returns Dispose function — call it to deactivate the broker subscription
+     *
+     * @example
+     * ```typescript
+     * import { Broker } from "backtest-kit";
+     *
+     * Broker.useBrokerAdapter(MyBrokerAdapter);
+     * const dispose = Broker.enable();
+     *
+     * // ... run backtest or live session ...
+     *
+     * dispose(); // or Broker.disable()
+     * ```
+     */
+    enable: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Deactivates the broker: unsubscribes from syncSubject and resets the singleshot guard.
+     *
+     * Idempotent — safe to call even if `enable()` was never called.
+     * After `disable()`, `enable()` can be called again to reactivate.
+     *
+     * @example
+     * ```typescript
+     * import { Broker } from "backtest-kit";
+     *
+     * Broker.useBrokerAdapter(MyBrokerAdapter);
+     * Broker.enable();
+     *
+     * // Stop receiving events
+     * Broker.disable();
+     * ```
+     */
+    disable: () => void;
+}
+/**
+ * Base class for custom broker adapter implementations.
+ *
+ * Provides default no-op implementations for all IBroker methods that log events.
+ * Extend this class to implement a real exchange adapter for:
+ * - Placing and canceling limit/market orders
+ * - Updating stop-loss and take-profit levels on exchange
+ * - Tracking position state in an external system
+ * - Sending trade notifications (Telegram, Discord, Email)
+ * - Recording trades to a database or analytics service
+ *
+ * Key features:
+ * - All methods have default implementations (no need to override unused methods)
+ * - Automatic logging of all events via bt.loggerService
+ * - Implements the full IBroker interface
+ * - `makeExtendable` applied for correct subclass instantiation
+ *
+ * Lifecycle:
+ * 1. Constructor called (no arguments)
+ * 2. `waitForInit()` called once for async initialization (e.g. exchange login)
+ * 3. Event methods called as strategy executes
+ * 4. No explicit dispose — clean up in `waitForInit` teardown or externally
+ *
+ * Event flow (called only in live mode, skipped in backtest):
+ * - `onSignalOpenCommit` — new position opened
+ * - `onSignalCloseCommit` — position closed (SL/TP hit or manual close)
+ * - `onPartialProfitCommit` — partial close at profit executed
+ * - `onPartialLossCommit` — partial close at loss executed
+ * - `onTrailingStopCommit` — trailing stop-loss updated
+ * - `onTrailingTakeCommit` — trailing take-profit updated
+ * - `onBreakevenCommit` — stop-loss moved to entry price
+ * - `onAverageBuyCommit` — new DCA entry added to position
+ *
+ * @example
+ * ```typescript
+ * import { BrokerBase, Broker } from "backtest-kit";
+ *
+ * // Extend BrokerBase and override only needed methods
+ * class BinanceBroker extends BrokerBase {
+ *   private client: BinanceClient | null = null;
+ *
+ *   async waitForInit() {
+ *     super.waitForInit(); // Call parent for logging
+ *     this.client = new BinanceClient(process.env.API_KEY, process.env.SECRET);
+ *     await this.client.connect();
+ *   }
+ *
+ *   async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
+ *     super.onSignalOpenCommit(payload); // Call parent for logging
+ *     await this.client!.placeOrder({
+ *       symbol: payload.symbol,
+ *       side: payload.position === "long" ? "BUY" : "SELL",
+ *       quantity: payload.cost / payload.priceOpen,
+ *     });
+ *   }
+ *
+ *   async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
+ *     super.onSignalCloseCommit(payload); // Call parent for logging
+ *     await this.client!.closePosition(payload.symbol);
+ *   }
+ * }
+ *
+ * // Register the adapter
+ * Broker.useBrokerAdapter(BinanceBroker);
+ * Broker.enable();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Minimal implementation — only handle opens and closes
+ * class NotifyBroker extends BrokerBase {
+ *   async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
+ *     await sendTelegram(`Opened ${payload.position} on ${payload.symbol}`);
+ *   }
+ *
+ *   async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
+ *     const pnl = payload.pnl.profit - payload.pnl.loss;
+ *     await sendTelegram(`Closed ${payload.symbol}: PnL $${pnl.toFixed(2)}`);
+ *   }
+ * }
+ * ```
+ */
+declare class BrokerBase implements IBroker {
+    /**
+     * Performs async initialization before the broker starts receiving events.
+     *
+     * Called once by BrokerProxy via `waitForInit()` (singleshot) before the first event.
+     * Override to establish exchange connections, authenticate API clients, load configuration.
+     *
+     * Default implementation: Logs initialization event.
+     *
+     * @example
+     * ```typescript
+     * async waitForInit() {
+     *   super.waitForInit(); // Keep parent logging
+     *   this.exchange = new ExchangeClient(process.env.API_KEY);
+     *   await this.exchange.authenticate();
+     * }
+     * ```
+     */
+    waitForInit(): Promise<void>;
+    /**
+     * Called when a new position is opened (signal activated).
+     *
+     * Triggered automatically via syncSubject when a scheduled signal's priceOpen is hit.
+     * Use to place the actual entry order on the exchange.
+     *
+     * Default implementation: Logs signal-open event.
+     *
+     * @param payload - Signal open details: symbol, cost, position, priceOpen, priceTakeProfit, priceStopLoss, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
+     *   super.onSignalOpenCommit(payload); // Keep parent logging
+     *   await this.exchange.placeMarketOrder({
+     *     symbol: payload.symbol,
+     *     side: payload.position === "long" ? "BUY" : "SELL",
+     *     quantity: payload.cost / payload.priceOpen,
+     *   });
+     * }
+     * ```
+     */
+    onSignalOpenCommit(payload: BrokerSignalOpenPayload): Promise<void>;
+    /**
+     * Called when a position is fully closed (SL/TP hit or manual close).
+     *
+     * Triggered automatically via syncSubject when a pending signal is closed.
+     * Use to place the exit order and record final PnL.
+     *
+     * Default implementation: Logs signal-close event.
+     *
+     * @param payload - Signal close details: symbol, cost, position, currentPrice, pnl, totalEntries, totalPartials, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
+     *   super.onSignalCloseCommit(payload); // Keep parent logging
+     *   await this.exchange.closePosition(payload.symbol);
+     *   await this.db.recordTrade({ symbol: payload.symbol, pnl: payload.pnl });
+     * }
+     * ```
+     */
+    onSignalCloseCommit(payload: BrokerSignalClosePayload): Promise<void>;
+    /**
+     * Called when a partial close at profit is executed.
+     *
+     * Triggered explicitly from strategy.ts / Live.ts / Backtest.ts after all validations pass,
+     * before `strategyCoreService.partialProfit()`. If this method throws, the DI mutation is skipped.
+     * Use to partially close the position on the exchange at the profit level.
+     *
+     * Default implementation: Logs partial profit event.
+     *
+     * @param payload - Partial profit details: symbol, percentToClose, cost (dollar value), currentPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onPartialProfitCommit(payload: BrokerPartialProfitPayload) {
+     *   super.onPartialProfitCommit(payload); // Keep parent logging
+     *   await this.exchange.reducePosition({
+     *     symbol: payload.symbol,
+     *     dollarAmount: payload.cost,
+     *     price: payload.currentPrice,
+     *   });
+     * }
+     * ```
+     */
+    onPartialProfitCommit(payload: BrokerPartialProfitPayload): Promise<void>;
+    /**
+     * Called when a partial close at loss is executed.
+     *
+     * Triggered explicitly from strategy.ts / Live.ts / Backtest.ts after all validations pass,
+     * before `strategyCoreService.partialLoss()`. If this method throws, the DI mutation is skipped.
+     * Use to partially close the position on the exchange at the loss level.
+     *
+     * Default implementation: Logs partial loss event.
+     *
+     * @param payload - Partial loss details: symbol, percentToClose, cost (dollar value), currentPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onPartialLossCommit(payload: BrokerPartialLossPayload) {
+     *   super.onPartialLossCommit(payload); // Keep parent logging
+     *   await this.exchange.reducePosition({
+     *     symbol: payload.symbol,
+     *     dollarAmount: payload.cost,
+     *     price: payload.currentPrice,
+     *   });
+     * }
+     * ```
+     */
+    onPartialLossCommit(payload: BrokerPartialLossPayload): Promise<void>;
+    /**
+     * Called when the trailing stop-loss level is updated.
+     *
+     * Triggered explicitly after all validations pass, before `strategyCoreService.trailingStop()`.
+     * `newStopLossPrice` is the absolute SL price — use it to update the exchange order directly.
+     *
+     * Default implementation: Logs trailing stop event.
+     *
+     * @param payload - Trailing stop details: symbol, percentShift, currentPrice, newStopLossPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onTrailingStopCommit(payload: BrokerTrailingStopPayload) {
+     *   super.onTrailingStopCommit(payload); // Keep parent logging
+     *   await this.exchange.updateStopLoss({
+     *     symbol: payload.symbol,
+     *     price: payload.newStopLossPrice,
+     *   });
+     * }
+     * ```
+     */
+    onTrailingStopCommit(payload: BrokerTrailingStopPayload): Promise<void>;
+    /**
+     * Called when the trailing take-profit level is updated.
+     *
+     * Triggered explicitly after all validations pass, before `strategyCoreService.trailingTake()`.
+     * `newTakeProfitPrice` is the absolute TP price — use it to update the exchange order directly.
+     *
+     * Default implementation: Logs trailing take event.
+     *
+     * @param payload - Trailing take details: symbol, percentShift, currentPrice, newTakeProfitPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onTrailingTakeCommit(payload: BrokerTrailingTakePayload) {
+     *   super.onTrailingTakeCommit(payload); // Keep parent logging
+     *   await this.exchange.updateTakeProfit({
+     *     symbol: payload.symbol,
+     *     price: payload.newTakeProfitPrice,
+     *   });
+     * }
+     * ```
+     */
+    onTrailingTakeCommit(payload: BrokerTrailingTakePayload): Promise<void>;
+    /**
+     * Called when the stop-loss is moved to breakeven (entry price).
+     *
+     * Triggered explicitly after all validations pass, before `strategyCoreService.breakeven()`.
+     * `newStopLossPrice` equals `effectivePriceOpen` — the position's effective entry price.
+     * `newTakeProfitPrice` is unchanged by breakeven.
+     *
+     * Default implementation: Logs breakeven event.
+     *
+     * @param payload - Breakeven details: symbol, currentPrice, newStopLossPrice, newTakeProfitPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onBreakevenCommit(payload: BrokerBreakevenPayload) {
+     *   super.onBreakevenCommit(payload); // Keep parent logging
+     *   await this.exchange.updateStopLoss({
+     *     symbol: payload.symbol,
+     *     price: payload.newStopLossPrice, // = entry price
+     *   });
+     * }
+     * ```
+     */
+    onBreakevenCommit(payload: BrokerBreakevenPayload): Promise<void>;
+    /**
+     * Called when a new DCA entry is added to the active position.
+     *
+     * Triggered explicitly after all validations pass, before `strategyCoreService.averageBuy()`.
+     * `currentPrice` is the market price at which the new averaging entry is placed.
+     * `cost` is the dollar amount of the new DCA entry.
+     *
+     * Default implementation: Logs average buy event.
+     *
+     * @param payload - Average buy details: symbol, currentPrice, cost, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onAverageBuyCommit(payload: BrokerAverageBuyPayload) {
+     *   super.onAverageBuyCommit(payload); // Keep parent logging
+     *   await this.exchange.placeMarketOrder({
+     *     symbol: payload.symbol,
+     *     side: "BUY",
+     *     quantity: payload.cost / payload.currentPrice,
+     *   });
+     * }
+     * ```
+     */
+    onAverageBuyCommit(payload: BrokerAverageBuyPayload): Promise<void>;
+}
+/**
+ * Global singleton instance of BrokerAdapter.
+ * Provides static-like access to all broker commit methods and lifecycle controls.
+ *
+ * @example
+ * ```typescript
+ * import { Broker } from "backtest-kit";
+ *
+ * Broker.useBrokerAdapter(MyBrokerAdapter);
+ * const dispose = Broker.enable();
+ * ```
+ */
+declare const Broker: BrokerAdapter;
+
+/**
+ * Contract for walker stop signal events.
+ *
+ * Emitted when Walker.stop() is called to interrupt a running walker.
+ * Contains metadata about which walker and strategy should be stopped.
+ *
+ * Supports multiple walkers running on the same symbol simultaneously
+ * by including walkerName for filtering.
+ *
+ * @example
+ * ```typescript
+ * import { walkerStopSubject } from "backtest-kit";
+ *
+ * walkerStopSubject
+ *   .filter((event) => event.symbol === "BTCUSDT")
+ *   .connect((event) => {
+ *     console.log("Walker stopped:", event.walkerName);
+ *     console.log("Strategy:", event.strategyName);
+ *   });
+ * ```
+ */
+interface WalkerStopContract {
+    /** symbol - Trading symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** strategyName - Name of the strategy to stop */
+    strategyName: StrategyName;
+    /** walkerName - Name of the walker to stop (for filtering) */
+    walkerName: WalkerName;
+}
+
+/**
+ * Exchange signal synchronization emitter.
+ * If listenner throws, it means the signal was not properly synchronized to the exchange (e.g. limit order failed to fill).
+ *
+ * The framework will skip position open/close and will try again on the next tick until successful synchronization.
+ * This ensures that the framework's internal state remains consistent with the exchange's state.
+ * Consumers should implement retry logic in their listeners to handle transient synchronization failures.
+ */
+declare const syncSubject: Subject<SignalSyncContract>;
+/**
+ * Global signal emitter for all trading events (live + backtest).
+ * Emits all signal events regardless of execution mode.
  */
 declare const signalEmitter: Subject<IStrategyTickResult>;
 /**
@@ -18176,6 +19508,99 @@ declare const percentValue: (yesterdayValue: number, todayValue: number) => numb
  */
 declare const investedCostToPercent: (dollarAmount: number, investedCost: number) => number;
 
+/**
+ * Convert an absolute stop-loss price to a percentShift for `commitTrailingStop`.
+ *
+ * percentShift = newSlDistancePercent - originalSlDistancePercent
+ * where distance = Math.abs((effectivePriceOpen - slPrice) / effectivePriceOpen * 100)
+ *
+ * @param newStopLossPrice - Desired absolute stop-loss price
+ * @param originalStopLossPrice - Original stop-loss price from the pending signal
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @returns percentShift to pass to `commitTrailingStop`
+ *
+ * @example
+ * // LONG: entry=100, originalSL=90, desired newSL=95
+ * const shift = slPriceToPercentShift(95, 90, 100); // -5
+ * await commitTrailingStop("BTCUSDT", shift, currentPrice);
+ */
+declare const slPriceToPercentShift: (newStopLossPrice: number, originalStopLossPrice: number, effectivePriceOpen: number) => number;
+
+/**
+ * Convert an absolute take-profit price to a percentShift for `commitTrailingTake`.
+ *
+ * percentShift = newTpDistancePercent - originalTpDistancePercent
+ * where distance = Math.abs((tpPrice - effectivePriceOpen) / effectivePriceOpen * 100)
+ *
+ * @param newTakeProfitPrice - Desired absolute take-profit price
+ * @param originalTakeProfitPrice - Original take-profit price from the pending signal
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @returns percentShift to pass to `commitTrailingTake`
+ *
+ * @example
+ * // LONG: entry=100, originalTP=110, desired newTP=107
+ * const shift = tpPriceToPercentShift(107, 110, 100); // -3
+ * await commitTrailingTake("BTCUSDT", shift, currentPrice);
+ */
+declare const tpPriceToPercentShift: (newTakeProfitPrice: number, originalTakeProfitPrice: number, effectivePriceOpen: number) => number;
+
+/**
+ * Convert a percentShift for `commitTrailingStop` back to an absolute stop-loss price.
+ *
+ * Inverse of `slPriceToPercentShift`.
+ *
+ * newSlDistancePercent = originalSlDistancePercent + percentShift
+ * LONG:  newStopLossPrice = effectivePriceOpen * (1 - newSlDistancePercent / 100)
+ * SHORT: newStopLossPrice = effectivePriceOpen * (1 + newSlDistancePercent / 100)
+ *
+ * @param percentShift - Value returned by `slPriceToPercentShift` (or passed to `commitTrailingStop`)
+ * @param originalStopLossPrice - Original stop-loss price from the pending signal
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param position - Position direction: "long" or "short"
+ * @returns Absolute stop-loss price corresponding to the given percentShift
+ *
+ * @example
+ * // LONG: entry=100, originalSL=90, percentShift=-5
+ * const price = slPercentShiftToPrice(-5, 90, 100, "long"); // 95
+ */
+declare const slPercentShiftToPrice: (percentShift: number, originalStopLossPrice: number, effectivePriceOpen: number, position: "long" | "short") => number;
+
+/**
+ * Convert a percentShift for `commitTrailingTake` back to an absolute take-profit price.
+ *
+ * Inverse of `tpPriceToPercentShift`.
+ *
+ * newTpDistancePercent = originalTpDistancePercent + percentShift
+ * LONG:  newTakeProfitPrice = effectivePriceOpen * (1 + newTpDistancePercent / 100)
+ * SHORT: newTakeProfitPrice = effectivePriceOpen * (1 - newTpDistancePercent / 100)
+ *
+ * @param percentShift - Value returned by `tpPriceToPercentShift` (or passed to `commitTrailingTake`)
+ * @param originalTakeProfitPrice - Original take-profit price from the pending signal
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param position - Position direction: "long" or "short"
+ * @returns Absolute take-profit price corresponding to the given percentShift
+ *
+ * @example
+ * // LONG: entry=100, originalTP=110, percentShift=-3
+ * const price = tpPercentShiftToPrice(-3, 110, 100, "long"); // 107
+ */
+declare const tpPercentShiftToPrice: (percentShift: number, originalTakeProfitPrice: number, effectivePriceOpen: number, position: "long" | "short") => number;
+
+/**
+ * Compute the dollar cost of a partial close from percentToClose and current invested cost basis.
+ *
+ * cost = (percentToClose / 100) * investedCost
+ *
+ * @param percentToClose - Percentage of position to close (0–100)
+ * @param investedCost - Current invested cost basis (from `getPositionInvestedCost`)
+ * @returns Dollar amount that will be closed
+ *
+ * @example
+ * // Position investedCost=$1000, closing 25%
+ * const cost = percentToCloseCost(25, 1000); // 250
+ */
+declare const percentToCloseCost: (percentToClose: number, investedCost: number) => number;
+
 /**
  * Client implementation for exchange data access.
  *
@@ -19497,6 +20922,22 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }, closeId?: string) => Promise<void>;
+    /**
+     * Checks whether `partialProfit` would succeed without executing it.
+     * Delegates to `ClientStrategy.validatePartialProfit()` — no throws, pure boolean result.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentToClose - Percentage of position to check (0-100]
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `partialProfit` would execute, false otherwise
+     */
+    validatePartialProfit: (backtest: boolean, symbol: string, percentToClose: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Executes partial close at profit level (moving toward TP).
      *
@@ -19532,6 +20973,22 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Checks whether `partialLoss` would succeed without executing it.
+     * Delegates to `ClientStrategy.validatePartialLoss()` — no throws, pure boolean result.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentToClose - Percentage of position to check (0-100]
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `partialLoss` would execute, false otherwise
+     */
+    validatePartialLoss: (backtest: boolean, symbol: string, percentToClose: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Executes partial close at loss level (moving toward SL).
      *
@@ -19567,6 +21024,22 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Checks whether `trailingStop` would succeed without executing it.
+     * Delegates to `ClientStrategy.validateTrailingStop()` — no throws, pure boolean result.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage shift of ORIGINAL SL distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `trailingStop` would execute, false otherwise
+     */
+    validateTrailingStop: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Adjusts the trailing stop-loss distance for an active pending signal.
      *
@@ -19600,6 +21073,22 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Checks whether `trailingTake` would succeed without executing it.
+     * Delegates to `ClientStrategy.validateTrailingTake()` — no throws, pure boolean result.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage adjustment to ORIGINAL TP distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `trailingTake` would execute, false otherwise
+     */
+    validateTrailingTake: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Adjusts the trailing take-profit distance for an active pending signal.
      *
@@ -19633,6 +21122,21 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Checks whether `breakeven` would succeed without executing it.
+     * Delegates to `ClientStrategy.validateBreakeven()` — no throws, pure boolean result.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `breakeven` would execute, false otherwise
+     */
+    validateBreakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Delegates to ClientStrategy.breakeven() with current execution context.
      *
@@ -19688,6 +21192,21 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }, activateId?: string) => Promise<void>;
+    /**
+     * Checks whether `averageBuy` would succeed without executing it.
+     * Delegates to `ClientStrategy.validateAverageBuy()` — no throws, pure boolean result.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - New entry price to validate
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `averageBuy` would execute, false otherwise
+     */
+    validateAverageBuy: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Adds a new DCA entry to the active pending signal.
      *
@@ -20637,6 +22156,22 @@ declare class StrategyCoreService implements TStrategy {
         frameName: FrameName;
         backtest: boolean;
     }) => Promise<void>;
+    /**
+     * Checks whether `partialProfit` would succeed without executing it.
+     * Validates context, then delegates to StrategyConnectionService.validatePartialProfit().
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentToClose - Percentage of position to check (0-100]
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `partialProfit` would execute, false otherwise
+     */
+    validatePartialProfit: (backtest: boolean, symbol: string, percentToClose: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Executes partial close at profit level (moving toward TP).
      *
@@ -20672,6 +22207,22 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Checks whether `partialLoss` would succeed without executing it.
+     * Validates context, then delegates to StrategyConnectionService.validatePartialLoss().
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentToClose - Percentage of position to check (0-100]
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `partialLoss` would execute, false otherwise
+     */
+    validatePartialLoss: (backtest: boolean, symbol: string, percentToClose: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Executes partial close at loss level (moving toward SL).
      *
@@ -20735,6 +22286,22 @@ declare class StrategyCoreService implements TStrategy {
      * );
      * ```
      */
+    validateTrailingStop: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Checks whether `trailingStop` would succeed without executing it.
+     * Validates context, then delegates to StrategyConnectionService.validateTrailingStop().
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage shift of ORIGINAL SL distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `trailingStop` would execute, false otherwise
+     */
     trailingStop: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -20764,6 +22331,22 @@ declare class StrategyCoreService implements TStrategy {
      * );
      * ```
      */
+    validateTrailingTake: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Checks whether `trailingTake` would succeed without executing it.
+     * Validates context, then delegates to StrategyConnectionService.validateTrailingTake().
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage adjustment to ORIGINAL TP distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `trailingTake` would execute, false otherwise
+     */
     trailingTake: (backtest: boolean, symbol: string, percentShift: number, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -20789,6 +22372,21 @@ declare class StrategyCoreService implements TStrategy {
      * );
      * ```
      */
+    validateBreakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Checks whether `breakeven` would succeed without executing it.
+     * Validates context, then delegates to StrategyConnectionService.validateBreakeven().
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to validate against
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `breakeven` would execute, false otherwise
+     */
     breakeven: (backtest: boolean, symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -20834,6 +22432,21 @@ declare class StrategyCoreService implements TStrategy {
      * @param context - Execution context with strategyName, exchangeName, frameName
      * @returns Promise<boolean> - true if entry added, false if rejected
      */
+    validateAverageBuy: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Checks whether `averageBuy` would succeed without executing it.
+     * Validates context, then delegates to StrategyConnectionService.validateAverageBuy().
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - New entry price to validate
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<boolean> - true if `averageBuy` would execute, false otherwise
+     */
     averageBuy: (backtest: boolean, symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -23477,4 +25090,4 @@ declare const getTotalClosed: (signal: Signal) => {
     remainingCostBasis: number;
 };
 
-export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Cache, type CancelScheduledCommit, type CandleData, type CandleInterval, type ClosePendingCommit, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionAveragePrice, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, toProfitLossDto, validate, waitForCandle, warmCandles };
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CandleData, type CandleInterval, type ClosePendingCommit, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, type TBrokerCtor, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionAveragePrice, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };