backtest-kit 6.5.2 → 6.8.0

package/types.d.ts

@@ -272,6 +272,8 @@ interface IRiskParams extends IRiskSchema {
     exchangeName: ExchangeName;
     /** Logger service for debug output */
     logger: ILogger;
+    /** Execution context service (symbol, when, backtest flag) */
+    execution: TExecutionContextService;
     /** True if backtest mode, false if live mode */
     backtest: boolean;
     /**
@@ -1321,6 +1323,47 @@ type SignalSyncContract = SignalOpenContract | SignalCloseContract;
  * ```
  */
 type TActionCtor = new (strategyName: StrategyName, frameName: FrameName, actionName: ActionName, backtest: boolean) => Partial<IPublicAction>;
+/**
+ * Strategy query interface exposed to action handlers via IActionParams.strategy.
+ *
+ * Provides read-only access to the current signal state needed for
+ * guard checks inside ActionProxy before invoking user callbacks.
+ *
+ * Used by:
+ * - ActionProxy.breakevenAvailable — skips if no pending signal
+ * - ActionProxy.partialProfitAvailable — skips if no pending signal
+ * - ActionProxy.partialLossAvailable — skips if no pending signal
+ * - ActionProxy.pingActive — skips if no pending signal
+ * - ActionProxy.pingScheduled — skips if no scheduled signal
+ */
+interface IActionStrategy {
+    /**
+     * Checks if there is an active pending signal (open position) for the symbol.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to true if a pending signal exists, false otherwise
+     */
+    hasPendingSignal(backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }): Promise<boolean>;
+    /**
+     * Checks if there is a waiting scheduled signal for the symbol.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to true if a scheduled signal exists, false otherwise
+     */
+    hasScheduledSignal(backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }): Promise<boolean>;
+}
 /**
  * Action parameters passed to ClientAction constructor.
  * Combines schema with runtime dependencies and execution context.
@@ -1355,6 +1398,8 @@ interface IActionParams extends IActionSchema {
     frameName: FrameName;
     /** Whether running in backtest mode */
     backtest: boolean;
+    /** Strategy context object providing access to current signal and position state */
+    strategy: IActionStrategy;
 }
 /**
  * Lifecycle and event callbacks for action handlers.
@@ -2235,6 +2280,19 @@ interface ISignalRow extends ISignalDto {
         pnlPercentage: number;
         pnlCost: number;
     };
+    /**
+     * Worst price seen in loss direction during the life of this position.
+     * Initialized at position open with priceOpen/pendingAt (pnl = 0).
+     * Updated on every tick/candle when price moves toward SL (currentDistance < 0).
+     * - For LONG: minimum VWAP price seen below effective entry
+     * - For SHORT: maximum VWAP price seen above effective entry
+     */
+    _fall: {
+        price: number;
+        timestamp: number;
+        pnlPercentage: number;
+        pnlCost: number;
+    };
     /** Unix timestamp in milliseconds when this signal was created/scheduled in backtest context or when getSignal was called in live context (before validation) */
     timestamp: number;
 }
@@ -3502,6 +3560,68 @@ interface IStrategy {
      * @returns Promise resolving to drawdown duration in minutes or null
      */
     getPositionDrawdownMinutes: (symbol: string, timestamp: number) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to minutes since last profit peak or null
+     */
+    getPositionHighestProfitMinutes: (symbol: string, timestamp: number) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to minutes since last drawdown trough or null
+     */
+    getPositionMaxDrawdownMinutes: (symbol: string, timestamp: number) => Promise<number | null>;
+    /**
+     * Returns the worst price reached in the loss direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to price or null
+     */
+    getPositionMaxDrawdownPrice: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    getPositionMaxDrawdownTimestamp: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL percentage or null
+     */
+    getPositionMaxDrawdownPnlPercentage: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL cost or null
+     */
+    getPositionMaxDrawdownPnlCost: (symbol: string) => Promise<number | null>;
     /**
      * Disposes the strategy instance and cleans up resources.
      *
@@ -4106,6 +4226,10 @@ interface BacktestStatisticsModel {
     certaintyRatio: number | null;
     /** Expected yearly returns based on average trade duration and PNL, null if unsafe. Higher is better. */
     expectedYearlyReturns: number | null;
+    /** Average peak PNL percentage across all signals (_peak.pnlPercentage), null if unsafe. Higher is better. */
+    avgPeakPnl: number | null;
+    /** Average fall PNL percentage across all signals (_fall.pnlPercentage), null if unsafe. Lower (more negative) means deeper drawdowns. */
+    avgFallPnl: number | null;
 }
 
 /**
@@ -5349,6 +5473,115 @@ declare function getPositionHighestProfitBreakeven(symbol: string): Promise<bool
  * ```
  */
 declare function getPositionDrawdownMinutes(symbol: string): Promise<number>;
+/**
+ * Returns the number of minutes elapsed since the highest profit price was recorded.
+ *
+ * Alias for getPositionDrawdownMinutes — measures how long the position has been
+ * pulling back from its peak profit level.
+ * Zero when called at the exact moment the peak was set.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to minutes since last profit peak or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitMinutes } from "backtest-kit";
+ *
+ * const minutes = await getPositionHighestProfitMinutes("BTCUSDT");
+ * // e.g. 30 (30 minutes since the highest profit price)
+ * ```
+ */
+declare function getPositionHighestProfitMinutes(symbol: string): Promise<number>;
+/**
+ * Returns the number of minutes elapsed since the worst loss price was recorded.
+ *
+ * Measures how long ago the deepest drawdown point occurred.
+ * Zero when called at the exact moment the trough was set.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to minutes since last drawdown trough or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownMinutes } from "backtest-kit";
+ *
+ * const minutes = await getPositionMaxDrawdownMinutes("BTCUSDT");
+ * // e.g. 15 (15 minutes since the worst loss price)
+ * ```
+ */
+declare function getPositionMaxDrawdownMinutes(symbol: string): Promise<number>;
+/**
+ * Returns the worst price reached in the loss direction during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to price or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPrice } from "backtest-kit";
+ *
+ * const price = await getPositionMaxDrawdownPrice("BTCUSDT");
+ * // e.g. 41000 (lowest price seen for a LONG position)
+ * ```
+ */
+declare function getPositionMaxDrawdownPrice(symbol: string): Promise<number>;
+/**
+ * Returns the timestamp when the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to timestamp in milliseconds or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownTimestamp } from "backtest-kit";
+ *
+ * const ts = await getPositionMaxDrawdownTimestamp("BTCUSDT");
+ * // e.g. 1700000000000
+ * ```
+ */
+declare function getPositionMaxDrawdownTimestamp(symbol: string): Promise<number>;
+/**
+ * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL percentage or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPnlPercentage } from "backtest-kit";
+ *
+ * const pnl = await getPositionMaxDrawdownPnlPercentage("BTCUSDT");
+ * // e.g. -5.2 (deepest PnL percentage reached)
+ * ```
+ */
+declare function getPositionMaxDrawdownPnlPercentage(symbol: string): Promise<number>;
+/**
+ * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL cost or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPnlCost } from "backtest-kit";
+ *
+ * const cost = await getPositionMaxDrawdownPnlCost("BTCUSDT");
+ * // e.g. -52 (deepest PnL in quote currency)
+ * ```
+ */
+declare function getPositionMaxDrawdownPnlCost(symbol: string): Promise<number>;
 /**
  * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
  * Use this to prevent duplicate DCA entries at the same price area.
@@ -5653,6 +5886,13 @@ declare const GLOBAL_CONFIG: {
      * Default: 250 events
      */
     CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: number;
+    /**
+     * Maximum number of events to keep in max drawdown markdown report storage.
+     * Older events are removed (FIFO) when this limit is exceeded.
+     *
+     * Default: 250 events
+     */
+    CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS: number;
     /**
      * Maximum number of events to keep in live markdown report storage.
      * Older events are removed (FIFO) when this limit is exceeded.
@@ -5807,6 +6047,8 @@ declare const COLUMN_CONFIG: {
     sync_columns: ColumnModel<SyncEvent>[];
     /** Columns for highest profit milestone tracking events */
     highest_profit_columns: ColumnModel<HighestProfitEvent>[];
+    /** Columns for max drawdown milestone tracking events */
+    max_drawdown_columns: ColumnModel<MaxDrawdownEvent>[];
     /** Walker: PnL summary columns */
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     /** Walker: strategy-level summary columns */
@@ -5886,6 +6128,7 @@ declare function getConfig(): {
     CC_MAX_BREAKEVEN_MARKDOWN_ROWS: number;
     CC_MAX_HEATMAP_MARKDOWN_ROWS: number;
     CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: number;
+    CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS: number;
     CC_MAX_LIVE_MARKDOWN_ROWS: number;
     CC_MAX_PARTIAL_MARKDOWN_ROWS: number;
     CC_MAX_RISK_MARKDOWN_ROWS: number;
@@ -5941,6 +6184,7 @@ declare function getDefaultConfig(): Readonly<{
     CC_MAX_BREAKEVEN_MARKDOWN_ROWS: number;
     CC_MAX_HEATMAP_MARKDOWN_ROWS: number;
     CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: number;
+    CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS: number;
     CC_MAX_LIVE_MARKDOWN_ROWS: number;
     CC_MAX_PARTIAL_MARKDOWN_ROWS: number;
     CC_MAX_RISK_MARKDOWN_ROWS: number;
@@ -6010,6 +6254,7 @@ declare function getColumns(): {
     strategy_columns: ColumnModel<StrategyEvent>[];
     sync_columns: ColumnModel<SyncEvent>[];
     highest_profit_columns: ColumnModel<HighestProfitEvent>[];
+    max_drawdown_columns: ColumnModel<MaxDrawdownEvent>[];
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     walker_strategy_columns: ColumnModel<IStrategyResult>[];
 };
@@ -6039,6 +6284,7 @@ declare function getDefaultColumns(): Readonly<{
     strategy_columns: ColumnModel<StrategyEvent>[];
     sync_columns: ColumnModel<SyncEvent>[];
     highest_profit_columns: ColumnModel<HighestProfitEvent>[];
+    max_drawdown_columns: ColumnModel<MaxDrawdownEvent>[];
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     walker_strategy_columns: ColumnModel<IStrategyResult>[];
 }>;
@@ -7112,6 +7358,35 @@ interface HighestProfitContract {
     backtest: boolean;
 }
 
+/**
+ * Contract for max drawdown updates emitted by the framework.
+ * This contract defines the structure of the data emitted when a new maximum drawdown is reached for an open position.
+ * It includes contextual information about the strategy, exchange, frame, and the associated signal.
+ * Consumers can use this information to implement custom logic based on drawdown milestones (e.g. dynamic stop-loss adjustments, risk management).
+ * The backtest flag allows consumers to differentiate between live and backtest updates for appropriate handling.
+ * Max drawdown events are crucial for monitoring and managing risk, as they indicate the largest peak-to-trough decline in the position's value.
+ * By tracking max drawdown, traders can make informed decisions to protect capital and optimize position management strategies.
+ * The framework emits max drawdown updates whenever a new drawdown level is reached, allowing consumers to react in real-time to changing market conditions and position performance.
+ */
+interface MaxDrawdownContract {
+    /** Trading symbol (e.g. "BTC/USDT") */
+    symbol: string;
+    /** Current price at the time of the max drawdown update */
+    currentPrice: number;
+    /** Timestamp of the max drawdown update (milliseconds since epoch) */
+    timestamp: number;
+    /** Strategy name for context */
+    strategyName: StrategyName;
+    /** Exchange name for context */
+    exchangeName: ExchangeName;
+    /** Frame name for context (e.g. "1m", "5m") */
+    frameName: FrameName;
+    /** Public signal data for the position associated with this max drawdown update */
+    signal: IPublicSignalRow;
+    /** Indicates if the update is from a backtest or live trading (true for backtest, false for live) */
+    backtest: boolean;
+}
+
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -8148,6 +8423,25 @@ declare function listenHighestProfit(fn: (event: HighestProfitContract) => void)
  * @returns Unsubscribe function to cancel the listener before it fires
  */
 declare function listenHighestProfitOnce(filterFn: (event: HighestProfitContract) => boolean, fn: (event: HighestProfitContract) => void): () => void;
+/**
+ * Subscribes to max drawdown events with queued async processing.
+ * Emits when a signal reaches a new maximum drawdown level during its lifecycle.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * Useful for tracking drawdown milestones and implementing dynamic risk management logic.
+ * @param fn - Callback function to handle max drawdown events
+ * @return Unsubscribe function to stop listening to events
+ */
+declare function listenMaxDrawdown(fn: (event: MaxDrawdownContract) => void): () => void;
+/**
+ * Subscribes to filtered max drawdown events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific drawdown conditions.
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @return Unsubscribe function to cancel the listener before it fires
+ */
+declare function listenMaxDrawdownOnce(filterFn: (event: MaxDrawdownContract) => boolean, fn: (event: MaxDrawdownContract) => void): () => void;
 
 /**
  * Checks if trade context is active (execution and method contexts).
@@ -8826,6 +9120,10 @@ interface IHeatmapRow {
     maxLossStreak: number;
     /** Expectancy: (winRate * avgWin) - (lossRate * avgLoss) */
     expectancy: number | null;
+    /** Average peak PNL percentage across all trades (_peak.pnlPercentage). Higher is better. */
+    avgPeakPnl: number | null;
+    /** Average fall PNL percentage across all trades (_fall.pnlPercentage). Closer to 0 is better. */
+    avgFallPnl: number | null;
 }
 
 /**
@@ -10111,6 +10409,10 @@ interface TickEvent {
     pendingAt?: number;
     /** Timestamp when signal was created/scheduled (only for scheduled/waiting/opened/active/closed/cancelled) */
     scheduledAt?: number;
+    /** Peak PNL percentage at best price during position (_peak.pnlPercentage, only for closed) */
+    peakPnl?: number;
+    /** Fall PNL percentage at worst price during position (_fall.pnlPercentage, only for closed) */
+    fallPnl?: number;
 }
 /**
  * Statistical data calculated from live trading results.
@@ -10162,6 +10464,10 @@ interface LiveStatisticsModel {
     certaintyRatio: number | null;
     /** Expected yearly returns based on average trade duration and PNL, null if unsafe. Higher is better. */
     expectedYearlyReturns: number | null;
+    /** Average peak PNL percentage across all closed signals (_peak.pnlPercentage), null if unsafe. Higher is better. */
+    avgPeakPnl: number | null;
+    /** Average fall PNL percentage across all closed signals (_fall.pnlPercentage), null if unsafe. Closer to 0 is better. */
+    avgFallPnl: number | null;
 }
 
 /**
@@ -10179,6 +10485,10 @@ interface HeatmapStatisticsModel {
     portfolioSharpeRatio: number | null;
     /** Portfolio-wide total trades */
     portfolioTotalTrades: number;
+    /** Trade-count-weighted average peak PNL across all symbols. Higher is better. */
+    portfolioAvgPeakPnl: number | null;
+    /** Trade-count-weighted average fall PNL across all symbols. Closer to 0 is better. */
+    portfolioAvgFallPnl: number | null;
 }
 
 /**
@@ -10485,6 +10795,43 @@ interface HighestProfitStatisticsModel {
     totalEvents: number;
 }
 
+/**
+ * Single max drawdown event recorded for a position.
+ */
+interface MaxDrawdownEvent {
+    /** Unix timestamp in milliseconds when the record was set */
+    timestamp: number;
+    /** Trading pair symbol */
+    symbol: string;
+    /** Strategy name */
+    strategyName: string;
+    /** Signal unique identifier */
+    signalId: string;
+    /** Position direction */
+    position: IPublicSignalRow["position"];
+    /** Unrealized PNL at the time the record was set */
+    pnl: IStrategyPnL;
+    /** Record price reached in the loss direction */
+    currentPrice: number;
+    /** Effective entry price at the time of the update */
+    priceOpen: number;
+    /** Take profit price */
+    priceTakeProfit: number;
+    /** Stop loss price */
+    priceStopLoss: number;
+    /** Whether the event occurred in backtest mode */
+    backtest: boolean;
+}
+/**
+ * Aggregated statistics model for max drawdown events.
+ */
+interface MaxDrawdownStatisticsModel {
+    /** Full list of recorded events (newest first) */
+    eventList: MaxDrawdownEvent[];
+    /** Total number of recorded events */
+    totalEvents: number;
+}
+
 /**
  * Risk rejection event data for report generation.
  * Contains all information about rejected signals due to risk limits.
@@ -11849,44 +12196,235 @@ declare class PersistMemoryUtils {
  */
 declare const PersistMemoryAdapter: PersistMemoryUtils;
 
-/** Symbol key for the singleshot waitForInit function on ReportBase instances. */
-declare const WAIT_FOR_INIT_SYMBOL$1: unique symbol;
-/** Symbol key for the timeout-protected write function on ReportBase instances. */
-declare const WRITE_SAFE_SYMBOL$1: unique symbol;
 /**
- * Configuration interface for selective report service enablement.
- * Controls which report services should be activated for JSONL event logging.
+ * Configuration interface for selective markdown service enablement.
+ * Controls which markdown report services should be activated.
  */
-interface IReportTarget {
-    /** Enable strategy commit actions */
+interface IMarkdownTarget {
+    /** Enable strategy event tracking reports (entry/exit signals) */
     strategy: boolean;
-    /** Enable risk rejection event logging */
+    /** Enable risk rejection tracking reports (signals blocked by risk limits) */
     risk: boolean;
-    /** Enable breakeven event logging */
+    /** Enable breakeven event tracking reports (when stop loss moves to entry) */
     breakeven: boolean;
-    /** Enable partial close event logging */
+    /** Enable partial profit/loss event tracking reports */
     partial: boolean;
-    /** Enable heatmap data event logging */
+    /** Enable portfolio heatmap analysis reports across all symbols */
     heat: boolean;
-    /** Enable walker iteration event logging */
+    /** Enable walker strategy comparison and optimization reports */
     walker: boolean;
-    /** Enable performance metrics event logging */
+    /** Enable performance metrics and bottleneck analysis reports */
     performance: boolean;
-    /** Enable scheduled signal event logging */
+    /** Enable scheduled signal tracking reports (signals waiting for trigger) */
     schedule: boolean;
-    /** Enable live trading event logging (all tick states) */
+    /** Enable live trading event reports (all tick events) */
     live: boolean;
-    /** Enable backtest closed signal event logging */
+    /** Enable backtest markdown reports (main strategy results with full trade history) */
     backtest: boolean;
-    /** Enable signal synchronization event logging (signal-open, signal-close) */
+    /** Enable signal sync lifecycle reports (signal-open and signal-close events) */
     sync: boolean;
-    /** Enable highest profit milestone event logging */
+    /** Enable highest profit milestone tracking reports */
     highest_profit: boolean;
+    /** Enable max drawdown milestone tracking reports */
+    max_drawdown: boolean;
 }
+/** Symbol key for the singleshot waitForInit function on MarkdownFileBase instances. */
+declare const WAIT_FOR_INIT_SYMBOL: unique symbol;
+/** Symbol key for the timeout-protected write function on MarkdownFileBase instances. */
+declare const WRITE_SAFE_SYMBOL: unique symbol;
 /**
- * Union type of all valid report names.
- * Used for type-safe identification of report services.
- */
+ * Union type of all valid markdown report names.
+ * Used for type-safe identification of markdown services.
+ */
+type MarkdownName = keyof IMarkdownTarget;
+/**
+ * Options for markdown dump operations.
+ * Contains path information and metadata for filtering.
+ */
+interface IMarkdownDumpOptions {
+    /** Directory path relative to process.cwd() */
+    path: string;
+    /** File name including extension */
+    file: string;
+    /** Trading pair symbol (e.g., "BTCUSDT") */
+    symbol: string;
+    /** Strategy name */
+    strategyName: string;
+    /** Exchange name */
+    exchangeName: string;
+    /** Frame name (timeframe identifier) */
+    frameName: string;
+    /** Signal unique identifier */
+    signalId: string;
+}
+/**
+ * Base interface for markdown storage adapters.
+ * All markdown adapters must implement this interface.
+ */
+type TMarkdownBase = {
+    /**
+     * Initialize markdown storage and prepare for writes.
+     * Uses singleshot to ensure one-time execution.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    waitForInit(initial: boolean): Promise<void>;
+    /**
+     * Dump markdown content to storage.
+     *
+     * @param content - Markdown content to write
+     * @param options - Metadata and path options for the dump
+     * @returns Promise that resolves when write is complete
+     * @throws Error if write fails or stream is not initialized
+     */
+    dump(content: string, options: IMarkdownDumpOptions): Promise<void>;
+};
+/**
+ * Constructor type for markdown storage adapters.
+ * Used for custom markdown storage implementations.
+ */
+type TMarkdownBaseCtor = new (markdownName: MarkdownName) => TMarkdownBase;
+/**
+ * JSONL-based markdown adapter with append-only writes.
+ *
+ * Features:
+ * - Writes markdown reports as JSONL entries to a single file per markdown type
+ * - Stream-based writes with backpressure handling
+ * - 15-second timeout protection for write operations
+ * - Automatic directory creation
+ * - Error handling via exitEmitter
+ * - Search metadata for filtering (symbol, strategy, exchange, frame, signalId)
+ *
+ * File format: ./dump/markdown/{markdownName}.jsonl
+ * Each line contains: markdownName, data, symbol, strategyName, exchangeName, frameName, signalId, timestamp
+ *
+ * Use this adapter for centralized logging and post-processing with JSONL tools.
+ */
+declare class MarkdownFileBase implements TMarkdownBase {
+    readonly markdownName: MarkdownName;
+    /** Absolute path to the JSONL file for this markdown type */
+    _filePath: string;
+    /** WriteStream instance for append-only writes, null until initialized */
+    _stream: WriteStream | null;
+    /** Base directory for all JSONL markdown files */
+    _baseDir: string;
+    /**
+     * Creates a new JSONL markdown adapter instance.
+     *
+     * @param markdownName - Type of markdown report (backtest, live, walker, etc.)
+     */
+    constructor(markdownName: MarkdownName);
+    /**
+     * Singleshot initialization function that creates directory and stream.
+     * Protected by singleshot to ensure one-time execution.
+     * Sets up error handler that emits to exitEmitter.
+     */
+    [WAIT_FOR_INIT_SYMBOL]: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    /**
+     * Timeout-protected write function with backpressure handling.
+     * Waits for drain event if write buffer is full.
+     * Times out after 15 seconds and returns TIMEOUT_SYMBOL.
+     */
+    [WRITE_SAFE_SYMBOL]: (line: string) => Promise<symbol | void>;
+    /**
+     * Initializes the JSONL file and write stream.
+     * Safe to call multiple times - singleshot ensures one-time execution.
+     *
+     * @returns Promise that resolves when initialization is complete
+     */
+    waitForInit(): Promise<void>;
+    /**
+     * Writes markdown content to JSONL file with metadata.
+     * Appends a single line with JSON object containing:
+     * - markdownName: Type of report
+     * - data: Markdown content
+     * - Search flags: symbol, strategyName, exchangeName, frameName, signalId
+     * - timestamp: Current timestamp in milliseconds
+     *
+     * @param data - Markdown content to write
+     * @param options - Path and metadata options
+     * @throws Error if stream not initialized or write timeout exceeded
+     */
+    dump(data: string, options: IMarkdownDumpOptions): Promise<void>;
+}
+/**
+ * Folder-based markdown adapter with separate files per report.
+ *
+ * Features:
+ * - Writes each markdown report as a separate .md file
+ * - File path based on options.path and options.file
+ * - Automatic directory creation
+ * - No stream management (direct writeFile)
+ * - Suitable for human-readable report directories
+ *
+ * File format: {options.path}/{options.file}
+ * Example: ./dump/backtest/BTCUSDT_my-strategy_binance_2024-Q1_backtest-1736601234567.md
+ *
+ * Use this adapter (default) for organized report directories and manual review.
+ */
+declare class MarkdownFolderBase implements TMarkdownBase {
+    readonly markdownName: MarkdownName;
+    /**
+     * Creates a new folder-based markdown adapter instance.
+     *
+     * @param markdownName - Type of markdown report (backtest, live, walker, etc.)
+     */
+    constructor(markdownName: MarkdownName);
+    /**
+     * No-op initialization for folder adapter.
+     * This adapter doesn't need initialization since it uses direct writeFile.
+     *
+     * @returns Promise that resolves immediately
+     */
+    waitForInit(): Promise<void>;
+    /**
+     * Writes markdown content to a separate file.
+     * Creates directory structure automatically.
+     * File path is determined by options.path and options.file.
+     *
+     * @param content - Markdown content to write
+     * @param options - Path and file options for the dump
+     * @throws Error if directory creation or file write fails
+     */
+    dump(content: string, options: IMarkdownDumpOptions): Promise<void>;
+}
+/**
+ * Configuration interface for selective report service enablement.
+ * Controls which report services should be activated for JSONL event logging.
+ */
+interface IReportTarget {
+    /** Enable strategy commit actions */
+    strategy: boolean;
+    /** Enable risk rejection event logging */
+    risk: boolean;
+    /** Enable breakeven event logging */
+    breakeven: boolean;
+    /** Enable partial close event logging */
+    partial: boolean;
+    /** Enable heatmap data event logging */
+    heat: boolean;
+    /** Enable walker iteration event logging */
+    walker: boolean;
+    /** Enable performance metrics event logging */
+    performance: boolean;
+    /** Enable scheduled signal event logging */
+    schedule: boolean;
+    /** Enable live trading event logging (all tick states) */
+    live: boolean;
+    /** Enable backtest closed signal event logging */
+    backtest: boolean;
+    /** Enable signal synchronization event logging (signal-open, signal-close) */
+    sync: boolean;
+    /** Enable highest profit milestone event logging */
+    highest_profit: boolean;
+    /** Enable max drawdown milestone event logging */
+    max_drawdown: boolean;
+}
+/**
+ * Union type of all valid report names.
+ * Used for type-safe identification of report services.
+ */
 type ReportName = keyof IReportTarget;
 /**
  * Options for report data writes.
@@ -11969,13 +12507,13 @@ declare class ReportBase implements TReportBase {
      * Protected by singleshot to ensure one-time execution.
      * Sets up error handler that emits to exitEmitter.
      */
-    [WAIT_FOR_INIT_SYMBOL$1]: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    [WAIT_FOR_INIT_SYMBOL]: (() => Promise<void>) & functools_kit.ISingleshotClearable;
     /**
      * Timeout-protected write function with backpressure handling.
      * Waits for drain event if write buffer is full.
      * Times out after 15 seconds and returns TIMEOUT_SYMBOL.
      */
-    [WRITE_SAFE_SYMBOL$1]: (line: string) => Promise<symbol | void>;
+    [WRITE_SAFE_SYMBOL]: (line: string) => Promise<symbol | void>;
     /**
      * Initializes the JSONL file and write stream.
      * Safe to call multiple times - singleshot ensures one-time execution.
@@ -11998,6 +12536,7 @@ declare class ReportBase implements TReportBase {
      */
     write<T = any>(data: T, options: IReportDumpOptions): Promise<void>;
 }
+
 /**
  * Utility class for managing report services.
  *
@@ -12033,7 +12572,7 @@ declare class ReportUtils {
      *
      * @returns Cleanup function that unsubscribes from all enabled services
      */
-    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, }?: Partial<IReportTarget>) => (...args: any[]) => any;
+    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, max_drawdown, }?: Partial<IReportTarget>) => (...args: any[]) => any;
     /**
      * Disables report services selectively.
      *
@@ -12070,7 +12609,7 @@ declare class ReportUtils {
      * Report.disable();
      * ```
      */
