backtest-kit 12.8.0 → 13.0.0

package/build/index.cjs

@@ -1001,6 +1001,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";
@@ -1864,6 +1870,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 = functoolsKit.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.
  *
@@ -6791,6 +7003,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;
     }
@@ -7247,6 +7462,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) {
@@ -7296,6 +7524,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)
@@ -8920,14 +9170,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);
@@ -9179,7 +9430,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;
@@ -9230,7 +9489,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
@@ -9652,7 +9923,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;
     }
@@ -10335,6 +10606,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,
@@ -10393,6 +10666,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,
@@ -10448,6 +10723,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,
@@ -10705,18 +10982,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
@@ -10898,7 +11177,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.
@@ -10942,7 +11221,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
     }
     /**
@@ -10993,7 +11274,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()
     }
     /**
@@ -11038,6 +11321,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
     }
     /**
@@ -11208,10 +11493,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({
@@ -11221,6 +11506,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;
     }
     /**
@@ -11391,10 +11678,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({
@@ -11404,6 +11691,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;
     }
     /**
@@ -11590,10 +11879,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({
@@ -11602,6 +11891,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;
     }
     /**
@@ -11839,10 +12130,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({
@@ -11852,6 +12143,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;
     }
     /**
@@ -12075,10 +12368,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({
@@ -12088,6 +12381,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;
     }
     /**
@@ -12166,10 +12461,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({
@@ -12180,6 +12475,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;
     }
 }
@@ -22920,32 +23217,32 @@ const heat_columns = [
     {
         key: "totalPnl",
         label: "Total PNL",
-        format: (data) => data.totalPnl !== null ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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
-            ? functoolsKit.str(data.expectedYearlyReturns, "%")
+            ? `${data.expectedYearlyReturns.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -22958,37 +23255,37 @@ const heat_columns = [
     {
         key: "profitFactor",
         label: "PF",
-        format: (data) => data.profitFactor !== null ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.str(-data.maxDrawdown, "%") : "N/A",
+        format: (data) => data.maxDrawdown !== null ? `${(-data.maxDrawdown).toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23012,31 +23309,31 @@ const heat_columns = [
     {
         key: "avgPeakPnl",
         label: "Avg Peak PNL",
-        format: (data) => data.avgPeakPnl !== null ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.str(data.medianPnl, "%") : "N/A",
+        format: (data) => data.medianPnl !== null ? `${data.medianPnl.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23061,7 +23358,7 @@ const heat_columns = [
         key: "avgConsecutiveWinPnl",
         label: "Avg Win Streak PNL",
         format: (data) => data.avgConsecutiveWinPnl !== null
-            ? functoolsKit.str(data.avgConsecutiveWinPnl, "%")
+            ? `${data.avgConsecutiveWinPnl.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -23069,7 +23366,7 @@ const heat_columns = [
         key: "avgConsecutiveLossPnl",
         label: "Avg Loss Streak PNL",
         format: (data) => data.avgConsecutiveLossPnl !== null
-            ? functoolsKit.str(data.avgConsecutiveLossPnl, "%")
+            ? `${data.avgConsecutiveLossPnl.toFixed(2)}%`
             : "N/A",
         isVisible: () => true,
     },
@@ -23082,7 +23379,7 @@ const heat_columns = [
     {
         key: "trendStrength",
         label: "Trend %/d",
-        format: (data) => data.trendStrength !== null ? functoolsKit.str(data.trendStrength, "%") : "N/A",
+        format: (data) => data.trendStrength !== null ? `${data.trendStrength.toFixed(2)}%` : "N/A",
         isVisible: () => true,
     },
     {
@@ -23135,25 +23432,25 @@ const heat_columns = [
     {
         key: "medianStepSize",
         label: "Median Step",
-        format: (data) => data.medianStepSize !== null ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.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 ? functoolsKit.str(data.recoveryFactor) : "N/A",
+        format: (data) => data.recoveryFactor !== null ? data.recoveryFactor.toFixed(3) : "N/A",
         isVisible: () => true,
     },
 ];
@@ -30329,28 +30626,28 @@ class HeatmapStorage {
             `# Portfolio Heatmap: ${strategyName}`,
             "",
             `**Total Symbols:** ${data.totalSymbols}`,
-            `**Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%") : "N/A"}`,
-            `**Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio) : "N/A"}`,
-            `**Annualized Sharpe:** ${data.portfolioAnnualizedSharpeRatio !== null ? functoolsKit.str(data.portfolioAnnualizedSharpeRatio) : "N/A"}`,
-            `**Certainty Ratio:** ${data.portfolioCertaintyRatio !== null ? functoolsKit.str(data.portfolioCertaintyRatio) : "N/A"}`,
-            `**Expected Yearly Returns:** ${data.portfolioExpectedYearlyReturns !== null ? functoolsKit.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 ? functoolsKit.str(data.portfolioAvgPeakPnl, "%") : "N/A"}`,
-            `**Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? functoolsKit.str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
-            `**Peak Profit PNL:** ${data.portfolioPeakProfitPnl !== null ? functoolsKit.str(data.portfolioPeakProfitPnl, "%") : "N/A"}`,
-            `**Max Drawdown PNL:** ${data.portfolioMaxDrawdownPnl !== null ? functoolsKit.str(data.portfolioMaxDrawdownPnl, "%") : "N/A"}`,
-            `**Median PNL:** ${data.portfolioMedianPnl !== null ? functoolsKit.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 ? functoolsKit.str(data.portfolioAvgConsecutiveWinPnl, "%") : "N/A"}`,
-            `**Avg Consecutive Loss PNL:** ${data.portfolioAvgConsecutiveLossPnl !== null ? functoolsKit.str(data.portfolioAvgConsecutiveLossPnl, "%") : "N/A"}`,
-            `**Standard Deviation Per Trade:** ${data.portfolioStdDev !== null ? functoolsKit.str(data.portfolioStdDev, "%") : "N/A"}`,
-            `**Sortino Ratio:** ${data.portfolioSortinoRatio !== null ? functoolsKit.str(data.portfolioSortinoRatio) : "N/A"}`,
-            `**Calmar Ratio:** ${data.portfolioCalmarRatio !== null ? functoolsKit.str(data.portfolioCalmarRatio) : "N/A"}`,
-            `**Recovery Factor:** ${data.portfolioRecoveryFactor !== null ? functoolsKit.str(data.portfolioRecoveryFactor) : "N/A"}`,
-            `**Expectancy:** ${data.portfolioExpectancy !== null ? functoolsKit.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,
             "",
@@ -67716,6 +68013,8 @@ exports.PersistStateAdapter = PersistStateAdapter;
 exports.PersistStateInstance = PersistStateInstance;
 exports.PersistStorageAdapter = PersistStorageAdapter;
 exports.PersistStorageInstance = PersistStorageInstance;
+exports.PersistStrategyAdapter = PersistStrategyAdapter;
+exports.PersistStrategyInstance = PersistStrategyInstance;
 exports.Position = Position;
 exports.PositionSize = PositionSize;
 exports.Recent = Recent;