backtest-kit 1.5.28 → 1.5.30

package/build/index.cjs

@@ -2043,7 +2043,7 @@ const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
 const BASE_WAIT_FOR_INIT_FN = async (self) => {
-    bt.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+    backtest$1.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
         entityName: self.entityName,
         directory: self._directory,
     });
@@ -2101,7 +2101,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
             entityName: this.entityName,
             baseDir,
         });
@@ -2117,7 +2117,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         return path.join(this.baseDir, this.entityName, `${entityId}.json`);
     }
     async waitForInit(initial) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             entityName: this.entityName,
             initial,
         });
@@ -2134,7 +2134,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         return length;
     }
     async readValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2151,7 +2151,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         }
     }
     async hasValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2168,7 +2168,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
         }
     }
     async writeValue(entityId, entity) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2189,7 +2189,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if entity not found or deletion fails
      */
     async removeValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_VALUE, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -2211,7 +2211,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if deletion fails
      */
     async removeAll() {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_ALL, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_ALL, {
             entityName: this.entityName,
         });
         try {
@@ -2233,7 +2233,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if reading fails
      */
     async *values() {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_VALUES, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_VALUES, {
             entityName: this.entityName,
         });
         try {
@@ -2262,7 +2262,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * @throws Error if reading fails
      */
     async *keys() {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
             entityName: this.entityName,
         });
         try {
@@ -2367,7 +2367,7 @@ class PersistSignalUtils {
          * @returns Promise resolving to signal or null
          */
         this.readSignalData = async (symbol, strategyName) => {
-            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getSignalStorage.has(key);
             const stateStorage = this.getSignalStorage(symbol, strategyName);
@@ -2389,7 +2389,7 @@ class PersistSignalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSignalData = async (signalRow, symbol, strategyName) => {
-            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getSignalStorage.has(key);
             const stateStorage = this.getSignalStorage(symbol, strategyName);
@@ -2412,7 +2412,7 @@ class PersistSignalUtils {
      * ```
      */
     usePersistSignalAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
         this.PersistSignalFactory = Ctor;
     }
 }
@@ -2464,7 +2464,7 @@ class PersistRiskUtils {
          * @returns Promise resolving to Map of active positions
          */
         this.readPositionData = async (riskName) => {
-            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const isInitial = !this.getRiskStorage.has(riskName);
             const stateStorage = this.getRiskStorage(riskName);
             await stateStorage.waitForInit(isInitial);
@@ -2485,7 +2485,7 @@ class PersistRiskUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePositionData = async (riskRow, riskName) => {
-            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const isInitial = !this.getRiskStorage.has(riskName);
             const stateStorage = this.getRiskStorage(riskName);
             await stateStorage.waitForInit(isInitial);
@@ -2508,7 +2508,7 @@ class PersistRiskUtils {
      * ```
      */
     usePersistRiskAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
         this.PersistRiskFactory = Ctor;
     }
 }
@@ -2558,7 +2558,7 @@ class PersistScheduleUtils {
          * @returns Promise resolving to scheduled signal or null
          */
         this.readScheduleData = async (symbol, strategyName) => {
-            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const stateStorage = this.getScheduleStorage(symbol, strategyName);
@@ -2580,7 +2580,7 @@ class PersistScheduleUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName) => {
-            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const stateStorage = this.getScheduleStorage(symbol, strategyName);
@@ -2603,7 +2603,7 @@ class PersistScheduleUtils {
      * ```
      */
     usePersistScheduleAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
         this.PersistScheduleFactory = Ctor;
     }
 }
@@ -2653,7 +2653,7 @@ class PersistPartialUtils {
          * @returns Promise resolving to partial data record
          */
         this.readPartialData = async (symbol, strategyName) => {
-            bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getPartialStorage.has(key);
             const stateStorage = this.getPartialStorage(symbol, strategyName);
@@ -2676,7 +2676,7 @@ class PersistPartialUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePartialData = async (partialData, symbol, strategyName) => {
-            bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}`;
             const isInitial = !this.getPartialStorage.has(key);
             const stateStorage = this.getPartialStorage(symbol, strategyName);
@@ -2700,7 +2700,7 @@ class PersistPartialUtils {
      * ```
      */
     usePersistPartialAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
         this.PersistPartialFactory = Ctor;
     }
 }
@@ -3169,7 +3169,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        bt.loggerService.warn(message, payload);
+        backtest$1.loggerService.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -4349,7 +4349,7 @@ class MergeRisk {
      * @returns Promise resolving to true if all risks approve, false if any risk rejects
      */
     async checkSignal(params) {
-        bt.loggerService.info("MergeRisk checkSignal", {
+        backtest$1.loggerService.info("MergeRisk checkSignal", {
             params,
         });
         const riskCheck = await Promise.all(this._riskList.map(async (risk) => await risk.checkSignal(params)));
@@ -4366,7 +4366,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have registered the signal
      */
     async addSignal(symbol, context) {
-        bt.loggerService.info("MergeRisk addSignal", {
+        backtest$1.loggerService.info("MergeRisk addSignal", {
             symbol,
             context,
         });
@@ -4383,7 +4383,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have removed the signal
      */
     async removeSignal(symbol, context) {
-        bt.loggerService.info("MergeRisk removeSignal", {
+        backtest$1.loggerService.info("MergeRisk removeSignal", {
             symbol,
             context,
         });
@@ -4452,18 +4452,18 @@ class RiskUtils {
          * ```
          */
         this.getData = async (symbol, strategyName, backtest) => {
-            bt.loggerService.info(RISK_METHOD_NAME_GET_DATA, {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_DATA, {
                 symbol,
                 strategyName,
             });
-            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA));
+                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA));
             }
-            return await bt.riskMarkdownService.getData(symbol, strategyName, backtest);
+            return await backtest$1.riskMarkdownService.getData(symbol, strategyName, backtest);
         };
         /**
          * Generates markdown report with all risk rejection events for a symbol-strategy pair.
@@ -4507,18 +4507,18 @@ class RiskUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName, backtest, columns) => {
-            bt.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
+                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
             }
-            return await bt.riskMarkdownService.getReport(symbol, strategyName, backtest, columns);
+            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName, backtest, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -4553,19 +4553,19 @@ class RiskUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, backtest, path, columns) => {
-            bt.loggerService.info(RISK_METHOD_NAME_DUMP, {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            bt.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP));
+                    backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP));
             }
-            await bt.riskMarkdownService.dump(symbol, strategyName, backtest, path, columns);
+            await backtest$1.riskMarkdownService.dump(symbol, strategyName, backtest, path, columns);
         };
     }
 }
@@ -5183,7 +5183,7 @@ const DO_VALIDATION_FN = functoolsKit.trycatch(async (validation, params) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        bt.loggerService.warn(message, payload);
+        backtest$1.loggerService.warn(message, payload);
         console.warn(message, payload);
         validationSubject.next(error);
     },
@@ -6441,6 +6441,13 @@ class WalkerSchemaService {
             if (walkerSchema.strategies.length === 0) {
                 throw new Error(`walker schema validation failed: strategies array cannot be empty for walkerName=${walkerSchema.walkerName}`);
             }
+            if (walkerSchema.strategies &&
+                walkerSchema.strategies.length !== new Set(walkerSchema.strategies).size) {
+                throw new Error(`walker schema validation failed: found duplicate strategies for walkerName=${walkerSchema.walkerName} strategies=[${walkerSchema.strategies}]`);
+            }
+            if (walkerSchema.strategies?.some((value) => typeof value !== "string")) {
+                throw new Error(`walker schema validation failed: invalid strategies for walkerName=${walkerSchema.walkerName} strategies=[${walkerSchema.strategies}]`);
+            }
         };
         /**
          * Overrides an existing walker schema with partial updates.
@@ -13654,7 +13661,7 @@ const backtest = {
     ...templateServices,
 };
 init();
-var bt = backtest;
+var backtest$1 = backtest;
 
 /**
  * Sets custom logger implementation for the framework.
@@ -13674,7 +13681,7 @@ var bt = backtest;
  * ```
  */
 function setLogger(logger) {
-    bt.loggerService.setLogger(logger);
+    backtest$1.loggerService.setLogger(logger);
 }
 /**
  * Sets global configuration parameters for the framework.
@@ -13692,7 +13699,7 @@ function setConfig(config, _unsafe) {
     const prevConfig = Object.assign({}, GLOBAL_CONFIG);
     try {
         Object.assign(GLOBAL_CONFIG, config);
-        !_unsafe && bt.configValidationService.validate();
+        !_unsafe && backtest$1.configValidationService.validate();
     }
     catch (error) {
         console.warn(`backtest-kit setConfig failed: ${functoolsKit.getErrorMessage(error)}`, config);
@@ -13763,7 +13770,7 @@ function setColumns(columns, _unsafe) {
     const prevConfig = Object.assign({}, COLUMN_CONFIG);
     try {
         Object.assign(COLUMN_CONFIG, columns);
-        !_unsafe && bt.columnValidationService.validate();
+        !_unsafe && backtest$1.columnValidationService.validate();
     }
     catch (error) {
         console.warn(`backtest-kit setColumns failed: ${functoolsKit.getErrorMessage(error)}`, columns);
@@ -13848,11 +13855,11 @@ const ADD_OPTIMIZER_METHOD_NAME = "add.addOptimizer";
  * ```
  */
 function addStrategy(strategySchema) {
-    bt.loggerService.info(ADD_STRATEGY_METHOD_NAME, {
+    backtest$1.loggerService.info(ADD_STRATEGY_METHOD_NAME, {
         strategySchema,
     });
-    bt.strategyValidationService.addStrategy(strategySchema.strategyName, strategySchema);
-    bt.strategySchemaService.register(strategySchema.strategyName, strategySchema);
+    backtest$1.strategyValidationService.addStrategy(strategySchema.strategyName, strategySchema);
+    backtest$1.strategySchemaService.register(strategySchema.strategyName, strategySchema);
 }
 /**
  * Registers an exchange data source in the framework.
@@ -13890,11 +13897,11 @@ function addStrategy(strategySchema) {
  * ```
  */
 function addExchange(exchangeSchema) {
-    bt.loggerService.info(ADD_EXCHANGE_METHOD_NAME, {
+    backtest$1.loggerService.info(ADD_EXCHANGE_METHOD_NAME, {
         exchangeSchema,
     });
-    bt.exchangeValidationService.addExchange(exchangeSchema.exchangeName, exchangeSchema);
-    bt.exchangeSchemaService.register(exchangeSchema.exchangeName, exchangeSchema);
+    backtest$1.exchangeValidationService.addExchange(exchangeSchema.exchangeName, exchangeSchema);
+    backtest$1.exchangeSchemaService.register(exchangeSchema.exchangeName, exchangeSchema);
 }
 /**
  * Registers a timeframe generator for backtesting.
@@ -13927,11 +13934,11 @@ function addExchange(exchangeSchema) {
  * ```
  */
 function addFrame(frameSchema) {
-    bt.loggerService.info(ADD_FRAME_METHOD_NAME, {
+    backtest$1.loggerService.info(ADD_FRAME_METHOD_NAME, {
         frameSchema,
     });
-    bt.frameValidationService.addFrame(frameSchema.frameName, frameSchema);
-    bt.frameSchemaService.register(frameSchema.frameName, frameSchema);
+    backtest$1.frameValidationService.addFrame(frameSchema.frameName, frameSchema);
+    backtest$1.frameSchemaService.register(frameSchema.frameName, frameSchema);
 }
 /**
  * Registers a walker for strategy comparison.
@@ -13971,11 +13978,11 @@ function addFrame(frameSchema) {
  * ```
  */
 function addWalker(walkerSchema) {
-    bt.loggerService.info(ADD_WALKER_METHOD_NAME, {
+    backtest$1.loggerService.info(ADD_WALKER_METHOD_NAME, {
         walkerSchema,
     });
-    bt.walkerValidationService.addWalker(walkerSchema.walkerName, walkerSchema);
-    bt.walkerSchemaService.register(walkerSchema.walkerName, walkerSchema);
+    backtest$1.walkerValidationService.addWalker(walkerSchema.walkerName, walkerSchema);
+    backtest$1.walkerSchemaService.register(walkerSchema.walkerName, walkerSchema);
 }
 /**
  * Registers a position sizing configuration in the framework.
@@ -14030,11 +14037,11 @@ function addWalker(walkerSchema) {
  * ```
  */
 function addSizing(sizingSchema) {
-    bt.loggerService.info(ADD_SIZING_METHOD_NAME, {
+    backtest$1.loggerService.info(ADD_SIZING_METHOD_NAME, {
         sizingSchema,
     });
-    bt.sizingValidationService.addSizing(sizingSchema.sizingName, sizingSchema);
-    bt.sizingSchemaService.register(sizingSchema.sizingName, sizingSchema);
+    backtest$1.sizingValidationService.addSizing(sizingSchema.sizingName, sizingSchema);
+    backtest$1.sizingSchemaService.register(sizingSchema.sizingName, sizingSchema);
 }
 /**
  * Registers a risk management configuration in the framework.
@@ -14098,11 +14105,11 @@ function addSizing(sizingSchema) {
  * ```
  */
 function addRisk(riskSchema) {
-    bt.loggerService.info(ADD_RISK_METHOD_NAME, {
+    backtest$1.loggerService.info(ADD_RISK_METHOD_NAME, {
         riskSchema,
     });
-    bt.riskValidationService.addRisk(riskSchema.riskName, riskSchema);
-    bt.riskSchemaService.register(riskSchema.riskName, riskSchema);
+    backtest$1.riskValidationService.addRisk(riskSchema.riskName, riskSchema);
+    backtest$1.riskSchemaService.register(riskSchema.riskName, riskSchema);
 }
 /**
  * Registers an optimizer configuration in the framework.
@@ -14192,11 +14199,11 @@ function addRisk(riskSchema) {
  * ```
  */
 function addOptimizer(optimizerSchema) {
-    bt.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
+    backtest$1.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
         optimizerSchema,
     });
-    bt.optimizerValidationService.addOptimizer(optimizerSchema.optimizerName, optimizerSchema);
-    bt.optimizerSchemaService.register(optimizerSchema.optimizerName, optimizerSchema);
+    backtest$1.optimizerValidationService.addOptimizer(optimizerSchema.optimizerName, optimizerSchema);
+    backtest$1.optimizerSchemaService.register(optimizerSchema.optimizerName, optimizerSchema);
 }
 
 const LIST_EXCHANGES_METHOD_NAME = "list.listExchanges";
@@ -14232,8 +14239,8 @@ const LIST_OPTIMIZERS_METHOD_NAME = "list.listOptimizers";
  * ```
  */
 async function listExchanges() {
-    bt.loggerService.log(LIST_EXCHANGES_METHOD_NAME);
-    return await bt.exchangeValidationService.list();
+    backtest$1.loggerService.log(LIST_EXCHANGES_METHOD_NAME);
+    return await backtest$1.exchangeValidationService.list();
 }
 /**
  * Returns a list of all registered strategy schemas.
@@ -14266,8 +14273,8 @@ async function listExchanges() {
  * ```
  */
 async function listStrategies() {
-    bt.loggerService.log(LIST_STRATEGIES_METHOD_NAME);
-    return await bt.strategyValidationService.list();
+    backtest$1.loggerService.log(LIST_STRATEGIES_METHOD_NAME);
+    return await backtest$1.strategyValidationService.list();
 }
 /**
  * Returns a list of all registered frame schemas.
@@ -14295,8 +14302,8 @@ async function listStrategies() {
  * ```
  */
 async function listFrames() {
-    bt.loggerService.log(LIST_FRAMES_METHOD_NAME);
-    return await bt.frameValidationService.list();
+    backtest$1.loggerService.log(LIST_FRAMES_METHOD_NAME);
+    return await backtest$1.frameValidationService.list();
 }
 /**
  * Returns a list of all registered walker schemas.
@@ -14325,8 +14332,8 @@ async function listFrames() {
  * ```
  */
 async function listWalkers() {
-    bt.loggerService.log(LIST_WALKERS_METHOD_NAME);
-    return await bt.walkerValidationService.list();
+    backtest$1.loggerService.log(LIST_WALKERS_METHOD_NAME);
+    return await backtest$1.walkerValidationService.list();
 }
 /**
  * Returns a list of all registered sizing schemas.
@@ -14364,8 +14371,8 @@ async function listWalkers() {
  * ```
  */
 async function listSizings() {
-    bt.loggerService.log(LIST_SIZINGS_METHOD_NAME);
-    return await bt.sizingValidationService.list();
+    backtest$1.loggerService.log(LIST_SIZINGS_METHOD_NAME);
+    return await backtest$1.sizingValidationService.list();
 }
 /**
  * Returns a list of all registered risk schemas.
@@ -14400,8 +14407,8 @@ async function listSizings() {
  * ```
  */
 async function listRisks() {
-    bt.loggerService.log(LIST_RISKS_METHOD_NAME);
-    return await bt.riskValidationService.list();
+    backtest$1.loggerService.log(LIST_RISKS_METHOD_NAME);
+    return await backtest$1.riskValidationService.list();
 }
 /**
  * Returns a list of all registered optimizer schemas.
@@ -14440,8 +14447,8 @@ async function listRisks() {
  * ```
  */
 async function listOptimizers() {
-    bt.loggerService.log(LIST_OPTIMIZERS_METHOD_NAME);
-    return await bt.optimizerValidationService.list();
+    backtest$1.loggerService.log(LIST_OPTIMIZERS_METHOD_NAME);
+    return await backtest$1.optimizerValidationService.list();
 }
 
 const LISTEN_SIGNAL_METHOD_NAME = "event.listenSignal";
@@ -14498,7 +14505,7 @@ const LISTEN_RISK_ONCE_METHOD_NAME = "event.listenRiskOnce";
  * ```
  */
 function listenSignal(fn) {
-    bt.loggerService.log(LISTEN_SIGNAL_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_SIGNAL_METHOD_NAME);
     return signalEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14534,7 +14541,7 @@ function listenSignal(fn) {
  * ```
  */
 function listenSignalOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_SIGNAL_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_SIGNAL_ONCE_METHOD_NAME);
     return signalEmitter.filter(filterFn).once(fn);
 }
 /**
@@ -14558,7 +14565,7 @@ function listenSignalOnce(filterFn, fn) {
  * ```
  */
 function listenSignalLive(fn) {
-    bt.loggerService.log(LISTEN_SIGNAL_LIVE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_SIGNAL_LIVE_METHOD_NAME);
     return signalLiveEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14583,7 +14590,7 @@ function listenSignalLive(fn) {
  * ```
  */
 function listenSignalLiveOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME);
     return signalLiveEmitter.filter(filterFn).once(fn);
 }
 /**
@@ -14607,7 +14614,7 @@ function listenSignalLiveOnce(filterFn, fn) {
  * ```
  */
 function listenSignalBacktest(fn) {
-    bt.loggerService.log(LISTEN_SIGNAL_BACKTEST_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_SIGNAL_BACKTEST_METHOD_NAME);
     return signalBacktestEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14632,7 +14639,7 @@ function listenSignalBacktest(fn) {
  * ```
  */
 function listenSignalBacktestOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME);
     return signalBacktestEmitter.filter(filterFn).once(fn);
 }
 /**
@@ -14660,7 +14667,7 @@ function listenSignalBacktestOnce(filterFn, fn) {
  * ```
  */
 function listenError(fn) {
-    bt.loggerService.log(LISTEN_ERROR_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_ERROR_METHOD_NAME);
     return errorEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -14688,7 +14695,7 @@ function listenError(fn) {
  * ```
  */
 function listenExit(fn) {
-    bt.loggerService.log(LISTEN_EXIT_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_EXIT_METHOD_NAME);
     return exitEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -14719,7 +14726,7 @@ function listenExit(fn) {
  * ```
  */
 function listenDoneLive(fn) {
-    bt.loggerService.log(LISTEN_DONE_LIVE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_DONE_LIVE_METHOD_NAME);
     return doneLiveSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14749,7 +14756,7 @@ function listenDoneLive(fn) {
  * ```
  */
 function listenDoneLiveOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_DONE_LIVE_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_DONE_LIVE_ONCE_METHOD_NAME);
     return doneLiveSubject.filter(filterFn).once(fn);
 }
 /**
@@ -14781,7 +14788,7 @@ function listenDoneLiveOnce(filterFn, fn) {
  * ```
  */
 function listenDoneBacktest(fn) {
-    bt.loggerService.log(LISTEN_DONE_BACKTEST_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_DONE_BACKTEST_METHOD_NAME);
     return doneBacktestSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14812,7 +14819,7 @@ function listenDoneBacktest(fn) {
  * ```
  */
 function listenDoneBacktestOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_DONE_BACKTEST_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_DONE_BACKTEST_ONCE_METHOD_NAME);
     return doneBacktestSubject.filter(filterFn).once(fn);
 }
 /**
@@ -14842,7 +14849,7 @@ function listenDoneBacktestOnce(filterFn, fn) {
  * ```
  */
 function listenDoneWalker(fn) {
-    bt.loggerService.log(LISTEN_DONE_WALKER_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_DONE_WALKER_METHOD_NAME);
     return doneWalkerSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14871,7 +14878,7 @@ function listenDoneWalker(fn) {
  * ```
  */
 function listenDoneWalkerOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_DONE_WALKER_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_DONE_WALKER_ONCE_METHOD_NAME);
     return doneWalkerSubject.filter(filterFn).once(fn);
 }
 /**
@@ -14905,7 +14912,7 @@ function listenDoneWalkerOnce(filterFn, fn) {
  * ```
  */
 function listenBacktestProgress(fn) {
-    bt.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
     return progressBacktestEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14939,7 +14946,7 @@ function listenBacktestProgress(fn) {
  * ```
  */
 function listenWalkerProgress(fn) {
-    bt.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_PROGRESS_WALKER_METHOD_NAME);
     return progressWalkerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -14967,7 +14974,7 @@ function listenWalkerProgress(fn) {
  * ```
  */
 function listenOptimizerProgress(fn) {
-    bt.loggerService.log(LISTEN_PROGRESS_OPTIMIZER_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_PROGRESS_OPTIMIZER_METHOD_NAME);
     return progressOptimizerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15003,7 +15010,7 @@ function listenOptimizerProgress(fn) {
  * ```
  */
 function listenPerformance(fn) {
-    bt.loggerService.log(LISTEN_PERFORMANCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_PERFORMANCE_METHOD_NAME);
     return performanceEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15037,7 +15044,7 @@ function listenPerformance(fn) {
  * ```
  */
 function listenWalker(fn) {
-    bt.loggerService.log(LISTEN_WALKER_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_WALKER_METHOD_NAME);
     return walkerEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15080,7 +15087,7 @@ function listenWalker(fn) {
  * ```
  */
 function listenWalkerOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_WALKER_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_WALKER_ONCE_METHOD_NAME);
     return walkerEmitter.filter(filterFn).once(fn);
 }
 /**
@@ -15115,7 +15122,7 @@ function listenWalkerOnce(filterFn, fn) {
  * ```
  */
 function listenWalkerComplete(fn) {
-    bt.loggerService.log(LISTEN_WALKER_COMPLETE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_WALKER_COMPLETE_METHOD_NAME);
     return walkerCompleteSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15143,7 +15150,7 @@ function listenWalkerComplete(fn) {
  * ```
  */
 function listenValidation(fn) {
-    bt.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
     return validationSubject.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
 /**
@@ -15171,7 +15178,7 @@ function listenValidation(fn) {
  * ```
  */
 function listenPartialProfit(fn) {
-    bt.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
     return partialProfitSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15205,7 +15212,7 @@ function listenPartialProfit(fn) {
  * ```
  */
 function listenPartialProfitOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME);
     return partialProfitSubject.filter(filterFn).once(fn);
 }
 /**
@@ -15233,7 +15240,7 @@ function listenPartialProfitOnce(filterFn, fn) {
  * ```
  */
 function listenPartialLoss(fn) {
-    bt.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
     return partialLossSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15267,7 +15274,7 @@ function listenPartialLoss(fn) {
  * ```
  */
 function listenPartialLossOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME);
     return partialLossSubject.filter(filterFn).once(fn);
 }
 /**
@@ -15299,7 +15306,7 @@ function listenPartialLossOnce(filterFn, fn) {
  * ```
  */
 function listenRisk(fn) {
-    bt.loggerService.log(LISTEN_RISK_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_RISK_METHOD_NAME);
     return riskSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
@@ -15336,7 +15343,7 @@ function listenRisk(fn) {
  * ```
  */
 function listenRiskOnce(filterFn, fn) {
-    bt.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
+    backtest$1.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
     return riskSubject.filter(filterFn).once(fn);
 }
 
@@ -15346,6 +15353,31 @@ const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
 const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
 const GET_DATE_METHOD_NAME = "exchange.getDate";
 const GET_MODE_METHOD_NAME = "exchange.getMode";
+const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
+/**
+ * Checks if trade context is active (execution and method contexts).
+ *
+ * Returns true when both contexts are active, which is required for calling
+ * exchange functions like getCandles, getAveragePrice, formatPrice, formatQuantity,
+ * getDate, and getMode.
+ *
+ * @returns true if trade context is active, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { hasTradeContext, getCandles } from "backtest-kit";
+ *
+ * if (hasTradeContext()) {
+ *   const candles = await getCandles("BTCUSDT", "1m", 100);
+ * } else {
+ *   console.log("Trade context not active");
+ * }
+ * ```
+ */
+function hasTradeContext() {
+    backtest$1.loggerService.info(HAS_TRADE_CONTEXT_METHOD_NAME);
+    return ExecutionContextService.hasContext() && MethodContextService.hasContext();
+}
 /**
  * Fetches historical candle data from the registered exchange.
  *
@@ -15364,12 +15396,18 @@ const GET_MODE_METHOD_NAME = "exchange.getMode";
  * ```
  */
 async function getCandles(symbol, interval, limit) {
-    bt.loggerService.info(GET_CANDLES_METHOD_NAME, {
+    backtest$1.loggerService.info(GET_CANDLES_METHOD_NAME, {
         symbol,
         interval,
         limit,
     });
-    return await bt.exchangeConnectionService.getCandles(symbol, interval, limit);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getCandles requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getCandles requires a method context");
+    }
+    return await backtest$1.exchangeConnectionService.getCandles(symbol, interval, limit);
 }
 /**
  * Calculates VWAP (Volume Weighted Average Price) for a symbol.
@@ -15390,10 +15428,16 @@ async function getCandles(symbol, interval, limit) {
  * ```
  */
 async function getAveragePrice(symbol) {
-    bt.loggerService.info(GET_AVERAGE_PRICE_METHOD_NAME, {
+    backtest$1.loggerService.info(GET_AVERAGE_PRICE_METHOD_NAME, {
         symbol,
     });
-    return await bt.exchangeConnectionService.getAveragePrice(symbol);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getAveragePrice requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getAveragePrice requires a method context");
+    }
+    return await backtest$1.exchangeConnectionService.getAveragePrice(symbol);
 }
 /**
  * Formats a price value according to exchange rules.
@@ -15411,11 +15455,14 @@ async function getAveragePrice(symbol) {
  * ```
  */
 async function formatPrice(symbol, price) {
-    bt.loggerService.info(FORMAT_PRICE_METHOD_NAME, {
+    backtest$1.loggerService.info(FORMAT_PRICE_METHOD_NAME, {
         symbol,
         price,
     });
-    return await bt.exchangeConnectionService.formatPrice(symbol, price);
+    if (!MethodContextService.hasContext()) {
+        throw new Error("formatPrice requires a method context");
+    }
+    return await backtest$1.exchangeConnectionService.formatPrice(symbol, price);
 }
 /**
  * Formats a quantity value according to exchange rules.
@@ -15433,11 +15480,14 @@ async function formatPrice(symbol, price) {
  * ```
  */
 async function formatQuantity(symbol, quantity) {
-    bt.loggerService.info(FORMAT_QUANTITY_METHOD_NAME, {
+    backtest$1.loggerService.info(FORMAT_QUANTITY_METHOD_NAME, {
         symbol,
         quantity,
     });
-    return await bt.exchangeConnectionService.formatQuantity(symbol, quantity);
+    if (!MethodContextService.hasContext()) {
+        throw new Error("formatQuantity requires a method context");
+    }
+    return await backtest$1.exchangeConnectionService.formatQuantity(symbol, quantity);
 }
 /**
  * Gets the current date from execution context.
@@ -15454,8 +15504,11 @@ async function formatQuantity(symbol, quantity) {
  * ```
  */
 async function getDate() {
-    bt.loggerService.info(GET_DATE_METHOD_NAME);
-    const { when } = bt.executionContextService.context;
+    backtest$1.loggerService.info(GET_DATE_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getDate requires an execution context");
+    }
+    const { when } = backtest$1.executionContextService.context;
     return new Date(when.getTime());
 }
 /**
@@ -15474,9 +15527,12 @@ async function getDate() {
  * ```
  */
 async function getMode() {
-    bt.loggerService.info(GET_MODE_METHOD_NAME);
-    const { backtest: bt$1 } = bt.executionContextService.context;
-    return bt$1 ? "backtest" : "live";
+    backtest$1.loggerService.info(GET_MODE_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getMode requires an execution context");
+    }
+    const { backtest: bt } = backtest$1.executionContextService.context;
+    return bt ? "backtest" : "live";
 }
 
 const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
@@ -15547,13 +15603,13 @@ const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
  * ```
  */
 async function dumpSignal(signalId, history, signal, outputDir = "./dump/strategy") {
-    bt.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
+    backtest$1.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
         signalId,
         history,
         signal,
         outputDir,
     });
-    return await bt.outlineMarkdownService.dumpSignal(signalId, history, signal, outputDir);
+    return await backtest$1.outlineMarkdownService.dumpSignal(signalId, history, signal, outputDir);
 }
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
@@ -15640,7 +15696,7 @@ class BacktestInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -15659,7 +15715,7 @@ class BacktestInstance {
          * ```
          */
         this.getStatus = async () => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_STATUS);
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_STATUS);
             return {
                 id: this.id,
                 symbol: this.symbol,
@@ -15675,27 +15731,27 @@ class BacktestInstance {
          * @returns Async generator yielding closed signals with PNL
          */
         this.run = (symbol, context) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_RUN, {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_RUN, {
                 symbol,
                 context,
             });
             {
-                bt.backtestMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
-                bt.liveMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
-                bt.scheduleMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
-                bt.performanceMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
-                bt.partialMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
-                bt.riskMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                backtest$1.backtestMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                backtest$1.liveMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                backtest$1.scheduleMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                backtest$1.performanceMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                backtest$1.partialMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
+                backtest$1.riskMarkdownService.clear(true, { symbol, strategyName: context.strategyName });
             }
             {
-                bt.strategyCoreService.clear(true, { symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear(true, { symbol, strategyName: context.strategyName });
             }
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskGlobalService.clear(true, riskName);
-                riskList && riskList.forEach((riskName) => bt.riskGlobalService.clear(true, riskName));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskGlobalService.clear(true, riskName);
+                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, riskName));
             }
-            return bt.backtestCommandService.run(symbol, context);
+            return backtest$1.backtestCommandService.run(symbol, context);
         };
         /**
          * Runs backtest in background without yielding results.
@@ -15718,7 +15774,7 @@ class BacktestInstance {
          * ```
          */
         this.background = (symbol, context) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_BACKGROUND, {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_BACKGROUND, {
                 symbol,
                 context,
             });
@@ -15733,8 +15789,8 @@ class BacktestInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(true, { symbol, strategyName: context.strategyName });
-                bt.strategyCoreService
+                backtest$1.strategyCoreService.stop(true, { symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService
                     .getPendingSignal(true, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
@@ -15771,11 +15827,11 @@ class BacktestInstance {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
                 symbol,
                 strategyName,
             });
-            await bt.strategyCoreService.stop(true, { symbol, strategyName });
+            await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
@@ -15792,11 +15848,11 @@ class BacktestInstance {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            bt.loggerService.info("BacktestUtils.getData", {
+            backtest$1.loggerService.info("BacktestUtils.getData", {
                 symbol,
                 strategyName,
             });
-            return await bt.backtestMarkdownService.getData(symbol, strategyName, true);
+            return await backtest$1.backtestMarkdownService.getData(symbol, strategyName, true);
         };
         /**
          * Generates markdown report with all closed signals for a symbol-strategy pair.
@@ -15814,11 +15870,11 @@ class BacktestInstance {
          * ```
          */
         this.getReport = async (symbol, strategyName, columns) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await bt.backtestMarkdownService.getReport(symbol, strategyName, true, columns);
+            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName, true, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15839,12 +15895,12 @@ class BacktestInstance {
          * ```
          */
         this.dump = async (symbol, strategyName, path, columns) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await bt.backtestMarkdownService.dump(symbol, strategyName, true, path, columns);
+            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, true, path, columns);
         };
     }
 }
@@ -15883,14 +15939,14 @@ class BacktestUtils {
          */
         this.run = (symbol, context) => {
             {
-                bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_RUN);
-                bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_RUN);
-                bt.frameValidationService.validate(context.frameName, BACKTEST_METHOD_NAME_RUN);
+                backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_RUN);
+                backtest$1.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_RUN);
+                backtest$1.frameValidationService.validate(context.frameName, BACKTEST_METHOD_NAME_RUN);
             }
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_RUN);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_RUN));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_RUN);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.run(symbol, context);
@@ -15917,13 +15973,13 @@ class BacktestUtils {
          * ```
          */
         this.background = (symbol, context) => {
-            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_BACKGROUND);
-            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_BACKGROUND);
-            bt.frameValidationService.validate(context.frameName, BACKTEST_METHOD_NAME_BACKGROUND);
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_BACKGROUND);
+            backtest$1.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_BACKGROUND);
+            backtest$1.frameValidationService.validate(context.frameName, BACKTEST_METHOD_NAME_BACKGROUND);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BACKGROUND);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BACKGROUND));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BACKGROUND);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.background(symbol, context);
@@ -15946,11 +16002,11 @@ class BacktestUtils {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            bt.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_STOP);
+            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_STOP);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.stop(symbol, strategyName);
@@ -15969,11 +16025,11 @@ class BacktestUtils {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            bt.strategyValidationService.validate(strategyName, "BacktestUtils.getData");
+            backtest$1.strategyValidationService.validate(strategyName, "BacktestUtils.getData");
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, "BacktestUtils.getData");
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, "BacktestUtils.getData"));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, "BacktestUtils.getData");
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, "BacktestUtils.getData"));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.getData(symbol, strategyName);
@@ -15993,11 +16049,11 @@ class BacktestUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName, columns) => {
-            bt.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
+            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.getReport(symbol, strategyName, columns);
@@ -16020,11 +16076,11 @@ class BacktestUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, path, columns) => {
-            bt.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_DUMP);
+            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.dump(symbol, strategyName, path, columns);
@@ -16154,7 +16210,7 @@ class LiveInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_TASK, {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16173,7 +16229,7 @@ class LiveInstance {
          * ```
          */
         this.getStatus = async () => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_STATUS);
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_STATUS);
             return {
                 id: this.id,
                 symbol: this.symbol,
@@ -16192,27 +16248,27 @@ class LiveInstance {
          * @returns Infinite async generator yielding opened and closed signals
          */
         this.run = (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_RUN, {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_RUN, {
                 symbol,
                 context,
             });
             {
-                bt.backtestMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                bt.liveMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                bt.scheduleMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                bt.performanceMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                bt.partialMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                bt.riskMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.backtestMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.liveMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.scheduleMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.performanceMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.partialMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.riskMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
             }
             {
-                bt.strategyCoreService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear(false, { symbol, strategyName: context.strategyName });
             }
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskGlobalService.clear(false, riskName);
-                riskList && riskList.forEach((riskName) => bt.riskGlobalService.clear(false, riskName));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskGlobalService.clear(false, riskName);
+                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(false, riskName));
             }
-            return bt.liveCommandService.run(symbol, context);
+            return backtest$1.liveCommandService.run(symbol, context);
         };
         /**
          * Runs live trading in background without yielding results.
@@ -16235,7 +16291,7 @@ class LiveInstance {
          * ```
          */
         this.background = (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_BACKGROUND, {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_BACKGROUND, {
                 symbol,
                 context,
             });
@@ -16250,8 +16306,8 @@ class LiveInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(false, { symbol, strategyName: context.strategyName });
-                bt.strategyCoreService
+                backtest$1.strategyCoreService.stop(false, { symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService
                     .getPendingSignal(false, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
@@ -16288,11 +16344,11 @@ class LiveInstance {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_STOP, {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_STOP, {
                 symbol,
                 strategyName,
             });
-            await bt.strategyCoreService.stop(false, { symbol, strategyName });
+            await backtest$1.strategyCoreService.stop(false, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
@@ -16309,11 +16365,11 @@ class LiveInstance {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            bt.loggerService.info("LiveUtils.getData", {
+            backtest$1.loggerService.info("LiveUtils.getData", {
                 symbol,
                 strategyName,
             });
-            return await bt.liveMarkdownService.getData(symbol, strategyName, false);
+            return await backtest$1.liveMarkdownService.getData(symbol, strategyName, false);
         };
         /**
          * Generates markdown report with all events for a symbol-strategy pair.
@@ -16331,11 +16387,11 @@ class LiveInstance {
          * ```
          */
         this.getReport = async (symbol, strategyName, columns) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await bt.liveMarkdownService.getReport(symbol, strategyName, false, columns);
+            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName, false, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -16356,12 +16412,12 @@ class LiveInstance {
          * ```
          */
         this.dump = async (symbol, strategyName, path, columns) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_DUMP, {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await bt.liveMarkdownService.dump(symbol, strategyName, false, path, columns);
+            await backtest$1.liveMarkdownService.dump(symbol, strategyName, false, path, columns);
         };
     }
 }
@@ -16413,13 +16469,13 @@ class LiveUtils {
          */
         this.run = (symbol, context) => {
             {
-                bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_RUN);
-                bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_RUN);
+                backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_RUN);
+                backtest$1.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_RUN);
             }
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.run(symbol, context);
@@ -16446,12 +16502,12 @@ class LiveUtils {
          * ```
          */
         this.background = (symbol, context) => {
-            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_BACKGROUND);
-            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_BACKGROUND);
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_BACKGROUND);
+            backtest$1.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_BACKGROUND);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.strategyName);
             return instance.background(symbol, context);
@@ -16474,11 +16530,11 @@ class LiveUtils {
          * ```
          */
         this.stop = async (symbol, strategyName) => {
-            bt.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_STOP);
+            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_STOP);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.stop(symbol, strategyName);
@@ -16497,11 +16553,11 @@ class LiveUtils {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            bt.strategyValidationService.validate(strategyName, "LiveUtils.getData");
+            backtest$1.strategyValidationService.validate(strategyName, "LiveUtils.getData");
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.getData(symbol, strategyName);
@@ -16521,11 +16577,11 @@ class LiveUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName, columns) => {
-            bt.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_REPORT);
+            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.getReport(symbol, strategyName, columns);
@@ -16548,11 +16604,11 @@ class LiveUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, path, columns) => {
-            bt.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_DUMP);
+            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, strategyName);
             return await instance.dump(symbol, strategyName, path, columns);
@@ -16637,18 +16693,18 @@ class ScheduleUtils {
          * ```
          */
         this.getData = async (symbol, strategyName, backtest) => {
-            bt.loggerService.info(SCHEDULE_METHOD_NAME_GET_DATA, {
+            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_DATA, {
                 symbol,
                 strategyName,
                 backtest,
             });
-            bt.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
+            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA));
             }
-            return await bt.scheduleMarkdownService.getData(symbol, strategyName, backtest);
+            return await backtest$1.scheduleMarkdownService.getData(symbol, strategyName, backtest);
         };
         /**
          * Generates markdown report with all scheduled events for a symbol-strategy pair.
@@ -16665,18 +16721,18 @@ class ScheduleUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName, backtest, columns) => {
-            bt.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
+            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
                 backtest,
             });
-            bt.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
+            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT));
             }
-            return await bt.scheduleMarkdownService.getReport(symbol, strategyName, backtest, columns);
+            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName, backtest, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -16696,19 +16752,19 @@ class ScheduleUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, backtest, path, columns) => {
-            bt.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
+            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 backtest,
                 path,
             });
-            bt.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_DUMP);
+            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP));
             }
-            await bt.scheduleMarkdownService.dump(symbol, strategyName, backtest, path, columns);
+            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, backtest, path, columns);
         };
     }
 }
@@ -16790,13 +16846,13 @@ class Performance {
      * ```
      */
     static async getData(symbol, strategyName, backtest) {
-        bt.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
+        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
         {
-            const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-            riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA);
-            riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA));
+            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+            riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA);
+            riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA));
         }
-        return bt.performanceMarkdownService.getData(symbol, strategyName, backtest);
+        return backtest$1.performanceMarkdownService.getData(symbol, strategyName, backtest);
     }
     /**
      * Generates markdown report with performance analysis.
@@ -16822,13 +16878,13 @@ class Performance {
      * ```
      */
     static async getReport(symbol, strategyName, backtest, columns) {
-        bt.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
+        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
-            const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-            riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
-            riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT));
+            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+            riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
+            riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT));
         }
-        return bt.performanceMarkdownService.getReport(symbol, strategyName, backtest, columns);
+        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName, backtest, columns);
     }
     /**
      * Saves performance report to disk.
@@ -16851,13 +16907,13 @@ class Performance {
      * ```
      */
     static async dump(symbol, strategyName, backtest, path = "./dump/performance", columns) {
-        bt.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_DUMP);
+        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_DUMP);
         {
-            const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-            riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
-            riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP));
+            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+            riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
+            riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP));
         }
-        return bt.performanceMarkdownService.dump(symbol, strategyName, backtest, path, columns);
+        return backtest$1.performanceMarkdownService.dump(symbol, strategyName, backtest, path, columns);
     }
 }
 
@@ -16891,7 +16947,7 @@ const INSTANCE_TASK_FN = async (symbol, context, self) => {
         }
     }
     if (!self._isDone) {
-        const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
+        const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
         await doneWalkerSubject.next({
             exchangeName: walkerSchema.exchangeName,
             strategyName: context.walkerName,
@@ -16945,7 +17001,7 @@ class WalkerInstance {
          * @internal
          */
         this.task = functoolsKit.singlerun(async (symbol, context) => {
-            bt.loggerService.info(WALKER_METHOD_NAME_TASK, {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16964,7 +17020,7 @@ class WalkerInstance {
          * ```
          */
         this.getStatus = async () => {
-            bt.loggerService.info(WALKER_METHOD_NAME_GET_STATUS);
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_STATUS);
             return {
                 id: this.id,
                 symbol: this.symbol,
@@ -16980,39 +17036,39 @@ class WalkerInstance {
          * @returns Async generator yielding progress updates after each strategy
          */
         this.run = (symbol, context) => {
-            bt.loggerService.info(WALKER_METHOD_NAME_RUN, {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_RUN, {
                 symbol,
                 context,
             });
-            bt.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
-            const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
-            bt.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
-            bt.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+            backtest$1.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
+            backtest$1.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
             for (const strategyName of walkerSchema.strategies) {
-                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
+                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
             }
-            bt.walkerMarkdownService.clear(context.walkerName);
+            backtest$1.walkerMarkdownService.clear(context.walkerName);
             // Clear backtest data for all strategies
             for (const strategyName of walkerSchema.strategies) {
                 {
-                    bt.backtestMarkdownService.clear(true, { symbol, strategyName });
-                    bt.liveMarkdownService.clear(true, { symbol, strategyName });
-                    bt.scheduleMarkdownService.clear(true, { symbol, strategyName });
-                    bt.performanceMarkdownService.clear(true, { symbol, strategyName });
-                    bt.partialMarkdownService.clear(true, { symbol, strategyName });
-                    bt.riskMarkdownService.clear(true, { symbol, strategyName });
+                    backtest$1.backtestMarkdownService.clear(true, { symbol, strategyName });
+                    backtest$1.liveMarkdownService.clear(true, { symbol, strategyName });
+                    backtest$1.scheduleMarkdownService.clear(true, { symbol, strategyName });
+                    backtest$1.performanceMarkdownService.clear(true, { symbol, strategyName });
+                    backtest$1.partialMarkdownService.clear(true, { symbol, strategyName });
+                    backtest$1.riskMarkdownService.clear(true, { symbol, strategyName });
                 }
                 {
-                    bt.strategyCoreService.clear(true, { symbol, strategyName });
+                    backtest$1.strategyCoreService.clear(true, { symbol, strategyName });
                 }
                 {
-                    const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                    riskName && bt.riskGlobalService.clear(true, riskName);
+                    const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                    riskName && backtest$1.riskGlobalService.clear(true, riskName);
                     riskList &&
-                        riskList.forEach((riskName) => bt.riskGlobalService.clear(true, riskName));
+                        riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, riskName));
                 }
             }
-            return bt.walkerCommandService.run(symbol, {
+            return backtest$1.walkerCommandService.run(symbol, {
                 walkerName: context.walkerName,
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
@@ -17037,11 +17093,11 @@ class WalkerInstance {
          * ```
          */
         this.background = (symbol, context) => {
-            bt.loggerService.info(WALKER_METHOD_NAME_BACKGROUND, {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_BACKGROUND, {
                 symbol,
                 context,
             });
-            const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             {
                 const currentStatus = this.task.getStatus();
                 if (currentStatus === "pending") {
@@ -17054,7 +17110,7 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    bt.strategyCoreService.stop(true, { symbol, strategyName });
+                    backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
                     walkerStopSubject.next({
                         symbol,
                         strategyName,
@@ -17097,14 +17153,14 @@ class WalkerInstance {
          * ```
          */
         this.stop = async (symbol, walkerName) => {
-            bt.loggerService.info(WALKER_METHOD_NAME_STOP, {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_STOP, {
                 symbol,
                 walkerName,
             });
-            const walkerSchema = bt.walkerSchemaService.get(walkerName);
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName });
-                await bt.strategyCoreService.stop(true, { symbol, strategyName });
+                await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
             }
         };
         /**
@@ -17122,12 +17178,12 @@ class WalkerInstance {
          * ```
          */
         this.getData = async (symbol, walkerName) => {
-            bt.loggerService.info(WALKER_METHOD_NAME_GET_DATA, {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_DATA, {
                 symbol,
                 walkerName,
             });
-            const walkerSchema = bt.walkerSchemaService.get(walkerName);
-            return await bt.walkerMarkdownService.getData(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            return await backtest$1.walkerMarkdownService.getData(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             });
@@ -17149,12 +17205,12 @@ class WalkerInstance {
          * ```
          */
         this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
-            bt.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
                 symbol,
                 walkerName,
             });
-            const walkerSchema = bt.walkerSchemaService.get(walkerName);
-            return await bt.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            return await backtest$1.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             }, strategyColumns, pnlColumns);
@@ -17179,13 +17235,13 @@ class WalkerInstance {
          * ```
          */
         this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
-            bt.loggerService.info(WALKER_METHOD_NAME_DUMP, {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_DUMP, {
                 symbol,
                 walkerName,
                 path,
             });
-            const walkerSchema = bt.walkerSchemaService.get(walkerName);
-            await bt.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             }, path, strategyColumns, pnlColumns);
@@ -17226,17 +17282,17 @@ class WalkerUtils {
          * @returns Async generator yielding progress updates after each strategy
          */
         this.run = (symbol, context) => {
-            bt.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
-            const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
-            bt.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
-            bt.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+            backtest$1.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
+            backtest$1.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
             for (const strategyName of walkerSchema.strategies) {
-                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.run(symbol, context);
@@ -17261,17 +17317,17 @@ class WalkerUtils {
          * ```
          */
         this.background = (symbol, context) => {
-            bt.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_BACKGROUND);
-            const walkerSchema = bt.walkerSchemaService.get(context.walkerName);
-            bt.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_BACKGROUND);
-            bt.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_BACKGROUND);
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_BACKGROUND);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+            backtest$1.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_BACKGROUND);
+            backtest$1.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_BACKGROUND);
             for (const strategyName of walkerSchema.strategies) {
-                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_BACKGROUND);
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_BACKGROUND);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.background(symbol, context);
@@ -17300,15 +17356,15 @@ class WalkerUtils {
          * ```
          */
         this.stop = async (symbol, walkerName) => {
-            bt.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_STOP);
-            const walkerSchema = bt.walkerSchemaService.get(walkerName);
+            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_STOP);
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
-                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.stop(symbol, walkerName);
@@ -17327,15 +17383,15 @@ class WalkerUtils {
          * ```
          */
         this.getData = async (symbol, walkerName) => {
-            bt.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_DATA);
-            const walkerSchema = bt.walkerSchemaService.get(walkerName);
+            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_DATA);
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
-                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.getData(symbol, walkerName);
@@ -17356,15 +17412,15 @@ class WalkerUtils {
          * ```
          */
         this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
-            bt.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_REPORT);
-            const walkerSchema = bt.walkerSchemaService.get(walkerName);
+            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_REPORT);
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
-                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.getReport(symbol, walkerName, strategyColumns, pnlColumns);
@@ -17388,15 +17444,15 @@ class WalkerUtils {
          * ```
          */
         this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
-            bt.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_DUMP);
-            const walkerSchema = bt.walkerSchemaService.get(walkerName);
+            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_DUMP);
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
-                bt.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
+                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.dump(symbol, walkerName, path, strategyColumns, pnlColumns);
@@ -17489,14 +17545,14 @@ class HeatUtils {
          * ```
          */
         this.getData = async (strategyName, backtest) => {
-            bt.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName });
-            bt.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_DATA);
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName });
+            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA));
             }
-            return await bt.heatMarkdownService.getData(strategyName, backtest);
+            return await backtest$1.heatMarkdownService.getData(strategyName, backtest);
         };
         /**
          * Generates markdown report with portfolio heatmap table for a strategy.
@@ -17525,14 +17581,14 @@ class HeatUtils {
          * ```
          */
         this.getReport = async (strategyName, backtest, columns) => {
-            bt.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
-            bt.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_REPORT);
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
+            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT));
             }
-            return await bt.heatMarkdownService.getReport(strategyName, backtest, columns);
+            return await backtest$1.heatMarkdownService.getReport(strategyName, backtest, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -17554,14 +17610,14 @@ class HeatUtils {
          * ```
          */
         this.dump = async (strategyName, backtest, path, columns) => {
-            bt.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
-            bt.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_DUMP);
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
+            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP));
             }
-            await bt.heatMarkdownService.dump(strategyName, backtest, path, columns);
+            await backtest$1.heatMarkdownService.dump(strategyName, backtest, path, columns);
         };
     }
 }
@@ -17648,12 +17704,12 @@ class PositionSizeUtils {
  * @throws Error if sizing schema method is not "fixed-percentage"
  */
 PositionSizeUtils.fixedPercentage = async (symbol, accountBalance, priceOpen, priceStopLoss, context) => {
-    bt.loggerService.info(POSITION_SIZE_METHOD_NAME_FIXED, {
+    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_FIXED, {
         context,
         symbol,
     });
-    bt.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_FIXED, "fixed-percentage");
-    return await bt.sizingGlobalService.calculate({
+    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_FIXED, "fixed-percentage");
+    return await backtest$1.sizingGlobalService.calculate({
         symbol,
         accountBalance,
         priceOpen,
@@ -17674,12 +17730,12 @@ PositionSizeUtils.fixedPercentage = async (symbol, accountBalance, priceOpen, pr
  * @throws Error if sizing schema method is not "kelly-criterion"
  */
 PositionSizeUtils.kellyCriterion = async (symbol, accountBalance, priceOpen, winRate, winLossRatio, context) => {
-    bt.loggerService.info(POSITION_SIZE_METHOD_NAME_KELLY, {
+    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_KELLY, {
         context,
         symbol,
     });
-    bt.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_KELLY, "kelly-criterion");
-    return await bt.sizingGlobalService.calculate({
+    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_KELLY, "kelly-criterion");
+    return await backtest$1.sizingGlobalService.calculate({
         symbol,
         accountBalance,
         priceOpen,
@@ -17700,12 +17756,12 @@ PositionSizeUtils.kellyCriterion = async (symbol, accountBalance, priceOpen, win
  * @throws Error if sizing schema method is not "atr-based"
  */
 PositionSizeUtils.atrBased = async (symbol, accountBalance, priceOpen, atr, context) => {
-    bt.loggerService.info(POSITION_SIZE_METHOD_NAME_ATR, {
+    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_ATR, {
         context,
         symbol,
     });
-    bt.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_ATR, "atr-based");
-    return await bt.sizingGlobalService.calculate({
+    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_ATR, "atr-based");
+    return await backtest$1.sizingGlobalService.calculate({
         symbol,
         accountBalance,
         priceOpen,
@@ -17754,12 +17810,12 @@ class OptimizerUtils {
          * @throws Error if optimizer not found
          */
         this.getData = async (symbol, context) => {
-            bt.loggerService.info(OPTIMIZER_METHOD_NAME_GET_DATA, {
+            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_GET_DATA, {
                 symbol,
                 context,
             });
-            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_DATA);
-            return await bt.optimizerGlobalService.getData(symbol, context.optimizerName);
+            backtest$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_DATA);
+            return await backtest$1.optimizerGlobalService.getData(symbol, context.optimizerName);
         };
         /**
          * Generates complete executable strategy code.
@@ -17771,12 +17827,12 @@ class OptimizerUtils {
          * @throws Error if optimizer not found
          */
         this.getCode = async (symbol, context) => {
-            bt.loggerService.info(OPTIMIZER_METHOD_NAME_GET_CODE, {
+            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_GET_CODE, {
                 symbol,
                 context,
             });
-            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_CODE);
-            return await bt.optimizerGlobalService.getCode(symbol, context.optimizerName);
+            backtest$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_CODE);
+            return await backtest$1.optimizerGlobalService.getCode(symbol, context.optimizerName);
         };
         /**
          * Generates and saves strategy code to file.
@@ -17790,13 +17846,13 @@ class OptimizerUtils {
          * @throws Error if optimizer not found or file write fails
          */
         this.dump = async (symbol, context, path) => {
-            bt.loggerService.info(OPTIMIZER_METHOD_NAME_DUMP, {
+            backtest$1.loggerService.info(OPTIMIZER_METHOD_NAME_DUMP, {
                 symbol,
                 context,
                 path,
             });
-            bt.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_DUMP);
-            await bt.optimizerGlobalService.dump(symbol, context.optimizerName, path);
+            backtest$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_DUMP);
+            await backtest$1.optimizerGlobalService.dump(symbol, context.optimizerName, path);
         };
     }
 }
@@ -17878,14 +17934,14 @@ class PartialUtils {
          * ```
          */
         this.getData = async (symbol, strategyName, backtest) => {
-            bt.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName });
-            bt.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_DATA);
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName });
+            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA));
             }
-            return await bt.partialMarkdownService.getData(symbol, strategyName, backtest);
+            return await backtest$1.partialMarkdownService.getData(symbol, strategyName, backtest);
         };
         /**
          * Generates markdown report with all partial profit/loss events for a symbol-strategy pair.
@@ -17927,14 +17983,14 @@ class PartialUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName, backtest, columns) => {
-            bt.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
-            bt.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
+            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT));
             }
-            return await bt.partialMarkdownService.getReport(symbol, strategyName, backtest, columns);
+            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName, backtest, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -17969,14 +18025,14 @@ class PartialUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, backtest, path, columns) => {
-            bt.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
-            bt.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_DUMP);
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
+            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = bt.strategySchemaService.get(strategyName);
-                riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP));
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP));
             }
-            await bt.partialMarkdownService.dump(symbol, strategyName, backtest, path, columns);
+            await backtest$1.partialMarkdownService.dump(symbol, strategyName, backtest, path, columns);
         };
     }
 }
@@ -18077,8 +18133,201 @@ class ConstantUtils {
  */
 const Constant = new ConstantUtils();
 
+const EXCHANGE_METHOD_NAME_GET_CANDLES = "ExchangeUtils.getCandles";
+const EXCHANGE_METHOD_NAME_FORMAT_QUANTITY = "ExchangeUtils.formatQuantity";
+const EXCHANGE_METHOD_NAME_FORMAT_PRICE = "ExchangeUtils.formatPrice";
+/**
+ * Instance class for exchange operations on a specific exchange.
+ *
+ * Provides isolated exchange operations for a single exchange.
+ * Each instance maintains its own context and exposes IExchangeSchema methods.
+ * The schema is retrieved once during construction for better performance.
+ *
+ * @example
+ * ```typescript
+ * const instance = new ExchangeInstance("binance");
+ *
+ * const candles = await instance.getCandles("BTCUSDT", "1m", new Date(), 100);
+ * const formattedQty = await instance.formatQuantity("BTCUSDT", 0.001);
+ * const formattedPrice = await instance.formatPrice("BTCUSDT", 50000.123);
+ * ```
+ */
+class ExchangeInstance {
+    /**
+     * Creates a new ExchangeInstance for a specific exchange.
+     *
+     * @param exchangeName - Exchange name (e.g., "binance")
+     */
+    constructor(exchangeName) {
+        this.exchangeName = exchangeName;
+        /**
+         * Fetch candles from data source (API or database).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle time interval (e.g., "1m", "1h")
+         * @param since - Start date for candle fetching
+         * @param limit - Maximum number of candles to fetch
+         * @returns Promise resolving to array of OHLCV candle data
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const candles = await instance.getCandles("BTCUSDT", "1m", new Date(), 100);
+         * ```
+         */
+        this.getCandles = async (symbol, interval, since, limit) => {
+            backtest$1.loggerService.info(EXCHANGE_METHOD_NAME_GET_CANDLES, {
+                exchangeName: this.exchangeName,
+                symbol,
+                interval,
+                since,
+                limit,
+            });
+            return await this._schema.getCandles(symbol, interval, since, limit);
+        };
+        /**
+         * Format quantity according to exchange precision rules.
+         *
+         * @param symbol - Trading pair symbol
+         * @param quantity - Raw quantity value
+         * @returns Promise resolving to formatted quantity string
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const formatted = await instance.formatQuantity("BTCUSDT", 0.001);
+         * console.log(formatted); // "0.001"
+         * ```
+         */
+        this.formatQuantity = async (symbol, quantity) => {
+            backtest$1.loggerService.info(EXCHANGE_METHOD_NAME_FORMAT_QUANTITY, {
+                exchangeName: this.exchangeName,
+                symbol,
+                quantity,
+            });
+            return await this._schema.formatQuantity(symbol, quantity);
+        };
+        /**
+         * Format price according to exchange precision rules.
+         *
+         * @param symbol - Trading pair symbol
+         * @param price - Raw price value
+         * @returns Promise resolving to formatted price string
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const formatted = await instance.formatPrice("BTCUSDT", 50000.123);
+         * console.log(formatted); // "50000.12"
+         * ```
+         */
+        this.formatPrice = async (symbol, price) => {
+            backtest$1.loggerService.info(EXCHANGE_METHOD_NAME_FORMAT_PRICE, {
+                exchangeName: this.exchangeName,
+                symbol,
+                price,
+            });
+            return await this._schema.formatPrice(symbol, price);
+        };
+        this._schema = backtest$1.exchangeSchemaService.get(this.exchangeName);
+    }
+}
+/**
+ * Utility class for exchange operations.
+ *
+ * Provides simplified access to exchange schema methods with validation.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Exchange } from "./classes/Exchange";
+ *
+ * const candles = await Exchange.getCandles("BTCUSDT", "1m", new Date(), 100, {
+ *   exchangeName: "binance"
+ * });
+ * const formatted = await Exchange.formatQuantity("BTCUSDT", 0.001, {
+ *   exchangeName: "binance"
+ * });
+ * ```
+ */
+class ExchangeUtils {
+    constructor() {
+        /**
+         * Memoized function to get or create ExchangeInstance for an exchange.
+         * Each exchange gets its own isolated instance.
+         */
+        this._getInstance = functoolsKit.memoize(([exchangeName]) => exchangeName, (exchangeName) => new ExchangeInstance(exchangeName));
+        /**
+         * Fetch candles from data source (API or database).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle time interval (e.g., "1m", "1h")
+         * @param since - Start date for candle fetching
+         * @param limit - Maximum number of candles to fetch
+         * @param context - Execution context with exchange name
+         * @returns Promise resolving to array of OHLCV candle data
+         */
+        this.getCandles = async (symbol, interval, since, limit, context) => {
+            backtest$1.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_CANDLES);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.getCandles(symbol, interval, since, limit);
+        };
+        /**
+         * Format quantity according to exchange precision rules.
+         *
+         * @param symbol - Trading pair symbol
+         * @param quantity - Raw quantity value
+         * @param context - Execution context with exchange name
+         * @returns Promise resolving to formatted quantity string
+         */
+        this.formatQuantity = async (symbol, quantity, context) => {
+            backtest$1.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_FORMAT_QUANTITY);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.formatQuantity(symbol, quantity);
+        };
+        /**
+         * Format price according to exchange precision rules.
+         *
+         * @param symbol - Trading pair symbol
+         * @param price - Raw price value
+         * @param context - Execution context with exchange name
+         * @returns Promise resolving to formatted price string
+         */
+        this.formatPrice = async (symbol, price, context) => {
+            backtest$1.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_FORMAT_PRICE);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.formatPrice(symbol, price);
+        };
+    }
+}
+/**
+ * Singleton instance of ExchangeUtils for convenient exchange operations.
+ *
+ * @example
+ * ```typescript
+ * import { Exchange } from "./classes/Exchange";
+ *
+ * // Using static-like API with context
+ * const candles = await Exchange.getCandles("BTCUSDT", "1m", new Date(), 100, {
+ *   exchangeName: "binance"
+ * });
+ * const qty = await Exchange.formatQuantity("BTCUSDT", 0.001, {
+ *   exchangeName: "binance"
+ * });
+ * const price = await Exchange.formatPrice("BTCUSDT", 50000.123, {
+ *   exchangeName: "binance"
+ * });
+ *
+ * // Using instance API (no context needed, exchange set in constructor)
+ * const binance = new ExchangeInstance("binance");
+ * const candles2 = await binance.getCandles("BTCUSDT", "1m", new Date(), 100);
+ * ```
+ */
+const Exchange = new ExchangeUtils();
+
 exports.Backtest = Backtest;
 exports.Constant = Constant;
+exports.Exchange = Exchange;
 exports.ExecutionContextService = ExecutionContextService;
 exports.Heat = Heat;
 exports.Live = Live;
@@ -18114,6 +18363,7 @@ exports.getDate = getDate;
 exports.getDefaultColumns = getDefaultColumns;
 exports.getDefaultConfig = getDefaultConfig;
 exports.getMode = getMode;
+exports.hasTradeContext = hasTradeContext;
 exports.lib = backtest;
 exports.listExchanges = listExchanges;
 exports.listFrames = listFrames;