backtest-kit 2.2.9 → 2.2.11

package/build/index.mjs

@@ -711,6 +711,11 @@ const PERSIST_BASE_METHOD_NAME_READ_VALUE = "PersistBase.readValue";
 const PERSIST_BASE_METHOD_NAME_WRITE_VALUE = "PersistBase.writeValue";
 const PERSIST_BASE_METHOD_NAME_HAS_VALUE = "PersistBase.hasValue";
 const PERSIST_BASE_METHOD_NAME_KEYS = "PersistBase.keys";
+const PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA = "PersistStorageUtils.readStorageData";
+const PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA = "PersistStorageUtils.writeStorageData";
+const PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON = "PersistStorageUtils.useJson";
+const PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY = "PersistStorageUtils.useDummy";
+const PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER = "PersistStorageUtils.usePersistStorageAdapter";
 const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
@@ -929,7 +934,7 @@ class PersistDummy {
 class PersistSignalUtils {
     constructor() {
         this.PersistSignalFactory = PersistBase;
-        this.getSignalStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
+        this.getStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
             `${symbol}_${strategyName}_${exchangeName}`,
             `./dump/data/signal/`,
         ]));
@@ -947,8 +952,8 @@ class PersistSignalUtils {
         this.readSignalData = async (symbol, strategyName, exchangeName) => {
             bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getSignalStorage.has(key);
-            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            const isInitial = !this.getStorage.has(key);
+            const stateStorage = this.getStorage(symbol, strategyName, exchangeName);
             await stateStorage.waitForInit(isInitial);
             if (await stateStorage.hasValue(symbol)) {
                 return await stateStorage.readValue(symbol);
@@ -970,8 +975,8 @@ class PersistSignalUtils {
         this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
             bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getSignalStorage.has(key);
-            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            const isInitial = !this.getStorage.has(key);
+            const stateStorage = this.getStorage(symbol, strategyName, exchangeName);
             await stateStorage.waitForInit(isInitial);
             await stateStorage.writeValue(symbol, signalRow);
         };
@@ -1659,6 +1664,101 @@ class PersistCandleUtils {
  * ```
  */
 const PersistCandleAdapter = new PersistCandleUtils();
+/**
+ * Utility class for managing signal storage persistence.
+ *
+ * Features:
+ * - Memoized storage instances
+ * - Custom adapter support
+ * - Atomic read/write operations for StorageData
+ * - Each signal stored as separate file keyed by id
+ * - Crash-safe signal state management
+ *
+ * Used by SignalLiveUtils for live mode persistence of signals.
+ */
+class PersistStorageUtils {
+    constructor() {
+        this.PersistStorageFactory = PersistBase;
+        this.getStorageStorage = memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistStorageFactory, [
+            backtest ? `backtest` : `live`,
+            `./dump/data/signal-storage/`,
+        ]));
+        /**
+         * Reads persisted signals data.
+         *
+         * Called by StorageLiveUtils/StorageBacktestUtils.waitForInit() to restore state.
+         * Uses keys() from PersistBase to iterate over all stored signals.
+         * Returns empty array if no signals exist.
+         *
+         * @param backtest - If true, reads from backtest storage; otherwise from live storage
+         * @returns Promise resolving to array of signal entries
+         */
+        this.readStorageData = async (backtest) => {
+            bt.loggerService.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
+            const key = backtest ? `backtest` : `live`;
+            const isInitial = !this.getStorageStorage.has(key);
+            const stateStorage = this.getStorageStorage(backtest);
+            await stateStorage.waitForInit(isInitial);
+            const signals = [];
+            for await (const signalId of stateStorage.keys()) {
+                const signal = await stateStorage.readValue(signalId);
+                signals.push(signal);
+            }
+            return signals;
+        };
+        /**
+         * Writes signal data to disk with atomic file writes.
+         *
+         * Called by StorageLiveUtils/StorageBacktestUtils after signal changes to persist state.
+         * Uses signal.id as the storage key for individual file storage.
+         * Uses atomic writes to prevent corruption on crashes.
+         *
+         * @param signalData - Signal entries to persist
+         * @param backtest - If true, writes to backtest storage; otherwise to live storage
+         * @returns Promise that resolves when write is complete
+         */
+        this.writeStorageData = async (signalData, backtest) => {
+            bt.loggerService.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = backtest ? `backtest` : `live`;
+            const isInitial = !this.getStorageStorage.has(key);
+            const stateStorage = this.getStorageStorage(backtest);
+            await stateStorage.waitForInit(isInitial);
+            for (const signal of signalData) {
+                await stateStorage.writeValue(signal.id, signal);
+            }
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     */
+    usePersistStorageAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
+        this.PersistStorageFactory = Ctor;
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistStorageAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistStorageAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistStorageUtils.
+ * Used by SignalLiveUtils for signal storage persistence.
+ */
+const PersistStorageAdapter = new PersistStorageUtils();
 
 const MS_PER_MINUTE$1 = 60000;
 const INTERVAL_MINUTES$4 = {
@@ -12087,6 +12187,7 @@ class BacktestLogicPrivateService {
             if (result.action === "scheduled") {
                 const signalStartTime = performance.now();
                 const signal = result.signal;
+                yield result;
                 this.loggerService.info("backtestLogicPrivateService scheduled signal detected", {
                     symbol,
                     signalId: signal.id,
@@ -12230,6 +12331,7 @@ class BacktestLogicPrivateService {
             if (result.action === "opened") {
                 const signalStartTime = performance.now();
                 const signal = result.signal;
+                yield result;
                 this.loggerService.info("backtestLogicPrivateService signal opened", {
                     symbol,
                     signalId: signal.id,
@@ -31427,6 +31529,480 @@ 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_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";
+/**
+ * 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";
+ *
+ * const storage = new StorageBacktestUtils();
+ *
+ * // Handle signal events
+ * await storage.handleOpened(tickResult);
+ * await storage.handleClosed(tickResult);
+ *
+ * // Query signals
+ * const signal = await storage.findById("signal-123");
+ * const allSignals = await storage.list();
+ * ```
+ */
+class StorageBacktestUtils {
+    constructor() {
+        /**
+         * Initializes storage by loading existing signal history from persist layer.
+         * Uses singleshot to ensure initialization happens only once.
+         */
+        this.waitForInit = singleshot(async () => {
+            bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_WAIT_FOR_INIT);
+            const signalList = await PersistStorageAdapter.readStorageData(true);
+            signalList.sort((a, b) => a.priority - b.priority);
+            this._signals = new Map(signalList
+                .slice(-MAX_SIGNALS)
+                .map((signal) => [signal.id, signal]));
+        });
+        /**
+         * Handles signal opened event.
+         *
+         * @param tick - Tick result containing opened signal data
+         * @returns Promise resolving when storage is updated
+         */
+        this.handleOpened = async (tick) => {
+            bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_OPENED, {
+                signalId: tick.signal.id,
+            });
+            await this.waitForInit();
+            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(),
+                updatedAt: tick.createdAt,
+            });
+            await this._updateStorage();
+        };
+        /**
+         * Handles signal closed event.
+         *
+         * @param tick - Tick result containing closed signal data
+         * @returns Promise resolving when storage is updated
+         */
+        this.handleClosed = async (tick) => {
+            bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_CLOSED, {
+                signalId: tick.signal.id,
+            });
+            await this.waitForInit();
+            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(),
+                updatedAt: tick.createdAt,
+            });
+            await this._updateStorage();
+        };
+        /**
+         * Handles signal scheduled event.
+         *
+         * @param tick - Tick result containing scheduled signal data
+         * @returns Promise resolving when storage is updated
+         */
+        this.handleScheduled = async (tick) => {
+            bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED, {
+                signalId: tick.signal.id,
+            });
+            await this.waitForInit();
+            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(),
+                updatedAt: tick.createdAt,
+            });
+            await this._updateStorage();
+        };
+        /**
+         * Handles signal cancelled event.
+         *
+         * @param tick - Tick result containing cancelled signal data
+         * @returns Promise resolving when storage is updated
+         */
+        this.handleCancelled = async (tick) => {
+            bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_CANCELLED, {
+                signalId: tick.signal.id,
+            });
+            await this.waitForInit();
+            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(),
+                updatedAt: tick.createdAt,
+            });
+            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
+         */
+        this.findById = async (id) => {
+            bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_FIND_BY_ID, { id });
+            await this.waitForInit();
+            return this._signals.get(id) ?? null;
+        };
+        /**
+         * Lists all stored backtest signals.
+         *
+         * @returns Promise resolving to array of signal rows
+         */
+        this.list = async () => {
+            bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_LIST);
+            await this.waitForInit();
+            return Array.from(this._signals.values());
+        };
+    }
+    /**
+     * Persists current signal history to storage.
+     * Sorts by priority and limits to MAX_SIGNALS entries.
+     *
+     * @throws Error if storage 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.");
+        }
+        const signalList = Array.from(this._signals.values());
+        signalList.sort((a, b) => a.priority - b.priority);
+        await PersistStorageAdapter.writeStorageData(signalList.slice(-MAX_SIGNALS), true);
+    }
+}
+/**
+ * Utility class for managing live trading signal history.
+ *
+ * Stores trading signal history for admin dashboard display during live trading
+ * with automatic initialization, deduplication, and storage limits.
+ *
+ * @example
+ * ```typescript
+ * import { StorageLiveUtils } from "./classes/Storage";
+ *
+ * const storage = new StorageLiveUtils();
+ *
+ * // Handle signal events
+ * await storage.handleOpened(tickResult);
+ * await storage.handleClosed(tickResult);
+ *
+ * // Query signals
+ * const signal = await storage.findById("signal-123");
+ * const allSignals = await storage.list();
+ * ```
+ */
+class StorageLiveUtils {
+    constructor() {
+        /**
+         * Initializes storage by loading existing signal history from persist layer.
+         * Uses singleshot to ensure initialization happens only once.
+         */
+        this.waitForInit = singleshot(async () => {
+            bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_WAIT_FOR_INIT);
+            const signalList = await PersistStorageAdapter.readStorageData(false);
+            signalList.sort((a, b) => a.priority - b.priority);
+            this._signals = new Map(signalList
+                .slice(-MAX_SIGNALS)
+                .map((signal) => [signal.id, signal]));
+        });
+        /**
+         * Handles signal opened event.
+         *
+         * @param tick - Tick result containing opened signal data
+         * @returns Promise resolving when history is updated
+         */
+        this.handleOpened = async (tick) => {
+            bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_OPENED, {
+                signalId: tick.signal.id,
+            });
+            await this.waitForInit();
+            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(),
+                updatedAt: tick.createdAt,
+            });
+            await this._updateStorage();
+        };
+        /**
+         * Handles signal closed event.
+         *
+         * @param tick - Tick result containing closed signal data
+         * @returns Promise resolving when history is updated
+         */
+        this.handleClosed = async (tick) => {
+            bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_CLOSED, {
+                signalId: tick.signal.id,
+            });
+            await this.waitForInit();
+            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(),
+                updatedAt: tick.createdAt,
+            });
+            await this._updateStorage();
+        };
+        /**
+         * Handles signal scheduled event.
+         *
+         * @param tick - Tick result containing scheduled signal data
+         * @returns Promise resolving when history is updated
+         */
+        this.handleScheduled = async (tick) => {
+            bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_SCHEDULED, {
+                signalId: tick.signal.id,
+            });
+            await this.waitForInit();
+            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(),
+                updatedAt: tick.createdAt,
+            });
+            await this._updateStorage();
+        };
+        /**
+         * Handles signal cancelled event.
+         *
+         * @param tick - Tick result containing cancelled signal data
+         * @returns Promise resolving when history is updated
+         */
+        this.handleCancelled = async (tick) => {
+            bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_CANCELLED, {
+                signalId: tick.signal.id,
+            });
+            await this.waitForInit();
+            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(),
+                updatedAt: tick.createdAt,
+            });
+            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
+         */
+        this.findById = async (id) => {
+            bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_FIND_BY_ID, { id });
+            await this.waitForInit();
+            return this._signals.get(id) ?? null;
+        };
+        /**
+         * Lists all stored live signals.
+         *
+         * @returns Promise resolving to array of signal rows
+         */
+        this.list = async () => {
+            bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_LIST);
+            await this.waitForInit();
+            return Array.from(this._signals.values());
+        };
+    }
+    /**
+     * Persists current signal history to storage.
+     * Sorts by priority and limits to MAX_SIGNALS entries.
+     *
+     * @throws Error if storage 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.");
+        }
+        const signalList = Array.from(this._signals.values());
+        signalList.sort((a, b) => a.priority - b.priority);
+        await PersistStorageAdapter.writeStorageData(signalList.slice(-MAX_SIGNALS), false);
+    }
+}
+/**
+ * Main storage adapter for signal history management.
+ *
+ * Provides unified interface for accessing backtest and live signal history
+ * for admin dashboard. Subscribes to signal emitters and automatically
+ * updates history on signal events.
+ *
+ * @example
+ * ```typescript
+ * import { Storage } from "./classes/Storage";
+ *
+ * // Enable signal history tracking
+ * const unsubscribe = Storage.enable();
+ *
+ * // Query signals
+ * const backtestSignals = await Storage.listSignalBacktest();
+ * const liveSignals = await Storage.listSignalLive();
+ * const signal = await Storage.findSignalById("signal-123");
+ *
+ * // Disable tracking
+ * Storage.disable();
+ * ```
+ */
+class StorageAdapter {
+    constructor() {
+        this._signalLiveUtils = new StorageLiveUtils();
+        this._signalBacktestUtils = new StorageBacktestUtils();
+        /**
+         * Enables signal history tracking by subscribing to emitters.
+         *
+         * @returns Cleanup function to unsubscribe from all emitters
+         */
+        this.enable = singleshot(() => {
+            bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_ENABLE);
+            let unLive;
+            let unBacktest;
+            {
+                const unBacktestOpen = signalBacktestEmitter
+                    .filter(({ action }) => action === "opened")
+                    .connect((tick) => this._signalBacktestUtils.handleOpened(tick));
+                const unBacktestClose = signalBacktestEmitter
+                    .filter(({ action }) => action === "closed")
+                    .connect((tick) => this._signalBacktestUtils.handleClosed(tick));
+                const unBacktestScheduled = signalBacktestEmitter
+                    .filter(({ action }) => action === "scheduled")
+                    .connect((tick) => this._signalBacktestUtils.handleScheduled(tick));
+                const unBacktestCancelled = signalBacktestEmitter
+                    .filter(({ action }) => action === "cancelled")
+                    .connect((tick) => this._signalBacktestUtils.handleCancelled(tick));
+                unBacktest = compose(() => unBacktestOpen(), () => unBacktestClose(), () => unBacktestScheduled(), () => unBacktestCancelled());
+            }
+            {
+                const unLiveOpen = signalLiveEmitter
+                    .filter(({ action }) => action === "opened")
+                    .connect((tick) => this._signalLiveUtils.handleOpened(tick));
+                const unLiveClose = signalLiveEmitter
+                    .filter(({ action }) => action === "closed")
+                    .connect((tick) => this._signalLiveUtils.handleClosed(tick));
+                const unLiveScheduled = signalLiveEmitter
+                    .filter(({ action }) => action === "scheduled")
+                    .connect((tick) => this._signalLiveUtils.handleScheduled(tick));
+                const unLiveCancelled = signalLiveEmitter
+                    .filter(({ action }) => action === "cancelled")
+                    .connect((tick) => this._signalLiveUtils.handleCancelled(tick));
+                unLive = compose(() => unLiveOpen(), () => unLiveClose(), () => unLiveScheduled(), () => unLiveCancelled());
+            }
+            return () => {
+                unLive();
+                unBacktest();
+                this.enable.clear();
+            };
+        });
+        /**
+         * Disables signal history tracking by unsubscribing from emitters.
+         */
+        this.disable = () => {
+            bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_DISABLE);
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+        /**
+         * Finds a signal by ID across both backtest and live history.
+         *
+         * @param id - Signal identifier
+         * @returns Promise resolving to signal row
+         * @throws Error if signal not found in either storage
+         */
+        this.findSignalById = async (id) => {
+            bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_FIND_SIGNAL_BY_ID, { id });
+            let result = null;
+            if ((result = await this._signalBacktestUtils.findById(id))) {
+                return result;
+            }
+            if ((result = await this._signalLiveUtils.findById(id))) {
+                return result;
+            }
+            throw new Error(`Storage signal with id ${id} not found`);
+        };
+        /**
+         * Lists all backtest signal history.
+         *
+         * @returns Promise resolving to array of backtest signal rows
+         */
+        this.listSignalBacktest = async () => {
+            bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_BACKTEST);
+            return await this._signalBacktestUtils.list();
+        };
+        /**
+         * Lists all live signal history.
+         *
+         * @returns Promise resolving to array of live signal rows
+         */
+        this.listSignalLive = async () => {
+            bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_LIVE);
+            return await this._signalLiveUtils.list();
+        };
+    }
+}
+const Storage = new StorageAdapter();
+
 const EXCHANGE_METHOD_NAME_GET_CANDLES = "ExchangeUtils.getCandles";
 const EXCHANGE_METHOD_NAME_GET_AVERAGE_PRICE = "ExchangeUtils.getAveragePrice";
 const EXCHANGE_METHOD_NAME_FORMAT_QUANTITY = "ExchangeUtils.formatQuantity";
@@ -33432,4 +34008,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "2.2.9",
+  "version": "2.2.11",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",