backtest-kit 11.7.0 → 11.9.0

package/build/index.mjs

@@ -74,6 +74,7 @@ const metaServices$1 = {
     contextMetaService: Symbol('contextMetaService'),
     priceMetaService: Symbol('priceMetaService'),
     timeMetaService: Symbol('timeMetaService'),
+    runtimeMetaService: Symbol('runtimeMetaService'),
 };
 const globalServices$1 = {
     sizingGlobalService: Symbol('sizingGlobalService'),
@@ -4660,7 +4661,7 @@ const LOGGER_SERVICE$8 = new LoggerService();
  * @param backtest - `true` for backtest, `false` for live.
  * @returns Colon-joined composite key.
  */
-const CREATE_KEY_FN$y = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$B = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -4703,7 +4704,7 @@ class LookupUtils {
             LOGGER_SERVICE$8.info(METHOD_NAME_ADD_ACTIVITY, {
                 activity,
             });
-            const key = CREATE_KEY_FN$y(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
+            const key = CREATE_KEY_FN$B(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
             this._lookupMap.set(key, activity);
         };
         /**
@@ -4717,7 +4718,7 @@ class LookupUtils {
             LOGGER_SERVICE$8.info(METHOD_NAME_REMOVE_ACTIVITY, {
                 activity,
             });
-            const key = CREATE_KEY_FN$y(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
+            const key = CREATE_KEY_FN$B(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
             this._lookupMap.delete(key);
         };
         /**
@@ -12335,7 +12336,7 @@ const GET_RISK_FN = (dto, backtest, exchangeName, frameName, self) => {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$x = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$A = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -12356,6 +12357,7 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strateg
         symbol,
         strategyName,
         exchangeName,
+        frameName: data.frameName,
         currentPrice,
         data,
         backtest,
@@ -12423,6 +12425,7 @@ const CREATE_COMMIT_ACTIVE_PING_FN = (self) => trycatch(async (symbol, strategyN
         symbol,
         strategyName,
         exchangeName,
+        frameName: data.frameName,
         currentPrice,
         data,
         backtest,
@@ -12635,7 +12638,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$x(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$A(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval = STRATEGY_DEFAULT_INTERVAL, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -13597,7 +13600,7 @@ class StrategyConnectionService {
                 }
                 return;
             }
-            const key = CREATE_KEY_FN$x(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$A(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getStrategy.has(key)) {
                 return;
             }
@@ -13995,11 +13998,51 @@ class StrategyConnectionService {
     }
 }
 
+const MS_PER_MINUTE$6 = 60000;
+const INTERVAL_MINUTES$7 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+    "1d": 1440,
+};
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
+ *
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
+ *
+ * @param date - Date to align
+ * @param interval - Candle interval (e.g., "1m", "15m", "1h")
+ * @returns New Date aligned down to interval boundary
+ */
+const alignToInterval = (date, interval) => {
+    const minutes = INTERVAL_MINUTES$7[interval];
+    if (minutes === undefined) {
+        throw new Error(`alignToInterval: unknown interval=${interval}`);
+    }
+    const intervalMs = minutes * MS_PER_MINUTE$6;
+    return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
+};
+
 /**
  * Maps FrameInterval to minutes for timestamp calculation.
  * Used to generate timeframe arrays with proper spacing.
  */
-const INTERVAL_MINUTES$7 = {
+const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -14053,7 +14096,7 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
         symbol,
     });
     const { interval, startDate, endDate } = self.params;
-    const intervalMinutes = INTERVAL_MINUTES$7[interval];
+    const intervalMinutes = INTERVAL_MINUTES$6[interval];
     if (!intervalMinutes) {
         throw new Error(`ClientFrame unknown interval: ${interval}`);
     }
@@ -14062,8 +14105,14 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
     today.setUTCHours(0, 0, 0, 0);
     // Ensure endDate doesn't go beyond today
     const effectiveEndDate = endDate > today ? today : endDate;
+    // Align the iteration start down to the 1-minute boundary so every generated
+    // timestamp lands on a clean minute, matching live mode
+    // (LiveLogicPrivateService aligns `when` via alignToInterval(new Date(), "1m")).
+    // Without this, a startDate carrying sub-minute (or any non-aligned) offset
+    // would propagate that offset to every tick `when` — and therefore to
+    // IRuntimeInfo.when handed to Cron handlers — diverging from live behaviour.
     const timeframes = [];
-    let currentDate = new Date(startDate);
+    let currentDate = alignToInterval(startDate, "1m");
     while (currentDate <= effectiveEndDate) {
         timeframes.push(new Date(currentDate));
         currentDate = new Date(currentDate.getTime() + intervalMinutes * 60 * 1000);
@@ -14097,6 +14146,7 @@ class ClientFrame {
     }
 }
 
+const DEFAULT_INTERVAL = "1m";
 /**
  * Connection service routing frame operations to correct ClientFrame instance.
  *
@@ -14140,7 +14190,7 @@ class FrameConnectionService {
                 logger: this.loggerService,
                 startDate,
                 endDate,
-                interval,
+                interval: interval || DEFAULT_INTERVAL,
                 callbacks,
             });
         });
@@ -14799,7 +14849,7 @@ class ClientRisk {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$w = (riskName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$z = (riskName, exchangeName, frameName, backtest) => {
     const parts = [riskName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -14899,7 +14949,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$w(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$z(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
@@ -14989,7 +15039,7 @@ class RiskConnectionService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$w(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$z(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -16108,7 +16158,7 @@ class ClientAction {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$v = (actionName, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$y = (actionName, strategyName, exchangeName, frameName, backtest) => {
     const parts = [actionName, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -16160,7 +16210,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$v(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$y(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
             const schema = this.actionSchemaService.get(actionName);
             return new ClientAction({
                 ...schema,
@@ -16386,7 +16436,7 @@ class ActionConnectionService {
                 await Promise.all(actions.map(async (action) => await action.dispose()));
                 return;
             }
-            const key = CREATE_KEY_FN$v(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$y(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getAction.has(key)) {
                 return;
             }
@@ -16397,14 +16447,14 @@ class ActionConnectionService {
     }
 }
 
-const METHOD_NAME_VALIDATE$3 = "exchangeCoreService validate";
+const METHOD_NAME_VALIDATE$6 = "exchangeCoreService validate";
 /**
  * Creates a unique key for memoizing validate calls.
  * Key format: "exchangeName"
  * @param exchangeName - Exchange name
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$u = (exchangeName) => {
+const CREATE_KEY_FN$x = (exchangeName) => {
     return exchangeName;
 };
 /**
@@ -16428,11 +16478,11 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$u(exchangeName), async (exchangeName) => {
-            this.loggerService.log(METHOD_NAME_VALIDATE$3, {
+        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$x(exchangeName), async (exchangeName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$6, {
                 exchangeName,
             });
-            this.exchangeValidationService.validate(exchangeName, METHOD_NAME_VALIDATE$3);
+            this.exchangeValidationService.validate(exchangeName, METHOD_NAME_VALIDATE$6);
         });
         /**
          * Fetches historical candles with execution context.
@@ -16701,14 +16751,14 @@ class ExchangeCoreService {
     }
 }
 
-const METHOD_NAME_VALIDATE$2 = "strategyCoreService validate";
+const METHOD_NAME_VALIDATE$5 = "strategyCoreService validate";
 /**
  * Creates a unique key for memoizing validate calls.
  * Key format: "strategyName:exchangeName:frameName"
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$t = (context) => {
+const CREATE_KEY_FN$w = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -16731,6 +16781,7 @@ class StrategyCoreService {
         this.strategyValidationService = inject(TYPES.strategyValidationService);
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         this.frameValidationService = inject(TYPES.frameValidationService);
+        this.actionValidationService = inject(TYPES.actionValidationService);
         /**
          * Validates strategy and associated risk configuration.
          *
@@ -16740,16 +16791,17 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$t(context), async (context) => {
-            this.loggerService.log(METHOD_NAME_VALIDATE$2, {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$w(context), async (context) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$5, {
                 context,
             });
-            const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
-            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE$2);
-            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE$2);
-            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE$2);
-            riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$2);
-            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$2));
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
+            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE$5);
+            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE$5);
+            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE$5);
+            riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$5);
+            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$5));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_VALIDATE$5));
         });
         /**
          * Retrieves the currently active pending signal for the symbol.
@@ -18110,7 +18162,7 @@ class SizingGlobalService {
  * @param context - Context with riskName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$s = (context) => {
+const CREATE_KEY_FN$v = (context) => {
     const parts = [context.riskName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -18136,7 +18188,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$s(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$v(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -18228,14 +18280,14 @@ class RiskGlobalService {
     }
 }
 
-const METHOD_NAME_VALIDATE$1 = "actionCoreService validate";
+const METHOD_NAME_VALIDATE$4 = "actionCoreService validate";
 /**
  * Creates a unique key for memoizing validate calls.
  * Key format: "strategyName:exchangeName:frameName"
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$r = (context) => {
+const CREATE_KEY_FN$u = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -18279,17 +18331,17 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$r(context), async (context) => {
-            this.loggerService.log(METHOD_NAME_VALIDATE$1, {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$u(context), async (context) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$4, {
                 context,
             });
             const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
-            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE$1);
-            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE$1);
-            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE$1);
-            riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$1);
-            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$1));
-            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_VALIDATE$1));
+            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE$4);
+            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE$4);
+            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE$4);
+            riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$4);
+            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE$4));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_VALIDATE$4));
         });
         /**
          * Initializes all ClientAction instances for the strategy.
@@ -18785,8 +18837,8 @@ class FrameSchemaService {
             if (typeof frameSchema.frameName !== "string") {
                 throw new Error(`frame schema validation failed: missing frameName`);
             }
-            if (typeof frameSchema.interval !== "string") {
-                throw new Error(`frame schema validation failed: missing interval for frameName=${frameSchema.frameName}`);
+            if (frameSchema.interval && typeof frameSchema.interval !== "string") {
+                throw new Error(`frame schema validation failed: invalid interval for frameName=${frameSchema.frameName}`);
             }
             if (!(frameSchema.startDate instanceof Date)) {
                 throw new Error(`frame schema validation failed: missing startDate for frameName=${frameSchema.frameName}`);
@@ -19914,8 +19966,8 @@ class BacktestLogicPrivateService {
 }
 
 const EMITTER_CHECK_INTERVAL = 5000;
-const MS_PER_MINUTE$6 = 60000;
-const INTERVAL_MINUTES$6 = {
+const MS_PER_MINUTE$5 = 60000;
+const INTERVAL_MINUTES$5 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -19930,7 +19982,7 @@ const INTERVAL_MINUTES$6 = {
 };
 const createEmitter = memoize(([interval]) => `${interval}`, (interval) => {
     const tickSubject = new Subject();
-    const intervalMs = INTERVAL_MINUTES$6[interval] * MS_PER_MINUTE$6;
+    const intervalMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$5;
     {
         let lastAligned = Math.floor(Date.now() / intervalMs) * intervalMs;
         Source.fromInterval(EMITTER_CHECK_INTERVAL)
@@ -19957,46 +20009,6 @@ const waitForCandle = async (interval) => {
     return emitter.toPromise();
 };
 
-const MS_PER_MINUTE$5 = 60000;
-const INTERVAL_MINUTES$5 = {
-    "1m": 1,
-    "3m": 3,
-    "5m": 5,
-    "15m": 15,
-    "30m": 30,
-    "1h": 60,
-    "2h": 120,
-    "4h": 240,
-    "6h": 360,
-    "8h": 480,
-    "1d": 1440,
-};
-/**
- * Aligns timestamp down to the nearest interval boundary.
- * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
- *
- * Candle timestamp convention:
- * - Candle timestamp = openTime (when candle opens)
- * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
- *
- * Adapter contract:
- * - Adapter must return candles with timestamp = openTime
- * - First returned candle.timestamp must equal aligned since
- * - Adapter must return exactly `limit` candles
- *
- * @param date - Date to align
- * @param interval - Candle interval (e.g., "1m", "15m", "1h")
- * @returns New Date aligned down to interval boundary
- */
-const alignToInterval = (date, interval) => {
-    const minutes = INTERVAL_MINUTES$5[interval];
-    if (minutes === undefined) {
-        throw new Error(`alignToInterval: unknown interval=${interval}`);
-    }
-    const intervalMs = minutes * MS_PER_MINUTE$5;
-    return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
-};
-
 /**
  * Private service for live trading orchestration using async generators.
  *
@@ -20819,6 +20831,17 @@ class WalkerLogicPublicService {
 }
 
 const METHOD_NAME_RUN$2 = "liveCommandService run";
+const METHOD_NAME_VALIDATE$3 = "liveCommandService validate";
+/**
+ * Creates a unique key for memoizing validate calls.
+ * Key format: "strategyName:exchangeName:frameName"
+ * @param context - Context with strategyName, exchangeName, frameName
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$t = (context) => {
+    const parts = [context.strategyName, context.exchangeName];
+    return parts.join(":");
+};
 /**
  * Global service providing access to live trading functionality.
  *
@@ -20834,6 +20857,25 @@ class LiveCommandService {
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskValidationService = inject(TYPES.riskValidationService);
         this.actionValidationService = inject(TYPES.actionValidationService);
+        /**
+         * Validates strategy and associated risk configuration.
+         * Memoized to avoid redundant validations for the same strategy-exchange combination.
+         *
+         * @param context - Context with strategyName, exchangeName
+         * @param methodName - Name of the calling method for error tracking
+         */
+        this.validate = memoize(([context]) => CREATE_KEY_FN$t(context), (context, methodName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$3, {
+                context,
+                methodName,
+            });
+            this.strategyValidationService.validate(context.strategyName, methodName);
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
+            riskName && this.riskValidationService.validate(riskName, methodName);
+            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
+        });
         /**
          * Runs live trading for a symbol with context propagation.
          *
@@ -20848,22 +20890,26 @@ class LiveCommandService {
                 symbol,
                 context,
             });
-            {
-                this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$2);
-                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$2);
-            }
-            {
-                const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
-                riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN$2);
-                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN$2));
-                actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_RUN$2));
-            }
+            this.validate(context, METHOD_NAME_RUN$2);
             return this.liveLogicPublicService.run(symbol, context);
         };
     }
 }
 
 const METHOD_NAME_RUN$1 = "backtestCommandService run";
+const METHOD_NAME_VALIDATE$2 = "backtestCommandService validate";
+/**
+ * Creates a unique key for memoizing validate calls.
+ * Key format: "strategyName:exchangeName:frameName"
+ * @param context - Context with strategyName, exchangeName, frameName
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$s = (context) => {
+    const parts = [context.strategyName, context.exchangeName];
+    if (context.frameName)
+        parts.push(context.frameName);
+    return parts.join(":");
+};
 /**
  * Global service providing access to backtest functionality.
  *
@@ -20880,6 +20926,26 @@ class BacktestCommandService {
         this.strategyValidationService = inject(TYPES.strategyValidationService);
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         this.frameValidationService = inject(TYPES.frameValidationService);
+        /**
+         * Validates strategy and associated risk configuration.
+         * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
+         *
+         * @param context - Context with strategyName, exchangeName and frameName
+         * @param methodName - Name of the calling method for error tracking
+         */
+        this.validate = memoize(([context]) => CREATE_KEY_FN$s(context), (context, methodName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$2, {
+                context,
+                methodName,
+            });
+            this.strategyValidationService.validate(context.strategyName, methodName);
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
+            this.frameValidationService.validate(context.frameName, methodName);
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
+            riskName && this.riskValidationService.validate(riskName, methodName);
+            riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
+        });
         /**
          * Runs backtest for a symbol with context propagation.
          *
@@ -20892,23 +20958,26 @@ class BacktestCommandService {
                 symbol,
                 context,
             });
-            {
-                this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$1);
-                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$1);
-                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN$1);
-            }
-            {
-                const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
-                riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1);
-                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1));
-                actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_RUN$1));
-            }
+            this.validate(context, METHOD_NAME_RUN$1);
             return this.backtestLogicPublicService.run(symbol, context);
         };
     }
 }
 
 const METHOD_NAME_RUN = "walkerCommandService run";
+const METHOD_NAME_VALIDATE$1 = "walkerCommandService validate";
+/**
+ * Creates a unique key for memoizing validate calls.
+ * Key format: "walkerName:exchangeName:frameName"
+ * @param context - Context with walkerName, exchangeName, frameName
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$r = (context) => {
+    const parts = [context.walkerName, context.exchangeName];
+    if (context.frameName)
+        parts.push(context.frameName);
+    return parts.join(":");
+};
 /**
  * Global service providing access to walker functionality.
  *
@@ -20927,6 +20996,34 @@ class WalkerCommandService {
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskValidationService = inject(TYPES.riskValidationService);
         this.actionValidationService = inject(TYPES.actionValidationService);
+        /**
+         * Validates walker and associated strategy configurations.
+         * Memoized to avoid redundant validations for the same walker-exchange-frame combination.
+         *
+         * Strategy/risk/action validation is performed explicitly here in addition to the
+         * cascade inside WalkerValidationService — this is critical-path code and the
+         * redundant check is intentional defense-in-depth.
+         *
+         * @param context - Context with walkerName, exchangeName and frameName
+         * @param methodName - Name of the calling method for error tracking
+         */
+        this.validate = memoize(([context]) => CREATE_KEY_FN$r(context), (context, methodName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$1, {
+                context,
+                methodName,
+            });
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
+            this.frameValidationService.validate(context.frameName, methodName);
+            this.walkerValidationService.validate(context.walkerName, methodName);
+            const walkerSchema = this.walkerSchemaService.get(context.walkerName);
+            for (const strategyName of walkerSchema.strategies) {
+                const { riskName, riskList, actions } = this.strategySchemaService.get(strategyName);
+                this.strategyValidationService.validate(strategyName, methodName);
+                riskName && this.riskValidationService.validate(riskName, methodName);
+                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+                actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
+            }
+        });
         /**
          * Runs walker comparison for a symbol with context propagation.
          *
@@ -20938,21 +21035,7 @@ class WalkerCommandService {
                 symbol,
                 context,
             });
-            {
-                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN);
-                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN);
-                this.walkerValidationService.validate(context.walkerName, METHOD_NAME_RUN);
-            }
-            {
-                const walkerSchema = this.walkerSchemaService.get(context.walkerName);
-                for (const strategyName of walkerSchema.strategies) {
-                    const { riskName, riskList, actions } = this.strategySchemaService.get(strategyName);
-                    this.strategyValidationService.validate(strategyName, METHOD_NAME_RUN);
-                    riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN);
-                    riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN));
-                    actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, METHOD_NAME_RUN));
-                }
-            }
+            this.validate(context, METHOD_NAME_RUN);
             return this.walkerLogicPublicService.run(symbol, context);
         };
     }
@@ -28675,6 +28758,36 @@ class WalkerValidationService {
          * Injected logger service instance
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * @readonly
+         * Injected walker schema service instance
+         */
+        this.walkerSchemaService = inject(TYPES.walkerSchemaService);
+        /**
+         * @private
+         * @readonly
+         * Injected strategy validation service instance
+         */
+        this.strategyValidationService = inject(TYPES.strategyValidationService);
+        /**
+         * @private
+         * @readonly
+         * Injected strategy schema service instance
+         */
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        /**
+         * @private
+         * @readonly
+         * Injected risk validation service instance
+         */
+        this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * @private
+         * @readonly
+         * Injected action validation service instance
+         */
+        this.actionValidationService = inject(TYPES.actionValidationService);
         /**
          * @private
          * Map storing walker schemas by walker name
@@ -28696,9 +28809,12 @@ class WalkerValidationService {
             this._walkerMap.set(walkerName, walkerSchema);
         };
         /**
-         * Validates the existence of a walker
+         * Validates the existence of a walker and its associated strategy configurations.
+         * Each strategy referenced by the walker is validated via StrategyValidationService,
+         * which in turn validates the strategy's risk profiles and actions.
          * @public
          * @throws {Error} If walkerName is not found
+         * @throws {Error} If any referenced strategy (or its risk/actions) is invalid
          * Memoized function to cache validation results
          */
         this.validate = memoize(([walkerName]) => walkerName, (walkerName, source) => {
@@ -28710,6 +28826,14 @@ class WalkerValidationService {
             if (!walker) {
                 throw new Error(`walker ${walkerName} not found source=${source}`);
             }
+            const walkerSchema = this.walkerSchemaService.get(walkerName);
+            for (const strategyName of walkerSchema.strategies) {
+                const { riskName, riskList, actions } = this.strategySchemaService.get(strategyName);
+                this.strategyValidationService.validate(strategyName, source);
+                riskName && this.riskValidationService.validate(riskName, source);
+                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, source));
+                actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, source));
+            }
             return true;
         });
         /**
@@ -30146,6 +30270,10 @@ class PartialGlobalService {
          * Frame validation service for validating frame existence.
          */
         this.frameValidationService = inject(TYPES.frameValidationService);
+        /**
+         * Action validation service for validating action existence.
+         */
+        this.actionValidationService = inject(TYPES.actionValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -30161,9 +30289,10 @@ class PartialGlobalService {
             this.strategyValidationService.validate(context.strategyName, methodName);
             this.exchangeValidationService.validate(context.exchangeName, methodName);
             context.frameName && this.frameValidationService.validate(context.frameName, methodName);
-            const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
         });
         /**
          * Processes profit state and emits events for newly reached profit levels.
@@ -31230,6 +31359,10 @@ class BreakevenGlobalService {
          * Frame validation service for validating frame existence.
          */
         this.frameValidationService = inject(TYPES.frameValidationService);
+        /**
+         * Action validation service for validating frame existence.
+         */
+        this.actionValidationService = inject(TYPES.actionValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -31245,9 +31378,10 @@ class BreakevenGlobalService {
             this.strategyValidationService.validate(context.strategyName, methodName);
             this.exchangeValidationService.validate(context.exchangeName, methodName);
             context.frameName && this.frameValidationService.validate(context.frameName, methodName);
-            const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
+            const { riskName, riskList, actions } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
+            actions && actions.forEach((actionName) => this.actionValidationService.validate(actionName, methodName));
         });
         /**
          * Checks if breakeven should be triggered and emits event if conditions met.
@@ -36135,6 +36269,21 @@ class PriceMetaService {
          * Instances are cached until clear() is called.
          */
         this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        /**
+         * Checks if a price exists for the given key and has emitted at least one value.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns True if a price exists and has emitted a value, false otherwise
+         */
+        this.hasPrice = (symbol, context, backtest) => {
+            const key = CREATE_KEY_FN$b(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            if (!this.getSource.has(key)) {
+                return false;
+            }
+            return !!this.getSource.get(key)?.data;
+        };
         /**
          * Returns the current market price for the given symbol and context.
          *
@@ -36797,6 +36946,129 @@ class NotificationHelperService {
     }
 }
 
+const GET_RANGE_FN = trycatch((self, context, backtest) => {
+    if (!backtest) {
+        return null;
+    }
+    const { startDate, endDate } = self.frameSchemaService.get(context.frameName);
+    return {
+        from: startDate,
+        to: endDate,
+    };
+}, {
+    fallback: (error, self) => {
+        const message = "RuntimeMetaService GET_RANGE_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+const GET_INFO_FN = trycatch((self, context) => {
+    const { info } = self.strategySchemaService.get(context.strategyName);
+    return info || null;
+}, {
+    fallback: (error, self) => {
+        const message = "RuntimeMetaService GET_INFO_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+const GET_PRICE_FN = trycatch(async (self, symbol, context, backtest) => {
+    return await self.priceMetaService.getCurrentPrice(symbol, context, backtest);
+}, {
+    fallback: (error, self) => {
+        const message = "RuntimeMetaService GET_PRICE_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+const RuntimeMetaService = singleton(class {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.timeMetaService = inject(TYPES.timeMetaService);
+        this.priceMetaService = inject(TYPES.priceMetaService);
+        this.frameSchemaService = inject(TYPES.frameSchemaService);
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        /**
+         * Fetches the time range for the current strategy execution context.
+         *
+         * For backtest mode, it retrieves the start and end dates from the frame schema.
+         * For live mode, it returns null since there is no predefined time range.
+         *
+         * This method is memoized to optimize performance, as the time range for a given context will not change during execution.
+         *
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns An object containing 'from' and 'to' Date objects for backtest mode, or null for live mode
+         */
+        this._getRange = memoize(([context, backtest]) => `${context.frameName}:${backtest ? "backtest" : "live"}`, (context, backtest) => {
+            return GET_RANGE_FN(this, context, backtest);
+        });
+        /**
+         * Fetches strategy-defined runtime information for the current execution context.
+         *
+         * This method retrieves the 'info' object defined in the strategy schema, which can contain any custom data the strategy wants to track at runtime.
+         * The content of this object is not defined by the system and can be used freely by strategy implementations for monitoring, reporting, or external logic.
+         *
+         * This method is memoized to optimize performance, as the strategy info for a given context will not change during execution.
+         *
+         * @param context - Strategy, exchange, and frame identifiers
+         * @returns The 'info' object defined in the strategy schema for the given strategy, or null if not defined
+         */
+        this._getInfo = memoize(([context]) => context.strategyName, (context) => {
+            return GET_INFO_FN(this, context);
+        });
+        /**
+         * Fetches comprehensive runtime information for a given symbol and strategy context, including current price, timestamp, and strategy-specific info.
+         *
+         * This method aggregates data from multiple sources (time, price, frame schema, strategy schema) to provide a complete picture of the current runtime state for a strategy tick.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns An object containing symbol, time range, strategy-defined info, context, timestamp, current price, and backtest flag
+         */
+        this.getRuntimeInfo = async (symbol, context, backtest) => {
+            this.loggerService.log("runtimeMetaService getRuntimeInfo", {
+                symbol,
+                context,
+                backtest,
+            });
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            const when = new Date(timestamp);
+            const currentPrice = await GET_PRICE_FN(this, symbol, context, backtest);
+            const range = this._getRange(context, backtest);
+            const info = this._getInfo(context);
+            return {
+                symbol,
+                range,
+                info,
+                context,
+                backtest,
+                when,
+                currentPrice,
+            };
+        };
+    }
+});
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -36833,6 +37105,7 @@ class NotificationHelperService {
     provide(TYPES.contextMetaService, () => new ContextMetaService());
     provide(TYPES.priceMetaService, () => new PriceMetaService());
     provide(TYPES.timeMetaService, () => new TimeMetaService());
+    provide(TYPES.runtimeMetaService, () => new RuntimeMetaService());
 }
 {
     provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
@@ -36936,6 +37209,7 @@ const metaServices = {
     timeMetaService: inject(TYPES.timeMetaService),
     priceMetaService: inject(TYPES.priceMetaService),
     contextMetaService: inject(TYPES.contextMetaService),
+    runtimeMetaService: inject(TYPES.runtimeMetaService),
 };
 const globalServices = {
     sizingGlobalService: inject(TYPES.sizingGlobalService),
@@ -50449,6 +50723,7 @@ const GET_TIMESTAMP_METHOD_NAME = "meta.getTimestamp";
 const GET_MODE_METHOD_NAME = "meta.getMode";
 const GET_SYMBOL_METHOD_NAME = "meta.getSymbol";
 const GET_CONTEXT_METHOD_NAME = "meta.getContext";
+const GET_RUNTIME_INFO_METHOD_NAME = "meta.getRuntimeInfo";
 /**
  * Gets the current date from execution context.
  *
@@ -50565,6 +50840,45 @@ async function getContext() {
     }
     return backtest.methodContextService.context;
 }
+/**
+ * Gets runtime information about the current execution environment.
+ *
+ * This includes details such as the current symbol, exchange, timeframe, strategy, and whether it's a backtest or live run.
+ *
+ * @returns Promise resolving to an object containing runtime information
+ * @throws Error if method context or execution context is not active
+ *
+ * @example
+ * ```typescript
+ * const runtimeInfo = await getRuntimeInfo();
+ * console.log(runtimeInfo);
+ * // {
+ * //   symbol: "BTCUSDT",
+ * //   context: {,
+ * //     exchangeName: "Binance",
+ * //     frameName: "1m",
+ * //     strategyName: "MyStrategy",
+ * //   },
+ * //   backtest: false
+ * // }
+ * ```
+ */
+async function getRuntimeInfo() {
+    backtest.loggerService.info(GET_RUNTIME_INFO_METHOD_NAME);
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getRuntimeInfo requires a method context");
+    }
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getRuntimeInfo requires an execution context");
+    }
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    const { symbol, backtest: isBacktest } = backtest.executionContextService.context;
+    return await backtest.runtimeMetaService.getRuntimeInfo(symbol, {
+        exchangeName,
+        frameName,
+        strategyName,
+    }, isBacktest);
+}
 
 const RECENT_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentPersistBacktestUtils.handleActivePing";
 const RECENT_PERSIST_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL = "RecentPersistBacktestUtils.getLatestSignal";
