backtest-kit 13.0.0 → 13.2.0

package/build/index.cjs

@@ -6837,6 +6837,119 @@ const validateScheduledSignal = (signal, currentPrice) => {
     }
 };
 
+/**
+ * Validates ISignalDto returned by getSignal, branching on the same logic as ClientStrategy GET_SIGNAL_FN.
+ *
+ * When priceOpen is provided:
+ *   - If currentPrice already reached priceOpen (shouldActivateImmediately) →
+ *     validates as pending: currentPrice must be between SL and TP
+ *   - Otherwise → validates as scheduled: priceOpen must be between SL and TP
+ *
+ * When priceOpen is absent:
+ *   - Validates as pending: currentPrice must be between SL and TP
+ *
+ * Checks:
+ * - currentPrice is a finite positive number
+ * - Common signal fields via validateCommonSignal (position, prices, TP/SL relationships, minuteEstimatedTime)
+ * - Position-specific immediate-close protection (pending) or activation-close protection (scheduled)
+ *
+ * @param signal - Signal DTO returned by getSignal
+ * @param currentPrice - Current market price at the moment of signal creation
+ * @returns true if signal is valid, false if validation errors were found (errors logged to console.error)
+ */
+const validateSignal = (signal, currentPrice) => {
+    const errors = [];
+    // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
+    {
+        if (typeof currentPrice !== "number") {
+            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (!isFinite(currentPrice)) {
+            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (isFinite(currentPrice) && currentPrice <= 0) {
+            errors.push(`currentPrice must be positive, got ${currentPrice}`);
+        }
+    }
+    if (errors.length > 0) {
+        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
+        return false;
+    }
+    try {
+        validateCommonSignal(signal);
+    }
+    catch (error) {
+        console.error(functoolsKit.getErrorMessage(error));
+        return false;
+    }
+    // Определяем режим валидации по той же логике что в GET_SIGNAL_FN:
+    // - нет priceOpen → pending (открывается по currentPrice)
+    // - priceOpen задан и уже достигнут (shouldActivateImmediately) → pending
+    // - priceOpen задан и ещё не достигнут → scheduled
+    const hasPriceOpen = signal.priceOpen !== undefined;
+    const shouldActivateImmediately = hasPriceOpen && ((signal.position === "long" && currentPrice <= signal.priceOpen) ||
+        (signal.position === "short" && currentPrice >= signal.priceOpen));
+    const isScheduled = hasPriceOpen && !shouldActivateImmediately;
+    if (isScheduled) {
+        // Scheduled: priceOpen должен быть между SL и TP (активация не даст моментального закрытия)
+        if (signal.position === "long") {
+            if (isFinite(signal.priceOpen)) {
+                if (signal.priceOpen <= signal.priceStopLoss) {
+                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) <= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
+                }
+                if (signal.priceOpen >= signal.priceTakeProfit) {
+                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would close immediately on activation. This is logically impossible for LONG position.`);
+                }
+            }
+        }
+        if (signal.position === "short") {
+            if (isFinite(signal.priceOpen)) {
+                if (signal.priceOpen >= signal.priceStopLoss) {
+                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) >= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
+                }
+                if (signal.priceOpen <= signal.priceTakeProfit) {
+                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would close immediately on activation. This is logically impossible for SHORT position.`);
+                }
+            }
+        }
+    }
+    else {
+        // Pending: currentPrice должна быть между SL и TP (позиция не закроется сразу после открытия)
+        if (signal.position === "long") {
+            if (isFinite(currentPrice)) {
+                if (currentPrice <= signal.priceStopLoss) {
+                    errors.push(`Long immediate: currentPrice (${currentPrice}) <= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
+                }
+                if (currentPrice >= signal.priceTakeProfit) {
+                    errors.push(`Long immediate: currentPrice (${currentPrice}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+                }
+            }
+        }
+        if (signal.position === "short") {
+            if (isFinite(currentPrice)) {
+                if (currentPrice >= signal.priceStopLoss) {
+                    errors.push(`Short immediate: currentPrice (${currentPrice}) >= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
+                }
+                if (currentPrice <= signal.priceTakeProfit) {
+                    errors.push(`Short immediate: currentPrice (${currentPrice}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+                }
+            }
+        }
+    }
+    if (errors.length > 0) {
+        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
+    }
+    return !errors.length;
+};
+
 const INTERVAL_MINUTES$8 = {
     "1m": 1,
     "3m": 3,
@@ -7303,11 +7416,27 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         self._lastSignalTimestamp = alignedTime;
     }
     const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
-    const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
-    const signal = await Promise.race([
-        self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
-        functoolsKit.sleep(timeoutMs).then(() => TIMEOUT_SYMBOL$1),
-    ]);
+    // PRIORITY: a user-queued createPending/createScheduled DTO (set out of async-hooks
+    // context) takes precedence over params.getSignal. When present it is consumed once
+    // here — the slot is cleared and the snapshot rewritten — and then flows through the
+    // exact same pipeline (risk check, priceOpen branching, onSignalSync on open) as a
+    // signal returned by getSignal would.
+    let signal;
+    {
+        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),
+                functoolsKit.sleep(timeoutMs).then(() => TIMEOUT_SYMBOL$1),
+            ]);
+        }
+        if (self._userSignal) {
+            signal = self._userSignal;
+            self._userSignal = null;
+            await PERSIST_STRATEGY_FN(self);
+        }
+        self._userSignal = null;
+    }
     if (typeof signal === "symbol") {
         throw new Error(`Timeout for ${self.params.method.context.strategyName} symbol=${self.params.execution.context.symbol}`);
     }
@@ -7462,18 +7591,20 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
             self._lastPendingId = recentSignal.id;
         }
     }
-    // Restore deferred strategy state (commit queue + deferred user actions) so any
+    // Read deferred strategy state (commit queue + deferred user actions) so any
     // confirmed-but-not-yet-forwarded broker operation survives a live crash and is
-    // re-drained on the next tick. Placed before the pending/scheduled restore which
-    // may early-return on exchange/strategy mismatch.
-    {
-        const strategyData = await PersistStrategyAdapter.readStrategyData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
-        if (strategyData) {
-            self._commitQueue = strategyData.commitQueue ?? [];
-            self._closedSignal = strategyData.closedSignal;
-            self._cancelledSignal = strategyData.cancelledSignal;
-            self._activatedSignal = strategyData.activatedSignal;
-        }
+    // re-drained on the next tick. Read here, before the pending restore which may
+    // early-return on exchange/strategy mismatch.
+    const strategyData = await PersistStrategyAdapter.readStrategyData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
+    if (strategyData) {
+        // Deferred user actions are restored unconditionally: a deferred close belongs to
+        // an already-cleared _pendingSignal, and cancel/activate belong to the scheduled
+        // signal — none of them are tied to the currently-pending signal's id. A queued
+        // createSignal is a not-yet-consumed signal source and likewise stands on its own.
+        self._userSignal = strategyData.createSignal;
+        self._closedSignal = strategyData.closedSignal;
+        self._cancelledSignal = strategyData.cancelledSignal;
+        self._activatedSignal = strategyData.activatedSignal;
     }
     // Restore pending signal
     const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
@@ -7491,6 +7622,14 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
             pendingSignal.minuteEstimatedTime = Infinity;
         }
         self._pendingSignal = pendingSignal;
+        // Restore the commit queue only if the snapshot belongs to this exact pending
+        // signal (pendingSignalId === restored id). The queue holds confirmed-but-not-yet
+        // forwarded broker ops (average-buy / partial-* / trailing-* / breakeven) that are
+        // always tied to the active position; a mismatch means the snapshot is stale and
+        // the queue is dropped to avoid replaying ops against the wrong position.
+        if (strategyData && strategyData.pendingSignalId === pendingSignal.id) {
+            self._commitQueue = strategyData.commitQueue ?? [];
+        }
         // Call onActive callback for restored signal
         const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
         const currentTime = self.params.execution.context.when.getTime();
