backtest-kit 3.0.0 → 3.0.2

package/build/index.mjs

@@ -730,6 +730,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;
@@ -1803,6 +1808,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 = 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 = {
@@ -33620,325 +33720,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 = () => 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,
+        };
+    }
+    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,
+        };
+    }
+    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,
+        };
+    }
+    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,
+        };
+    }
+    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,
+        };
+    }
+    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,
+        };
+    }
+    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,
+        };
+    }
+    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,
+        };
+    }
+    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 = 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: errorData(error),
-            message: 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: errorData(error),
+    message: 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 = trycatch(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: errorData(error),
-            message: 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: errorData(error),
+    message: 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: errorData(error),
+    message: 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: 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: 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: 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 = 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: 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: 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: 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: 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: 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: 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 = 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: 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: 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: 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 = 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 = 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 = 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 = 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: errorData(error),
+            message: 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 = trycatch(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: errorData(error),
+            message: 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}`);
             }
@@ -34370,7 +36193,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);
@@ -34452,7 +36275,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) {
@@ -34490,7 +36313,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);
         };
     }
@@ -34638,663 +36461,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 = () => 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: errorData(error),
-                message: getErrorMessage(error),
-                backtest: false,
-            });
-        };
-        /**
-         * Processes critical error events.
-         */
-        this._handleCriticalError = async (error) => {
-            this._addNotification({
-                type: "error.critical",
-                id: CREATE_KEY_FN(),
-                error: errorData(error),
-                message: getErrorMessage(error),
-                backtest: false,
-            });
-        };
-        /**
-         * Processes validation error events.
-         */
-        this._handleValidationError = async (error) => {
-            this._addNotification({
-                type: "error.validation",
-                id: CREATE_KEY_FN(),
-                error: errorData(error),
-                message: 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 = 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 = 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";
@@ -35806,4 +36972,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitActivateScheduled, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitActivateScheduled, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };