backtest-kit 2.2.10 → 2.2.12

package/build/index.cjs

@@ -731,6 +731,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;
@@ -949,7 +954,7 @@ class PersistDummy {
 class PersistSignalUtils {
     constructor() {
         this.PersistSignalFactory = PersistBase;
-        this.getSignalStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
             `${symbol}_${strategyName}_${exchangeName}`,
             `./dump/data/signal/`,
         ]));
@@ -967,8 +972,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);
@@ -990,8 +995,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);
         };
@@ -1679,6 +1684,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 = functoolsKit.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 = {
@@ -31449,6 +31549,489 @@ 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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.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 });
+            if (!this.enable.hasValue()) {
+                throw new Error("StorageAdapter is not enabled. Call enable() first.");
+            }
+            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);
+            if (!this.enable.hasValue()) {
+                throw new Error("StorageAdapter is not enabled. Call enable() first.");
+            }
+            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);
+            if (!this.enable.hasValue()) {
+                throw new Error("StorageAdapter is not enabled. Call enable() first.");
+            }
+            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";
@@ -33477,11 +34060,13 @@ exports.PersistPartialAdapter = PersistPartialAdapter;
 exports.PersistRiskAdapter = PersistRiskAdapter;
 exports.PersistScheduleAdapter = PersistScheduleAdapter;
 exports.PersistSignalAdapter = PersistSignalAdapter;
+exports.PersistStorageAdapter = PersistStorageAdapter;
 exports.PositionSize = PositionSize;
 exports.Report = Report;
 exports.ReportBase = ReportBase;
 exports.Risk = Risk;
 exports.Schedule = Schedule;
+exports.Storage = Storage;
 exports.Strategy = Strategy;
 exports.Walker = Walker;
 exports.addActionSchema = addActionSchema;