-    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, }?: Partial<IReportTarget>) => void;
+    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, max_drawdown, }?: Partial<IReportTarget>) => void;
 }
 /**
  * Report adapter with pluggable storage backend and instance memoization.
@@ -12085,19 +12624,6 @@ declare class ReportUtils {
  * Used for structured event logging and analytics pipelines.
  */
 declare class ReportAdapter extends ReportUtils {
-    /**
-     * Current report storage adapter constructor.
-     * Defaults to ReportBase for JSONL storage.
-     * Can be changed via useReportAdapter().
-     */
-    private ReportFactory;
-    /**
-     * Memoized storage instances cache.
-     * Key: reportName (backtest, live, walker, etc.)
-     * Value: TReportBase instance created with current ReportFactory.
-     * Ensures single instance per report type for the lifetime of the application.
-     */
-    private getReportStorage;
     /**
      * Sets the report storage adapter constructor.
      * All future report instances will use this adapter.
@@ -12105,19 +12631,6 @@ declare class ReportAdapter extends ReportUtils {
      * @param Ctor - Constructor for report storage adapter
      */
     useReportAdapter(Ctor: TReportBaseCtor): void;
-    /**
-     * Writes report data to storage using the configured adapter.
-     * Automatically initializes storage on first write for each report type.
-     *
-     * @param reportName - Type of report (backtest, live, walker, etc.)
-     * @param data - Event data object to write
-     * @param options - Metadata options for filtering and search
-     * @returns Promise that resolves when write is complete
-     * @throws Error if write fails or storage initialization fails
-     *
-     * @internal - Automatically called by report services, not for direct use
-     */
-    writeData: <T = any>(reportName: ReportName, data: T, options: IReportDumpOptions) => Promise<void>;
     /**
      * Clears the memoized storage cache.
      * Call this when process.cwd() changes between strategy iterations
@@ -12141,197 +12654,6 @@ declare class ReportAdapter extends ReportUtils {
  */
 declare const Report: ReportAdapter;
 
-/**
- * Configuration interface for selective markdown service enablement.
- * Controls which markdown report services should be activated.
- */
-interface IMarkdownTarget {
-    /** Enable strategy event tracking reports (entry/exit signals) */
-    strategy: boolean;
-    /** Enable risk rejection tracking reports (signals blocked by risk limits) */
-    risk: boolean;
-    /** Enable breakeven event tracking reports (when stop loss moves to entry) */
-    breakeven: boolean;
-    /** Enable partial profit/loss event tracking reports */
-    partial: boolean;
-    /** Enable portfolio heatmap analysis reports across all symbols */
-    heat: boolean;
-    /** Enable walker strategy comparison and optimization reports */
-    walker: boolean;
-    /** Enable performance metrics and bottleneck analysis reports */
-    performance: boolean;
-    /** Enable scheduled signal tracking reports (signals waiting for trigger) */
-    schedule: boolean;
-    /** Enable live trading event reports (all tick events) */
-    live: boolean;
-    /** Enable backtest markdown reports (main strategy results with full trade history) */
-    backtest: boolean;
-    /** Enable signal sync lifecycle reports (signal-open and signal-close events) */
-    sync: boolean;
-    /** Enable highest profit milestone tracking reports */
-    highest_profit: boolean;
-}
-/** Symbol key for the singleshot waitForInit function on MarkdownFileBase instances. */
-declare const WAIT_FOR_INIT_SYMBOL: unique symbol;
-/** Symbol key for the timeout-protected write function on MarkdownFileBase instances. */
-declare const WRITE_SAFE_SYMBOL: unique symbol;
-/**
- * Union type of all valid markdown report names.
- * Used for type-safe identification of markdown services.
- */
-type MarkdownName = keyof IMarkdownTarget;
-/**
- * Options for markdown dump operations.
- * Contains path information and metadata for filtering.
- */
-interface IMarkdownDumpOptions {
-    /** Directory path relative to process.cwd() */
-    path: string;
-    /** File name including extension */
-    file: string;
-    /** Trading pair symbol (e.g., "BTCUSDT") */
-    symbol: string;
-    /** Strategy name */
-    strategyName: string;
-    /** Exchange name */
-    exchangeName: string;
-    /** Frame name (timeframe identifier) */
-    frameName: string;
-    /** Signal unique identifier */
-    signalId: string;
-}
-/**
- * Base interface for markdown storage adapters.
- * All markdown adapters must implement this interface.
- */
-type TMarkdownBase = {
-    /**
-     * Initialize markdown storage and prepare for writes.
-     * Uses singleshot to ensure one-time execution.
-     *
-     * @param initial - Whether this is the first initialization
-     * @returns Promise that resolves when initialization is complete
-     */
-    waitForInit(initial: boolean): Promise<void>;
-    /**
-     * Dump markdown content to storage.
-     *
-     * @param content - Markdown content to write
-     * @param options - Metadata and path options for the dump
-     * @returns Promise that resolves when write is complete
-     * @throws Error if write fails or stream is not initialized
-     */
-    dump(content: string, options: IMarkdownDumpOptions): Promise<void>;
-};
-/**
- * Constructor type for markdown storage adapters.
- * Used for custom markdown storage implementations.
- */
-type TMarkdownBaseCtor = new (markdownName: MarkdownName) => TMarkdownBase;
-/**
- * JSONL-based markdown adapter with append-only writes.
- *
- * Features:
- * - Writes markdown reports as JSONL entries to a single file per markdown type
- * - Stream-based writes with backpressure handling
- * - 15-second timeout protection for write operations
- * - Automatic directory creation
- * - Error handling via exitEmitter
- * - Search metadata for filtering (symbol, strategy, exchange, frame, signalId)
- *
- * File format: ./dump/markdown/{markdownName}.jsonl
- * Each line contains: markdownName, data, symbol, strategyName, exchangeName, frameName, signalId, timestamp
- *
- * Use this adapter for centralized logging and post-processing with JSONL tools.
- */
-declare class MarkdownFileBase implements TMarkdownBase {
-    readonly markdownName: MarkdownName;
-    /** Absolute path to the JSONL file for this markdown type */
-    _filePath: string;
-    /** WriteStream instance for append-only writes, null until initialized */
-    _stream: WriteStream | null;
-    /** Base directory for all JSONL markdown files */
-    _baseDir: string;
-    /**
-     * Creates a new JSONL markdown adapter instance.
-     *
-     * @param markdownName - Type of markdown report (backtest, live, walker, etc.)
-     */
-    constructor(markdownName: MarkdownName);
-    /**
-     * Singleshot initialization function that creates directory and stream.
-     * Protected by singleshot to ensure one-time execution.
-     * Sets up error handler that emits to exitEmitter.
-     */
-    [WAIT_FOR_INIT_SYMBOL]: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-    /**
-     * Timeout-protected write function with backpressure handling.
-     * Waits for drain event if write buffer is full.
-     * Times out after 15 seconds and returns TIMEOUT_SYMBOL.
-     */
-    [WRITE_SAFE_SYMBOL]: (line: string) => Promise<symbol | void>;
-    /**
-     * Initializes the JSONL file and write stream.
-     * Safe to call multiple times - singleshot ensures one-time execution.
-     *
-     * @returns Promise that resolves when initialization is complete
-     */
-    waitForInit(): Promise<void>;
-    /**
-     * Writes markdown content to JSONL file with metadata.
-     * Appends a single line with JSON object containing:
-     * - markdownName: Type of report
-     * - data: Markdown content
-     * - Search flags: symbol, strategyName, exchangeName, frameName, signalId
-     * - timestamp: Current timestamp in milliseconds
-     *
-     * @param data - Markdown content to write
-     * @param options - Path and metadata options
-     * @throws Error if stream not initialized or write timeout exceeded
-     */
-    dump(data: string, options: IMarkdownDumpOptions): Promise<void>;
-}
-/**
- * Folder-based markdown adapter with separate files per report.
- *
- * Features:
- * - Writes each markdown report as a separate .md file
- * - File path based on options.path and options.file
- * - Automatic directory creation
- * - No stream management (direct writeFile)
- * - Suitable for human-readable report directories
- *
- * File format: {options.path}/{options.file}
- * Example: ./dump/backtest/BTCUSDT_my-strategy_binance_2024-Q1_backtest-1736601234567.md
- *
- * Use this adapter (default) for organized report directories and manual review.
- */
-declare class MarkdownFolderBase implements TMarkdownBase {
-    readonly markdownName: MarkdownName;
-    /**
-     * Creates a new folder-based markdown adapter instance.
-     *
-     * @param markdownName - Type of markdown report (backtest, live, walker, etc.)
-     */
-    constructor(markdownName: MarkdownName);
-    /**
-     * No-op initialization for folder adapter.
-     * This adapter doesn't need initialization since it uses direct writeFile.
-     *
-     * @returns Promise that resolves immediately
-     */
-    waitForInit(): Promise<void>;
-    /**
-     * Writes markdown content to a separate file.
-     * Creates directory structure automatically.
-     * File path is determined by options.path and options.file.
-     *
-     * @param content - Markdown content to write
-     * @param options - Path and file options for the dump
-     * @throws Error if directory creation or file write fails
-     */
-    dump(content: string, options: IMarkdownDumpOptions): Promise<void>;
-}
 /**
  * Utility class for managing markdown report services.
  *
@@ -12367,7 +12689,7 @@ declare class MarkdownUtils {
      *
      * @returns Cleanup function that unsubscribes from all enabled services
      */
-    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, strategy, risk, schedule, walker, sync, highest_profit, }?: Partial<IMarkdownTarget>) => (...args: any[]) => any;
+    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, strategy, risk, schedule, walker, sync, highest_profit, max_drawdown, }?: Partial<IMarkdownTarget>) => (...args: any[]) => any;
     /**
      * Disables markdown report services selectively.
      *
@@ -12405,7 +12727,7 @@ declare class MarkdownUtils {
      * Markdown.disable();
      * ```
      */
-    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, strategy, schedule, walker, sync, highest_profit, }?: Partial<IMarkdownTarget>) => void;
+    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, strategy, schedule, walker, sync, highest_profit, max_drawdown, }?: Partial<IMarkdownTarget>) => void;
 }
 /**
  * Markdown adapter with pluggable storage backend and instance memoization.
@@ -12419,19 +12741,6 @@ declare class MarkdownUtils {
  * - Convenience methods: useMd(), useJsonl()
  */
 declare class MarkdownAdapter extends MarkdownUtils {
-    /**
-     * Current markdown storage adapter constructor.
-     * Defaults to MarkdownFolderBase for separate file storage.
-     * Can be changed via useMarkdownAdapter().
-     */
-    private MarkdownFactory;
-    /**
-     * Memoized storage instances cache.
-     * Key: markdownName (backtest, live, walker, etc.)
-     * Value: TMarkdownBase instance created with current MarkdownFactory.
-     * Ensures single instance per markdown type for the lifetime of the application.
-     */
-    private getMarkdownStorage;
     /**
      * Sets the markdown storage adapter constructor.
      * All future markdown instances will use this adapter.
@@ -12439,19 +12748,6 @@ declare class MarkdownAdapter extends MarkdownUtils {
      * @param Ctor - Constructor for markdown storage adapter
      */
     useMarkdownAdapter(Ctor: TMarkdownBaseCtor): void;
-    /**
-     * Writes markdown data to storage using the configured adapter.
-     * Automatically initializes storage on first write for each markdown type.
-     *
-     * @param markdownName - Type of markdown report (backtest, live, walker, etc.)
-     * @param content - Markdown content to write
-     * @param options - Path, file, and metadata options
-     * @returns Promise that resolves when write is complete
-     * @throws Error if write fails or storage initialization fails
-     *
-     * @internal - Use service-specific dump methods instead (e.g., Backtest.dump)
-     */
-    writeData(markdownName: MarkdownName, content: string, options: IMarkdownDumpOptions): Promise<void>;
     /**
      * Switches to folder-based markdown storage (default).
      * Shorthand for useMarkdownAdapter(MarkdownFolderBase).
@@ -12617,7 +12913,7 @@ declare const Log: LogAdapter;
  * @see ColumnModel for the base interface
  * @see IStrategyTickResultClosed for the signal data structure
  */
-type Columns$a = ColumnModel<IStrategyTickResultClosed>;
+type Columns$b = ColumnModel<IStrategyTickResultClosed>;
 /**
  * Service for generating and saving backtest markdown reports.
  *
@@ -12711,7 +13007,7 @@ declare class BacktestMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$a[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$b[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -12736,7 +13032,7 @@ declare class BacktestMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", true, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$a[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$b[]) => Promise<void>;
     /**
      * Clears accumulated signal data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -13191,87 +13487,178 @@ declare class BacktestUtils {
         frameName: FrameName;
     }) => Promise<number>;
     /**
-     * Returns the best price reached in the profit direction during this position's life.
+     * Returns the best price reached in the profit direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns price or null if no active position
+     */
+    getPositionHighestProfitPrice: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the timestamp when the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns timestamp in milliseconds or null if no active position
+     */
+    getPositionHighestProfitTimestamp: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns PnL percentage or null if no active position
+     */
+    getPositionHighestPnlPercentage: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns PnL cost or null if no active position
+     */
+    getPositionHighestPnlCost: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns whether breakeven was mathematically reachable at the highest profit price.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns true if breakeven was reachable at peak, false otherwise, or null if no active position
+     */
+    getPositionHighestProfitBreakeven: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Measures how long the position has been pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
+     * Grows continuously as price moves away from the peak without setting a new record.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Drawdown duration in minutes, or null if no active position
+     */
+    getPositionDrawdownMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
      *
      * Returns null if no pending signal exists.
      *
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, and frameName
-     * @returns price or null if no active position
+     * @returns Minutes since last profit peak, or null if no active position
      */
-    getPositionHighestProfitPrice: (symbol: string, context: {
+    getPositionHighestProfitMinutes: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number>;
     /**
-     * Returns the timestamp when the best profit price was recorded during this position's life.
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
      *
      * Returns null if no pending signal exists.
      *
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, and frameName
-     * @returns timestamp in milliseconds or null if no active position
+     * @returns Minutes since last drawdown trough, or null if no active position
      */
-    getPositionHighestProfitTimestamp: (symbol: string, context: {
+    getPositionMaxDrawdownMinutes: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number>;
     /**
-     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     * Returns the worst price reached in the loss direction during this position's life.
      *
      * Returns null if no pending signal exists.
      *
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, and frameName
-     * @returns PnL percentage or null if no active position
+     * @returns price or null if no active position
      */
-    getPositionHighestPnlPercentage: (symbol: string, context: {
+    getPositionMaxDrawdownPrice: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number>;
     /**
-     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
      *
      * Returns null if no pending signal exists.
      *
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, and frameName
-     * @returns PnL cost or null if no active position
+     * @returns timestamp in milliseconds or null if no active position
      */
-    getPositionHighestPnlCost: (symbol: string, context: {
+    getPositionMaxDrawdownTimestamp: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number>;
     /**
-     * Returns whether breakeven was mathematically reachable at the highest profit price.
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
      *
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, and frameName
-     * @returns true if breakeven was reachable at peak, false otherwise, or null if no active position
+     * @returns PnL percentage or null if no active position
      */
-    getPositionHighestProfitBreakeven: (symbol: string, context: {
+    getPositionMaxDrawdownPnlPercentage: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<boolean>;
+    }) => Promise<number>;
     /**
-     * Returns the number of minutes elapsed since the highest profit price was recorded.
-     *
-     * Measures how long the position has been pulling back from its peak profit level.
-     * Zero when called at the exact moment the peak was set.
-     * Grows continuously as price moves away from the peak without setting a new record.
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
      *
      * Returns null if no pending signal exists.
      *
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, and frameName
-     * @returns Drawdown duration in minutes, or null if no active position
+     * @returns PnL cost or null if no active position
      */
-    getPositionDrawdownMinutes: (symbol: string, context: {
+    getPositionMaxDrawdownPnlCost: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
@@ -13793,7 +14180,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, columns?: Columns$a[]) => Promise<string>;
+    }, columns?: Columns$b[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -13824,7 +14211,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, path?: string, columns?: Columns$a[]) => Promise<void>;
+    }, path?: string, columns?: Columns$b[]) => Promise<void>;
     /**
      * Lists all active backtest instances with their current status.
      *
@@ -13898,7 +14285,7 @@ declare const Backtest: BacktestUtils;
  * @see ColumnModel for the base interface
  * @see TickEvent for the event data structure
  */
-type Columns$9 = ColumnModel<TickEvent>;
+type Columns$a = ColumnModel<TickEvent>;
 /**
  * Service for generating and saving live trading markdown reports.
  *
@@ -14025,7 +14412,7 @@ declare class LiveMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$9[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$a[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -14050,7 +14437,7 @@ declare class LiveMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$9[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$a[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -14549,6 +14936,91 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Minutes since last profit peak, or null if no active position
+     */
+    getPositionHighestProfitMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Minutes since last drawdown trough, or null if no active position
+     */
+    getPositionMaxDrawdownMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the worst price reached in the loss direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns price or null if no active position
+     */
+    getPositionMaxDrawdownPrice: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns timestamp in milliseconds or null if no active position
+     */
+    getPositionMaxDrawdownTimestamp: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns PnL percentage or null if no active position
+     */
+    getPositionMaxDrawdownPnlPercentage: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns PnL cost or null if no active position
+     */
+    getPositionMaxDrawdownPnlCost: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
     /**
      * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
      * Use this to prevent duplicate DCA entries at the same price area.
@@ -15034,7 +15506,7 @@ declare class LiveUtils {
     getReport: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, columns?: Columns$9[]) => Promise<string>;
+    }, columns?: Columns$a[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -15064,7 +15536,7 @@ declare class LiveUtils {
     dump: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, path?: string, columns?: Columns$9[]) => Promise<void>;
+    }, path?: string, columns?: Columns$a[]) => Promise<void>;
     /**
      * Lists all active live trading instances with their current status.
      *
@@ -15134,7 +15606,7 @@ declare const Live: LiveUtils;
  * @see ColumnModel for the base interface
  * @see ScheduledEvent for the event data structure
  */
-type Columns$8 = ColumnModel<ScheduledEvent>;
+type Columns$9 = ColumnModel<ScheduledEvent>;
 /**
  * Service for generating and saving scheduled signals markdown reports.
  *
@@ -15245,7 +15717,7 @@ declare class ScheduleMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$8[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$9[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -15270,7 +15742,7 @@ declare class ScheduleMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$9[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -15360,7 +15832,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$8[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$9[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -15382,7 +15854,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$9[]) => Promise<void>;
 }
 /**
  * Singleton instance of ScheduleUtils for convenient scheduled signals reporting.
@@ -15428,7 +15900,7 @@ declare const Schedule: ScheduleUtils;
  * @see ColumnModel for the base interface
  * @see MetricStats for the metric data structure
  */
-type Columns$7 = ColumnModel<MetricStats>;
+type Columns$8 = ColumnModel<MetricStats>;
 /**
  * Service for collecting and analyzing performance metrics.
  *
@@ -15535,7 +16007,7 @@ declare class PerformanceMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$7[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$8[]) => Promise<string>;
     /**
      * Saves performance report to disk.
      *
@@ -15556,7 +16028,7 @@ declare class PerformanceMarkdownService {
      * await performanceService.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
     /**
      * Clears accumulated performance data from storage.
      *
@@ -15664,7 +16136,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$7[]): Promise<string>;
+    }, backtest?: boolean, columns?: Columns$8[]): Promise<string>;
     /**
      * Saves performance report to disk.
      *
@@ -15689,7 +16161,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$7[]): Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$8[]): Promise<void>;
 }
 
 /**
@@ -16120,7 +16592,7 @@ declare const Walker: WalkerUtils;
  * @see ColumnModel for the base interface
  * @see IHeatmapRow for the row data structure
  */
-type Columns$6 = ColumnModel<IHeatmapRow>;
+type Columns$7 = ColumnModel<IHeatmapRow>;
 /**
  * Portfolio Heatmap Markdown Service.
  *
@@ -16255,7 +16727,7 @@ declare class HeatMarkdownService {
      * // | ETHUSDT | +12.3%  | 1.85   | -3.1%  | 38     |
      * ```
      */
-    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
+    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$7[]) => Promise<string>;
     /**
      * Generates the heatmap report and writes it to disk.
      *
@@ -16283,7 +16755,7 @@ declare class HeatMarkdownService {
      * await service.dump("my-strategy", "binance", "frame1", true, "./reports");
      * ```
      */
-    dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
+    dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
     /**
      * Evicts memoized `HeatmapStorage` instances, releasing all accumulated signal data.
      *
@@ -16419,7 +16891,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$6[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$7[]) => Promise<string>;
     /**
      * Saves heatmap report to disk for a strategy.
      *
@@ -16452,7 +16924,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
 }
 /**
  * Singleton instance of HeatUtils for convenient heatmap operations.
@@ -16606,7 +17078,7 @@ declare const PositionSize: typeof PositionSizeUtils;
  * @see ColumnModel for the base interface
  * @see PartialEvent for the event data structure
  */
-type Columns$5 = ColumnModel<PartialEvent>;
+type Columns$6 = ColumnModel<PartialEvent>;
 /**
  * Service for generating and saving partial profit/loss markdown reports.
  *
@@ -16728,7 +17200,7 @@ declare class PartialMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$5[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -16753,7 +17225,7 @@ declare class PartialMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -16889,7 +17361,7 @@ declare class PartialUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$5[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Generates and saves markdown report to file.
      *
@@ -16926,7 +17398,7 @@ declare class PartialUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
 }
 /**
  * Global singleton instance of PartialUtils.
@@ -16947,7 +17419,7 @@ declare const Partial$1: PartialUtils;
 /**
  * Type alias for column configuration used in highest profit markdown reports.
  */
-type Columns$4 = ColumnModel<HighestProfitEvent>;
+type Columns$5 = ColumnModel<HighestProfitEvent>;
 /**
  * Service for generating and saving highest profit markdown reports.
  *
@@ -17040,7 +17512,7 @@ declare class HighestProfitMarkdownService {
      * @returns Promise resolving to the full markdown string
      * @throws {Error} If `subscribe()` has not been called before this method
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$4[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$5[]) => Promise<string>;
     /**
      * Generates the highest profit report and writes it to disk.
      *
@@ -17058,7 +17530,7 @@ declare class HighestProfitMarkdownService {
      *   defaults to `COLUMN_CONFIG.highest_profit_columns`
      * @throws {Error} If `subscribe()` has not been called before this method
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
     /**
      * Evicts memoized `ReportStorage` instances, releasing all accumulated event data.
      *
@@ -17132,7 +17604,7 @@ declare class HighestProfitUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$4[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$5[]) => Promise<string>;
     /**
      * Generates and saves a markdown report to file.
      *
@@ -17146,13 +17618,135 @@ declare class HighestProfitUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
 }
 /**
  * Global singleton instance of HighestProfitUtils.
  */
 declare const HighestProfit: HighestProfitUtils;
 
+/**
+ * Type alias for column configuration used in max drawdown markdown reports.
+ */
+type Columns$4 = ColumnModel<MaxDrawdownEvent>;
+/**
+ * Service for generating and saving max drawdown markdown reports.
+ *
+ * Listens to maxDrawdownSubject and accumulates events per
+ * symbol-strategy-exchange-frame combination. Provides getData(),
+ * getReport(), and dump() methods matching the HighestProfit pattern.
+ */
+declare class MaxDrawdownMarkdownService {
+    private readonly loggerService;
+    private getStorage;
+    /**
+     * Subscribes to `maxDrawdownSubject` to start receiving `MaxDrawdownContract`
+     * events. Protected against multiple subscriptions via `singleshot`.
+     *
+     * @returns Unsubscribe function; calling it tears down the subscription and
+     *   clears all accumulated data
+     */
+    subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Detaches from `maxDrawdownSubject` and clears all accumulated data.
+     *
+     * If `subscribe()` was never called, does nothing.
+     */
+    unsubscribe: () => Promise<void>;
+    /**
+     * Handles a single `MaxDrawdownContract` event emitted by `maxDrawdownSubject`.
+     */
+    private tick;
+    /**
+     * Returns accumulated max drawdown statistics for the given context.
+     */
+    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<MaxDrawdownStatisticsModel>;
+    /**
+     * Generates a markdown max drawdown report for the given context.
+     */
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$4[]) => Promise<string>;
+    /**
+     * Generates the max drawdown report and writes it to disk.
+     */
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
+    /**
+     * Evicts memoized `ReportStorage` instances, releasing all accumulated event data.
+     *
+     * - With `payload` — clears only the storage bucket for that combination.
+     * - Without `payload` — clears **all** storage buckets.
+     */
+    clear: (payload?: {
+        symbol: string;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+        backtest: boolean;
+    }) => Promise<void>;
+}
+
+/**
+ * Utility class for accessing max drawdown reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by MaxDrawdownMarkdownService from maxDrawdownSubject events.
+ *
+ * @example
+ * ```typescript
+ * import { MaxDrawdown } from "backtest-kit";
+ *
+ * const stats = await MaxDrawdown.getData("BTCUSDT", { strategyName, exchangeName, frameName });
+ * const report = await MaxDrawdown.getReport("BTCUSDT", { strategyName, exchangeName, frameName });
+ * await MaxDrawdown.dump("BTCUSDT", { strategyName, exchangeName, frameName });
+ * ```
+ */
+declare class MaxDrawdownUtils {
+    /**
+     * Retrieves statistical data from accumulated max drawdown events.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @returns Promise resolving to MaxDrawdownStatisticsModel
+     */
+    getData: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean) => Promise<MaxDrawdownStatisticsModel>;
+    /**
+     * Generates a markdown report with all max drawdown events for a symbol-strategy pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @param columns - Optional column configuration
+     * @returns Promise resolving to markdown formatted report string
+     */
+    getReport: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, columns?: Columns$4[]) => Promise<string>;
+    /**
+     * Generates and saves a markdown report to file.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @param path - Output directory path (default: "./dump/max_drawdown")
+     * @param columns - Optional column configuration
+     */
+    dump: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
+}
+/**
+ * Global singleton instance of MaxDrawdownUtils.
+ */
+declare const MaxDrawdown: MaxDrawdownUtils;
+
 /**
  * Utility class containing predefined trading constants for take-profit and stop-loss levels.
  *
@@ -17692,7 +18286,7 @@ type Columns$2 = ColumnModel<SyncEvent>;
  * ```typescript
  * import { Markdown } from "backtest-kit";
  *
- * const unsubscribe = Markdown.enable({ sync: true });
+ * const unsubscribe = MarkdownWriter.enable({ sync: true });
  * // ... later
  * unsubscribe();
  * ```
@@ -19644,67 +20238,6 @@ declare class BreakevenUtils {
  */
 declare const Breakeven: BreakevenUtils;
 
-/**
- * Logger service with automatic context injection.
- *
- * Features:
- * - Delegates to user-provided logger via setLogger()
- * - Automatically appends method context (strategyName, exchangeName, frameName)
- * - Automatically appends execution context (symbol, when, backtest)
- * - Defaults to NOOP_LOGGER if no logger configured
- *
- * Used throughout the framework for consistent logging with context.
- */
-declare class LoggerService implements ILogger {
-    private readonly methodContextService;
-    private readonly executionContextService;
-    private _commonLogger;
-    /**
-     * Gets current method context if available.
-     * Contains strategyName, exchangeName, frameName from MethodContextService.
-     */
-    private get methodContext();
-    /**
-     * Gets current execution context if available.
-     * Contains symbol, when, backtest from ExecutionContextService.
-     */
-    private get executionContext();
-    /**
-     * Logs general-purpose message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    log: (topic: string, ...args: any[]) => Promise<void>;
-    /**
-     * Logs debug-level message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    debug: (topic: string, ...args: any[]) => Promise<void>;
-    /**
-     * Logs info-level message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    info: (topic: string, ...args: any[]) => Promise<void>;
-    /**
-     * Logs warning-level message with automatic context injection.
-     *
-     * @param topic - Log topic/category
-     * @param args - Additional log arguments
-     */
-    warn: (topic: string, ...args: any[]) => Promise<void>;
-    /**
-     * Sets custom logger implementation.
-     *
-     * @param logger - Custom logger implementing ILogger interface
-     */
-    setLogger: (logger: ILogger) => void;
-}
-
 /**
  * Type alias for column configuration used in strategy markdown reports.
  *
@@ -19759,7 +20292,22 @@ type Columns = ColumnModel<StrategyEvent>;
  * @see Strategy for the high-level utility class that wraps this service
  */
 declare class StrategyMarkdownService {
-    readonly loggerService: LoggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     /**
      * Memoized factory for ReportStorage instances.
      *
@@ -19995,7 +20543,7 @@ declare class StrategyMarkdownService {
      * Generates and saves a markdown report to disk.
      *
      * Creates the output directory if it doesn't exist and writes
-     * the report with a timestamped filename via Markdown.writeData().
+     * the report with a timestamped filename via MarkdownWriter.writeData().
      *
      * Filename format: `{symbol}_{strategyName}_{exchangeName}[_{frameName}_backtest|_live]-{timestamp}.md`
      *
@@ -20127,294 +20675,93 @@ declare class StrategyUtils {
      * - Timestamp (ISO 8601)
      * - Mode (Backtest/Live)
      *
-     * Also includes summary statistics at the end with counts by action type.
-     *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Strategy context with strategyName, exchangeName, frameName
-     * @param backtest - Whether to get backtest data (default: false)
-     * @param columns - Optional columns configuration for the report
-     * @returns Promise resolving to markdown formatted report string
-     *
-     * @example
-     * ```typescript
-     * const markdown = await Strategy.getReport("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
-     * console.log(markdown);
-     *
-     * // Output:
-     * // # Strategy Report: BTCUSDT:my-strategy
-     * //
-     * // | Symbol | Strategy | Signal ID | Action | Price | ... |
-     * // | --- | --- | --- | --- | --- | ... |
-     * // | BTCUSDT | my-strategy | abc123 | partial-profit | 50100.00000000 USD | ... |
-     * //
-     * // **Total events:** 5
-     * // - Cancel scheduled: 0
-     * // - Close pending: 1
-     * // - Partial profit: 2
-     * // ...
-     * ```
-     */
-    getReport: (symbol: string, context: {
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns[]) => Promise<string>;
-    /**
-     * Generates and saves markdown report to file.
-     *
-     * Creates directory if it doesn't exist.
-     * Filename format: {symbol}_{strategyName}_{exchangeName}_{frameName|live}-{timestamp}.md
-     *
-     * Delegates to StrategyMarkdownService.dump() which:
-     * 1. Generates markdown report via getReport()
-     * 2. Creates output directory (recursive mkdir)
-     * 3. Writes file with UTF-8 encoding
-     * 4. Logs success/failure to console
-     *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Strategy context with strategyName, exchangeName, frameName
-     * @param backtest - Whether to dump backtest data (default: false)
-     * @param path - Output directory path (default: "./dump/strategy")
-     * @param columns - Optional columns configuration for the report
-     * @returns Promise that resolves when file is written
-     *
-     * @example
-     * ```typescript
-     * // Save to default path: ./dump/strategy/BTCUSDT_my-strategy_binance_1h_backtest-{timestamp}.md
-     * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true);
-     *
-     * // Save to custom path
-     * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true, "./reports/strategy");
-     *
-     * // After multiple symbols backtested, export all reports
-     * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
-     *   await Strategy.dump(symbol, { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true, "./backtest-results");
-     * }
-     * ```
-     */
-    dump: (symbol: string, context: {
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns[]) => Promise<void>;
-}
-/**
- * Global singleton instance of StrategyUtils.
- * Provides static-like access to strategy management reporting methods.
- *
- * @example
- * ```typescript
- * import { Strategy } from "backtest-kit";
- *
- * // Usage same as StrategyUtils methods
- * const stats = await Strategy.getData("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
- * const report = await Strategy.getReport("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
- * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
- * ```
- */
-declare const Strategy: StrategyUtils;
-
-/**
- * Proxy wrapper for user-defined action handlers with automatic error capture.
- *
- * Wraps all IPublicAction methods with trycatch to prevent user code errors from crashing the system.
- * All errors are logged, sent to errorEmitter, and returned as null (non-breaking).
- *
- * Key features:
- * - Automatic error catching and logging for all action methods
- * - Safe execution of partial user implementations (missing methods return null)
- * - Consistent error capture across all action lifecycle events
- * - Non-breaking failure mode (errors logged but execution continues)
- *
- * Architecture:
- * - Private constructor enforces factory pattern via fromInstance()
- * - Each method checks if target implements the method before calling
- * - Errors caught with fallback handler (warn log + errorEmitter)
- * - Returns null on error to prevent undefined behavior
- *
- * Used by:
- * - ClientAction to wrap user-provided action handlers
- * - ActionCoreService to safely invoke action callbacks
- *
- * @example
- * ```typescript
- * // Create proxy from user implementation
- * const userAction = {
- *   signal: async (event) => {
- *     // User code that might throw
- *     throw new Error('User error');
- *   }
- * };
- *
- * const proxy = ActionProxy.fromInstance(userAction);
- *
- * // Error is caught and logged, execution continues
- * await proxy.signal(event); // Logs error, returns null
- * await proxy.dispose(); // Safe call even though not implemented
- * ```
- *
- * @example
- * ```typescript
- * // Partial implementation is safe
- * const partialAction = {
- *   init: async () => console.log('Initialized'),
- *   // Other methods not implemented
- * };
- *
- * const proxy = ActionProxy.fromInstance(partialAction);
- * await proxy.init(); // Works
- * await proxy.signal(event); // Returns null (not implemented)
- * ```
- */
-declare class ActionProxy implements IPublicAction {
-    readonly _target: Partial<IPublicAction>;
-    /**
-     * Creates a new ActionProxy instance.
-     *
-     * @param _target - Partial action implementation to wrap with error capture
-     * @private Use ActionProxy.fromInstance() instead
-     */
-    private constructor();
-    /**
-     * Initializes the action handler with error capture.
-     *
-     * Wraps the user's init() method in trycatch to prevent initialization errors from crashing the system.
-     * If the target doesn't implement init(), this method safely returns undefined.
-     *
-     * @returns Promise resolving to user's init() result or undefined if not implemented
-     */
-    init(): Promise<any>;
-    /**
-     * Handles signal events from all modes with error capture.
-     *
-     * Wraps the user's signal() method to catch and log any errors.
-     * Called on every tick/candle when strategy is evaluated.
-     *
-     * @param event - Signal state result with action, state, signal data, and context
-     * @returns Promise resolving to user's signal() result or null on error
-     */
-    signal(event: IStrategyTickResult): Promise<any>;
-    /**
-     * Handles signal events from live trading only with error capture.
-     *
-     * Wraps the user's signalLive() method to catch and log any errors.
-     * Called every tick in live mode.
-     *
-     * @param event - Signal state result from live trading
-     * @returns Promise resolving to user's signalLive() result or null on error
-     */
-    signalLive(event: IStrategyTickResult): Promise<any>;
-    /**
-     * Handles signal events from backtest only with error capture.
-     *
-     * Wraps the user's signalBacktest() method to catch and log any errors.
-     * Called every candle in backtest mode.
-     *
-     * @param event - Signal state result from backtest
-     * @returns Promise resolving to user's signalBacktest() result or null on error
-     */
-    signalBacktest(event: IStrategyTickResult): Promise<any>;
-    /**
-     * Handles breakeven events with error capture.
-     *
-     * Wraps the user's breakevenAvailable() method to catch and log any errors.
-     * Called once per signal when stop-loss is moved to entry price.
-     *
-     * @param event - Breakeven milestone data with signal info, current price, timestamp
-     * @returns Promise resolving to user's breakevenAvailable() result or null on error
-     */
-    breakevenAvailable(event: BreakevenContract): Promise<any>;
-    /**
-     * Handles partial profit level events with error capture.
-     *
-     * Wraps the user's partialProfitAvailable() method to catch and log any errors.
-     * Called once per profit level per signal (10%, 20%, 30%, etc).
-     *
-     * @param event - Profit milestone data with signal info, level, price, timestamp
-     * @returns Promise resolving to user's partialProfitAvailable() result or null on error
-     */
-    partialProfitAvailable(event: PartialProfitContract): Promise<any>;
-    /**
-     * Handles partial loss level events with error capture.
-     *
-     * Wraps the user's partialLossAvailable() method to catch and log any errors.
-     * Called once per loss level per signal (-10%, -20%, -30%, etc).
-     *
-     * @param event - Loss milestone data with signal info, level, price, timestamp
-     * @returns Promise resolving to user's partialLossAvailable() result or null on error
-     */
-    partialLossAvailable(event: PartialLossContract): Promise<any>;
-    /**
-     * Handles scheduled ping events with error capture.
-     *
-     * Wraps the user's pingScheduled() method to catch and log any errors.
-     * Called every minute while a scheduled signal is waiting for activation.
-     *
-     * @param event - Scheduled signal monitoring data with symbol, strategy info, signal data, timestamp
-     * @returns Promise resolving to user's pingScheduled() result or null on error
-     */
-    pingScheduled(event: SchedulePingContract): Promise<any>;
-    /**
-     * Handles active ping events with error capture.
-     *
-     * Wraps the user's pingActive() method to catch and log any errors.
-     * Called every minute while a pending signal is active (position open).
-     *
-     * @param event - Active pending signal monitoring data with symbol, strategy info, signal data, timestamp
-     * @returns Promise resolving to user's pingActive() result or null on error
-     */
-    pingActive(event: ActivePingContract): Promise<any>;
-    /**
-     * Handles risk rejection events with error capture.
-     *
-     * Wraps the user's riskRejection() method to catch and log any errors.
-     * Called only when signal is rejected by risk management validation.
-     *
-     * @param event - Risk rejection data with symbol, pending signal, rejection reason, timestamp
-     * @returns Promise resolving to user's riskRejection() result or null on error
-     */
-    riskRejection(event: RiskContract): Promise<any>;
-    /**
-     * Gate for position open/close via limit order.
-     * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_FN.
-     *
-     * @param event - Sync event with action "signal-open" or "signal-close"
-     */
-    signalSync(event: SignalSyncContract): Promise<void>;
-    /**
-     * Cleans up resources with error capture.
+     * Also includes summary statistics at the end with counts by action type.
      *
-     * Wraps the user's dispose() method to catch and log any errors.
-     * Called once when strategy execution ends.
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @param backtest - Whether to get backtest data (default: false)
+     * @param columns - Optional columns configuration for the report
+     * @returns Promise resolving to markdown formatted report string
      *
-     * @returns Promise resolving to user's dispose() result or null on error
+     * @example
+     * ```typescript
+     * const markdown = await Strategy.getReport("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+     * console.log(markdown);
+     *
+     * // Output:
+     * // # Strategy Report: BTCUSDT:my-strategy
+     * //
+     * // | Symbol | Strategy | Signal ID | Action | Price | ... |
+     * // | --- | --- | --- | --- | --- | ... |
+     * // | BTCUSDT | my-strategy | abc123 | partial-profit | 50100.00000000 USD | ... |
+     * //
+     * // **Total events:** 5
+     * // - Cancel scheduled: 0
+     * // - Close pending: 1
+     * // - Partial profit: 2
+     * // ...
+     * ```
      */
-    dispose(): Promise<any>;
+    getReport: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, columns?: Columns[]) => Promise<string>;
     /**
-     * Creates a new ActionProxy instance wrapping a user-provided action handler.
+     * Generates and saves markdown report to file.
      *
-     * Factory method enforcing the private constructor pattern.
-     * Wraps all methods of the provided instance with error capture.
+     * Creates directory if it doesn't exist.
+     * Filename format: {symbol}_{strategyName}_{exchangeName}_{frameName|live}-{timestamp}.md
      *
-     * @param instance - Partial action implementation to wrap
-     * @returns New ActionProxy instance with error-safe method wrappers
+     * Delegates to StrategyMarkdownService.dump() which:
+     * 1. Generates markdown report via getReport()
+     * 2. Creates output directory (recursive mkdir)
+     * 3. Writes file with UTF-8 encoding
+     * 4. Logs success/failure to console
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Strategy context with strategyName, exchangeName, frameName
+     * @param backtest - Whether to dump backtest data (default: false)
+     * @param path - Output directory path (default: "./dump/strategy")
+     * @param columns - Optional columns configuration for the report
+     * @returns Promise that resolves when file is written
      *
      * @example
      * ```typescript
-     * const userAction = {
-     *   signal: async (event) => {
-     *     console.log('Signal received:', event);
-     *   },
-     *   dispose: async () => {
-     *     console.log('Cleanup complete');
-     *   }
-     * };
+     * // Save to default path: ./dump/strategy/BTCUSDT_my-strategy_binance_1h_backtest-{timestamp}.md
+     * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true);
      *
-     * const proxy = ActionProxy.fromInstance(userAction);
+     * // Save to custom path
+     * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true, "./reports/strategy");
+     *
+     * // After multiple symbols backtested, export all reports
+     * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
+     *   await Strategy.dump(symbol, { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }, true, "./backtest-results");
+     * }
      * ```
      */
-    static fromInstance(instance: Partial<IPublicAction>): ActionProxy;
+    dump: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, path?: string, columns?: Columns[]) => Promise<void>;
 }
+/**
+ * Global singleton instance of StrategyUtils.
+ * Provides static-like access to strategy management reporting methods.
+ *
+ * @example
+ * ```typescript
+ * import { Strategy } from "backtest-kit";
+ *
+ * // Usage same as StrategyUtils methods
+ * const stats = await Strategy.getData("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+ * const report = await Strategy.getReport("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+ * await Strategy.dump("BTCUSDT", { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" });
+ * ```
+ */
+declare const Strategy: StrategyUtils;
+
 /**
  * Base class for custom action handlers.
  *
@@ -20428,7 +20775,7 @@ declare class ActionProxy implements IPublicAction {
  *
  * Key features:
  * - All methods have default implementations (no need to implement unused methods)
- * - Automatic logging of all events via backtest.loggerService
+ * - Automatic logging of all events via LOGGER_SERVICE
  * - Access to strategy context (strategyName, frameName, actionName)
  * - Implements full IPublicAction interface
  *
@@ -21992,6 +22339,12 @@ declare const backtestScheduleOpenSubject: Subject<IStrategyTickResultOpened>;
  * Allows users to track profit milestones and implement custom management logic based on profit levels.
  */
 declare const highestProfitSubject: Subject<HighestProfitContract>;
+/**
+ * Max drawdown emitter for real-time risk tracking.
+ * Emits updates on the maximum drawdown experienced for an open position.
+ * Allows users to track drawdown levels and implement custom risk management logic based on drawdown thresholds.
+ */
+declare const maxDrawdownSubject: Subject<MaxDrawdownContract>;
 
 declare const emitters_activePingSubject: typeof activePingSubject;
 declare const emitters_backtestScheduleOpenSubject: typeof backtestScheduleOpenSubject;
@@ -22002,6 +22355,7 @@ declare const emitters_doneWalkerSubject: typeof doneWalkerSubject;
 declare const emitters_errorEmitter: typeof errorEmitter;
 declare const emitters_exitEmitter: typeof exitEmitter;
 declare const emitters_highestProfitSubject: typeof highestProfitSubject;
+declare const emitters_maxDrawdownSubject: typeof maxDrawdownSubject;
 declare const emitters_partialLossSubject: typeof partialLossSubject;
 declare const emitters_partialProfitSubject: typeof partialProfitSubject;
 declare const emitters_performanceEmitter: typeof performanceEmitter;
@@ -22020,7 +22374,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_activePingSubject as activePingSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_activePingSubject as activePingSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_maxDrawdownSubject as maxDrawdownSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -22645,7 +22999,22 @@ declare class ExchangeConnectionService implements IExchange {
  * Strategies are registered via addStrategy() and retrieved by name.
  */
 declare class StrategySchemaService {
-    readonly loggerService: LoggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     private _registry;
     /**
      * Registers a new strategy schema.
@@ -22771,6 +23140,67 @@ declare class ClientRisk implements IRisk {
     checkSignal: (params: IRiskCheckArgs) => Promise<boolean>;
 }
 
+/**
+ * Service for managing risk schema registry.
+ *
+ * Uses ToolRegistry from functools-kit for type-safe schema storage.
+ * Risk profiles are registered via addRisk() and retrieved by name.
+ */
+declare class RiskSchemaService {
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
+    private _registry;
+    /**
+     * Registers a new risk schema.
+     *
+     * @param key - Unique risk profile name
+     * @param value - Risk schema configuration
+     * @throws Error if risk name already exists
+     */
+    register: (key: RiskName, value: IRiskSchema) => void;
+    /**
+     * Validates risk schema structure for required properties.
+     *
+     * Performs shallow validation to ensure all required properties exist
+     * and have correct types before registration in the registry.
+     *
+     * @param riskSchema - Risk schema to validate
+     * @throws Error if riskName is missing or not a string
+     */
+    private validateShallow;
+    /**
+     * Overrides an existing risk schema with partial updates.
+     *
+     * @param key - Risk name to override
+     * @param value - Partial schema updates
+     * @returns Updated risk schema
+     * @throws Error if risk name doesn't exist
+     */
+    override: (key: RiskName, value: Partial<IRiskSchema>) => IRiskSchema;
+    /**
+     * Retrieves a risk schema by name.
+     *
+     * @param key - Risk name
+     * @returns Risk schema configuration
+     * @throws Error if risk name doesn't exist
+     */
+    get: (key: RiskName) => IRiskSchema;
+}
+
 /**
  * Type definition for action methods.
  * Maps all keys of IAction to any type.
@@ -23057,8 +23487,26 @@ type TRisk$1 = {
  * ```
  */
 declare class RiskConnectionService implements TRisk$1 {
-    private readonly loggerService;
-    private readonly riskSchemaService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
+    readonly riskSchemaService: RiskSchemaService;
+    readonly executionContextService: {
+        readonly context: IExecutionContext;
+    };
     /**
      * Action core service injected from DI container.
      */
@@ -23178,7 +23626,22 @@ declare class PartialConnectionService implements IPartial {
     /**
      * Logger service injected from DI container.
      */
-    private readonly loggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     /**
      * Action core service injected from DI container.
      */
@@ -23279,7 +23742,22 @@ declare class BreakevenConnectionService implements IBreakeven {
     /**
      * Logger service injected from DI container.
      */
-    private readonly loggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     /**
      * Action core service injected from DI container.
      */
@@ -23536,7 +24014,22 @@ type TStrategy$1 = {
  * ```
  */
 declare class StrategyConnectionService implements TStrategy$1 {
-    readonly loggerService: LoggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     readonly executionContextService: {
         readonly context: IExecutionContext;
     };
@@ -23919,139 +24412,243 @@ declare class StrategyConnectionService implements TStrategy$1 {
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to true if there is a waiting scheduled signal, false otherwise
+     * @returns Promise resolving to true if there is a waiting scheduled signal, false otherwise
+     */
+    hasScheduledSignal: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Returns the original estimated duration for the current pending signal.
+     *
+     * Delegates to ClientStrategy.getPositionEstimateMinutes().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to estimated duration in minutes or null
+     */
+    getPositionEstimateMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the remaining time before the position expires, clamped to zero.
+     *
+     * Resolves current timestamp via timeMetaService and delegates to
+     * ClientStrategy.getPositionCountdownMinutes().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to remaining minutes (≥ 0) or null
+     */
+    getPositionCountdownMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the best price reached in the profit direction during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionHighestProfitPrice().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to price or null
+     */
+    getPositionHighestProfitPrice: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the best profit price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionHighestProfitTimestamp().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    getPositionHighestProfitTimestamp: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionHighestPnlPercentage().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL percentage or null
+     */
+    getPositionHighestPnlPercentage: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionHighestPnlCost().
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL cost or null
      */
-    hasScheduledSignal: (backtest: boolean, symbol: string, context: {
+    getPositionHighestPnlCost: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<boolean>;
+    }) => Promise<number | null>;
     /**
-     * Returns the original estimated duration for the current pending signal.
+     * Returns whether breakeven was mathematically reachable at the highest profit price.
      *
-     * Delegates to ClientStrategy.getPositionEstimateMinutes().
+     * Delegates to ClientStrategy.getPositionHighestProfitBreakeven().
      * Returns null if no pending signal exists.
      *
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to estimated duration in minutes or null
+     * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
      */
-    getPositionEstimateMinutes: (backtest: boolean, symbol: string, context: {
+    getPositionHighestProfitBreakeven: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<number | null>;
+    }) => Promise<boolean | null>;
     /**
-     * Returns the remaining time before the position expires, clamped to zero.
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
      *
      * Resolves current timestamp via timeMetaService and delegates to
-     * ClientStrategy.getPositionCountdownMinutes().
+     * ClientStrategy.getPositionDrawdownMinutes().
      * Returns null if no pending signal exists.
      *
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to remaining minutes (≥ 0) or null
+     * @returns Promise resolving to drawdown duration in minutes or null
      */
-    getPositionCountdownMinutes: (backtest: boolean, symbol: string, context: {
+    getPositionDrawdownMinutes: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
     /**
-     * Returns the best price reached in the profit direction during this position's life.
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
      *
-     * Delegates to ClientStrategy.getPositionHighestProfitPrice().
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     *
+     * Resolves current timestamp via timeMetaService and delegates to
+     * ClientStrategy.getPositionHighestProfitMinutes().
      * Returns null if no pending signal exists.
      *
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to price or null
+     * @returns Promise resolving to minutes since last profit peak or null
      */
-    getPositionHighestProfitPrice: (backtest: boolean, symbol: string, context: {
+    getPositionHighestProfitMinutes: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
     /**
-     * Returns the timestamp when the best profit price was recorded during this position's life.
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
      *
-     * Delegates to ClientStrategy.getPositionHighestProfitTimestamp().
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Resolves current timestamp via timeMetaService and delegates to
+     * ClientStrategy.getPositionMaxDrawdownMinutes().
      * Returns null if no pending signal exists.
      *
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to timestamp in milliseconds or null
+     * @returns Promise resolving to minutes since last drawdown trough or null
      */
-    getPositionHighestProfitTimestamp: (backtest: boolean, symbol: string, context: {
+    getPositionMaxDrawdownMinutes: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
     /**
-     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     * Returns the worst price reached in the loss direction during this position's life.
      *
-     * Delegates to ClientStrategy.getPositionHighestPnlPercentage().
+     * Delegates to ClientStrategy.getPositionMaxDrawdownPrice().
      * Returns null if no pending signal exists.
      *
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to PnL percentage or null
+     * @returns Promise resolving to price or null
      */
-    getPositionHighestPnlPercentage: (backtest: boolean, symbol: string, context: {
+    getPositionMaxDrawdownPrice: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
     /**
-     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
      *
-     * Delegates to ClientStrategy.getPositionHighestPnlCost().
+     * Delegates to ClientStrategy.getPositionMaxDrawdownTimestamp().
      * Returns null if no pending signal exists.
      *
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to PnL cost or null
+     * @returns Promise resolving to timestamp in milliseconds or null
      */
-    getPositionHighestPnlCost: (backtest: boolean, symbol: string, context: {
+    getPositionMaxDrawdownTimestamp: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
     /**
-     * Returns whether breakeven was mathematically reachable at the highest profit price.
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
      *
-     * Delegates to ClientStrategy.getPositionHighestProfitBreakeven().
+     * Delegates to ClientStrategy.getPositionMaxDrawdownPnlPercentage().
      * Returns null if no pending signal exists.
      *
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+     * @returns Promise resolving to PnL percentage or null
      */
-    getPositionHighestProfitBreakeven: (backtest: boolean, symbol: string, context: {
+    getPositionMaxDrawdownPnlPercentage: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<boolean | null>;
+    }) => Promise<number | null>;
     /**
-     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
      *
-     * Resolves current timestamp via timeMetaService and delegates to
-     * ClientStrategy.getPositionDrawdownMinutes().
+     * Delegates to ClientStrategy.getPositionMaxDrawdownPnlCost().
      * Returns null if no pending signal exists.
      *
      * @param backtest - Whether running in backtest mode
      * @param symbol - Trading pair symbol
      * @param context - Execution context with strategyName, exchangeName, frameName
-     * @returns Promise resolving to drawdown duration in minutes or null
+     * @returns Promise resolving to PnL cost or null
      */
-    getPositionDrawdownMinutes: (backtest: boolean, symbol: string, context: {
+    getPositionMaxDrawdownPnlCost: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
@@ -24579,16 +25176,219 @@ declare class SizingConnectionService implements TSizing$1 {
     /**
      * Calculates position size based on risk parameters and configured method.
      *
-     * Routes to appropriate ClientSizing instance based on provided context.
-     * Supports multiple sizing methods: fixed-percentage, kelly-criterion, atr-based.
+     * Routes to appropriate ClientSizing instance based on provided context.
+     * Supports multiple sizing methods: fixed-percentage, kelly-criterion, atr-based.
+     *
+     * @param params - Calculation parameters (symbol, balance, prices, method-specific data)
+     * @param context - Execution context with sizing name
+     * @returns Promise resolving to calculated position size
+     */
+    calculate: (params: ISizingCalculateParams, context: {
+        sizingName: SizingName;
+    }) => Promise<number>;
+}
+
+/**
+ * Proxy wrapper for user-defined action handlers with automatic error capture.
+ *
+ * Wraps all IPublicAction methods with trycatch to prevent user code errors from crashing the system.
+ * All errors are logged, sent to errorEmitter, and returned as null (non-breaking).
+ *
+ * Key features:
+ * - Automatic error catching and logging for all action methods
+ * - Safe execution of partial user implementations (missing methods return null)
+ * - Consistent error capture across all action lifecycle events
+ * - Non-breaking failure mode (errors logged but execution continues)
+ *
+ * Architecture:
+ * - Private constructor enforces factory pattern via fromInstance()
+ * - Each method checks if target implements the method before calling
+ * - Errors caught with fallback handler (warn log + errorEmitter)
+ * - Returns null on error to prevent undefined behavior
+ *
+ * Used by:
+ * - ClientAction to wrap user-provided action handlers
+ * - ActionCoreService to safely invoke action callbacks
+ *
+ * @example
+ * ```typescript
+ * // Create proxy from user implementation
+ * const userAction = {
+ *   signal: async (event) => {
+ *     // User code that might throw
+ *     throw new Error('User error');
+ *   }
+ * };
+ *
+ * const proxy = ActionProxy.fromInstance(userAction);
+ *
+ * // Error is caught and logged, execution continues
+ * await proxy.signal(event); // Logs error, returns null
+ * await proxy.dispose(); // Safe call even though not implemented
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Partial implementation is safe
+ * const partialAction = {
+ *   init: async () => console.log('Initialized'),
+ *   // Other methods not implemented
+ * };
+ *
+ * const proxy = ActionProxy.fromInstance(partialAction);
+ * await proxy.init(); // Works
+ * await proxy.signal(event); // Returns null (not implemented)
+ * ```
+ */
+declare class ActionProxy implements IPublicAction {
+    readonly _target: Partial<IPublicAction>;
+    readonly params: IActionParams;
+    /**
+     * Creates a new ActionProxy instance.
+     *
+     * @param _target - Partial action implementation to wrap with error capture
+     * @private Use ActionProxy.fromInstance() instead
+     */
+    private constructor();
+    /**
+     * Initializes the action handler with error capture.
+     *
+     * Wraps the user's init() method in trycatch to prevent initialization errors from crashing the system.
+     * If the target doesn't implement init(), this method safely returns undefined.
+     *
+     * @returns Promise resolving to user's init() result or undefined if not implemented
+     */
+    init(): Promise<any>;
+    /**
+     * Handles signal events from all modes with error capture.
+     *
+     * Wraps the user's signal() method to catch and log any errors.
+     * Called on every tick/candle when strategy is evaluated.
+     *
+     * @param event - Signal state result with action, state, signal data, and context
+     * @returns Promise resolving to user's signal() result or null on error
+     */
+    signal(event: IStrategyTickResult): Promise<any>;
+    /**
+     * Handles signal events from live trading only with error capture.
+     *
+     * Wraps the user's signalLive() method to catch and log any errors.
+     * Called every tick in live mode.
+     *
+     * @param event - Signal state result from live trading
+     * @returns Promise resolving to user's signalLive() result or null on error
+     */
+    signalLive(event: IStrategyTickResult): Promise<any>;
+    /**
+     * Handles signal events from backtest only with error capture.
+     *
+     * Wraps the user's signalBacktest() method to catch and log any errors.
+     * Called every candle in backtest mode.
+     *
+     * @param event - Signal state result from backtest
+     * @returns Promise resolving to user's signalBacktest() result or null on error
+     */
+    signalBacktest(event: IStrategyTickResult): Promise<any>;
+    /**
+     * Handles breakeven events with error capture.
+     *
+     * Wraps the user's breakevenAvailable() method to catch and log any errors.
+     * Called once per signal when stop-loss is moved to entry price.
+     *
+     * @param event - Breakeven milestone data with signal info, current price, timestamp
+     * @returns Promise resolving to user's breakevenAvailable() result or null on error
+     */
+    breakevenAvailable(event: BreakevenContract): Promise<any>;
+    /**
+     * Handles partial profit level events with error capture.
+     *
+     * Wraps the user's partialProfitAvailable() method to catch and log any errors.
+     * Called once per profit level per signal (10%, 20%, 30%, etc).
+     *
+     * @param event - Profit milestone data with signal info, level, price, timestamp
+     * @returns Promise resolving to user's partialProfitAvailable() result or null on error
+     */
+    partialProfitAvailable(event: PartialProfitContract): Promise<any>;
+    /**
+     * Handles partial loss level events with error capture.
+     *
+     * Wraps the user's partialLossAvailable() method to catch and log any errors.
+     * Called once per loss level per signal (-10%, -20%, -30%, etc).
+     *
+     * @param event - Loss milestone data with signal info, level, price, timestamp
+     * @returns Promise resolving to user's partialLossAvailable() result or null on error
+     */
+    partialLossAvailable(event: PartialLossContract): Promise<any>;
+    /**
+     * Handles scheduled ping events with error capture.
+     *
+     * Wraps the user's pingScheduled() method to catch and log any errors.
+     * Called every minute while a scheduled signal is waiting for activation.
+     *
+     * @param event - Scheduled signal monitoring data with symbol, strategy info, signal data, timestamp
+     * @returns Promise resolving to user's pingScheduled() result or null on error
+     */
+    pingScheduled(event: SchedulePingContract): Promise<any>;
+    /**
+     * Handles active ping events with error capture.
+     *
+     * Wraps the user's pingActive() method to catch and log any errors.
+     * Called every minute while a pending signal is active (position open).
+     *
+     * @param event - Active pending signal monitoring data with symbol, strategy info, signal data, timestamp
+     * @returns Promise resolving to user's pingActive() result or null on error
+     */
+    pingActive(event: ActivePingContract): Promise<any>;
+    /**
+     * Handles risk rejection events with error capture.
+     *
+     * Wraps the user's riskRejection() method to catch and log any errors.
+     * Called only when signal is rejected by risk management validation.
+     *
+     * @param event - Risk rejection data with symbol, pending signal, rejection reason, timestamp
+     * @returns Promise resolving to user's riskRejection() result or null on error
+     */
+    riskRejection(event: RiskContract): Promise<any>;
+    /**
+     * Gate for position open/close via limit order.
+     * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_FN.
+     *
+     * @param event - Sync event with action "signal-open" or "signal-close"
+     */
+    signalSync(event: SignalSyncContract): Promise<void>;
+    /**
+     * Cleans up resources with error capture.
+     *
+     * Wraps the user's dispose() method to catch and log any errors.
+     * Called once when strategy execution ends.
+     *
+     * @returns Promise resolving to user's dispose() result or null on error
+     */
+    dispose(): Promise<any>;
+    /**
+     * Creates a new ActionProxy instance wrapping a user-provided action handler.
+     *
+     * Factory method enforcing the private constructor pattern.
+     * Wraps all methods of the provided instance with error capture.
      *
-     * @param params - Calculation parameters (symbol, balance, prices, method-specific data)
-     * @param context - Execution context with sizing name
-     * @returns Promise resolving to calculated position size
+     * @param instance - Partial action implementation to wrap
+     * @returns New ActionProxy instance with error-safe method wrappers
+     *
+     * @example
+     * ```typescript
+     * const userAction = {
+     *   signal: async (event) => {
+     *     console.log('Signal received:', event);
+     *   },
+     *   dispose: async () => {
+     *     console.log('Cleanup complete');
+     *   }
+     * };
+     *
+     * const proxy = ActionProxy.fromInstance(userAction);
+     * ```
      */
-    calculate: (params: ISizingCalculateParams, context: {
-        sizingName: SizingName;
-    }) => Promise<number>;
+    static fromInstance(instance: Partial<IPublicAction>, params: IActionParams): ActionProxy;
 }
 
 /**
@@ -24748,6 +25548,7 @@ type TAction = {
 declare class ActionConnectionService implements TAction {
     private readonly loggerService;
     private readonly actionSchemaService;
+    private readonly strategyCoreService;
     /**
      * Retrieves memoized ClientAction instance for given action name, strategy, exchange, frame and backtest mode.
      *
@@ -25933,6 +26734,96 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     *
+     * Validates strategy existence and delegates to connection service.
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to minutes since last profit peak or null
+     */
+    getPositionHighestProfitMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Validates strategy existence and delegates to connection service.
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to minutes since last drawdown trough or null
+     */
+    getPositionMaxDrawdownMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the worst price reached in the loss direction during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to price or null
+     */
+    getPositionMaxDrawdownPrice: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    getPositionMaxDrawdownTimestamp: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL percentage or null
+     */
+    getPositionMaxDrawdownPnlPercentage: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL cost or null
+     */
+    getPositionMaxDrawdownPnlCost: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
 }
 
 /**
@@ -26081,6 +26972,188 @@ declare class RiskGlobalService implements TRisk {
     }) => Promise<void>;
 }
 
+/**
+ * Private service for backtest orchestration using async generators.
+ *
+ * Flow:
+ * 1. Get timeframes from frame service
+ * 2. Iterate through timeframes calling tick()
+ * 3. When signal opens: fetch candles and call backtest()
+ * 4. Skip timeframes until signal closes
+ * 5. Yield closed result and continue
+ *
+ * Memory efficient: streams results without array accumulation.
+ * Supports early termination via break in consumer.
+ */
+declare class BacktestLogicPrivateService {
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
+    readonly strategyCoreService: StrategyCoreService;
+    readonly exchangeCoreService: ExchangeCoreService;
+    readonly frameCoreService: FrameCoreService;
+    readonly methodContextService: {
+        readonly context: IMethodContext;
+    };
+    readonly actionCoreService: ActionCoreService;
+    /**
+     * Runs backtest for a symbol, streaming closed signals as async generator.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @yields Closed signal results with PNL
+     *
+     * @example
+     * ```typescript
+     * for await (const result of backtestLogic.run("BTCUSDT")) {
+     *   console.log(result.closeReason, result.pnl.pnlPercentage);
+     *   if (result.pnl.pnlPercentage < -10) break; // Early termination
+     * }
+     * ```
+     */
+    run(symbol: string): AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, any>;
+}
+
+/**
+ * Type definition for public BacktestLogic service.
+ * Omits private dependencies from BacktestLogicPrivateService.
+ */
+type IBacktestLogicPrivateService = Omit<BacktestLogicPrivateService, keyof {
+    loggerService: never;
+    strategyCoreService: never;
+    exchangeCoreService: never;
+    frameCoreService: never;
+    actionCoreService: never;
+    methodContextService: never;
+}>;
+/**
+ * Type definition for BacktestLogicPublicService.
+ * Maps all keys of IBacktestLogicPrivateService to any type.
+ */
+type TBacktestLogicPrivateService = {
+    [key in keyof IBacktestLogicPrivateService]: any;
+};
+/**
+ * Public service for backtest orchestration with context management.
+ *
+ * Wraps BacktestLogicPrivateService with MethodContextService to provide
+ * implicit context propagation for strategyName, exchangeName, and frameName.
+ *
+ * This allows getCandles(), getSignal(), and other functions to work without
+ * explicit context parameters.
+ *
+ * @example
+ * ```typescript
+ * const backtestLogicPublicService = inject(TYPES.backtestLogicPublicService);
+ *
+ * for await (const result of backtestLogicPublicService.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ *   frameName: "1d-backtest",
+ * })) {
+ *   if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.profit);
+ *   }
+ * }
+ * ```
+ */
+declare class BacktestLogicPublicService implements TBacktestLogicPrivateService {
+    private readonly loggerService;
+    private readonly backtestLogicPrivateService;
+    /**
+     * Runs backtest for a symbol with context propagation.
+     *
+     * Streams closed signals as async generator. Context is automatically
+     * injected into all framework functions called during iteration.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy, exchange, and frame names
+     * @returns Async generator yielding closed signals with PNL
+     */
+    run: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, any>;
+}
+
+/**
+ * Service for managing walker schema registry.
+ *
+ * Uses ToolRegistry from functools-kit for type-safe schema storage.
+ * Walkers are registered via addWalker() and retrieved by name.
+ */
+declare class WalkerSchemaService {
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
+    private _registry;
+    /**
+     * Registers a new walker schema.
+     *
+     * @param key - Unique walker name
+     * @param value - Walker schema configuration
+     * @throws Error if walker name already exists
+     */
+    register: (key: WalkerName, value: IWalkerSchema) => void;
+    /**
+     * Validates walker schema structure for required properties.
+     *
+     * Performs shallow validation to ensure all required properties exist
+     * and have correct types before registration in the registry.
+     *
+     * @param walkerSchema - Walker schema to validate
+     * @throws Error if walkerName is missing or not a string
+     * @throws Error if exchangeName is missing or not a string
+     * @throws Error if frameName is missing or not a string
+     * @throws Error if strategies is missing or not an array
+     * @throws Error if strategies array is empty
+     */
+    private validateShallow;
+    /**
+     * Overrides an existing walker schema with partial updates.
+     *
+     * @param key - Walker name to override
+     * @param value - Partial schema updates
+     * @returns Updated walker schema
+     * @throws Error if walker name doesn't exist
+     */
+    override: (key: WalkerName, value: Partial<IWalkerSchema>) => IWalkerSchema;
+    /**
+     * Retrieves a walker schema by name.
+     *
+     * @param key - Walker name
+     * @returns Walker schema configuration
+     * @throws Error if walker name doesn't exist
+     */
+    get: (key: WalkerName) => IWalkerSchema;
+}
+
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -26092,10 +27165,25 @@ declare class RiskGlobalService implements TRisk {
  * Uses BacktestLogicPublicService internally for each strategy.
  */
 declare class WalkerLogicPrivateService {
-    private readonly loggerService;
-    private readonly backtestLogicPublicService;
-    private readonly backtestMarkdownService;
-    private readonly walkerSchemaService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
+    readonly backtestLogicPublicService: BacktestLogicPublicService;
+    readonly backtestMarkdownService: BacktestMarkdownService;
+    readonly walkerSchemaService: WalkerSchemaService;
     /**
      * Runs walker comparison for a symbol.
      *
@@ -26232,7 +27320,22 @@ declare class WalkerCommandService implements TWalkerLogicPublicService {
  * Exchanges are registered via addExchange() and retrieved by name.
  */
 declare class ExchangeSchemaService {
-    readonly loggerService: LoggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     private _registry;
     /**
      * Registers a new exchange schema.
@@ -26281,7 +27384,22 @@ declare class ExchangeSchemaService {
  * Frames are registered via addFrame() and retrieved by name.
  */
 declare class FrameSchemaService {
-    readonly loggerService: LoggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     private _registry;
     /**
      * Registers a new frame schema.
@@ -26329,7 +27447,22 @@ declare class FrameSchemaService {
  * Sizing schemas are registered via addSizing() and retrieved by name.
  */
 declare class SizingSchemaService {
-    readonly loggerService: LoggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     private _registry;
     /**
      * Registers a new sizing schema.
@@ -26369,52 +27502,6 @@ declare class SizingSchemaService {
     get(key: SizingName): ISizingSchema;
 }
 
-/**
- * Service for managing risk schema registry.
- *
- * Uses ToolRegistry from functools-kit for type-safe schema storage.
- * Risk profiles are registered via addRisk() and retrieved by name.
- */
-declare class RiskSchemaService {
-    readonly loggerService: LoggerService;
-    private _registry;
-    /**
-     * Registers a new risk schema.
-     *
-     * @param key - Unique risk profile name
-     * @param value - Risk schema configuration
-     * @throws Error if risk name already exists
-     */
-    register: (key: RiskName, value: IRiskSchema) => void;
-    /**
-     * Validates risk schema structure for required properties.
-     *
-     * Performs shallow validation to ensure all required properties exist
-     * and have correct types before registration in the registry.
-     *
-     * @param riskSchema - Risk schema to validate
-     * @throws Error if riskName is missing or not a string
-     */
-    private validateShallow;
-    /**
-     * Overrides an existing risk schema with partial updates.
-     *
-     * @param key - Risk name to override
-     * @param value - Partial schema updates
-     * @returns Updated risk schema
-     * @throws Error if risk name doesn't exist
-     */
-    override: (key: RiskName, value: Partial<IRiskSchema>) => IRiskSchema;
-    /**
-     * Retrieves a risk schema by name.
-     *
-     * @param key - Risk name
-     * @returns Risk schema configuration
-     * @throws Error if risk name doesn't exist
-     */
-    get: (key: RiskName) => IRiskSchema;
-}
-
 /**
  * Service for managing action schema registry.
  *
@@ -26449,7 +27536,22 @@ declare class RiskSchemaService {
  * ```
  */
 declare class ActionSchemaService {
-    readonly loggerService: LoggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     private _registry;
     /**
      * Registers a new action schema.
@@ -26502,95 +27604,6 @@ declare class ActionSchemaService {
     get: (key: ActionName) => IActionSchema;
 }
 
-/**
- * Service for managing walker schema registry.
- *
- * Uses ToolRegistry from functools-kit for type-safe schema storage.
- * Walkers are registered via addWalker() and retrieved by name.
- */
-declare class WalkerSchemaService {
-    readonly loggerService: LoggerService;
-    private _registry;
-    /**
-     * Registers a new walker schema.
-     *
-     * @param key - Unique walker name
-     * @param value - Walker schema configuration
-     * @throws Error if walker name already exists
-     */
-    register: (key: WalkerName, value: IWalkerSchema) => void;
-    /**
-     * Validates walker schema structure for required properties.
-     *
-     * Performs shallow validation to ensure all required properties exist
-     * and have correct types before registration in the registry.
-     *
-     * @param walkerSchema - Walker schema to validate
-     * @throws Error if walkerName is missing or not a string
-     * @throws Error if exchangeName is missing or not a string
-     * @throws Error if frameName is missing or not a string
-     * @throws Error if strategies is missing or not an array
-     * @throws Error if strategies array is empty
-     */
-    private validateShallow;
-    /**
-     * Overrides an existing walker schema with partial updates.
-     *
-     * @param key - Walker name to override
-     * @param value - Partial schema updates
-     * @returns Updated walker schema
-     * @throws Error if walker name doesn't exist
-     */
-    override: (key: WalkerName, value: Partial<IWalkerSchema>) => IWalkerSchema;
-    /**
-     * Retrieves a walker schema by name.
-     *
-     * @param key - Walker name
-     * @returns Walker schema configuration
-     * @throws Error if walker name doesn't exist
-     */
-    get: (key: WalkerName) => IWalkerSchema;
-}
-
-/**
- * Private service for backtest orchestration using async generators.
- *
- * Flow:
- * 1. Get timeframes from frame service
- * 2. Iterate through timeframes calling tick()
- * 3. When signal opens: fetch candles and call backtest()
- * 4. Skip timeframes until signal closes
- * 5. Yield closed result and continue
- *
- * Memory efficient: streams results without array accumulation.
- * Supports early termination via break in consumer.
- */
-declare class BacktestLogicPrivateService {
-    readonly loggerService: LoggerService;
-    readonly strategyCoreService: StrategyCoreService;
-    readonly exchangeCoreService: ExchangeCoreService;
-    readonly frameCoreService: FrameCoreService;
-    readonly methodContextService: {
-        readonly context: IMethodContext;
-    };
-    readonly actionCoreService: ActionCoreService;
-    /**
-     * Runs backtest for a symbol, streaming closed signals as async generator.
-     *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @yields Closed signal results with PNL
-     *
-     * @example
-     * ```typescript
-     * for await (const result of backtestLogic.run("BTCUSDT")) {
-     *   console.log(result.closeReason, result.pnl.pnlPercentage);
-     *   if (result.pnl.pnlPercentage < -10) break; // Early termination
-     * }
-     * ```
-     */
-    run(symbol: string): AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, any>;
-}
-
 /**
  * Private service for live trading orchestration using async generators.
  *
@@ -26636,69 +27649,6 @@ declare class LiveLogicPrivateService {
     run(symbol: string): AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
 }
 
-/**
- * Type definition for public BacktestLogic service.
- * Omits private dependencies from BacktestLogicPrivateService.
- */
-type IBacktestLogicPrivateService = Omit<BacktestLogicPrivateService, keyof {
-    loggerService: never;
-    strategyCoreService: never;
-    exchangeCoreService: never;
-    frameCoreService: never;
-    actionCoreService: never;
-    methodContextService: never;
-}>;
-/**
- * Type definition for BacktestLogicPublicService.
- * Maps all keys of IBacktestLogicPrivateService to any type.
- */
-type TBacktestLogicPrivateService = {
-    [key in keyof IBacktestLogicPrivateService]: any;
-};
-/**
- * Public service for backtest orchestration with context management.
- *
- * Wraps BacktestLogicPrivateService with MethodContextService to provide
- * implicit context propagation for strategyName, exchangeName, and frameName.
- *
- * This allows getCandles(), getSignal(), and other functions to work without
- * explicit context parameters.
- *
- * @example
- * ```typescript
- * const backtestLogicPublicService = inject(TYPES.backtestLogicPublicService);
- *
- * for await (const result of backtestLogicPublicService.run("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- *   frameName: "1d-backtest",
- * })) {
- *   if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.profit);
- *   }
- * }
- * ```
- */
-declare class BacktestLogicPublicService implements TBacktestLogicPrivateService {
-    private readonly loggerService;
-    private readonly backtestLogicPrivateService;
-    /**
-     * Runs backtest for a symbol with context propagation.
-     *
-     * Streams closed signals as async generator. Context is automatically
-     * injected into all framework functions called during iteration.
-     *
-     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param context - Execution context with strategy, exchange, and frame names
-     * @returns Async generator yielding closed signals with PNL
-     */
-    run: (symbol: string, context: {
-        strategyName: StrategyName;
-        exchangeName: ExchangeName;
-        frameName: FrameName;
-    }) => AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, any>;
-}
-
 /**
  * Type definition for public LiveLogic service.
  * Omits private dependencies from LiveLogicPrivateService.
@@ -27582,7 +28532,7 @@ declare class ColumnValidationService {
  * Features:
  * - Listens to backtest signal events via signalBacktestEmitter
  * - Logs all tick event types with full signal details
- * - Stores events in Report.writeData() for persistence
+ * - Stores events in ReportWriter.writeData() for persistence
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -27654,7 +28604,7 @@ declare class BacktestReportService {
  * Features:
  * - Listens to live signal events via signalLiveEmitter
  * - Logs all tick event types with full signal details
- * - Stores events in Report.writeData() for persistence
+ * - Stores events in ReportWriter.writeData() for persistence
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -27727,7 +28677,7 @@ declare class LiveReportService {
  * - Listens to signal events via signalEmitter
  * - Logs scheduled, opened (from scheduled), and cancelled events
  * - Calculates duration between scheduling and execution/cancellation
- * - Stores events in Report.writeData() for schedule tracking
+ * - Stores events in ReportWriter.writeData() for schedule tracking
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -27799,7 +28749,7 @@ declare class ScheduleReportService {
  * Features:
  * - Listens to performance events via performanceEmitter
  * - Logs all timing metrics with duration and metadata
- * - Stores events in Report.writeData() for performance analysis
+ * - Stores events in ReportWriter.writeData() for performance analysis
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -27871,7 +28821,7 @@ declare class PerformanceReportService {
  * - Listens to walker events via walkerEmitter
  * - Logs each strategy test result with metrics and statistics
  * - Tracks best strategy and optimization progress
- * - Stores events in Report.writeData() for optimization analysis
+ * - Stores events in ReportWriter.writeData() for optimization analysis
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -27942,7 +28892,7 @@ declare class WalkerReportService {
  * Features:
  * - Listens to signal events via signalEmitter
  * - Logs only closed signals with PNL data
- * - Stores events in Report.writeData() for heatmap generation
+ * - Stores events in ReportWriter.writeData() for heatmap generation
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -28015,7 +28965,7 @@ declare class HeatReportService {
  * - Listens to partial profit events via partialProfitSubject
  * - Listens to partial loss events via partialLossSubject
  * - Logs all partial exit events with level and price information
- * - Stores events in Report.writeData() for persistence
+ * - Stores events in ReportWriter.writeData() for persistence
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -28094,7 +29044,7 @@ declare class PartialReportService {
  * Features:
  * - Listens to breakeven events via breakevenSubject
  * - Logs all breakeven achievements with full signal details
- * - Stores events in Report.writeData() for persistence
+ * - Stores events in ReportWriter.writeData() for persistence
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -28165,7 +29115,7 @@ declare class BreakevenReportService {
  * Features:
  * - Listens to risk rejection events via riskSubject
  * - Logs all rejected signals with reason and pending signal details
- * - Stores events in Report.writeData() for risk tracking
+ * - Stores events in ReportWriter.writeData() for risk tracking
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -28239,14 +29189,29 @@ declare class RiskReportService {
  *
  * Lifecycle:
  * - Call subscribe() to enable event logging
- * - Events are written via Report.writeData() with "strategy" category
+ * - Events are written via ReportWriter.writeData() with "strategy" category
  * - Call unsubscribe() to disable event logging
  *
  * @see StrategyMarkdownService for in-memory event accumulation and markdown report generation
  * @see Report for the underlying persistence mechanism
  */
 declare class StrategyReportService {
-    readonly loggerService: LoggerService;
+    readonly loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
     /**
      * Logs a cancel-scheduled event when a scheduled signal is cancelled.
      */
@@ -28347,7 +29312,7 @@ declare class StrategyReportService {
  * - Listens to sync events via syncSubject
  * - Logs signal-open events (scheduled limit order filled) with full signal details
  * - Logs signal-close events (position exited) with PNL and close reason
- * - Stores events in Report.writeData() for persistence
+ * - Stores events in ReportWriter.writeData() for persistence
  * - Protected against multiple subscriptions using singleshot
  *
  * @example
@@ -28414,7 +29379,7 @@ declare class SyncReportService {
  * Service for logging highest profit events to the JSONL report database.
  *
  * Listens to highestProfitSubject and writes each new price record to
- * Report.writeData() for persistence and analytics.
+ * ReportWriter.writeData() for persistence and analytics.
  */
 declare class HighestProfitReportService {
     private readonly loggerService;
@@ -28422,7 +29387,7 @@ declare class HighestProfitReportService {
      * Handles a single `HighestProfitContract` event emitted by `highestProfitSubject`.
      *
      * Writes a JSONL record to the `"highest_profit"` report database via
-     * `Report.writeData`, capturing the full signal snapshot at the moment
+     * `ReportWriter.writeData`, capturing the full signal snapshot at the moment
      * the new profit record was set:
      * - `timestamp`, `symbol`, `strategyName`, `exchangeName`, `frameName`, `backtest`
      * - `signalId`, `position`, `currentPrice`
@@ -28472,6 +29437,52 @@ declare class HighestProfitReportService {
     unsubscribe: () => Promise<void>;
 }
 
+/**
+ * Service for logging max drawdown events to the JSONL report database.
+ *
+ * Listens to maxDrawdownSubject and writes each new drawdown record to
+ * ReportWriter.writeData() for persistence and analytics.
+ */
+declare class MaxDrawdownReportService {
+    private readonly loggerService;
+    /**
+     * Handles a single `MaxDrawdownContract` event emitted by `maxDrawdownSubject`.
+     *
+     * Writes a JSONL record to the `"max_drawdown"` report database via
+     * `ReportWriter.writeData`, capturing the full signal snapshot at the moment
+     * the new drawdown record was set:
+     * - `timestamp`, `symbol`, `strategyName`, `exchangeName`, `frameName`, `backtest`
+     * - `signalId`, `position`, `currentPrice`
+     * - `priceOpen`, `priceTakeProfit`, `priceStopLoss` (effective values from the signal)
+     *
+     * `strategyName` and signal-level fields are sourced from `data.signal`
+     * rather than the contract root.
+     *
+     * @param data - `MaxDrawdownContract` payload containing `symbol`,
+     *   `signal`, `currentPrice`, `backtest`, `timestamp`, `exchangeName`,
+     *   `frameName`
+     */
+    private tick;
+    /**
+     * Subscribes to `maxDrawdownSubject` to start persisting drawdown records.
+     * Protected against multiple subscriptions via `singleshot` — subsequent
+     * calls return the same unsubscribe function without re-subscribing.
+     *
+     * The returned unsubscribe function clears the `singleshot` state and
+     * detaches from `maxDrawdownSubject`.
+     *
+     * @returns Unsubscribe function; calling it tears down the subscription
+     */
+    subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Detaches from `maxDrawdownSubject`, stopping further JSONL writes.
+     *
+     * Calls the unsubscribe closure returned by `subscribe()`.
+     * If `subscribe()` was never called, does nothing.
+     */
+    unsubscribe: () => Promise<void>;
+}
+
 declare const backtest: {
     exchangeValidationService: ExchangeValidationService;
     strategyValidationService: StrategyValidationService;
@@ -28494,6 +29505,7 @@ declare const backtest: {
     strategyReportService: StrategyReportService;
     syncReportService: SyncReportService;
     highestProfitReportService: HighestProfitReportService;
+    maxDrawdownReportService: MaxDrawdownReportService;
     backtestMarkdownService: BacktestMarkdownService;
     liveMarkdownService: LiveMarkdownService;
     scheduleMarkdownService: ScheduleMarkdownService;
@@ -28506,6 +29518,7 @@ declare const backtest: {
     strategyMarkdownService: StrategyMarkdownService;
     syncMarkdownService: SyncMarkdownService;
     highestProfitMarkdownService: HighestProfitMarkdownService;
+    maxDrawdownMarkdownService: MaxDrawdownMarkdownService;
     backtestLogicPublicService: BacktestLogicPublicService;
     liveLogicPublicService: LiveLogicPublicService;
     walkerLogicPublicService: WalkerLogicPublicService;
@@ -28521,6 +29534,28 @@ declare const backtest: {
     breakevenGlobalService: BreakevenGlobalService;
     timeMetaService: TimeMetaService;
     priceMetaService: PriceMetaService;
+    contextMetaService: {
+        readonly loggerService: {
+            readonly methodContextService: {
+                readonly context: IMethodContext;
+            };
+            readonly executionContextService: {
+                readonly context: IExecutionContext;
+            };
+            _commonLogger: ILogger;
+            readonly _methodContext: {};
+            readonly _executionContext: {};
+            log: (topic: string, ...args: any[]) => Promise<void>;
+            debug: (topic: string, ...args: any[]) => Promise<void>;
+            info: (topic: string, ...args: any[]) => Promise<void>;
+            warn: (topic: string, ...args: any[]) => Promise<void>;
+            setLogger: (logger: ILogger) => void;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        getContextTimestamp: () => number;
+    };
     exchangeCoreService: ExchangeCoreService;
     strategyCoreService: StrategyCoreService;
     actionCoreService: ActionCoreService;
@@ -28546,7 +29581,22 @@ declare const backtest: {
     methodContextService: {
         readonly context: IMethodContext;
     };
-    loggerService: LoggerService;
+    loggerService: {
+        readonly methodContextService: {
+            readonly context: IMethodContext;
+        };
+        readonly executionContextService: {
+            readonly context: IExecutionContext;
+        };
+        _commonLogger: ILogger;
+        readonly _methodContext: {};
+        readonly _executionContext: {};
+        log: (topic: string, ...args: any[]) => Promise<void>;
+        debug: (topic: string, ...args: any[]) => Promise<void>;
+        info: (topic: string, ...args: any[]) => Promise<void>;
+        warn: (topic: string, ...args: any[]) => Promise<void>;
+        setLogger: (logger: ILogger) => void;
+    };
 };
 
 interface Signal$2 extends ISignalDto {
@@ -28625,4 +29675,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, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, 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, Memory, type MemoryData, type MessageModel, type MessageRole, type MessageToolCall, 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, PersistMemoryAdapter, 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 TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, 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, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, 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, MaxDrawdown, type MaxDrawdownContract, type MaxDrawdownEvent, type MaxDrawdownStatisticsModel, type MeasureData, Memory, type MemoryData, type MessageModel, type MessageRole, type MessageToolCall, 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, PersistMemoryAdapter, 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 TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, 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, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };