backtest-kit 1.5.13 → 1.5.15

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,
@@ -587,6 +590,14 @@ class ClientExchange {
         const vwap = sumPriceVolume / totalVolume;
         return vwap;
     }
+    /**
+     * Formats quantity according to exchange-specific rules for the given symbol.
+     * Applies proper decimal precision and rounding based on symbol's lot size filters.
+     *
+     * @param symbol - Trading pair symbol
+     * @param quantity - Raw quantity to format
+     * @returns Promise resolving to formatted quantity as string
+     */
     async formatQuantity(symbol, quantity) {
         this.params.logger.debug("binanceService formatQuantity", {
             symbol,
@@ -594,6 +605,14 @@ class ClientExchange {
         });
         return await this.params.formatQuantity(symbol, quantity);
     }
+    /**
+     * Formats price according to exchange-specific rules for the given symbol.
+     * Applies proper decimal precision and rounding based on symbol's price filters.
+     *
+     * @param symbol - Trading pair symbol
+     * @param price - Raw price to format
+     * @returns Promise resolving to formatted price as string
+     */
     async formatPrice(symbol, price) {
         this.params.logger.debug("binanceService formatPrice", {
             symbol,
@@ -2001,15 +2020,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 +2034,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 +2275,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 +2359,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 +2586,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 +4048,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 +4057,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 +4087,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 +4117,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 +4145,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 +4172,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 +4200,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 +4221,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 +4230,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 +4268,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 +4289,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 +4311,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 +4342,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 +4372,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 +4388,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 +4399,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 +4422,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 +5030,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 +5054,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 +5073,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 +5084,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 +5098,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 +5128,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 +5157,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 +5200,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 +5227,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 +5254,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 +5293,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 +5367,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 +5402,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 +5436,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 +5458,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,
@@ -6496,14 +6549,11 @@ let ReportStorage$3 = class ReportStorage {
         }
     }
     /**
-     * Updates or adds an active event to the storage.
-     * Replaces the previous event with the same signalId.
+     * Adds an active event to the storage.
      *
      * @param data - Active tick result
      */
     addActiveEvent(data) {
-        // Find existing event with the same signalId
-        const existingIndex = this._eventList.findIndex((event) => event.signalId === data.signal.id);
         const newEvent = {
             timestamp: Date.now(),
             action: "active",
@@ -6518,29 +6568,20 @@ let ReportStorage$3 = class ReportStorage {
             percentTp: data.percentTp,
             percentSl: data.percentSl,
         };
-        // Replace existing event or add new one
-        if (existingIndex !== -1) {
-            this._eventList[existingIndex] = newEvent;
-        }
-        else {
-            this._eventList.push(newEvent);
-            // Trim queue if exceeded MAX_EVENTS
-            if (this._eventList.length > MAX_EVENTS$3) {
-                this._eventList.shift();
-            }
+        this._eventList.push(newEvent);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS$3) {
+            this._eventList.shift();
         }
     }
     /**
-     * Updates or adds a closed event to the storage.
-     * Replaces the previous event with the same signalId.
+     * Adds a closed event to the storage.
      *
      * @param data - Closed tick result
      */
     addClosedEvent(data) {
         const durationMs = data.closeTimestamp - data.signal.pendingAt;
         const durationMin = Math.round(durationMs / 60000);
-        // Find existing event with the same signalId
-        const existingIndex = this._eventList.findIndex((event) => event.signalId === data.signal.id);
         const newEvent = {
             timestamp: data.closeTimestamp,
             action: "closed",
@@ -6556,16 +6597,10 @@ let ReportStorage$3 = class ReportStorage {
             closeReason: data.closeReason,
             duration: durationMin,
         };
-        // Replace existing event or add new one
-        if (existingIndex !== -1) {
-            this._eventList[existingIndex] = newEvent;
-        }
-        else {
-            this._eventList.push(newEvent);
-            // Trim queue if exceeded MAX_EVENTS
-            if (this._eventList.length > MAX_EVENTS$3) {
-                this._eventList.shift();
-            }
+        this._eventList.push(newEvent);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS$3) {
+            this._eventList.shift();
         }
     }
     /**
@@ -7000,16 +7035,13 @@ let ReportStorage$2 = class ReportStorage {
         }
     }
     /**
-     * Updates or adds a cancelled event to the storage.
-     * Replaces the previous event with the same signalId.
+     * Adds a cancelled event to the storage.
      *
      * @param data - Cancelled tick result
      */
     addCancelledEvent(data) {
         const durationMs = data.closeTimestamp - data.signal.scheduledAt;
         const durationMin = Math.round(durationMs / 60000);
-        // Find existing event with the same signalId
-        const existingIndex = this._eventList.findIndex((event) => event.signalId === data.signal.id);
         const newEvent = {
             timestamp: data.closeTimestamp,
             action: "cancelled",
@@ -7024,16 +7056,10 @@ let ReportStorage$2 = class ReportStorage {
             closeTimestamp: data.closeTimestamp,
             duration: durationMin,
         };
-        // Replace existing event or add new one
-        if (existingIndex !== -1) {
-            this._eventList[existingIndex] = newEvent;
-        }
-        else {
-            this._eventList.push(newEvent);
-            // Trim queue if exceeded MAX_EVENTS
-            if (this._eventList.length > MAX_EVENTS$2) {
-                this._eventList.shift();
-            }
+        this._eventList.push(newEvent);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS$2) {
+            this._eventList.shift();
         }
     }
     /**
@@ -11841,9 +11867,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 +11941,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 +11995,7 @@ const backtest = {
     ...contextServices,
     ...connectionServices,
     ...schemaServices,
+    ...coreServices,
     ...globalServices,
     ...commandServices,
     ...logicPrivateServices,
@@ -11999,6 +12030,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 +13893,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 +13928,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 +13970,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 +14385,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 +14420,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 +14462,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 +15143,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 +15183,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 +15229,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);
             }
         };
         /**