backtest-kit 1.5.11 → 1.5.13

package/build/index.mjs

@@ -1,6 +1,6 @@
+import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, and, resolveDocuments, str, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, and, resolveDocuments, str, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
@@ -18,12 +18,32 @@ const GLOBAL_CONFIG = {
      * Default: 5 candles (last 5 minutes when using 1m interval)
      */
     CC_AVG_PRICE_CANDLES_COUNT: 5,
+    /**
+     * Slippage percentage applied to entry and exit prices.
+     * Simulates market impact and order book depth.
+     * Applied twice (entry and exit) for realistic execution simulation.
+     * Default: 0.1% per transaction
+     */
+    CC_PERCENT_SLIPPAGE: 0.1,
+    /**
+     * Fee percentage charged per transaction.
+     * Applied twice (entry and exit) for total fee calculation.
+     * Default: 0.1% per transaction (total 0.2%)
+     */
+    CC_PERCENT_FEE: 0.1,
     /**
      * Minimum TakeProfit distance from priceOpen (percentage)
-     * Must be greater than trading fees to ensure profitable trades
-     * Default: 0.3% (covers 2×0.1% fees + minimum profit margin)
+     * Must be greater than (slippage + fees) to ensure profitable trades
+     *
+     * Calculation:
+     * - Slippage effect: ~0.2% (0.1% × 2 transactions)
+     * - Fees: 0.2% (0.1% × 2 transactions)
+     * - Minimum profit buffer: 0.1%
+     * - Total: 0.5%
+     *
+     * Default: 0.5% (covers all costs + minimum profit margin)
      */
-    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: 0.3,
+    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: 0.5,
     /**
      * Minimum StopLoss distance from priceOpen (percentage)
      * Prevents signals from being immediately stopped out due to price volatility
@@ -90,6 +110,7 @@ const GLOBAL_CONFIG = {
      */
     CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: 5,
 };
+const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
 const { init, inject, provide } = createActivator("backtest");
 
@@ -186,6 +207,7 @@ const validationServices$1 = {
     sizingValidationService: Symbol('sizingValidationService'),
     riskValidationService: Symbol('riskValidationService'),
     optimizerValidationService: Symbol('optimizerValidationService'),
+    configValidationService: Symbol('configValidationService'),
 };
 const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
@@ -715,16 +737,6 @@ class ExchangeConnectionService {
     }
 }
 
-/**
- * Slippage percentage applied to entry and exit prices.
- * Simulates market impact and order book depth.
- */
-const PERCENT_SLIPPAGE = 0.1;
-/**
- * Fee percentage charged per transaction.
- * Applied twice (entry and exit) for total fee calculation.
- */
-const PERCENT_FEE = 0.1;
 /**
  * Calculates profit/loss for a closed signal with slippage and fees.
  *
@@ -760,16 +772,16 @@ const toProfitLossDto = (signal, priceClose) => {
     let priceCloseWithSlippage;
     if (signal.position === "long") {
         // LONG: покупаем дороже, продаем дешевле
-        priceOpenWithSlippage = priceOpen * (1 + PERCENT_SLIPPAGE / 100);
-        priceCloseWithSlippage = priceClose * (1 - PERCENT_SLIPPAGE / 100);
+        priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
     }
     else {
         // SHORT: продаем дешевле, покупаем дороже
-        priceOpenWithSlippage = priceOpen * (1 - PERCENT_SLIPPAGE / 100);
-        priceCloseWithSlippage = priceClose * (1 + PERCENT_SLIPPAGE / 100);
+        priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
     }
     // Применяем комиссию дважды (при открытии и закрытии)
-    const totalFee = PERCENT_FEE * 2;
+    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
     let pnlPercentage;
     if (signal.position === "long") {
         // LONG: прибыль при росте цены
@@ -8682,8 +8694,27 @@ class HeatMarkdownService {
 }
 
 /**
- * @class ExchangeValidationService
- * Service for managing and validating exchange configurations
+ * Service for managing and validating exchange configurations.
+ *
+ * Maintains a registry of all configured exchanges and validates
+ * their existence before operations. Uses memoization for performance.
+ *
+ * Key features:
+ * - Registry management: addExchange() to register new exchanges
+ * - Validation: validate() ensures exchange exists before use
+ * - Memoization: validation results are cached for performance
+ * - Listing: list() returns all registered exchanges
+ *
+ * @throws {Error} If duplicate exchange name is added
+ * @throws {Error} If unknown exchange is referenced
+ *
+ * @example
+ * ```typescript
+ * const exchangeValidation = new ExchangeValidationService();
+ * exchangeValidation.addExchange("binance", binanceSchema);
+ * exchangeValidation.validate("binance", "backtest"); // OK
+ * exchangeValidation.validate("unknown", "live"); // Throws error
+ * ```
  */
 class ExchangeValidationService {
     constructor() {
@@ -8743,8 +8774,29 @@ class ExchangeValidationService {
 }
 
 /**
- * @class StrategyValidationService
- * Service for managing and validating strategy configurations
+ * Service for managing and validating trading strategy configurations.
+ *
+ * Maintains a registry of all configured strategies, validates their existence
+ * before operations, and ensures associated risk profiles are valid.
+ * Uses memoization for performance.
+ *
+ * Key features:
+ * - Registry management: addStrategy() to register new strategies
+ * - Dual validation: validates both strategy existence and risk profile (if configured)
+ * - Memoization: validation results are cached for performance
+ * - Listing: list() returns all registered strategies
+ *
+ * @throws {Error} If duplicate strategy name is added
+ * @throws {Error} If unknown strategy is referenced
+ * @throws {Error} If strategy's risk profile doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const strategyValidation = new StrategyValidationService();
+ * strategyValidation.addStrategy("momentum-btc", { ...schema, riskName: "conservative" });
+ * strategyValidation.validate("momentum-btc", "backtest"); // Validates strategy + risk
+ * strategyValidation.validate("unknown", "live"); // Throws error
+ * ```
  */
 class StrategyValidationService {
     constructor() {
@@ -8815,8 +8867,27 @@ class StrategyValidationService {
 }
 
 /**
- * @class FrameValidationService
- * Service for managing and validating frame configurations
+ * Service for managing and validating frame (timeframe) configurations.
+ *
+ * Maintains a registry of all configured frames and validates
+ * their existence before operations. Uses memoization for performance.
+ *
+ * Key features:
+ * - Registry management: addFrame() to register new timeframes
+ * - Validation: validate() ensures frame exists before use
+ * - Memoization: validation results are cached for performance
+ * - Listing: list() returns all registered frames
+ *
+ * @throws {Error} If duplicate frame name is added
+ * @throws {Error} If unknown frame is referenced
+ *
+ * @example
+ * ```typescript
+ * const frameValidation = new FrameValidationService();
+ * frameValidation.addFrame("2024-Q1", frameSchema);
+ * frameValidation.validate("2024-Q1", "backtest"); // OK
+ * frameValidation.validate("unknown", "live"); // Throws error
+ * ```
  */
 class FrameValidationService {
     constructor() {
@@ -8876,8 +8947,29 @@ class FrameValidationService {
 }
 
 /**
- * @class WalkerValidationService
- * Service for managing and validating walker configurations
+ * Service for managing and validating walker (parameter sweep) configurations.
+ *
+ * Maintains a registry of all configured walkers and validates
+ * their existence before operations. Uses memoization for performance.
+ *
+ * Walkers define parameter ranges for optimization and hyperparameter tuning.
+ *
+ * Key features:
+ * - Registry management: addWalker() to register new walker configurations
+ * - Validation: validate() ensures walker exists before use
+ * - Memoization: validation results are cached for performance
+ * - Listing: list() returns all registered walkers
+ *
+ * @throws {Error} If duplicate walker name is added
+ * @throws {Error} If unknown walker is referenced
+ *
+ * @example
+ * ```typescript
+ * const walkerValidation = new WalkerValidationService();
+ * walkerValidation.addWalker("rsi-sweep", walkerSchema);
+ * walkerValidation.validate("rsi-sweep", "optimizer"); // OK
+ * walkerValidation.validate("unknown", "optimizer"); // Throws error
+ * ```
  */
 class WalkerValidationService {
     constructor() {
@@ -8937,8 +9029,27 @@ class WalkerValidationService {
 }
 
 /**
- * @class SizingValidationService
- * Service for managing and validating sizing configurations
+ * Service for managing and validating position sizing configurations.
+ *
+ * Maintains a registry of all configured sizing strategies and validates
+ * their existence before operations. Uses memoization for performance.
+ *
+ * Key features:
+ * - Registry management: addSizing() to register new sizing strategies
+ * - Validation: validate() ensures sizing strategy exists before use
+ * - Memoization: validation results are cached for performance
+ * - Listing: list() returns all registered sizing strategies
+ *
+ * @throws {Error} If duplicate sizing name is added
+ * @throws {Error} If unknown sizing strategy is referenced
+ *
+ * @example
+ * ```typescript
+ * const sizingValidation = new SizingValidationService();
+ * sizingValidation.addSizing("fixed-1000", fixedSizingSchema);
+ * sizingValidation.validate("fixed-1000", "strategy-1"); // OK
+ * sizingValidation.validate("unknown", "strategy-2"); // Throws error
+ * ```
  */
 class SizingValidationService {
     constructor() {
@@ -9003,8 +9114,27 @@ class SizingValidationService {
 }
 
 /**
- * @class RiskValidationService
- * Service for managing and validating risk configurations
+ * Service for managing and validating risk management configurations.
+ *
+ * Maintains a registry of all configured risk profiles and validates
+ * their existence before operations. Uses memoization for performance.
+ *
+ * Key features:
+ * - Registry management: addRisk() to register new risk profiles
+ * - Validation: validate() ensures risk profile exists before use
+ * - Memoization: validation results are cached by riskName:source for performance
+ * - Listing: list() returns all registered risk profiles
+ *
+ * @throws {Error} If duplicate risk name is added
+ * @throws {Error} If unknown risk profile is referenced
+ *
+ * @example
+ * ```typescript
+ * const riskValidation = new RiskValidationService();
+ * riskValidation.addRisk("conservative", conservativeSchema);
+ * riskValidation.validate("conservative", "strategy-1"); // OK
+ * riskValidation.validate("unknown", "strategy-2"); // Throws error
+ * ```
  */
 class RiskValidationService {
     constructor() {
@@ -11556,6 +11686,133 @@ class OutlineMarkdownService {
     }
 }
 
+/**
+ * Service for validating GLOBAL_CONFIG parameters to ensure mathematical correctness
+ * and prevent unprofitable trading configurations.
+ *
+ * Performs comprehensive validation on:
+ * - **Percentage parameters**: Slippage, fees, and profit margins must be non-negative
+ * - **Economic viability**: Ensures CC_MIN_TAKEPROFIT_DISTANCE_PERCENT covers all trading costs
+ *   (slippage + fees) to guarantee profitable trades when TakeProfit is hit
+ * - **Range constraints**: Validates MIN < MAX relationships (e.g., StopLoss distances)
+ * - **Time-based parameters**: Ensures positive integer values for timeouts and lifetimes
+ * - **Candle parameters**: Validates retry counts, delays, and anomaly detection thresholds
+ *
+ * @throws {Error} If any validation fails, throws with detailed breakdown of all errors
+ *
+ * @example
+ * ```typescript
+ * const validator = new ConfigValidationService();
+ * validator.validate(); // Throws if config is invalid
+ * ```
+ *
+ * @example Validation failure output:
+ * ```
+ * GLOBAL_CONFIG validation failed:
+ *   1. CC_MIN_TAKEPROFIT_DISTANCE_PERCENT (0.3%) is too low to cover trading costs.
+ *      Required minimum: 0.40%
+ *      Breakdown:
+ *        - Slippage effect: 0.20% (0.1% × 2 transactions)
+ *        - Fees: 0.20% (0.1% × 2 transactions)
+ *      All TakeProfit signals will be unprofitable with current settings!
+ * ```
+ */
+class ConfigValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Validates GLOBAL_CONFIG parameters for mathematical correctness.
+         *
+         * Checks:
+         * 1. CC_MIN_TAKEPROFIT_DISTANCE_PERCENT must cover slippage + fees
+         * 2. All percentage values must be positive
+         * 3. Time/count values must be positive integers
+         *
+         * @throws Error if configuration is invalid
+         */
+        this.validate = () => {
+            this.loggerService.log("configValidationService validate");
+            const errors = [];
+            // Validate slippage and fee percentages
+            if (!Number.isFinite(GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE) || GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE < 0) {
+                errors.push(`CC_PERCENT_SLIPPAGE must be a non-negative number, got ${GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE}`);
+            }
+            if (!Number.isFinite(GLOBAL_CONFIG.CC_PERCENT_FEE) || GLOBAL_CONFIG.CC_PERCENT_FEE < 0) {
+                errors.push(`CC_PERCENT_FEE must be a non-negative number, got ${GLOBAL_CONFIG.CC_PERCENT_FEE}`);
+            }
+            // Calculate minimum required TP distance to cover costs
+            const slippageEffect = GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE * 2; // Applied twice (entry + exit)
+            const feesTotal = GLOBAL_CONFIG.CC_PERCENT_FEE * 2; // Applied twice (entry + exit)
+            const minRequiredTpDistance = slippageEffect + feesTotal;
+            // Validate CC_MIN_TAKEPROFIT_DISTANCE_PERCENT
+            if (!Number.isFinite(GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) || GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT <= 0) {
+                errors.push(`CC_MIN_TAKEPROFIT_DISTANCE_PERCENT must be a positive number, got ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}`);
+            }
+            else if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT < minRequiredTpDistance) {
+                errors.push(`CC_MIN_TAKEPROFIT_DISTANCE_PERCENT (${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}%) is too low to cover trading costs.\n` +
+                    `  Required minimum: ${minRequiredTpDistance.toFixed(2)}%\n` +
+                    `  Breakdown:\n` +
+                    `    - Slippage effect: ${slippageEffect.toFixed(2)}% (${GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE}% × 2 transactions)\n` +
+                    `    - Fees: ${feesTotal.toFixed(2)}% (${GLOBAL_CONFIG.CC_PERCENT_FEE}% × 2 transactions)\n` +
+                    `  All TakeProfit signals will be unprofitable with current settings!`);
+            }
+            // Validate CC_MIN_STOPLOSS_DISTANCE_PERCENT
+            if (!Number.isFinite(GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) || GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT <= 0) {
+                errors.push(`CC_MIN_STOPLOSS_DISTANCE_PERCENT must be a positive number, got ${GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT}`);
+            }
+            // Validate CC_MAX_STOPLOSS_DISTANCE_PERCENT
+            if (!Number.isFinite(GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) || GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT <= 0) {
+                errors.push(`CC_MAX_STOPLOSS_DISTANCE_PERCENT must be a positive number, got ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}`);
+            }
+            // Validate that MIN < MAX for StopLoss
+            if (Number.isFinite(GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) &&
+                Number.isFinite(GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) &&
+                GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT >= GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
+                errors.push(`CC_MIN_STOPLOSS_DISTANCE_PERCENT (${GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT}%) must be less than ` +
+                    `CC_MAX_STOPLOSS_DISTANCE_PERCENT (${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}%)`);
+            }
+            // Validate time-based parameters
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES) || GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES <= 0) {
+                errors.push(`CC_SCHEDULE_AWAIT_MINUTES must be a positive integer, got ${GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES}`);
+            }
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) || GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES <= 0) {
+                errors.push(`CC_MAX_SIGNAL_LIFETIME_MINUTES must be a positive integer, got ${GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES}`);
+            }
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS) || GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS <= 0) {
+                errors.push(`CC_MAX_SIGNAL_GENERATION_SECONDS must be a positive integer, got ${GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS}`);
+            }
+            // Validate candle-based parameters
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT) || GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT <= 0) {
+                errors.push(`CC_AVG_PRICE_CANDLES_COUNT must be a positive integer, got ${GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT}`);
+            }
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT) || GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT < 0) {
+                errors.push(`CC_GET_CANDLES_RETRY_COUNT must be a non-negative integer, got ${GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT}`);
+            }
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS) || GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS < 0) {
+                errors.push(`CC_GET_CANDLES_RETRY_DELAY_MS must be a non-negative integer, got ${GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS}`);
+            }
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR) || GLOBAL_CONFIG.CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR <= 0) {
+                errors.push(`CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR must be a positive integer, got ${GLOBAL_CONFIG.CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR}`);
+            }
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN) || GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN <= 0) {
+                errors.push(`CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN must be a positive integer, got ${GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN}`);
+            }
+            // Throw aggregated errors if any
+            if (errors.length > 0) {
+                const errorMessage = `GLOBAL_CONFIG validation failed:\n${errors.map((e, i) => `  ${i + 1}. ${e}`).join('\n')}`;
+                this.loggerService.warn(errorMessage);
+                throw new Error(errorMessage);
+            }
+            this.loggerService.log("configValidationService validation passed");
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -11623,6 +11880,7 @@ class OutlineMarkdownService {
     provide(TYPES.sizingValidationService, () => new SizingValidationService());
     provide(TYPES.riskValidationService, () => new RiskValidationService());
     provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
+    provide(TYPES.configValidationService, () => new ConfigValidationService());
 }
 {
     provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
@@ -11695,6 +11953,7 @@ const validationServices = {
     sizingValidationService: inject(TYPES.sizingValidationService),
     riskValidationService: inject(TYPES.riskValidationService),
     optimizerValidationService: inject(TYPES.optimizerValidationService),
+    configValidationService: inject(TYPES.configValidationService),
 };
 const templateServices = {
     optimizerTemplateService: inject(TYPES.optimizerTemplateService),
@@ -11732,7 +11991,7 @@ var backtest$1 = backtest;
  * });
  * ```
  */
-async function setLogger(logger) {
+function setLogger(logger) {
     backtest$1.loggerService.setLogger(logger);
 }
 /**
@@ -11746,8 +12005,51 @@ async function setLogger(logger) {
  * });
  * ```
  */
-async function setConfig(config) {
-    Object.assign(GLOBAL_CONFIG, config);
+function setConfig(config, _unsafe) {
+    const prevConfig = Object.assign({}, GLOBAL_CONFIG);
+    try {
+        Object.assign(GLOBAL_CONFIG, config);
+        !_unsafe && backtest$1.configValidationService.validate();
+    }
+    catch (error) {
+        console.warn(`backtest-kit setConfig failed: ${getErrorMessage(error)}`, config);
+        Object.assign(GLOBAL_CONFIG, prevConfig);
+        throw error;
+    }
+}
+/**
+ * Retrieves a copy of the current global configuration.
+ *
+ * Returns a shallow copy of the current GLOBAL_CONFIG to prevent accidental mutations.
+ * Use this to inspect the current configuration state without modifying it.
+ *
+ * @returns {GlobalConfig} A copy of the current global configuration object
+ *
+ * @example
+ * ```typescript
+ * const currentConfig = getConfig();
+ * console.log(currentConfig.CC_SCHEDULE_AWAIT_MINUTES);
+ * ```
+ */
+function getConfig() {
+    return Object.assign({}, GLOBAL_CONFIG);
+}
+/**
+ * Retrieves the default configuration object for the framework.
+ *
+ * Returns a reference to the default configuration with all preset values.
+ * Use this to see what configuration options are available and their default values.
+ *
+ * @returns {GlobalConfig} The default configuration object
+ *
+ * @example
+ * ```typescript
+ * const defaultConfig = getDefaultConfig();
+ * console.log(defaultConfig.CC_SCHEDULE_AWAIT_MINUTES);
+ * ```
+ */
+function getDefaultConfig() {
+    return DEFAULT_CONFIG;
 }
 
 const ADD_STRATEGY_METHOD_NAME = "add.addStrategy";
@@ -13496,6 +13798,8 @@ class BacktestInstance {
     constructor(symbol, strategyName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
+        /** A randomly generated string. */
+        this.id = randomString();
         /** Internal flag indicating if backtest was stopped manually */
         this._isStopped = false;
         /** Internal flag indicating if backtest task completed */
@@ -13532,6 +13836,7 @@ class BacktestInstance {
         this.getStatus = async () => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_STATUS);
             return {
+                id: this.id,
                 symbol: this.symbol,
                 strategyName: this.strategyName,
                 status: this.task.getStatus(),
@@ -13982,6 +14287,8 @@ class LiveInstance {
     constructor(symbol, strategyName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
+        /** A randomly generated string. */
+        this.id = randomString();
         /** Internal flag indicating if live trading was stopped manually */
         this._isStopped = false;
         /** Internal flag indicating if live trading task completed */
@@ -14018,6 +14325,7 @@ class LiveInstance {
         this.getStatus = async () => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_STATUS);
             return {
+                id: this.id,
                 symbol: this.symbol,
                 strategyName: this.strategyName,
                 status: this.task.getStatus(),
@@ -14730,6 +15038,8 @@ class WalkerInstance {
     constructor(symbol, walkerName) {
         this.symbol = symbol;
         this.walkerName = walkerName;
+        /** A randomly generated string. */
+        this.id = randomString();
         /** Internal flag indicating if walker was stopped manually */
         this._isStopped = false;
         /** Internal flag indicating if walker task completed */
@@ -14766,6 +15076,7 @@ class WalkerInstance {
         this.getStatus = async () => {
             backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_STATUS);
             return {
+                id: this.id,
                 symbol: this.symbol,
                 walkerName: this.walkerName,
                 status: this.task.getStatus(),
@@ -15827,4 +16138,4 @@ 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, getDate, 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 };
+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 };

package/package.json

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