backtest-kit 1.5.29 → 1.5.30

package/build/index.mjs

@@ -2041,7 +2041,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,
     });
@@ -2099,7 +2099,7 @@ const PersistBase = makeExtendable(class {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a] = 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,
         });
@@ -2115,7 +2115,7 @@ const PersistBase = makeExtendable(class {
         return 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,
         });
@@ -2132,7 +2132,7 @@ const PersistBase = 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,
         });
@@ -2149,7 +2149,7 @@ const PersistBase = 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,
         });
@@ -2166,7 +2166,7 @@ const PersistBase = 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,
         });
@@ -2187,7 +2187,7 @@ const PersistBase = 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,
         });
@@ -2209,7 +2209,7 @@ const PersistBase = 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 {
@@ -2231,7 +2231,7 @@ const PersistBase = 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 {
@@ -2260,7 +2260,7 @@ const PersistBase = 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 {
@@ -2365,7 +2365,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);
@@ -2387,7 +2387,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);
@@ -2410,7 +2410,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;
     }
 }
@@ -2462,7 +2462,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);
@@ -2483,7 +2483,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);
@@ -2506,7 +2506,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;
     }
 }
@@ -2556,7 +2556,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);
@@ -2578,7 +2578,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);
@@ -2601,7 +2601,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;
     }
 }
@@ -2651,7 +2651,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);
@@ -2674,7 +2674,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);
@@ -2698,7 +2698,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;
     }
 }
@@ -3167,7 +3167,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        bt.loggerService.warn(message, payload);
+        backtest$1.loggerService.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -4347,7 +4347,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)));
@@ -4364,7 +4364,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,
         });
@@ -4381,7 +4381,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,
         });
@@ -4450,18 +4450,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.
@@ -4505,18 +4505,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.
@@ -4551,19 +4551,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);
         };
     }
 }
@@ -5181,7 +5181,7 @@ const DO_VALIDATION_FN = trycatch(async (validation, params) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        bt.loggerService.warn(message, payload);
+        backtest$1.loggerService.warn(message, payload);
         console.warn(message, payload);
         validationSubject.next(error);
     },
@@ -13659,7 +13659,7 @@ const backtest = {
     ...templateServices,
 };
 init();
-var bt = backtest;
+var backtest$1 = backtest;
 
 /**
  * Sets custom logger implementation for the framework.
@@ -13679,7 +13679,7 @@ var bt = backtest;
  * ```
  */
 function setLogger(logger) {
-    bt.loggerService.setLogger(logger);
+    backtest$1.loggerService.setLogger(logger);
 }
 /**
  * Sets global configuration parameters for the framework.
@@ -13697,7 +13697,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: ${getErrorMessage(error)}`, config);
@@ -13768,7 +13768,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: ${getErrorMessage(error)}`, columns);
@@ -13853,11 +13853,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.
@@ -13895,11 +13895,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.
@@ -13932,11 +13932,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.
@@ -13976,11 +13976,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.
@@ -14035,11 +14035,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.
@@ -14103,11 +14103,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.
@@ -14197,11 +14197,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";
@@ -14237,8 +14237,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.
@@ -14271,8 +14271,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.
@@ -14300,8 +14300,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.
@@ -14330,8 +14330,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.
@@ -14369,8 +14369,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.
@@ -14405,8 +14405,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.
@@ -14445,8 +14445,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";
@@ -14503,7 +14503,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14539,7 +14539,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);
 }
 /**
@@ -14563,7 +14563,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14588,7 +14588,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);
 }
 /**
@@ -14612,7 +14612,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14637,7 +14637,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);
 }
 /**
@@ -14665,7 +14665,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(queued(async (error) => fn(error)));
 }
 /**
@@ -14693,7 +14693,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(queued(async (error) => fn(error)));
 }
 /**
@@ -14724,7 +14724,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14754,7 +14754,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);
 }
 /**
@@ -14786,7 +14786,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14817,7 +14817,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);
 }
 /**
@@ -14847,7 +14847,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14876,7 +14876,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);
 }
 /**
@@ -14910,7 +14910,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14944,7 +14944,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(queued(async (event) => fn(event)));
 }
 /**
@@ -14972,7 +14972,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15008,7 +15008,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15042,7 +15042,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15085,7 +15085,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);
 }
 /**
@@ -15120,7 +15120,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15148,7 +15148,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(queued(async (error) => fn(error)));
 }
 /**
@@ -15176,7 +15176,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15210,7 +15210,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);
 }
 /**
@@ -15238,7 +15238,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15272,7 +15272,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);
 }
 /**
@@ -15304,7 +15304,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(queued(async (event) => fn(event)));
 }
 /**
@@ -15341,7 +15341,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);
 }
 
@@ -15351,6 +15351,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.
  *
@@ -15369,12 +15394,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.
@@ -15395,10 +15426,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.
@@ -15416,11 +15453,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.
@@ -15438,11 +15478,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.
@@ -15459,8 +15502,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());
 }
 /**
@@ -15479,9 +15525,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";
@@ -15552,13 +15601,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";
@@ -15645,7 +15694,7 @@ class BacktestInstance {
          * @internal
          */
         this.task = singlerun(async (symbol, context) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -15664,7 +15713,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,
@@ -15680,27 +15729,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.
@@ -15723,7 +15772,7 @@ class BacktestInstance {
          * ```
          */
         this.background = (symbol, context) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_BACKGROUND, {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_BACKGROUND, {
                 symbol,
                 context,
             });
@@ -15738,8 +15787,8 @@ class BacktestInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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) {
@@ -15776,11 +15825,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.
@@ -15797,11 +15846,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.
@@ -15819,11 +15868,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.
@@ -15844,12 +15893,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);
         };
     }
 }
@@ -15888,14 +15937,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);
@@ -15922,13 +15971,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);
@@ -15951,11 +16000,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);
@@ -15974,11 +16023,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);
@@ -15998,11 +16047,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);
@@ -16025,11 +16074,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);
@@ -16159,7 +16208,7 @@ class LiveInstance {
          * @internal
          */
         this.task = singlerun(async (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_TASK, {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16178,7 +16227,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,
@@ -16197,27 +16246,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.
@@ -16240,7 +16289,7 @@ class LiveInstance {
          * ```
          */
         this.background = (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_BACKGROUND, {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_BACKGROUND, {
                 symbol,
                 context,
             });
@@ -16255,8 +16304,8 @@ class LiveInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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) {
@@ -16293,11 +16342,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.
@@ -16314,11 +16363,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.
@@ -16336,11 +16385,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.
@@ -16361,12 +16410,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);
         };
     }
 }
@@ -16418,13 +16467,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);
@@ -16451,12 +16500,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);
@@ -16479,11 +16528,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);
@@ -16502,11 +16551,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);
@@ -16526,11 +16575,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);
@@ -16553,11 +16602,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);
@@ -16642,18 +16691,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.
@@ -16670,18 +16719,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.
@@ -16701,19 +16750,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);
         };
     }
 }
@@ -16795,13 +16844,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.
@@ -16827,13 +16876,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.
@@ -16856,13 +16905,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);
     }
 }
 
@@ -16896,7 +16945,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,
@@ -16950,7 +16999,7 @@ class WalkerInstance {
          * @internal
          */
         this.task = singlerun(async (symbol, context) => {
-            bt.loggerService.info(WALKER_METHOD_NAME_TASK, {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_TASK, {
                 symbol,
                 context,
             });
@@ -16969,7 +17018,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,
@@ -16985,39 +17034,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,
@@ -17042,11 +17091,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") {
@@ -17059,7 +17108,7 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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,
@@ -17102,14 +17151,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 });
             }
         };
         /**
@@ -17127,12 +17176,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,
             });
@@ -17154,12 +17203,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);
@@ -17184,13 +17233,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);
@@ -17231,17 +17280,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);
@@ -17266,17 +17315,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);
@@ -17305,15 +17354,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);
@@ -17332,15 +17381,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);
@@ -17361,15 +17410,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);
@@ -17393,15 +17442,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);
@@ -17494,14 +17543,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.
@@ -17530,14 +17579,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.
@@ -17559,14 +17608,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);
         };
     }
 }
@@ -17653,12 +17702,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,
@@ -17679,12 +17728,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,
@@ -17705,12 +17754,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,
@@ -17759,12 +17808,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.
@@ -17776,12 +17825,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.
@@ -17795,13 +17844,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);
         };
     }
 }
@@ -17883,14 +17932,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.
@@ -17932,14 +17981,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.
@@ -17974,14 +18023,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);
         };
     }
 }
@@ -18082,4 +18131,196 @@ class ConstantUtils {
  */
 const Constant = new ConstantUtils();
 
-export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setColumns, setConfig, setLogger };
+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 = 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();
+
+export { Backtest, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setColumns, setConfig, setLogger };