backtest-kit 1.5.11 → 1.5.13

package/build/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
+var functoolsKit = require('functools-kit');
 var diKit = require('di-kit');
 var diScoped = require('di-scoped');
-var functoolsKit = require('functools-kit');
 var fs = require('fs/promises');
 var path = require('path');
 var crypto = require('crypto');
@@ -20,12 +20,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
@@ -92,6 +112,7 @@ const GLOBAL_CONFIG = {
      */
     CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: 5,
 };
+const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
 const { init, inject, provide } = diKit.createActivator("backtest");
 
@@ -188,6 +209,7 @@ const validationServices$1 = {
     sizingValidationService: Symbol('sizingValidationService'),
     riskValidationService: Symbol('riskValidationService'),
     optimizerValidationService: Symbol('optimizerValidationService'),
+    configValidationService: Symbol('configValidationService'),
 };
 const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
@@ -717,16 +739,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.
  *
@@ -762,16 +774,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: прибыль при росте цены
@@ -8684,8 +8696,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() {
@@ -8745,8 +8776,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() {
@@ -8817,8 +8869,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() {
@@ -8878,8 +8949,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() {
@@ -8939,8 +9031,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() {
@@ -9005,8 +9116,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() {
@@ -11558,6 +11688,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());
 }
@@ -11625,6 +11882,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());
@@ -11697,6 +11955,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),
@@ -11734,7 +11993,7 @@ var backtest$1 = backtest;
  * });
  * ```
  */
-async function setLogger(logger) {
+function setLogger(logger) {
     backtest$1.loggerService.setLogger(logger);
 }
 /**
@@ -11748,8 +12007,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: ${functoolsKit.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";
@@ -13498,6 +13800,8 @@ class BacktestInstance {
     constructor(symbol, strategyName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
+        /** A randomly generated string. */
+        this.id = functoolsKit.randomString();
         /** Internal flag indicating if backtest was stopped manually */
         this._isStopped = false;
         /** Internal flag indicating if backtest task completed */
@@ -13534,6 +13838,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(),
@@ -13984,6 +14289,8 @@ class LiveInstance {
     constructor(symbol, strategyName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
+        /** A randomly generated string. */
+        this.id = functoolsKit.randomString();
         /** Internal flag indicating if live trading was stopped manually */
         this._isStopped = false;
         /** Internal flag indicating if live trading task completed */
@@ -14020,6 +14327,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(),
@@ -14732,6 +15040,8 @@ class WalkerInstance {
     constructor(symbol, walkerName) {
         this.symbol = symbol;
         this.walkerName = walkerName;
+        /** A randomly generated string. */
+        this.id = functoolsKit.randomString();
         /** Internal flag indicating if walker was stopped manually */
         this._isStopped = false;
         /** Internal flag indicating if walker task completed */
@@ -14768,6 +15078,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(),
@@ -15859,7 +16170,9 @@ exports.formatPrice = formatPrice;
 exports.formatQuantity = formatQuantity;
 exports.getAveragePrice = getAveragePrice;
 exports.getCandles = getCandles;
+exports.getConfig = getConfig;
 exports.getDate = getDate;
+exports.getDefaultConfig = getDefaultConfig;
 exports.getMode = getMode;
 exports.lib = backtest;
 exports.listExchanges = listExchanges;