backtest-kit 1.1.4 → 1.1.6

package/build/index.mjs

@@ -1127,6 +1127,11 @@ const errorEmitter = new Subject();
  * Emits when background tasks complete (Live.background, Backtest.background).
  */
 const doneEmitter = new Subject();
+/**
+ * Progress emitter for backtest execution progress.
+ * Emits progress updates during backtest execution.
+ */
+const progressEmitter = new Subject();
 
 const INTERVAL_MINUTES$1 = {
     "1m": 1,
@@ -2400,6 +2405,7 @@ class BacktestLogicPrivateService {
         this.strategyGlobalService = inject(TYPES.strategyGlobalService);
         this.exchangeGlobalService = inject(TYPES.exchangeGlobalService);
         this.frameGlobalService = inject(TYPES.frameGlobalService);
+        this.methodContextService = inject(TYPES.methodContextService);
     }
     /**
      * Runs backtest for a symbol, streaming closed signals as async generator.
@@ -2420,9 +2426,21 @@ class BacktestLogicPrivateService {
             symbol,
         });
         const timeframes = await this.frameGlobalService.getTimeframe(symbol);
+        const totalFrames = timeframes.length;
         let i = 0;
         while (i < timeframes.length) {
             const when = timeframes[i];
+            // Emit progress event if context is available
+            {
+                await progressEmitter.next({
+                    exchangeName: this.methodContextService.context.exchangeName,
+                    strategyName: this.methodContextService.context.strategyName,
+                    symbol,
+                    totalFrames,
+                    processedFrames: i,
+                    progress: totalFrames > 0 ? i / totalFrames : 0,
+                });
+            }
             const result = await this.strategyGlobalService.tick(symbol, when, true);
             // Если сигнал открыт, вызываем backtest
             if (result.action === "opened") {
@@ -2459,6 +2477,17 @@ class BacktestLogicPrivateService {
             }
             i++;
         }
+        // Emit final progress event (100%)
+        {
+            await progressEmitter.next({
+                exchangeName: this.methodContextService.context.exchangeName,
+                strategyName: this.methodContextService.context.strategyName,
+                symbol,
+                totalFrames,
+                processedFrames: totalFrames,
+                progress: 1.0,
+            });
+        }
     }
 }
 
@@ -2711,6 +2740,24 @@ class BacktestGlobalService {
     }
 }
 
+/**
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ *
+ * @param value - Value to check
+ * @returns true if value is unsafe, false otherwise
+ */
+function isUnsafe$1(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
 const columns$1 = [
     {
         key: "signalId",
@@ -2803,13 +2850,80 @@ let ReportStorage$1 = class ReportStorage {
         this._signalList.push(data);
     }
     /**
-     * Generates markdown report with all closed signals for a strategy.
+     * Calculates statistical data from closed signals (Controller).
+     * Returns null for any unsafe numeric values (NaN, Infinity, etc).
+     *
+     * @returns Statistical data (empty object if no signals)
+     */
+    async getData() {
+        if (this._signalList.length === 0) {
+            return {
+                signalList: [],
+                totalSignals: 0,
+                winCount: 0,
+                lossCount: 0,
+                winRate: null,
+                avgPnl: null,
+                totalPnl: null,
+                stdDev: null,
+                sharpeRatio: null,
+                annualizedSharpeRatio: null,
+                certaintyRatio: null,
+                expectedYearlyReturns: null,
+            };
+        }
+        const totalSignals = this._signalList.length;
+        const winCount = this._signalList.filter((s) => s.pnl.pnlPercentage > 0).length;
+        const lossCount = this._signalList.filter((s) => s.pnl.pnlPercentage < 0).length;
+        // Calculate basic statistics
+        const avgPnl = this._signalList.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0) / totalSignals;
+        const totalPnl = this._signalList.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0);
+        const winRate = (winCount / totalSignals) * 100;
+        // Calculate Sharpe Ratio (risk-free rate = 0)
+        const returns = this._signalList.map((s) => s.pnl.pnlPercentage);
+        const variance = returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / totalSignals;
+        const stdDev = Math.sqrt(variance);
+        const sharpeRatio = stdDev > 0 ? avgPnl / stdDev : 0;
+        const annualizedSharpeRatio = sharpeRatio * Math.sqrt(365);
+        // Calculate Certainty Ratio
+        const wins = this._signalList.filter((s) => s.pnl.pnlPercentage > 0);
+        const losses = this._signalList.filter((s) => s.pnl.pnlPercentage < 0);
+        const avgWin = wins.length > 0
+            ? wins.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0) / wins.length
+            : 0;
+        const avgLoss = losses.length > 0
+            ? losses.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0) / losses.length
+            : 0;
+        const certaintyRatio = avgLoss < 0 ? avgWin / Math.abs(avgLoss) : 0;
+        // Calculate Expected Yearly Returns
+        const avgDurationMs = this._signalList.reduce((sum, s) => sum + (s.closeTimestamp - s.signal.timestamp), 0) / totalSignals;
+        const avgDurationDays = avgDurationMs / (1000 * 60 * 60 * 24);
+        const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
+        const expectedYearlyReturns = avgPnl * tradesPerYear;
+        return {
+            signalList: this._signalList,
+            totalSignals,
+            winCount,
+            lossCount,
+            winRate: isUnsafe$1(winRate) ? null : winRate,
+            avgPnl: isUnsafe$1(avgPnl) ? null : avgPnl,
+            totalPnl: isUnsafe$1(totalPnl) ? null : totalPnl,
+            stdDev: isUnsafe$1(stdDev) ? null : stdDev,
+            sharpeRatio: isUnsafe$1(sharpeRatio) ? null : sharpeRatio,
+            annualizedSharpeRatio: isUnsafe$1(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
+            certaintyRatio: isUnsafe$1(certaintyRatio) ? null : certaintyRatio,
+            expectedYearlyReturns: isUnsafe$1(expectedYearlyReturns) ? null : expectedYearlyReturns,
+        };
+    }
+    /**
+     * Generates markdown report with all closed signals for a strategy (View).
      *
      * @param strategyName - Strategy name
      * @returns Markdown formatted report with all signals
      */
-    getReport(strategyName) {
-        if (this._signalList.length === 0) {
+    async getReport(strategyName) {
+        const stats = await this.getData();
+        if (stats.totalSignals === 0) {
             return str.newline(`# Backtest Report: ${strategyName}`, "", "No signals closed yet.");
         }
         const header = columns$1.map((col) => col.label);
@@ -2817,13 +2931,7 @@ let ReportStorage$1 = class ReportStorage {
         const rows = this._signalList.map((closedSignal) => columns$1.map((col) => col.format(closedSignal)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
-        // Calculate statistics
-        const totalSignals = this._signalList.length;
-        const winCount = this._signalList.filter((s) => s.pnl.pnlPercentage > 0).length;
-        const lossCount = this._signalList.filter((s) => s.pnl.pnlPercentage < 0).length;
-        const avgPnl = this._signalList.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0) / totalSignals;
-        const totalPnl = this._signalList.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0);
-        return str.newline(`# Backtest Report: ${strategyName}`, "", table, "", `**Total signals:** ${totalSignals}`, `**Closed signals:** ${totalSignals}`, `**Win rate:** ${((winCount / totalSignals) * 100).toFixed(2)}% (${winCount}W / ${lossCount}L)`, `**Average PNL:** ${avgPnl > 0 ? "+" : ""}${avgPnl.toFixed(2)}%`, `**Total PNL:** ${totalPnl > 0 ? "+" : ""}${totalPnl.toFixed(2)}%`);
+        return str.newline(`# Backtest Report: ${strategyName}`, "", table, "", `**Total signals:** ${stats.totalSignals}`, `**Closed signals:** ${stats.totalSignals}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
     }
     /**
      * Saves strategy report to disk.
@@ -2832,7 +2940,7 @@ let ReportStorage$1 = class ReportStorage {
      * @param path - Directory path to save report (default: "./logs/backtest")
      */
     async dump(strategyName, path = "./logs/backtest") {
-        const markdown = this.getReport(strategyName);
+        const markdown = await this.getReport(strategyName);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -2911,6 +3019,27 @@ class BacktestMarkdownService {
             const storage = this.getStorage(data.strategyName);
             storage.addSignal(data);
         };
+        /**
+         * Gets statistical data from all closed signals for a strategy.
+         * Delegates to ReportStorage.getData().
+         *
+         * @param strategyName - Strategy name to get data for
+         * @returns Statistical data object with all metrics
+         *
+         * @example
+         * ```typescript
+         * const service = new BacktestMarkdownService();
+         * const stats = await service.getData("my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (strategyName) => {
+            this.loggerService.log("backtestMarkdownService getData", {
+                strategyName,
+            });
+            const storage = this.getStorage(strategyName);
+            return storage.getData();
+        };
         /**
          * Generates markdown report with all closed signals for a strategy.
          * Delegates to ReportStorage.generateReport().
@@ -2921,7 +3050,7 @@ class BacktestMarkdownService {
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
-         * const markdown = service.generateReport("my-strategy");
+         * const markdown = await service.getReport("my-strategy");
          * console.log(markdown);
          * ```
          */
@@ -3001,6 +3130,24 @@ class BacktestMarkdownService {
     }
 }
 
+/**
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ *
+ * @param value - Value to check
+ * @returns true if value is unsafe, false otherwise
+ */
+function isUnsafe(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
 const columns = [
     {
         key: "timestamp",
@@ -3208,36 +3355,103 @@ class ReportStorage {
         }
     }
     /**
-     * Generates markdown report with all tick events for a strategy.
+     * Calculates statistical data from live trading events (Controller).
+     * Returns null for any unsafe numeric values (NaN, Infinity, etc).
      *
-     * @param strategyName - Strategy name
-     * @returns Markdown formatted report with all events
+     * @returns Statistical data (empty object if no events)
      */
-    getReport(strategyName) {
+    async getData() {
         if (this._eventList.length === 0) {
-            return str.newline(`# Live Trading Report: ${strategyName}`, "", "No events recorded yet.");
+            return {
+                eventList: [],
+                totalEvents: 0,
+                totalClosed: 0,
+                winCount: 0,
+                lossCount: 0,
+                winRate: null,
+                avgPnl: null,
+                totalPnl: null,
+                stdDev: null,
+                sharpeRatio: null,
+                annualizedSharpeRatio: null,
+                certaintyRatio: null,
+                expectedYearlyReturns: null,
+            };
         }
-        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 = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
-        // Calculate statistics
         const closedEvents = this._eventList.filter((e) => e.action === "closed");
         const totalClosed = closedEvents.length;
         const winCount = closedEvents.filter((e) => e.pnl && e.pnl > 0).length;
         const lossCount = closedEvents.filter((e) => e.pnl && e.pnl < 0).length;
+        // Calculate basic statistics
         const avgPnl = totalClosed > 0
             ? closedEvents.reduce((sum, e) => sum + (e.pnl || 0), 0) / totalClosed
             : 0;
         const totalPnl = closedEvents.reduce((sum, e) => sum + (e.pnl || 0), 0);
-        return str.newline(`# Live Trading Report: ${strategyName}`, "", table, "", `**Total events:** ${this._eventList.length}`, `**Closed signals:** ${totalClosed}`, totalClosed > 0
-            ? `**Win rate:** ${((winCount / totalClosed) * 100).toFixed(2)}% (${winCount}W / ${lossCount}L)`
-            : "", totalClosed > 0
-            ? `**Average PNL:** ${avgPnl > 0 ? "+" : ""}${avgPnl.toFixed(2)}%`
-            : "", totalClosed > 0
-            ? `**Total PNL:** ${totalPnl > 0 ? "+" : ""}${totalPnl.toFixed(2)}%`
-            : "");
+        const winRate = (winCount / totalClosed) * 100;
+        // Calculate Sharpe Ratio (risk-free rate = 0)
+        let sharpeRatio = 0;
+        let stdDev = 0;
+        if (totalClosed > 0) {
+            const returns = closedEvents.map((e) => e.pnl || 0);
+            const variance = returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / totalClosed;
+            stdDev = Math.sqrt(variance);
+            sharpeRatio = stdDev > 0 ? avgPnl / stdDev : 0;
+        }
+        const annualizedSharpeRatio = sharpeRatio * Math.sqrt(365);
+        // Calculate Certainty Ratio
+        let certaintyRatio = 0;
+        if (totalClosed > 0) {
+            const wins = closedEvents.filter((e) => e.pnl && e.pnl > 0);
+            const losses = closedEvents.filter((e) => e.pnl && e.pnl < 0);
+            const avgWin = wins.length > 0
+                ? wins.reduce((sum, e) => sum + (e.pnl || 0), 0) / wins.length
+                : 0;
+            const avgLoss = losses.length > 0
+                ? losses.reduce((sum, e) => sum + (e.pnl || 0), 0) / losses.length
+                : 0;
+            certaintyRatio = avgLoss < 0 ? avgWin / Math.abs(avgLoss) : 0;
+        }
+        // Calculate Expected Yearly Returns
+        let expectedYearlyReturns = 0;
+        if (totalClosed > 0) {
+            const avgDurationMin = closedEvents.reduce((sum, e) => sum + (e.duration || 0), 0) / totalClosed;
+            const avgDurationDays = avgDurationMin / (60 * 24);
+            const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
+            expectedYearlyReturns = avgPnl * tradesPerYear;
+        }
+        return {
+            eventList: this._eventList,
+            totalEvents: this._eventList.length,
+            totalClosed,
+            winCount,
+            lossCount,
+            winRate: isUnsafe(winRate) ? null : winRate,
+            avgPnl: isUnsafe(avgPnl) ? null : avgPnl,
+            totalPnl: isUnsafe(totalPnl) ? null : totalPnl,
+            stdDev: isUnsafe(stdDev) ? null : stdDev,
+            sharpeRatio: isUnsafe(sharpeRatio) ? null : sharpeRatio,
+            annualizedSharpeRatio: isUnsafe(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
+            certaintyRatio: isUnsafe(certaintyRatio) ? null : certaintyRatio,
+            expectedYearlyReturns: isUnsafe(expectedYearlyReturns) ? null : expectedYearlyReturns,
+        };
+    }
+    /**
+     * Generates markdown report with all tick events for a strategy (View).
+     *
+     * @param strategyName - Strategy name
+     * @returns Markdown formatted report with all events
+     */
+    async getReport(strategyName) {
+        const stats = await this.getData();
+        if (stats.totalEvents === 0) {
+            return str.newline(`# Live Trading Report: ${strategyName}`, "", "No events recorded yet.");
+        }
+        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 = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
+        return str.newline(`# Live Trading Report: ${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Closed signals:** ${stats.totalClosed}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
     }
     /**
      * Saves strategy report to disk.
@@ -3246,7 +3460,7 @@ class ReportStorage {
      * @param path - Directory path to save report (default: "./logs/live")
      */
     async dump(strategyName, path = "./logs/live") {
-        const markdown = this.getReport(strategyName);
+        const markdown = await this.getReport(strategyName);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -3338,6 +3552,27 @@ class LiveMarkdownService {
                 storage.addClosedEvent(data);
             }
         };
+        /**
+         * Gets statistical data from all live trading events for a strategy.
+         * Delegates to ReportStorage.getData().
+         *
+         * @param strategyName - Strategy name to get data for
+         * @returns Statistical data object with all metrics
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         * const stats = await service.getData("my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (strategyName) => {
+            this.loggerService.log("liveMarkdownService getData", {
+                strategyName,
+            });
+            const storage = this.getStorage(strategyName);
+            return storage.getData();
+        };
         /**
          * Generates markdown report with all events for a strategy.
          * Delegates to ReportStorage.getReport().
@@ -3477,6 +3712,15 @@ class ExchangeValidationService {
             }
             return true;
         });
+        /**
+         * Returns a list of all registered exchange schemas
+         * @public
+         * @returns Array of exchange schemas with their configurations
+         */
+        this.list = async () => {
+            this.loggerService.log("exchangeValidationService list");
+            return Array.from(this._exchangeMap.values());
+        };
     }
 }
 
@@ -3529,6 +3773,15 @@ class StrategyValidationService {
             }
             return true;
         });
+        /**
+         * Returns a list of all registered strategy schemas
+         * @public
+         * @returns Array of strategy schemas with their configurations
+         */
+        this.list = async () => {
+            this.loggerService.log("strategyValidationService list");
+            return Array.from(this._strategyMap.values());
+        };
     }
 }
 
@@ -3581,6 +3834,15 @@ class FrameValidationService {
             }
             return true;
         });
+        /**
+         * Returns a list of all registered frame schemas
+         * @public
+         * @returns Array of frame schemas with their configurations
+         */
+        this.list = async () => {
+            this.loggerService.log("frameValidationService list");
+            return Array.from(this._frameMap.values());
+        };
     }
 }
 
@@ -3826,6 +4088,102 @@ function addFrame(frameSchema) {
     backtest$1.frameSchemaService.register(frameSchema.frameName, frameSchema);
 }
 
+const LIST_EXCHANGES_METHOD_NAME = "list.listExchanges";
+const LIST_STRATEGIES_METHOD_NAME = "list.listStrategies";
+const LIST_FRAMES_METHOD_NAME = "list.listFrames";
+/**
+ * Returns a list of all registered exchange schemas.
+ *
+ * Retrieves all exchanges that have been registered via addExchange().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of exchange schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listExchanges, addExchange } from "backtest-kit";
+ *
+ * addExchange({
+ *   exchangeName: "binance",
+ *   note: "Binance cryptocurrency exchange",
+ *   getCandles: async (symbol, interval, since, limit) => [...],
+ *   formatPrice: async (symbol, price) => price.toFixed(2),
+ *   formatQuantity: async (symbol, quantity) => quantity.toFixed(8),
+ * });
+ *
+ * const exchanges = listExchanges();
+ * console.log(exchanges);
+ * // [{ exchangeName: "binance", note: "Binance cryptocurrency exchange", ... }]
+ * ```
+ */
+async function listExchanges() {
+    backtest$1.loggerService.log(LIST_EXCHANGES_METHOD_NAME);
+    return await backtest$1.exchangeValidationService.list();
+}
+/**
+ * Returns a list of all registered strategy schemas.
+ *
+ * Retrieves all strategies that have been registered via addStrategy().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of strategy schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listStrategies, addStrategy } from "backtest-kit";
+ *
+ * addStrategy({
+ *   strategyName: "my-strategy",
+ *   note: "Simple moving average crossover strategy",
+ *   interval: "5m",
+ *   getSignal: async (symbol) => ({
+ *     position: "long",
+ *     priceOpen: 50000,
+ *     priceTakeProfit: 51000,
+ *     priceStopLoss: 49000,
+ *     minuteEstimatedTime: 60,
+ *   }),
+ * });
+ *
+ * const strategies = listStrategies();
+ * console.log(strategies);
+ * // [{ strategyName: "my-strategy", note: "Simple moving average...", ... }]
+ * ```
+ */
+async function listStrategies() {
+    backtest$1.loggerService.log(LIST_STRATEGIES_METHOD_NAME);
+    return await backtest$1.strategyValidationService.list();
+}
+/**
+ * Returns a list of all registered frame schemas.
+ *
+ * Retrieves all frames that have been registered via addFrame().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of frame schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listFrames, addFrame } from "backtest-kit";
+ *
+ * addFrame({
+ *   frameName: "1d-backtest",
+ *   note: "One day backtest period for testing",
+ *   interval: "1m",
+ *   startDate: new Date("2024-01-01T00:00:00Z"),
+ *   endDate: new Date("2024-01-02T00:00:00Z"),
+ * });
+ *
+ * const frames = listFrames();
+ * console.log(frames);
+ * // [{ frameName: "1d-backtest", note: "One day backtest...", ... }]
+ * ```
+ */
+async function listFrames() {
+    backtest$1.loggerService.log(LIST_FRAMES_METHOD_NAME);
+    return await backtest$1.frameValidationService.list();
+}
+
 const LISTEN_SIGNAL_METHOD_NAME = "event.listenSignal";
 const LISTEN_SIGNAL_ONCE_METHOD_NAME = "event.listenSignalOnce";
 const LISTEN_SIGNAL_LIVE_METHOD_NAME = "event.listenSignalLive";
@@ -3835,6 +4193,7 @@ const LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME = "event.listenSignalBacktestOnce"
 const LISTEN_ERROR_METHOD_NAME = "event.listenError";
 const LISTEN_DONE_METHOD_NAME = "event.listenDone";
 const LISTEN_DONE_ONCE_METHOD_NAME = "event.listenDoneOnce";
+const LISTEN_PROGRESS_METHOD_NAME = "event.listenProgress";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -4090,6 +4449,40 @@ function listenDoneOnce(filterFn, fn) {
     backtest$1.loggerService.log(LISTEN_DONE_ONCE_METHOD_NAME);
     return doneEmitter.filter(filterFn).once(fn);
 }
+/**
+ * Subscribes to backtest progress events with queued async processing.
+ *
+ * Emits during Backtest.background() execution to track progress.
+ * 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 progress events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenProgress, Backtest } from "backtest-kit";
+ *
+ * const unsubscribe = listenProgress((event) => {
+ *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
+ *   console.log(`${event.processedFrames} / ${event.totalFrames} frames`);
+ *   console.log(`Strategy: ${event.strategyName}, Symbol: ${event.symbol}`);
+ * });
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenProgress(fn) {
+    backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
+    return progressEmitter.subscribe(queued(async (event) => fn(event)));
+}
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
@@ -4317,6 +4710,24 @@ class BacktestUtils {
                 isStopped = true;
             };
         };
+        /**
+         * Gets statistical data from all closed signals for a strategy.
+         *
+         * @param strategyName - Strategy name to get data for
+         * @returns Promise resolving to statistical data object
+         *
+         * @example
+         * ```typescript
+         * const stats = await Backtest.getData("my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (strategyName) => {
+            backtest$1.loggerService.info("BacktestUtils.getData", {
+                strategyName,
+            });
+            return await backtest$1.backtestMarkdownService.getData(strategyName);
+        };
         /**
          * Generates markdown report with all closed signals for a strategy.
          *
@@ -4479,6 +4890,24 @@ class LiveUtils {
                 isStopped = true;
             };
         };
+        /**
+         * Gets statistical data from all live trading events for a strategy.
+         *
+         * @param strategyName - Strategy name to get data for
+         * @returns Promise resolving to statistical data object
+         *
+         * @example
+         * ```typescript
+         * const stats = await Live.getData("my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (strategyName) => {
+            backtest$1.loggerService.info("LiveUtils.getData", {
+                strategyName,
+            });
+            return await backtest$1.liveMarkdownService.getData(strategyName);
+        };
         /**
          * Generates markdown report with all events for a strategy.
          *
@@ -4538,4 +4967,4 @@ class LiveUtils {
  */
 const Live = new LiveUtils();
 
-export { Backtest, ExecutionContextService, Live, MethodContextService, PersistBase, PersistSignalAdaper, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listenDone, listenDoneOnce, listenError, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };
+export { Backtest, ExecutionContextService, Live, MethodContextService, PersistBase, PersistSignalAdaper, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listStrategies, listenDone, listenDoneOnce, listenError, listenProgress, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",