backtest-kit 12.8.0 → 13.0.0

package/build/index.mjs

@@ -981,6 +981,12 @@ const PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA = "PersistScheduleUtils.writ
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON = "PersistScheduleUtils.useJson";
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY = "PersistScheduleUtils.useDummy";
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR = "PersistScheduleUtils.clear";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_PERSIST_STRATEGY_ADAPTER = "PersistStrategyUtils.usePersistStrategyAdapter";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_READ_DATA = "PersistStrategyUtils.readStrategyData";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_WRITE_DATA = "PersistStrategyUtils.writeStrategyData";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_JSON = "PersistStrategyUtils.useJson";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_DUMMY = "PersistStrategyUtils.useDummy";
+const PERSIST_STRATEGY_UTILS_METHOD_NAME_CLEAR = "PersistStrategyUtils.clear";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER = "PersistPartialUtils.usePersistPartialAdapter";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA = "PersistPartialUtils.readPartialData";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistPartialUtils.writePartialData";
@@ -1844,6 +1850,212 @@ class PersistScheduleUtils {
  * ```
  */
 const PersistScheduleAdapter = new PersistScheduleUtils();
+/**
+ * Default file-based implementation of IPersistStrategyInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses fixed entity ID "strategy" within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistStrategyInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeStrategyData(snapshot);
+ * const restored = await instance.readStrategyData();
+ * ```
+ */
+class PersistStrategyInstance {
+    /**
+     * Creates new deferred strategy state persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/strategy/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted strategy state snapshot using the fixed STORAGE_KEY.
+     *
+     * @returns Promise resolving to strategy state snapshot or null if not found
+     */
+    async readStrategyData() {
+        if (await this._storage.hasValue(PersistStrategyInstance.STORAGE_KEY)) {
+            const strategyData = await this._storage.readValue(PersistStrategyInstance.STORAGE_KEY);
+            // JSON serializes Infinity as null, so an eternal-hold signal
+            // (minuteEstimatedTime: Infinity) reads back as null — restore it.
+            for (const signal of [strategyData.closedSignal, strategyData.cancelledSignal, strategyData.activatedSignal]) {
+                if (signal && signal.minuteEstimatedTime == null) {
+                    signal.minuteEstimatedTime = Infinity;
+                }
+            }
+            return strategyData;
+        }
+        return null;
+    }
+    /**
+     * Writes the strategy state snapshot (or null to clear) using the fixed STORAGE_KEY.
+     *
+     * @param row - Strategy state snapshot to persist, or null to clear
+     * @returns Promise that resolves when write is complete
+     */
+    async writeStrategyData(row) {
+        await this._storage.writeValue(PersistStrategyInstance.STORAGE_KEY, row);
+    }
+}
+/** Fixed entity key for storing the strategy state snapshot */
+PersistStrategyInstance.STORAGE_KEY = "strategy";
+/**
+ * No-op IPersistStrategyInstance implementation used by PersistStrategyUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistStrategyDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistStrategyInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted strategy state).
+     * @returns Promise resolving to null
+     */
+    async readStrategyData() { return null; }
+    /**
+     * No-op write (discards strategy state).
+     * @returns Promise that resolves immediately
+     */
+    async writeStrategyData(_row) { }
+}
+/**
+ * Utility class for managing deferred strategy state persistence.
+ *
+ * Features:
+ * - Memoized storage instances per strategy
+ * - Custom adapter support
+ * - Atomic read/write operations for the deferred state snapshot
+ * - Crash-safe in-flight broker operation state management
+ *
+ * Used by ClientStrategy for live mode persistence of the commit queue and deferred
+ * user actions (_commitQueue, _closedSignal, _cancelledSignal, _activatedSignal).
+ */
+class PersistStrategyUtils {
+    constructor() {
+        /**
+         * Constructor used to create per-context strategy state instances.
+         * Replaceable via usePersistStrategyAdapter() / useJson() / useDummy().
+         */
+        this.PersistStrategyInstanceCtor = PersistStrategyInstance;
+        /**
+         * Memoized factory creating one IPersistStrategyInstance per (symbol, strategy, exchange) triple.
+         */
+        this.getStrategyStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistStrategyInstanceCtor, [symbol, strategyName, exchangeName]));
+        /**
+         * Reads persisted deferred strategy state for the given context.
+         * Lazily initializes the instance on first access.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to strategy state snapshot or null if none persisted
+         */
+        this.readStrategyData = async (symbol, strategyName, exchangeName) => {
+            LOGGER_SERVICE$9.info(PERSIST_STRATEGY_UTILS_METHOD_NAME_READ_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getStrategyStorage.has(key);
+            const instance = this.getStrategyStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readStrategyData();
+        };
+        /**
+         * Writes deferred strategy state (or null to clear) for the given context.
+         * Lazily initializes the instance on first access.
+         *
+         * @param strategyRow - Strategy state snapshot to persist, or null to clear
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
+         */
+        this.writeStrategyData = async (strategyRow, symbol, strategyName, exchangeName) => {
+            LOGGER_SERVICE$9.info(PERSIST_STRATEGY_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getStrategyStorage.has(key);
+            const instance = this.getStrategyStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeStrategyData(strategyRow);
+        };
+    }
+    /**
+     * Registers a custom IPersistStrategyInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
+     *
+     * @param Ctor - Custom IPersistStrategyInstance constructor
+     */
+    usePersistStrategyAdapter(Ctor) {
+        LOGGER_SERVICE$9.info(PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_PERSIST_STRATEGY_ADAPTER);
+        this.PersistStrategyInstanceCtor = Ctor;
+        this.getStrategyStorage.clear();
+    }
+    /**
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
+     */
+    clear() {
+        LOGGER_SERVICE$9.log(PERSIST_STRATEGY_UTILS_METHOD_NAME_CLEAR);
+        this.getStrategyStorage.clear();
+    }
+    /**
+     * Switches to the default file-based PersistStrategyInstance.
+     */
+    useJson() {
+        LOGGER_SERVICE$9.log(PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistStrategyAdapter(PersistStrategyInstance);
+    }
+    /**
+     * Switches to PersistStrategyDummyInstance (all operations are no-ops).
+     */
+    useDummy() {
+        LOGGER_SERVICE$9.log(PERSIST_STRATEGY_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistStrategyAdapter(PersistStrategyDummyInstance);
+    }
+}
+/**
+ * Global singleton instance of PersistStrategyUtils.
+ * Used by ClientStrategy for deferred strategy state persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistStrategyAdapter.usePersistStrategyAdapter(RedisPersist);
+ *
+ * // Read strategy state
+ * const state = await PersistStrategyAdapter.readStrategyData("BTCUSDT", "my-strategy", "binance");
+ *
+ * // Write strategy state
+ * await PersistStrategyAdapter.writeStrategyData(state, "BTCUSDT", "my-strategy", "binance");
+ * ```
+ */
+const PersistStrategyAdapter = new PersistStrategyUtils();
 /**
  * Default file-based implementation of IPersistPartialInstance.
  *
@@ -6771,6 +6983,9 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
     {
         self._commitQueue = [];
     }
+    // Persist the now-empty queue so a crash after draining does not replay commits
+    // that were already forwarded to the broker on the next restart.
+    await PERSIST_STRATEGY_FN(self);
     if (!self._pendingSignal) {
         return;
     }
@@ -7227,6 +7442,19 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
             self._lastPendingId = recentSignal.id;
         }
     }
+    // Restore 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;
+        }
+    }
     // Restore pending signal
     const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
     if (pendingSignal) {
@@ -7276,6 +7504,28 @@ const WAIT_FOR_DISPOSE_FN$1 = async (self) => {
     self.params.logger.debug("ClientStrategy dispose");
     await self.params.onDispose(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName, self.params.method.context.frameName, self.params.execution.context.backtest);
 };
+/**
+ * Persists the deferred strategy state snapshot (commit queue + deferred user actions)
+ * to disk in live mode.
+ *
+ * These fields carry confirmed-but-not-yet-forwarded broker operations and survive the
+ * gap between ticks (drained at the start of the next tick). Without persistence a live
+ * crash in that window silently loses the pending broker operation while _pendingSignal
+ * (already mutated and saved) claims it happened. Skipped in backtest mode.
+ *
+ * @param self - ClientStrategy instance
+ */
+const PERSIST_STRATEGY_FN = async (self) => {
+    if (self.params.backtest) {
+        return;
+    }
+    await PersistStrategyAdapter.writeStrategyData({
+        commitQueue: self._commitQueue,
+        closedSignal: self._closedSignal,
+        cancelledSignal: self._cancelledSignal,
+        activatedSignal: self._activatedSignal,
+    }, self.params.symbol, self.params.strategyName, self.params.exchangeName);
+};
 const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice, timestamp) => {
     // Initialize partial array if not present
     if (!signal._partial)
@@ -8900,14 +9150,15 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
 const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, averagePrice, closeTimestamp) => {
     const syncCloseAllowed = await CALL_SIGNAL_SYNC_CLOSE_FN(closeTimestamp, averagePrice, "closed", closedSignal, self);
     if (!syncCloseAllowed) {
-        self.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry", {
+        // Sync close rejected (e.g. broker rejected the order) — keep _closedSignal intact
+        // and return null so the candle loop re-attempts on the next candle. Mirrors live
+        // tick, which keeps _closedSignal and returns idle on a rejected user close,
+        // re-trying on the following tick.
+        self.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry on next candle", {
             symbol: self.params.execution.context.symbol,
             signalId: closedSignal.id,
         });
-        self._closedSignal = null;
-        self._pendingSignal = closedSignal;
-        throw new Error(`ClientStrategy backtest: signal close rejected by sync (signalId=${closedSignal.id}). ` +
-            `Retry backtest() with new candle data.`);
+        return null;
     }
     self._closedSignal = null;
     const publicSignal = TO_PUBLIC_SIGNAL("pending", closedSignal, averagePrice);