@@ -64591,6 +64905,20 @@ const CRON_METHOD_NAME_TICK = "CronUtils._tick";
 const CRON_METHOD_NAME_ENABLE = "CronUtils.enable";
 const CRON_METHOD_NAME_DISABLE = "CronUtils.disable";
 const CRON_METHOD_NAME_DISPOSE = "CronUtils.dispose";
+/**
+ * Watchdog timeout (ms) for a single cron handler invocation.
+ *
+ * A handler that does not settle within this window is treated as failed:
+ * `_runEntry` races `entry.handler(info)` against this `sleep` and, when the
+ * timeout wins, throws into the same `catch` as any other handler error —
+ * surfacing `failed = true`, logging a warning, and (for periodic entries)
+ * rolling back the watermark so the boundary is retried on the next tick.
+ *
+ * This guards the `singlerun`-serialised tick pipeline against a handler that
+ * never resolves (a lost `resolve`, a hung promise with no timeout of its
+ * own): without it such a handler would stall every subsequent tick forever.
+ */
+const CRON_HANDLER_TIMEOUT = 120000;
 /**
  * Local logger instance.
  *
@@ -64599,6 +64927,20 @@ const CRON_METHOD_NAME_DISPOSE = "CronUtils.dispose";
  * being bootstrapped — `Cron` can be imported and used in isolation.
  */
 const LOGGER_SERVICE$1 = new LoggerService();
+/**
+ * Local runtime-meta-service instance.
+ *
+ * Like {@link LOGGER_SERVICE}, instantiated directly via `new` rather than
+ * resolved from the DI container so `CronUtils` carries no compile-time
+ * dependency on a bootstrapped framework. `RuntimeMetaService` is built with
+ * the `singleton` HOF from `di-singleton`, so `new RuntimeMetaService()`
+ * returns the one shared singleton proxy — the same instance the rest of the
+ * framework injects — and resolves its own dependencies lazily on first use.
+ *
+ * Used by {@link CronUtils._runEntry} to assemble the {@link IRuntimeInfo}
+ * snapshot handed to each cron handler.
+ */
+const RUNTIME_META_SERVICE = new RuntimeMetaService();
 /**
  * Utility class for registering periodic tasks that fire on candle-interval
  * boundaries of the virtual time produced by parallel backtests.
@@ -64621,8 +64963,8 @@ const LOGGER_SERVICE$1 = new LoggerService();
  * Cron.register({
  *   name: "tg-signal-parser",
  *   interval: "1h",
- *   handler: async (symbol, when, backtest) => {
- *     await parseTelegramSignalsToMongo(when);
+ *   handler: async (info) => {
+ *     await parseTelegramSignalsToMongo(info.when);
  *   },
  * });
  *
@@ -64664,12 +65006,15 @@ class CronUtils {
          * - Fire-once global: `${name}:once:g${generation}`.
          * - Fire-once fan-out: `${name}:once:${symbol}:g${generation}`.
          *
-         * Value is the shared in-flight handler promise. Every parallel `tick` for
-         * the same slot key awaits this exact promise (mutex semantics) and is
-         * released together when it settles. `_inFlight` is owned exclusively by
-         * `_runEntry` — `clear()` does **not** touch it, so the singleshot promise
-         * survives concurrent `clear` calls and continues to coordinate parallel
-         * ticks until it settles.
+         * Value is the shared in-flight handler promise. It resolves to a `boolean`
+         * "failed" flag (`true` when the handler — or the runtime-info assembly —
+         * threw), which `_tick` uses to roll back the periodic watermark of the slot
+         * it opened so a failed boundary is retried. Every parallel `tick` for the
+         * same slot key awaits this exact promise (mutex semantics) and is released
+         * together when it settles. `_inFlight` is owned exclusively by `_runEntry` —
+         * `clear()` does **not** touch it, so the singleshot promise survives
+         * concurrent `clear` calls and continues to coordinate parallel ticks until
+         * it settles.
          */
         this._inFlight = new Map();
         /**
@@ -64713,9 +65058,12 @@ class CronUtils {
          *
          * Written synchronously in `_tick` at slot-open time (before the `await`),
          * so a still-in-flight handler does not let a later tick re-open the same
-         * (or an already-passed) boundary. Fire-once entries never touch this map —
-         * they use `_firedOnce`. Pruned by `_clearBoundaryFor` on
-         * `register`/`unregister` and wiped by `dispose`.
+         * (or an already-passed) boundary. If that handler then **fails**, the
+         * advance is rolled back after the slot settles — the prior value is restored
+         * (or the key deleted if there was none) — so the failed boundary is retried
+         * on the next tick, mirroring catch-up of a skipped boundary. Fire-once
+         * entries never touch this map — they use `_firedOnce`. Pruned by
+         * `_clearBoundaryFor` on `register`/`unregister` and wiped by `dispose`.
          */
         this._lastBoundary = new Map();
         /**
@@ -64735,7 +65083,7 @@ class CronUtils {
          *   name: "fetch-funding",
          *   interval: "8h",
          *   symbols: ["BTCUSDT", "ETHUSDT"],
-         *   handler: async (symbol, when, backtest) => { ... },
+         *   handler: async (info) => { ... },
          * });
          * // Later:
          * dispose();
@@ -64855,7 +65203,7 @@ class CronUtils {
          * 4. **Fire-once** (`entry.interval === undefined`):
          *    - If the entry's fired-once key is already in `_firedOnce`, skip.
          *    - Slot key: `${name}:once` (+ scope) (+ gen).
-         *    - `aligned` = the 1-minute-aligned `when` from step 0.
+         *    - `alignedMs` = the 1-minute-aligned `when` from step 0 (`ts`).
          * 5. **Periodic** (`entry.interval` set):
          *    - Align `when` to the entry's interval via {@link alignToInterval} to
          *      get `alignedMs`, the boundary this tick belongs to.
@@ -64877,32 +65225,44 @@ class CronUtils {
          *      handler is still in flight.
          *    - Slot key: `${name}:${alignedMs}` (+ scope) (+ gen).
          * 6. Singleshot per slot key: look up the slot in `_inFlight`. If a promise
-         *    already exists, `await` the same promise. Otherwise invoke
-         *    `entry.handler`, store the promise, and `await` it. The slot is
-         *    removed in `.finally()` so the next boundary creates a fresh promise;
-         *    for fire-once entries the fired-once key is also added to
-         *    `_firedOnce` on success so subsequent ticks skip it.
+         *    already exists, `await` the same promise. Otherwise open the slot via
+         *    {@link _runEntry} — which assembles the {@link IRuntimeInfo} snapshot
+         *    (from `symbol`, `context`, `backtest`) and invokes `entry.handler(info)`
+         *    — store the promise, and `await` it. The slot is removed in `.finally()`
+         *    so the next boundary creates a fresh promise; for fire-once entries the
+         *    fired-once key is also added to `_firedOnce` on success so subsequent
+         *    ticks skip it.
+         * 7. After `await Promise.all`, roll back the watermark for every **periodic**
+         *    slot this tick *opened* (not the ones whose in-flight promise it reused)
+         *    whose handler reported failure, so the next tick re-opens and re-runs
+         *    that boundary.
          *
          * Errors thrown by `handler` are caught, logged via `console.error`, and
          * **not** rethrown — a failing handler must not break the per-symbol
          * tick loop or unblock other parallel backtests with an unhandled
          * rejection. A failed fire-once handler is **not** marked as fired and
-         * will retry on the next tick.
+         * will retry on the next tick. A failed **periodic** handler likewise
+         * retries: the boundary watermark advanced at slot-open time is rolled back
+         * after the slot settles (step 7), so the next tick re-opens that boundary.
          *
          * Requires active method context and execution context.
          *
          * @param symbol - Trading symbol from the current tick.
          * @param when - Virtual time of the current tick.
          * @param backtest - `true` for backtest ticks, `false` for live ticks.
-         *   Forwarded as the third argument to `entry.handler`. Only the value
-         *   from the tick that **opens** a given slot is observed by all parallel
-         *   awaiters of that slot.
+         *   Forwarded to {@link _runEntry} and surfaced as `info.backtest`. Only the
+         *   value from the tick that **opens** a given slot is observed by all
+         *   parallel awaiters of that slot.
+         * @param context - Strategy/exchange/frame identifiers from the originating
+         *   lifecycle event, forwarded to `RuntimeMetaService.getRuntimeInfo` to
+         *   build the {@link IRuntimeInfo} snapshot passed to the handler.
          * @throws Error if method or execution context is missing.
          */
