backtest-kit 13.0.0 → 13.1.0

package/build/index.mjs

@@ -6817,6 +6817,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(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,
@@ -7283,11 +7396,27 @@ const GET_SIGNAL_FN = 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),
-        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),
+                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}`);
     }
@@ -7442,18 +7571,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);
@@ -7471,6 +7602,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();
@@ -7520,6 +7659,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,
@@ -9655,6 +9796,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 = [];
         /**
@@ -11305,6 +11453,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.
      *
@@ -12603,6 +12833,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).
@@ -13036,7 +13268,7 @@ class StrategyConnectionService {
          * @returns Configured ClientStrategy instance
          */
         this.getStrategy = 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,
@@ -14055,6 +14287,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.
@@ -17658,6 +17931,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.
          *
@@ -19182,7 +19496,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}`);
             }
         };
@@ -42896,6 +43210,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 CREATE_SIGNAL_METHOD_NAME = "strategy.createSignal";
+const GET_STRATEGY_STATUS_METHOD_NAME = "strategy.getStrategyStatus";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -44960,6 +45276,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 createSignal("BTCUSDT", { position: "long", priceTakeProfit: 110, priceStopLoss: 90 });
+ * ```
+ */
+async function createSignal(symbol, dto) {
+    bt.loggerService.info(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";
 /**
@@ -46631,6 +47010,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_CREATE_SIGNAL = "Backtest.createSignal";
+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";
@@ -48335,6 +48716,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.createSignal = async (symbol, context, dto) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_CREATE_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CREATE_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CREATE_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CREATE_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CREATE_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_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).
          *
@@ -49293,6 +49721,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_CREATE_SIGNAL = "Live.createSignal";
+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";
@@ -51170,6 +51600,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.createSignal = async (symbol, context, dto) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_CREATE_SIGNAL, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CREATE_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CREATE_SIGNAL);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CREATE_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CREATE_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_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).
          *
@@ -67816,117 +68301,4 @@ 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(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;
-};
-
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, PersistStrategyAdapter, PersistStrategyInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getPriceScale, getRawCandles, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCandles, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, PersistStrategyAdapter, PersistStrategyInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignal, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getPriceScale, getRawCandles, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getStrategyStatus, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCandles, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };