backtest-kit 3.0.0 → 3.0.1

package/build/index.cjs

@@ -750,6 +750,11 @@ const PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA = "PersistStorageUtils.writeS
 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 PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA = "PersistNotificationUtils.readNotificationData";
+const PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA = "PersistNotificationUtils.writeNotificationData";
+const PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON = "PersistNotificationUtils.useJson";
+const PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY = "PersistNotificationUtils.useDummy";
+const PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER = "PersistNotificationUtils.usePersistNotificationAdapter";
 const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
@@ -1823,6 +1828,101 @@ class PersistStorageUtils {
  * Used by SignalLiveUtils for signal storage persistence.
  */
 const PersistStorageAdapter = new PersistStorageUtils();
+/**
+ * Utility class for managing notification persistence.
+ *
+ * Features:
+ * - Memoized storage instances
+ * - Custom adapter support
+ * - Atomic read/write operations for NotificationData
+ * - Each notification stored as separate file keyed by id
+ * - Crash-safe notification state management
+ *
+ * Used by NotificationPersistLiveUtils/NotificationPersistBacktestUtils for persistence.
+ */
+class PersistNotificationUtils {
+    constructor() {
+        this.PersistNotificationFactory = PersistBase;
+        this.getNotificationStorage = functoolsKit.memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistNotificationFactory, [
+            backtest ? `backtest` : `live`,
+            `./dump/data/notification/`,
+        ]));
+        /**
+         * Reads persisted notifications data.
+         *
+         * Called by NotificationPersistLiveUtils/NotificationPersistBacktestUtils.waitForInit() to restore state.
+         * Uses keys() from PersistBase to iterate over all stored notifications.
+         * Returns empty array if no notifications exist.
+         *
+         * @param backtest - If true, reads from backtest storage; otherwise from live storage
+         * @returns Promise resolving to array of notification entries
+         */
+        this.readNotificationData = async (backtest) => {
+            bt.loggerService.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
+            const key = backtest ? `backtest` : `live`;
+            const isInitial = !this.getNotificationStorage.has(key);
+            const stateStorage = this.getNotificationStorage(backtest);
+            await stateStorage.waitForInit(isInitial);
+            const notifications = [];
+            for await (const notificationId of stateStorage.keys()) {
+                const notification = await stateStorage.readValue(notificationId);
+                notifications.push(notification);
+            }
+            return notifications;
+        };
+        /**
+         * Writes notification data to disk with atomic file writes.
+         *
+         * Called by NotificationPersistLiveUtils/NotificationPersistBacktestUtils after notification changes to persist state.
+         * Uses notification.id as the storage key for individual file storage.
+         * Uses atomic writes to prevent corruption on crashes.
+         *
+         * @param notificationData - Notification entries to persist
+         * @param backtest - If true, writes to backtest storage; otherwise to live storage
+         * @returns Promise that resolves when write is complete
+         */
+        this.writeNotificationData = async (notificationData, backtest) => {
+            bt.loggerService.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = backtest ? `backtest` : `live`;
+            const isInitial = !this.getNotificationStorage.has(key);
+            const stateStorage = this.getNotificationStorage(backtest);
+            await stateStorage.waitForInit(isInitial);
+            for (const notification of notificationData) {
+                await stateStorage.writeValue(notification.id, notification);
+            }
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     */
+    usePersistNotificationAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
+        this.PersistNotificationFactory = Ctor;
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistNotificationAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistNotificationAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistNotificationUtils.
+ * Used by NotificationPersistLiveUtils/NotificationPersistBacktestUtils for notification persistence.
+ */
+const PersistNotificationAdapter = new PersistNotificationUtils();
 
 const MS_PER_MINUTE$1 = 60000;
 const INTERVAL_MINUTES$4 = {
@@ -33640,325 +33740,2048 @@ const StorageLive = new StorageLiveAdapter();
  */
 const StorageBacktest = new StorageBacktestAdapter();
 
-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";
-const EXCHANGE_METHOD_NAME_FORMAT_PRICE = "ExchangeUtils.formatPrice";
-const EXCHANGE_METHOD_NAME_GET_ORDER_BOOK = "ExchangeUtils.getOrderBook";
-const EXCHANGE_METHOD_NAME_GET_RAW_CANDLES = "ExchangeUtils.getRawCandles";
-const MS_PER_MINUTE = 60000;
 /**
- * Gets current timestamp from execution context if available.
- * Returns current Date() if no execution context exists (non-trading GUI).
+ * Maximum number of notifications to keep in storage.
+ * Older notifications are removed when this limit is exceeded.
  */
-const GET_TIMESTAMP_FN = async () => {
-    if (ExecutionContextService.hasContext()) {
-        return new Date(bt.executionContextService.context.when);
-    }
-    return new Date();
-};
+const MAX_NOTIFICATIONS = 250;
 /**
- * Gets backtest mode flag from execution context if available.
- * Returns false if no execution context exists (live mode).
+ * Generates a unique key for notification identification.
+ * @returns Random string identifier
  */
-const GET_BACKTEST_FN = async () => {
-    if (ExecutionContextService.hasContext()) {
-        return bt.executionContextService.context.backtest;
-    }
-    return false;
-};
+const CREATE_KEY_FN$1 = () => functoolsKit.randomString();
 /**
- * Default implementation for getCandles.
- * Throws an error indicating the method is not implemented.
+ * Creates a notification model from signal tick result.
+ * Handles opened, closed, scheduled, and cancelled signal actions.
+ * @param data - The strategy tick result data
+ * @returns NotificationModel or null if action is not recognized
  */
-const DEFAULT_GET_CANDLES_FN = async (_symbol, _interval, _since, _limit, _backtest) => {
-    throw new Error(`getCandles is not implemented for this exchange`);
+const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
+    if (data.action === "opened") {
+        return {
+            type: "signal.opened",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.signal.pendingAt,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            note: data.signal.note,
+            scheduledAt: data.signal.scheduledAt,
+            pendingAt: data.signal.pendingAt,
+            createdAt: data.createdAt,
+        };
+    }
+    else if (data.action === "closed") {
+        const durationMs = data.closeTimestamp - data.signal.pendingAt;
+        const durationMin = Math.round(durationMs / 60000);
+        return {
+            type: "signal.closed",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.closeTimestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            priceOpen: data.signal.priceOpen,
+            priceClose: data.currentPrice,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            pnlPercentage: data.pnl.pnlPercentage,
+            closeReason: data.closeReason,
+            duration: durationMin,
+            note: data.signal.note,
+            scheduledAt: data.signal.scheduledAt,
+            pendingAt: data.signal.pendingAt,
+            createdAt: data.createdAt,
+        };
+    }
+    else if (data.action === "scheduled") {
+        return {
+            type: "signal.scheduled",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.signal.scheduledAt,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            scheduledAt: data.signal.scheduledAt,
+            currentPrice: data.currentPrice,
+            createdAt: data.createdAt,
+        };
+    }
+    else if (data.action === "cancelled") {
+        const durationMs = data.closeTimestamp - data.signal.scheduledAt;
+        const durationMin = Math.round(durationMs / 60000);
+        return {
+            type: "signal.cancelled",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.closeTimestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            cancelReason: data.reason,
+            cancelId: data.cancelId,
+            duration: durationMin,
+            scheduledAt: data.signal.scheduledAt,
+            pendingAt: data.signal.pendingAt,
+            createdAt: data.createdAt,
+        };
+    }
+    return null;
 };
 /**
- * Default implementation for formatQuantity.
- * Returns Bitcoin precision on Binance (8 decimal places).
- */
-const DEFAULT_FORMAT_QUANTITY_FN = async (_symbol, quantity, _backtest) => {
-    return quantity.toFixed(8);
-};
+ * Creates a notification model for partial profit availability.
+ * @param data - The partial profit contract data
+ * @returns NotificationModel for partial profit event
+ */
+const CREATE_PARTIAL_PROFIT_NOTIFICATION_FN = (data) => ({
+    type: "partial_profit.available",
+    id: CREATE_KEY_FN$1(),
+    timestamp: data.timestamp,
+    backtest: data.backtest,
+    symbol: data.symbol,
+    strategyName: data.strategyName,
+    exchangeName: data.exchangeName,
+    signalId: data.data.id,
+    level: data.level,
+    currentPrice: data.currentPrice,
+    priceOpen: data.data.priceOpen,
+    position: data.data.position,
+    priceTakeProfit: data.data.priceTakeProfit,
+    priceStopLoss: data.data.priceStopLoss,
+    originalPriceTakeProfit: data.data.originalPriceTakeProfit,
+    originalPriceStopLoss: data.data.originalPriceStopLoss,
+    scheduledAt: data.data.scheduledAt,
+    pendingAt: data.data.pendingAt,
+    createdAt: data.timestamp,
+});
 /**
- * Default implementation for formatPrice.
- * Returns Bitcoin precision on Binance (2 decimal places).
- */
-const DEFAULT_FORMAT_PRICE_FN = async (_symbol, price, _backtest) => {
-    return price.toFixed(2);
-};
+ * Creates a notification model for partial loss availability.
+ * @param data - The partial loss contract data
+ * @returns NotificationModel for partial loss event
+ */
+const CREATE_PARTIAL_LOSS_NOTIFICATION_FN = (data) => ({
+    type: "partial_loss.available",
+    id: CREATE_KEY_FN$1(),
+    timestamp: data.timestamp,
+    backtest: data.backtest,
+    symbol: data.symbol,
+    strategyName: data.strategyName,
+    exchangeName: data.exchangeName,
+    signalId: data.data.id,
+    level: data.level,
+    currentPrice: data.currentPrice,
+    priceOpen: data.data.priceOpen,
+    position: data.data.position,
+    priceTakeProfit: data.data.priceTakeProfit,
+    priceStopLoss: data.data.priceStopLoss,
+    originalPriceTakeProfit: data.data.originalPriceTakeProfit,
+    originalPriceStopLoss: data.data.originalPriceStopLoss,
+    scheduledAt: data.data.scheduledAt,
+    pendingAt: data.data.pendingAt,
+    createdAt: data.timestamp,
+});
 /**
- * Default implementation for getOrderBook.
- * Throws an error indicating the method is not implemented.
- *
- * @param _symbol - Trading pair symbol (unused)
- * @param _depth - Maximum depth levels (unused)
- * @param _from - Start of time range (unused - can be ignored in live implementations)
- * @param _to - End of time range (unused - can be ignored in live implementations)
- * @param _backtest - Whether running in backtest mode (unused)
- */
-const DEFAULT_GET_ORDER_BOOK_FN = async (_symbol, _depth, _from, _to, _backtest) => {
-    throw new Error(`getOrderBook is not implemented for this exchange`);
-};
-const INTERVAL_MINUTES$1 = {
-    "1m": 1,
-    "3m": 3,
-    "5m": 5,
-    "15m": 15,
-    "30m": 30,
-    "1h": 60,
-    "2h": 120,
-    "4h": 240,
-    "6h": 360,
-    "8h": 480,
-};
+ * Creates a notification model for breakeven availability.
+ * @param data - The breakeven contract data
+ * @returns NotificationModel for breakeven event
+ */
+const CREATE_BREAKEVEN_NOTIFICATION_FN = (data) => ({
+    type: "breakeven.available",
+    id: CREATE_KEY_FN$1(),
+    timestamp: data.timestamp,
+    backtest: data.backtest,
+    symbol: data.symbol,
+    strategyName: data.strategyName,
+    exchangeName: data.exchangeName,
+    signalId: data.data.id,
+    currentPrice: data.currentPrice,
+    priceOpen: data.data.priceOpen,
+    position: data.data.position,
+    priceTakeProfit: data.data.priceTakeProfit,
+    priceStopLoss: data.data.priceStopLoss,
+    originalPriceTakeProfit: data.data.originalPriceTakeProfit,
+    originalPriceStopLoss: data.data.originalPriceStopLoss,
+    scheduledAt: data.data.scheduledAt,
+    pendingAt: data.data.pendingAt,
+    createdAt: data.timestamp,
+});
 /**
- * Aligns timestamp down to the nearest interval boundary.
- * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
- *
- * Candle timestamp convention:
- * - Candle timestamp = openTime (when candle opens)
- * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
- *
- * Adapter contract:
- * - Adapter must return candles with timestamp = openTime
- * - First returned candle.timestamp must equal aligned since
- * - Adapter must return exactly `limit` candles
- *
- * @param timestamp - Timestamp in milliseconds
- * @param intervalMinutes - Interval in minutes
- * @returns Aligned timestamp rounded down to interval boundary
+ * Creates a notification model for strategy commit events.
+ * Handles partial-profit, partial-loss, breakeven, trailing-stop,
+ * trailing-take, and activate-scheduled actions.
+ * @param data - The strategy commit contract data
+ * @returns NotificationModel or null if action is not recognized
  */
-const ALIGN_TO_INTERVAL_FN = (timestamp, intervalMinutes) => {
-    const intervalMs = intervalMinutes * MS_PER_MINUTE;
-    return Math.floor(timestamp / intervalMs) * intervalMs;
+const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
+    if (data.action === "partial-profit") {
+        return {
+            type: "partial_profit.commit",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.timestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signalId,
+            percentToClose: data.percentToClose,
+            currentPrice: data.currentPrice,
+            position: data.position,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            originalPriceTakeProfit: data.originalPriceTakeProfit,
+            originalPriceStopLoss: data.originalPriceStopLoss,
+            scheduledAt: data.scheduledAt,
+            pendingAt: data.pendingAt,
+            createdAt: data.timestamp,
+        };
+    }
+    else if (data.action === "partial-loss") {
+        return {
+            type: "partial_loss.commit",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.timestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signalId,
+            percentToClose: data.percentToClose,
+            currentPrice: data.currentPrice,
+            position: data.position,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            originalPriceTakeProfit: data.originalPriceTakeProfit,
+            originalPriceStopLoss: data.originalPriceStopLoss,
+            scheduledAt: data.scheduledAt,
+            pendingAt: data.pendingAt,
+            createdAt: data.timestamp,
+        };
+    }
+    else if (data.action === "breakeven") {
+        return {
+            type: "breakeven.commit",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.timestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signalId,
+            currentPrice: data.currentPrice,
+            position: data.position,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            originalPriceTakeProfit: data.originalPriceTakeProfit,
+            originalPriceStopLoss: data.originalPriceStopLoss,
+            scheduledAt: data.scheduledAt,
+            pendingAt: data.pendingAt,
+            createdAt: data.timestamp,
+        };
+    }
+    else if (data.action === "trailing-stop") {
+        return {
+            type: "trailing_stop.commit",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.timestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signalId,
+            percentShift: data.percentShift,
+            currentPrice: data.currentPrice,
+            position: data.position,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            originalPriceTakeProfit: data.originalPriceTakeProfit,
+            originalPriceStopLoss: data.originalPriceStopLoss,
+            scheduledAt: data.scheduledAt,
+            pendingAt: data.pendingAt,
+            createdAt: data.timestamp,
+        };
+    }
+    else if (data.action === "trailing-take") {
+        return {
+            type: "trailing_take.commit",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.timestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signalId,
+            percentShift: data.percentShift,
+            currentPrice: data.currentPrice,
+            position: data.position,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            originalPriceTakeProfit: data.originalPriceTakeProfit,
+            originalPriceStopLoss: data.originalPriceStopLoss,
+            scheduledAt: data.scheduledAt,
+            pendingAt: data.pendingAt,
+            createdAt: data.timestamp,
+        };
+    }
+    else if (data.action === "activate-scheduled") {
+        return {
+            type: "activate_scheduled.commit",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.timestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signalId,
+            activateId: data.activateId,
+            currentPrice: data.currentPrice,
+            position: data.position,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            originalPriceTakeProfit: data.originalPriceTakeProfit,
+            originalPriceStopLoss: data.originalPriceStopLoss,
+            scheduledAt: data.scheduledAt,
+            pendingAt: data.pendingAt,
+            createdAt: data.timestamp,
+        };
+    }
+    return null;
 };
 /**
- * Creates exchange instance with methods resolved once during construction.
- * Applies default implementations where schema methods are not provided.
- *
- * @param schema - Exchange schema from registry
- * @returns Object with resolved exchange methods
- */
-const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
-    const getCandles = schema.getCandles ?? DEFAULT_GET_CANDLES_FN;
-    const formatQuantity = schema.formatQuantity ?? DEFAULT_FORMAT_QUANTITY_FN;
-    const formatPrice = schema.formatPrice ?? DEFAULT_FORMAT_PRICE_FN;
-    const getOrderBook = schema.getOrderBook ?? DEFAULT_GET_ORDER_BOOK_FN;
-    return {
-        getCandles,
-        formatQuantity,
-        formatPrice,
-        getOrderBook,
-    };
-};
+ * Creates a notification model for risk rejection events.
+ * @param data - The risk contract data
+ * @returns NotificationModel for risk rejection event
+ */
+const CREATE_RISK_NOTIFICATION_FN = (data) => ({
+    type: "risk.rejection",
+    id: CREATE_KEY_FN$1(),
+    timestamp: data.timestamp,
+    backtest: data.backtest,
+    symbol: data.symbol,
+    strategyName: data.strategyName,
+    exchangeName: data.exchangeName,
+    rejectionNote: data.rejectionNote,
+    rejectionId: data.rejectionId,
+    activePositionCount: data.activePositionCount,
+    currentPrice: data.currentPrice,
+    signalId: data.currentSignal.id,
+    position: data.currentSignal.position,
+    priceOpen: data.currentSignal.priceOpen,
+    priceTakeProfit: data.currentSignal.priceTakeProfit,
+    priceStopLoss: data.currentSignal.priceStopLoss,
+    minuteEstimatedTime: data.currentSignal.minuteEstimatedTime,
+    signalNote: data.currentSignal.note,
+    createdAt: data.timestamp,
+});
 /**
- * Attempts to read candles from cache.
- *
- * Cache lookup calculates expected timestamps:
- * sinceTimestamp + i * stepMs for i = 0..limit-1
- * Returns all candles if found, null if any missing.
- *
- * @param dto - Data transfer object containing symbol, interval, and limit
- * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
- * @param untilTimestamp - Unused, kept for API compatibility
- * @param exchangeName - Exchange name
- * @returns Cached candles array (exactly limit) or null if cache miss
+ * Creates a notification model for error events.
+ * @param error - The error object
+ * @returns NotificationModel for error event
  */
-const READ_CANDLES_CACHE_FN = functoolsKit.trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
-    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
-    // sinceTimestamp + i * stepMs for i = 0..limit-1
-    // Returns all candles if found, null if any missing
-    const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
-    // Return cached data only if we have exactly the requested limit
-    if (cachedCandles?.length === dto.limit) {
-        bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
-        return cachedCandles;
-    }
-    bt.loggerService.warn(`ExchangeInstance READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
-    return null;
-}, {
-    fallback: async (error) => {
-        const message = `ExchangeInstance READ_CANDLES_CACHE_FN: cache read failed`;
-        const payload = {
-            error: functoolsKit.errorData(error),
-            message: functoolsKit.getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-    defaultValue: null,
+const CREATE_ERROR_NOTIFICATION_FN = (error) => ({
+    type: "error.info",
+    id: CREATE_KEY_FN$1(),
+    error: functoolsKit.errorData(error),
+    message: functoolsKit.getErrorMessage(error),
+    backtest: false,
 });
 /**
- * Writes candles to cache with error handling.
- *
- * The candles passed to this function should be validated:
- * - First candle.timestamp equals aligned sinceTimestamp (openTime)
- * - Exact number of candles as requested (limit)
- * - Sequential timestamps: sinceTimestamp + i * stepMs
- *
- * @param candles - Array of validated candle data to cache
- * @param dto - Data transfer object containing symbol, interval, and limit
- * @param exchangeName - Exchange name
+ * Creates a notification model for critical error events.
+ * @param error - The error object
+ * @returns NotificationModel for critical error event
  */
-const WRITE_CANDLES_CACHE_FN = functoolsKit.trycatch(functoolsKit.queued(async (candles, dto, exchangeName) => {
-    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, exchangeName);
-    bt.loggerService.debug(`ExchangeInstance WRITE_CANDLES_CACHE_FN: cache updated for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
-}), {
-    fallback: async (error) => {
-        const message = `ExchangeInstance WRITE_CANDLES_CACHE_FN: cache write failed`;
-        const payload = {
-            error: functoolsKit.errorData(error),
-            message: functoolsKit.getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-    defaultValue: null,
+const CREATE_CRITICAL_ERROR_NOTIFICATION_FN = (error) => ({
+    type: "error.critical",
+    id: CREATE_KEY_FN$1(),
+    error: functoolsKit.errorData(error),
+    message: functoolsKit.getErrorMessage(error),
+    backtest: false,
 });
 /**
- * Instance class for exchange operations on a specific exchange.
- *
- * Provides isolated exchange operations for a single exchange.
- * Each instance maintains its own context and exposes IExchangeSchema methods.
- * The schema is retrieved once during construction for better performance.
+ * Creates a notification model for validation error events.
+ * @param error - The error object
+ * @returns NotificationModel for validation error event
+ */
+const CREATE_VALIDATION_ERROR_NOTIFICATION_FN = (error) => ({
+    type: "error.validation",
+    id: CREATE_KEY_FN$1(),
+    error: functoolsKit.errorData(error),
+    message: functoolsKit.getErrorMessage(error),
+    backtest: false,
+});
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_SIGNAL = "NotificationMemoryBacktestUtils.handleSignal";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_PROFIT = "NotificationMemoryBacktestUtils.handlePartialProfit";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_LOSS = "NotificationMemoryBacktestUtils.handlePartialLoss";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_BREAKEVEN = "NotificationMemoryBacktestUtils.handleBreakeven";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_STRATEGY_COMMIT = "NotificationMemoryBacktestUtils.handleStrategyCommit";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_RISK = "NotificationMemoryBacktestUtils.handleRisk";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_ERROR = "NotificationMemoryBacktestUtils.handleError";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CRITICAL_ERROR = "NotificationMemoryBacktestUtils.handleCriticalError";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_VALIDATION_ERROR = "NotificationMemoryBacktestUtils.handleValidationError";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_GET_DATA = "NotificationMemoryBacktestUtils.getData";
+const NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_CLEAR = "NotificationMemoryBacktestUtils.clear";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_SIGNAL = "NotificationMemoryLiveUtils.handleSignal";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_PARTIAL_PROFIT = "NotificationMemoryLiveUtils.handlePartialProfit";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_PARTIAL_LOSS = "NotificationMemoryLiveUtils.handlePartialLoss";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_BREAKEVEN = "NotificationMemoryLiveUtils.handleBreakeven";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_STRATEGY_COMMIT = "NotificationMemoryLiveUtils.handleStrategyCommit";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_RISK = "NotificationMemoryLiveUtils.handleRisk";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_ERROR = "NotificationMemoryLiveUtils.handleError";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_CRITICAL_ERROR = "NotificationMemoryLiveUtils.handleCriticalError";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_VALIDATION_ERROR = "NotificationMemoryLiveUtils.handleValidationError";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_GET_DATA = "NotificationMemoryLiveUtils.getData";
+const NOTIFICATION_MEMORY_LIVE_METHOD_NAME_CLEAR = "NotificationMemoryLiveUtils.clear";
+const NOTIFICATION_ADAPTER_METHOD_NAME_ENABLE = "NotificationAdapter.enable";
+const NOTIFICATION_ADAPTER_METHOD_NAME_DISABLE = "NotificationAdapter.disable";
+const NOTIFICATION_ADAPTER_METHOD_NAME_GET_DATA_BACKTEST = "NotificationAdapter.getDataBacktest";
+const NOTIFICATION_ADAPTER_METHOD_NAME_GET_DATA_LIVE = "NotificationAdapter.getDataLive";
+const NOTIFICATION_ADAPTER_METHOD_NAME_CLEAR_BACKTEST = "NotificationAdapter.clearBacktest";
+const NOTIFICATION_ADAPTER_METHOD_NAME_CLEAR_LIVE = "NotificationAdapter.clearLive";
+const NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER = "NotificationBacktestAdapter.useNotificationAdapter";
+const NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY = "NotificationBacktestAdapter.useDummy";
+const NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY = "NotificationBacktestAdapter.useMemory";
+const NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST = "NotificationBacktestAdapter.usePersist";
+const NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER = "NotificationLiveAdapter.useNotificationAdapter";
+const NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY = "NotificationLiveAdapter.useDummy";
+const NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY = "NotificationLiveAdapter.useMemory";
+const NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST = "NotificationLiveAdapter.usePersist";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_WAIT_FOR_INIT = "NotificationPersistBacktestUtils.waitForInit";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_UPDATE_NOTIFICATIONS = "NotificationPersistBacktestUtils._updateNotifications";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_SIGNAL = "NotificationPersistBacktestUtils.handleSignal";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_PROFIT = "NotificationPersistBacktestUtils.handlePartialProfit";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_LOSS = "NotificationPersistBacktestUtils.handlePartialLoss";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_BREAKEVEN = "NotificationPersistBacktestUtils.handleBreakeven";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_STRATEGY_COMMIT = "NotificationPersistBacktestUtils.handleStrategyCommit";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_RISK = "NotificationPersistBacktestUtils.handleRisk";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ERROR = "NotificationPersistBacktestUtils.handleError";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_CRITICAL_ERROR = "NotificationPersistBacktestUtils.handleCriticalError";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_VALIDATION_ERROR = "NotificationPersistBacktestUtils.handleValidationError";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_GET_DATA = "NotificationPersistBacktestUtils.getData";
+const NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_CLEAR = "NotificationPersistBacktestUtils.clear";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_WAIT_FOR_INIT = "NotificationPersistLiveUtils.waitForInit";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_UPDATE_NOTIFICATIONS = "NotificationPersistLiveUtils._updateNotifications";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_SIGNAL = "NotificationPersistLiveUtils.handleSignal";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_PARTIAL_PROFIT = "NotificationPersistLiveUtils.handlePartialProfit";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_PARTIAL_LOSS = "NotificationPersistLiveUtils.handlePartialLoss";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_BREAKEVEN = "NotificationPersistLiveUtils.handleBreakeven";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_STRATEGY_COMMIT = "NotificationPersistLiveUtils.handleStrategyCommit";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_RISK = "NotificationPersistLiveUtils.handleRisk";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_ERROR = "NotificationPersistLiveUtils.handleError";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_CRITICAL_ERROR = "NotificationPersistLiveUtils.handleCriticalError";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_VALIDATION_ERROR = "NotificationPersistLiveUtils.handleValidationError";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_GET_DATA = "NotificationPersistLiveUtils.getData";
+const NOTIFICATION_PERSIST_LIVE_METHOD_NAME_CLEAR = "NotificationPersistLiveUtils.clear";
+/**
+ * In-memory notification adapter for backtest signals.
  *
- * @example
- * ```typescript
- * const instance = new ExchangeInstance("binance");
+ * Features:
+ * - Stores notifications in memory only (no persistence)
+ * - Fast read/write operations
+ * - Data is lost when application restarts
+ * - Maintains up to MAX_NOTIFICATIONS (250) most recent notifications
+ * - Handles all notification types: signals, partial profit/loss, breakeven, risk, errors
  *
- * const candles = await instance.getCandles("BTCUSDT", "1m", 100);
- * const vwap = await instance.getAveragePrice("BTCUSDT");
- * const formattedQty = await instance.formatQuantity("BTCUSDT", 0.001);
- * const formattedPrice = await instance.formatPrice("BTCUSDT", 50000.123);
- * ```
+ * Use this adapter for testing or when persistence is not required.
  */
-class ExchangeInstance {
-    /**
-     * Creates a new ExchangeInstance for a specific exchange.
-     *
-     * @param exchangeName - Exchange name (e.g., "binance")
-     */
-    constructor(exchangeName) {
-        this.exchangeName = exchangeName;
+class NotificationMemoryBacktestUtils {
+    constructor() {
+        /** Array of notification models */
+        this._notifications = [];
         /**
-         * Fetch candles from data source (API or database).
-         *
-         * Automatically calculates the start date based on Date.now() and the requested interval/limit.
-         * Uses the same logic as ClientExchange to ensure backwards compatibility.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param interval - Candle time interval (e.g., "1m", "1h")
-         * @param limit - Maximum number of candles to fetch
-         * @returns Promise resolving to array of OHLCV candle data
-         *
-         * @example
-         * ```typescript
-         * const instance = new ExchangeInstance("binance");
-         * const candles = await instance.getCandles("BTCUSDT", "1m", 100);
-         * ```
+         * Handles signal events.
+         * Creates and stores notification for opened, closed, scheduled, cancelled signals.
+         * @param data - The strategy tick result data
          */
-        this.getCandles = async (symbol, interval, limit) => {
-            bt.loggerService.info(EXCHANGE_METHOD_NAME_GET_CANDLES, {
-                exchangeName: this.exchangeName,
-                symbol,
-                interval,
-                limit,
+        this.handleSignal = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_SIGNAL, {
+                signalId: data.signal.id,
+                action: data.action,
             });
-            const getCandles = this._methods.getCandles;
-            const step = INTERVAL_MINUTES$1[interval];
-            if (!step) {
-                throw new Error(`ExchangeInstance unknown interval=${interval}`);
-            }
-            const stepMs = step * MS_PER_MINUTE;
-            // Align when down to interval boundary
-            const when = await GET_TIMESTAMP_FN();
-            const whenTimestamp = when.getTime();
-            const alignedWhen = ALIGN_TO_INTERVAL_FN(whenTimestamp, step);
-            // Calculate since: go back limit candles from aligned when
-            const sinceTimestamp = alignedWhen - limit * stepMs;
-            const since = new Date(sinceTimestamp);
-            const untilTimestamp = alignedWhen;
-            // Try to read from cache first
-            const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit }, sinceTimestamp, untilTimestamp, this.exchangeName);
-            if (cachedCandles !== null) {
-                return cachedCandles;
-            }
-            let allData = [];
-            // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
-            if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
-                let remaining = limit;
-                let currentSince = new Date(since.getTime());
-                const isBacktest = await GET_BACKTEST_FN();
-                while (remaining > 0) {
-                    const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
-                    const chunkData = await getCandles(symbol, interval, currentSince, chunkLimit, isBacktest);
-                    allData.push(...chunkData);
-                    remaining -= chunkLimit;
-                    if (remaining > 0) {
-                        // Move currentSince forward by the number of candles fetched
-                        currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
-                    }
-                }
-            }
-            else {
-                const isBacktest = await GET_BACKTEST_FN();
-                allData = await getCandles(symbol, interval, since, limit, isBacktest);
-            }
-            // Apply distinct by timestamp to remove duplicates
-            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
-            if (allData.length !== uniqueData.length) {
-                bt.loggerService.warn(`ExchangeInstance getCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
-            }
-            // Validate adapter returned data
-            if (uniqueData.length === 0) {
-                throw new Error(`ExchangeInstance getCandles: adapter returned empty array. ` +
-                    `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
-            }
-            if (uniqueData[0].timestamp !== sinceTimestamp) {
-                throw new Error(`ExchangeInstance getCandles: first candle timestamp mismatch. ` +
-                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
-                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
-            }
-            if (uniqueData.length !== limit) {
-                throw new Error(`ExchangeInstance getCandles: candle count mismatch. ` +
-                    `Expected ${limit} candles, got ${uniqueData.length}. ` +
-                    `Adapter must return exact number of candles requested.`);
+            const notification = CREATE_SIGNAL_NOTIFICATION_FN(data);
+            if (notification) {
+                this._addNotification(notification);
             }
-            // Write to cache after successful fetch
-            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit }, this.exchangeName);
-            return uniqueData;
         };
         /**
-         * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
-         * The number of candles is configurable via GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT.
-         *
-         * Formula:
-         * - Typical Price = (high + low + close) / 3
-         * - VWAP = sum(typical_price * volume) / sum(volume)
-         *
-         * If volume is zero, returns simple average of close prices.
-         *
-         * @param symbol - Trading pair symbol
-         * @returns Promise resolving to VWAP price
-         * @throws Error if no candles available
-         *
-         * @example
-         * ```typescript
-         * const instance = new ExchangeInstance("binance");
-         * const vwap = await instance.getAveragePrice("BTCUSDT");
-         * console.log(vwap); // 50125.43
-         * ```
+         * Handles partial profit availability event.
+         * @param data - The partial profit contract data
          */
-        this.getAveragePrice = async (symbol) => {
-            bt.loggerService.debug(`ExchangeInstance getAveragePrice`, {
-                exchangeName: this.exchangeName,
-                symbol,
+        this.handlePartialProfit = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_PROFIT, {
+                signalId: data.data.id,
+                level: data.level,
             });
-            const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
+            this._addNotification(CREATE_PARTIAL_PROFIT_NOTIFICATION_FN(data));
+        };
+        /**
+         * Handles partial loss availability event.
+         * @param data - The partial loss contract data
+         */
+        this.handlePartialLoss = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_LOSS, {
+                signalId: data.data.id,
+                level: data.level,
+            });
+            this._addNotification(CREATE_PARTIAL_LOSS_NOTIFICATION_FN(data));
+        };
+        /**
+         * Handles breakeven availability event.
+         * @param data - The breakeven contract data
+         */
+        this.handleBreakeven = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_BREAKEVEN, {
+                signalId: data.data.id,
+            });
+            this._addNotification(CREATE_BREAKEVEN_NOTIFICATION_FN(data));
+        };
+        /**
+         * Handles strategy commit events.
+         * @param data - The strategy commit contract data
+         */
+        this.handleStrategyCommit = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_STRATEGY_COMMIT, {
+                signalId: data.signalId,
+                action: data.action,
+            });
+            const notification = CREATE_STRATEGY_COMMIT_NOTIFICATION_FN(data);
+            if (notification) {
+                this._addNotification(notification);
+            }
+        };
+        /**
+         * Handles risk rejection event.
+         * @param data - The risk contract data
+         */
+        this.handleRisk = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_RISK, {
+                signalId: data.currentSignal.id,
+                rejectionId: data.rejectionId,
+            });
+            this._addNotification(CREATE_RISK_NOTIFICATION_FN(data));
+        };
+        /**
+         * Handles error event.
+         * @param error - The error object
+         */
+        this.handleError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            this._addNotification(CREATE_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Handles critical error event.
+         * @param error - The error object
+         */
+        this.handleCriticalError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CRITICAL_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            this._addNotification(CREATE_CRITICAL_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Handles validation error event.
+         * @param error - The error object
+         */
+        this.handleValidationError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_VALIDATION_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            this._addNotification(CREATE_VALIDATION_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Gets all stored notifications.
+         * @returns Copy of notifications array
+         */
+        this.getData = async () => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_GET_DATA);
+            return [...this._notifications];
+        };
+        /**
+         * Clears all stored notifications.
+         */
+        this.clear = async () => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_CLEAR);
+            this._notifications = [];
+        };
+    }
+    /**
+     * Adds a notification to the beginning of the list.
+     * Removes oldest notification if limit is exceeded.
+     * @param notification - The notification model to add
+     */
+    _addNotification(notification) {
+        this._notifications.unshift(notification);
+        if (this._notifications.length > MAX_NOTIFICATIONS) {
+            this._notifications.pop();
+        }
+    }
+}
+/**
+ * Dummy notification adapter for backtest signals that discards all writes.
+ *
+ * Features:
+ * - No-op implementation for all methods
+ * - getData always returns empty array
+ *
+ * Use this adapter to disable backtest notification storage completely.
+ */
+class NotificationDummyBacktestUtils {
+    constructor() {
+        /**
+         * No-op handler for signal events.
+         */
+        this.handleSignal = async () => {
+        };
+        /**
+         * No-op handler for partial profit event.
+         */
+        this.handlePartialProfit = async () => {
+        };
+        /**
+         * No-op handler for partial loss event.
+         */
+        this.handlePartialLoss = async () => {
+        };
+        /**
+         * No-op handler for breakeven event.
+         */
+        this.handleBreakeven = async () => {
+        };
+        /**
+         * No-op handler for strategy commit event.
+         */
+        this.handleStrategyCommit = async () => {
+        };
+        /**
+         * No-op handler for risk rejection event.
+         */
+        this.handleRisk = async () => {
+        };
+        /**
+         * No-op handler for error event.
+         */
+        this.handleError = async () => {
+        };
+        /**
+         * No-op handler for critical error event.
+         */
+        this.handleCriticalError = async () => {
+        };
+        /**
+         * No-op handler for validation error event.
+         */
+        this.handleValidationError = async () => {
+        };
+        /**
+         * Always returns empty array (no storage).
+         * @returns Empty array
+         */
+        this.getData = async () => {
+            return [];
+        };
+        /**
+         * No-op clear operation.
+         */
+        this.clear = async () => {
+        };
+    }
+}
+/**
+ * Persistent notification adapter for backtest signals.
+ *
+ * Features:
+ * - Persists notifications to disk using PersistNotificationAdapter
+ * - Lazy initialization with singleshot pattern
+ * - Maintains up to MAX_NOTIFICATIONS (250) most recent notifications
+ * - Handles all notification types: signals, partial profit/loss, breakeven, risk, errors
+ *
+ * Use this adapter (default) for backtest notification persistence across sessions.
+ */
+class NotificationPersistBacktestUtils {
+    constructor() {
+        /**
+         * Singleshot initialization function that loads notifications from disk.
+         * Protected by singleshot to ensure one-time execution.
+         */
+        this.waitForInit = functoolsKit.singleshot(async () => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_WAIT_FOR_INIT);
+            const notificationList = await PersistNotificationAdapter.readNotificationData(true);
+            notificationList.sort((a, b) => {
+                const aTime = 'createdAt' in a ? a.createdAt : 0;
+                const bTime = 'createdAt' in b ? b.createdAt : 0;
+                return aTime - bTime;
+            });
+            this._notifications = new Map(notificationList
+                .slice(-MAX_NOTIFICATIONS)
+                .map((notification) => [notification.id, notification]));
+        });
+        /**
+         * Handles signal events.
+         * Creates and stores notification for opened, closed, scheduled, cancelled signals.
+         * @param data - The strategy tick result data
+         */
+        this.handleSignal = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_SIGNAL, {
+                signalId: data.signal.id,
+                action: data.action,
+            });
+            await this.waitForInit();
+            const notification = CREATE_SIGNAL_NOTIFICATION_FN(data);
+            if (notification) {
+                this._addNotification(notification);
+                await this._updateNotifications();
+            }
+        };
+        /**
+         * Handles partial profit availability event.
+         * @param data - The partial profit contract data
+         */
+        this.handlePartialProfit = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_PROFIT, {
+                signalId: data.data.id,
+                level: data.level,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_PARTIAL_PROFIT_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        };
+        /**
+         * Handles partial loss availability event.
+         * @param data - The partial loss contract data
+         */
+        this.handlePartialLoss = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_PARTIAL_LOSS, {
+                signalId: data.data.id,
+                level: data.level,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_PARTIAL_LOSS_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        };
+        /**
+         * Handles breakeven availability event.
+         * @param data - The breakeven contract data
+         */
+        this.handleBreakeven = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_BREAKEVEN, {
+                signalId: data.data.id,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_BREAKEVEN_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        };
+        /**
+         * Handles strategy commit events.
+         * @param data - The strategy commit contract data
+         */
+        this.handleStrategyCommit = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_STRATEGY_COMMIT, {
+                signalId: data.signalId,
+                action: data.action,
+            });
+            await this.waitForInit();
+            const notification = CREATE_STRATEGY_COMMIT_NOTIFICATION_FN(data);
+            if (notification) {
+                this._addNotification(notification);
+                await this._updateNotifications();
+            }
+        };
+        /**
+         * Handles risk rejection event.
+         * @param data - The risk contract data
+         */
+        this.handleRisk = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_RISK, {
+                signalId: data.currentSignal.id,
+                rejectionId: data.rejectionId,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_RISK_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        };
+        /**
+         * Handles error event.
+         * Note: Error notifications are not persisted to disk.
+         * @param error - The error object
+         */
+        this.handleError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Handles critical error event.
+         * Note: Error notifications are not persisted to disk.
+         * @param error - The error object
+         */
+        this.handleCriticalError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_CRITICAL_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_CRITICAL_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Handles validation error event.
+         * Note: Error notifications are not persisted to disk.
+         * @param error - The error object
+         */
+        this.handleValidationError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_VALIDATION_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_VALIDATION_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Gets all stored notifications.
+         * @returns Array of all notification models
+         */
+        this.getData = async () => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_GET_DATA);
+            await this.waitForInit();
+            return Array.from(this._notifications.values());
+        };
+        /**
+         * Clears all stored notifications.
+         */
+        this.clear = async () => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_CLEAR);
+            await this.waitForInit();
+            this._notifications.clear();
+            await this._updateNotifications();
+        };
+    }
+    /**
+     * Persists the current notification map to disk storage.
+     * Sorts notifications by createdAt and keeps only the most recent MAX_NOTIFICATIONS.
+     * @throws Error if not initialized
+     */
+    async _updateNotifications() {
+        bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_UPDATE_NOTIFICATIONS);
+        if (!this._notifications) {
+            throw new Error("NotificationPersistBacktestUtils not initialized. Call waitForInit first.");
+        }
+        const notificationList = Array.from(this._notifications.values());
+        notificationList.sort((a, b) => {
+            const aTime = 'createdAt' in a ? a.createdAt : 0;
+            const bTime = 'createdAt' in b ? b.createdAt : 0;
+            return aTime - bTime;
+        });
+        await PersistNotificationAdapter.writeNotificationData(notificationList.slice(-MAX_NOTIFICATIONS), true);
+    }
+    /**
+     * Adds a notification to the map.
+     * Removes oldest notification if limit is exceeded.
+     * @param notification - The notification model to add
+     */
+    _addNotification(notification) {
+        this._notifications.set(notification.id, notification);
+        if (this._notifications.size > MAX_NOTIFICATIONS) {
+            const firstKey = this._notifications.keys().next().value;
+            if (firstKey) {
+                this._notifications.delete(firstKey);
+            }
+        }
+    }
+}
+/**
+ * In-memory notification adapter for live trading signals.
+ *
+ * Features:
+ * - Stores notifications in memory only (no persistence)
+ * - Fast read/write operations
+ * - Data is lost when application restarts
+ * - Maintains up to MAX_NOTIFICATIONS (250) most recent notifications
+ * - Handles all notification types: signals, partial profit/loss, breakeven, risk, errors
+ *
+ * Use this adapter for testing or when persistence is not required.
+ */
+class NotificationMemoryLiveUtils {
+    constructor() {
+        /** Array of notification models */
+        this._notifications = [];
+        /**
+         * Handles signal events.
+         * Creates and stores notification for opened, closed, scheduled, cancelled signals.
+         * @param data - The strategy tick result data
+         */
+        this.handleSignal = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_SIGNAL, {
+                signalId: data.signal.id,
+                action: data.action,
+            });
+            const notification = CREATE_SIGNAL_NOTIFICATION_FN(data);
+            if (notification) {
+                this._addNotification(notification);
+            }
+        };
+        /**
+         * Handles partial profit availability event.
+         * @param data - The partial profit contract data
+         */
+        this.handlePartialProfit = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_PARTIAL_PROFIT, {
+                signalId: data.data.id,
+                level: data.level,
+            });
+            this._addNotification(CREATE_PARTIAL_PROFIT_NOTIFICATION_FN(data));
+        };
+        /**
+         * Handles partial loss availability event.
+         * @param data - The partial loss contract data
+         */
+        this.handlePartialLoss = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_PARTIAL_LOSS, {
+                signalId: data.data.id,
+                level: data.level,
+            });
+            this._addNotification(CREATE_PARTIAL_LOSS_NOTIFICATION_FN(data));
+        };
+        /**
+         * Handles breakeven availability event.
+         * @param data - The breakeven contract data
+         */
+        this.handleBreakeven = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_BREAKEVEN, {
+                signalId: data.data.id,
+            });
+            this._addNotification(CREATE_BREAKEVEN_NOTIFICATION_FN(data));
+        };
+        /**
+         * Handles strategy commit events.
+         * @param data - The strategy commit contract data
+         */
+        this.handleStrategyCommit = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_STRATEGY_COMMIT, {
+                signalId: data.signalId,
+                action: data.action,
+            });
+            const notification = CREATE_STRATEGY_COMMIT_NOTIFICATION_FN(data);
+            if (notification) {
+                this._addNotification(notification);
+            }
+        };
+        /**
+         * Handles risk rejection event.
+         * @param data - The risk contract data
+         */
+        this.handleRisk = async (data) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_RISK, {
+                signalId: data.currentSignal.id,
+                rejectionId: data.rejectionId,
+            });
+            this._addNotification(CREATE_RISK_NOTIFICATION_FN(data));
+        };
+        /**
+         * Handles error event.
+         * @param error - The error object
+         */
+        this.handleError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            this._addNotification(CREATE_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Handles critical error event.
+         * @param error - The error object
+         */
+        this.handleCriticalError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_CRITICAL_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            this._addNotification(CREATE_CRITICAL_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Handles validation error event.
+         * @param error - The error object
+         */
+        this.handleValidationError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_VALIDATION_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            this._addNotification(CREATE_VALIDATION_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Gets all stored notifications.
+         * @returns Copy of notifications array
+         */
+        this.getData = async () => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_GET_DATA);
+            return [...this._notifications];
+        };
+        /**
+         * Clears all stored notifications.
+         */
+        this.clear = async () => {
+            bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_CLEAR);
+            this._notifications = [];
+        };
+    }
+    /**
+     * Adds a notification to the beginning of the list.
+     * Removes oldest notification if limit is exceeded.
+     * @param notification - The notification model to add
+     */
+    _addNotification(notification) {
+        this._notifications.unshift(notification);
+        if (this._notifications.length > MAX_NOTIFICATIONS) {
+            this._notifications.pop();
+        }
+    }
+}
+/**
+ * Dummy notification adapter for live trading signals that discards all writes.
+ *
+ * Features:
+ * - No-op implementation for all methods
+ * - getData always returns empty array
+ *
+ * Use this adapter to disable live notification storage completely.
+ */
+class NotificationDummyLiveUtils {
+    constructor() {
+        /**
+         * No-op handler for signal events.
+         */
+        this.handleSignal = async () => {
+        };
+        /**
+         * No-op handler for partial profit event.
+         */
+        this.handlePartialProfit = async () => {
+        };
+        /**
+         * No-op handler for partial loss event.
+         */
+        this.handlePartialLoss = async () => {
+        };
+        /**
+         * No-op handler for breakeven event.
+         */
+        this.handleBreakeven = async () => {
+        };
+        /**
+         * No-op handler for strategy commit event.
+         */
+        this.handleStrategyCommit = async () => {
+        };
+        /**
+         * No-op handler for risk rejection event.
+         */
+        this.handleRisk = async () => {
+        };
+        /**
+         * No-op handler for error event.
+         */
+        this.handleError = async () => {
+        };
+        /**
+         * No-op handler for critical error event.
+         */
+        this.handleCriticalError = async () => {
+        };
+        /**
+         * No-op handler for validation error event.
+         */
+        this.handleValidationError = async () => {
+        };
+        /**
+         * Always returns empty array (no storage).
+         * @returns Empty array
+         */
+        this.getData = async () => {
+            return [];
+        };
+        /**
+         * No-op clear operation.
+         */
+        this.clear = async () => {
+        };
+    }
+}
+/**
+ * Persistent notification adapter for live trading signals.
+ *
+ * Features:
+ * - Persists notifications to disk using PersistNotificationAdapter
+ * - Lazy initialization with singleshot pattern
+ * - Maintains up to MAX_NOTIFICATIONS (250) most recent notifications
+ * - Filters out error notifications when persisting to disk
+ * - Handles all notification types: signals, partial profit/loss, breakeven, risk, errors
+ *
+ * Use this adapter (default) for live notification persistence across sessions.
+ */
+class NotificationPersistLiveUtils {
+    constructor() {
+        /**
+         * Singleshot initialization function that loads notifications from disk.
+         * Protected by singleshot to ensure one-time execution.
+         */
+        this.waitForInit = functoolsKit.singleshot(async () => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_WAIT_FOR_INIT);
+            const notificationList = await PersistNotificationAdapter.readNotificationData(false);
+            notificationList.sort((a, b) => {
+                const aTime = 'createdAt' in a ? a.createdAt : 0;
+                const bTime = 'createdAt' in b ? b.createdAt : 0;
+                return aTime - bTime;
+            });
+            this._notifications = new Map(notificationList
+                .slice(-MAX_NOTIFICATIONS)
+                .map((notification) => [notification.id, notification]));
+        });
+        /**
+         * Handles signal events.
+         * Creates and stores notification for opened, closed, scheduled, cancelled signals.
+         * @param data - The strategy tick result data
+         */
+        this.handleSignal = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_SIGNAL, {
+                signalId: data.signal.id,
+                action: data.action,
+            });
+            await this.waitForInit();
+            const notification = CREATE_SIGNAL_NOTIFICATION_FN(data);
+            if (notification) {
+                this._addNotification(notification);
+                await this._updateNotifications();
+            }
+        };
+        /**
+         * Handles partial profit availability event.
+         * @param data - The partial profit contract data
+         */
+        this.handlePartialProfit = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_PARTIAL_PROFIT, {
+                signalId: data.data.id,
+                level: data.level,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_PARTIAL_PROFIT_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        };
+        /**
+         * Handles partial loss availability event.
+         * @param data - The partial loss contract data
+         */
+        this.handlePartialLoss = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_PARTIAL_LOSS, {
+                signalId: data.data.id,
+                level: data.level,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_PARTIAL_LOSS_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        };
+        /**
+         * Handles breakeven availability event.
+         * @param data - The breakeven contract data
+         */
+        this.handleBreakeven = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_BREAKEVEN, {
+                signalId: data.data.id,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_BREAKEVEN_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        };
+        /**
+         * Handles strategy commit events.
+         * @param data - The strategy commit contract data
+         */
+        this.handleStrategyCommit = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_STRATEGY_COMMIT, {
+                signalId: data.signalId,
+                action: data.action,
+            });
+            await this.waitForInit();
+            const notification = CREATE_STRATEGY_COMMIT_NOTIFICATION_FN(data);
+            if (notification) {
+                this._addNotification(notification);
+                await this._updateNotifications();
+            }
+        };
+        /**
+         * Handles risk rejection event.
+         * @param data - The risk contract data
+         */
+        this.handleRisk = async (data) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_RISK, {
+                signalId: data.currentSignal.id,
+                rejectionId: data.rejectionId,
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_RISK_NOTIFICATION_FN(data));
+            await this._updateNotifications();
+        };
+        /**
+         * Handles error event.
+         * Note: Error notifications are not persisted to disk.
+         * @param error - The error object
+         */
+        this.handleError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Handles critical error event.
+         * Note: Error notifications are not persisted to disk.
+         * @param error - The error object
+         */
+        this.handleCriticalError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_CRITICAL_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_CRITICAL_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Handles validation error event.
+         * Note: Error notifications are not persisted to disk.
+         * @param error - The error object
+         */
+        this.handleValidationError = async (error) => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_VALIDATION_ERROR, {
+                message: functoolsKit.getErrorMessage(error),
+            });
+            await this.waitForInit();
+            this._addNotification(CREATE_VALIDATION_ERROR_NOTIFICATION_FN(error));
+        };
+        /**
+         * Gets all stored notifications.
+         * @returns Array of all notification models
+         */
+        this.getData = async () => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_GET_DATA);
+            await this.waitForInit();
+            return Array.from(this._notifications.values());
+        };
+        /**
+         * Clears all stored notifications.
+         */
+        this.clear = async () => {
+            bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_CLEAR);
+            await this.waitForInit();
+            this._notifications.clear();
+            await this._updateNotifications();
+        };
+    }
+    /**
+     * Persists the current notification map to disk storage.
+     * Filters out error notifications and sorts by createdAt.
+     * Keeps only the most recent MAX_NOTIFICATIONS.
+     * @throws Error if not initialized
+     */
+    async _updateNotifications() {
+        bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_UPDATE_NOTIFICATIONS);
+        if (!this._notifications) {
+            throw new Error("NotificationPersistLiveUtils not initialized. Call waitForInit first.");
+        }
+        const notificationList = Array.from(this._notifications.values())
+            .filter(({ type }) => !type.startsWith("error."));
+        notificationList.sort((a, b) => {
+            const aTime = 'createdAt' in a ? a.createdAt : 0;
+            const bTime = 'createdAt' in b ? b.createdAt : 0;
+            return aTime - bTime;
+        });
+        await PersistNotificationAdapter.writeNotificationData(notificationList.slice(-MAX_NOTIFICATIONS), false);
+    }
+    /**
+     * Adds a notification to the map.
+     * Removes oldest notification if limit is exceeded.
+     * @param notification - The notification model to add
+     */
+    _addNotification(notification) {
+        this._notifications.set(notification.id, notification);
+        if (this._notifications.size > MAX_NOTIFICATIONS) {
+            const firstKey = this._notifications.keys().next().value;
+            if (firstKey) {
+                this._notifications.delete(firstKey);
+            }
+        }
+    }
+}
+/**
+ * Backtest notification adapter with pluggable notification backend.
+ *
+ * Features:
+ * - Adapter pattern for swappable notification implementations
+ * - Default adapter: NotificationMemoryBacktestUtils (in-memory storage)
+ * - Alternative adapters: NotificationPersistBacktestUtils, NotificationDummyBacktestUtils
+ * - Convenience methods: usePersist(), useMemory(), useDummy()
+ */
+class NotificationBacktestAdapter {
+    constructor() {
+        /** Internal notification utils instance */
+        this._notificationBacktestUtils = new NotificationMemoryBacktestUtils();
+        /**
+         * Handles signal events.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The strategy tick result data
+         */
+        this.handleSignal = async (data) => {
+            return await this._notificationBacktestUtils.handleSignal(data);
+        };
+        /**
+         * Handles partial profit availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The partial profit contract data
+         */
+        this.handlePartialProfit = async (data) => {
+            return await this._notificationBacktestUtils.handlePartialProfit(data);
+        };
+        /**
+         * Handles partial loss availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The partial loss contract data
+         */
+        this.handlePartialLoss = async (data) => {
+            return await this._notificationBacktestUtils.handlePartialLoss(data);
+        };
+        /**
+         * Handles breakeven availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The breakeven contract data
+         */
+        this.handleBreakeven = async (data) => {
+            return await this._notificationBacktestUtils.handleBreakeven(data);
+        };
+        /**
+         * Handles strategy commit events.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The strategy commit contract data
+         */
+        this.handleStrategyCommit = async (data) => {
+            return await this._notificationBacktestUtils.handleStrategyCommit(data);
+        };
+        /**
+         * Handles risk rejection event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The risk contract data
+         */
+        this.handleRisk = async (data) => {
+            return await this._notificationBacktestUtils.handleRisk(data);
+        };
+        /**
+         * Handles error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
+         */
+        this.handleError = async (error) => {
+            return await this._notificationBacktestUtils.handleError(error);
+        };
+        /**
+         * Handles critical error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
+         */
+        this.handleCriticalError = async (error) => {
+            return await this._notificationBacktestUtils.handleCriticalError(error);
+        };
+        /**
+         * Handles validation error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
+         */
+        this.handleValidationError = async (error) => {
+            return await this._notificationBacktestUtils.handleValidationError(error);
+        };
+        /**
+         * Gets all stored notifications.
+         * Proxies call to the underlying notification adapter.
+         * @returns Array of all notification models
+         */
+        this.getData = async () => {
+            return await this._notificationBacktestUtils.getData();
+        };
+        /**
+         * Clears all stored notifications.
+         * Proxies call to the underlying notification adapter.
+         */
+        this.clear = async () => {
+            return await this._notificationBacktestUtils.clear();
+        };
+        /**
+         * Sets the notification adapter constructor.
+         * All future notification operations will use this adapter.
+         *
+         * @param Ctor - Constructor for notification adapter
+         */
+        this.useNotificationAdapter = (Ctor) => {
+            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._notificationBacktestUtils = Reflect.construct(Ctor, []);
+        };
+        /**
+         * Switches to dummy notification adapter.
+         * All future notification writes will be no-ops.
+         */
+        this.useDummy = () => {
+            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY);
+            this._notificationBacktestUtils = new NotificationDummyBacktestUtils();
+        };
+        /**
+         * Switches to in-memory notification adapter (default).
+         * Notifications will be stored in memory only.
+         */
+        this.useMemory = () => {
+            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._notificationBacktestUtils = new NotificationMemoryBacktestUtils();
+        };
+        /**
+         * Switches to persistent notification adapter.
+         * Notifications will be persisted to disk.
+         */
+        this.usePersist = () => {
+            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._notificationBacktestUtils = new NotificationPersistBacktestUtils();
+        };
+    }
+}
+/**
+ * Live trading notification adapter with pluggable notification backend.
+ *
+ * Features:
+ * - Adapter pattern for swappable notification implementations
+ * - Default adapter: NotificationMemoryLiveUtils (in-memory storage)
+ * - Alternative adapters: NotificationPersistLiveUtils, NotificationDummyLiveUtils
+ * - Convenience methods: usePersist(), useMemory(), useDummy()
+ */
+class NotificationLiveAdapter {
+    constructor() {
+        /** Internal notification utils instance */
+        this._notificationLiveUtils = new NotificationMemoryLiveUtils();
+        /**
+         * Handles signal events.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The strategy tick result data
+         */
+        this.handleSignal = async (data) => {
+            return await this._notificationLiveUtils.handleSignal(data);
+        };
+        /**
+         * Handles partial profit availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The partial profit contract data
+         */
+        this.handlePartialProfit = async (data) => {
+            return await this._notificationLiveUtils.handlePartialProfit(data);
+        };
+        /**
+         * Handles partial loss availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The partial loss contract data
+         */
+        this.handlePartialLoss = async (data) => {
+            return await this._notificationLiveUtils.handlePartialLoss(data);
+        };
+        /**
+         * Handles breakeven availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The breakeven contract data
+         */
+        this.handleBreakeven = async (data) => {
+            return await this._notificationLiveUtils.handleBreakeven(data);
+        };
+        /**
+         * Handles strategy commit events.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The strategy commit contract data
+         */
+        this.handleStrategyCommit = async (data) => {
+            return await this._notificationLiveUtils.handleStrategyCommit(data);
+        };
+        /**
+         * Handles risk rejection event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The risk contract data
+         */
+        this.handleRisk = async (data) => {
+            return await this._notificationLiveUtils.handleRisk(data);
+        };
+        /**
+         * Handles error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
+         */
+        this.handleError = async (error) => {
+            return await this._notificationLiveUtils.handleError(error);
+        };
+        /**
+         * Handles critical error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
+         */
+        this.handleCriticalError = async (error) => {
+            return await this._notificationLiveUtils.handleCriticalError(error);
+        };
+        /**
+         * Handles validation error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
+         */
+        this.handleValidationError = async (error) => {
+            return await this._notificationLiveUtils.handleValidationError(error);
+        };
+        /**
+         * Gets all stored notifications.
+         * Proxies call to the underlying notification adapter.
+         * @returns Array of all notification models
+         */
+        this.getData = async () => {
+            return await this._notificationLiveUtils.getData();
+        };
+        /**
+         * Clears all stored notifications.
+         * Proxies call to the underlying notification adapter.
+         */
+        this.clear = async () => {
+            return await this._notificationLiveUtils.clear();
+        };
+        /**
+         * Sets the notification adapter constructor.
+         * All future notification operations will use this adapter.
+         *
+         * @param Ctor - Constructor for notification adapter
+         */
+        this.useNotificationAdapter = (Ctor) => {
+            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._notificationLiveUtils = Reflect.construct(Ctor, []);
+        };
+        /**
+         * Switches to dummy notification adapter.
+         * All future notification writes will be no-ops.
+         */
+        this.useDummy = () => {
+            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY);
+            this._notificationLiveUtils = new NotificationDummyLiveUtils();
+        };
+        /**
+         * Switches to in-memory notification adapter (default).
+         * Notifications will be stored in memory only.
+         */
+        this.useMemory = () => {
+            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._notificationLiveUtils = new NotificationMemoryLiveUtils();
+        };
+        /**
+         * Switches to persistent notification adapter.
+         * Notifications will be persisted to disk.
+         */
+        this.usePersist = () => {
+            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._notificationLiveUtils = new NotificationPersistLiveUtils();
+        };
+    }
+}
+/**
+ * Main notification adapter that manages both backtest and live notification storage.
+ *
+ * Features:
+ * - Subscribes to signal emitters for automatic notification updates
+ * - Provides unified access to both backtest and live notifications
+ * - Singleshot enable pattern prevents duplicate subscriptions
+ * - Cleanup function for proper unsubscription
+ */
+class NotificationAdapter {
+    constructor() {
+        /**
+         * Enables notification storage by subscribing to signal emitters.
+         * Uses singleshot to ensure one-time subscription.
+         *
+         * @returns Cleanup function that unsubscribes from all emitters
+         */
+        this.enable = functoolsKit.singleshot(() => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_ENABLE);
+            let unLive;
+            let unBacktest;
+            {
+                const unBacktestSignal = signalBacktestEmitter.subscribe((data) => NotificationBacktest.handleSignal(data));
+                const unBacktestPartialProfit = partialProfitSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handlePartialProfit(data));
+                const unBacktestPartialLoss = partialLossSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handlePartialLoss(data));
+                const unBacktestBreakeven = breakevenSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handleBreakeven(data));
+                const unBacktestStrategyCommit = strategyCommitSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handleStrategyCommit(data));
+                const unBacktestRisk = riskSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handleRisk(data));
+                const unBacktestError = errorEmitter.subscribe((error) => NotificationBacktest.handleError(error));
+                const unBacktestExit = exitEmitter.subscribe((error) => NotificationBacktest.handleCriticalError(error));
+                const unBacktestValidation = validationSubject.subscribe((error) => NotificationBacktest.handleValidationError(error));
+                unBacktest = functoolsKit.compose(() => unBacktestSignal(), () => unBacktestPartialProfit(), () => unBacktestPartialLoss(), () => unBacktestBreakeven(), () => unBacktestStrategyCommit(), () => unBacktestRisk(), () => unBacktestError(), () => unBacktestExit(), () => unBacktestValidation());
+            }
+            {
+                const unLiveSignal = signalLiveEmitter.subscribe((data) => NotificationLive.handleSignal(data));
+                const unLivePartialProfit = partialProfitSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handlePartialProfit(data));
+                const unLivePartialLoss = partialLossSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handlePartialLoss(data));
+                const unLiveBreakeven = breakevenSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handleBreakeven(data));
+                const unLiveStrategyCommit = strategyCommitSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handleStrategyCommit(data));
+                const unLiveRisk = riskSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handleRisk(data));
+                const unLiveError = errorEmitter.subscribe((error) => NotificationLive.handleError(error));
+                const unLiveExit = exitEmitter.subscribe((error) => NotificationLive.handleCriticalError(error));
+                const unLiveValidation = validationSubject.subscribe((error) => NotificationLive.handleValidationError(error));
+                unLive = functoolsKit.compose(() => unLiveSignal(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation());
+            }
+            return () => {
+                unLive();
+                unBacktest();
+                this.enable.clear();
+            };
+        });
+        /**
+         * Disables notification storage by unsubscribing from all emitters.
+         * Safe to call multiple times.
+         */
+        this.disable = () => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_DISABLE);
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+        /**
+         * Gets all backtest notifications from storage.
+         *
+         * @returns Array of all backtest notification models
+         * @throws Error if NotificationAdapter is not enabled
+         */
+        this.getDataBacktest = async () => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_GET_DATA_BACKTEST);
+            if (!this.enable.hasValue()) {
+                throw new Error("NotificationAdapter is not enabled. Call enable() first.");
+            }
+            return await NotificationBacktest.getData();
+        };
+        /**
+         * Gets all live notifications from storage.
+         *
+         * @returns Array of all live notification models
+         * @throws Error if NotificationAdapter is not enabled
+         */
+        this.getDataLive = async () => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_GET_DATA_LIVE);
+            if (!this.enable.hasValue()) {
+                throw new Error("NotificationAdapter is not enabled. Call enable() first.");
+            }
+            return await NotificationLive.getData();
+        };
+        /**
+         * Clears all backtest notifications from storage.
+         *
+         * @throws Error if NotificationAdapter is not enabled
+         */
+        this.clearBacktest = async () => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_CLEAR_BACKTEST);
+            if (!this.enable.hasValue()) {
+                throw new Error("NotificationAdapter is not enabled. Call enable() first.");
+            }
+            return await NotificationBacktest.clear();
+        };
+        /**
+         * Clears all live notifications from storage.
+         *
+         * @throws Error if NotificationAdapter is not enabled
+         */
+        this.clearLive = async () => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_CLEAR_LIVE);
+            if (!this.enable.hasValue()) {
+                throw new Error("NotificationAdapter is not enabled. Call enable() first.");
+            }
+            return await NotificationLive.clear();
+        };
+    }
+}
+/**
+ * Global singleton instance of NotificationAdapter.
+ * Provides unified notification management for backtest and live trading.
+ */
+const Notification = new NotificationAdapter();
+/**
+ * Global singleton instance of NotificationLiveAdapter.
+ * Provides live trading notification storage with pluggable backends.
+ */
+const NotificationLive = new NotificationLiveAdapter();
+/**
+ * Global singleton instance of NotificationBacktestAdapter.
+ * Provides backtest notification storage with pluggable backends.
+ */
+const NotificationBacktest = new NotificationBacktestAdapter();
+
+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";
+const EXCHANGE_METHOD_NAME_FORMAT_PRICE = "ExchangeUtils.formatPrice";
+const EXCHANGE_METHOD_NAME_GET_ORDER_BOOK = "ExchangeUtils.getOrderBook";
+const EXCHANGE_METHOD_NAME_GET_RAW_CANDLES = "ExchangeUtils.getRawCandles";
+const MS_PER_MINUTE = 60000;
+/**
+ * Gets current timestamp from execution context if available.
+ * Returns current Date() if no execution context exists (non-trading GUI).
+ */
+const GET_TIMESTAMP_FN = async () => {
+    if (ExecutionContextService.hasContext()) {
+        return new Date(bt.executionContextService.context.when);
+    }
+    return new Date();
+};
+/**
+ * Gets backtest mode flag from execution context if available.
+ * Returns false if no execution context exists (live mode).
+ */
+const GET_BACKTEST_FN = async () => {
+    if (ExecutionContextService.hasContext()) {
+        return bt.executionContextService.context.backtest;
+    }
+    return false;
+};
+/**
+ * Default implementation for getCandles.
+ * Throws an error indicating the method is not implemented.
+ */
+const DEFAULT_GET_CANDLES_FN = async (_symbol, _interval, _since, _limit, _backtest) => {
+    throw new Error(`getCandles is not implemented for this exchange`);
+};
+/**
+ * Default implementation for formatQuantity.
+ * Returns Bitcoin precision on Binance (8 decimal places).
+ */
+const DEFAULT_FORMAT_QUANTITY_FN = async (_symbol, quantity, _backtest) => {
+    return quantity.toFixed(8);
+};
+/**
+ * Default implementation for formatPrice.
+ * Returns Bitcoin precision on Binance (2 decimal places).
+ */
+const DEFAULT_FORMAT_PRICE_FN = async (_symbol, price, _backtest) => {
+    return price.toFixed(2);
+};
+/**
+ * Default implementation for getOrderBook.
+ * Throws an error indicating the method is not implemented.
+ *
+ * @param _symbol - Trading pair symbol (unused)
+ * @param _depth - Maximum depth levels (unused)
+ * @param _from - Start of time range (unused - can be ignored in live implementations)
+ * @param _to - End of time range (unused - can be ignored in live implementations)
+ * @param _backtest - Whether running in backtest mode (unused)
+ */
+const DEFAULT_GET_ORDER_BOOK_FN = async (_symbol, _depth, _from, _to, _backtest) => {
+    throw new Error(`getOrderBook is not implemented for this exchange`);
+};
+const INTERVAL_MINUTES$1 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+};
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
+ *
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
+ *
+ * @param timestamp - Timestamp in milliseconds
+ * @param intervalMinutes - Interval in minutes
+ * @returns Aligned timestamp rounded down to interval boundary
+ */
+const ALIGN_TO_INTERVAL_FN = (timestamp, intervalMinutes) => {
+    const intervalMs = intervalMinutes * MS_PER_MINUTE;
+    return Math.floor(timestamp / intervalMs) * intervalMs;
+};
+/**
+ * Creates exchange instance with methods resolved once during construction.
+ * Applies default implementations where schema methods are not provided.
+ *
+ * @param schema - Exchange schema from registry
+ * @returns Object with resolved exchange methods
+ */
+const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
+    const getCandles = schema.getCandles ?? DEFAULT_GET_CANDLES_FN;
+    const formatQuantity = schema.formatQuantity ?? DEFAULT_FORMAT_QUANTITY_FN;
+    const formatPrice = schema.formatPrice ?? DEFAULT_FORMAT_PRICE_FN;
+    const getOrderBook = schema.getOrderBook ?? DEFAULT_GET_ORDER_BOOK_FN;
+    return {
+        getCandles,
+        formatQuantity,
+        formatPrice,
+        getOrderBook,
+    };
+};
+/**
+ * Attempts to read candles from cache.
+ *
+ * Cache lookup calculates expected timestamps:
+ * sinceTimestamp + i * stepMs for i = 0..limit-1
+ * Returns all candles if found, null if any missing.
+ *
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+ * @param untilTimestamp - Unused, kept for API compatibility
+ * @param exchangeName - Exchange name
+ * @returns Cached candles array (exactly limit) or null if cache miss
+ */
+const READ_CANDLES_CACHE_FN = functoolsKit.trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
+    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
+    // sinceTimestamp + i * stepMs for i = 0..limit-1
+    // Returns all candles if found, null if any missing
+    const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
+    // Return cached data only if we have exactly the requested limit
+    if (cachedCandles?.length === dto.limit) {
+        bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+        return cachedCandles;
+    }
+    bt.loggerService.warn(`ExchangeInstance READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+    return null;
+}, {
+    fallback: async (error) => {
+        const message = `ExchangeInstance READ_CANDLES_CACHE_FN: cache read failed`;
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Writes candles to cache with error handling.
+ *
+ * The candles passed to this function should be validated:
+ * - First candle.timestamp equals aligned sinceTimestamp (openTime)
+ * - Exact number of candles as requested (limit)
+ * - Sequential timestamps: sinceTimestamp + i * stepMs
+ *
+ * @param candles - Array of validated candle data to cache
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param exchangeName - Exchange name
+ */
+const WRITE_CANDLES_CACHE_FN = functoolsKit.trycatch(functoolsKit.queued(async (candles, dto, exchangeName) => {
+    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, exchangeName);
+    bt.loggerService.debug(`ExchangeInstance WRITE_CANDLES_CACHE_FN: cache updated for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
+}), {
+    fallback: async (error) => {
+        const message = `ExchangeInstance WRITE_CANDLES_CACHE_FN: cache write failed`;
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Instance class for exchange operations on a specific exchange.
+ *
+ * Provides isolated exchange operations for a single exchange.
+ * Each instance maintains its own context and exposes IExchangeSchema methods.
+ * The schema is retrieved once during construction for better performance.
+ *
+ * @example
+ * ```typescript
+ * const instance = new ExchangeInstance("binance");
+ *
+ * const candles = await instance.getCandles("BTCUSDT", "1m", 100);
+ * const vwap = await instance.getAveragePrice("BTCUSDT");
+ * const formattedQty = await instance.formatQuantity("BTCUSDT", 0.001);
+ * const formattedPrice = await instance.formatPrice("BTCUSDT", 50000.123);
+ * ```
+ */
+class ExchangeInstance {
+    /**
+     * Creates a new ExchangeInstance for a specific exchange.
+     *
+     * @param exchangeName - Exchange name (e.g., "binance")
+     */
+    constructor(exchangeName) {
+        this.exchangeName = exchangeName;
+        /**
+         * Fetch candles from data source (API or database).
+         *
+         * Automatically calculates the start date based on Date.now() and the requested interval/limit.
+         * Uses the same logic as ClientExchange to ensure backwards compatibility.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle time interval (e.g., "1m", "1h")
+         * @param limit - Maximum number of candles to fetch
+         * @returns Promise resolving to array of OHLCV candle data
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const candles = await instance.getCandles("BTCUSDT", "1m", 100);
+         * ```
+         */
+        this.getCandles = async (symbol, interval, limit) => {
+            bt.loggerService.info(EXCHANGE_METHOD_NAME_GET_CANDLES, {
+                exchangeName: this.exchangeName,
+                symbol,
+                interval,
+                limit,
+            });
+            const getCandles = this._methods.getCandles;
+            const step = INTERVAL_MINUTES$1[interval];
+            if (!step) {
+                throw new Error(`ExchangeInstance unknown interval=${interval}`);
+            }
+            const stepMs = step * MS_PER_MINUTE;
+            // Align when down to interval boundary
+            const when = await GET_TIMESTAMP_FN();
+            const whenTimestamp = when.getTime();
+            const alignedWhen = ALIGN_TO_INTERVAL_FN(whenTimestamp, step);
+            // Calculate since: go back limit candles from aligned when
+            const sinceTimestamp = alignedWhen - limit * stepMs;
+            const since = new Date(sinceTimestamp);
+            const untilTimestamp = alignedWhen;
+            // Try to read from cache first
+            const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit }, sinceTimestamp, untilTimestamp, this.exchangeName);
+            if (cachedCandles !== null) {
+                return cachedCandles;
+            }
+            let allData = [];
+            // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
+            if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+                let remaining = limit;
+                let currentSince = new Date(since.getTime());
+                const isBacktest = await GET_BACKTEST_FN();
+                while (remaining > 0) {
+                    const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                    const chunkData = await getCandles(symbol, interval, currentSince, chunkLimit, isBacktest);
+                    allData.push(...chunkData);
+                    remaining -= chunkLimit;
+                    if (remaining > 0) {
+                        // Move currentSince forward by the number of candles fetched
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
+                    }
+                }
+            }
+            else {
+                const isBacktest = await GET_BACKTEST_FN();
+                allData = await getCandles(symbol, interval, since, limit, isBacktest);
+            }
+            // Apply distinct by timestamp to remove duplicates
+            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+            if (allData.length !== uniqueData.length) {
+                bt.loggerService.warn(`ExchangeInstance getCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
+            }
+            // Validate adapter returned data
+            if (uniqueData.length === 0) {
+                throw new Error(`ExchangeInstance getCandles: adapter returned empty array. ` +
+                    `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
+            }
+            if (uniqueData[0].timestamp !== sinceTimestamp) {
+                throw new Error(`ExchangeInstance getCandles: first candle timestamp mismatch. ` +
+                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+            }
+            if (uniqueData.length !== limit) {
+                throw new Error(`ExchangeInstance getCandles: candle count mismatch. ` +
+                    `Expected ${limit} candles, got ${uniqueData.length}. ` +
+                    `Adapter must return exact number of candles requested.`);
+            }
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit }, this.exchangeName);
+            return uniqueData;
+        };
+        /**
+         * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
+         * The number of candles is configurable via GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT.
+         *
+         * Formula:
+         * - Typical Price = (high + low + close) / 3
+         * - VWAP = sum(typical_price * volume) / sum(volume)
+         *
+         * If volume is zero, returns simple average of close prices.
+         *
+         * @param symbol - Trading pair symbol
+         * @returns Promise resolving to VWAP price
+         * @throws Error if no candles available
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const vwap = await instance.getAveragePrice("BTCUSDT");
+         * console.log(vwap); // 50125.43
+         * ```
+         */
+        this.getAveragePrice = async (symbol) => {
+            bt.loggerService.debug(`ExchangeInstance getAveragePrice`, {
+                exchangeName: this.exchangeName,
+                symbol,
+            });
+            const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
             if (candles.length === 0) {
                 throw new Error(`ExchangeInstance getAveragePrice: no candles data for symbol=${symbol}`);
             }
@@ -34390,7 +36213,7 @@ const INTERVAL_MINUTES = {
  * @param backtest - Whether running in backtest mode
  * @returns Cache key string
  */
-const CREATE_KEY_FN$1 = (strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN = (strategyName, exchangeName, frameName, backtest) => {
     const parts = [strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -34472,7 +36295,7 @@ class CacheInstance {
                     throw new Error(`CacheInstance unknown cache ttl interval=${this.interval}`);
                 }
             }
-            const key = CREATE_KEY_FN$1(bt.methodContextService.context.strategyName, bt.methodContextService.context.exchangeName, bt.methodContextService.context.frameName, bt.executionContextService.context.backtest);
+            const key = CREATE_KEY_FN(bt.methodContextService.context.strategyName, bt.methodContextService.context.exchangeName, bt.methodContextService.context.frameName, bt.executionContextService.context.backtest);
             const currentWhen = bt.executionContextService.context.when;
             const cached = this._cacheMap.get(key);
             if (cached) {
@@ -34510,7 +36333,7 @@ class CacheInstance {
          * ```
          */
         this.clear = () => {
-            const key = CREATE_KEY_FN$1(bt.methodContextService.context.strategyName, bt.methodContextService.context.exchangeName, bt.methodContextService.context.frameName, bt.executionContextService.context.backtest);
+            const key = CREATE_KEY_FN(bt.methodContextService.context.strategyName, bt.methodContextService.context.exchangeName, bt.methodContextService.context.frameName, bt.executionContextService.context.backtest);
             this._cacheMap.delete(key);
         };
     }
@@ -34658,663 +36481,6 @@ class CacheUtils {
  */
 const Cache = new CacheUtils();
 
-/** Maximum number of notifications to store in history */
-const MAX_NOTIFICATIONS = 250;
-/** Function to create unique notification IDs */
-const CREATE_KEY_FN = () => functoolsKit.randomString();
-/**
- * Instance class for notification history management.
- *
- * Contains all business logic for notification collection from emitters/subjects.
- * Stores notifications in chronological order with automatic limit management.
- *
- * @example
- * ```typescript
- * const instance = new NotificationInstance();
- * await instance.waitForInit();
- *
- * // Get all notifications
- * const all = instance.getData();
- *
- * // Process notifications with type discrimination
- * all.forEach(notification => {
- *   switch (notification.type) {
- *     case "signal.closed":
- *       console.log(`Closed: ${notification.pnlPercentage}%`);
- *       break;
- *     case "partial.loss":
- *       if (notification.level >= 30) {
- *         alert("High loss!");
- *       }
- *       break;
- *     case "risk.rejection":
- *       console.warn(notification.rejectionNote);
- *       break;
- *   }
- * });
- *
- * // Clear history
- * instance.clear();
- * ```
- */
-class NotificationInstance {
-    constructor() {
-        /** Internal notification history storage (newest first) */
-        this._notifications = [];
-        /**
-         * Processes signal events and creates appropriate notifications.
-         * Sorts signal notifications by createdAt to maintain chronological order.
-         */
-        this._handleSignal = async (data) => {
-            if (data.action === "opened") {
-                this._addNotification({
-                    type: "signal.opened",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.signal.pendingAt,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signal.id,
-                    position: data.signal.position,
-                    priceOpen: data.signal.priceOpen,
-                    priceTakeProfit: data.signal.priceTakeProfit,
-                    priceStopLoss: data.signal.priceStopLoss,
-                    originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.signal.originalPriceStopLoss,
-                    note: data.signal.note,
-                    scheduledAt: data.signal.scheduledAt,
-                    pendingAt: data.signal.pendingAt,
-                    createdAt: data.createdAt,
-                });
-            }
-            else if (data.action === "closed") {
-                const durationMs = data.closeTimestamp - data.signal.pendingAt;
-                const durationMin = Math.round(durationMs / 60000);
-                this._addNotification({
-                    type: "signal.closed",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.closeTimestamp,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signal.id,
-                    position: data.signal.position,
-                    priceOpen: data.signal.priceOpen,
-                    priceClose: data.currentPrice,
-                    priceTakeProfit: data.signal.priceTakeProfit,
-                    priceStopLoss: data.signal.priceStopLoss,
-                    originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.signal.originalPriceStopLoss,
-                    pnlPercentage: data.pnl.pnlPercentage,
-                    closeReason: data.closeReason,
-                    duration: durationMin,
-                    note: data.signal.note,
-                    scheduledAt: data.signal.scheduledAt,
-                    pendingAt: data.signal.pendingAt,
-                    createdAt: data.createdAt,
-                });
-            }
-            else if (data.action === "scheduled") {
-                this._addNotification({
-                    type: "signal.scheduled",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.signal.scheduledAt,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signal.id,
-                    position: data.signal.position,
-                    priceOpen: data.signal.priceOpen,
-                    priceTakeProfit: data.signal.priceTakeProfit,
-                    priceStopLoss: data.signal.priceStopLoss,
-                    originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.signal.originalPriceStopLoss,
-                    scheduledAt: data.signal.scheduledAt,
-                    currentPrice: data.currentPrice,
-                    createdAt: data.createdAt,
-                });
-            }
-            else if (data.action === "cancelled") {
-                const durationMs = data.closeTimestamp - data.signal.scheduledAt;
-                const durationMin = Math.round(durationMs / 60000);
-                this._addNotification({
-                    type: "signal.cancelled",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.closeTimestamp,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signal.id,
-                    position: data.signal.position,
-                    priceOpen: data.signal.priceOpen,
-                    priceTakeProfit: data.signal.priceTakeProfit,
-                    priceStopLoss: data.signal.priceStopLoss,
-                    originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.signal.originalPriceStopLoss,
-                    cancelReason: data.reason,
-                    cancelId: data.cancelId,
-                    duration: durationMin,
-                    scheduledAt: data.signal.scheduledAt,
-                    pendingAt: data.signal.pendingAt,
-                    createdAt: data.createdAt,
-                });
-            }
-        };
-        /**
-         * Processes partial profit events.
-         */
-        this._handlePartialProfit = async (data) => {
-            this._addNotification({
-                type: "partial_profit.available",
-                id: CREATE_KEY_FN(),
-                timestamp: data.timestamp,
-                backtest: data.backtest,
-                symbol: data.symbol,
-                strategyName: data.strategyName,
-                exchangeName: data.exchangeName,
-                signalId: data.data.id,
-                level: data.level,
-                currentPrice: data.currentPrice,
-                priceOpen: data.data.priceOpen,
-                position: data.data.position,
-                priceTakeProfit: data.data.priceTakeProfit,
-                priceStopLoss: data.data.priceStopLoss,
-                originalPriceTakeProfit: data.data.originalPriceTakeProfit,
-                originalPriceStopLoss: data.data.originalPriceStopLoss,
-                scheduledAt: data.data.scheduledAt,
-                pendingAt: data.data.pendingAt,
-                createdAt: data.timestamp,
-            });
-        };
-        /**
-         * Processes partial loss events.
-         */
-        this._handlePartialLoss = async (data) => {
-            this._addNotification({
-                type: "partial_loss.available",
-                id: CREATE_KEY_FN(),
-                timestamp: data.timestamp,
-                backtest: data.backtest,
-                symbol: data.symbol,
-                strategyName: data.strategyName,
-                exchangeName: data.exchangeName,
-                signalId: data.data.id,
-                level: data.level,
-                currentPrice: data.currentPrice,
-                priceOpen: data.data.priceOpen,
-                position: data.data.position,
-                priceTakeProfit: data.data.priceTakeProfit,
-                priceStopLoss: data.data.priceStopLoss,
-                originalPriceTakeProfit: data.data.originalPriceTakeProfit,
-                originalPriceStopLoss: data.data.originalPriceStopLoss,
-                scheduledAt: data.data.scheduledAt,
-                pendingAt: data.data.pendingAt,
-                createdAt: data.timestamp,
-            });
-        };
-        /**
-         * Processes breakeven events.
-         */
-        this._handleBreakeven = async (data) => {
-            this._addNotification({
-                type: "breakeven.available",
-                id: CREATE_KEY_FN(),
-                timestamp: data.timestamp,
-                backtest: data.backtest,
-                symbol: data.symbol,
-                strategyName: data.strategyName,
-                exchangeName: data.exchangeName,
-                signalId: data.data.id,
-                currentPrice: data.currentPrice,
-                priceOpen: data.data.priceOpen,
-                position: data.data.position,
-                priceTakeProfit: data.data.priceTakeProfit,
-                priceStopLoss: data.data.priceStopLoss,
-                originalPriceTakeProfit: data.data.originalPriceTakeProfit,
-                originalPriceStopLoss: data.data.originalPriceStopLoss,
-                scheduledAt: data.data.scheduledAt,
-                pendingAt: data.data.pendingAt,
-                createdAt: data.timestamp,
-            });
-        };
-        /**
-         * Processes strategy commit events.
-         */
-        this._handleStrategyCommit = async (data) => {
-            if (data.action === "partial-profit") {
-                this._addNotification({
-                    type: "partial_profit.commit",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.timestamp,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signalId,
-                    percentToClose: data.percentToClose,
-                    currentPrice: data.currentPrice,
-                    position: data.position,
-                    priceOpen: data.priceOpen,
-                    priceTakeProfit: data.priceTakeProfit,
-                    priceStopLoss: data.priceStopLoss,
-                    originalPriceTakeProfit: data.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.originalPriceStopLoss,
-                    scheduledAt: data.scheduledAt,
-                    pendingAt: data.pendingAt,
-                    createdAt: data.timestamp,
-                });
-            }
-            else if (data.action === "partial-loss") {
-                this._addNotification({
-                    type: "partial_loss.commit",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.timestamp,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signalId,
-                    percentToClose: data.percentToClose,
-                    currentPrice: data.currentPrice,
-                    position: data.position,
-                    priceOpen: data.priceOpen,
-                    priceTakeProfit: data.priceTakeProfit,
-                    priceStopLoss: data.priceStopLoss,
-                    originalPriceTakeProfit: data.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.originalPriceStopLoss,
-                    scheduledAt: data.scheduledAt,
-                    pendingAt: data.pendingAt,
-                    createdAt: data.timestamp,
-                });
-            }
-            else if (data.action === "breakeven") {
-                this._addNotification({
-                    type: "breakeven.commit",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.timestamp,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signalId,
-                    currentPrice: data.currentPrice,
-                    position: data.position,
-                    priceOpen: data.priceOpen,
-                    priceTakeProfit: data.priceTakeProfit,
-                    priceStopLoss: data.priceStopLoss,
-                    originalPriceTakeProfit: data.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.originalPriceStopLoss,
-                    scheduledAt: data.scheduledAt,
-                    pendingAt: data.pendingAt,
-                    createdAt: data.timestamp,
-                });
-            }
-            else if (data.action === "trailing-stop") {
-                this._addNotification({
-                    type: "trailing_stop.commit",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.timestamp,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signalId,
-                    percentShift: data.percentShift,
-                    currentPrice: data.currentPrice,
-                    position: data.position,
-                    priceOpen: data.priceOpen,
-                    priceTakeProfit: data.priceTakeProfit,
-                    priceStopLoss: data.priceStopLoss,
-                    originalPriceTakeProfit: data.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.originalPriceStopLoss,
-                    scheduledAt: data.scheduledAt,
-                    pendingAt: data.pendingAt,
-                    createdAt: data.timestamp,
-                });
-            }
-            else if (data.action === "trailing-take") {
-                this._addNotification({
-                    type: "trailing_take.commit",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.timestamp,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signalId,
-                    percentShift: data.percentShift,
-                    currentPrice: data.currentPrice,
-                    position: data.position,
-                    priceOpen: data.priceOpen,
-                    priceTakeProfit: data.priceTakeProfit,
-                    priceStopLoss: data.priceStopLoss,
-                    originalPriceTakeProfit: data.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.originalPriceStopLoss,
-                    scheduledAt: data.scheduledAt,
-                    pendingAt: data.pendingAt,
-                    createdAt: data.timestamp,
-                });
-            }
-            else if (data.action === "activate-scheduled") {
-                this._addNotification({
-                    type: "activate_scheduled.commit",
-                    id: CREATE_KEY_FN(),
-                    timestamp: data.timestamp,
-                    backtest: data.backtest,
-                    symbol: data.symbol,
-                    strategyName: data.strategyName,
-                    exchangeName: data.exchangeName,
-                    signalId: data.signalId,
-                    activateId: data.activateId,
-                    currentPrice: data.currentPrice,
-                    position: data.position,
-                    priceOpen: data.priceOpen,
-                    priceTakeProfit: data.priceTakeProfit,
-                    priceStopLoss: data.priceStopLoss,
-                    originalPriceTakeProfit: data.originalPriceTakeProfit,
-                    originalPriceStopLoss: data.originalPriceStopLoss,
-                    scheduledAt: data.scheduledAt,
-                    pendingAt: data.pendingAt,
-                    createdAt: data.timestamp,
-                });
-            }
-        };
-        /**
-         * Processes risk rejection events.
-         */
-        this._handleRisk = async (data) => {
-            this._addNotification({
-                type: "risk.rejection",
-                id: CREATE_KEY_FN(),
-                timestamp: data.timestamp,
-                backtest: data.backtest,
-                symbol: data.symbol,
-                strategyName: data.strategyName,
-                exchangeName: data.exchangeName,
-                rejectionNote: data.rejectionNote,
-                rejectionId: data.rejectionId,
-                activePositionCount: data.activePositionCount,
-                currentPrice: data.currentPrice,
-                signalId: data.currentSignal.id,
-                position: data.currentSignal.position,
-                priceOpen: data.currentSignal.priceOpen,
-                priceTakeProfit: data.currentSignal.priceTakeProfit,
-                priceStopLoss: data.currentSignal.priceStopLoss,
-                minuteEstimatedTime: data.currentSignal.minuteEstimatedTime,
-                signalNote: data.currentSignal.note,
-                createdAt: data.timestamp,
-            });
-        };
-        /**
-         * Processes error events.
-         */
-        this._handleError = async (error) => {
-            this._addNotification({
-                type: "error.info",
-                id: CREATE_KEY_FN(),
-                error: functoolsKit.errorData(error),
-                message: functoolsKit.getErrorMessage(error),
-                backtest: false,
-            });
-        };
-        /**
-         * Processes critical error events.
-         */
-        this._handleCriticalError = async (error) => {
-            this._addNotification({
-                type: "error.critical",
-                id: CREATE_KEY_FN(),
-                error: functoolsKit.errorData(error),
-                message: functoolsKit.getErrorMessage(error),
-                backtest: false,
-            });
-        };
-        /**
-         * Processes validation error events.
-         */
-        this._handleValidationError = async (error) => {
-            this._addNotification({
-                type: "error.validation",
-                id: CREATE_KEY_FN(),
-                error: functoolsKit.errorData(error),
-                message: functoolsKit.getErrorMessage(error),
-                backtest: false,
-            });
-        };
-        /**
-         * Subscribes to all notification emitters and returns an unsubscribe function.
-         * Protected against multiple subscriptions using singleshot.
-         *
-         * @returns Unsubscribe function to stop receiving all notification events
-         *
-         * @example
-         * ```typescript
-         * const instance = new NotificationInstance();
-         * const unsubscribe = instance.subscribe();
-         * // ... later
-         * unsubscribe();
-         * ```
-         */
-        this.enable = functoolsKit.singleshot(() => {
-            const unSignal = signalEmitter.subscribe(this._handleSignal);
-            const unProfit = partialProfitSubject.subscribe(this._handlePartialProfit);
-            const unLoss = partialLossSubject.subscribe(this._handlePartialLoss);
-            const unBreakeven = breakevenSubject.subscribe(this._handleBreakeven);
-            const unStrategyCommit = strategyCommitSubject.subscribe(this._handleStrategyCommit);
-            const unRisk = riskSubject.subscribe(this._handleRisk);
-            const unError = errorEmitter.subscribe(this._handleError);
-            const unExit = exitEmitter.subscribe(this._handleCriticalError);
-            const unValidation = validationSubject.subscribe(this._handleValidationError);
-            const disposeFn = functoolsKit.compose(() => unSignal(), () => unProfit(), () => unLoss(), () => unBreakeven(), () => unStrategyCommit(), () => unRisk(), () => unError(), () => unExit(), () => unValidation());
-            return () => {
-                disposeFn();
-                this.enable.clear();
-            };
-        });
-    }
-    /**
-     * Adds notification to history with automatic limit management.
-     */
-    _addNotification(notification) {
-        this._notifications.unshift(notification);
-        // Trim history if exceeded MAX_NOTIFICATIONS
-        if (this._notifications.length > MAX_NOTIFICATIONS) {
-            this._notifications.pop();
-        }
-    }
-    /**
-     * Returns all notifications in chronological order (newest first).
-     *
-     * @returns Array of strongly-typed notification objects
-     *
-     * @example
-     * ```typescript
-     * const notifications = instance.getData();
-     *
-     * notifications.forEach(notification => {
-     *   switch (notification.type) {
-     *     case "signal.closed":
-     *       console.log(`${notification.symbol}: ${notification.pnlPercentage}%`);
-     *       break;
-     *     case "partial.loss":
-     *       if (notification.level >= 30) {
-     *         console.warn(`High loss: ${notification.symbol}`);
-     *       }
-     *       break;
-     *   }
-     * });
-     * ```
-     */
-    getData() {
-        return [...this._notifications];
-    }
-    /**
-     * Clears all notification history.
-     *
-     * @example
-     * ```typescript
-     * instance.clear();
-     * ```
-     */
-    clear() {
-        this._notifications = [];
-    }
-    /**
-     * Unsubscribes from all notification emitters to stop receiving events.
-     * Calls the unsubscribe function returned by subscribe().
-     * If not subscribed, does nothing.
-     *
-     * @example
-     * ```typescript
-     * const instance = new NotificationInstance();
-     * instance.subscribe();
-     * // ... later
-     * instance.unsubscribe();
-     * ```
-     */
-    disable() {
-        if (this.enable.hasValue()) {
-            const unsubscribeFn = this.enable();
-            unsubscribeFn();
-        }
-    }
-}
-/**
- * Public facade for notification operations.
- *
- * Automatically subscribes on first use and provides simplified access to notification instance methods.
- *
- * @example
- * ```typescript
- * import { Notification } from "./classes/Notification";
- *
- * // Get all notifications (auto-subscribes if not subscribed)
- * const all = await Notification.getData();
- *
- * // Process notifications with type discrimination
- * all.forEach(notification => {
- *   switch (notification.type) {
- *     case "signal.closed":
- *       console.log(`Closed: ${notification.pnlPercentage}%`);
- *       break;
- *     case "partial.loss":
- *       if (notification.level >= 30) {
- *         alert("High loss!");
- *       }
- *       break;
- *     case "risk.rejection":
- *       console.warn(notification.rejectionNote);
- *       break;
- *   }
- * });
- *
- * // Clear history
- * await Notification.clear();
- *
- * // Unsubscribe when done
- * await Notification.unsubscribe();
- * ```
- */
-class NotificationUtils {
-    constructor() {
-        /** Internal instance containing business logic */
-        this._instance = new NotificationInstance();
-    }
-    /**
-     * Returns all notifications in chronological order (newest first).
-     * Automatically subscribes to emitters if not already subscribed.
-     *
-     * @returns Array of strongly-typed notification objects
-     *
-     * @example
-     * ```typescript
-     * const notifications = await Notification.getData();
-     *
-     * notifications.forEach(notification => {
-     *   switch (notification.type) {
-     *     case "signal.closed":
-     *       console.log(`${notification.symbol}: ${notification.pnlPercentage}%`);
-     *       break;
-     *     case "partial.loss":
-     *       if (notification.level >= 30) {
-     *         console.warn(`High loss: ${notification.symbol}`);
-     *       }
-     *       break;
-     *   }
-     * });
-     * ```
-     */
-    async getData() {
-        if (!this._instance.enable.hasValue()) {
-            throw new Error("Notification not initialized. Call enable() before getting data.");
-        }
-        return this._instance.getData();
-    }
-    /**
-     * Clears all notification history.
-     * Automatically subscribes to emitters if not already subscribed.
-     *
-     * @example
-     * ```typescript
-     * await Notification.clear();
-     * ```
-     */
-    async clear() {
-        if (!this._instance.enable.hasValue()) {
-            throw new Error("Notification not initialized. Call enable() before clearing data.");
-        }
-        this._instance.clear();
-    }
-    /**
-     * Unsubscribes from all notification emitters.
-     * Call this when you no longer need to collect notifications.
-     *
-     * @example
-     * ```typescript
-     * await Notification.unsubscribe();
-     * ```
-     */
-    async enable() {
-        this._instance.enable();
-    }
-    /**
-     * Unsubscribes from all notification emitters.
-     * Call this when you no longer need to collect notifications.
-     * @example
-     * ```typescript
-     * await Notification.unsubscribe();
-     * ```
-     */
-    async disable() {
-        this._instance.disable();
-    }
-}
-/**
- * Singleton instance of NotificationUtils for convenient notification access.
- *
- * @example
- * ```typescript
- * import { Notification } from "./classes/Notification";
- *
- * // Get all notifications
- * const all = await Notification.getData();
- *
- * // Filter by type using type discrimination
- * const closedSignals = all.filter(n => n.type === "signal.closed");
- * const highLosses = all.filter(n =>
- *   n.type === "partial.loss" && n.level >= 30
- * );
- *
- * // Clear history
- * await Notification.clear();
- * ```
- */
-const Notification = new NotificationUtils();
-
 const BREAKEVEN_METHOD_NAME_GET_DATA = "BreakevenUtils.getData";
 const BREAKEVEN_METHOD_NAME_GET_REPORT = "BreakevenUtils.getReport";
 const BREAKEVEN_METHOD_NAME_DUMP = "BreakevenUtils.dump";
@@ -35840,6 +37006,8 @@ exports.MarkdownFileBase = MarkdownFileBase;
 exports.MarkdownFolderBase = MarkdownFolderBase;
 exports.MethodContextService = MethodContextService;
 exports.Notification = Notification;
+exports.NotificationBacktest = NotificationBacktest;
+exports.NotificationLive = NotificationLive;
 exports.Partial = Partial;
 exports.Performance = Performance;
 exports.PersistBase = PersistBase;