backtest-kit 15.1.0 → 15.3.0

package/build/index.cjs

@@ -553,6 +553,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.
@@ -5317,6 +5327,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,
@@ -6012,7 +6040,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
@@ -6029,7 +6057,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) {
@@ -15376,6 +15404,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);
@@ -42696,6 +42728,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).
@@ -43192,7 +43242,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
@@ -43209,7 +43259,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) {
@@ -45708,6 +45758,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45734,6 +45785,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45757,6 +45809,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45775,6 +45828,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45792,6 +45846,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45804,6 +45859,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 });
             });
@@ -45821,6 +45877,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 };
                 if (event.action === "scheduled") {
@@ -45843,6 +45900,7 @@ class BrokerAdapter {
                         exchangeName: event.exchangeName,
                         frameName: event.frameName,
                     },
+                    when: new Date(event.timestamp),
                     backtest: event.backtest,
                 };
                 if (event.action === "opened") {
@@ -46617,6 +46675,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 });
@@ -46685,6 +46744,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 });
@@ -46769,6 +46829,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 });
@@ -46853,6 +46914,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 });
@@ -46908,6 +46970,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 });
@@ -46963,6 +47026,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 });
@@ -47024,6 +47088,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 });
@@ -47116,6 +47181,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);
@@ -47552,6 +47618,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 });
@@ -47624,6 +47691,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 });
@@ -52538,6 +52606,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);
@@ -52612,6 +52681,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);
@@ -52689,6 +52759,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);
@@ -52766,6 +52837,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);
@@ -52855,6 +52927,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);
@@ -52944,6 +53017,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);
@@ -52999,6 +53073,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);
@@ -53054,6 +53129,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);
@@ -53115,6 +53191,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);
@@ -53216,6 +53293,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);
@@ -55547,6 +55625,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, {
@@ -55642,6 +55721,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, {
@@ -55739,6 +55819,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, {
@@ -55836,6 +55917,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, {
@@ -55940,6 +56022,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, {
@@ -56044,6 +56127,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, {
@@ -56115,6 +56199,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, {
@@ -56186,6 +56271,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, {
@@ -56267,6 +56353,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, {
@@ -56386,6 +56473,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, {
@@ -66681,7 +66769,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,
@@ -67410,14 +67499,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,
@@ -67425,6 +67515,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,
@@ -67462,7 +67553,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,
@@ -67470,6 +67561,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,
@@ -67507,6 +67599,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
@@ -67624,6 +67764,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";
@@ -67637,6 +67778,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";
@@ -67666,6 +67808,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";
@@ -67681,6 +67824,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";
@@ -67779,15 +67923,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 = functoolsKit.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
@@ -67902,6 +68054,13 @@ class NotificationDummyBacktestUtils {
         }, {
             defaultValue: null,
         });
+        /**
+         * No-op handler for order-ping check event.
+         */
+        this.handleCheck = functoolsKit.trycatch(async () => {
+        }, {
+            defaultValue: null,
+        });
         /**
          * No-op handler for risk rejection event.
          */
@@ -68053,17 +68212,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 = functoolsKit.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
@@ -68257,15 +68426,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 = functoolsKit.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
@@ -68380,6 +68557,13 @@ class NotificationDummyLiveUtils {
         }, {
             defaultValue: null,
         });
+        /**
+         * No-op handler for order-ping check event.
+         */
+        this.handleCheck = functoolsKit.trycatch(async () => {
+        }, {
+            defaultValue: null,
+        });
         /**
          * No-op handler for risk rejection event.
          */
@@ -68532,17 +68716,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 = functoolsKit.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
@@ -68720,6 +68914,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 = functoolsKit.trycatch(async (data) => {
+            return await this.getInstance().handleCheck(data);
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * Proxies call to the underlying notification adapter.
@@ -68890,6 +69094,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 = functoolsKit.trycatch(async (data) => {
+            return await this.getInstance().handleCheck(data);
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * Proxies call to the underlying notification adapter.
@@ -69003,16 +69217,40 @@ class NotificationAdapter {
          *
          * @returns Cleanup function that unsubscribes from all emitters
          */
-        this.enable = functoolsKit.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 = functoolsKit.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) => {
@@ -69044,10 +69282,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) => {
@@ -69077,14 +69327,38 @@ class NotificationAdapter {
                         await NotificationBacktest.handleSignalNotify(data);
                     }
                 });
-                unBacktest = functoolsKit.compose(() => unBacktestSignal(), () => unBacktestPartialProfit(), () => unBacktestPartialLoss(), () => unBacktestBreakeven(), () => unBacktestStrategyCommit(), () => unBacktestSync(), () => unBacktestRisk(), () => unBacktestError(), () => unBacktestExit(), () => unBacktestValidation(), () => unBacktestSignalNotify());
+                unBacktest = functoolsKit.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) => {
@@ -69116,10 +69390,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) => {
@@ -69149,7 +69435,7 @@ class NotificationAdapter {
                         await NotificationLive.handleSignalNotify(data);
                     }
                 });
-                unLive = functoolsKit.compose(() => unLiveSignal(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveSync(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation(), () => unLiveSignalNotify());
+                unLive = functoolsKit.compose(() => unLiveSignal(), () => unLiveSignalEvent(), () => unLiveScheduleEvent(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveSync(), () => unLiveCheck(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation(), () => unLiveSignalNotify(), () => checkThrottleMap.clear());
             }
             return () => {
                 unLive();
@@ -70444,17 +70730,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.
  *
@@ -70876,28 +71176,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
@@ -71081,9 +71362,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
@@ -71108,9 +71397,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;
@@ -71126,6 +71443,8 @@ class CronUtils {
             errorEmitter.next(error);
         }
         finally {
+            clearTimeout(slowAlarm);
+            clearTimeout(watchdog);
             this._inFlight.delete(slotKey);
             if (!failed && firedKey !== null) {
                 this._firedOnce.add(firedKey);