backtest-kit 1.5.13 → 1.5.15

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,
@@ -585,6 +588,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,
@@ -592,6 +603,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,
@@ -1999,15 +2018,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 +2032,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 +2273,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 +2357,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 +2584,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 +4046,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 +4055,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 +4085,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 +4115,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 +4143,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 +4170,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 +4198,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 +4219,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 +4228,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 +4266,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 +4287,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 +4309,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 +4340,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 +4370,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 +4386,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 +4397,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 +4420,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 +5028,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 +5052,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 +5071,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 +5082,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 +5096,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 +5126,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 +5155,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 +5198,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 +5225,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 +5252,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 +5291,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 +5365,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 +5400,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 +5434,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 +5456,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,
@@ -6494,14 +6547,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",
@@ -6516,29 +6566,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",
@@ -6554,16 +6595,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();
         }
     }
     /**
@@ -6998,16 +7033,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",
@@ -7022,16 +7054,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();
         }
     }
     /**
@@ -11839,9 +11865,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 +11939,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 +11993,7 @@ const backtest = {
     ...contextServices,
     ...connectionServices,
     ...schemaServices,
+    ...coreServices,
     ...globalServices,
     ...commandServices,
     ...logicPrivateServices,
@@ -11997,6 +12028,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 +13891,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 +13926,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 +13968,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 +14383,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 +14418,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 +14460,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 +15141,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 +15181,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 +15227,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);
             }
         };
         /**