backtest-kit 1.6.4 → 1.6.6

package/build/index.cjs

@@ -3734,11 +3734,22 @@ class RiskUtils {
  */
 const Risk = new RiskUtils();
 
+/**
+ * No-operation IRisk implementation.
+ * Always allows signals and performs no actions.
+ */
 const NOOP_RISK = {
     checkSignal: () => Promise.resolve(true),
     addSignal: () => Promise.resolve(),
     removeSignal: () => Promise.resolve(),
 };
+/**
+ * Determines the appropriate IRisk instance based on provided riskName and riskList.
+ * @param dto - Object containing riskName and riskList
+ * @param backtest - Whether running in backtest mode
+ * @param self - Reference to StrategyConnectionService instance
+ * @returns Configured IRisk instance (single or merged)
+ */
 const GET_RISK_FN = (dto, backtest, self) => {
     const hasRiskName = !!dto.riskName;
     const hasRiskList = !!dto.riskList?.length;
@@ -3768,7 +3779,7 @@ const GET_RISK_FN = (dto, backtest, self) => {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$9 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$b = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
 /**
  * Callback function for emitting ping events to pingSubject.
  *
@@ -3829,7 +3840,7 @@ class StrategyConnectionService {
          * @param strategyName - Name of registered strategy schema
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, backtest), (symbol, strategyName, backtest) => {
+        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, backtest), (symbol, strategyName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -3996,7 +4007,7 @@ class StrategyConnectionService {
                 ctx,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN$9(ctx.symbol, ctx.strategyName, backtest);
+                const key = CREATE_KEY_FN$b(ctx.symbol, ctx.strategyName, backtest);
                 this.getStrategy.clear(key);
             }
             else {
@@ -4606,7 +4617,7 @@ class ClientRisk {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$8 = (riskName, backtest) => `${riskName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$a = (riskName, backtest) => `${riskName}:${backtest ? "backtest" : "live"}`;
 /**
  * Callback function for emitting risk rejection events to riskSubject.
  *
@@ -4678,7 +4689,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = functoolsKit.memoize(([riskName, backtest]) => CREATE_KEY_FN$8(riskName, backtest), (riskName, backtest) => {
+        this.getRisk = functoolsKit.memoize(([riskName, backtest]) => CREATE_KEY_FN$a(riskName, backtest), (riskName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
@@ -4745,7 +4756,7 @@ class RiskConnectionService {
                 backtest,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN$8(ctx.riskName, backtest);
+                const key = CREATE_KEY_FN$a(ctx.riskName, backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -4978,9 +4989,6 @@ class StrategyCoreService {
                 symbol,
                 strategyName,
             });
-            if (!MethodContextService.hasContext()) {
-                throw new Error("strategyCoreService getPendingSignal requires a method context");
-            }
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getPendingSignal(backtest, symbol, strategyName);
         };
@@ -4998,9 +5006,6 @@ class StrategyCoreService {
                 symbol,
                 strategyName,
             });
-            if (!MethodContextService.hasContext()) {
-                throw new Error("strategyCoreService getScheduledSignal requires a method context");
-            }
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getScheduledSignal(backtest, symbol, strategyName);
         };
@@ -5020,9 +5025,6 @@ class StrategyCoreService {
                 strategyName,
                 backtest,
             });
-            if (!MethodContextService.hasContext()) {
-                throw new Error("strategyCoreService getStopped requires a method context");
-            }
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getStopped(backtest, symbol, strategyName);
         };
@@ -7793,7 +7795,7 @@ const DEFAULT_COLUMNS = Object.freeze({ ...COLUMN_CONFIG });
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$7 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$9 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
 /**
  * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
  *
@@ -8002,7 +8004,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
          * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, backtest), () => new ReportStorage$5());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, backtest), () => new ReportStorage$5());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -8140,7 +8142,7 @@ class BacktestMarkdownService {
                 ctx,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN$7(ctx.symbol, ctx.strategyName, backtest);
+                const key = CREATE_KEY_FN$9(ctx.symbol, ctx.strategyName, backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -8173,7 +8175,7 @@ class BacktestMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$6 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$8 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
 /**
  * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
  *
@@ -8503,7 +8505,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
          * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, backtest), () => new ReportStorage$4());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, backtest), () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -8651,7 +8653,7 @@ class LiveMarkdownService {
                 ctx,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN$6(ctx.symbol, ctx.strategyName, backtest);
+                const key = CREATE_KEY_FN$8(ctx.symbol, ctx.strategyName, backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -8684,7 +8686,7 @@ class LiveMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$5 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$7 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
 /** Maximum number of events to store in schedule reports */
 const MAX_EVENTS$4 = 250;
 /**
@@ -8920,7 +8922,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
          * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, backtest), () => new ReportStorage$3());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, backtest), () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates scheduled/opened/cancelled events.
          * Should be called from signalEmitter subscription.
@@ -9062,7 +9064,7 @@ class ScheduleMarkdownService {
                 ctx,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN$5(ctx.symbol, ctx.strategyName, backtest);
+                const key = CREATE_KEY_FN$7(ctx.symbol, ctx.strategyName, backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -9095,7 +9097,7 @@ class ScheduleMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$4 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$6 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
 /**
  * Calculates percentile value from sorted array.
  */
@@ -9313,7 +9315,7 @@ class PerformanceMarkdownService {
          * Memoized function to get or create PerformanceStorage for a symbol-strategy-backtest triple.
          * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$4(symbol, strategyName, backtest), () => new PerformanceStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, backtest), () => new PerformanceStorage());
         /**
          * Processes performance events and accumulates metrics.
          * Should be called from performance tracking code.
@@ -9418,7 +9420,7 @@ class PerformanceMarkdownService {
                 ctx,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN$4(ctx.symbol, ctx.strategyName, backtest);
+                const key = CREATE_KEY_FN$6(ctx.symbol, ctx.strategyName, backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -9852,7 +9854,7 @@ class WalkerMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$3 = (strategyName, backtest) => `${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$5 = (strategyName, backtest) => `${strategyName}:${backtest ? "backtest" : "live"}`;
 const HEATMAP_METHOD_NAME_GET_DATA = "HeatMarkdownService.getData";
 const HEATMAP_METHOD_NAME_GET_REPORT = "HeatMarkdownService.getReport";
 const HEATMAP_METHOD_NAME_DUMP = "HeatMarkdownService.dump";
@@ -10196,7 +10198,7 @@ class HeatMarkdownService {
          * Memoized function to get or create HeatmapStorage for a strategy and backtest mode.
          * Each strategy + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([strategyName, backtest]) => CREATE_KEY_FN$3(strategyName, backtest), () => new HeatmapStorage());
+        this.getStorage = functoolsKit.memoize(([strategyName, backtest]) => CREATE_KEY_FN$5(strategyName, backtest), () => new HeatmapStorage());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from signal emitter subscription.
@@ -10332,7 +10334,7 @@ class HeatMarkdownService {
                 ctx,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN$3(ctx.strategyName, backtest);
+                const key = CREATE_KEY_FN$5(ctx.strategyName, backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -12550,7 +12552,7 @@ class ClientPartial {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$2 = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$4 = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Callback function for emitting profit events to partialProfitSubject.
  *
@@ -12648,7 +12650,7 @@ class PartialConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$2(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$4(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -12738,7 +12740,7 @@ class PartialConnectionService {
             const partial = this.getPartial(data.id, backtest);
             await partial.waitForInit(symbol, data.strategyName);
             await partial.clear(symbol, data, priceClose, backtest);
-            const key = CREATE_KEY_FN$2(data.id, backtest);
+            const key = CREATE_KEY_FN$4(data.id, backtest);
             this.getPartial.clear(key);
         };
     }
@@ -12750,7 +12752,7 @@ class PartialConnectionService {
  * @param param0 - Tuple of symbol, strategyName and backtest boolean
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$1 = ([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$3 = ([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
 /** Maximum number of events to store in partial reports */
 const MAX_EVENTS$1 = 250;
 /**
@@ -12925,7 +12927,7 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
          * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(CREATE_KEY_FN$1, () => new ReportStorage$1());
+        this.getStorage = functoolsKit.memoize(CREATE_KEY_FN$3, () => new ReportStorage$1());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -13072,7 +13074,7 @@ class PartialMarkdownService {
                 ctx,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN$1([ctx.symbol, ctx.strategyName, backtest]);
+                const key = CREATE_KEY_FN$3([ctx.symbol, ctx.strategyName, backtest]);
                 this.getStorage.clear(key);
             }
             else {
@@ -13515,7 +13517,7 @@ class ConfigValidationService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$2 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
 /** Maximum number of events to store in risk reports */
 const MAX_EVENTS = 250;
 /**
@@ -13660,7 +13662,7 @@ class RiskMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
          * Each symbol-strategy-backtest combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN(symbol, strategyName, backtest), () => new ReportStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$2(symbol, strategyName, backtest), () => new ReportStorage());
         /**
          * Processes risk rejection events and accumulates them.
          * Should be called from riskSubject subscription.
@@ -13788,7 +13790,7 @@ class RiskMarkdownService {
                 ctx,
             });
             if (ctx) {
-                const key = CREATE_KEY_FN(ctx.symbol, ctx.strategyName, backtest);
+                const key = CREATE_KEY_FN$2(ctx.symbol, ctx.strategyName, backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -19500,7 +19502,15 @@ const INTERVAL_MINUTES = {
     "6h": 360,
     "8h": 480,
 };
-const createKey = (strategyName, exchangeName, backtest) => `${strategyName}:${exchangeName}:${backtest ? "backtest" : "live"}`;
+/**
+ * Create a cache key string from strategy name, exchange name, and backtest mode.
+ *
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Name of the exchange
+ * @param backtest - Whether running in backtest mode
+ * @returns Cache key string
+ */
+const CREATE_KEY_FN$1 = (strategyName, exchangeName, backtest) => `${strategyName}:${exchangeName}:${backtest ? "backtest" : "live"}`;
 /**
  * Instance class for caching function results with timeframe-based invalidation.
  *
@@ -19576,7 +19586,7 @@ class CacheInstance {
                     throw new Error(`CacheInstance unknown cache ttl interval=${this.interval}`);
                 }
             }
-            const key = createKey(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
+            const key = CREATE_KEY_FN$1(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
             const currentWhen = backtest$1.executionContextService.context.when;
             const cached = this._cacheMap.get(key);
             if (cached) {
@@ -19614,7 +19624,7 @@ class CacheInstance {
          * ```
          */
         this.clear = () => {
-            const key = createKey(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
+            const key = CREATE_KEY_FN$1(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
             this._cacheMap.delete(key);
         };
     }
@@ -19762,6 +19772,440 @@ class CacheUtils {
  */
 const Cache = new CacheUtils();
 
+/** Maximum number of notifications to store in history */
+const MAX_NOTIFICATIONS = 250;
+/** Function to create unique notification IDs */
+const CREATE_KEY_FN = () => functoolsKit.randomString();
+/**
+ * Instance class for notification history management.
+ *
+ * Contains all business logic for notification collection from emitters/subjects.
+ * Stores notifications in chronological order with automatic limit management.
+ *
+ * @example
+ * ```typescript
+ * const instance = new NotificationInstance();
+ * await instance.waitForInit();
+ *
+ * // Get all notifications
+ * const all = instance.getData();
+ *
+ * // Process notifications with type discrimination
+ * all.forEach(notification => {
+ *   switch (notification.type) {
+ *     case "signal.closed":
+ *       console.log(`Closed: ${notification.pnlPercentage}%`);
+ *       break;
+ *     case "partial.loss":
+ *       if (notification.level >= 30) {
+ *         alert("High loss!");
+ *       }
+ *       break;
+ *     case "risk.rejection":
+ *       console.warn(notification.rejectionNote);
+ *       break;
+ *   }
+ * });
+ *
+ * // Clear history
+ * instance.clear();
+ * ```
+ */
+class NotificationInstance {
+    constructor() {
+        /** Internal notification history storage (newest first) */
+        this._notifications = [];
+        /**
+         * Processes signal events and creates appropriate notifications.
+         */
+        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,
+                    note: data.signal.note,
+                });
+            }
+            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,
+                    pnlPercentage: data.pnl.pnlPercentage,
+                    closeReason: data.closeReason,
+                    duration: durationMin,
+                    note: data.signal.note,
+                });
+            }
+            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,
+                    scheduledAt: data.signal.scheduledAt,
+                    currentPrice: data.currentPrice,
+                });
+            }
+            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,
+                    cancelReason: data.reason,
+                    cancelId: data.cancelId,
+                    duration: durationMin,
+                });
+            }
+        };
+        /**
+         * Processes partial profit events.
+         */
+        this._handlePartialProfit = async (data) => {
+            this._addNotification({
+                type: "partial.profit",
+                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,
+            });
+        };
+        /**
+         * Processes partial loss events.
+         */
+        this._handlePartialLoss = async (data) => {
+            this._addNotification({
+                type: "partial.loss",
+                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,
+            });
+        };
+        /**
+         * 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,
+                pendingSignal: data.pendingSignal,
+            });
+        };
+        /**
+         * Processes done events (live/backtest).
+         */
+        this._handleDoneLive = async (data) => {
+            this._addNotification({
+                type: "live.done",
+                id: CREATE_KEY_FN(),
+                timestamp: Date.now(),
+                backtest: false,
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+            });
+        };
+        /**
+         * Processes done events (backtest).
+         */
+        this._handleDoneBacktest = async (data) => {
+            this._addNotification({
+                type: "backtest.done",
+                id: CREATE_KEY_FN(),
+                timestamp: Date.now(),
+                backtest: true,
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+            });
+        };
+        /**
+         * Processes error events.
+         */
+        this._handleError = async (error) => {
+            this._addNotification({
+                type: "error.info",
+                id: CREATE_KEY_FN(),
+                timestamp: Date.now(),
+                error: functoolsKit.errorData(error),
+                message: functoolsKit.getErrorMessage(error),
+                backtest: false,
+            });
+        };
+        /**
+         * Processes critical error events.
+         */
+        this._handleCriticalError = async (error) => {
+            this._addNotification({
+                type: "error.critical",
+                id: CREATE_KEY_FN(),
+                timestamp: Date.now(),
+                error: functoolsKit.errorData(error),
+                message: functoolsKit.getErrorMessage(error),
+                backtest: false,
+            });
+        };
+        /**
+         * Processes validation error events.
+         */
+        this._handleValidationError = async (error) => {
+            this._addNotification({
+                type: "error.validation",
+                id: CREATE_KEY_FN(),
+                timestamp: Date.now(),
+                error: functoolsKit.errorData(error),
+                message: functoolsKit.getErrorMessage(error),
+                backtest: false,
+            });
+        };
+        /**
+         * Processes progress events.
+         */
+        this._handleProgressBacktest = async (data) => {
+            this._addNotification({
+                type: "progress.backtest",
+                id: CREATE_KEY_FN(),
+                timestamp: Date.now(),
+                backtest: true,
+                exchangeName: data.exchangeName,
+                strategyName: data.strategyName,
+                symbol: data.symbol,
+                totalFrames: data.totalFrames,
+                processedFrames: data.processedFrames,
+                progress: data.progress,
+            });
+        };
+        /**
+         * Initializes notification system by subscribing to all emitters.
+         * Uses singleshot to ensure initialization happens only once.
+         * Automatically called on first use.
+         */
+        this.waitForInit = functoolsKit.singleshot(async () => {
+            // Signal events
+            signalEmitter.subscribe(this._handleSignal);
+            // Partial profit/loss events
+            partialProfitSubject.subscribe(this._handlePartialProfit);
+            partialLossSubject.subscribe(this._handlePartialLoss);
+            // Risk events
+            riskSubject.subscribe(this._handleRisk);
+            // Done events
+            doneLiveSubject.subscribe(this._handleDoneLive);
+            doneBacktestSubject.subscribe(this._handleDoneBacktest);
+            // Error events
+            errorEmitter.subscribe(this._handleError);
+            exitEmitter.subscribe(this._handleCriticalError);
+            validationSubject.subscribe(this._handleValidationError);
+            // Progress events
+            progressBacktestEmitter.subscribe(this._handleProgressBacktest);
+        });
+    }
+    /**
+     * 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 = [];
+    }
+}
+/**
+ * Public facade for notification operations.
+ *
+ * Automatically calls waitForInit on each userspace method call.
+ * Provides simplified access to notification instance methods.
+ *
+ * @example
+ * ```typescript
+ * import { Notification } from "./classes/Notification";
+ *
+ * // Get all notifications
+ * 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();
+ * ```
+ */
+class NotificationUtils {
+    constructor() {
+        /** Internal instance containing business logic */
+        this._instance = new NotificationInstance();
+    }
+    /**
+     * Returns all notifications in chronological order (newest first).
+     *
+     * @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() {
+        await this._instance.waitForInit();
+        return this._instance.getData();
+    }
+    /**
+     * Clears all notification history.
+     *
+     * @example
+     * ```typescript
+     * await Notification.clear();
+     * ```
+     */
+    async clear() {
+        await this._instance.waitForInit();
+        this._instance.clear();
+    }
+}
+/**
+ * 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();
+
 exports.Backtest = Backtest;
 exports.Cache = Cache;
 exports.Constant = Constant;
@@ -19770,6 +20214,7 @@ exports.ExecutionContextService = ExecutionContextService;
 exports.Heat = Heat;
 exports.Live = Live;
 exports.MethodContextService = MethodContextService;
+exports.Notification = Notification;
 exports.Optimizer = Optimizer;
 exports.Partial = Partial;
 exports.Performance = Performance;