@@ -7540,6 +7679,8 @@ const PERSIST_STRATEGY_FN = async (self) => {
         return;
     }
     await PersistStrategyAdapter.writeStrategyData({
+        pendingSignalId: self._pendingSignal?.id ?? null,
+        createSignal: self._userSignal,
         commitQueue: self._commitQueue,
         closedSignal: self._closedSignal,
         cancelledSignal: self._cancelledSignal,
@@ -9675,6 +9816,13 @@ class ClientStrategy {
         this._cancelledSignal = null;
         this._closedSignal = null;
         this._activatedSignal = null;
+        /**
+         * User-supplied signal DTO to be consumed by the next GET_SIGNAL_FN tick instead of
+         * params.getSignal. Set via createSignal. When non-null, params.getSignal is NOT called
+         * and the existing pipeline (priceOpen decides pending vs scheduled, onSignalSync on open)
+         * is reused.
+         */
+        this._userSignal = null;
         /** Queue for commit events to be processed in tick()/backtest() with proper timestamp */
         this._commitQueue = [];
         /**
@@ -11325,6 +11473,88 @@ class ClientStrategy {
         await PERSIST_STRATEGY_FN(this);
         // Commit will be emitted in tick() with correct currentTime
     }
+    /**
+     * Queues a user-supplied signal DTO to be consumed by the next tick instead of
+     * params.getSignal.
+     *
+     * Works OUT of the async-hooks execution context (uses this.params.symbol directly).
+     * priceOpen decides the outcome in the existing pipeline: when omitted the position opens
+     * immediately at currentPrice; when provided the pipeline opens immediately if priceOpen is
+     * already reached, otherwise registers a scheduled (priceOpen-awaiting) signal. On the next
+     * tick GET_SIGNAL_FN consumes _userSignal and runs the normal pipeline, so onSignalSync
+     * delivery is checked by OPEN_NEW_PENDING_SIGNAL_FN exactly as for a getSignal-produced signal.
+     *
+     * Validation (BEFORE any state mutation — a rejected call stores nothing):
+     * - The DTO must pass the intrinsic shape/price checks.
+     * - There must be NO signal already in flight: no active pending signal, no scheduled signal,
+     *   no already-queued createSignal, and no deferred activate/close/cancel awaiting drain.
+     *   Creating a new signal on top of an existing one is rejected.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price (priceOpen fallback for immediate signals)
+     * @param dto - Signal DTO to open (priceOpen optional)
+     * @returns Promise that resolves when the DTO is queued (and persisted in live mode)
+     * @throws {Error} If the DTO is invalid or a signal/deferred action is already in flight
+     */
+    async createSignal(symbol, currentPrice, dto) {
+        this.params.logger.debug("ClientStrategy createSignal", { symbol, currentPrice });
+        // 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
+        // validateCommonSignal which requires priceOpen and minuteEstimatedTime, so normalize the
+        // DTO to the defaults GET_SIGNAL_FN would apply (priceOpen → currentPrice for an immediate
+        // signal, minuteEstimatedTime → CC_MAX_SIGNAL_LIFETIME_MINUTES). The original dto stored in
+        // _userSignal is left untouched so GET_SIGNAL_FN applies its own defaults on consume.
+        if (!validateSignal({
+            ...dto,
+            priceOpen: dto.priceOpen ?? currentPrice,
+            minuteEstimatedTime: dto.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
+        }, currentPrice)) {
+            throw new Error(`ClientStrategy createSignal: invalid signal DTO for symbol=${symbol}`);
+        }
+        // Reject if any signal is already in flight or any deferred action is awaiting drain.
+        if (this._pendingSignal) {
+            throw new Error(`ClientStrategy createSignal: a pending signal already exists for symbol=${symbol}`);
+        }
+        if (this._scheduledSignal) {
+            throw new Error(`ClientStrategy createSignal: a scheduled signal already exists for symbol=${symbol}`);
+        }
+        if (this._userSignal) {
+            throw new Error(`ClientStrategy createSignal: a signal is already queued for creation for symbol=${symbol}`);
+        }
+        if (this._activatedSignal) {
+            throw new Error(`ClientStrategy createSignal: a scheduled activation is pending for symbol=${symbol}`);
+        }
+        if (this._closedSignal) {
+            throw new Error(`ClientStrategy createSignal: a pending close is awaiting for symbol=${symbol}`);
+        }
+        if (this._cancelledSignal) {
+            throw new Error(`ClientStrategy createSignal: a scheduled cancel is awaiting for symbol=${symbol}`);
+        }
+        this._userSignal = dto;
+        await PERSIST_STRATEGY_FN(this);
+    }
+    /**
+     * Returns the deferred strategy-state snapshot exactly as it would be written to persist on
+     * this iteration: the in-memory _userSignal, _commitQueue and deferred user-action flags,
+     * plus the current pending signal id.
+     *
+     * Synchronous in-memory read (no disk access), so it works OUT of the async-hooks context.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @returns The current StrategyData snapshot held in memory
+     */
+    async getStatus(symbol) {
+        this.params.logger.debug("ClientStrategy getStatus", { symbol });
+        return {
+            pendingSignalId: this._pendingSignal?.id ?? null,
+            createSignal: this._userSignal,
+            commitQueue: this._commitQueue,
+            closedSignal: this._closedSignal,
+            cancelledSignal: this._cancelledSignal,
+            activatedSignal: this._activatedSignal,
+        };
+    }
     /**
      * Validates preconditions for partialProfit without mutating state.
      *
@@ -12623,6 +12853,8 @@ class MergeRisk {
 
 /** Default interval for strategies that do not specify one */
 const STRATEGY_DEFAULT_INTERVAL = "1m";
+/** If not specified strategy will not open positions until createSignal is called manually */
+const STRATEGY_DEFAULT_SIGNAL = () => null;
 /**
  * If syncSubject listener or any registered action throws, it means the signal was not properly synchronized
  * to the exchange (e.g. limit order failed to fill).
@@ -13056,7 +13288,7 @@ class StrategyConnectionService {
          * @returns Configured ClientStrategy instance
          */
         this.getStrategy = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$A(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
-            const { riskName = "", riskList = [], getSignal, interval = STRATEGY_DEFAULT_INTERVAL, callbacks, } = this.strategySchemaService.get(strategyName);
+            const { riskName = "", riskList = [], getSignal = STRATEGY_DEFAULT_SIGNAL, interval = STRATEGY_DEFAULT_INTERVAL, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
                 interval,
@@ -14075,6 +14307,47 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.closePending(symbol, backtest, payload);
         };
+        /**
+         * Queues a user-supplied signal DTO to be consumed by the next tick instead of getSignal.
+         *
+         * Delegates to ClientStrategy.createSignal(). Validated and rejected if a signal/deferred
+         * action is already in flight. Works out of the async-hooks execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param dto - Signal DTO to open
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when the DTO is queued
+         */
+        this.createSignal = async (backtest, symbol, dto, context) => {
+            this.loggerService.log("strategyConnectionService createSignal", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            await strategy.createSignal(symbol, currentPrice, dto);
+        };
+        /**
+         * Returns the in-memory deferred strategy-state snapshot for this iteration.
+         *
+         * Delegates to ClientStrategy.getStatus(). Synchronous in-memory read; works out of context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to the current StrategyData snapshot
+         */
+        this.getStatus = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getStatus", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getStatus(symbol);
+        };
         /**
          * Checks whether `partialProfit` would succeed without executing it.
          * Delegates to `ClientStrategy.validatePartialProfit()` — no throws, pure boolean result.
@@ -17678,6 +17951,47 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.closePending(backtest, symbol, context, payload);
         };
+        /**
+         * Queues a user-supplied signal DTO to be consumed by the next tick instead of getSignal.
+         *
+         * Validates the context, then delegates to StrategyConnectionService.createSignal().
+         * Rejected if a signal or deferred action is already in flight. Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param dto - Signal DTO to open
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when the DTO is queued
+         */
+        this.createSignal = async (backtest, symbol, dto, context) => {
+            this.loggerService.log("strategyCoreService createSignal", {
+                symbol,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.createSignal(backtest, symbol, dto, context);
+        };
+        /**
+         * Returns the in-memory deferred strategy-state snapshot for this iteration.
+         *
+         * Validates the context, then delegates to StrategyConnectionService.getStatus().
+         * Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to the current StrategyStatus snapshot
+         */
+        this.getStatus = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getStatus", {
+                symbol,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getStatus(backtest, symbol, context);
+        };
         /**
          * Disposes the ClientStrategy instance for the given context.
          *
@@ -19202,7 +19516,7 @@ class StrategySchemaService {
             if (strategySchema.interval && typeof strategySchema.interval !== "string") {
                 throw new Error(`strategy schema validation failed: invalid interval for strategyName=${strategySchema.strategyName}`);
             }
-            if (typeof strategySchema.getSignal !== "function") {
+            if (strategySchema.getSignal && typeof strategySchema.getSignal !== "function") {
                 throw new Error(`strategy schema validation failed: missing getSignal for strategyName=${strategySchema.strategyName}`);
             }
         };
@@ -42916,6 +43230,8 @@ const GET_POSITION_PARTIAL_OVERLAP_METHOD_NAME = "strategy.getPositionPartialOve
 const HAS_NO_PENDING_SIGNAL_METHOD_NAME = "strategy.hasNoPendingSignal";
 const HAS_NO_SCHEDULED_SIGNAL_METHOD_NAME = "strategy.hasNoScheduledSignal";
 const COMMIT_SIGNAL_NOTIFY_METHOD_NAME = "strategy.commitSignalNotify";
+const COMMIT_CREATE_SIGNAL_METHOD_NAME = "strategy.commitCreateSignal";
+const GET_STRATEGY_STATUS_METHOD_NAME = "strategy.getStrategyStatus";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -44980,6 +45296,69 @@ async function commitSignalNotify(symbol, payload = {}) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     await bt.notificationHelperService.commitSignalNotify(payload, symbol, currentPrice, { strategyName, exchangeName, frameName }, isBacktest);
 }
+/**
+ * Queues a user-supplied signal DTO to be consumed by the next tick instead of params.getSignal.
+ *
+ * priceOpen decides the outcome via the existing pipeline: omitted → opens immediately at the
+ * current price; provided → opens immediately if already reached, otherwise registers a
+ * scheduled (priceOpen-awaiting) signal. The DTO is validated (reusing validateSignal) and the
+ * call is rejected if a signal or deferred action is already in flight.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param dto - Signal DTO to open (priceOpen optional)
+ * @returns Promise that resolves when the DTO is queued
+ *
+ * @example
+ * ```typescript
+ * import { createSignal } from "backtest-kit";
+ *
+ * // Open immediately at current price
+ * await commitCreateSignal("BTCUSDT", { position: "long", priceTakeProfit: 110, priceStopLoss: 90 });
+ * ```
+ */
+async function commitCreateSignal(symbol, dto) {
+    bt.loggerService.info(COMMIT_CREATE_SIGNAL_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("createSignal requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("createSignal requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.createSignal(isBacktest, symbol, dto, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the in-memory deferred strategy-state snapshot for the current iteration: the queued
+ * createSignal, commit queue and deferred user-action flags, plus the current pending signal id.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to the current StrategyStatus snapshot
+ *
+ * @example
+ * ```typescript
+ * import { getStrategyStatus } from "backtest-kit";
+ *
+ * const status = await getStrategyStatus("BTCUSDT");
+ * console.log(status.pendingSignalId, status.commitQueue.length);
+ * ```
+ */
+async function getStrategyStatus(symbol) {
+    bt.loggerService.info(GET_STRATEGY_STATUS_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getStrategyStatus requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getStrategyStatus requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getStatus(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -46651,6 +47030,8 @@ const BACKTEST_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "BacktestUtils.getPosi
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
 const BACKTEST_METHOD_NAME_CANCEL_SCHEDULED = "Backtest.commitCancelScheduled";
 const BACKTEST_METHOD_NAME_CLOSE_PENDING = "Backtest.commitClosePending";
+const BACKTEST_METHOD_NAME_COMMIT_CREATE_SIGNAL = "Backtest.commitCreateSignal";
+const BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS = "Backtest.getStrategyStatus";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST = "BacktestUtils.commitPartialProfitCost";
@@ -48355,6 +48736,53 @@ class BacktestUtils {
             }
             await bt.strategyCoreService.closePending(true, symbol, context, payload);
         };
+        /**
+         * Queues a user-supplied signal DTO to be consumed by the next backtest tick instead of
+         * params.getSignal.
+         *
+         * priceOpen decides the outcome via the existing pipeline: omitted → opens immediately at the
+         * current price; provided → opens immediately if already reached, otherwise registers a
+         * scheduled signal. Validated, and rejected if a signal or deferred action is already in flight.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param dto - Signal DTO to open (priceOpen optional)
+         * @returns Promise that resolves when the DTO is queued
+         */
+        this.commitCreateSignal = async (symbol, context, dto) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_COMMIT_CREATE_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_COMMIT_CREATE_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_COMMIT_CREATE_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_COMMIT_CREATE_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_COMMIT_CREATE_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_COMMIT_CREATE_SIGNAL));
+            }
+            await bt.strategyCoreService.createSignal(true, symbol, dto, context);
+        };
+        /**
+         * Returns the in-memory deferred strategy-state snapshot for the current backtest iteration.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise resolving to the current StrategyStatus snapshot
+         */
+        this.getStrategyStatus = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS);
+            return await bt.strategyCoreService.getStatus(true, symbol, context);
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -49313,6 +49741,8 @@ const LIVE_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "LiveUtils.getPositionPart
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
 const LIVE_METHOD_NAME_CANCEL_SCHEDULED = "Live.cancelScheduled";
 const LIVE_METHOD_NAME_CLOSE_PENDING = "Live.closePending";
+const LIVE_METHOD_NAME_COMMIT_CREATE_SIGNAL = "Live.commitCreateSignal";
+const LIVE_METHOD_NAME_GET_STRATEGY_STATUS = "Live.getStrategyStatus";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT_COST = "LiveUtils.commitPartialProfitCost";
@@ -51190,6 +51620,61 @@ class LiveUtils {
                 frameName: "",
             }, payload);
         };
+        /**
+         * Queues a user-supplied signal DTO to be consumed by the next live tick instead of
+         * params.getSignal.
+         *
+         * priceOpen decides the outcome via the existing pipeline: omitted → opens immediately at the
+         * current price; provided → opens immediately if already reached, otherwise registers a
+         * scheduled signal. Validated, and rejected if a signal or deferred action is already in flight.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param dto - Signal DTO to open (priceOpen optional)
+         * @returns Promise that resolves when the DTO is queued
+         */
+        this.commitCreateSignal = async (symbol, context, dto) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_COMMIT_CREATE_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_COMMIT_CREATE_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_COMMIT_CREATE_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_COMMIT_CREATE_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_COMMIT_CREATE_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_COMMIT_CREATE_SIGNAL));
+            }
+            await bt.strategyCoreService.createSignal(false, symbol, dto, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the in-memory deferred strategy-state snapshot for the current live iteration.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise resolving to the current StrategyStatus snapshot
+         */
+        this.getStrategyStatus = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_STRATEGY_STATUS, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_STRATEGY_STATUS);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_STRATEGY_STATUS);
+            return await bt.strategyCoreService.getStatus(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -67836,119 +68321,6 @@ const percentValue = (yesterdayValue, todayValue) => {
     return yesterdayValue / todayValue - 1;
 };
 
-/**
- * Validates ISignalDto returned by getSignal, branching on the same logic as ClientStrategy GET_SIGNAL_FN.
- *
- * When priceOpen is provided:
- *   - If currentPrice already reached priceOpen (shouldActivateImmediately) →
- *     validates as pending: currentPrice must be between SL and TP
- *   - Otherwise → validates as scheduled: priceOpen must be between SL and TP
- *
- * When priceOpen is absent:
- *   - Validates as pending: currentPrice must be between SL and TP
- *
- * Checks:
- * - currentPrice is a finite positive number
- * - Common signal fields via validateCommonSignal (position, prices, TP/SL relationships, minuteEstimatedTime)
- * - Position-specific immediate-close protection (pending) or activation-close protection (scheduled)
- *
- * @param signal - Signal DTO returned by getSignal
- * @param currentPrice - Current market price at the moment of signal creation
- * @returns true if signal is valid, false if validation errors were found (errors logged to console.error)
- */
-const validateSignal = (signal, currentPrice) => {
-    const errors = [];
-    // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
-    {
-        if (typeof currentPrice !== "number") {
-            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
-        }
-        if (!isFinite(currentPrice)) {
-            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
-        }
-        if (isFinite(currentPrice) && currentPrice <= 0) {
-            errors.push(`currentPrice must be positive, got ${currentPrice}`);
-        }
-    }
-    if (errors.length > 0) {
-        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
-        return false;
-    }
-    try {
-        validateCommonSignal(signal);
-    }
-    catch (error) {
-        console.error(functoolsKit.getErrorMessage(error));
-        return false;
-    }
-    // Определяем режим валидации по той же логике что в GET_SIGNAL_FN:
-    // - нет priceOpen → pending (открывается по currentPrice)
-    // - priceOpen задан и уже достигнут (shouldActivateImmediately) → pending
-    // - priceOpen задан и ещё не достигнут → scheduled
-    const hasPriceOpen = signal.priceOpen !== undefined;
-    const shouldActivateImmediately = hasPriceOpen && ((signal.position === "long" && currentPrice <= signal.priceOpen) ||
-        (signal.position === "short" && currentPrice >= signal.priceOpen));
-    const isScheduled = hasPriceOpen && !shouldActivateImmediately;
-    if (isScheduled) {
-        // Scheduled: priceOpen должен быть между SL и TP (активация не даст моментального закрытия)
-        if (signal.position === "long") {
-            if (isFinite(signal.priceOpen)) {
-                if (signal.priceOpen <= signal.priceStopLoss) {
-                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) <= priceStopLoss (${signal.priceStopLoss}). ` +
-                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
-                }
-                if (signal.priceOpen >= signal.priceTakeProfit) {
-                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                        `Signal would close immediately on activation. This is logically impossible for LONG position.`);
-                }
-            }
-        }
-        if (signal.position === "short") {
-            if (isFinite(signal.priceOpen)) {
-                if (signal.priceOpen >= signal.priceStopLoss) {
-                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) >= priceStopLoss (${signal.priceStopLoss}). ` +
-                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
-                }
-                if (signal.priceOpen <= signal.priceTakeProfit) {
-                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                        `Signal would close immediately on activation. This is logically impossible for SHORT position.`);
-                }
-            }
-        }
-    }
-    else {
-        // Pending: currentPrice должна быть между SL и TP (позиция не закроется сразу после открытия)
-        if (signal.position === "long") {
-            if (isFinite(currentPrice)) {
-                if (currentPrice <= signal.priceStopLoss) {
-                    errors.push(`Long immediate: currentPrice (${currentPrice}) <= priceStopLoss (${signal.priceStopLoss}). ` +
-                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
-                }
-                if (currentPrice >= signal.priceTakeProfit) {
-                    errors.push(`Long immediate: currentPrice (${currentPrice}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
-                }
-            }
-        }
-        if (signal.position === "short") {
-            if (isFinite(currentPrice)) {
-                if (currentPrice >= signal.priceStopLoss) {
-                    errors.push(`Short immediate: currentPrice (${currentPrice}) >= priceStopLoss (${signal.priceStopLoss}). ` +
-                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
-                }
-                if (currentPrice <= signal.priceTakeProfit) {
-                    errors.push(`Short immediate: currentPrice (${currentPrice}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
-                }
-            }
-        }
-    }
-    if (errors.length > 0) {
-        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
-    }
-    return !errors.length;
-};
-
 exports.ActionBase = ActionBase;
 exports.Backtest = Backtest;
 exports.Breakeven = Breakeven;
@@ -68058,6 +68430,7 @@ exports.commitAverageBuy = commitAverageBuy;
 exports.commitBreakeven = commitBreakeven;
 exports.commitCancelScheduled = commitCancelScheduled;
 exports.commitClosePending = commitClosePending;
+exports.commitCreateSignal = commitCreateSignal;
 exports.commitPartialLoss = commitPartialLoss;
 exports.commitPartialLossCost = commitPartialLossCost;
 exports.commitPartialProfit = commitPartialProfit;
@@ -68141,6 +68514,7 @@ exports.getSessionData = getSessionData;
 exports.getSignalState = getSignalState;
 exports.getSizingSchema = getSizingSchema;
 exports.getStrategySchema = getStrategySchema;
+exports.getStrategyStatus = getStrategyStatus;
 exports.getSymbol = getSymbol;
 exports.getTimestamp = getTimestamp;
 exports.getTotalClosed = getTotalClosed;