-        this._tick = async (symbol, when, backtest) => {
+        this._tick = async (symbol, when, backtest, context) => {
             LOGGER_SERVICE$1.debug(CRON_METHOD_NAME_TICK, {
                 symbol,
                 when,
+                context,
             });
             if (!MethodContextService.hasContext()) {
                 throw new Error("CronUtils _tick requires method context");
@@ -64912,6 +65272,10 @@ class CronUtils {
             }
             const ts = alignToInterval(when, "1m").getTime();
             const taskList = [];
+            // Periodic slots THIS tick actually opened (the `!pending` branch), tracked
+            // for watermark rollback on failure. See {@link IOpenedSlot} for what is and
+            // is not recorded here and why.
+            const openedList = [];
             for (const { entry, generation } of this._entries.values()) {
                 if (entry.symbols?.length && !entry.symbols.includes(symbol)) {
                     continue;
@@ -64919,7 +65283,6 @@ class CronUtils {
                 const perSymbol = !!entry.symbols?.length;
                 const scope = perSymbol ? `:${symbol}` : "";
                 const genSuffix = `:g${generation}`;
-                let aligned;
                 let alignedMs;
                 let slotKey;
                 let firedKey;
@@ -64931,15 +65294,13 @@ class CronUtils {
                     if (this._firedOnce.has(onceKey)) {
                         continue;
                     }
-                    aligned = alignToInterval(when, "1m");
                     alignedMs = ts;
                     slotKey = `${entry.name}:once${scope}${genSuffix}`;
                     firedKey = onceKey;
                     boundaryKey = null;
                 }
                 else {
-                    aligned = alignToInterval(when, entry.interval);
-                    alignedMs = aligned.getTime();
+                    alignedMs = alignToInterval(when, entry.interval).getTime();
                     boundaryKey = `${entry.name}${scope}${genSuffix}`;
                     const lastBoundary = this._lastBoundary.get(boundaryKey);
                     // Fire when the tick's aligned boundary has advanced past the last one
@@ -64957,16 +65318,70 @@ class CronUtils {
                     // Advance the watermark synchronously at slot-open time, before the
                     // await below. Otherwise a later tick on the same (or an already
                     // crossed) boundary, arriving while this handler is still in flight,
-                    // would see the stale watermark and open a duplicate slot.
+                    // would see the stale watermark and open a duplicate slot. The advance
+                    // is rolled back after the slot settles if the handler failed (see the
+                    // post-await loop below), so a failed boundary is retried next tick.
                     if (boundaryKey !== null) {
+                        // Capture the pre-advance value so it can be restored verbatim on
+                        // failure (undefined => the boundary had never opened => delete the
+                        // key on rollback). Read fresh here rather than reusing `lastBoundary`
+                        // above to keep the value↔slot binding local and obvious; there is no
+                        // `await` between the two reads, so they are identical.
+                        const prevBoundary = this._lastBoundary.get(boundaryKey);
                         this._lastBoundary.set(boundaryKey, alignedMs);
+                        pending = this._runEntry(entry, symbol, alignedMs, slotKey, firedKey, backtest, context);
+                        this._inFlight.set(slotKey, pending);
+                        openedList.push({ boundaryKey, prevBoundary, pending });
+                    }
+                    else {
+                        pending = this._runEntry(entry, symbol, alignedMs, slotKey, firedKey, backtest, context);
+                        this._inFlight.set(slotKey, pending);
                     }
-                    pending = this._runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest);
-                    this._inFlight.set(slotKey, pending);
                 }
                 taskList.push(pending);
             }
-            await Promise.all(taskList);
+            {
+                // Watchdog: warn (do not interrupt) if the slots this tick is awaiting
+                // have not settled within CRON_HANDLER_TIMEOUT. We deliberately keep
+                // awaiting Promise.all so the singlerun pipeline stays serialised and no
+                // duplicate/zombie slots are spawned — the timer only surfaces the stall.
+                // Use a real setTimeout/clearTimeout (not sleep) so the alarm is cancelled
+                // the instant Promise.all resolves, rather than lingering for the full
+                // timeout on every fast tick.
+                const timer = setTimeout(() => {
+                    const message = `${CRON_METHOD_NAME_TICK} timed out after ${CRON_HANDLER_TIMEOUT}ms`;
+                    const payload = { symbol, when, context };
+                    LOGGER_SERVICE$1.warn(message, payload);
+                    console.error(message, payload);
+                    errorEmitter.next(new Error(message));
+                }, CRON_HANDLER_TIMEOUT);
+                try {
+                    await Promise.all(taskList);
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            }
+            // Roll back the watermark for any periodic slot THIS tick opened whose
+            // handler failed, so the next tick re-opens the same boundary and retries
+            // it — mirroring how a skipped boundary is later caught up. Restoring
+            // `prevBoundary` (or deleting the key when it was `undefined`) re-arms the
+            // strict-`>` gate without disturbing any earlier already-fired boundary.
+            // `await pending` is cheap — every promise already settled in `Promise.all`
+            // above; we re-await via `openedList` because its entries (opened slots
+            // only) do not line up with `taskList` indices.
+            for (const { boundaryKey, prevBoundary, pending } of openedList) {
+                const failed = await pending;
+                if (!failed) {
+                    continue;
+                }
+                if (prevBoundary === undefined) {
+                    this._lastBoundary.delete(boundaryKey);
+                }
+                else {
+                    this._lastBoundary.set(boundaryKey, prevBoundary);
+                }
+            }
         };
         /**
          * Subscribe `Cron` to the engine's strategy lifecycle subjects so registered
@@ -64981,7 +65396,11 @@ class CronUtils {
          *
          * All four subjects are subscribed to a single `singlerun`-wrapped
          * handler that builds `_tick(event.symbol, new Date(event.timestamp),
-         * event.backtest)`. `singlerun` merges the four streams into one serial
+         * event.backtest, { strategyName, exchangeName, frameName })`. The context
+         * object is read uniformly from the event — every contract carries
+         * `strategyName`, `exchangeName` and `frameName` at the top level (Active /
+         * Schedule contracts gained `frameName` for exactly this reason), so no
+         * per-event branching is needed. `singlerun` merges the four streams into one serial
          * queue: at most one `_tick` runs at a time, the next waits. This matters
          * because the engine can emit `beforeStart` and an immediate `idlePing`
          * on the very same minute, and concurrent `_tick`s on the same
@@ -65017,7 +65436,11 @@ class CronUtils {
         this.enable = singleshot(() => {
             LOGGER_SERVICE$1.info(CRON_METHOD_NAME_ENABLE);
             const handleTick = singlerun(async (event) => {
-                return await this._tick(event.symbol, new Date(event.timestamp), event.backtest);
+                return await this._tick(event.symbol, new Date(event.timestamp), event.backtest, {
+                    strategyName: event.strategyName,
+                    exchangeName: event.exchangeName,
+                    frameName: event.frameName,
+                });
             });
             const unBeforeStart = beforeStartSubject.subscribe(handleTick);
             const unIdlePing = idlePingSubject.subscribe(handleTick);
@@ -65120,25 +65543,51 @@ class CronUtils {
     /**
      * Build the singleshot promise for a single in-flight slot.
      *
-     * Invokes `entry.handler(symbol, aligned, backtest)`, swallows and logs
-     * any error via `console.error`, and clears the `_inFlight` slot
-     * in `.finally()` so the next boundary produces a fresh promise. For
-     * fire-once entries `firedKey` is added to `_firedOnce` on success so
-     * subsequent ticks skip it.
-     *
+     * Assembles the {@link IRuntimeInfo} snapshot via
+     * `RuntimeMetaService.getRuntimeInfo(symbol, context, backtest)` and invokes
+     * `entry.handler(info)`. Logs any error via `console.error` and **returns** a
+     * `failed` boolean (`true` when the handler — or the runtime-info assembly —
+     * threw) so the caller (`_tick`) can roll back the periodic watermark of the
+     * slot it opened and retry that boundary. The error is **not** rethrown, so a
+     * failing handler never produces an unhandled rejection. Clears the
+     * `_inFlight` slot in `.finally()` so the next boundary produces a fresh
+     * promise. For fire-once entries `firedKey` is added to `_firedOnce` on
+     * success so subsequent ticks skip it.
+     *
+     * `getRuntimeInfo` is the user-facing aggregator: its sub-fetches (range,
+     * info, price) are individually wrapped in `trycatch` with `null` fallbacks,
+     * so it almost never throws for missing data. Whatever does throw — the
+     * handler, or in rare cases `getRuntimeInfo` — is caught here and reported via
+     * the returned `failed` flag; the watermark rollback treats both identically.
+     *
+     * @param context - Strategy/exchange/frame identifiers from the originating
+     *   lifecycle event, forwarded to `getRuntimeInfo` to resolve `range`/`info`.
      * @param firedKey - Key to add to `_firedOnce` on success, or `null` for
      *   periodic entries (which never populate `_firedOnce`).
-     * @param backtest - Value forwarded as the third handler argument; the
-     *   "winner" tick's flag is what all parallel awaiters of this slot see.
+     * @param backtest - Forwarded to `getRuntimeInfo` and surfaced as
+     *   `info.backtest`; the "winner" tick's flag is what all parallel awaiters
+     *   of this slot see.
+     * @returns `true` if the handler (or `getRuntimeInfo`) threw, `false` on
+     *   success. `_tick` uses this to decide whether to roll back the watermark.
      */
-    async _runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest) {
+    async _runEntry(entry, symbol, alignedMs, slotKey, firedKey, backtest, context) {
         let failed = false;
         try {
-            await entry.handler(symbol, aligned, backtest);
+            const info = await RUNTIME_META_SERVICE.getRuntimeInfo(symbol, context, backtest);
+            await entry.handler(info);
         }
-        catch (err) {
+        catch (error) {
             failed = true;
-            console.error(`${CRON_METHOD_NAME_TICK} entry "${entry.name}" failed`, { symbol, alignedMs, err });
+            const message = `${CRON_METHOD_NAME_TICK} entry "${entry.name}" failed`;
+            const payload = {
+                symbol,
+                alignedMs,
+                error: errorData(error),
+                message: getErrorMessage(error),
+            };
+            LOGGER_SERVICE$1.warn(message, payload);
+            console.error(message, payload);
+            errorEmitter.next(error);
         }
         finally {
             this._inFlight.delete(slotKey);
@@ -65146,6 +65595,7 @@ class CronUtils {
                 this._firedOnce.add(firedKey);
             }
         }
+        return failed;
     }
 }
 /**
@@ -65159,7 +65609,7 @@ class CronUtils {
  * Cron.register({
  *   name: "tg-parser",
  *   interval: "1h",
- *   handler: async (symbol, when, backtest) => { ... },
+ *   handler: async (info) => { ... },
  * });
  * ```
  */
@@ -66325,4 +66775,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };