backtest-kit 1.5.13 → 1.5.14

package/build/index.cjs

@@ -167,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'),
@@ -219,6 +221,7 @@ const TYPES = {
     ...contextServices$1,
     ...connectionServices$1,
     ...schemaServices$1,
+    ...coreServices$1,
     ...globalServices$1,
     ...commandServices$1,
     ...logicPrivateServices$1,
@@ -2001,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),
@@ -2024,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?
@@ -2255,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,
@@ -2338,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,
@@ -2564,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,
@@ -4025,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.
  *
@@ -4034,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);
@@ -4064,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);
@@ -4091,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);
@@ -4116,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);
@@ -4140,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);
@@ -4165,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);
@@ -4183,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.
  *
@@ -4192,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);
@@ -4230,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);
         };
@@ -4248,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);
         };
@@ -4267,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 () => {
@@ -4295,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 () => {
@@ -4322,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,
             });
@@ -4338,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) {
@@ -4349,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);
@@ -4372,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);
         };
@@ -4977,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);
     }
     /**
@@ -5001,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;
@@ -5020,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(),
@@ -5031,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}`);
@@ -5045,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(),
@@ -5075,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}`);
@@ -5104,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}`);
@@ -5147,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,
@@ -5174,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}`);
@@ -5201,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}`);
@@ -5240,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,
@@ -5314,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);
     }
     /**
@@ -5349,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}`);
@@ -5383,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(),
@@ -5405,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,
@@ -11841,9 +11878,11 @@ class ConfigValidationService {
     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());
@@ -11913,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),
@@ -11965,6 +12006,7 @@ const backtest = {
     ...contextServices,
     ...connectionServices,
     ...schemaServices,
+    ...coreServices,
     ...globalServices,
     ...commandServices,
     ...logicPrivateServices,
@@ -11999,6 +12041,7 @@ function 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
@@ -13861,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);
@@ -13896,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) {
@@ -13938,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.
@@ -14353,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);
@@ -14388,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) {
@@ -14430,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.
@@ -15111,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);
@@ -15151,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) {
@@ -15197,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);
             }
         };
         /**

package/build/index.mjs

@@ -165,10 +165,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'),
@@ -217,6 +219,7 @@ const TYPES = {
     ...contextServices$1,
     ...connectionServices$1,
     ...schemaServices$1,
+    ...coreServices$1,
     ...globalServices$1,
     ...commandServices$1,
     ...logicPrivateServices$1,
@@ -1999,15 +2002,6 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         self._lastSignalTimestamp = currentTime;
     }
     const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
-    if (await 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),
@@ -2022,6 +2016,16 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     if (self._isStopped) {
         return null;
     }
+    if (await 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?
@@ -2253,6 +2257,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
     });
     if (await 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,
@@ -2336,6 +2341,7 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
 };
 const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
     if (await 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,
@@ -2562,6 +2568,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         pendingAt: activationTime,
     });
     if (await 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,
@@ -4023,7 +4030,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.
  *
@@ -4032,7 +4039,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);
@@ -4062,13 +4069,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);
@@ -4089,13 +4099,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);
@@ -4114,11 +4127,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);
@@ -4138,12 +4154,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);
@@ -4163,12 +4182,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);
@@ -4181,7 +4203,7 @@ class ExchangeGlobalService {
     }
 }
 
-const METHOD_NAME_VALIDATE = "strategyGlobalService validate";
+const METHOD_NAME_VALIDATE = "strategyCoreService validate";
 /**
  * Global service for strategy operations with execution context injection.
  *
@@ -4190,7 +4212,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);
@@ -4228,10 +4250,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);
         };
@@ -4246,10 +4271,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);
         };
@@ -4265,11 +4293,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 () => {
@@ -4293,12 +4324,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 () => {
@@ -4320,7 +4354,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,
             });
@@ -4336,7 +4370,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) {
@@ -4347,14 +4381,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);
@@ -4370,6 +4404,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);
         };
@@ -4975,9 +5012,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);
     }
     /**
@@ -4999,7 +5036,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;
@@ -5018,7 +5055,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(),
@@ -5029,7 +5066,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}`);
@@ -5043,7 +5080,7 @@ class BacktestLogicPrivateService {
                 continue;
             }
             // Check if strategy should stop when idle (no active signal)
-            if (await and(Promise.resolve(result.action === "idle"), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+            if (await 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(),
@@ -5073,7 +5110,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}`);
@@ -5102,7 +5139,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}`);
@@ -5145,7 +5182,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,
@@ -5172,7 +5209,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}`);
@@ -5199,7 +5236,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}`);
@@ -5238,7 +5275,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,
@@ -5312,7 +5349,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);
     }
     /**
@@ -5347,7 +5384,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}`);
@@ -5381,7 +5418,7 @@ class LiveLogicPrivateService {
             previousEventTimestamp = currentTimestamp;
             // Check if strategy should stop when idle (no active signal)
             if (result.action === "idle") {
-                if (await and(Promise.resolve(true), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                if (await 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(),
@@ -5403,7 +5440,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,
@@ -11839,9 +11876,11 @@ class ConfigValidationService {
     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());
@@ -11911,10 +11950,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),
@@ -11963,6 +12004,7 @@ const backtest = {
     ...contextServices,
     ...connectionServices,
     ...schemaServices,
+    ...coreServices,
     ...globalServices,
     ...commandServices,
     ...logicPrivateServices,
@@ -11997,6 +12039,7 @@ function 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
@@ -13859,7 +13902,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);
@@ -13894,8 +13937,8 @@ class BacktestInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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) {
@@ -13936,7 +13979,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.
@@ -14351,7 +14394,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);
@@ -14386,8 +14429,8 @@ class LiveInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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) {
@@ -14428,7 +14471,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.
@@ -15109,7 +15152,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);
@@ -15149,7 +15192,7 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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) {
@@ -15195,7 +15238,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);
             }
         };
         /**

package/package.json

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

package/types.d.ts

@@ -159,6 +159,7 @@ declare function setLogger(logger: ILogger): void;
 /**
  * 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
@@ -540,6 +541,8 @@ declare const MethodContextService: (new () => {
 interface IRiskCheckArgs {
     /** Trading pair symbol (e.g., "BTCUSDT") */
     symbol: string;
+    /** Pending signal to apply */
+    pendingSignal: ISignalDto;
     /** Strategy name requesting to open a position */
     strategyName: StrategyName;
     /** Exchange name */
@@ -576,6 +579,8 @@ interface IRiskCallbacks {
  * Extends IRiskCheckArgs with portfolio state data.
  */
 interface IRiskValidationPayload extends IRiskCheckArgs {
+    /** Pending signal to apply */
+    pendingSignal: ISignalDto;
     /** Number of currently active positions across all strategies */
     activePositionCount: number;
     /** List of currently active positions across all strategies */
@@ -7228,7 +7233,7 @@ declare class RiskConnectionService {
  *
  * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
  */
-declare class ExchangeGlobalService {
+declare class ExchangeCoreService {
     private readonly loggerService;
     private readonly exchangeConnectionService;
     private readonly methodContextService;
@@ -7302,7 +7307,7 @@ declare class ExchangeGlobalService {
  *
  * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
  */
-declare class StrategyGlobalService {
+declare class StrategyCoreService {
     private readonly loggerService;
     private readonly strategyConnectionService;
     private readonly strategySchemaService;
@@ -7399,7 +7404,7 @@ declare class StrategyGlobalService {
  * Wraps FrameConnectionService for timeframe generation.
  * Used internally by BacktestLogicPrivateService.
  */
-declare class FrameGlobalService {
+declare class FrameCoreService {
     private readonly loggerService;
     private readonly frameConnectionService;
     private readonly frameValidationService;
@@ -7823,9 +7828,9 @@ declare class WalkerSchemaService {
  */
 declare class BacktestLogicPrivateService {
     private readonly loggerService;
-    private readonly strategyGlobalService;
-    private readonly exchangeGlobalService;
-    private readonly frameGlobalService;
+    private readonly strategyCoreService;
+    private readonly exchangeCoreService;
+    private readonly frameCoreService;
     private readonly methodContextService;
     /**
      * Runs backtest for a symbol, streaming closed signals as async generator.
@@ -7862,7 +7867,7 @@ declare class BacktestLogicPrivateService {
  */
 declare class LiveLogicPrivateService {
     private readonly loggerService;
-    private readonly strategyGlobalService;
+    private readonly strategyCoreService;
     private readonly methodContextService;
     /**
      * Runs live trading for a symbol, streaming results as async generator.
@@ -9293,13 +9298,13 @@ declare const backtest: {
     liveCommandService: LiveCommandService;
     backtestCommandService: BacktestCommandService;
     walkerCommandService: WalkerCommandService;
-    exchangeGlobalService: ExchangeGlobalService;
-    strategyGlobalService: StrategyGlobalService;
-    frameGlobalService: FrameGlobalService;
     sizingGlobalService: SizingGlobalService;
     riskGlobalService: RiskGlobalService;
     optimizerGlobalService: OptimizerGlobalService;
     partialGlobalService: PartialGlobalService;
+    exchangeCoreService: ExchangeCoreService;
+    strategyCoreService: StrategyCoreService;
+    frameCoreService: FrameCoreService;
     exchangeSchemaService: ExchangeSchemaService;
     strategySchemaService: StrategySchemaService;
     frameSchemaService: FrameSchemaService;