backtest-kit 15.0.0 → 15.1.0

package/build/index.mjs

@@ -5276,6 +5276,14 @@ const validateCandles = (candles) => {
             candle.volume < 0) {
             throw new Error(`validateCandles: candle[${i}] has zero or negative values`);
         }
+        // OHLC coherence: high < low is definitionally corrupt — such a candle
+        // would silently skew VWAP ((h+l+c)/3) and scheduled activation (low/high
+        // breach checks). Deliberately NOT extended to open/close vs high/low:
+        // cross-feed aggregation occasionally puts open/close a rounding step
+        // outside [low, high] on real exchanges.
+        if (candle.high < candle.low) {
+            throw new Error(`validateCandles: candle[${i}] has high (${candle.high}) < low (${candle.low})`);
+        }
         // Check for anomalously low prices (incomplete candle indicator)
         if (candle.open < minValidPrice ||
             candle.high < minValidPrice ||
@@ -5434,7 +5442,7 @@ const GET_CANDLES_FN$1 = async (dto, since, self) => {
                 return result;
             }
             catch (err) {
-                const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
+                const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}`;
                 const payload = {
                     error: errorData(err),
                     message: getErrorMessage(err),
@@ -5442,7 +5450,9 @@ const GET_CANDLES_FN$1 = async (dto, since, self) => {
                 self.params.logger.warn(message, payload);
                 console.warn(message, payload);
                 lastError = err;
-                await sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
+                if (i < GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT - 1) {
+                    await sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
+                }
             }
         }
         throw lastError ?? new Error(`ClientExchange GET_CANDLES_FN: no fetch attempts made (CC_GET_CANDLES_RETRY_COUNT=${GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT})`);
@@ -5598,7 +5608,9 @@ class ClientExchange {
      * @param symbol - Trading pair symbol
      * @param interval - Candle interval
      * @param limit - Number of candles to fetch
-     * @returns Promise resolving to array of candles
+     * @returns Promise resolving to array of candles; an EMPTY array when the
+     *          requested range extends beyond Date.now() (those candles have not
+     *          closed yet in the real world — the caller decides how to proceed)
      * @throws Error if trying to fetch future candles in live mode
      */
     async getNextCandles(symbol, interval, limit) {
@@ -5818,6 +5830,20 @@ class ClientExchange {
             }
             // Align sDate down to interval boundary
             sinceTimestamp = ALIGN_TO_INTERVAL_FN$2(sDate, step);
+            // The fetch is driven by sDate+limit, not by eDate — validate the ACTUAL
+            // end of the range like Case 4 does, otherwise a limit larger than the
+            // sDate..eDate span silently reads candles past `when` (and past eDate).
+            const endTimestamp = sinceTimestamp + limit * stepMs;
+            if (endTimestamp > whenTimestamp) {
+                throw new Error(`ClientExchange getRawCandles: calculated endTimestamp (${endTimestamp}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            // eDate is a hard bound, not advisory: the declared range must contain the
+            // whole fetch, otherwise the eDate<=when validation above is illusory.
+            const alignedEDate = ALIGN_TO_INTERVAL_FN$2(eDate, step);
+            if (endTimestamp > alignedEDate) {
+                throw new Error(`ClientExchange getRawCandles: limit (${limit}) extends the fetch end (${endTimestamp}) past aligned eDate (${alignedEDate}). ` +
+                    `With sDate+eDate+limit the whole range [alignedSDate, alignedSDate + limit*step] must fit within eDate.`);
+            }
             calculatedLimit = limit;
         }
         // Case 2: sDate + eDate (no limit) - calculate limit from date range
@@ -5999,8 +6025,13 @@ class ClientExchange {
             // Move window backwards
             windowEnd = windowStart;
         }
+        // Deduplicate by trade id across window seams: adjacent windows share the
+        // boundary timestamp, and the adapter [from, to] inclusivity is not pinned
+        // by the contract — an inclusive adapter returns the boundary trade in
+        // BOTH windows (systematically so for minute-bucketed sources).
+        const uniqueTrades = Array.from(new Map(result.map((trade) => [trade.id, trade])).values());
         // Slice to requested limit (most recent trades)
-        return result.slice(-limit);
+        return uniqueTrades.slice(-limit);
     }
 }
 
@@ -6336,6 +6367,18 @@ const weightedHarmonicMean = (entries) => {
     return totalCost / totalCoins;
 };
 
+/**
+ * Относительная составляющая допуска для guard'а «партиалы превысили вложения».
+ *
+ * Кап партиалов (PARTIAL_CAP_TOLERANCE_FACTOR в ClientStrategy) пропускает
+ * floating-point дрейф до totalInvested × 1e-9 НА ШАГ, а этот guard заново
+ * суммирует весь реплей partial-истории — дрейф накапливается по шагам, поэтому
+ * запас на порядок шире (1e-8). Чисто абсолютный порог ($0.001) отвергал
+ * легитимное 100%-закрытие позиции с крупным кастомным cost (>$1M): центы
+ * ULP-шума double — это не превышение вложений. Реальный перебор (проценты,
+ * а не 1e-8 относительных) по-прежнему отсекается.
+ */
+const PARTIAL_OVERCLOSE_RELATIVE_TOLERANCE = 1e-8;
 /**
  * Calculates profit/loss for a closed signal with slippage and fees.
  *
@@ -6396,7 +6439,8 @@ const toProfitLossDto = (signal, priceClose) => {
                     weight *
                     (priceCloseWithSlippage / priceOpenWithSlippage);
         }
-        if (closedDollarValue > totalInvested + 0.001) {
+        // Допуск absolute-OR-relative: см. PARTIAL_OVERCLOSE_RELATIVE_TOLERANCE
+        if (closedDollarValue > totalInvested + Math.max(0.001, totalInvested * PARTIAL_OVERCLOSE_RELATIVE_TOLERANCE)) {
             throw new Error(`Partial closes dollar value (${closedDollarValue.toFixed(4)}) exceeds total invested (${totalInvested}) — signal id: ${signal.id}`);
         }
         // Remaining position
@@ -7731,8 +7775,14 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         const intervalMinutes = INTERVAL_MINUTES$8[self.params.interval];
         const intervalMs = intervalMinutes * 60 * 1000;
         const alignedTime = Math.floor(currentTime / intervalMs) * intervalMs;
-        // Проверяем что наступил новый интервал (по aligned timestamp)
-        if (self._lastSignalTimestamp !== null &&
+        // Проверяем что наступил новый интервал (по aligned timestamp).
+        // User-queued DTO (createSignal) минует троттл: это явная команда, а не
+        // периодическая генерация — ожидание границы интервала задерживало её
+        // до целого интервала (час для "1h"). Потребление DTO при этом занимает
+        // слот текущего интервала (ниже), так что собственная генерация
+        // стратегии не учащается.
+        if (!self._userSignal &&
+            self._lastSignalTimestamp !== null &&
             alignedTime === self._lastSignalTimestamp) {
             return null;
         }
@@ -7748,10 +7798,23 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     {
         if (!self._userSignal) {
             const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
-            signal = await Promise.race([
-                self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
-                sleep(timeoutMs).then(() => TIMEOUT_SYMBOL$1),
-            ]);
+            // Cancelable timeout instead of a plain sleep: Promise.race does not
+            // cancel the loser, so the sleep timer stayed referenced for the full
+            // CC_MAX_SIGNAL_GENERATION_SECONDS after every getSignal call — keeping
+            // the node process alive up to 3 minutes after a backtest finishes and
+            // piling up one live timer per interval on long runs.
+            let timeoutId;
+            try {
+                signal = await Promise.race([
+                    self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
+                    new Promise((res) => {
+                        timeoutId = setTimeout(() => res(TIMEOUT_SYMBOL$1), timeoutMs);
+                    }),
+                ]);
+            }
+            finally {
+                timeoutId !== undefined && clearTimeout(timeoutId);
+            }
         }
         if (self._userSignal) {
             const userDto = self._userSignal;
@@ -8010,6 +8073,17 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
         // _closedSignal), so they stand on their own and are restored unconditionally too.
         self._takeProfitSignal = strategyData.takeProfitSignal;
         self._stopLossSignal = strategyData.stopLossSignal;
+        // Restore the commit queue when its attribution target is the deferred USER
+        // close snapshot (closePending / full-partial auto-close): that snapshot has
+        // pendingSignalId already null, so the pending-id match below cannot apply,
+        // yet PROCESS_COMMIT_QUEUE_FN attributes drained ops to _closedSignal — the
+        // non-crash flow delivers them, so dropping the queue here would lose
+        // broker-confirmed operations only because a restart happened in between.
+        // Broker-confirmed TP/SL fill snapshots intentionally do NOT restore the
+        // queue: those ops are void (see the orphaned-queue recovery test).
+        if (strategyData.closedSignal) {
+            self._commitQueue = strategyData.commitQueue ?? [];
+        }
     }
     // Restore pending signal. A context mismatch skips ONLY this block (not an
     // early return): the scheduled restore below and the onInit call must still run.
@@ -11849,11 +11923,15 @@ class ClientStrategy {
         // NOTE: No _isStopped check here - cancellation must work for graceful shutdown
         if (this._cancelledSignal) {
             const cancelledSignal = this._cancelledSignal;
+            // Release the slot reserved at scheduled-signal creation BEFORE persisting
+            // the drained flag: a crash in between replays the (idempotent) removal on
+            // restart instead of orphaning the slot — an orphan blocks the shared
+            // concurrency limit for the whole lifetime, forever for Infinity-hold
+            // (expiry pruning never removes those, and no owner is left to removeSignal).
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, currentTime, this.params.execution.context.backtest);
             this._cancelledSignal = null; // Clear after emitting
             // Persist the cleared deferred state so the drained flag is not replayed on restart
             await PERSIST_STRATEGY_FN(this);
-            // Release the slot reserved at scheduled-signal creation
-            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, currentTime, this.params.execution.context.backtest);
             this.params.logger.info("ClientStrategy tick: scheduled signal was cancelled", {
                 symbol: this.params.execution.context.symbol,
                 signalId: cancelledSignal.id,
@@ -11912,6 +11990,10 @@ class ClientStrategy {
                 // Do NOT clear _closedSignal — retry on next tick
                 return await RETURN_IDLE_FN(this, currentPrice);
             }
+            // Release the risk slot BEFORE persisting the drained flag: a crash in
+            // between replays the (idempotent) removal on restart instead of orphaning
+            // the slot until lifetime expiry (forever for Infinity-hold positions).
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, currentTime, this.params.execution.context.backtest);
             this._closedSignal = null; // Clear only after sync confirmed
             // Persist the cleared deferred state so the drained flag is not replayed on restart
             await PERSIST_STRATEGY_FN(this);
@@ -11946,8 +12028,8 @@ class ClientStrategy {
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
             await CALL_PARTIAL_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientBreakeven при закрытии позиции
+            // (риск-слот уже освобождён ДО персиста дренированного флага — см. выше)
             await CALL_BREAKEVEN_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
-            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, currentTime, this.params.execution.context.backtest);
             const result = {
                 action: "closed",
                 signal: publicSignal,
@@ -11970,6 +12052,10 @@ class ClientStrategy {
         // The exchange filled the TP order (e.g. by high/low); close bypassing the VWAP TP check.
         if (this._takeProfitSignal) {
             const filledSignal = this._takeProfitSignal;
+            // Release the risk slot BEFORE persisting the drained flag (crash-safe:
+            // removal is idempotent and re-runs on replay; the late removal inside
+            // CLOSE_PENDING_SIGNAL_AS_FILL_FN stays for the backtest paths)
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, currentTime, this.params.execution.context.backtest);
             this._takeProfitSignal = null; // Clear after draining
             // Persist the cleared deferred state so the drained flag is not replayed on restart
             await PERSIST_STRATEGY_FN(this);
@@ -11983,6 +12069,10 @@ class ClientStrategy {
         // The exchange filled the SL order (e.g. by high/low); close bypassing the VWAP SL check.
         if (this._stopLossSignal) {
             const filledSignal = this._stopLossSignal;
+            // Release the risk slot BEFORE persisting the drained flag (crash-safe:
+            // removal is idempotent and re-runs on replay; the late removal inside
+            // CLOSE_PENDING_SIGNAL_AS_FILL_FN stays for the backtest paths)
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, currentTime, this.params.execution.context.backtest);
             this._stopLossSignal = null; // Clear after draining
             // Persist the cleared deferred state so the drained flag is not replayed on restart
             await PERSIST_STRATEGY_FN(this);
@@ -12592,6 +12682,13 @@ class ClientStrategy {
             hasStopLossSignal: this._stopLossSignal !== null,
         });
         this._isStopped = true;
+        // A queued createSignal DTO is an explicit intent to open a NEW position —
+        // stop voids it, like it cancels a scheduled signal. Nothing was placed on
+        // the exchange for a queued DTO, so the drop is safe. Without this,
+        // _isStopped (deliberately NOT persisted: restart = operator intent to run)
+        // left the DTO on disk and the next restart silently opened a stale position.
+        const droppedUserSignal = this._userSignal !== null;
+        this._userSignal = null;
         // NOTE: _isStopped blocks NEW position opening, but deferred user commands
         // and broker-confirmed fills must still drain on subsequent ticks:
         // - _cancelledSignal / _closedSignal are KEPT — their drain emits the
@@ -12615,6 +12712,11 @@ class ClientStrategy {
         this._activatedSignal = null;
         this._scheduledSignal = null;
         if (!signalToCancel) {
+            // Persist the dropped createSignal DTO even when there is nothing to
+            // cancel — otherwise a crash after stop restores and opens it.
+            if (droppedUserSignal && !backtest) {
+                await PERSIST_STRATEGY_FN(this);
+            }
             return;
         }
         if (!this._cancelledSignal) {
@@ -12819,6 +12921,12 @@ class ClientStrategy {
      */
     async createSignal(symbol, currentPrice, dto) {
         this.params.logger.debug("ClientStrategy createSignal", { symbol, currentPrice });
+        // Queueing a DTO is opening a NEW position — blocked while stopped,
+        // mirroring activateScheduled (stopStrategy likewise voids an already
+        // queued DTO).
+        if (this._isStopped) {
+            throw new Error(`ClientStrategy createSignal: strategy is stopped for symbol=${symbol}`);
+        }
         // Validate BEFORE mutating state — a bad DTO or a busy strategy must store nothing.
         // Reuse validateSignal (the canonical getSignal-output validator, branching
         // pending-vs-scheduled by the same rule as GET_SIGNAL_FN). It forwards to
@@ -16588,6 +16696,9 @@ const calculateKellyCriterion = (params, schema) => {
     if (winLossRatio <= 0) {
         throw new Error("winLossRatio must be positive");
     }
+    if (priceOpen <= 0) {
+        throw new Error("priceOpen must be positive");
+    }
     // Kelly formula: (W * R - L) / R
     // W = win rate, L = loss rate (1 - W), R = win/loss ratio
     const kellyPercentage = (winRate * winLossRatio - (1 - winRate)) / winLossRatio;
@@ -16613,6 +16724,9 @@ const calculateATRBased = (params, schema) => {
     }
     const riskAmount = accountBalance * (riskPercentage / 100);
     const stopDistance = atr * atrMultiplier;
+    if (stopDistance === 0) {
+        throw new Error("ATR stop distance cannot be zero (check atrMultiplier)");
+    }
     return riskAmount / stopDistance;
 };
 /**
@@ -16684,6 +16798,9 @@ const CALCULATE_FN = async (params, self) => {
     }
     // Apply max position percentage constraint (risk cap)
     if (schema.maxPositionPercentage !== undefined) {
+        if (params.priceOpen <= 0) {
+            throw new Error("ClientSizing calculate: priceOpen must be positive to apply maxPositionPercentage");
+        }
         const maxByPercentage = (params.accountBalance * schema.maxPositionPercentage) /
             100 /
             params.priceOpen;
@@ -16854,15 +16971,21 @@ const TO_RISK_SIGNAL = (signal, currentPrice, timestamp) => {
     const hasTrailingSL = "_trailingPriceStopLoss" in signal && signal._trailingPriceStopLoss !== undefined;
     const hasTrailingTP = "_trailingPriceTakeProfit" in signal && signal._trailingPriceTakeProfit !== undefined;
     const partialExecuted = ("_partial" in signal && Array.isArray(signal._partial))
-        ? signal._partial.reduce((sum, partial) => sum + partial.percent, 0)
+        ? getTotalClosed(signal).totalClosedPercent
         : 0;
-    const pnl = signal._isScheduled ? ZERO_PNL : toProfitLossDto(signal, currentPrice);
+    // A market-open candidate (ISignalDto without priceOpen) opens at currentPrice —
+    // apply the same fallback BEFORE computing pnl, otherwise pnl.pnlPercentage is
+    // NaN and every numeric comparison in user risk validations silently passes.
+    const pnlSignal = signal.priceOpen === undefined
+        ? { ...signal, priceOpen: currentPrice }
+        : signal;
+    const pnl = signal._isScheduled ? ZERO_PNL : toProfitLossDto(pnlSignal, currentPrice);
     const maxDrawdown = signal._isScheduled ? ZERO_PNL : pnl;
     const peakProfit = signal._isScheduled ? ZERO_PNL : pnl;
     return {
         ...structuredClone(signal),
         cost: signal.cost || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST,
-        timestamp: signal.timestamp || timestamp,
+        timestamp: signal.timestamp ?? timestamp,
         totalEntries: 1,
         totalPartials: 0,
         priceOpen: signal.priceOpen ?? currentPrice,
@@ -16986,10 +17109,20 @@ class ClientRisk {
         this.params = params;
         /**
          * Map of active positions tracked across all strategies.
-         * Key: `${strategyName}:${exchangeName}:${symbol}`
+         * Key: `${strategyName}_${exchangeName}_${symbol}` (see CREATE_NAME_FN)
          * Starts as POSITION_NEED_FETCH symbol, gets initialized on first use.
          */
         this._activePositions = POSITION_NEED_FETCH;
+        /**
+         * Keys of transient reservation placeholders (checkSignalAndReserve) still
+         * awaiting their finalizing addSignal / releasing removeSignal. Excluded from
+         * persisted snapshots in _updatePositions: a reservation is process-transient,
+         * but a CONCURRENT strategy's addSignal persists the whole shared map — flushed
+         * to disk that placeholder would survive a crash as a phantom position and
+         * block the shared concurrency limit for the whole signal lifetime (forever
+         * for minuteEstimatedTime: Infinity, which the expiry pruning never removes).
+         */
+        this._reservedKeys = new Set();
         /**
          * Initializes active positions by loading from persistence.
          * Uses singleshot pattern to ensure initialization happens exactly once.
@@ -17060,8 +17193,11 @@ class ClientRisk {
                     }
                 }
                 if (rejectionResult) {
-                    // Call params.onRejected for riskSubject emission
-                    await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, params.timestamp, this.params.backtest);
+                    // Call params.onRejected for riskSubject emission.
+                    // Use the time-service timestamp — the same clock the rest of this
+                    // critical section runs on (TO_RISK_SIGNAL, waitForInit, reservation),
+                    // not the caller-supplied params.timestamp.
+                    await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, timestamp, this.params.backtest);
                     // Call schema callbacks.onRejected if defined
                     await CALL_REJECTED_CALLBACKS_FN(this, params.symbol, params);
                     return false;
@@ -17083,9 +17219,16 @@ class ClientRisk {
                         priceOpen: signal.priceOpen ?? params.currentPrice,
                         priceStopLoss: signal.priceStopLoss,
                         priceTakeProfit: signal.priceTakeProfit,
-                        minuteEstimatedTime: signal.minuteEstimatedTime,
+                        // The DTO is risk-checked BEFORE GET_SIGNAL_FN applies row defaults, so
+                        // apply the same lifetime default here — an undefined placeholder value
+                        // poisons expiry math (openTimestamp + undefined * 60_000 = NaN) in
+                        // concurrent validations reading activePositions.
+                        minuteEstimatedTime: signal.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
                         openTimestamp: timestamp,
                     });
+                    // Transient placeholder: visible to concurrent checks, but kept out of
+                    // persisted snapshots until addSignal finalizes it (see _reservedKeys)
+                    this._reservedKeys.add(reserveKey);
                 }
                 // All checks passed
                 await CALL_ALLOWED_CALLBACKS_FN(this, params.symbol, params);
@@ -17135,7 +17278,8 @@ class ClientRisk {
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit(when);
         }
-        await PersistRiskAdapter.writePositionData(Array.from(this._activePositions), this.params.riskName, this.params.exchangeName, when);
+        // Reservation placeholders stay in-memory only (see _reservedKeys)
+        await PersistRiskAdapter.writePositionData(Array.from(this._activePositions).filter(([key]) => !this._reservedKeys.has(key)), this.params.riskName, this.params.exchangeName, when);
     }
     /**
      * Registers a new opened signal.
@@ -17168,6 +17312,8 @@ class ClientRisk {
                 minuteEstimatedTime: positionData.minuteEstimatedTime,
                 openTimestamp: positionData.openTimestamp,
             });
+            // The placeholder (if any) is finalized into a real position — persist it
+            this._reservedKeys.delete(key);
             await this._updatePositions(new Date(timestamp));
         }
         finally {
@@ -17193,6 +17339,7 @@ class ClientRisk {
             const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
             const riskMap = this._activePositions;
             riskMap.delete(key);
+            this._reservedKeys.delete(key);
             await this._updatePositions(new Date(timestamp));
         }
         finally {
@@ -18427,6 +18574,12 @@ class ClientAction {
          * Starts as null, gets initialized on first use.
          */
         this._handlerInstance = null;
+        /**
+         * Terminal flag set by dispose(). Once true, all event methods become no-ops:
+         * the handler will not be recreated (waitForInit is singleshot), so late
+         * events must not reach the schema callbacks either.
+         */
+        this._isDisposed = false;
         /**
          * Initializes handler instance using singleshot pattern.
          * Ensures initialization happens exactly once.
@@ -18437,6 +18590,7 @@ class ClientAction {
          * Uses singleshot pattern to ensure cleanup happens exactly once.
          */
         this.dispose = singleshot(async () => {
+            this._isDisposed = true;
             await WAIT_FOR_DISPOSE_FN(this);
         });
     }
@@ -18450,6 +18604,12 @@ class ClientAction {
             frameName: this.params.frameName,
             action: event.action,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18468,6 +18628,12 @@ class ClientAction {
             frameName: this.params.frameName,
             action: event.action,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18487,6 +18653,12 @@ class ClientAction {
             frameName: this.params.frameName,
             action: event.action,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18505,6 +18677,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18523,6 +18701,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18541,6 +18725,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18559,6 +18749,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18582,6 +18778,12 @@ class ClientAction {
             frameName: this.params.frameName,
             action: event.action,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18605,6 +18807,12 @@ class ClientAction {
             frameName: this.params.frameName,
             action: event.action,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18623,6 +18831,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18641,6 +18855,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18659,6 +18879,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18678,6 +18904,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -18697,6 +18929,12 @@ class ClientAction {
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
         });
+        // Dropped after dispose(): the handler is gone and will not be recreated
+        // (waitForInit is singleshot), so firing only the schema callbacks here
+        // would desync them from the handler.
+        if (this._isDisposed) {
+            return;
+        }
         if (!this._handlerInstance) {
             await this.waitForInit();
         }
@@ -34328,10 +34566,10 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
  * @param backtest - True if backtest mode, false if live mode
  * @param self - ClientPartial instance reference
  */
-const WAIT_FOR_INIT_FN$1 = async (symbol, strategyName, exchangeName, frameName, backtest, self) => {
+const WAIT_FOR_INIT_FN$1 = async (symbol, strategyName, exchangeName, frameName, self) => {
     self.params.logger.debug("ClientPartial waitForInit", {
         symbol,
-        backtest,
+        backtest: self.params.backtest,
         strategyName,
         exchangeName,
     });
@@ -34457,7 +34695,7 @@ class ClientPartial {
          * // Now profit()/loss() can be called
          * ```
          */
-        this.waitForInit = singleshot(async (symbol, strategyName, exchangeName, frameName, backtest) => await WAIT_FOR_INIT_FN$1(symbol, strategyName, exchangeName, frameName, backtest, this));
+        this.waitForInit = singleshot(async (symbol, strategyName, exchangeName, frameName) => await WAIT_FOR_INIT_FN$1(symbol, strategyName, exchangeName, frameName, this));
     }
     /**
      * Persists current partial state to disk.
@@ -34789,7 +35027,7 @@ class PartialConnectionService {
                 when,
             });
             const partial = this.getPartial(data.id, backtest);
-            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
+            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName);
             return await partial.profit(symbol, data, currentPrice, revenuePercent, backtest, when);
         };
         /**
@@ -34816,7 +35054,7 @@ class PartialConnectionService {
                 when,
             });
             const partial = this.getPartial(data.id, backtest);
-            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
+            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName);
             return await partial.loss(symbol, data, currentPrice, lossPercent, backtest, when);
         };
         /**
@@ -34844,7 +35082,7 @@ class PartialConnectionService {
                 backtest,
             });
             const partial = this.getPartial(data.id, backtest);
-            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
+            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName);
             await partial.clear(symbol, data, priceClose, backtest);
             const key = CREATE_KEY_FN$l(data.id, backtest);
             this.getPartial.clear(key);
@@ -35590,12 +35828,12 @@ const HANDLE_BREAKEVEN_FN = async (symbol, data, currentPrice, backtest, when, s
  * @param exchangeName - Exchange identifier
  * @param self - ClientBreakeven instance reference
  */
-const WAIT_FOR_INIT_FN = async (symbol, strategyName, exchangeName, frameName, backtest, self) => {
+const WAIT_FOR_INIT_FN = async (symbol, strategyName, exchangeName, frameName, self) => {
     self.params.logger.debug("ClientBreakeven waitForInit", {
         symbol,
         strategyName,
         exchangeName,
-        backtest,
+        backtest: self.params.backtest,
     });
     if (self._states !== NEED_FETCH) {
         throw new Error("ClientBreakeven WAIT_FOR_INIT_FN should be called once!");
@@ -35716,7 +35954,7 @@ class ClientBreakeven {
          * // Now check() can be called
          * ```
          */
-        this.waitForInit = singleshot(async (symbol, strategyName, exchangeName, frameName, backtest) => await WAIT_FOR_INIT_FN(symbol, strategyName, exchangeName, frameName, backtest, this));
+        this.waitForInit = singleshot(async (symbol, strategyName, exchangeName, frameName) => await WAIT_FOR_INIT_FN(symbol, strategyName, exchangeName, frameName, this));
     }
     /**
      * Persists current breakeven state to disk.
@@ -35973,7 +36211,7 @@ class BreakevenConnectionService {
                 when,
             });
             const breakeven = this.getBreakeven(data.id, backtest);
-            await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
+            await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName);
             return await breakeven.check(symbol, data, currentPrice, backtest, when);
         };
         /**
@@ -36002,7 +36240,7 @@ class BreakevenConnectionService {
                 backtest,
             });
             const breakeven = this.getBreakeven(data.id, backtest);
-            await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
+            await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName);
             await breakeven.clear(symbol, data, priceClose, backtest);
             const key = CREATE_KEY_FN$i(data.id, backtest);
             this.getBreakeven.clear(key);
@@ -42967,8 +43205,13 @@ class ExchangeInstance {
                 // Move window backwards
                 windowEnd = windowStart;
             }
+            // Deduplicate by trade id across window seams: adjacent windows share the
+            // boundary timestamp, and the adapter [from, to] inclusivity is not pinned
+            // by the contract — an inclusive adapter returns the boundary trade in
+            // BOTH windows (systematically so for minute-bucketed sources).
+            const uniqueTrades = Array.from(new Map(result.map((trade) => [trade.id, trade])).values());
             // Slice to requested limit (most recent trades)
-            return result.slice(-limit);
+            return uniqueTrades.slice(-limit);
         };
         /**
          * Fetches raw candles with flexible date/limit parameters.