backtest-kit 1.5.12 → 1.5.14

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");
 
@@ -146,10 +167,12 @@ const schemaServices$1 = {
     riskSchemaService: Symbol('riskSchemaService'),
     optimizerSchemaService: Symbol('optimizerSchemaService'),
 };
+const coreServices$1 = {
+    exchangeCoreService: Symbol('exchangeCoreService'),
+    strategyCoreService: Symbol('strategyCoreService'),
+    frameCoreService: Symbol('frameCoreService'),
+};
 const globalServices$1 = {
-    exchangeGlobalService: Symbol('exchangeGlobalService'),
-    strategyGlobalService: Symbol('strategyGlobalService'),
-    frameGlobalService: Symbol('frameGlobalService'),
     sizingGlobalService: Symbol('sizingGlobalService'),
     riskGlobalService: Symbol('riskGlobalService'),
     optimizerGlobalService: Symbol('optimizerGlobalService'),
@@ -188,6 +211,7 @@ const validationServices$1 = {
     sizingValidationService: Symbol('sizingValidationService'),
     riskValidationService: Symbol('riskValidationService'),
     optimizerValidationService: Symbol('optimizerValidationService'),
+    configValidationService: Symbol('configValidationService'),
 };
 const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
@@ -197,6 +221,7 @@ const TYPES = {
     ...contextServices$1,
     ...connectionServices$1,
     ...schemaServices$1,
+    ...coreServices$1,
     ...globalServices$1,
     ...commandServices$1,
     ...logicPrivateServices$1,
@@ -717,16 +742,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 +777,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: прибыль при росте цены
@@ -1989,15 +2004,6 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         self._lastSignalTimestamp = currentTime;
     }
     const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        symbol: self.params.execution.context.symbol,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        currentPrice,
-        timestamp: currentTime,
-    }))) {
-        return null;
-    }
     const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
     const signal = await Promise.race([
         self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when),
@@ -2012,6 +2018,16 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     if (self._isStopped) {
         return null;
     }
+    if (await functoolsKit.not(self.params.risk.checkSignal({
+        pendingSignal: signal,
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        currentPrice,
+        timestamp: currentTime,
+    }))) {
+        return null;
+    }
     // Если priceOpen указан - проверяем нужно ли ждать активации или открыть сразу
     if (signal.priceOpen !== undefined) {
         // КРИТИЧЕСКАЯ ПРОВЕРКА: достигнут ли priceOpen?
@@ -2243,6 +2259,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
     });
     if (await functoolsKit.not(self.params.risk.checkSignal({
         symbol: self.params.execution.context.symbol,
+        pendingSignal: scheduled,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         currentPrice: scheduled.priceOpen,
@@ -2326,6 +2343,7 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
 };
 const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
     if (await functoolsKit.not(self.params.risk.checkSignal({
+        pendingSignal: signal,
         symbol: self.params.execution.context.symbol,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
@@ -2552,6 +2570,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         pendingAt: activationTime,
     });
     if (await functoolsKit.not(self.params.risk.checkSignal({
+        pendingSignal: scheduled,
         symbol: self.params.execution.context.symbol,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
@@ -4013,7 +4032,7 @@ class RiskConnectionService {
     }
 }
 
-const METHOD_NAME_VALIDATE$1 = "exchangeGlobalService validate";
+const METHOD_NAME_VALIDATE$1 = "exchangeCoreService validate";
 /**
  * Global service for exchange operations with execution context injection.
  *
@@ -4022,7 +4041,7 @@ const METHOD_NAME_VALIDATE$1 = "exchangeGlobalService validate";
  *
  * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
  */
-class ExchangeGlobalService {
+class ExchangeCoreService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
@@ -4052,13 +4071,16 @@ class ExchangeGlobalService {
          * @returns Promise resolving to array of candles
          */
         this.getCandles = async (symbol, interval, limit, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService getCandles", {
+            this.loggerService.log("exchangeCoreService getCandles", {
                 symbol,
                 interval,
                 limit,
                 when,
                 backtest,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService getCandles requires a method context");
+            }
             await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.getCandles(symbol, interval, limit);
@@ -4079,13 +4101,16 @@ class ExchangeGlobalService {
          * @returns Promise resolving to array of future candles
          */
         this.getNextCandles = async (symbol, interval, limit, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService getNextCandles", {
+            this.loggerService.log("exchangeCoreService getNextCandles", {
                 symbol,
                 interval,
                 limit,
                 when,
                 backtest,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService getNextCandles requires a method context");
+            }
             await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.getNextCandles(symbol, interval, limit);
@@ -4104,11 +4129,14 @@ class ExchangeGlobalService {
          * @returns Promise resolving to VWAP price
          */
         this.getAveragePrice = async (symbol, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService getAveragePrice", {
+            this.loggerService.log("exchangeCoreService getAveragePrice", {
                 symbol,
                 when,
                 backtest,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService getAveragePrice requires a method context");
+            }
             await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.getAveragePrice(symbol);
@@ -4128,12 +4156,15 @@ class ExchangeGlobalService {
          * @returns Promise resolving to formatted price string
          */
         this.formatPrice = async (symbol, price, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService formatPrice", {
+            this.loggerService.log("exchangeCoreService formatPrice", {
                 symbol,
                 price,
                 when,
                 backtest,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService formatPrice requires a method context");
+            }
             await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.formatPrice(symbol, price);
@@ -4153,12 +4184,15 @@ class ExchangeGlobalService {
          * @returns Promise resolving to formatted quantity string
          */
         this.formatQuantity = async (symbol, quantity, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService formatQuantity", {
+            this.loggerService.log("exchangeCoreService formatQuantity", {
                 symbol,
                 quantity,
                 when,
                 backtest,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService formatQuantity requires a method context");
+            }
             await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.formatQuantity(symbol, quantity);
@@ -4171,7 +4205,7 @@ class ExchangeGlobalService {
     }
 }
 
-const METHOD_NAME_VALIDATE = "strategyGlobalService validate";
+const METHOD_NAME_VALIDATE = "strategyCoreService validate";
 /**
  * Global service for strategy operations with execution context injection.
  *
@@ -4180,7 +4214,7 @@ const METHOD_NAME_VALIDATE = "strategyGlobalService validate";
  *
  * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
  */
-class StrategyGlobalService {
+class StrategyCoreService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.strategyConnectionService = inject(TYPES.strategyConnectionService);
@@ -4218,10 +4252,13 @@ class StrategyGlobalService {
          * @returns Promise resolving to pending signal or null
          */
         this.getPendingSignal = async (symbol, strategyName) => {
-            this.loggerService.log("strategyGlobalService getPendingSignal", {
+            this.loggerService.log("strategyCoreService getPendingSignal", {
                 symbol,
                 strategyName,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("strategyCoreService getPendingSignal requires a method context");
+            }
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getPendingSignal(symbol, strategyName);
         };
@@ -4236,10 +4273,13 @@ class StrategyGlobalService {
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
         this.getStopped = async (symbol, strategyName) => {
-            this.loggerService.log("strategyGlobalService getStopped", {
+            this.loggerService.log("strategyCoreService getStopped", {
                 symbol,
                 strategyName,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("strategyCoreService getStopped requires a method context");
+            }
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getStopped(symbol, strategyName);
         };
@@ -4255,11 +4295,14 @@ class StrategyGlobalService {
          * @returns Discriminated union of tick result (idle, opened, active, closed)
          */
         this.tick = async (symbol, when, backtest) => {
-            this.loggerService.log("strategyGlobalService tick", {
+            this.loggerService.log("strategyCoreService tick", {
                 symbol,
                 when,
                 backtest,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("strategyCoreService tick requires a method context");
+            }
             const strategyName = this.methodContextService.context.strategyName;
             await this.validate(symbol, strategyName);
             return await ExecutionContextService.runInContext(async () => {
@@ -4283,12 +4326,15 @@ class StrategyGlobalService {
          * @returns Closed signal result with PNL
          */
         this.backtest = async (symbol, candles, when, backtest) => {
-            this.loggerService.log("strategyGlobalService backtest", {
+            this.loggerService.log("strategyCoreService backtest", {
                 symbol,
                 candleCount: candles.length,
                 when,
                 backtest,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("strategyCoreService backtest requires a method context");
+            }
             const strategyName = this.methodContextService.context.strategyName;
             await this.validate(symbol, strategyName);
             return await ExecutionContextService.runInContext(async () => {
@@ -4310,7 +4356,7 @@ class StrategyGlobalService {
          * @returns Promise that resolves when stop flag is set
          */
         this.stop = async (ctx, backtest) => {
-            this.loggerService.log("strategyGlobalService stop", {
+            this.loggerService.log("strategyCoreService stop", {
                 ctx,
                 backtest,
             });
@@ -4326,7 +4372,7 @@ class StrategyGlobalService {
          * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
         this.clear = async (ctx) => {
-            this.loggerService.log("strategyGlobalService clear", {
+            this.loggerService.log("strategyCoreService clear", {
                 ctx,
             });
             if (ctx) {
@@ -4337,14 +4383,14 @@ class StrategyGlobalService {
     }
 }
 
-const METHOD_NAME_GET_TIMEFRAME = "frameGlobalService getTimeframe";
+const METHOD_NAME_GET_TIMEFRAME = "frameCoreService getTimeframe";
 /**
  * Global service for frame operations.
  *
  * Wraps FrameConnectionService for timeframe generation.
  * Used internally by BacktestLogicPrivateService.
  */
-class FrameGlobalService {
+class FrameCoreService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.frameConnectionService = inject(TYPES.frameConnectionService);
@@ -4360,6 +4406,9 @@ class FrameGlobalService {
                 frameName,
                 symbol,
             });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("frameCoreService getTimeframe requires a method context");
+            }
             this.frameValidationService.validate(frameName, METHOD_NAME_GET_TIMEFRAME);
             return await this.frameConnectionService.getTimeframe(symbol, frameName);
         };
@@ -4965,9 +5014,9 @@ class WalkerSchemaService {
 class BacktestLogicPrivateService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.strategyGlobalService = inject(TYPES.strategyGlobalService);
-        this.exchangeGlobalService = inject(TYPES.exchangeGlobalService);
-        this.frameGlobalService = inject(TYPES.frameGlobalService);
+        this.strategyCoreService = inject(TYPES.strategyCoreService);
+        this.exchangeCoreService = inject(TYPES.exchangeCoreService);
+        this.frameCoreService = inject(TYPES.frameCoreService);
         this.methodContextService = inject(TYPES.methodContextService);
     }
     /**
@@ -4989,7 +5038,7 @@ class BacktestLogicPrivateService {
             symbol,
         });
         const backtestStartTime = performance.now();
-        const timeframes = await this.frameGlobalService.getTimeframe(symbol, this.methodContextService.context.frameName);
+        const timeframes = await this.frameCoreService.getTimeframe(symbol, this.methodContextService.context.frameName);
         const totalFrames = timeframes.length;
         let i = 0;
         let previousEventTimestamp = null;
@@ -5008,7 +5057,7 @@ class BacktestLogicPrivateService {
                 });
             }
             // Check if strategy should stop before processing next frame
-            if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+            if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (before tick)", {
                     symbol,
                     when: when.toISOString(),
@@ -5019,7 +5068,7 @@ class BacktestLogicPrivateService {
             }
             let result;
             try {
-                result = await this.strategyGlobalService.tick(symbol, when, true);
+                result = await this.strategyCoreService.tick(symbol, when, true);
             }
             catch (error) {
                 console.warn(`backtestLogicPrivateService tick failed, skipping timeframe when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -5033,7 +5082,7 @@ class BacktestLogicPrivateService {
                 continue;
             }
             // Check if strategy should stop when idle (no active signal)
-            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
                     symbol,
                     when: when.toISOString(),
@@ -5063,7 +5112,7 @@ class BacktestLogicPrivateService {
                 const candlesNeeded = bufferMinutes + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
                 let candles;
                 try {
-                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
+                    candles = await this.exchangeCoreService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
                 }
                 catch (error) {
                     console.warn(`backtestLogicPrivateService getNextCandles failed for scheduled signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -5092,7 +5141,7 @@ class BacktestLogicPrivateService {
                 // и если активируется - продолжит с TP/SL мониторингом
                 let backtestResult;
                 try {
-                    backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                    backtestResult = await this.strategyCoreService.backtest(symbol, candles, when, true);
                 }
                 catch (error) {
                     console.warn(`backtestLogicPrivateService backtest failed for scheduled signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -5135,7 +5184,7 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after scheduled signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -5162,7 +5211,7 @@ class BacktestLogicPrivateService {
                 const totalCandles = signal.minuteEstimatedTime + bufferMinutes;
                 let candles;
                 try {
-                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", totalCandles, bufferStartTime, true);
+                    candles = await this.exchangeCoreService.getNextCandles(symbol, "1m", totalCandles, bufferStartTime, true);
                 }
                 catch (error) {
                     console.warn(`backtestLogicPrivateService getNextCandles failed for opened signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -5189,7 +5238,7 @@ class BacktestLogicPrivateService {
                 // Вызываем backtest - всегда возвращает closed
                 let backtestResult;
                 try {
-                    backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                    backtestResult = await this.strategyCoreService.backtest(symbol, candles, when, true);
                 }
                 catch (error) {
                     console.warn(`backtestLogicPrivateService backtest failed for opened signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -5228,7 +5277,7 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -5302,7 +5351,7 @@ const TICK_TTL = 1 * 60 * 1000 + 1;
 class LiveLogicPrivateService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.strategyGlobalService = inject(TYPES.strategyGlobalService);
+        this.strategyCoreService = inject(TYPES.strategyCoreService);
         this.methodContextService = inject(TYPES.methodContextService);
     }
     /**
@@ -5337,7 +5386,7 @@ class LiveLogicPrivateService {
             const when = new Date();
             let result;
             try {
-                result = await this.strategyGlobalService.tick(symbol, when, false);
+                result = await this.strategyCoreService.tick(symbol, when, false);
             }
             catch (error) {
                 console.warn(`backtestLogicPrivateService tick failed when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -5371,7 +5420,7 @@ class LiveLogicPrivateService {
             previousEventTimestamp = currentTimestamp;
             // Check if strategy should stop when idle (no active signal)
             if (result.action === "idle") {
-                if (await functoolsKit.and(Promise.resolve(true), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                if (await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (idle state)", {
                         symbol,
                         when: when.toISOString(),
@@ -5393,7 +5442,7 @@ class LiveLogicPrivateService {
             yield result;
             // Check if strategy should stop after signal is closed
             if (result.action === "closed") {
-                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: result.signal.id,
@@ -8684,8 +8733,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 +8813,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 +8906,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 +8986,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 +9068,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 +9153,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 +11725,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());
 }
@@ -11584,9 +11878,11 @@ class OutlineMarkdownService {
     provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
 }
 {
-    provide(TYPES.exchangeGlobalService, () => new ExchangeGlobalService());
-    provide(TYPES.strategyGlobalService, () => new StrategyGlobalService());
-    provide(TYPES.frameGlobalService, () => new FrameGlobalService());
+    provide(TYPES.exchangeCoreService, () => new ExchangeCoreService());
+    provide(TYPES.strategyCoreService, () => new StrategyCoreService());
+    provide(TYPES.frameCoreService, () => new FrameCoreService());
+}
+{
     provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
     provide(TYPES.riskGlobalService, () => new RiskGlobalService());
     provide(TYPES.optimizerGlobalService, () => new OptimizerGlobalService());
@@ -11625,6 +11921,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());
@@ -11655,10 +11952,12 @@ const schemaServices = {
     riskSchemaService: inject(TYPES.riskSchemaService),
     optimizerSchemaService: inject(TYPES.optimizerSchemaService),
 };
+const coreServices = {
+    exchangeCoreService: inject(TYPES.exchangeCoreService),
+    strategyCoreService: inject(TYPES.strategyCoreService),
+    frameCoreService: inject(TYPES.frameCoreService),
+};
 const globalServices = {
-    exchangeGlobalService: inject(TYPES.exchangeGlobalService),
-    strategyGlobalService: inject(TYPES.strategyGlobalService),
-    frameGlobalService: inject(TYPES.frameGlobalService),
     sizingGlobalService: inject(TYPES.sizingGlobalService),
     riskGlobalService: inject(TYPES.riskGlobalService),
     optimizerGlobalService: inject(TYPES.optimizerGlobalService),
@@ -11697,6 +11996,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),
@@ -11706,6 +12006,7 @@ const backtest = {
     ...contextServices,
     ...connectionServices,
     ...schemaServices,
+    ...coreServices,
     ...globalServices,
     ...commandServices,
     ...logicPrivateServices,
@@ -11734,12 +12035,13 @@ var backtest$1 = backtest;
  * });
  * ```
  */
-async function setLogger(logger) {
+function setLogger(logger) {
     backtest$1.loggerService.setLogger(logger);
 }
 /**
  * Sets global configuration parameters for the framework.
  * @param config - Partial configuration object to override default settings
+ * @param _unsafe - Skip config validations - required for testbed
  *
  * @example
  * ```typescript
@@ -11748,8 +12050,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";
@@ -13559,7 +13904,7 @@ class BacktestInstance {
                 backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyGlobalService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear({ symbol, strategyName: context.strategyName });
             }
             {
                 const { riskName } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -13594,8 +13939,8 @@ class BacktestInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, true);
-                backtest$1.strategyGlobalService
+                backtest$1.strategyCoreService.stop({ symbol, strategyName: context.strategyName }, true);
+                backtest$1.strategyCoreService
                     .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
@@ -13636,7 +13981,7 @@ class BacktestInstance {
                 symbol,
                 strategyName,
             });
-            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+            await backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
         };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
@@ -14051,7 +14396,7 @@ class LiveInstance {
                 backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyGlobalService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear({ symbol, strategyName: context.strategyName });
             }
             {
                 const { riskName } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -14086,8 +14431,8 @@ class LiveInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, false);
-                backtest$1.strategyGlobalService
+                backtest$1.strategyCoreService.stop({ symbol, strategyName: context.strategyName }, false);
+                backtest$1.strategyCoreService
                     .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
@@ -14128,7 +14473,7 @@ class LiveInstance {
                 symbol,
                 strategyName,
             });
-            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, false);
+            await backtest$1.strategyCoreService.stop({ symbol, strategyName }, false);
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
@@ -14809,7 +15154,7 @@ class WalkerInstance {
                     backtest$1.scheduleMarkdownService.clear({ symbol, strategyName });
                 }
                 {
-                    backtest$1.strategyGlobalService.clear({ symbol, strategyName });
+                    backtest$1.strategyCoreService.clear({ symbol, strategyName });
                 }
                 {
                     const { riskName } = backtest$1.strategySchemaService.get(strategyName);
@@ -14849,7 +15194,7 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+                    backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
                     walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
                 }
                 if (!this._isDone) {
@@ -14895,7 +15240,7 @@ class WalkerInstance {
             const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName });
-                await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+                await backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
             }
         };
         /**
@@ -15868,7 +16213,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;