backtest-kit 2.0.11 → 2.1.1

package/build/index.mjs

@@ -4389,6 +4389,7 @@ class ClientStrategy {
         this._lastSignalTimestamp = null;
         this._scheduledSignal = null;
         this._cancelledSignal = null;
+        this._closedSignal = null;
         /**
          * Initializes strategy state by loading persisted signal from disk.
          *
@@ -4665,6 +4666,41 @@ class ClientStrategy {
                 reason: "user",
                 cancelId: cancelledSignal.cancelId,
             };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
+            return result;
+        }
+        // Check if pending signal was closed - emit closed event once
+        if (this._closedSignal) {
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            const closedSignal = this._closedSignal;
+            this._closedSignal = null; // Clear after emitting
+            this.params.logger.info("ClientStrategy tick: pending signal was closed", {
+                symbol: this.params.execution.context.symbol,
+                signalId: closedSignal.id,
+            });
+            // Call onClose callback
+            await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние 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 pnl = toProfitLossDto(closedSignal, currentPrice);
+            const result = {
+                action: "closed",
+                signal: TO_PUBLIC_SIGNAL(closedSignal),
+                currentPrice,
+                closeReason: "closed",
+                closeTimestamp: currentTime,
+                pnl,
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                backtest: this.params.execution.context.backtest,
+                closeId: closedSignal.closeId,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
             return result;
         }
         // Monitor scheduled signal
@@ -4778,8 +4814,40 @@ class ClientStrategy {
                 reason: "user",
                 cancelId: cancelledSignal.cancelId,
             };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledResult, closeTimestamp, this.params.execution.context.backtest);
             return cancelledResult;
         }
+        // If signal was closed - return closed
+        if (this._closedSignal) {
+            this.params.logger.debug("ClientStrategy backtest: pending signal was closed");
+            const currentPrice = await this.params.exchange.getAveragePrice(symbol);
+            const closedSignal = this._closedSignal;
+            this._closedSignal = null; // Clear after using
+            const closeTimestamp = this.params.execution.context.when.getTime();
+            await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
+            await CALL_PARTIAL_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientBreakeven при закрытии позиции
+            await CALL_BREAKEVEN_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, closeTimestamp, this.params.execution.context.backtest);
+            const pnl = toProfitLossDto(closedSignal, currentPrice);
+            const closedResult = {
+                action: "closed",
+                signal: TO_PUBLIC_SIGNAL(closedSignal),
+                currentPrice,
+                closeReason: "closed",
+                closeTimestamp: closeTimestamp,
+                pnl,
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                backtest: true,
+                closeId: closedSignal.closeId,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, closedResult, closeTimestamp, this.params.execution.context.backtest);
+            return closedResult;
+        }
         if (!this._pendingSignal && !this._scheduledSignal) {
             throw new Error("ClientStrategy backtest: no pending or scheduled signal");
         }
@@ -4906,12 +4974,12 @@ class ClientStrategy {
      * @example
      * ```typescript
      * // In Live.background() cancellation
-     * await strategy.stop();
+     * await strategy.stopStrategy();
      * // Existing signal will continue until natural close
      * ```
      */
-    async stop(symbol, backtest) {
-        this.params.logger.debug("ClientStrategy stop", {
+    async stopStrategy(symbol, backtest) {
+        this.params.logger.debug("ClientStrategy stopStrategy", {
             symbol,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
@@ -4944,12 +5012,12 @@ class ClientStrategy {
      * @example
      * ```typescript
      * // Cancel scheduled signal without stopping strategy
-     * await strategy.cancel("BTCUSDT", "my-strategy", false);
+     * await strategy.cancelScheduled("BTCUSDT", "my-strategy", false);
      * // Strategy continues, can generate new signals
      * ```
      */
-    async cancel(symbol, backtest, cancelId) {
-        this.params.logger.debug("ClientStrategy cancel", {
+    async cancelScheduled(symbol, backtest, cancelId) {
+        this.params.logger.debug("ClientStrategy cancelScheduled", {
             symbol,
             hasScheduledSignal: this._scheduledSignal !== null,
             cancelId,
@@ -4966,6 +5034,45 @@ class ClientStrategy {
         }
         await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
     }
+    /**
+     * Closes the pending signal without stopping the strategy.
+     *
+     * Clears the pending signal (active position).
+     * Does NOT affect scheduled signals or strategy operation.
+     * Does NOT set stop flag - strategy can continue generating new signals.
+     *
+     * Use case: Close an active position that is no longer desired without stopping the entire strategy.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param closeId - Optional identifier for this close operation
+     * @returns Promise that resolves when pending signal is cleared
+     *
+     * @example
+     * ```typescript
+     * // Close pending signal without stopping strategy
+     * await strategy.closePending("BTCUSDT", false, "user-close-123");
+     * // Strategy continues, can generate new signals
+     * ```
+     */
+    async closePending(symbol, backtest, closeId) {
+        this.params.logger.debug("ClientStrategy closePending", {
+            symbol,
+            hasPendingSignal: this._pendingSignal !== null,
+            closeId,
+        });
+        // Save closed signal for next tick to emit closed event
+        if (this._pendingSignal) {
+            this._closedSignal = Object.assign({}, this._pendingSignal, {
+                closeId,
+            });
+            this._pendingSignal = null;
+        }
+        if (backtest) {
+            return;
+        }
+        await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
+    }
     /**
      * Executes partial close at profit level (moving toward TP).
      *
@@ -6418,7 +6525,7 @@ class StrategyConnectionService {
         /**
          * Stops the specified strategy from generating new signals.
          *
-         * Delegates to ClientStrategy.stop() which sets internal flag to prevent
+         * Delegates to ClientStrategy.stopStrategy() which sets internal flag to prevent
          * getSignal from being called on subsequent ticks.
          *
          * @param backtest - Whether running in backtest mode
@@ -6426,13 +6533,13 @@ class StrategyConnectionService {
          * @param ctx - Context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (backtest, symbol, context) => {
-            this.loggerService.log("strategyConnectionService stop", {
+        this.stopStrategy = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService stopStrategy", {
                 symbol,
                 context,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.stop(symbol, backtest);
+            await strategy.stopStrategy(symbol, backtest);
         };
         /**
          * Disposes the ClientStrategy instance for the given context.
@@ -6484,7 +6591,7 @@ class StrategyConnectionService {
         /**
          * Cancels the scheduled signal for the specified strategy.
          *
-         * Delegates to ClientStrategy.cancel() which clears the scheduled signal
+         * Delegates to ClientStrategy.cancelScheduled() which clears the scheduled signal
          * without stopping the strategy or affecting pending signals.
          *
          * Note: Cancelled event will be emitted on next tick() call when strategy
@@ -6496,14 +6603,39 @@ class StrategyConnectionService {
          * @param cancelId - Optional cancellation ID for user-initiated cancellations
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancel = async (backtest, symbol, context, cancelId) => {
-            this.loggerService.log("strategyConnectionService cancel", {
+        this.cancelScheduled = async (backtest, symbol, context, cancelId) => {
+            this.loggerService.log("strategyConnectionService cancelScheduled", {
                 symbol,
                 context,
                 cancelId,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.cancel(symbol, backtest, cancelId);
+            await strategy.cancelScheduled(symbol, backtest, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * Note: Closed event will be emitted on next tick() call when strategy
+         * detects the pending signal was closed.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         */
+        this.closePending = async (backtest, symbol, context, closeId) => {
+            this.loggerService.log("strategyConnectionService closePending", {
+                symbol,
+                context,
+                closeId,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.closePending(symbol, backtest, closeId);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -9690,19 +9822,19 @@ class StrategyCoreService {
          * @param ctx - Context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (backtest, symbol, context) => {
-            this.loggerService.log("strategyCoreService stop", {
+        this.stopStrategy = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService stopStrategy", {
                 symbol,
                 context,
                 backtest,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.stop(backtest, symbol, context);
+            return await this.strategyConnectionService.stopStrategy(backtest, symbol, context);
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
          *
-         * Delegates to StrategyConnectionService.cancel() to clear scheduled signal
+         * Delegates to StrategyConnectionService.cancelScheduled() to clear scheduled signal
          * and emit cancelled event through emitters.
          * Does not require execution context.
          *
@@ -9712,15 +9844,42 @@ class StrategyCoreService {
          * @param cancelId - Optional cancellation ID for user-initiated cancellations
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancel = async (backtest, symbol, context, cancelId) => {
-            this.loggerService.log("strategyCoreService cancel", {
+        this.cancelScheduled = async (backtest, symbol, context, cancelId) => {
+            this.loggerService.log("strategyCoreService cancelScheduled", {
                 symbol,
                 context,
                 backtest,
                 cancelId,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.cancel(backtest, symbol, context, cancelId);
+            return await this.strategyConnectionService.cancelScheduled(backtest, symbol, context, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * Delegates to StrategyConnectionService.closePending() to clear pending signal
+         * and emit closed event through emitters.
+         * Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         */
+        this.closePending = async (backtest, symbol, context, closeId) => {
+            this.loggerService.log("strategyCoreService closePending", {
+                symbol,
+                context,
+                backtest,
+                closeId,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.closePending(backtest, symbol, context, closeId);
         };
         /**
          * Disposes the ClientStrategy instance for the given context.
@@ -25006,7 +25165,8 @@ async function getOrderBook(symbol, depth) {
     return await bt.exchangeConnectionService.getOrderBook(symbol, depth);
 }
 
-const CANCEL_METHOD_NAME = "strategy.commitCancel";
+const CANCEL_SCHEDULED_METHOD_NAME = "strategy.commitCancelScheduled";
+const CLOSE_PENDING_METHOD_NAME = "strategy.commitClosePending";
 const PARTIAL_PROFIT_METHOD_NAME = "strategy.commitPartialProfit";
 const PARTIAL_LOSS_METHOD_NAME = "strategy.commitPartialLoss";
 const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
@@ -25028,26 +25188,62 @@ const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
  *
  * @example
  * ```typescript
- * import { cancel } from "backtest-kit";
+ * import { commitCancelScheduled } from "backtest-kit";
  *
  * // Cancel scheduled signal with custom ID
- * await cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+ * await commitCancelScheduled("BTCUSDT", "manual-cancel-001");
  * ```
  */
-async function commitCancel(symbol, cancelId) {
-    bt.loggerService.info(CANCEL_METHOD_NAME, {
+async function commitCancelScheduled(symbol, cancelId) {
+    bt.loggerService.info(CANCEL_SCHEDULED_METHOD_NAME, {
         symbol,
         cancelId,
     });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("cancel requires an execution context");
+        throw new Error("commitCancelScheduled requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("cancel requires a method context");
+        throw new Error("commitCancelScheduled requires a method context");
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.cancel(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+    await bt.strategyCoreService.cancelScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+}
+/**
+ * Closes the pending signal without stopping the strategy.
+ *
+ * Clears the pending signal (active position).
+ * Does NOT affect scheduled signals or strategy operation.
+ * Does NOT set stop flag - strategy can continue generating new signals.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param closeId - Optional close ID for tracking user-initiated closes
+ * @returns Promise that resolves when pending signal is closed
+ *
+ * @example
+ * ```typescript
+ * import { commitClosePending } from "backtest-kit";
+ *
+ * // Close pending signal with custom ID
+ * await commitClosePending("BTCUSDT", "manual-close-001");
+ * ```
+ */
+async function commitClosePending(symbol, closeId) {
+    bt.loggerService.info(CLOSE_PENDING_METHOD_NAME, {
+        symbol,
+        closeId,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitClosePending requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitClosePending requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.closePending(isBacktest, symbol, { exchangeName, frameName, strategyName }, closeId);
 }
 /**
  * Executes partial close at profit level (moving toward TP).
@@ -25294,7 +25490,7 @@ async function commitBreakeven(symbol) {
     return await bt.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
 
-const STOP_METHOD_NAME = "control.stop";
+const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
  * Stops the strategy from generating new signals.
  *
@@ -25316,8 +25512,8 @@ const STOP_METHOD_NAME = "control.stop";
  * await stop("BTCUSDT", "my-strategy");
  * ```
  */
-async function stop(symbol) {
-    bt.loggerService.info(STOP_METHOD_NAME, {
+async function stopStrategy(symbol) {
+    bt.loggerService.info(STOP_STRATEGY_METHOD_NAME, {
         symbol,
     });
     if (!ExecutionContextService.hasContext()) {
@@ -25328,7 +25524,7 @@ async function stop(symbol) {
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.stop(isBacktest, symbol, {
+    await bt.strategyCoreService.stopStrategy(isBacktest, symbol, {
         exchangeName,
         frameName,
         strategyName,
@@ -27715,7 +27911,8 @@ const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal"
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
 const BACKTEST_METHOD_NAME_GET_BREAKEVEN = "BacktestUtils.getBreakeven";
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
-const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.commitCancel";
+const BACKTEST_METHOD_NAME_CANCEL_SCHEDULED = "Backtest.commitCancelScheduled";
+const BACKTEST_METHOD_NAME_CLOSE_PENDING = "Backtest.commitClosePending";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
@@ -27957,7 +28154,7 @@ class BacktestInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(true, symbol, {
+                bt.strategyCoreService.stopStrategy(true, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: context.frameName,
@@ -28225,7 +28422,7 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_STOP));
             }
-            await bt.strategyCoreService.stop(true, symbol, context);
+            await bt.strategyCoreService.stopStrategy(true, symbol, context);
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
@@ -28250,24 +28447,65 @@ class BacktestUtils {
          * }, "manual-cancel-001");
          * ```
          */
-        this.commitCancel = async (symbol, context, cancelId) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_CANCEL, {
+        this.commitCancelScheduled = async (symbol, context, cancelId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_CANCEL_SCHEDULED, {
                 symbol,
                 context,
                 cancelId,
             });
-            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL);
-            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL);
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL);
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL));
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED));
                 actions &&
-                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CANCEL));
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED));
             }
-            await bt.strategyCoreService.cancel(true, symbol, context, cancelId);
+            await bt.strategyCoreService.cancelScheduled(true, symbol, context, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         *
+         * @example
+         * ```typescript
+         * // Close pending signal with custom ID
+         * await Backtest.commitClose("BTCUSDT", {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy",
+         *   frameName: "1m"
+         * }, "manual-close-001");
+         * ```
+         */
+        this.commitClosePending = async (symbol, context, closeId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_CLOSE_PENDING, {
+                symbol,
+                context,
+                closeId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CLOSE_PENDING));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CLOSE_PENDING));
+            }
+            await bt.strategyCoreService.closePending(true, symbol, context, closeId);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -28704,7 +28942,8 @@ const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
 const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
 const LIVE_METHOD_NAME_GET_BREAKEVEN = "LiveUtils.getBreakeven";
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
-const LIVE_METHOD_NAME_CANCEL = "LiveUtils.commitCancel";
+const LIVE_METHOD_NAME_CANCEL_SCHEDULED = "Live.cancelScheduled";
+const LIVE_METHOD_NAME_CLOSE_PENDING = "Live.closePending";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
@@ -28909,7 +29148,7 @@ class LiveInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(false, symbol, {
+                bt.strategyCoreService.stopStrategy(false, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: ""
@@ -29176,7 +29415,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
                 actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_STOP));
             }
-            await bt.strategyCoreService.stop(false, symbol, {
+            await bt.strategyCoreService.stopStrategy(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -29205,26 +29444,67 @@ class LiveUtils {
          * }, "manual-cancel-001");
          * ```
          */
-        this.commitCancel = async (symbol, context, cancelId) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_CANCEL, {
+        this.commitCancelScheduled = async (symbol, context, cancelId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_CANCEL_SCHEDULED, {
                 symbol,
                 context,
                 cancelId,
             });
-            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL);
-            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL);
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CANCEL));
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
             }
-            await bt.strategyCoreService.cancel(false, symbol, {
+            await bt.strategyCoreService.cancelScheduled(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
             }, cancelId);
         };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         *
+         * @example
+         * ```typescript
+         * // Close pending signal with custom ID
+         * await Live.commitClose("BTCUSDT", {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * }, "manual-close-001");
+         * ```
+         */
+        this.commitClosePending = async (symbol, context, closeId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_CLOSE_PENDING, {
+                symbol,
+                context,
+                closeId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CLOSE_PENDING);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CLOSE_PENDING);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CLOSE_PENDING));
+            }
+            await bt.strategyCoreService.closePending(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, closeId);
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -30141,7 +30421,7 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    bt.strategyCoreService.stop(true, symbol, {
+                    bt.strategyCoreService.stopStrategy(true, symbol, {
                         strategyName,
                         exchangeName: walkerSchema.exchangeName,
                         frameName: walkerSchema.frameName
@@ -30297,7 +30577,7 @@ class WalkerUtils {
             }
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
-                await bt.strategyCoreService.stop(true, symbol, {
+                await bt.strategyCoreService.stopStrategy(true, symbol, {
                     strategyName,
                     exchangeName: walkerSchema.exchangeName,
                     frameName: walkerSchema.frameName
@@ -32134,33 +32414,35 @@ class NotificationInstance {
             });
         };
         /**
-         * Initializes notification system by subscribing to all emitters.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
+         * Subscribes to all notification emitters and returns an unsubscribe function.
+         * Protected against multiple subscriptions using singleshot.
+         *
+         * @returns Unsubscribe function to stop receiving all notification events
+         *
+         * @example
+         * ```typescript
+         * const instance = new NotificationInstance();
+         * const unsubscribe = instance.subscribe();
+         * // ... later
+         * unsubscribe();
+         * ```
          */
-        this.waitForInit = singleshot(async () => {
-            // Add bootstrap notification to mark initialization
-            this._addNotification({
-                type: "bootstrap",
-                id: CREATE_KEY_FN(),
-                timestamp: Date.now(),
-            });
-            // Signal events
-            signalEmitter.subscribe(this._handleSignal);
-            // Partial profit/loss events
-            partialProfitSubject.subscribe(this._handlePartialProfit);
-            partialLossSubject.subscribe(this._handlePartialLoss);
-            // Risk events
-            riskSubject.subscribe(this._handleRisk);
-            // Done events
-            doneLiveSubject.subscribe(this._handleDoneLive);
-            doneBacktestSubject.subscribe(this._handleDoneBacktest);
-            // Error events
-            errorEmitter.subscribe(this._handleError);
-            exitEmitter.subscribe(this._handleCriticalError);
-            validationSubject.subscribe(this._handleValidationError);
-            // Progress events
-            progressBacktestEmitter.subscribe(this._handleProgressBacktest);
+        this.enable = singleshot(() => {
+            const unSignal = signalEmitter.subscribe(this._handleSignal);
+            const unProfit = partialProfitSubject.subscribe(this._handlePartialProfit);
+            const unLoss = partialLossSubject.subscribe(this._handlePartialLoss);
+            const unRisk = riskSubject.subscribe(this._handleRisk);
+            const unDoneLine = doneLiveSubject.subscribe(this._handleDoneLive);
+            const unDoneBacktest = doneBacktestSubject.subscribe(this._handleDoneBacktest);
+            const unError = errorEmitter.subscribe(this._handleError);
+            const unExit = exitEmitter.subscribe(this._handleCriticalError);
+            const unValidation = validationSubject.subscribe(this._handleValidationError);
+            const unProgressBacktest = progressBacktestEmitter.subscribe(this._handleProgressBacktest);
+            const disposeFn = compose(() => unSignal(), () => unProfit(), () => unLoss(), () => unRisk(), () => unDoneLine(), () => unDoneBacktest(), () => unError(), () => unExit(), () => unValidation(), () => unProgressBacktest());
+            return () => {
+                disposeFn();
+                this.enable.clear();
+            };
         });
     }
     /**
@@ -32210,18 +32492,36 @@ class NotificationInstance {
     clear() {
         this._notifications = [];
     }
+    /**
+     * Unsubscribes from all notification emitters to stop receiving events.
+     * Calls the unsubscribe function returned by subscribe().
+     * If not subscribed, does nothing.
+     *
+     * @example
+     * ```typescript
+     * const instance = new NotificationInstance();
+     * instance.subscribe();
+     * // ... later
+     * instance.unsubscribe();
+     * ```
+     */
+    disable() {
+        if (this.enable.hasValue()) {
+            const unsubscribeFn = this.enable();
+            unsubscribeFn();
+        }
+    }
 }
 /**
  * Public facade for notification operations.
  *
- * Automatically calls waitForInit on each userspace method call.
- * Provides simplified access to notification instance methods.
+ * Automatically subscribes on first use and provides simplified access to notification instance methods.
  *
  * @example
  * ```typescript
  * import { Notification } from "./classes/Notification";
  *
- * // Get all notifications
+ * // Get all notifications (auto-subscribes if not subscribed)
  * const all = await Notification.getData();
  *
  * // Process notifications with type discrimination
@@ -32243,6 +32543,9 @@ class NotificationInstance {
  *
  * // Clear history
  * await Notification.clear();
+ *
+ * // Unsubscribe when done
+ * await Notification.unsubscribe();
  * ```
  */
 class NotificationUtils {
@@ -32252,6 +32555,7 @@ class NotificationUtils {
     }
     /**
      * Returns all notifications in chronological order (newest first).
+     * Automatically subscribes to emitters if not already subscribed.
      *
      * @returns Array of strongly-typed notification objects
      *
@@ -32274,11 +32578,14 @@ class NotificationUtils {
      * ```
      */
     async getData() {
-        await this._instance.waitForInit();
+        if (!this._instance.enable.hasValue()) {
+            throw new Error("Notification not initialized. Call enable() before getting data.");
+        }
         return this._instance.getData();
     }
     /**
      * Clears all notification history.
+     * Automatically subscribes to emitters if not already subscribed.
      *
      * @example
      * ```typescript
@@ -32286,9 +32593,34 @@ class NotificationUtils {
      * ```
      */
     async clear() {
-        await this._instance.waitForInit();
+        if (!this._instance.enable.hasValue()) {
+            throw new Error("Notification not initialized. Call enable() before clearing data.");
+        }
         this._instance.clear();
     }
+    /**
+     * Unsubscribes from all notification emitters.
+     * Call this when you no longer need to collect notifications.
+     *
+     * @example
+     * ```typescript
+     * await Notification.unsubscribe();
+     * ```
+     */
+    async enable() {
+        this._instance.enable();
+    }
+    /**
+     * Unsubscribes from all notification emitters.
+     * Call this when you no longer need to collect notifications.
+     * @example
+     * ```typescript
+     * await Notification.unsubscribe();
+     * ```
+     */
+    async disable() {
+        this._instance.disable();
+    }
 }
 /**
  * Singleton instance of NotificationUtils for convenient notification access.
@@ -32628,4 +32960,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancel, commitPartialLoss, commitPartialProfit, commitSignalPromptHistory, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stop, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitSignalPromptHistory, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };