backtest-kit 15.1.0 → 15.3.0

package/build/index.mjs

@@ -533,6 +533,16 @@ const GLOBAL_CONFIG = {
      * Default: 500 notifications
      */
     CC_MAX_NOTIFICATIONS: 500,
+    /**
+     * Minimum interval between `order_sync.check` notifications for a single signalId.
+     * Order-ping events (syncPendingSubject) fire on every live tick, so the
+     * NotificationAdapter throttles them: a signal produces at most one check
+     * notification per this interval. The throttle entry is removed when the
+     * signal is closed or cancelled.
+     *
+     * Default: 900000 ms (15 minutes)
+     */
+    CC_NOTIFICATION_ORDER_CHECK_TTL: 900000,
     /**
      * Maximum number of signals to keep in storage.
      * Older signals are removed when this limit is exceeded.
@@ -5297,6 +5307,24 @@ const validateCandles = (candles) => {
 };
 
 const MS_PER_MINUTE$7 = 60000;
+/**
+ * Normalizes raw adapter output to the {@link IAggregatedTradeData} contract.
+ *
+ * Implicit-API exchange adapters (e.g. ccxt `publicGetAggTrades`) return every
+ * scalar as a string. A string `timestamp` is type-invisible at runtime — it
+ * survives serialization and comparison — and only blows up deep inside a
+ * downstream consumer (`Number.isFinite("1783601403565") === false`). Coercing
+ * the numeric fields here, at the single point where adapter data enters the
+ * framework, guarantees the contract's `number` types hold regardless of
+ * adapter behaviour. `isBuyerMaker` is deliberately left untouched: `Boolean`
+ * coercion of a string `"false"` would yield `true`.
+ */
+const NORMALIZE_AGGREGATED_TRADES_FN$1 = (trades) => trades.map((trade) => ({
+    ...trade,
+    price: Number(trade.price),
+    qty: Number(trade.qty),
+    timestamp: Number(trade.timestamp),
+}));
 const INTERVAL_MINUTES$9 = {
     "1m": 1,
     "3m": 3,
@@ -5992,7 +6020,7 @@ class ClientExchange {
         if (limit === undefined) {
             const to = new Date(alignedTo);
             const from = new Date(alignedTo - windowMs);
-            return await this.params.getAggregatedTrades(symbol, from, to, this.params.execution.context.backtest);
+            return NORMALIZE_AGGREGATED_TRADES_FN$1(await this.params.getAggregatedTrades(symbol, from, to, this.params.execution.context.backtest));
         }
         // With limit: paginate backwards until we have enough trades.
         // Consecutive empty windows bound the scan: before the symbol's listing
@@ -6009,7 +6037,7 @@ class ClientExchange {
             }
             const to = new Date(windowEnd);
             const from = new Date(windowStart);
-            const chunk = await this.params.getAggregatedTrades(symbol, from, to, this.params.execution.context.backtest);
+            const chunk = NORMALIZE_AGGREGATED_TRADES_FN$1(await this.params.getAggregatedTrades(symbol, from, to, this.params.execution.context.backtest));
             if (chunk.length === 0) {
                 emptyWindows += 1;
                 if (emptyWindows >= MAX_CONSECUTIVE_EMPTY_WINDOWS) {
@@ -15356,6 +15384,10 @@ class StrategyConnectionService {
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.waitForInit();
+            if (!this.timeMetaService.hasTimestamp(symbol, context, backtest)) {
+                const timestamp = this.executionContextService.context.when.getTime();
+                await this.timeMetaService.next(symbol, timestamp, context, backtest);
+            }
             const tick = await strategy.tick(symbol, context.strategyName);
             {
                 await this.priceMetaService.next(symbol, tick.currentPrice, context, backtest);
@@ -42676,6 +42708,24 @@ const EXCHANGE_METHOD_NAME_GET_ORDER_BOOK = "ExchangeUtils.getOrderBook";
 const EXCHANGE_METHOD_NAME_GET_RAW_CANDLES = "ExchangeUtils.getRawCandles";
 const EXCHANGE_METHOD_NAME_GET_AGGREGATED_TRADES = "ExchangeUtils.getAggregatedTrades";
 const MS_PER_MINUTE$4 = 60000;
+/**
+ * Normalizes raw adapter output to the {@link IAggregatedTradeData} contract.
+ *
+ * Implicit-API exchange adapters (e.g. ccxt `publicGetAggTrades`) return every
+ * scalar as a string. A string `timestamp` is type-invisible at runtime — it
+ * survives serialization and comparison — and only blows up deep inside a
+ * downstream consumer (`Number.isFinite("1783601403565") === false`). Coercing
+ * the numeric fields here, at the single point where adapter data enters the
+ * framework, guarantees the contract's `number` types hold regardless of
+ * adapter behaviour. `isBuyerMaker` is deliberately left untouched: `Boolean`
+ * coercion of a string `"false"` would yield `true`.
+ */
+const NORMALIZE_AGGREGATED_TRADES_FN = (trades) => trades.map((trade) => ({
+    ...trade,
+    price: Number(trade.price),
+    qty: Number(trade.qty),
+    timestamp: Number(trade.timestamp),
+}));
 /**
  * Gets current timestamp from execution context if available.
  * Returns current Date() if no execution context exists (non-trading GUI).
@@ -43172,7 +43222,7 @@ class ExchangeInstance {
             if (limit === undefined) {
                 const to = new Date(alignedTo);
                 const from = new Date(alignedTo - windowMs);
-                return await this._methods.getAggregatedTrades(symbol, from, to, isBacktest);
+                return NORMALIZE_AGGREGATED_TRADES_FN(await this._methods.getAggregatedTrades(symbol, from, to, isBacktest));
             }
             // With limit: paginate backwards until we have enough trades.
             // Consecutive empty windows bound the scan: before the symbol's listing
@@ -43189,7 +43239,7 @@ class ExchangeInstance {
                 }
                 const to = new Date(windowEnd);
                 const from = new Date(windowStart);
-                const chunk = await this._methods.getAggregatedTrades(symbol, from, to, isBacktest);
+                const chunk = NORMALIZE_AGGREGATED_TRADES_FN(await this._methods.getAggregatedTrades(symbol, from, to, isBacktest));
                 if (chunk.length === 0) {
                     emptyWindows += 1;
                     if (emptyWindows >= MAX_CONSECUTIVE_EMPTY_WINDOWS) {
@@ -45688,6 +45738,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45714,6 +45765,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45737,6 +45789,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45755,6 +45808,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45772,6 +45826,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45784,6 +45839,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45801,6 +45857,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 };
                 if (event.action === "scheduled") {
@@ -45823,6 +45880,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 };
                 if (event.action === "opened") {
@@ -46597,6 +46655,7 @@ async function commitPartialProfit(symbol, percentToClose) {
         priceTakeProfit: signalForProfit.priceTakeProfit,
         priceStopLoss: signalForProfit.priceStopLoss,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.partialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
@@ -46665,6 +46724,7 @@ async function commitPartialLoss(symbol, percentToClose) {
         priceTakeProfit: signalForLoss.priceTakeProfit,
         priceStopLoss: signalForLoss.priceStopLoss,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
@@ -46749,6 +46809,7 @@ async function commitTrailingStop(symbol, percentShift, currentPrice) {
         takeProfitPrice: signal.priceTakeProfit,
         position: signal.position,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
@@ -46833,6 +46894,7 @@ async function commitTrailingTake(symbol, percentShift, currentPrice) {
         takeProfitPrice: signal.priceTakeProfit,
         position: signal.position,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.trailingTake(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
@@ -46888,6 +46950,7 @@ async function commitTrailingStopCost(symbol, newStopLossPrice) {
         position: signal.position,
         takeProfitPrice: signal.priceTakeProfit,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
@@ -46943,6 +47006,7 @@ async function commitTrailingTakeCost(symbol, newTakeProfitPrice) {
         takeProfitPrice: signal.priceTakeProfit,
         position: signal.position,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.trailingTake(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
@@ -47004,6 +47068,7 @@ async function commitBreakeven(symbol) {
         newTakeProfitPrice: breakevenNewTakeProfitPrice(signal.priceTakeProfit, signal._trailingPriceTakeProfit),
         position: signal.position,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
@@ -47096,6 +47161,7 @@ async function commitAverageBuy(symbol, cost = GLOBAL_CONFIG.CC_POSITION_ENTRY_C
         priceTakeProfit: signalForAvgBuy.priceTakeProfit,
         priceStopLoss: signalForAvgBuy.priceStopLoss,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.averageBuy(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName }, cost);
@@ -47532,6 +47598,7 @@ async function commitPartialProfitCost(symbol, dollarAmount) {
         priceTakeProfit: signalForProfitCost.priceTakeProfit,
         priceStopLoss: signalForProfitCost.priceStopLoss,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.partialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
@@ -47604,6 +47671,7 @@ async function commitPartialLossCost(symbol, dollarAmount) {
         priceTakeProfit: signalForLossCost.priceTakeProfit,
         priceStopLoss: signalForLossCost.priceStopLoss,
         context: { exchangeName, frameName, strategyName },
+        when: backtest.executionContextService.context.when,
         backtest: isBacktest,
     });
     return await backtest.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
@@ -52518,6 +52586,7 @@ class BacktestUtils {
                 priceTakeProfit: signalForProfit.priceTakeProfit,
                 priceStopLoss: signalForProfit.priceStopLoss,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.partialProfit(true, symbol, percentToClose, currentPrice, context);
@@ -52592,6 +52661,7 @@ class BacktestUtils {
                 priceTakeProfit: signalForLoss.priceTakeProfit,
                 priceStopLoss: signalForLoss.priceStopLoss,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
@@ -52669,6 +52739,7 @@ class BacktestUtils {
                 priceTakeProfit: signalForProfitCost.priceTakeProfit,
                 priceStopLoss: signalForProfitCost.priceStopLoss,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.partialProfit(true, symbol, percentToClose, currentPrice, context);
@@ -52746,6 +52817,7 @@ class BacktestUtils {
                 priceTakeProfit: signalForLossCost.priceTakeProfit,
                 priceStopLoss: signalForLossCost.priceStopLoss,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
@@ -52835,6 +52907,7 @@ class BacktestUtils {
                 takeProfitPrice: signal.priceTakeProfit,
                 position: signal.position,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
@@ -52924,6 +52997,7 @@ class BacktestUtils {
                 takeProfitPrice: signal.priceTakeProfit,
                 position: signal.position,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.trailingTake(true, symbol, percentShift, currentPrice, context);
@@ -52979,6 +53053,7 @@ class BacktestUtils {
                 position: signal.position,
                 takeProfitPrice: signal.priceTakeProfit,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
@@ -53034,6 +53109,7 @@ class BacktestUtils {
                 position: signal.position,
                 takeProfitPrice: signal.priceTakeProfit,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.trailingTake(true, symbol, percentShift, currentPrice, context);
@@ -53095,6 +53171,7 @@ class BacktestUtils {
                 newTakeProfitPrice: breakevenNewTakeProfitPrice(signal.priceTakeProfit, signal._trailingPriceTakeProfit),
                 position: signal.position,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.breakeven(true, symbol, currentPrice, context);
@@ -53196,6 +53273,7 @@ class BacktestUtils {
                 priceTakeProfit: signalForAvgBuy.priceTakeProfit,
                 priceStopLoss: signalForAvgBuy.priceStopLoss,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, context, true)),
                 backtest: true,
             });
             return await backtest.strategyCoreService.averageBuy(true, symbol, currentPrice, context, cost);
@@ -55527,6 +55605,7 @@ class LiveUtils {
                     exchangeName: context.exchangeName,
                     frameName: "",
                 },
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.partialProfit(false, symbol, percentToClose, currentPrice, {
@@ -55622,6 +55701,7 @@ class LiveUtils {
                     exchangeName: context.exchangeName,
                     frameName: "",
                 },
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.partialLoss(false, symbol, percentToClose, currentPrice, {
@@ -55719,6 +55799,7 @@ class LiveUtils {
                     exchangeName: context.exchangeName,
                     frameName: "",
                 },
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.partialProfit(false, symbol, percentToClose, currentPrice, {
@@ -55816,6 +55897,7 @@ class LiveUtils {
                     exchangeName: context.exchangeName,
                     frameName: "",
                 },
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.partialLoss(false, symbol, percentToClose, currentPrice, {
@@ -55920,6 +56002,7 @@ class LiveUtils {
                 takeProfitPrice: signal.priceTakeProfit,
                 position: signal.position,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.trailingStop(false, symbol, percentShift, currentPrice, {
@@ -56024,6 +56107,7 @@ class LiveUtils {
                 takeProfitPrice: signal.priceTakeProfit,
                 position: signal.position,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.trailingTake(false, symbol, percentShift, currentPrice, {
@@ -56095,6 +56179,7 @@ class LiveUtils {
                 takeProfitPrice: signal.priceTakeProfit,
                 position: signal.position,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.trailingStop(false, symbol, percentShift, currentPrice, {
@@ -56166,6 +56251,7 @@ class LiveUtils {
                 takeProfitPrice: signal.priceTakeProfit,
                 position: signal.position,
                 context,
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.trailingTake(false, symbol, percentShift, currentPrice, {
@@ -56247,6 +56333,7 @@ class LiveUtils {
                     exchangeName: context.exchangeName,
                     frameName: "",
                 },
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.breakeven(false, symbol, currentPrice, {
@@ -56366,6 +56453,7 @@ class LiveUtils {
                     exchangeName: context.exchangeName,
                     frameName: "",
                 },
+                when: new Date(await backtest.timeMetaService.getTimestamp(symbol, { strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "" }, false)),
                 backtest: false,
             });
             return await backtest.strategyCoreService.averageBuy(false, symbol, currentPrice, {
@@ -66661,7 +66749,8 @@ const WILDCARD_TARGET = {
     partial_loss: true,
     breakeven: true,
     strategy_commit: true,
-    signal_sync: true,
+    order_sync: true,
+    order_check: true,
     risk: true,
     info: true,
     common_error: true,
@@ -67390,14 +67479,15 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
 };
 /**
  * Creates a notification model for signal sync events.
- * Handles signal-open (limit order filled) and signal-close (position exited) actions.
+ * Handles signal-open (position order filled with orderType "active", or resting
+ * entry order placed with orderType "schedule") and signal-close (position exited) actions.
  * @param data - The signal sync contract data
  * @returns NotificationModel for signal sync event
  */
 const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
     if (data.action === "signal-open") {
         return {
-            type: "signal_sync.open",
+            type: "order_sync.open",
             id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
@@ -67405,6 +67495,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
             strategyName: data.strategyName,
             exchangeName: data.exchangeName,
             signalId: data.signalId,
+            orderType: data.type,
             currentPrice: data.currentPrice,
             pnl: data.signal.pnl,
             maxDrawdown: data.signal.maxDrawdown,
@@ -67442,7 +67533,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
     }
     if (data.action === "signal-close") {
         return {
-            type: "signal_sync.close",
+            type: "order_sync.close",
             id: CREATE_KEY_FN$2(),
             timestamp: data.timestamp,
             backtest: data.backtest,
@@ -67450,6 +67541,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
             strategyName: data.strategyName,
             exchangeName: data.exchangeName,
             signalId: data.signalId,
+            orderType: data.type,
             currentPrice: data.currentPrice,
             pnl: data.signal.pnl,
             maxDrawdown: data.signal.maxDrawdown,
@@ -67487,6 +67579,54 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
     }
     throw new Error(`Unrecognized signal sync action: ${get(data, "action")}`);
 };
+/**
+ * Creates a notification model for order-ping check events.
+ * @param data - The order check contract data
+ * @returns NotificationModel for signal sync check event
+ */
+const CREATE_ORDER_CHECK_NOTIFICATION_FN = (data) => ({
+    type: "order_sync.check",
+    id: CREATE_KEY_FN$2(),
+    timestamp: data.timestamp,
+    backtest: data.backtest,
+    symbol: data.symbol,
+    strategyName: data.strategyName,
+    exchangeName: data.exchangeName,
+    signalId: data.signalId,
+    orderType: data.type,
+    currentPrice: data.currentPrice,
+    position: data.position,
+    priceOpen: data.priceOpen,
+    priceTakeProfit: data.priceTakeProfit,
+    priceStopLoss: data.priceStopLoss,
+    originalPriceTakeProfit: data.originalPriceTakeProfit,
+    originalPriceStopLoss: data.originalPriceStopLoss,
+    originalPriceOpen: data.originalPriceOpen,
+    totalEntries: data.totalEntries,
+    totalPartials: data.totalPartials,
+    pnl: data.pnl,
+    maxDrawdown: data.maxDrawdown,
+    peakProfit: data.peakProfit,
+    pnlPercentage: data.pnl.pnlPercentage,
+    pnlPriceOpen: data.pnl.priceOpen,
+    pnlPriceClose: data.pnl.priceClose,
+    pnlCost: data.pnl.pnlCost,
+    pnlEntries: data.pnl.pnlEntries,
+    peakProfitPriceOpen: data.peakProfit.priceOpen,
+    peakProfitPriceClose: data.peakProfit.priceClose,
+    peakProfitPercentage: data.peakProfit.pnlPercentage,
+    peakProfitCost: data.peakProfit.pnlCost,
+    peakProfitEntries: data.peakProfit.pnlEntries,
+    maxDrawdownPriceOpen: data.maxDrawdown.priceOpen,
+    maxDrawdownPriceClose: data.maxDrawdown.priceClose,
+    maxDrawdownPercentage: data.maxDrawdown.pnlPercentage,
+    maxDrawdownCost: data.maxDrawdown.pnlCost,
+    maxDrawdownEntries: data.maxDrawdown.pnlEntries,
+    scheduledAt: data.scheduledAt,
+    pendingAt: data.pendingAt,
+    note: data.signal.note,
+    createdAt: data.timestamp,
+});
 /**
  * Creates a notification model for risk rejection events.
  * @param data - The risk contract data
@@ -67604,6 +67744,7 @@ const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_LOSS = "Notificati
 const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_BREAKEVEN = "NotificationMemoryBacktestUtils.handleBreakeven";
 const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_STRATEGY_COMMIT = "NotificationMemoryBacktestUtils.handleStrategyCommit";
 const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_SYNC = "NotificationMemoryBacktestUtils.handleSync";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CHECK = "NotificationMemoryBacktestUtils.handleCheck";
 const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_RISK = "NotificationMemoryBacktestUtils.handleRisk";
 const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_ERROR = "NotificationMemoryBacktestUtils.handleError";
 const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CRITICAL_ERROR = "NotificationMemoryBacktestUtils.handleCriticalError";
@@ -67617,6 +67758,7 @@ const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_PARTIAL_LOSS = "NotificationMe
 const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_BREAKEVEN = "NotificationMemoryLiveUtils.handleBreakeven";
 const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_STRATEGY_COMMIT = "NotificationMemoryLiveUtils.handleStrategyCommit";
 const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_SYNC = "NotificationMemoryLiveUtils.handleSync";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_CHECK = "NotificationMemoryLiveUtils.handleCheck";
 const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_RISK = "NotificationMemoryLiveUtils.handleRisk";
 const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_ERROR = "NotificationMemoryLiveUtils.handleError";
 const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_CRITICAL_ERROR = "NotificationMemoryLiveUtils.handleCriticalError";
@@ -67646,6 +67788,7 @@ const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_LOSS = "Notificat
 const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_BREAKEVEN = "NotificationPersistBacktestUtils.handleBreakeven";
 const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_STRATEGY_COMMIT = "NotificationPersistBacktestUtils.handleStrategyCommit";
 const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_SYNC = "NotificationPersistBacktestUtils.handleSync";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_CHECK = "NotificationPersistBacktestUtils.handleCheck";
 const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_RISK = "NotificationPersistBacktestUtils.handleRisk";
 const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ERROR = "NotificationPersistBacktestUtils.handleError";
 const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_CRITICAL_ERROR = "NotificationPersistBacktestUtils.handleCriticalError";
@@ -67661,6 +67804,7 @@ const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_PARTIAL_LOSS = "NotificationP
 const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_BREAKEVEN = "NotificationPersistLiveUtils.handleBreakeven";
 const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_STRATEGY_COMMIT = "NotificationPersistLiveUtils.handleStrategyCommit";
 const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_SYNC = "NotificationPersistLiveUtils.handleSync";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_CHECK = "NotificationPersistLiveUtils.handleCheck";
 const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_RISK = "NotificationPersistLiveUtils.handleRisk";
 const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_ERROR = "NotificationPersistLiveUtils.handleError";
 const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_CRITICAL_ERROR = "NotificationPersistLiveUtils.handleCriticalError";
@@ -67759,15 +67903,23 @@ class NotificationMemoryBacktestUtils {
                 signalId: data.signalId,
                 action: data.action,
             });
-            // A "schedule" open is a resting-order placement, not a fill:
-            // signal_sync.open means "limit order confirmed filled"
-            if (data.action === "signal-open" && data.type === "schedule") {
-                return;
-            }
             this._addNotification(CREATE_SIGNAL_SYNC_NOTIFICATION_FN(data));
         }, {
             defaultValue: null,
         });
+        /**
+         * Handles order-ping check event.
+         * @param data - The order check contract data
+         */
+        this.handleCheck = trycatch(async (data) => {
+            backtest.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CHECK, {
+                signalId: data.signalId,
+                type: data.type,
+            });
+            this._addNotification(CREATE_ORDER_CHECK_NOTIFICATION_FN(data));
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * @param data - The risk contract data
@@ -67882,6 +68034,13 @@ class NotificationDummyBacktestUtils {
         }, {
             defaultValue: null,
         });
+        /**
+         * No-op handler for order-ping check event.
+         */
+        this.handleCheck = trycatch(async () => {
+        }, {
+            defaultValue: null,
+        });
         /**
          * No-op handler for risk rejection event.
          */
@@ -68033,17 +68192,27 @@ class NotificationPersistBacktestUtils {
                 signalId: data.signalId,
                 action: data.action,
             });
-            // A "schedule" open is a resting-order placement, not a fill:
-            // signal_sync.open means "limit order confirmed filled"
-            if (data.action === "signal-open" && data.type === "schedule") {
-                return;
-            }
             await this.waitForInit();
             this._addNotification(CREATE_SIGNAL_SYNC_NOTIFICATION_FN(data));
             await this._updateNotifications();
         }, {
             defaultValue: null,
         });
+        /**
+         * Handles order-ping check event.
+         * @param data - The order check contract data
+         */
+        this.handleCheck = trycatch(async (data) => {
+            backtest.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_CHECK, {
+                signalId: data.signalId,
+                type: data.type,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_ORDER_CHECK_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * @param data - The risk contract data
@@ -68237,15 +68406,23 @@ class NotificationMemoryLiveUtils {
                 signalId: data.signalId,
                 action: data.action,
             });
-            // A "schedule" open is a resting-order placement, not a fill:
-            // signal_sync.open means "limit order confirmed filled"
-            if (data.action === "signal-open" && data.type === "schedule") {
-                return;
-            }
             this._addNotification(CREATE_SIGNAL_SYNC_NOTIFICATION_FN(data));
         }, {
             defaultValue: null,
         });
+        /**
+         * Handles order-ping check event.
+         * @param data - The order check contract data
+         */
+        this.handleCheck = trycatch(async (data) => {
+            backtest.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_CHECK, {
+                signalId: data.signalId,
+                type: data.type,
+            });
+            this._addNotification(CREATE_ORDER_CHECK_NOTIFICATION_FN(data));
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * @param data - The risk contract data
@@ -68360,6 +68537,13 @@ class NotificationDummyLiveUtils {
         }, {
             defaultValue: null,
         });
+        /**
+         * No-op handler for order-ping check event.
+         */
+        this.handleCheck = trycatch(async () => {
+        }, {
+            defaultValue: null,
+        });
         /**
          * No-op handler for risk rejection event.
          */
@@ -68512,17 +68696,27 @@ class NotificationPersistLiveUtils {
                 signalId: data.signalId,
                 action: data.action,
             });
-            // A "schedule" open is a resting-order placement, not a fill:
-            // signal_sync.open means "limit order confirmed filled"
-            if (data.action === "signal-open" && data.type === "schedule") {
-                return;
-            }
             await this.waitForInit();
             this._addNotification(CREATE_SIGNAL_SYNC_NOTIFICATION_FN(data));
             await this._updateNotifications();
         }, {
             defaultValue: null,
         });
+        /**
+         * Handles order-ping check event.
+         * @param data - The order check contract data
+         */
+        this.handleCheck = trycatch(async (data) => {
+            backtest.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_CHECK, {
+                signalId: data.signalId,
+                type: data.type,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_ORDER_CHECK_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * @param data - The risk contract data
@@ -68700,6 +68894,16 @@ class NotificationBacktestAdapter {
         }, {
             defaultValue: null,
         });
+        /**
+         * Handles order-ping check event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The order check contract data
+         */
+        this.handleCheck = trycatch(async (data) => {
+            return await this.getInstance().handleCheck(data);
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * Proxies call to the underlying notification adapter.
@@ -68870,6 +69074,16 @@ class NotificationLiveAdapter {
         }, {
             defaultValue: null,
         });
+        /**
+         * Handles order-ping check event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The order check contract data
+         */
+        this.handleCheck = trycatch(async (data) => {
+            return await this.getInstance().handleCheck(data);
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * Proxies call to the underlying notification adapter.
@@ -68983,16 +69197,40 @@ class NotificationAdapter {
          *
          * @returns Cleanup function that unsubscribes from all emitters
          */
-        this.enable = singleshot(({ signal = false, info = false, partial_profit = false, partial_loss = false, breakeven = false, strategy_commit = false, signal_sync = false, risk = false, common_error = false, critical_error = false, validation_error = false, } = WILDCARD_TARGET) => {
+        this.enable = singleshot(({ signal = false, info = false, partial_profit = false, partial_loss = false, breakeven = false, strategy_commit = false, order_sync = false, order_check = false, risk = false, common_error = false, critical_error = false, validation_error = false, } = WILDCARD_TARGET) => {
             backtest.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_ENABLE);
             let unLive;
             let unBacktest;
             {
+                // Throttle state for order_sync.check: signalId -> timestamp of the last
+                // emitted check notification. Entries are dropped on signal close/cancel
+                // so the map cannot grow unbounded.
+                const checkThrottleMap = new Map();
                 const unBacktestSignal = signalBacktestEmitter.subscribe(async (data) => {
                     if (signal) {
                         await NotificationBacktest.handleSignal(data);
                     }
                 });
+                // Cleanup for checkThrottleMap. Tick-result emitters are NOT sufficient here:
+                // out-of-band closes (commitClosePending, failed order ping, scheduled cancel
+                // via commit) never reach signalBacktestEmitter/signalLiveEmitter. The
+                // lifecycle channels cover every path: signalEventSubject "closed" fires for
+                // all pending-signal closes (TP/SL/time_expired/user/ping), scheduleEventSubject
+                // "cancelled" fires for scheduled signals removed before activation.
+                const unBacktestSignalEvent = signalEventSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect(async (event) => {
+                    if (event.action === "closed") {
+                        checkThrottleMap.delete(event.data.id);
+                    }
+                });
+                const unBacktestScheduleEvent = scheduleEventSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect(async (event) => {
+                    if (event.action === "cancelled") {
+                        checkThrottleMap.delete(event.data.id);
+                    }
+                });
                 const unBacktestPartialProfit = partialProfitSubject
                     .filter(({ backtest }) => backtest)
                     .connect(async (data) => {
@@ -69024,10 +69262,22 @@ class NotificationAdapter {
                 const unBacktestSync = syncSubject
                     .filter(({ backtest }) => backtest)
                     .connect(async (data) => {
-                    if (signal_sync) {
+                    if (order_sync) {
                         await NotificationBacktest.handleSync(data);
                     }
                 });
+                const unBacktestCheck = syncPendingSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect(async (data) => {
+                    if (order_check) {
+                        const lastTimestamp = checkThrottleMap.get(data.signalId);
+                        if (lastTimestamp !== undefined && data.timestamp - lastTimestamp < GLOBAL_CONFIG.CC_NOTIFICATION_ORDER_CHECK_TTL) {
+                            return;
+                        }
+                        checkThrottleMap.set(data.signalId, data.timestamp);
+                        await NotificationBacktest.handleCheck(data);
+                    }
+                });
                 const unBacktestRisk = riskSubject
                     .filter(({ backtest }) => backtest)
                     .connect(async (data) => {
@@ -69057,14 +69307,38 @@ class NotificationAdapter {
                         await NotificationBacktest.handleSignalNotify(data);
                     }
                 });
-                unBacktest = compose(() => unBacktestSignal(), () => unBacktestPartialProfit(), () => unBacktestPartialLoss(), () => unBacktestBreakeven(), () => unBacktestStrategyCommit(), () => unBacktestSync(), () => unBacktestRisk(), () => unBacktestError(), () => unBacktestExit(), () => unBacktestValidation(), () => unBacktestSignalNotify());
+                unBacktest = compose(() => unBacktestSignal(), () => unBacktestSignalEvent(), () => unBacktestScheduleEvent(), () => unBacktestPartialProfit(), () => unBacktestPartialLoss(), () => unBacktestBreakeven(), () => unBacktestStrategyCommit(), () => unBacktestSync(), () => unBacktestCheck(), () => unBacktestRisk(), () => unBacktestError(), () => unBacktestExit(), () => unBacktestValidation(), () => unBacktestSignalNotify(), () => checkThrottleMap.clear());
             }
             {
+                // Throttle state for order_sync.check: signalId -> timestamp of the last
+                // emitted check notification. Entries are dropped on signal close/cancel
+                // so the map cannot grow unbounded.
+                const checkThrottleMap = new Map();
                 const unLiveSignal = signalLiveEmitter.subscribe(async (data) => {
                     if (signal) {
                         await NotificationLive.handleSignal(data);
                     }
                 });
+                // Cleanup for checkThrottleMap. Tick-result emitters are NOT sufficient here:
+                // out-of-band closes (commitClosePending, failed order ping, scheduled cancel
+                // via commit) never reach signalBacktestEmitter/signalLiveEmitter. The
+                // lifecycle channels cover every path: signalEventSubject "closed" fires for
+                // all pending-signal closes (TP/SL/time_expired/user/ping), scheduleEventSubject
+                // "cancelled" fires for scheduled signals removed before activation.
+                const unLiveSignalEvent = signalEventSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect(async (event) => {
+                    if (event.action === "closed") {
+                        checkThrottleMap.delete(event.data.id);
+                    }
+                });
+                const unLiveScheduleEvent = scheduleEventSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect(async (event) => {
+                    if (event.action === "cancelled") {
+                        checkThrottleMap.delete(event.data.id);
+                    }
+                });
                 const unLivePartialProfit = partialProfitSubject
                     .filter(({ backtest }) => !backtest)
                     .connect(async (data) => {
@@ -69096,10 +69370,22 @@ class NotificationAdapter {
                 const unLiveSync = syncSubject
                     .filter(({ backtest }) => !backtest)
                     .connect(async (data) => {
-                    if (signal_sync) {
+                    if (order_sync) {
                         await NotificationLive.handleSync(data);
                     }
                 });
+                const unLiveCheck = syncPendingSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect(async (data) => {
+                    if (order_check) {
+                        const lastTimestamp = checkThrottleMap.get(data.signalId);
+                        if (lastTimestamp !== undefined && data.timestamp - lastTimestamp < GLOBAL_CONFIG.CC_NOTIFICATION_ORDER_CHECK_TTL) {
+                            return;
+                        }
+                        checkThrottleMap.set(data.signalId, data.timestamp);
+                        await NotificationLive.handleCheck(data);
+                    }
+                });
                 const unLiveRisk = riskSubject
                     .filter(({ backtest }) => !backtest)
                     .connect(async (data) => {
@@ -69129,7 +69415,7 @@ class NotificationAdapter {
                         await NotificationLive.handleSignalNotify(data);
                     }
                 });
-                unLive = compose(() => unLiveSignal(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveSync(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation(), () => unLiveSignalNotify());
+                unLive = compose(() => unLiveSignal(), () => unLiveSignalEvent(), () => unLiveScheduleEvent(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveSync(), () => unLiveCheck(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation(), () => unLiveSignalNotify(), () => checkThrottleMap.clear());
             }
             return () => {
                 unLive();
@@ -70424,17 +70710,31 @@ 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.
+ * A slot that does not settle within this window is treated as failed:
+ * `_runEntry` races the runtime-info assembly plus `entry.handler(info)`
+ * against a timer of this duration and, when the timer wins, rejects 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.
+ * never resolves (a lost `resolve`, a hung network call with no timeout of its
+ * own): without it such a handler would hold its `_inFlight` slot forever and
+ * `_tick`'s `Promise.all` would never settle, silently stalling every
+ * subsequent lifecycle tick while the process stays alive and outwardly
+ * healthy.
+ */
+const CRON_HANDLER_TIMEOUT = 900000;
+/**
+ * Early-warning threshold (ms) for a single cron handler invocation.
+ *
+ * Purely observational: when a slot is still running this long after it was
+ * opened, `_runEntry` logs a warning naming the entry — so a slow handler is
+ * visible in the logs long before the {@link CRON_HANDLER_TIMEOUT} watchdog
+ * forcibly fails it. Nothing is interrupted and no rollback happens at this
+ * mark; the slot keeps running and may still succeed.
  */
-const CRON_HANDLER_TIMEOUT = 120000;
+const CRON_HANDLER_WARN_TIMEOUT = 120000;
 /**
  * Local logger instance.
  *
@@ -70856,28 +71156,9 @@ class CronUtils {
                 }
                 taskList.push(pending);
             }
-            {
-                // 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);
-                }
-            }
+            // Every slot self-terminates via the `_runEntry` watchdog, so this settles
+            // within CRON_HANDLER_TIMEOUT plus epsilon even when a handler hangs.
+            await Promise.all(taskList);
             // 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
@@ -71061,9 +71342,17 @@ class CronUtils {
      *
      * 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
+     * `entry.handler(info)`, racing both against the
+     * {@link CRON_HANDLER_TIMEOUT} watchdog — a slot that does not settle in time
+     * rejects into the same `catch` as any other error, so a hung handler (or a
+     * hung price fetch inside `getRuntimeInfo`) can never hold the `_inFlight`
+     * slot forever and stall the serialised tick pipeline. A slot still running
+     * at {@link CRON_HANDLER_WARN_TIMEOUT} logs an observational warning first,
+     * so a slow handler is visible in the logs well before the watchdog forcibly
+     * fails it. Logs any error via
+     * `console.error` and **returns** a `failed` boolean (`true` when the
+     * handler — or the runtime-info assembly — threw or timed out) 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
@@ -71088,9 +71377,37 @@ class CronUtils {
      */
     async _runEntry(entry, symbol, alignedMs, slotKey, firedKey, backtest, context) {
         let failed = false;
+        let watchdog;
+        // Observational early warning: fires while the slot is still running, long
+        // before the watchdog below forcibly fails it. Cancelled in `finally`, so
+        // it never fires for slots that settle in time.
+        const slowAlarm = setTimeout(() => {
+            const message = `${CRON_METHOD_NAME_TICK} entry "${entry.name}" still running after ${CRON_HANDLER_WARN_TIMEOUT}ms (watchdog at ${CRON_HANDLER_TIMEOUT}ms)`;
+            const payload = { symbol, alignedMs };
+            LOGGER_SERVICE$1.warn(message, payload);
+            console.error(message, payload);
+        }, CRON_HANDLER_WARN_TIMEOUT);
         try {
-            const info = await RUNTIME_META_SERVICE.getRuntimeInfo(symbol, context, backtest);
-            await entry.handler(info);
+            // The runtime-info assembly is raced alongside the handler: in live mode
+            // getRuntimeInfo reaches out to the exchange for the current price, so it
+            // can hang on a dead network exactly like a user handler can.
+            const work = (async () => {
+                const info = await RUNTIME_META_SERVICE.getRuntimeInfo(symbol, context, backtest);
+                await entry.handler(info);
+            })();
+            // A timed-out slot abandons `work`; swallow its eventual rejection so a
+            // zombie handler that fails later never surfaces as an unhandled
+            // rejection. Its late success is equally unobserved: `failed` was already
+            // reported and (for fire-once entries) the fired mark deliberately not set.
+            work.catch(() => void 0);
+            await Promise.race([
+                work,
+                new Promise((_, reject) => {
+                    watchdog = setTimeout(() => {
+                        reject(new Error(`Cron entry "${entry.name}" timed out after ${CRON_HANDLER_TIMEOUT}ms`));
+                    }, CRON_HANDLER_TIMEOUT);
+                }),
+            ]);
         }
         catch (error) {
             failed = true;
@@ -71106,6 +71423,8 @@ class CronUtils {
             errorEmitter.next(error);
         }
         finally {
+            clearTimeout(slowAlarm);
+            clearTimeout(watchdog);
             this._inFlight.delete(slotKey);
             if (!failed && firedKey !== null) {
                 this._firedOnce.add(firedKey);