@@ -9159,7 +9410,15 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEnd
         }
         // КРИТИЧНО: Проверяем был ли сигнал закрыт пользователем через closePending()
         if (self._closedSignal) {
-            return await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
+            const userCloseResult = await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
+            // Sync close accepted — position closed, return. If rejected, _closedSignal is
+            // kept and we skip this candle: live tick returns idle on a rejected user close
+            // (it does NOT fall into the TP/SL or active-monitoring path), so the candle is
+            // skipped here and the close is re-attempted on the next candle.
+            if (userCloseResult) {
+                return userCloseResult;
+            }
+            continue;
         }
         let shouldClose = false;
         let closeReason;
@@ -9210,7 +9469,19 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEnd
             else {
                 closePrice = averagePrice; // time_expired uses VWAP
             }
-            return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
+            const closeResult = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
+            // Sync close accepted — position closed, return.
+            if (closeResult) {
+                return closeResult;
+            }
+            // Sync close rejected (e.g. broker rejected the order) — _pendingSignal is left
+            // intact (not cleared on rejection). Do NOT return/continue: fall through to the
+            // active-monitoring block below so this candle is processed exactly like live
+            // tick, which runs RETURN_PENDING_SIGNAL_ACTIVE_FN when CLOSE_PENDING_SIGNAL_FN
+            // returns null (updates _peak/_fall, fires active ping / breakeven / partial
+            // callbacks, drains the commit queue). The close is re-attempted on the next
+            // candle; for time_expired this eventually reaches the loop-exhausted close
+            // (which throws if still rejected).
         }
         // Call onPartialProfit/onPartialLoss callbacks during backtest candle processing
         // Calculate percentage of path to TP/SL
@@ -9632,7 +9903,7 @@ class ClientStrategy {
     async getStopped(symbol) {
         this.params.logger.debug("ClientStrategy getStopped", {
             symbol,
-            strategyName: this.params.method.context.strategyName,
+            strategyName: this.params.strategyName,
         });
         return this._isStopped;
     }
@@ -10315,6 +10586,8 @@ class ClientStrategy {
         if (this._cancelledSignal) {
             const cancelledSignal = this._cancelledSignal;
             this._cancelledSignal = null; // Clear after emitting
+            // Persist the cleared deferred state so the drained flag is not replayed on restart
+            await PERSIST_STRATEGY_FN(this);
             this.params.logger.info("ClientStrategy tick: scheduled signal was cancelled", {
                 symbol: this.params.execution.context.symbol,
                 signalId: cancelledSignal.id,
@@ -10373,6 +10646,8 @@ class ClientStrategy {
                 return await RETURN_IDLE_FN(this, currentPrice);
             }
             this._closedSignal = null; // Clear only after sync confirmed
+            // Persist the cleared deferred state so the drained flag is not replayed on restart
+            await PERSIST_STRATEGY_FN(this);
             this.params.logger.info("ClientStrategy tick: pending signal was closed", {
                 symbol: this.params.execution.context.symbol,
                 signalId: closedSignal.id,
@@ -10428,6 +10703,8 @@ class ClientStrategy {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
             const activatedSignal = this._activatedSignal;
             this._activatedSignal = null; // Clear after emitting
+            // Persist the cleared deferred state so the drained flag is not replayed on restart
+            await PERSIST_STRATEGY_FN(this);
             this.params.logger.info("ClientStrategy tick: scheduled signal was activated", {
                 symbol: this.params.execution.context.symbol,
                 signalId: activatedSignal.id,
@@ -10685,18 +10962,20 @@ class ClientStrategy {
             const currentPrice = await this.params.exchange.getAveragePrice(symbol);
             const closedSignal = this._closedSignal;
             const closeTimestamp = this.params.execution.context.when.getTime();
-            // Sync close: if external system rejects — restore _pendingSignal, retry on next backtest() call
+            // Sync close: if external system rejects — keep the close pending and re-attempt
+            // it inside the candle loop below (PROCESS_PENDING_SIGNAL_CANDLES_FN handles
+            // _closedSignal per candle). Mirrors live tick, which keeps _closedSignal and
+            // retries on the next tick instead of failing.
             const syncCloseAllowed = await CALL_SIGNAL_SYNC_CLOSE_FN(closeTimestamp, currentPrice, "closed", closedSignal, this);
             if (!syncCloseAllowed) {
-                this.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry", {
+                this.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry in candle loop", {
                     symbol: this.params.execution.context.symbol,
                     signalId: closedSignal.id,
                 });
-                // Restore _pendingSignal so next backtest() call can process it normally
-                this._closedSignal = null;
+                // Restore _pendingSignal so the candle loop processes the position normally;
+                // _closedSignal is kept so the loop re-attempts the close on each candle.
                 this._pendingSignal = closedSignal;
-                throw new Error(`ClientStrategy backtest: signal close rejected by sync (signalId=${closedSignal.id}). ` +
-                    `Retry backtest() with new candle data.`);
+                return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, this._pendingSignal, candles, frameEndTime);
             }
             this._closedSignal = null; // Clear only after sync confirmed
             // Emit commit with correct timestamp from backtest context
@@ -10878,7 +11157,7 @@ class ClientStrategy {
         if (backtest) {
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.strategyName, this.params.exchangeName);
     }
     /**
      * Cancels the scheduled signal without stopping the strategy.
@@ -10922,7 +11201,9 @@ class ClientStrategy {
             // Commit will be emitted in backtest() with correct candle timestamp
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.strategyName, this.params.exchangeName);
+        // Persist deferred _cancelledSignal so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         // Commit will be emitted in tick() with correct currentTime
     }
     /**
@@ -10973,7 +11254,9 @@ class ClientStrategy {
             // Commit will be emitted AFTER successful risk check in PROCESS_SCHEDULED_SIGNAL_CANDLES_FN
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.strategyName, this.params.exchangeName);
+        // Persist deferred _activatedSignal so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         // Commit will be emitted AFTER successful risk check in tick()
     }
     /**
@@ -11018,6 +11301,8 @@ class ClientStrategy {
             return;
         }
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
+        // Persist deferred _closedSignal so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         // Commit will be emitted in tick() with correct currentTime
     }
     /**
@@ -11188,10 +11473,10 @@ class ClientStrategy {
         });
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
+            this.params.callbacks.onWrite(this.params.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -11201,6 +11486,8 @@ class ClientStrategy {
             percentToClose,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -11371,10 +11658,10 @@ class ClientStrategy {
         });
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
+            this.params.callbacks.onWrite(this.params.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -11384,6 +11671,8 @@ class ClientStrategy {
             percentToClose,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -11570,10 +11859,10 @@ class ClientStrategy {
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
             const publicSignal = TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice);
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
+            this.params.callbacks.onWrite(this.params.symbol, publicSignal, backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -11582,6 +11871,8 @@ class ClientStrategy {
             backtest,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -11819,10 +12110,10 @@ class ClientStrategy {
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
             const publicSignal = TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice);
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
+            this.params.callbacks.onWrite(this.params.symbol, publicSignal, backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -11832,6 +12123,8 @@ class ClientStrategy {
             percentShift,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -12055,10 +12348,10 @@ class ClientStrategy {
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
             const publicSignal = TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice);
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
+            this.params.callbacks.onWrite(this.params.symbol, publicSignal, backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -12068,6 +12361,8 @@ class ClientStrategy {
             percentShift,
             currentPrice,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
     /**
@@ -12146,10 +12441,10 @@ class ClientStrategy {
         });
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
+            this.params.callbacks.onWrite(this.params.symbol, TO_PUBLIC_SIGNAL("pending", this._pendingSignal, currentPrice), backtest);
         }
         if (!backtest) {
-            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.symbol, this.params.strategyName, this.params.exchangeName);
         }
         // Queue commit event for processing in tick()/backtest() with proper timestamp
         this._commitQueue.push({
@@ -12160,6 +12455,8 @@ class ClientStrategy {
             cost,
             totalEntries: this._pendingSignal._entry?.length ?? 1,
         });
+        // Persist the queued commit so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
         return true;
     }
 }
@@ -22900,32 +23197,32 @@ const heat_columns = [
     {
         key: "totalPnl",
         label: "Total PNL",
-        format: (data) => data.totalPnl !== null ? str(data.totalPnl, "%") : "N/A",
+        format: (data) => data.totalPnl !== null ? `${data.totalPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "sharpeRatio",
         label: "Sharpe",
-        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio) : "N/A",
+        format: (data) => data.sharpeRatio !== null ? data.sharpeRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "annualizedSharpeRatio",
         label: "Ann Sharpe",
-        format: (data) => data.annualizedSharpeRatio !== null ? str(data.annualizedSharpeRatio) : "N/A",
+        format: (data) => data.annualizedSharpeRatio !== null ? data.annualizedSharpeRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "certaintyRatio",
         label: "Certainty",
-        format: (data) => data.certaintyRatio !== null ? str(data.certaintyRatio) : "N/A",
+        format: (data) => data.certaintyRatio !== null ? data.certaintyRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "expectedYearlyReturns",
         label: "Exp Yearly",
         format: (data) => data.expectedYearlyReturns !== null
-            ? str(data.expectedYearlyReturns, "%")
+            ? `${data.expectedYearlyReturns.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -22938,37 +23235,37 @@ const heat_columns = [
     {
         key: "profitFactor",
         label: "PF",
-        format: (data) => data.profitFactor !== null ? str(data.profitFactor) : "N/A",
+        format: (data) => data.profitFactor !== null ? data.profitFactor.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "expectancy",
         label: "Expect",
-        format: (data) => data.expectancy !== null ? str(data.expectancy, "%") : "N/A",
+        format: (data) => data.expectancy !== null ? `${data.expectancy.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "winRate",
         label: "WR",
-        format: (data) => data.winRate !== null ? str(data.winRate, "%") : "N/A",
+        format: (data) => data.winRate !== null ? `${data.winRate.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgWin",
         label: "Avg Win",
-        format: (data) => data.avgWin !== null ? str(data.avgWin, "%") : "N/A",
+        format: (data) => data.avgWin !== null ? `${data.avgWin.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgLoss",
         label: "Avg Loss",
-        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%") : "N/A",
+        format: (data) => data.avgLoss !== null ? `${data.avgLoss.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "maxDrawdown",
         label: "Max DD",
-        format: (data) => data.maxDrawdown !== null ? str(-data.maxDrawdown, "%") : "N/A",
+        format: (data) => data.maxDrawdown !== null ? `${(-data.maxDrawdown).toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -22992,31 +23289,31 @@ const heat_columns = [
     {
         key: "avgPeakPnl",
         label: "Avg Peak PNL",
-        format: (data) => data.avgPeakPnl !== null ? str(data.avgPeakPnl, "%") : "N/A",
+        format: (data) => data.avgPeakPnl !== null ? `${data.avgPeakPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgFallPnl",
         label: "Avg DD PNL",
-        format: (data) => data.avgFallPnl !== null ? str(data.avgFallPnl, "%") : "N/A",
+        format: (data) => data.avgFallPnl !== null ? `${data.avgFallPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "peakProfitPnl",
         label: "Peak Profit PNL",
-        format: (data) => data.peakProfitPnl !== null ? str(data.peakProfitPnl, "%") : "N/A",
+        format: (data) => data.peakProfitPnl !== null ? `${data.peakProfitPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "maxDrawdownPnl",
         label: "Max DD PNL",
-        format: (data) => data.maxDrawdownPnl !== null ? str(data.maxDrawdownPnl, "%") : "N/A",
+        format: (data) => data.maxDrawdownPnl !== null ? `${data.maxDrawdownPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "medianPnl",
         label: "Median PNL",
-        format: (data) => data.medianPnl !== null ? str(data.medianPnl, "%") : "N/A",
+        format: (data) => data.medianPnl !== null ? `${data.medianPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23041,7 +23338,7 @@ const heat_columns = [
         key: "avgConsecutiveWinPnl",
         label: "Avg Win Streak PNL",
         format: (data) => data.avgConsecutiveWinPnl !== null
-            ? str(data.avgConsecutiveWinPnl, "%")
+            ? `${data.avgConsecutiveWinPnl.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -23049,7 +23346,7 @@ const heat_columns = [
         key: "avgConsecutiveLossPnl",
         label: "Avg Loss Streak PNL",
         format: (data) => data.avgConsecutiveLossPnl !== null
-            ? str(data.avgConsecutiveLossPnl, "%")
+            ? `${data.avgConsecutiveLossPnl.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -23062,7 +23359,7 @@ const heat_columns = [
     {
         key: "trendStrength",
         label: "Trend %/d",
-        format: (data) => data.trendStrength !== null ? str(data.trendStrength, "%") : "N/A",
+        format: (data) => data.trendStrength !== null ? `${data.trendStrength.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23115,25 +23412,25 @@ const heat_columns = [
     {
         key: "medianStepSize",
         label: "Median Step",
-        format: (data) => data.medianStepSize !== null ? str(data.medianStepSize, "%") : "N/A",
+        format: (data) => data.medianStepSize !== null ? `${data.medianStepSize.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
         key: "sortinoRatio",
         label: "Sortino",
-        format: (data) => data.sortinoRatio !== null ? str(data.sortinoRatio) : "N/A",
+        format: (data) => data.sortinoRatio !== null ? data.sortinoRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "calmarRatio",
         label: "Calmar",
-        format: (data) => data.calmarRatio !== null ? str(data.calmarRatio) : "N/A",
+        format: (data) => data.calmarRatio !== null ? data.calmarRatio.toFixed(3) : "N/A",
         isVisible: () => true,
     },
     {
         key: "recoveryFactor",
         label: "Recovery",
-        format: (data) => data.recoveryFactor !== null ? str(data.recoveryFactor) : "N/A",
+        format: (data) => data.recoveryFactor !== null ? data.recoveryFactor.toFixed(3) : "N/A",
         isVisible: () => true,
     },
 ];
@@ -30309,28 +30606,28 @@ class HeatmapStorage {
             `# Portfolio Heatmap: ${strategyName}`,
             "",
             `**Total Symbols:** ${data.totalSymbols}`,
-            `**Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"}`,
-            `**Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"}`,
-            `**Annualized Sharpe:** ${data.portfolioAnnualizedSharpeRatio !== null ? str(data.portfolioAnnualizedSharpeRatio) : "N/A"}`,
-            `**Certainty Ratio:** ${data.portfolioCertaintyRatio !== null ? str(data.portfolioCertaintyRatio) : "N/A"}`,
-            `**Expected Yearly Returns:** ${data.portfolioExpectedYearlyReturns !== null ? str(data.portfolioExpectedYearlyReturns, "%") : "N/A"}`,
+            `**Portfolio PNL:** ${data.portfolioTotalPnl !== null ? `${data.portfolioTotalPnl.toFixed(2)} %` : "N/A"}`,
+            `**Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? data.portfolioSharpeRatio.toFixed(3) : "N/A"}`,
+            `**Annualized Sharpe:** ${data.portfolioAnnualizedSharpeRatio !== null ? data.portfolioAnnualizedSharpeRatio.toFixed(3) : "N/A"}`,
+            `**Certainty Ratio:** ${data.portfolioCertaintyRatio !== null ? data.portfolioCertaintyRatio.toFixed(3) : "N/A"}`,
+            `**Expected Yearly Returns:** ${data.portfolioExpectedYearlyReturns !== null ? `${data.portfolioExpectedYearlyReturns.toFixed(2)} %` : "N/A"}`,
             `**Trades Per Year:** ${data.portfolioTradesPerYear !== null ? data.portfolioTradesPerYear.toFixed(1) : "N/A"}`,
             `**Total Trades:** ${data.portfolioTotalTrades}`,
-            `**Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? str(data.portfolioAvgPeakPnl, "%") : "N/A"}`,
-            `**Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
-            `**Peak Profit PNL:** ${data.portfolioPeakProfitPnl !== null ? str(data.portfolioPeakProfitPnl, "%") : "N/A"}`,
-            `**Max Drawdown PNL:** ${data.portfolioMaxDrawdownPnl !== null ? str(data.portfolioMaxDrawdownPnl, "%") : "N/A"}`,
-            `**Median PNL:** ${data.portfolioMedianPnl !== null ? str(data.portfolioMedianPnl, "%") : "N/A"}`,
+            `**Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? `${data.portfolioAvgPeakPnl.toFixed(2)} %` : "N/A"}`,
+            `**Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? `${data.portfolioAvgFallPnl.toFixed(2)} %` : "N/A"}`,
+            `**Peak Profit PNL:** ${data.portfolioPeakProfitPnl !== null ? `${data.portfolioPeakProfitPnl.toFixed(2)} %` : "N/A"}`,
+            `**Max Drawdown PNL:** ${data.portfolioMaxDrawdownPnl !== null ? `${data.portfolioMaxDrawdownPnl.toFixed(2)} %` : "N/A"}`,
+            `**Median PNL:** ${data.portfolioMedianPnl !== null ? `${data.portfolioMedianPnl.toFixed(2)} %` : "N/A"}`,
             `**Avg Duration:** ${data.portfolioAvgDuration !== null ? `${data.portfolioAvgDuration.toFixed(1)} min` : "N/A"}`,
             `**Avg Win Duration:** ${data.portfolioAvgWinDuration !== null ? `${data.portfolioAvgWinDuration.toFixed(1)} min` : "N/A"}`,
             `**Avg Loss Duration:** ${data.portfolioAvgLossDuration !== null ? `${data.portfolioAvgLossDuration.toFixed(1)} min` : "N/A"}`,
-            `**Avg Consecutive Win PNL:** ${data.portfolioAvgConsecutiveWinPnl !== null ? str(data.portfolioAvgConsecutiveWinPnl, "%") : "N/A"}`,
-            `**Avg Consecutive Loss PNL:** ${data.portfolioAvgConsecutiveLossPnl !== null ? str(data.portfolioAvgConsecutiveLossPnl, "%") : "N/A"}`,
-            `**Standard Deviation Per Trade:** ${data.portfolioStdDev !== null ? str(data.portfolioStdDev, "%") : "N/A"}`,
-            `**Sortino Ratio:** ${data.portfolioSortinoRatio !== null ? str(data.portfolioSortinoRatio) : "N/A"}`,
-            `**Calmar Ratio:** ${data.portfolioCalmarRatio !== null ? str(data.portfolioCalmarRatio) : "N/A"}`,
-            `**Recovery Factor:** ${data.portfolioRecoveryFactor !== null ? str(data.portfolioRecoveryFactor) : "N/A"}`,
-            `**Expectancy:** ${data.portfolioExpectancy !== null ? str(data.portfolioExpectancy, "%") : "N/A"}`,
+            `**Avg Consecutive Win PNL:** ${data.portfolioAvgConsecutiveWinPnl !== null ? `${data.portfolioAvgConsecutiveWinPnl.toFixed(2)} %` : "N/A"}`,
+            `**Avg Consecutive Loss PNL:** ${data.portfolioAvgConsecutiveLossPnl !== null ? `${data.portfolioAvgConsecutiveLossPnl.toFixed(2)} %` : "N/A"}`,
+            `**Standard Deviation Per Trade:** ${data.portfolioStdDev !== null ? `${data.portfolioStdDev.toFixed(2)} %` : "N/A"}`,
+            `**Sortino Ratio:** ${data.portfolioSortinoRatio !== null ? data.portfolioSortinoRatio.toFixed(3) : "N/A"}`,
+            `**Calmar Ratio:** ${data.portfolioCalmarRatio !== null ? data.portfolioCalmarRatio.toFixed(3) : "N/A"}`,
+            `**Recovery Factor:** ${data.portfolioRecoveryFactor !== null ? data.portfolioRecoveryFactor.toFixed(3) : "N/A"}`,
+            `**Expectancy:** ${data.portfolioExpectancy !== null ? `${data.portfolioExpectancy.toFixed(2)} %` : "N/A"}`,
             "",
             table,
             "",
@@ -67632,4 +67929,4 @@ const validateSignal = (signal, currentPrice) => {
     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, 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, 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 };