backtest-kit 1.5.16 → 1.5.17

package/build/index.mjs

@@ -200,6 +200,7 @@ const markdownServices$1 = {
     heatMarkdownService: Symbol('heatMarkdownService'),
     partialMarkdownService: Symbol('partialMarkdownService'),
     outlineMarkdownService: Symbol('outlineMarkdownService'),
+    riskMarkdownService: Symbol('riskMarkdownService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -440,11 +441,12 @@ const GET_CANDLES_FN = async (dto, since, self) => {
         }
         catch (err) {
             const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
-            self.params.logger.warn(message, {
+            const payload = {
                 error: errorData(err),
                 message: getErrorMessage(err),
-            });
-            console.warn(message);
+            };
+            self.params.logger.warn(message, payload);
+            console.warn(message, payload);
             lastError = err;
             await sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
         }
@@ -1723,6 +1725,12 @@ const partialProfitSubject = new Subject();
  * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
  */
 const partialLossSubject = new Subject();
+/**
+ * Risk rejection emitter for risk management violations.
+ * Emits ONLY when a signal is rejected due to risk validation failure.
+ * Does not emit for allowed signals (prevents spam).
+ */
+const riskSubject = new Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1737,6 +1745,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     progressBacktestEmitter: progressBacktestEmitter,
     progressOptimizerEmitter: progressOptimizerEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
+    riskSubject: riskSubject,
     signalBacktestEmitter: signalBacktestEmitter,
     signalEmitter: signalEmitter,
     signalLiveEmitter: signalLiveEmitter,
@@ -1823,6 +1832,9 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
     if (signal.position === undefined || signal.position === null) {
         errors.push('position is required and must be "long" or "short"');
     }
+    if (signal.position !== "long" && signal.position !== "short") {
+        errors.push(`position must be "long" or "short", got "${signal.position}"`);
+    }
     // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
     if (!isFinite(currentPrice)) {
         errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
@@ -2109,10 +2121,13 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
 }, {
     defaultValue: null,
     fallback: (error) => {
-        backtest$1.loggerService.warn("ClientStrategy exception thrown", {
+        const message = "ClientStrategy exception thrown";
+        const payload = {
             error: errorData(error),
             message: getErrorMessage(error),
-        });
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
         errorEmitter.next(error);
     },
 });
@@ -2803,7 +2818,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards TP
                     const tpDistance = signal.priceTakeProfit - signal.priceOpen;
                     const progressPercent = (currentDistance / tpDistance) * 100;
-                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, self.params.execution.context.when);
+                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
                     if (self.params.callbacks?.onPartialProfit) {
                         self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
                     }
@@ -2812,7 +2827,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards SL
                     const slDistance = signal.priceOpen - signal.priceStopLoss;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
-                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, self.params.execution.context.when);
+                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
                     if (self.params.callbacks?.onPartialLoss) {
                         self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
                     }
@@ -2825,7 +2840,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards TP
                     const tpDistance = signal.priceOpen - signal.priceTakeProfit;
                     const progressPercent = (currentDistance / tpDistance) * 100;
-                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, self.params.execution.context.when);
+                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
                     if (self.params.callbacks?.onPartialProfit) {
                         self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
                     }
@@ -2834,7 +2849,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards SL
                     const slDistance = signal.priceStopLoss - signal.priceOpen;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
-                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, self.params.execution.context.when);
+                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
                     if (self.params.callbacks?.onPartialLoss) {
                         self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
                     }
@@ -3789,10 +3804,13 @@ const DO_VALIDATION_FN = trycatch(async (validation, params) => {
 }, {
     defaultValue: false,
     fallback: (error) => {
-        backtest$1.loggerService.warn("ClientRisk exception thrown", {
+        const message = "ClientRisk exception thrown";
+        const payload = {
             error: errorData(error),
             message: getErrorMessage(error),
-        });
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
         validationSubject.next(error);
     },
 });
@@ -3862,17 +3880,25 @@ class ClientRisk {
             };
             // Execute custom validations
             let isValid = true;
+            let rejectionNote = "N/A";
             if (this.params.validations) {
                 for (const validation of this.params.validations) {
                     if (not(await DO_VALIDATION_FN(typeof validation === "function"
                         ? validation
                         : validation.validate, payload))) {
                         isValid = false;
+                        // Capture note from validation if available
+                        if (typeof validation !== "function" && validation.note) {
+                            rejectionNote = validation.note;
+                        }
                         break;
                     }
                 }
             }
             if (!isValid) {
+                // Call params.onRejected for riskSubject emission
+                await this.params.onRejected(params.symbol, params, riskMap.size, rejectionNote, Date.now());
+                // Call schema callbacks.onRejected if defined
                 if (this.params.callbacks?.onRejected) {
                     this.params.callbacks.onRejected(params.symbol, params);
                 }
@@ -3935,6 +3961,28 @@ class ClientRisk {
     }
 }
 
+/**
+ * Callback function for emitting risk rejection events to riskSubject.
+ *
+ * Called by ClientRisk when a signal is rejected due to risk validation failure.
+ * Emits RiskContract event to all subscribers.
+ *
+ * @param symbol - Trading pair symbol
+ * @param params - Risk check arguments
+ * @param activePositionCount - Number of active positions at rejection time
+ * @param comment - Rejection reason from validation note or "N/A"
+ * @param timestamp - Event timestamp in milliseconds
+ */
+const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment, timestamp) => await riskSubject.next({
+    symbol,
+    pendingSignal: params.pendingSignal,
+    strategyName: params.strategyName,
+    exchangeName: params.exchangeName,
+    currentPrice: params.currentPrice,
+    activePositionCount,
+    comment,
+    timestamp,
+});
 /**
  * Connection service routing risk operations to correct ClientRisk instance.
  *
@@ -3985,6 +4033,7 @@ class RiskConnectionService {
             return new ClientRisk({
                 ...schema,
                 logger: this.loggerService,
+                onRejected: COMMIT_REJECTION_FN,
             });
         });
         /**
@@ -3992,6 +4041,7 @@ class RiskConnectionService {
          *
          * Routes to appropriate ClientRisk instance based on provided context.
          * Validates portfolio drawdown, symbol exposure, position count, and daily loss limits.
+         * ClientRisk will emit riskSubject event via onRejected callback when signal is rejected.
          *
          * @param params - Risk check arguments (portfolio state, position details)
          * @param context - Execution context with risk name
@@ -5980,7 +6030,7 @@ function isUnsafe$3(value) {
     }
     return false;
 }
-const columns$4 = [
+const columns$5 = [
     {
         key: "signalId",
         label: "Signal ID",
@@ -6054,11 +6104,13 @@ const columns$4 = [
         format: (data) => new Date(data.closeTimestamp).toISOString(),
     },
 ];
+/** Maximum number of signals to store in backtest reports */
+const MAX_EVENTS$6 = 250;
 /**
  * Storage class for accumulating closed signals per strategy.
  * Maintains a list of all closed signals and provides methods to generate reports.
  */
-let ReportStorage$4 = class ReportStorage {
+let ReportStorage$5 = class ReportStorage {
     constructor() {
         /** Internal list of all closed signals for this strategy */
         this._signalList = [];
@@ -6069,7 +6121,11 @@ let ReportStorage$4 = class ReportStorage {
      * @param data - Closed signal data with PNL and close reason
      */
     addSignal(data) {
-        this._signalList.push(data);
+        this._signalList.unshift(data);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._signalList.length > MAX_EVENTS$6) {
+            this._signalList.pop();
+        }
     }
     /**
      * Calculates statistical data from closed signals (Controller).
@@ -6152,9 +6208,9 @@ let ReportStorage$4 = class ReportStorage {
                 "No signals closed yet."
             ].join("\n");
         }
-        const header = columns$4.map((col) => col.label);
-        const separator = columns$4.map(() => "---");
-        const rows = this._signalList.map((closedSignal) => columns$4.map((col) => col.format(closedSignal)));
+        const header = columns$5.map((col) => col.label);
+        const separator = columns$5.map(() => "---");
+        const rows = this._signalList.map((closedSignal) => columns$5.map((col) => col.format(closedSignal)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6230,7 +6286,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy pair.
          * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$4());
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$5());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -6401,7 +6457,7 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-const columns$3 = [
+const columns$4 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -6485,12 +6541,12 @@ const columns$3 = [
     },
 ];
 /** Maximum number of events to store in live trading reports */
-const MAX_EVENTS$4 = 250;
+const MAX_EVENTS$5 = 250;
 /**
  * Storage class for accumulating all tick events per strategy.
  * Maintains a chronological list of all events (idle, opened, active, closed).
  */
-let ReportStorage$3 = class ReportStorage {
+let ReportStorage$4 = class ReportStorage {
     constructor() {
         /** Internal list of all tick events for this strategy */
         this._eventList = [];
@@ -6517,9 +6573,9 @@ let ReportStorage$3 = class ReportStorage {
             return;
         }
         {
-            this._eventList.push(newEvent);
-            if (this._eventList.length > MAX_EVENTS$4) {
-                this._eventList.shift();
+            this._eventList.unshift(newEvent);
+            if (this._eventList.length > MAX_EVENTS$5) {
+                this._eventList.pop();
             }
         }
     }
@@ -6529,7 +6585,7 @@ let ReportStorage$3 = class ReportStorage {
      * @param data - Opened tick result
      */
     addOpenedEvent(data) {
-        this._eventList.push({
+        this._eventList.unshift({
             timestamp: data.signal.pendingAt,
             action: "opened",
             symbol: data.signal.symbol,
@@ -6542,12 +6598,13 @@ let ReportStorage$3 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$4) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$5) {
+            this._eventList.pop();
         }
     }
     /**
      * Adds an active event to the storage.
+     * Replaces the last active event with the same signalId.
      *
      * @param data - Active tick result
      */
@@ -6566,10 +6623,18 @@ let ReportStorage$3 = class ReportStorage {
             percentTp: data.percentTp,
             percentSl: data.percentSl,
         };
-        this._eventList.push(newEvent);
+        // Find the last active event with the same signalId
+        const lastActiveIndex = this._eventList.findLastIndex((event) => event.action === "active" && event.signalId === data.signal.id);
+        // Replace the last active event with the same signalId
+        if (lastActiveIndex !== -1) {
+            this._eventList[lastActiveIndex] = newEvent;
+            return;
+        }
+        // If no previous active event found, add new event
+        this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$4) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$5) {
+            this._eventList.pop();
         }
     }
     /**
@@ -6595,10 +6660,10 @@ let ReportStorage$3 = class ReportStorage {
             closeReason: data.closeReason,
             duration: durationMin,
         };
-        this._eventList.push(newEvent);
+        this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$4) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$5) {
+            this._eventList.pop();
         }
     }
     /**
@@ -6697,9 +6762,9 @@ let ReportStorage$3 = class ReportStorage {
                 "No events recorded yet."
             ].join("\n");
         }
-        const header = columns$3.map((col) => col.label);
-        const separator = columns$3.map(() => "---");
-        const rows = this._eventList.map((event) => columns$3.map((col) => col.format(event)));
+        const header = columns$4.map((col) => col.label);
+        const separator = columns$4.map(() => "---");
+        const rows = this._eventList.map((event) => columns$4.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6778,7 +6843,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy pair.
          * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$3());
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -6941,7 +7006,7 @@ class LiveMarkdownService {
     }
 }
 
-const columns$2 = [
+const columns$3 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -6999,12 +7064,12 @@ const columns$2 = [
     },
 ];
 /** Maximum number of events to store in schedule reports */
-const MAX_EVENTS$3 = 250;
+const MAX_EVENTS$4 = 250;
 /**
  * Storage class for accumulating scheduled signal events per strategy.
  * Maintains a chronological list of scheduled and cancelled events.
  */
-let ReportStorage$2 = class ReportStorage {
+let ReportStorage$3 = class ReportStorage {
     constructor() {
         /** Internal list of all scheduled events for this strategy */
         this._eventList = [];
@@ -7015,7 +7080,7 @@ let ReportStorage$2 = class ReportStorage {
      * @param data - Scheduled tick result
      */
     addScheduledEvent(data) {
-        this._eventList.push({
+        this._eventList.unshift({
             timestamp: data.signal.scheduledAt,
             action: "scheduled",
             symbol: data.signal.symbol,
@@ -7028,8 +7093,8 @@ let ReportStorage$2 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$3) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$4) {
+            this._eventList.pop();
         }
     }
     /**
@@ -7053,10 +7118,10 @@ let ReportStorage$2 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
             duration: durationMin,
         };
-        this._eventList.push(newEvent);
+        this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$3) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$4) {
+            this._eventList.pop();
         }
     }
     /**
@@ -7081,10 +7146,10 @@ let ReportStorage$2 = class ReportStorage {
             closeTimestamp: data.closeTimestamp,
             duration: durationMin,
         };
-        this._eventList.push(newEvent);
+        this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$3) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$4) {
+            this._eventList.pop();
         }
     }
     /**
@@ -7153,9 +7218,9 @@ let ReportStorage$2 = class ReportStorage {
                 "No scheduled signals recorded yet."
             ].join("\n");
         }
-        const header = columns$2.map((col) => col.label);
-        const separator = columns$2.map(() => "---");
-        const rows = this._eventList.map((event) => columns$2.map((col) => col.format(event)));
+        const header = columns$3.map((col) => col.label);
+        const separator = columns$3.map(() => "---");
+        const rows = this._eventList.map((event) => columns$3.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7223,7 +7288,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy pair.
          * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$2());
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates scheduled/opened/cancelled events.
          * Should be called from signalEmitter subscription.
@@ -7390,7 +7455,7 @@ function percentile(sortedArray, p) {
     return sortedArray[Math.max(0, index)];
 }
 /** Maximum number of performance events to store per strategy */
-const MAX_EVENTS$2 = 10000;
+const MAX_EVENTS$3 = 10000;
 /**
  * Storage class for accumulating performance metrics per strategy.
  * Maintains a list of all performance events and provides aggregated statistics.
@@ -7406,10 +7471,10 @@ class PerformanceStorage {
      * @param event - Performance event with timing data
      */
     addEvent(event) {
-        this._events.push(event);
+        this._events.unshift(event);
         // Trim queue if exceeded MAX_EVENTS (keep most recent)
-        if (this._events.length > MAX_EVENTS$2) {
-            this._events.shift();
+        if (this._events.length > MAX_EVENTS$3) {
+            this._events.pop();
         }
     }
     /**
@@ -7875,7 +7940,7 @@ const pnlColumns = [
  * Storage class for accumulating walker results.
  * Maintains a list of all strategy results and provides methods to generate reports.
  */
-let ReportStorage$1 = class ReportStorage {
+let ReportStorage$2 = class ReportStorage {
     constructor(walkerName) {
         this.walkerName = walkerName;
         /** Walker metadata (set from first addResult call) */
@@ -7893,17 +7958,13 @@ let ReportStorage$1 = class ReportStorage {
      * @param data - Walker contract with strategy result
      */
     addResult(data) {
-        {
-            this._bestMetric = data.bestMetric;
-            this._bestStrategy = data.bestStrategy;
-            this._totalStrategies = data.totalStrategies;
-        }
-        // Update best stats only if this strategy is the current best
+        this._totalStrategies = data.totalStrategies;
+        this._bestMetric = data.bestMetric;
+        this._bestStrategy = data.bestStrategy;
         if (data.strategyName === data.bestStrategy) {
             this._bestStats = data.stats;
         }
-        // Add strategy result to comparison list
-        this._strategyResults.push({
+        this._strategyResults.unshift({
             strategyName: data.strategyName,
             stats: data.stats,
             metricValue: data.metricValue,
@@ -8087,7 +8148,7 @@ class WalkerMarkdownService {
          * Memoized function to get or create ReportStorage for a walker.
          * Each walker gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$1(walkerName));
+        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$2(walkerName));
         /**
          * Processes walker progress events and accumulates strategy results.
          * Should be called from walkerEmitter.
@@ -8258,7 +8319,7 @@ function isUnsafe(value) {
     }
     return false;
 }
-const columns$1 = [
+const columns$2 = [
     {
         key: "symbol",
         label: "Symbol",
@@ -8321,7 +8382,7 @@ const columns$1 = [
     },
 ];
 /** Maximum number of signals to store per symbol in heatmap reports */
-const MAX_EVENTS$1 = 250;
+const MAX_EVENTS$2 = 250;
 /**
  * Storage class for accumulating closed signals per strategy and generating heatmap.
  * Maintains symbol-level statistics and provides portfolio-wide metrics.
@@ -8342,10 +8403,10 @@ class HeatmapStorage {
             this.symbolData.set(symbol, []);
         }
         const signals = this.symbolData.get(symbol);
-        signals.push(data);
+        signals.unshift(data);
         // Trim queue if exceeded MAX_EVENTS per symbol
-        if (signals.length > MAX_EVENTS$1) {
-            signals.shift();
+        if (signals.length > MAX_EVENTS$2) {
+            signals.pop();
         }
     }
     /**
@@ -8565,9 +8626,9 @@ class HeatmapStorage {
                 "*No data available*"
             ].join("\n");
         }
-        const header = columns$1.map((col) => col.label);
-        const separator = columns$1.map(() => "---");
-        const rows = data.symbols.map((row) => columns$1.map((col) => col.format(row)));
+        const header = columns$2.map((col) => col.label);
+        const separator = columns$2.map(() => "---");
+        const rows = data.symbols.map((row) => columns$2.map((col) => col.format(row)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -10605,7 +10666,7 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
                 revenuePercent,
                 backtest,
             });
-            await self.params.onProfit(symbol, data, currentPrice, level, backtest, when.getTime());
+            await self.params.onProfit(symbol, data.strategyName, data.exchangeName, data, currentPrice, level, backtest, when.getTime());
         }
     }
     if (shouldPersist) {
@@ -10652,7 +10713,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
                 lossPercent,
                 backtest,
             });
-            await self.params.onLoss(symbol, data, currentPrice, level, backtest, when.getTime());
+            await self.params.onLoss(symbol, data.strategyName, data.exchangeName, data, currentPrice, level, backtest, when.getTime());
         }
     }
     if (shouldPersist) {
@@ -10923,6 +10984,7 @@ class ClientPartial {
             symbol,
             data,
             priceClose,
+            backtest,
         });
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
@@ -10939,14 +11001,18 @@ class ClientPartial {
  * Emits PartialProfitContract event to all subscribers.
  *
  * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy name that generated this signal
+ * @param exchangeName - Exchange name where this signal is being executed
  * @param data - Signal row data
  * @param currentPrice - Current market price
  * @param level - Profit level reached
  * @param backtest - True if backtest mode
  * @param timestamp - Event timestamp in milliseconds
  */
-const COMMIT_PROFIT_FN = async (symbol, data, currentPrice, level, backtest, timestamp) => await partialProfitSubject.next({
+const COMMIT_PROFIT_FN = async (symbol, strategyName, exchangeName, data, currentPrice, level, backtest, timestamp) => await partialProfitSubject.next({
     symbol,
+    strategyName,
+    exchangeName,
     data,
     currentPrice,
     level,
@@ -10960,14 +11026,18 @@ const COMMIT_PROFIT_FN = async (symbol, data, currentPrice, level, backtest, tim
  * Emits PartialLossContract event to all subscribers.
  *
  * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy name that generated this signal
+ * @param exchangeName - Exchange name where this signal is being executed
  * @param data - Signal row data
  * @param currentPrice - Current market price
  * @param level - Loss level reached
  * @param backtest - True if backtest mode
  * @param timestamp - Event timestamp in milliseconds
  */
-const COMMIT_LOSS_FN = async (symbol, data, currentPrice, level, backtest, timestamp) => await partialLossSubject.next({
+const COMMIT_LOSS_FN = async (symbol, strategyName, exchangeName, data, currentPrice, level, backtest, timestamp) => await partialLossSubject.next({
     symbol,
+    strategyName,
+    exchangeName,
     data,
     currentPrice,
     level,
@@ -11113,7 +11183,7 @@ class PartialConnectionService {
     }
 }
 
-const columns = [
+const columns$1 = [
     {
         key: "action",
         label: "Action",
@@ -11161,12 +11231,12 @@ const columns = [
     },
 ];
 /** Maximum number of events to store in partial reports */
-const MAX_EVENTS = 250;
+const MAX_EVENTS$1 = 250;
 /**
  * Storage class for accumulating partial profit/loss events per symbol-strategy pair.
  * Maintains a chronological list of profit and loss level events.
  */
-class ReportStorage {
+let ReportStorage$1 = class ReportStorage {
     constructor() {
         /** Internal list of all partial events for this symbol */
         this._eventList = [];
@@ -11180,7 +11250,7 @@ class ReportStorage {
      * @param backtest - True if backtest mode
      */
     addProfitEvent(data, currentPrice, level, backtest, timestamp) {
-        this._eventList.push({
+        this._eventList.unshift({
             timestamp,
             action: "profit",
             symbol: data.symbol,
@@ -11192,8 +11262,8 @@ class ReportStorage {
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$1) {
+            this._eventList.pop();
         }
     }
     /**
@@ -11205,7 +11275,7 @@ class ReportStorage {
      * @param backtest - True if backtest mode
      */
     addLossEvent(data, currentPrice, level, backtest, timestamp) {
-        this._eventList.push({
+        this._eventList.unshift({
             timestamp,
             action: "loss",
             symbol: data.symbol,
@@ -11217,8 +11287,8 @@ class ReportStorage {
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$1) {
+            this._eventList.pop();
         }
     }
     /**
@@ -11260,9 +11330,9 @@ class ReportStorage {
                 "No partial profit/loss events recorded yet."
             ].join("\n");
         }
-        const header = columns.map((col) => col.label);
-        const separator = columns.map(() => "---");
-        const rows = this._eventList.map((event) => columns.map((col) => col.format(event)));
+        const header = columns$1.map((col) => col.label);
+        const separator = columns$1.map(() => "---");
+        const rows = this._eventList.map((event) => columns$1.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -11296,7 +11366,7 @@ class ReportStorage {
             console.error(`Failed to save markdown report:`, error);
         }
     }
-}
+};
 /**
  * Service for generating and saving partial profit/loss markdown reports.
  *
@@ -11326,7 +11396,7 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy pair.
          * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage());
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$1());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -11636,7 +11706,7 @@ class PartialGlobalService {
  * Warning threshold for message size in kilobytes.
  * Messages exceeding this size trigger console warnings.
  */
-const WARN_KB = 100;
+const WARN_KB = 20;
 /**
  * Internal function for dumping signal data to markdown files.
  * Creates a directory structure with system prompts, user messages, and LLM output.
@@ -11898,6 +11968,353 @@ class ConfigValidationService {
     }
 }
 
+const columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.pendingSignal.id || "N/A",
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.pendingSignal.position.toUpperCase(),
+    },
+    {
+        key: "exchangeName",
+        label: "Exchange",
+        format: (data) => data.exchangeName,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => data.pendingSignal.priceOpen !== undefined
+            ? `${data.pendingSignal.priceOpen.toFixed(8)} USD`
+            : "N/A",
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => data.pendingSignal.priceTakeProfit !== undefined
+            ? `${data.pendingSignal.priceTakeProfit.toFixed(8)} USD`
+            : "N/A",
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => data.pendingSignal.priceStopLoss !== undefined
+            ? `${data.pendingSignal.priceStopLoss.toFixed(8)} USD`
+            : "N/A",
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+    },
+    {
+        key: "activePositionCount",
+        label: "Active Positions",
+        format: (data) => data.activePositionCount.toString(),
+    },
+    {
+        key: "comment",
+        label: "Reason",
+        format: (data) => data.comment,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+    },
+];
+/** Maximum number of events to store in risk reports */
+const MAX_EVENTS = 250;
+/**
+ * Storage class for accumulating risk rejection events per symbol-strategy pair.
+ * Maintains a chronological list of rejected signals due to risk limits.
+ */
+class ReportStorage {
+    constructor() {
+        /** Internal list of all risk rejection events for this symbol */
+        this._eventList = [];
+    }
+    /**
+     * Adds a risk rejection event to the storage.
+     *
+     * @param event - Risk rejection event data
+     */
+    addRejectionEvent(event) {
+        this._eventList.unshift(event);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS) {
+            this._eventList.pop();
+        }
+    }
+    /**
+     * Calculates statistical data from risk rejection events (Controller).
+     *
+     * @returns Statistical data (empty object if no events)
+     */
+    async getData() {
+        if (this._eventList.length === 0) {
+            return {
+                eventList: [],
+                totalRejections: 0,
+                bySymbol: {},
+                byStrategy: {},
+            };
+        }
+        const bySymbol = {};
+        const byStrategy = {};
+        for (const event of this._eventList) {
+            bySymbol[event.symbol] = (bySymbol[event.symbol] || 0) + 1;
+            byStrategy[event.strategyName] = (byStrategy[event.strategyName] || 0) + 1;
+        }
+        return {
+            eventList: this._eventList,
+            totalRejections: this._eventList.length,
+            bySymbol,
+            byStrategy,
+        };
+    }
+    /**
+     * Generates markdown report with all risk rejection events for a symbol-strategy pair (View).
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name
+     * @returns Markdown formatted report with all events
+     */
+    async getReport(symbol, strategyName) {
+        const stats = await this.getData();
+        if (stats.totalRejections === 0) {
+            return [
+                `# Risk Rejection Report: ${symbol}:${strategyName}`,
+                "",
+                "No risk rejections recorded yet.",
+            ].join("\n");
+        }
+        const header = columns.map((col) => col.label);
+        const separator = columns.map(() => "---");
+        const rows = this._eventList.map((event) => columns.map((col) => col.format(event)));
+        const tableData = [header, separator, ...rows];
+        const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
+        return [
+            `# Risk Rejection Report: ${symbol}:${strategyName}`,
+            "",
+            table,
+            "",
+            `**Total rejections:** ${stats.totalRejections}`,
+            "",
+            "## Rejections by Symbol",
+            ...Object.entries(stats.bySymbol).map(([sym, count]) => `- ${sym}: ${count}`),
+            "",
+            "## Rejections by Strategy",
+            ...Object.entries(stats.byStrategy).map(([strat, count]) => `- ${strat}: ${count}`),
+        ].join("\n");
+    }
+    /**
+     * Saves symbol-strategy report to disk.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name
+     * @param path - Directory path to save report (default: "./dump/risk")
+     */
+    async dump(symbol, strategyName, path = "./dump/risk") {
+        const markdown = await this.getReport(symbol, strategyName);
+        try {
+            const dir = join(process.cwd(), path);
+            await mkdir(dir, { recursive: true });
+            const filename = `${symbol}_${strategyName}.md`;
+            const filepath = join(dir, filename);
+            await writeFile(filepath, markdown, "utf-8");
+            console.log(`Risk rejection report saved: ${filepath}`);
+        }
+        catch (error) {
+            console.error(`Failed to save markdown report:`, error);
+        }
+    }
+}
+/**
+ * Service for generating and saving risk rejection markdown reports.
+ *
+ * Features:
+ * - Listens to risk rejection events via riskSubject
+ * - Accumulates all rejection events per symbol-strategy pair
+ * - Generates markdown tables with detailed rejection information
+ * - Provides statistics (total rejections, by symbol, by strategy)
+ * - Saves reports to disk in dump/risk/{symbol}_{strategyName}.md
+ *
+ * @example
+ * ```typescript
+ * const service = new RiskMarkdownService();
+ *
+ * // Service automatically subscribes to subjects on init
+ * // No manual callback setup needed
+ *
+ * // Later: generate and save report
+ * await service.dump("BTCUSDT", "my-strategy");
+ * ```
+ */
+class RiskMarkdownService {
+    constructor() {
+        /** Logger service for debug output */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated storage instance.
+         */
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage());
+        /**
+         * Processes risk rejection events and accumulates them.
+         * Should be called from riskSubject subscription.
+         *
+         * @param data - Risk rejection event data
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * // Service automatically subscribes in init()
+         * ```
+         */
+        this.tickRejection = async (data) => {
+            this.loggerService.log("riskMarkdownService tickRejection", {
+                data,
+            });
+            const storage = this.getStorage(data.symbol, data.strategyName);
+            storage.addRejectionEvent(data);
+        };
+        /**
+         * Gets statistical data from all risk rejection events for a symbol-strategy pair.
+         * Delegates to ReportStorage.getData().
+         *
+         * @param symbol - Trading pair symbol to get data for
+         * @param strategyName - Strategy name to get data for
+         * @returns Statistical data object with all metrics
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * const stats = await service.getData("BTCUSDT", "my-strategy");
+         * console.log(stats.totalRejections, stats.bySymbol);
+         * ```
+         */
+        this.getData = async (symbol, strategyName) => {
+            this.loggerService.log("riskMarkdownService getData", {
+                symbol,
+                strategyName,
+            });
+            const storage = this.getStorage(symbol, strategyName);
+            return storage.getData();
+        };
+        /**
+         * Generates markdown report with all risk rejection events for a symbol-strategy pair.
+         * Delegates to ReportStorage.getReport().
+         *
+         * @param symbol - Trading pair symbol to generate report for
+         * @param strategyName - Strategy name to generate report for
+         * @returns Markdown formatted report string with table of all events
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, strategyName) => {
+            this.loggerService.log("riskMarkdownService getReport", {
+                symbol,
+                strategyName,
+            });
+            const storage = this.getStorage(symbol, strategyName);
+            return storage.getReport(symbol, strategyName);
+        };
+        /**
+         * Saves symbol-strategy report to disk.
+         * Creates directory if it doesn't exist.
+         * Delegates to ReportStorage.dump().
+         *
+         * @param symbol - Trading pair symbol to save report for
+         * @param strategyName - Strategy name to save report for
+         * @param path - Directory path to save report (default: "./dump/risk")
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         *
+         * // Save to default path: ./dump/risk/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, strategyName, path = "./dump/risk") => {
+            this.loggerService.log("riskMarkdownService dump", {
+                symbol,
+                strategyName,
+                path,
+            });
+            const storage = this.getStorage(symbol, strategyName);
+            await storage.dump(symbol, strategyName, path);
+        };
+        /**
+         * Clears accumulated event data from storage.
+         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If nothing is provided, clears all data.
+         *
+         * @param ctx - Optional context with symbol and strategyName
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         *
+         * // Clear specific symbol-strategy pair
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
+         *
+         * // Clear all data
+         * await service.clear();
+         * ```
+         */
+        this.clear = async (ctx) => {
+            this.loggerService.log("riskMarkdownService clear", {
+                ctx,
+            });
+            if (ctx) {
+                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
+        };
+        /**
+         * Initializes the service by subscribing to risk rejection events.
+         * Uses singleshot to ensure initialization happens only once.
+         * Automatically called on first use.
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * await service.init(); // Subscribe to rejection events
+         * ```
+         */
+        this.init = singleshot(async () => {
+            this.loggerService.log("riskMarkdownService init");
+            riskSubject.subscribe(this.tickRejection);
+        });
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -11958,6 +12375,7 @@ class ConfigValidationService {
     provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
     provide(TYPES.partialMarkdownService, () => new PartialMarkdownService());
     provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
+    provide(TYPES.riskMarkdownService, () => new RiskMarkdownService());
 }
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
@@ -12033,6 +12451,7 @@ const markdownServices = {
     heatMarkdownService: inject(TYPES.heatMarkdownService),
     partialMarkdownService: inject(TYPES.partialMarkdownService),
     outlineMarkdownService: inject(TYPES.outlineMarkdownService),
+    riskMarkdownService: inject(TYPES.riskMarkdownService),
 };
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
@@ -12807,6 +13226,8 @@ const LISTEN_PARTIAL_PROFIT_METHOD_NAME = "event.listenPartialProfit";
 const LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME = "event.listenPartialProfitOnce";
 const LISTEN_PARTIAL_LOSS_METHOD_NAME = "event.listenPartialLoss";
 const LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME = "event.listenPartialLossOnce";
+const LISTEN_RISK_METHOD_NAME = "event.listenRisk";
+const LISTEN_RISK_ONCE_METHOD_NAME = "event.listenRiskOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -13605,6 +14026,75 @@ function listenPartialLossOnce(filterFn, fn) {
     backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME);
     return partialLossSubject.filter(filterFn).once(fn);
 }
+/**
+ * Subscribes to risk rejection events with queued async processing.
+ *
+ * Emits ONLY when a signal is rejected due to risk validation failure.
+ * Does not emit for allowed signals (prevents spam).
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle risk rejection events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenRisk } from "./function/event";
+ *
+ * const unsubscribe = listenRisk((event) => {
+ *   console.log(`[RISK REJECTED] Signal for ${event.symbol}`);
+ *   console.log(`Strategy: ${event.strategyName}`);
+ *   console.log(`Position: ${event.pendingSignal.position}`);
+ *   console.log(`Active positions: ${event.activePositionCount}`);
+ *   console.log(`Reason: ${event.comment}`);
+ *   console.log(`Price: ${event.currentPrice}`);
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenRisk(fn) {
+    backtest$1.loggerService.log(LISTEN_RISK_METHOD_NAME);
+    return riskSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered risk rejection events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific risk rejection conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenRiskOnce } from "./function/event";
+ *
+ * // Wait for first risk rejection on BTCUSDT
+ * listenRiskOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => {
+ *     console.log("BTCUSDT signal rejected!");
+ *     console.log("Reason:", event.comment);
+ *   }
+ * );
+ *
+ * // Wait for rejection due to position limit
+ * const cancel = listenRiskOnce(
+ *   (event) => event.comment.includes("Max") && event.activePositionCount >= 3,
+ *   (event) => console.log("Position limit reached:", event.activePositionCount)
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
+ * ```
+ */
+function listenRiskOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
+    return riskSubject.filter(filterFn).once(fn);
+}
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
@@ -16229,4 +16719,184 @@ class ConstantUtils {
  */
 const Constant = new ConstantUtils();
 
-export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getConfig, getDate, getDefaultConfig, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };
+const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
+const RISK_METHOD_NAME_GET_REPORT = "RiskUtils.getReport";
+const RISK_METHOD_NAME_DUMP = "RiskUtils.dump";
+/**
+ * Utility class for accessing risk rejection reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by RiskMarkdownService from risk rejection events.
+ *
+ * Features:
+ * - Statistical data extraction (total rejections count, by symbol, by strategy)
+ * - Markdown report generation with event tables
+ * - File export to disk
+ *
+ * Data source:
+ * - RiskMarkdownService listens to riskSubject
+ * - Accumulates rejection events in ReportStorage (max 250 events per symbol-strategy pair)
+ * - Events include: timestamp, symbol, strategyName, position, exchangeName, price, activePositionCount, comment
+ *
+ * @example
+ * ```typescript
+ * import { Risk } from "./classes/Risk";
+ *
+ * // Get statistical data for BTCUSDT:my-strategy
+ * const stats = await Risk.getData("BTCUSDT", "my-strategy");
+ * console.log(`Total rejections: ${stats.totalRejections}`);
+ * console.log(`By symbol:`, stats.bySymbol);
+ * console.log(`By strategy:`, stats.byStrategy);
+ *
+ * // Generate markdown report
+ * const markdown = await Risk.getReport("BTCUSDT", "my-strategy");
+ * console.log(markdown); // Formatted table with all rejection events
+ *
+ * // Export report to file
+ * await Risk.dump("BTCUSDT", "my-strategy"); // Saves to ./dump/risk/BTCUSDT_my-strategy.md
+ * await Risk.dump("BTCUSDT", "my-strategy", "./custom/path"); // Custom directory
+ * ```
+ */
+class RiskUtils {
+    constructor() {
+        /**
+         * Retrieves statistical data from accumulated risk rejection events.
+         *
+         * Delegates to RiskMarkdownService.getData() which reads from ReportStorage.
+         * Returns aggregated metrics calculated from all rejection events.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @returns Promise resolving to RiskStatistics object with counts and event list
+         *
+         * @example
+         * ```typescript
+         * const stats = await Risk.getData("BTCUSDT", "my-strategy");
+         *
+         * console.log(`Total rejections: ${stats.totalRejections}`);
+         * console.log(`Rejections by symbol:`, stats.bySymbol);
+         * console.log(`Rejections by strategy:`, stats.byStrategy);
+         *
+         * // Iterate through all rejection events
+         * for (const event of stats.eventList) {
+         *   console.log(`REJECTED: ${event.symbol} - ${event.comment} (${event.activePositionCount} active)`);
+         * }
+         * ```
+         */
+        this.getData = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_DATA, { symbol, strategyName });
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
+            }
+            return await backtest$1.riskMarkdownService.getData(symbol, strategyName);
+        };
+        /**
+         * Generates markdown report with all risk rejection events for a symbol-strategy pair.
+         *
+         * Creates formatted table containing:
+         * - Symbol
+         * - Strategy
+         * - Position (LONG/SHORT)
+         * - Exchange
+         * - Price
+         * - Active Positions (at rejection time)
+         * - Reason (from validation note)
+         * - Timestamp (ISO 8601)
+         *
+         * Also includes summary statistics at the end (total rejections, by symbol, by strategy).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Risk.getReport("BTCUSDT", "my-strategy");
+         * console.log(markdown);
+         *
+         * // Output:
+         * // # Risk Rejection Report: BTCUSDT:my-strategy
+         * //
+         * // | Symbol | Strategy | Position | Exchange | Price | Active Positions | Reason | Timestamp |
+         * // | --- | --- | --- | --- | --- | --- | --- | --- |
+         * // | BTCUSDT | my-strategy | LONG | binance | 50000.00000000 USD | 3 | Max 3 positions allowed | 2024-01-15T10:30:00.000Z |
+         * //
+         * // **Total rejections:** 1
+         * //
+         * // ## Rejections by Symbol
+         * // - BTCUSDT: 1
+         * //
+         * // ## Rejections by Strategy
+         * // - my-strategy: 1
+         * ```
+         */
+        this.getReport = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, { symbol, strategyName });
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
+            }
+            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName);
+        };
+        /**
+         * Generates and saves markdown report to file.
+         *
+         * Creates directory if it doesn't exist.
+         * Filename format: {symbol}_{strategyName}.md (e.g., "BTCUSDT_my-strategy.md")
+         *
+         * Delegates to RiskMarkdownService.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 strategyName - Strategy name (e.g., "my-strategy")
+         * @param path - Output directory path (default: "./dump/risk")
+         * @returns Promise that resolves when file is written
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./dump/risk/BTCUSDT_my-strategy.md
+         * await Risk.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./reports/risk/BTCUSDT_my-strategy.md
+         * await Risk.dump("BTCUSDT", "my-strategy", "./reports/risk");
+         *
+         * // After multiple symbols backtested, export all risk reports
+         * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
+         *   await Risk.dump(symbol, "my-strategy", "./backtest-results");
+         * }
+         * ```
+         */
+        this.dump = async (symbol, strategyName, path) => {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, { symbol, strategyName, path });
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
+            }
+            await backtest$1.riskMarkdownService.dump(symbol, strategyName, path);
+        };
+    }
+}
+/**
+ * Global singleton instance of RiskUtils.
+ * Provides static-like access to risk rejection reporting methods.
+ *
+ * @example
+ * ```typescript
+ * import { Risk } from "backtest-kit";
+ *
+ * // Usage same as RiskUtils methods
+ * const stats = await Risk.getData("BTCUSDT", "my-strategy");
+ * const report = await Risk.getReport("BTCUSDT", "my-strategy");
+ * await Risk.dump("BTCUSDT", "my-strategy");
+ * ```
+ */
+const Risk = new RiskUtils();
+
+export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getConfig, getDate, getDefaultConfig, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };