backtest-kit 2.2.17 → 2.2.18

package/build/index.cjs

@@ -2867,73 +2867,78 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
         return;
     }
     const queue = self._commitQueue;
-    self._commitQueue = [];
+    {
+        self._commitQueue = [];
+    }
     for (const commit of queue) {
-        switch (commit.action) {
-            case "partial-profit":
-                await CALL_COMMIT_FN(self, {
-                    action: "partial-profit",
-                    symbol: commit.symbol,
-                    strategyName: self.params.strategyName,
-                    exchangeName: self.params.exchangeName,
-                    frameName: self.params.frameName,
-                    backtest: commit.backtest,
-                    percentToClose: commit.percentToClose,
-                    currentPrice: commit.currentPrice,
-                    timestamp,
-                });
-                break;
-            case "partial-loss":
-                await CALL_COMMIT_FN(self, {
-                    action: "partial-loss",
-                    symbol: commit.symbol,
-                    strategyName: self.params.strategyName,
-                    exchangeName: self.params.exchangeName,
-                    frameName: self.params.frameName,
-                    backtest: commit.backtest,
-                    percentToClose: commit.percentToClose,
-                    currentPrice: commit.currentPrice,
-                    timestamp,
-                });
-                break;
-            case "breakeven":
-                await CALL_COMMIT_FN(self, {
-                    action: "breakeven",
-                    symbol: commit.symbol,
-                    strategyName: self.params.strategyName,
-                    exchangeName: self.params.exchangeName,
-                    frameName: self.params.frameName,
-                    backtest: commit.backtest,
-                    currentPrice: commit.currentPrice,
-                    timestamp,
-                });
-                break;
-            case "trailing-stop":
-                await CALL_COMMIT_FN(self, {
-                    action: "trailing-stop",
-                    symbol: commit.symbol,
-                    strategyName: self.params.strategyName,
-                    exchangeName: self.params.exchangeName,
-                    frameName: self.params.frameName,
-                    backtest: commit.backtest,
-                    percentShift: commit.percentShift,
-                    currentPrice: commit.currentPrice,
-                    timestamp,
-                });
-                break;
-            case "trailing-take":
-                await CALL_COMMIT_FN(self, {
-                    action: "trailing-take",
-                    symbol: commit.symbol,
-                    strategyName: self.params.strategyName,
-                    exchangeName: self.params.exchangeName,
-                    frameName: self.params.frameName,
-                    backtest: commit.backtest,
-                    percentShift: commit.percentShift,
-                    currentPrice: commit.currentPrice,
-                    timestamp,
-                });
-                break;
+        if (commit.action === "partial-profit") {
+            await CALL_COMMIT_FN(self, {
+                action: "partial-profit",
+                symbol: commit.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                backtest: commit.backtest,
+                percentToClose: commit.percentToClose,
+                currentPrice: commit.currentPrice,
+                timestamp,
+            });
+            continue;
+        }
+        if (commit.action === "partial-loss") {
+            await CALL_COMMIT_FN(self, {
+                action: "partial-loss",
+                symbol: commit.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                backtest: commit.backtest,
+                percentToClose: commit.percentToClose,
+                currentPrice: commit.currentPrice,
+                timestamp,
+            });
+            continue;
+        }
+        if (commit.action === "breakeven") {
+            await CALL_COMMIT_FN(self, {
+                action: "breakeven",
+                symbol: commit.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                backtest: commit.backtest,
+                currentPrice: commit.currentPrice,
+                timestamp,
+            });
+            continue;
+        }
+        if (commit.action === "trailing-stop") {
+            await CALL_COMMIT_FN(self, {
+                action: "trailing-stop",
+                symbol: commit.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                backtest: commit.backtest,
+                percentShift: commit.percentShift,
+                currentPrice: commit.currentPrice,
+                timestamp,
+            });
+            continue;
+        }
+        if (commit.action === "trailing-take") {
+            await CALL_COMMIT_FN(self, {
+                action: "trailing-take",
+                symbol: commit.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                backtest: commit.backtest,
+                percentShift: commit.percentShift,
+                currentPrice: commit.currentPrice,
+                timestamp,
+            });
+            continue;
         }
     }
 };
@@ -23626,7 +23631,7 @@ class RiskReportService {
                 strategyName: data.strategyName,
                 exchangeName: data.exchangeName,
                 frameName: data.frameName,
-                signalId: "",
+                signalId: data.pendingSignal?.id || "",
                 walkerName: "",
             });
         };
@@ -31617,53 +31622,64 @@ class ConstantUtils {
 const Constant = new ConstantUtils();
 
 const MAX_SIGNALS = 25;
-const STORAGE_BACKTEST_METHOD_NAME_WAIT_FOR_INIT = "StorageBacktestUtils.waitForInit";
-const STORAGE_BACKTEST_METHOD_NAME_UPDATE_STORAGE = "StorageBacktestUtils._updateStorage";
-const STORAGE_BACKTEST_METHOD_NAME_HANDLE_OPENED = "StorageBacktestUtils.handleOpened";
-const STORAGE_BACKTEST_METHOD_NAME_HANDLE_CLOSED = "StorageBacktestUtils.handleClosed";
-const STORAGE_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED = "StorageBacktestUtils.handleScheduled";
-const STORAGE_BACKTEST_METHOD_NAME_HANDLE_CANCELLED = "StorageBacktestUtils.handleCancelled";
-const STORAGE_BACKTEST_METHOD_NAME_FIND_BY_ID = "StorageBacktestUtils.findById";
-const STORAGE_BACKTEST_METHOD_NAME_LIST = "StorageBacktestUtils.list";
-const STORAGE_LIVE_METHOD_NAME_WAIT_FOR_INIT = "StorageLiveUtils.waitForInit";
-const STORAGE_LIVE_METHOD_NAME_UPDATE_STORAGE = "StorageLiveUtils._updateStorage";
-const STORAGE_LIVE_METHOD_NAME_HANDLE_OPENED = "StorageLiveUtils.handleOpened";
-const STORAGE_LIVE_METHOD_NAME_HANDLE_CLOSED = "StorageLiveUtils.handleClosed";
-const STORAGE_LIVE_METHOD_NAME_HANDLE_SCHEDULED = "StorageLiveUtils.handleScheduled";
-const STORAGE_LIVE_METHOD_NAME_HANDLE_CANCELLED = "StorageLiveUtils.handleCancelled";
-const STORAGE_LIVE_METHOD_NAME_FIND_BY_ID = "StorageLiveUtils.findById";
-const STORAGE_LIVE_METHOD_NAME_LIST = "StorageLiveUtils.list";
+const STORAGE_BACKTEST_METHOD_NAME_WAIT_FOR_INIT = "StoragePersistBacktestUtils.waitForInit";
+const STORAGE_BACKTEST_METHOD_NAME_UPDATE_STORAGE = "StoragePersistBacktestUtils._updateStorage";
+const STORAGE_BACKTEST_METHOD_NAME_HANDLE_OPENED = "StoragePersistBacktestUtils.handleOpened";
+const STORAGE_BACKTEST_METHOD_NAME_HANDLE_CLOSED = "StoragePersistBacktestUtils.handleClosed";
+const STORAGE_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED = "StoragePersistBacktestUtils.handleScheduled";
+const STORAGE_BACKTEST_METHOD_NAME_HANDLE_CANCELLED = "StoragePersistBacktestUtils.handleCancelled";
+const STORAGE_BACKTEST_METHOD_NAME_FIND_BY_ID = "StoragePersistBacktestUtils.findById";
+const STORAGE_BACKTEST_METHOD_NAME_LIST = "StoragePersistBacktestUtils.list";
+const STORAGE_LIVE_METHOD_NAME_WAIT_FOR_INIT = "StoragePersistLiveUtils.waitForInit";
+const STORAGE_LIVE_METHOD_NAME_UPDATE_STORAGE = "StoragePersistLiveUtils._updateStorage";
+const STORAGE_LIVE_METHOD_NAME_HANDLE_OPENED = "StoragePersistLiveUtils.handleOpened";
+const STORAGE_LIVE_METHOD_NAME_HANDLE_CLOSED = "StoragePersistLiveUtils.handleClosed";
+const STORAGE_LIVE_METHOD_NAME_HANDLE_SCHEDULED = "StoragePersistLiveUtils.handleScheduled";
+const STORAGE_LIVE_METHOD_NAME_HANDLE_CANCELLED = "StoragePersistLiveUtils.handleCancelled";
+const STORAGE_LIVE_METHOD_NAME_FIND_BY_ID = "StoragePersistLiveUtils.findById";
+const STORAGE_LIVE_METHOD_NAME_LIST = "StoragePersistLiveUtils.list";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_OPENED = "StorageMemoryBacktestUtils.handleOpened";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CLOSED = "StorageMemoryBacktestUtils.handleClosed";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED = "StorageMemoryBacktestUtils.handleScheduled";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CANCELLED = "StorageMemoryBacktestUtils.handleCancelled";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_FIND_BY_ID = "StorageMemoryBacktestUtils.findById";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_LIST = "StorageMemoryBacktestUtils.list";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_OPENED = "StorageMemoryLiveUtils.handleOpened";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_CLOSED = "StorageMemoryLiveUtils.handleClosed";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_SCHEDULED = "StorageMemoryLiveUtils.handleScheduled";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_CANCELLED = "StorageMemoryLiveUtils.handleCancelled";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_FIND_BY_ID = "StorageMemoryLiveUtils.findById";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_LIST = "StorageMemoryLiveUtils.list";
 const STORAGE_ADAPTER_METHOD_NAME_ENABLE = "StorageAdapter.enable";
 const STORAGE_ADAPTER_METHOD_NAME_DISABLE = "StorageAdapter.disable";
 const STORAGE_ADAPTER_METHOD_NAME_FIND_SIGNAL_BY_ID = "StorageAdapter.findSignalById";
 const STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_BACKTEST = "StorageAdapter.listSignalBacktest";
 const STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_LIVE = "StorageAdapter.listSignalLive";
+const STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER = "StorageBacktestAdapter.useStorageAdapter";
+const STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY = "StorageBacktestAdapter.useDummy";
+const STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST = "StorageBacktestAdapter.usePersist";
+const STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY = "StorageBacktestAdapter.useMemory";
+const STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER = "StorageLiveAdapter.useStorageAdapter";
+const STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY = "StorageLiveAdapter.useDummy";
+const STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST = "StorageLiveAdapter.usePersist";
+const STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY = "StorageLiveAdapter.useMemory";
 /**
- * Utility class for managing backtest signal history.
- *
- * Stores trading signal history for admin dashboard display during backtesting
- * with automatic initialization, deduplication, and storage limits.
- *
- * @example
- * ```typescript
- * import { StorageBacktestUtils } from "./classes/Storage";
+ * Persistent storage adapter for backtest signals.
  *
- * const storage = new StorageBacktestUtils();
- *
- * // Handle signal events
- * await storage.handleOpened(tickResult);
- * await storage.handleClosed(tickResult);
+ * Features:
+ * - Persists signals to disk using PersistStorageAdapter
+ * - Lazy initialization with singleshot pattern
+ * - Maintains up to MAX_SIGNALS (25) most recent signals
+ * - Handles signal lifecycle events (opened, closed, scheduled, cancelled)
+ * - Prevents duplicate updates based on timestamp comparison
  *
- * // Query signals
- * const signal = await storage.findById("signal-123");
- * const allSignals = await storage.list();
- * ```
+ * Use this adapter (default) for backtest signal persistence across sessions.
  */
-class StorageBacktestUtils {
+class StoragePersistBacktestUtils {
     constructor() {
         /**
-         * Initializes storage by loading existing signal history from persist layer.
-         * Uses singleshot to ensure initialization happens only once.
+         * Singleshot initialization function that loads signals from disk.
+         * Protected by singleshot to ensure one-time execution.
          */
         this.waitForInit = functoolsKit.singleshot(async () => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_WAIT_FOR_INIT);
@@ -31675,9 +31691,8 @@ class StorageBacktestUtils {
         });
         /**
          * Handles signal opened event.
-         *
-         * @param tick - Tick result containing opened signal data
-         * @returns Promise resolving when storage is updated
+         * Updates storage with opened status if not stale.
+         * @param tick - The opened signal tick data
          */
         this.handleOpened = async (tick) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_OPENED, {
@@ -31699,9 +31714,8 @@ class StorageBacktestUtils {
         };
         /**
          * Handles signal closed event.
-         *
-         * @param tick - Tick result containing closed signal data
-         * @returns Promise resolving when storage is updated
+         * Updates storage with closed status and PnL if not stale.
+         * @param tick - The closed signal tick data
          */
         this.handleClosed = async (tick) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_CLOSED, {
@@ -31724,9 +31738,8 @@ class StorageBacktestUtils {
         };
         /**
          * Handles signal scheduled event.
-         *
-         * @param tick - Tick result containing scheduled signal data
-         * @returns Promise resolving when storage is updated
+         * Updates storage with scheduled status if not stale.
+         * @param tick - The scheduled signal tick data
          */
         this.handleScheduled = async (tick) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED, {
@@ -31748,9 +31761,8 @@ class StorageBacktestUtils {
         };
         /**
          * Handles signal cancelled event.
-         *
-         * @param tick - Tick result containing cancelled signal data
-         * @returns Promise resolving when storage is updated
+         * Updates storage with cancelled status if not stale.
+         * @param tick - The cancelled signal tick data
          */
         this.handleCancelled = async (tick) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_CANCELLED, {
@@ -31771,10 +31783,9 @@ class StorageBacktestUtils {
             await this._updateStorage();
         };
         /**
-         * Finds a signal by its unique identifier.
-         *
-         * @param id - Signal identifier
-         * @returns Promise resolving to signal row or null if not found
+         * Finds a signal by its ID.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
          */
         this.findById = async (id) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_FIND_BY_ID, { id });
@@ -31782,9 +31793,8 @@ class StorageBacktestUtils {
             return this._signals.get(id) ?? null;
         };
         /**
-         * Lists all stored backtest signals.
-         *
-         * @returns Promise resolving to array of signal rows
+         * Lists all stored signals.
+         * @returns Array of all signal rows
          */
         this.list = async () => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_LIST);
@@ -31793,15 +31803,14 @@ class StorageBacktestUtils {
         };
     }
     /**
-     * Persists current signal history to storage.
-     * Sorts by priority and limits to MAX_SIGNALS entries.
-     *
-     * @throws Error if storage not initialized
+     * Persists the current signal map to disk storage.
+     * Sorts signals by priority and keeps only the most recent MAX_SIGNALS.
+     * @throws Error if not initialized
      */
     async _updateStorage() {
         bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_UPDATE_STORAGE);
         if (!this._signals) {
-            throw new Error("StorageBacktestUtils not initialized. Call waitForInit first.");
+            throw new Error("StoragePersistBacktestUtils not initialized. Call waitForInit first.");
         }
         const signalList = Array.from(this._signals.values());
         signalList.sort((a, b) => a.priority - b.priority);
@@ -31809,31 +31818,190 @@ class StorageBacktestUtils {
     }
 }
 /**
- * Utility class for managing live trading signal history.
+ * In-memory storage adapter for backtest signals.
  *
- * Stores trading signal history for admin dashboard display during live trading
- * with automatic initialization, deduplication, and storage limits.
+ * Features:
+ * - Stores signals in memory only (no persistence)
+ * - Fast read/write operations
+ * - Data is lost when application restarts
+ * - Handles signal lifecycle events (opened, closed, scheduled, cancelled)
+ * - Prevents duplicate updates based on timestamp comparison
  *
- * @example
- * ```typescript
- * import { StorageLiveUtils } from "./classes/Storage";
+ * Use this adapter for testing or when persistence is not required.
+ */
+class StorageMemoryBacktestUtils {
+    constructor() {
+        /** Map of signal IDs to signal rows */
+        this._signals = new Map();
+        /**
+         * Handles signal opened event.
+         * Updates in-memory storage with opened status if not stale.
+         * @param tick - The opened signal tick data
+         */
+        this.handleOpened = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_OPENED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "opened",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal closed event.
+         * Updates in-memory storage with closed status and PnL if not stale.
+         * @param tick - The closed signal tick data
+         */
+        this.handleClosed = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CLOSED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "closed",
+                priority: Date.now(),
+                pnl: tick.pnl,
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal scheduled event.
+         * Updates in-memory storage with scheduled status if not stale.
+         * @param tick - The scheduled signal tick data
+         */
+        this.handleScheduled = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "scheduled",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal cancelled event.
+         * Updates in-memory storage with cancelled status if not stale.
+         * @param tick - The cancelled signal tick data
+         */
+        this.handleCancelled = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CANCELLED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "cancelled",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Finds a signal by its ID.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
+         */
+        this.findById = async (id) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_FIND_BY_ID, { id });
+            return this._signals.get(id) ?? null;
+        };
+        /**
+         * Lists all stored signals.
+         * @returns Array of all signal rows
+         */
+        this.list = async () => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_LIST);
+            return Array.from(this._signals.values());
+        };
+    }
+}
+/**
+ * Dummy storage adapter for backtest signals that discards all writes.
+ *
+ * Features:
+ * - No-op implementation for all methods
+ * - findById always returns null
+ * - list always returns empty array
  *
- * const storage = new StorageLiveUtils();
+ * Use this adapter to disable backtest signal storage completely.
+ */
+class StorageDummyBacktestUtils {
+    constructor() {
+        /**
+         * No-op handler for signal opened event.
+         */
+        this.handleOpened = async () => {
+        };
+        /**
+         * No-op handler for signal closed event.
+         */
+        this.handleClosed = async () => {
+        };
+        /**
+         * No-op handler for signal scheduled event.
+         */
+        this.handleScheduled = async () => {
+        };
+        /**
+         * No-op handler for signal cancelled event.
+         */
+        this.handleCancelled = async () => {
+        };
+        /**
+         * Always returns null (no storage).
+         * @returns null
+         */
+        this.findById = async () => {
+            return null;
+        };
+        /**
+         * Always returns empty array (no storage).
+         * @returns Empty array
+         */
+        this.list = async () => {
+            return [];
+        };
+    }
+}
+/**
+ * Persistent storage adapter for live trading signals.
  *
- * // Handle signal events
- * await storage.handleOpened(tickResult);
- * await storage.handleClosed(tickResult);
+ * Features:
+ * - Persists signals to disk using PersistStorageAdapter
+ * - Lazy initialization with singleshot pattern
+ * - Maintains up to MAX_SIGNALS (25) most recent signals
+ * - Handles signal lifecycle events (opened, closed, scheduled, cancelled)
+ * - Prevents duplicate updates based on timestamp comparison
  *
- * // Query signals
- * const signal = await storage.findById("signal-123");
- * const allSignals = await storage.list();
- * ```
+ * Use this adapter (default) for live signal persistence across sessions.
  */
-class StorageLiveUtils {
+class StoragePersistLiveUtils {
     constructor() {
         /**
-         * Initializes storage by loading existing signal history from persist layer.
-         * Uses singleshot to ensure initialization happens only once.
+         * Singleshot initialization function that loads signals from disk.
+         * Protected by singleshot to ensure one-time execution.
          */
         this.waitForInit = functoolsKit.singleshot(async () => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_WAIT_FOR_INIT);
@@ -31845,9 +32013,8 @@ class StorageLiveUtils {
         });
         /**
          * Handles signal opened event.
-         *
-         * @param tick - Tick result containing opened signal data
-         * @returns Promise resolving when history is updated
+         * Updates storage with opened status if not stale.
+         * @param tick - The opened signal tick data
          */
         this.handleOpened = async (tick) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_OPENED, {
@@ -31869,9 +32036,8 @@ class StorageLiveUtils {
         };
         /**
          * Handles signal closed event.
-         *
-         * @param tick - Tick result containing closed signal data
-         * @returns Promise resolving when history is updated
+         * Updates storage with closed status and PnL if not stale.
+         * @param tick - The closed signal tick data
          */
         this.handleClosed = async (tick) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_CLOSED, {
@@ -31894,9 +32060,8 @@ class StorageLiveUtils {
         };
         /**
          * Handles signal scheduled event.
-         *
-         * @param tick - Tick result containing scheduled signal data
-         * @returns Promise resolving when history is updated
+         * Updates storage with scheduled status if not stale.
+         * @param tick - The scheduled signal tick data
          */
         this.handleScheduled = async (tick) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_SCHEDULED, {
@@ -31918,9 +32083,8 @@ class StorageLiveUtils {
         };
         /**
          * Handles signal cancelled event.
-         *
-         * @param tick - Tick result containing cancelled signal data
-         * @returns Promise resolving when history is updated
+         * Updates storage with cancelled status if not stale.
+         * @param tick - The cancelled signal tick data
          */
         this.handleCancelled = async (tick) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_CANCELLED, {
@@ -31941,10 +32105,9 @@ class StorageLiveUtils {
             await this._updateStorage();
         };
         /**
-         * Finds a signal by its unique identifier.
-         *
-         * @param id - Signal identifier
-         * @returns Promise resolving to signal row or null if not found
+         * Finds a signal by its ID.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
          */
         this.findById = async (id) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_FIND_BY_ID, { id });
@@ -31952,9 +32115,8 @@ class StorageLiveUtils {
             return this._signals.get(id) ?? null;
         };
         /**
-         * Lists all stored live signals.
-         *
-         * @returns Promise resolving to array of signal rows
+         * Lists all stored signals.
+         * @returns Array of all signal rows
          */
         this.list = async () => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_LIST);
@@ -31963,15 +32125,14 @@ class StorageLiveUtils {
         };
     }
     /**
-     * Persists current signal history to storage.
-     * Sorts by priority and limits to MAX_SIGNALS entries.
-     *
-     * @throws Error if storage not initialized
+     * Persists the current signal map to disk storage.
+     * Sorts signals by priority and keeps only the most recent MAX_SIGNALS.
+     * @throws Error if not initialized
      */
     async _updateStorage() {
         bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_UPDATE_STORAGE);
         if (!this._signals) {
-            throw new Error("StorageLiveUtils not initialized. Call waitForInit first.");
+            throw new Error("StoragePersistLiveUtils not initialized. Call waitForInit first.");
         }
         const signalList = Array.from(this._signals.values());
         signalList.sort((a, b) => a.priority - b.priority);
@@ -31979,36 +32140,385 @@ class StorageLiveUtils {
     }
 }
 /**
- * Main storage adapter for signal history management.
+ * In-memory storage adapter for live trading signals.
  *
- * Provides unified interface for accessing backtest and live signal history
- * for admin dashboard. Subscribes to signal emitters and automatically
- * updates history on signal events.
+ * Features:
+ * - Stores signals in memory only (no persistence)
+ * - Fast read/write operations
+ * - Data is lost when application restarts
+ * - Handles signal lifecycle events (opened, closed, scheduled, cancelled)
+ * - Prevents duplicate updates based on timestamp comparison
  *
- * @example
- * ```typescript
- * import { Storage } from "./classes/Storage";
+ * Use this adapter for testing or when persistence is not required.
+ */
+class StorageMemoryLiveUtils {
+    constructor() {
+        /** Map of signal IDs to signal rows */
+        this._signals = new Map();
+        /**
+         * Handles signal opened event.
+         * Updates in-memory storage with opened status if not stale.
+         * @param tick - The opened signal tick data
+         */
+        this.handleOpened = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_OPENED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "opened",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal closed event.
+         * Updates in-memory storage with closed status and PnL if not stale.
+         * @param tick - The closed signal tick data
+         */
+        this.handleClosed = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_CLOSED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "closed",
+                priority: Date.now(),
+                pnl: tick.pnl,
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal scheduled event.
+         * Updates in-memory storage with scheduled status if not stale.
+         * @param tick - The scheduled signal tick data
+         */
+        this.handleScheduled = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_SCHEDULED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "scheduled",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal cancelled event.
+         * Updates in-memory storage with cancelled status if not stale.
+         * @param tick - The cancelled signal tick data
+         */
+        this.handleCancelled = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_CANCELLED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "cancelled",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Finds a signal by its ID.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
+         */
+        this.findById = async (id) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_FIND_BY_ID, { id });
+            return this._signals.get(id) ?? null;
+        };
+        /**
+         * Lists all stored signals.
+         * @returns Array of all signal rows
+         */
+        this.list = async () => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_LIST);
+            return Array.from(this._signals.values());
+        };
+    }
+}
+/**
+ * Dummy storage adapter for live trading signals that discards all writes.
  *
- * // Enable signal history tracking
- * const unsubscribe = Storage.enable();
+ * Features:
+ * - No-op implementation for all methods
+ * - findById always returns null
+ * - list always returns empty array
  *
- * // Query signals
- * const backtestSignals = await Storage.listSignalBacktest();
- * const liveSignals = await Storage.listSignalLive();
- * const signal = await Storage.findSignalById("signal-123");
+ * Use this adapter to disable live signal storage completely.
+ */
+class StorageDummyLiveUtils {
+    constructor() {
+        /**
+         * No-op handler for signal opened event.
+         */
+        this.handleOpened = async () => {
+        };
+        /**
+         * No-op handler for signal closed event.
+         */
+        this.handleClosed = async () => {
+        };
+        /**
+         * No-op handler for signal scheduled event.
+         */
+        this.handleScheduled = async () => {
+        };
+        /**
+         * No-op handler for signal cancelled event.
+         */
+        this.handleCancelled = async () => {
+        };
+        /**
+         * Always returns null (no storage).
+         * @returns null
+         */
+        this.findById = async () => {
+            return null;
+        };
+        /**
+         * Always returns empty array (no storage).
+         * @returns Empty array
+         */
+        this.list = async () => {
+            return [];
+        };
+    }
+}
+/**
+ * Backtest storage adapter with pluggable storage backend.
  *
- * // Disable tracking
- * Storage.disable();
- * ```
+ * Features:
+ * - Adapter pattern for swappable storage implementations
+ * - Default adapter: StoragePersistBacktestUtils (persistent storage)
+ * - Alternative adapters: StorageMemoryBacktestUtils, StorageDummyBacktestUtils
+ * - Convenience methods: usePersist(), useMemory(), useDummy()
+ */
+class StorageBacktestAdapter {
+    constructor() {
+        /** Internal storage utils instance */
+        this._signalBacktestUtils = new StorageMemoryBacktestUtils();
+        /**
+         * Handles signal opened event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The opened signal tick data
+         */
+        this.handleOpened = async (tick) => {
+            return await this._signalBacktestUtils.handleOpened(tick);
+        };
+        /**
+         * Handles signal closed event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The closed signal tick data
+         */
+        this.handleClosed = async (tick) => {
+            return await this._signalBacktestUtils.handleClosed(tick);
+        };
+        /**
+         * Handles signal scheduled event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The scheduled signal tick data
+         */
+        this.handleScheduled = async (tick) => {
+            return await this._signalBacktestUtils.handleScheduled(tick);
+        };
+        /**
+         * Handles signal cancelled event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The cancelled signal tick data
+         */
+        this.handleCancelled = async (tick) => {
+            return await this._signalBacktestUtils.handleCancelled(tick);
+        };
+        /**
+         * Finds a signal by its ID.
+         * Proxies call to the underlying storage adapter.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
+         */
+        this.findById = async (id) => {
+            return await this._signalBacktestUtils.findById(id);
+        };
+        /**
+         * Lists all stored signals.
+         * Proxies call to the underlying storage adapter.
+         * @returns Array of all signal rows
+         */
+        this.list = async () => {
+            return await this._signalBacktestUtils.list();
+        };
+        /**
+         * Sets the storage adapter constructor.
+         * All future storage operations will use this adapter.
+         *
+         * @param Ctor - Constructor for storage adapter
+         */
+        this.useStorageAdapter = (Ctor) => {
+            bt.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._signalBacktestUtils = Reflect.construct(Ctor, []);
+        };
+        /**
+         * Switches to dummy storage adapter.
+         * All future storage writes will be no-ops.
+         */
+        this.useDummy = () => {
+            bt.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY);
+            this._signalBacktestUtils = new StorageDummyBacktestUtils();
+        };
+        /**
+         * Switches to persistent storage adapter (default).
+         * Signals will be persisted to disk.
+         */
+        this.usePersist = () => {
+            bt.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._signalBacktestUtils = new StoragePersistBacktestUtils();
+        };
+        /**
+         * Switches to in-memory storage adapter.
+         * Signals will be stored in memory only.
+         */
+        this.useMemory = () => {
+            bt.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._signalBacktestUtils = new StorageMemoryBacktestUtils();
+        };
+    }
+}
+/**
+ * Live trading storage adapter with pluggable storage backend.
+ *
+ * Features:
+ * - Adapter pattern for swappable storage implementations
+ * - Default adapter: StoragePersistLiveUtils (persistent storage)
+ * - Alternative adapters: StorageMemoryLiveUtils, StorageDummyLiveUtils
+ * - Convenience methods: usePersist(), useMemory(), useDummy()
+ */
+class StorageLiveAdapter {
+    constructor() {
+        /** Internal storage utils instance */
+        this._signalLiveUtils = new StoragePersistLiveUtils();
+        /**
+         * Handles signal opened event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The opened signal tick data
+         */
+        this.handleOpened = async (tick) => {
+            return await this._signalLiveUtils.handleOpened(tick);
+        };
+        /**
+         * Handles signal closed event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The closed signal tick data
+         */
+        this.handleClosed = async (tick) => {
+            return await this._signalLiveUtils.handleClosed(tick);
+        };
+        /**
+         * Handles signal scheduled event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The scheduled signal tick data
+         */
+        this.handleScheduled = async (tick) => {
+            return await this._signalLiveUtils.handleScheduled(tick);
+        };
+        /**
+         * Handles signal cancelled event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The cancelled signal tick data
+         */
+        this.handleCancelled = async (tick) => {
+            return await this._signalLiveUtils.handleCancelled(tick);
+        };
+        /**
+         * Finds a signal by its ID.
+         * Proxies call to the underlying storage adapter.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
+         */
+        this.findById = async (id) => {
+            return await this._signalLiveUtils.findById(id);
+        };
+        /**
+         * Lists all stored signals.
+         * Proxies call to the underlying storage adapter.
+         * @returns Array of all signal rows
+         */
+        this.list = async () => {
+            return await this._signalLiveUtils.list();
+        };
+        /**
+         * Sets the storage adapter constructor.
+         * All future storage operations will use this adapter.
+         *
+         * @param Ctor - Constructor for storage adapter
+         */
+        this.useStorageAdapter = (Ctor) => {
+            bt.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._signalLiveUtils = Reflect.construct(Ctor, []);
+        };
+        /**
+         * Switches to dummy storage adapter.
+         * All future storage writes will be no-ops.
+         */
+        this.useDummy = () => {
+            bt.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY);
+            this._signalLiveUtils = new StorageDummyLiveUtils();
+        };
+        /**
+         * Switches to persistent storage adapter (default).
+         * Signals will be persisted to disk.
+         */
+        this.usePersist = () => {
+            bt.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._signalLiveUtils = new StoragePersistLiveUtils();
+        };
+        /**
+         * Switches to in-memory storage adapter.
+         * Signals will be stored in memory only.
+         */
+        this.useMemory = () => {
+            bt.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._signalLiveUtils = new StorageMemoryLiveUtils();
+        };
+    }
+}
+/**
+ * Main storage adapter that manages both backtest and live signal storage.
+ *
+ * Features:
+ * - Subscribes to signal emitters for automatic storage updates
+ * - Provides unified access to both backtest and live signals
+ * - Singleshot enable pattern prevents duplicate subscriptions
+ * - Cleanup function for proper unsubscription
  */
 class StorageAdapter {
     constructor() {
-        this._signalLiveUtils = new StorageLiveUtils();
-        this._signalBacktestUtils = new StorageBacktestUtils();
         /**
-         * Enables signal history tracking by subscribing to emitters.
+         * Enables signal storage by subscribing to signal emitters.
+         * Uses singleshot to ensure one-time subscription.
          *
-         * @returns Cleanup function to unsubscribe from all emitters
+         * @returns Cleanup function that unsubscribes from all emitters
          */
         this.enable = functoolsKit.singleshot(() => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_ENABLE);
@@ -32017,31 +32527,31 @@ class StorageAdapter {
             {
                 const unBacktestOpen = signalBacktestEmitter
                     .filter(({ action }) => action === "opened")
-                    .connect((tick) => this._signalBacktestUtils.handleOpened(tick));
+                    .connect((tick) => StorageBacktest.handleOpened(tick));
                 const unBacktestClose = signalBacktestEmitter
                     .filter(({ action }) => action === "closed")
-                    .connect((tick) => this._signalBacktestUtils.handleClosed(tick));
+                    .connect((tick) => StorageBacktest.handleClosed(tick));
                 const unBacktestScheduled = signalBacktestEmitter
                     .filter(({ action }) => action === "scheduled")
-                    .connect((tick) => this._signalBacktestUtils.handleScheduled(tick));
+                    .connect((tick) => StorageBacktest.handleScheduled(tick));
                 const unBacktestCancelled = signalBacktestEmitter
                     .filter(({ action }) => action === "cancelled")
-                    .connect((tick) => this._signalBacktestUtils.handleCancelled(tick));
+                    .connect((tick) => StorageBacktest.handleCancelled(tick));
                 unBacktest = functoolsKit.compose(() => unBacktestOpen(), () => unBacktestClose(), () => unBacktestScheduled(), () => unBacktestCancelled());
             }
             {
                 const unLiveOpen = signalLiveEmitter
                     .filter(({ action }) => action === "opened")
-                    .connect((tick) => this._signalLiveUtils.handleOpened(tick));
+                    .connect((tick) => StorageLive.handleOpened(tick));
                 const unLiveClose = signalLiveEmitter
                     .filter(({ action }) => action === "closed")
-                    .connect((tick) => this._signalLiveUtils.handleClosed(tick));
+                    .connect((tick) => StorageLive.handleClosed(tick));
                 const unLiveScheduled = signalLiveEmitter
                     .filter(({ action }) => action === "scheduled")
-                    .connect((tick) => this._signalLiveUtils.handleScheduled(tick));
+                    .connect((tick) => StorageLive.handleScheduled(tick));
                 const unLiveCancelled = signalLiveEmitter
                     .filter(({ action }) => action === "cancelled")
-                    .connect((tick) => this._signalLiveUtils.handleCancelled(tick));
+                    .connect((tick) => StorageLive.handleCancelled(tick));
                 unLive = functoolsKit.compose(() => unLiveOpen(), () => unLiveClose(), () => unLiveScheduled(), () => unLiveCancelled());
             }
             return () => {
@@ -32051,7 +32561,8 @@ class StorageAdapter {
             };
         });
         /**
-         * Disables signal history tracking by unsubscribing from emitters.
+         * Disables signal storage by unsubscribing from all emitters.
+         * Safe to call multiple times.
          */
         this.disable = () => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_DISABLE);
@@ -32061,11 +32572,12 @@ class StorageAdapter {
             }
         };
         /**
-         * Finds a signal by ID across both backtest and live history.
+         * Finds a signal by ID across both backtest and live storage.
          *
-         * @param id - Signal identifier
-         * @returns Promise resolving to signal row
-         * @throws Error if signal not found in either storage
+         * @param id - The signal ID to search for
+         * @returns The signal row or throws if not found
+         * @throws Error if StorageAdapter is not enabled
+         * @throws Error if signal is not found in either storage
          */
         this.findSignalById = async (id) => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_FIND_SIGNAL_BY_ID, { id });
@@ -32073,41 +32585,57 @@ class StorageAdapter {
                 throw new Error("StorageAdapter is not enabled. Call enable() first.");
             }
             let result = null;
-            if ((result = await this._signalBacktestUtils.findById(id))) {
+            if ((result = await StorageBacktest.findById(id))) {
                 return result;
             }
-            if ((result = await this._signalLiveUtils.findById(id))) {
+            if ((result = await StorageLive.findById(id))) {
                 return result;
             }
             throw new Error(`Storage signal with id ${id} not found`);
         };
         /**
-         * Lists all backtest signal history.
+         * Lists all backtest signals from storage.
          *
-         * @returns Promise resolving to array of backtest signal rows
+         * @returns Array of all backtest signal rows
+         * @throws Error if StorageAdapter is not enabled
          */
         this.listSignalBacktest = async () => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_BACKTEST);
             if (!this.enable.hasValue()) {
                 throw new Error("StorageAdapter is not enabled. Call enable() first.");
             }
-            return await this._signalBacktestUtils.list();
+            return await StorageBacktest.list();
         };
         /**
-         * Lists all live signal history.
+         * Lists all live signals from storage.
          *
-         * @returns Promise resolving to array of live signal rows
+         * @returns Array of all live signal rows
+         * @throws Error if StorageAdapter is not enabled
          */
         this.listSignalLive = async () => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_LIVE);
             if (!this.enable.hasValue()) {
                 throw new Error("StorageAdapter is not enabled. Call enable() first.");
             }
-            return await this._signalLiveUtils.list();
+            return await StorageLive.list();
         };
     }
 }
+/**
+ * Global singleton instance of StorageAdapter.
+ * Provides unified signal storage management for backtest and live trading.
+ */
 const Storage = new StorageAdapter();
+/**
+ * Global singleton instance of StorageLiveAdapter.
+ * Provides live trading signal storage with pluggable backends.
+ */
+const StorageLive = new StorageLiveAdapter();
+/**
+ * Global singleton instance of StorageBacktestAdapter.
+ * Provides backtest signal storage with pluggable backends.
+ */
+const StorageBacktest = new StorageBacktestAdapter();
 
 const EXCHANGE_METHOD_NAME_GET_CANDLES = "ExchangeUtils.getCandles";
 const EXCHANGE_METHOD_NAME_GET_AVERAGE_PRICE = "ExchangeUtils.getAveragePrice";
@@ -34144,6 +34672,8 @@ exports.ReportBase = ReportBase;
 exports.Risk = Risk;
 exports.Schedule = Schedule;
 exports.Storage = Storage;
+exports.StorageBacktest = StorageBacktest;
+exports.StorageLive = StorageLive;
 exports.Strategy = Strategy;
 exports.Walker = Walker;
 exports.addActionSchema = addActionSchema;