backtest-kit 6.10.0 → 6.11.0

package/build/index.mjs

@@ -4127,53 +4127,6 @@ const toProfitLossDto = (signal, priceClose) => {
     };
 };
 
-/**
- * Converts markdown content to plain text with minimal formatting
- * @param content - Markdown string to convert
- * @returns Plain text representation
- */
-const toPlainString = (content) => {
-    if (!content) {
-        return "";
-    }
-    let text = content;
-    // Remove code blocks
-    text = text.replace(/```[\s\S]*?```/g, "");
-    text = text.replace(/`([^`]+)`/g, "$1");
-    // Remove images
-    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
-    // Convert links to text only (keep link text, remove URL)
-    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-    // Remove headers (convert to plain text)
-    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
-    // Remove bold and italic markers
-    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
-    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
-    text = text.replace(/\*(.+?)\*/g, "$1");
-    text = text.replace(/___(.+?)___/g, "$1");
-    text = text.replace(/__(.+?)__/g, "$1");
-    text = text.replace(/_(.+?)_/g, "$1");
-    // Remove strikethrough
-    text = text.replace(/~~(.+?)~~/g, "$1");
-    // Convert lists to plain text with bullets
-    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
-    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
-    // Remove blockquotes
-    text = text.replace(/^\s*>\s+/gm, "");
-    // Remove horizontal rules
-    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
-    // Remove HTML tags
-    text = text.replace(/<[^>]+>/g, "");
-    // Remove excessive whitespace and normalize line breaks
-    text = text.replace(/\n[\s\n]*\n/g, "\n");
-    text = text.replace(/[ \t]+/g, " ");
-    // Remove all newline characters
-    text = text.replace(/\n/g, " ");
-    // Remove excessive spaces after newline removal
-    text = text.replace(/\s+/g, " ");
-    return text.trim();
-};
-
 /**
  * Returns the total closed state of a position using costBasisAtClose snapshots.
  *
@@ -4808,6 +4761,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4835,6 +4789,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4861,6 +4816,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4888,6 +4844,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4915,6 +4872,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4944,6 +4902,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -5042,7 +5001,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
     const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
     const signal = await Promise.race([
-        self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when),
+        self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
         sleep(timeoutMs).then(() => TIMEOUT_SYMBOL),
     ]);
     if (typeof signal === "symbol") {
@@ -5072,7 +5031,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
                 cost: signal.cost || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST,
                 priceOpen: signal.priceOpen, // Используем priceOpen из сигнала
                 position: signal.position,
-                note: toPlainString(signal.note),
+                note: signal.note || "",
                 priceTakeProfit: signal.priceTakeProfit,
                 priceStopLoss: signal.priceStopLoss,
                 minuteEstimatedTime: signal.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
@@ -5098,7 +5057,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             cost: signal.cost || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST,
             priceOpen: signal.priceOpen,
             position: signal.position,
-            note: toPlainString(signal.note),
+            note: signal.note || "",
             priceTakeProfit: signal.priceTakeProfit,
             priceStopLoss: signal.priceStopLoss,
             minuteEstimatedTime: signal.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
@@ -5123,7 +5082,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         cost: signal.cost || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST,
         priceOpen: currentPrice,
         ...structuredClone(signal),
-        note: toPlainString(signal.note),
+        note: signal.note || "",
         minuteEstimatedTime: signal.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
         symbol: self.params.execution.context.symbol,
         exchangeName: self.params.method.context.exchangeName,
@@ -5870,6 +5829,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
             totalPartials: scheduled._partial?.length ?? 0,
             originalPriceOpen: scheduled.priceOpen,
             pnl: toProfitLossDto(scheduled, scheduled.priceOpen),
+            note: scheduled.note,
         });
         return null;
     }
@@ -6638,6 +6598,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
             totalPartials: scheduled._partial?.length ?? 0,
             originalPriceOpen: scheduled.priceOpen,
             pnl: toProfitLossDto(scheduled, averagePrice),
+            note: scheduled.note,
         });
     }
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, averagePrice, closeTimestamp, self.params.execution.context.backtest);
@@ -6716,6 +6677,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
             totalPartials: scheduled._partial?.length ?? 0,
             originalPriceOpen: scheduled.priceOpen,
             pnl: toProfitLossDto(scheduled, scheduled.priceOpen),
+            note: scheduled.note,
         });
         return false;
     }
@@ -6803,6 +6765,7 @@ const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, aver
         totalPartials: closedSignal._partial?.length ?? 0,
         originalPriceOpen: closedSignal.priceOpen,
         pnl: toProfitLossDto(closedSignal, averagePrice),
+        note: closedSignal.note,
     });
     await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
     await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
@@ -6903,6 +6866,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
                     totalPartials: activatedSignal._partial?.length ?? 0,
                     originalPriceOpen: activatedSignal.priceOpen,
                     pnl: toProfitLossDto(activatedSignal, averagePrice),
+                    note: activatedSignal.note,
                 });
                 return { outcome: "pending" };
             }
@@ -6934,6 +6898,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
                 pendingAt: publicSignalForCommit.pendingAt,
                 totalEntries: publicSignalForCommit.totalEntries,
                 totalPartials: publicSignalForCommit.totalPartials,
+                note: publicSignalForCommit.note,
             });
             await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, pendingSignal.priceOpen, candle.timestamp, self.params.execution.context.backtest);
             await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
@@ -8118,6 +8083,7 @@ class ClientStrategy {
                 totalPartials: cancelledSignal._partial?.length ?? 0,
                 originalPriceOpen: cancelledSignal.priceOpen,
                 pnl: toProfitLossDto(cancelledSignal, currentPrice),
+                note: cancelledSignal.note,
             });
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8171,6 +8137,7 @@ class ClientStrategy {
                 totalPartials: closedSignal._partial?.length ?? 0,
                 originalPriceOpen: closedSignal.priceOpen,
                 pnl: toProfitLossDto(closedSignal, currentPrice),
+                note: closedSignal.note,
             });
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8252,6 +8219,7 @@ class ClientStrategy {
                     totalPartials: activatedSignal._partial?.length ?? 0,
                     originalPriceOpen: activatedSignal.priceOpen,
                     pnl: toProfitLossDto(activatedSignal, currentPrice),
+                    note: activatedSignal.note,
                 });
                 return await RETURN_IDLE_FN(this, currentPrice);
             }
@@ -8282,6 +8250,7 @@ class ClientStrategy {
                 pendingAt: publicSignalForCommit.pendingAt,
                 totalEntries: publicSignalForCommit.totalEntries,
                 totalPartials: publicSignalForCommit.totalPartials,
+                note: publicSignalForCommit.note,
             });
             // Call onOpen callback
             await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8417,6 +8386,7 @@ class ClientStrategy {
                 totalPartials: cancelledSignal._partial?.length ?? 0,
                 originalPriceOpen: cancelledSignal.priceOpen,
                 pnl: toProfitLossDto(cancelledSignal, currentPrice),
+                note: cancelledSignal.note,
             });
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
@@ -8471,6 +8441,7 @@ class ClientStrategy {
                 totalPartials: closedSignal._partial?.length ?? 0,
                 originalPriceOpen: closedSignal.priceOpen,
                 pnl: toProfitLossDto(closedSignal, currentPrice),
+                note: closedSignal.note,
             });
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -10020,6 +9991,8 @@ class MergeRisk {
     }
 }
 
+/** Default interval for strategies that do not specify one */
+const STRATEGY_DEFAULT_INTERVAL = "1m";
 /**
  * If syncSubject listener or any registered action throws, it means the signal was not properly synchronized
  * to the exchange (e.g. limit order failed to fill).
@@ -10405,7 +10378,7 @@ class StrategyConnectionService {
          * @returns Configured ClientStrategy instance
          */
         this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$t(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
-            const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
+            const { riskName = "", riskList = [], getSignal, interval = STRATEGY_DEFAULT_INTERVAL, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
                 interval,
@@ -16124,8 +16097,8 @@ class StrategySchemaService {
             if (strategySchema.actions?.some((value) => typeof value !== "string")) {
                 throw new Error(`strategy schema validation failed: invalid actions for strategyName=${strategySchema.strategyName} actions=[${strategySchema.actions}]`);
             }
-            if (typeof strategySchema.interval !== "string") {
-                throw new Error(`strategy schema validation failed: missing interval for strategyName=${strategySchema.strategyName}`);
+            if (strategySchema.interval && typeof strategySchema.interval !== "string") {
+                throw new Error(`strategy schema validation failed: invalid interval for strategyName=${strategySchema.strategyName}`);
             }
             if (typeof strategySchema.getSignal !== "function") {
                 throw new Error(`strategy schema validation failed: missing getSignal for strategyName=${strategySchema.strategyName}`);
@@ -18071,6 +18044,53 @@ class WalkerCommandService {
     }
 }
 
+/**
+ * Converts markdown content to plain text with minimal formatting
+ * @param content - Markdown string to convert
+ * @returns Plain text representation
+ */
+const toPlainString = (content) => {
+    if (!content) {
+        return "";
+    }
+    let text = content;
+    // Remove code blocks
+    text = text.replace(/```[\s\S]*?```/g, "");
+    text = text.replace(/`([^`]+)`/g, "$1");
+    // Remove images
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
+    // Convert links to text only (keep link text, remove URL)
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // Remove headers (convert to plain text)
+    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+    // Remove bold and italic markers
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
+    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+    text = text.replace(/\*(.+?)\*/g, "$1");
+    text = text.replace(/___(.+?)___/g, "$1");
+    text = text.replace(/__(.+?)__/g, "$1");
+    text = text.replace(/_(.+?)_/g, "$1");
+    // Remove strikethrough
+    text = text.replace(/~~(.+?)~~/g, "$1");
+    // Convert lists to plain text with bullets
+    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
+    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
+    // Remove blockquotes
+    text = text.replace(/^\s*>\s+/gm, "");
+    // Remove horizontal rules
+    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
+    // Remove HTML tags
+    text = text.replace(/<[^>]+>/g, "");
+    // Remove excessive whitespace and normalize line breaks
+    text = text.replace(/\n[\s\n]*\n/g, "\n");
+    text = text.replace(/[ \t]+/g, " ");
+    // Remove all newline characters
+    text = text.replace(/\n/g, " ");
+    // Remove excessive spaces after newline removal
+    text = text.replace(/\s+/g, " ");
+    return text.trim();
+};
+
 /**
  * Column configuration for backtest markdown reports.
  *
@@ -18746,7 +18766,7 @@ const partial_columns = [
     {
         key: "note",
         label: "Note",
-        format: (data) => data.note || "",
+        format: (data) => toPlainString(data.note ?? "N/A"),
         isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
     {
@@ -18906,7 +18926,7 @@ const breakeven_columns = [
     {
         key: "note",
         label: "Note",
-        format: (data) => data.note || "",
+        format: (data) => toPlainString(data.note ?? "N/A"),
         isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
     {
@@ -51645,6 +51665,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             pnlEntries: data.signal.pnl.pnlEntries,
             scheduledAt: data.signal.scheduledAt,
             currentPrice: data.currentPrice,
+            note: data.signal.note,
             createdAt: data.createdAt,
         };
     }
@@ -51674,6 +51695,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             duration: durationMin,
             scheduledAt: data.signal.scheduledAt,
             pendingAt: data.signal.pendingAt,
+            note: data.signal.note,
             createdAt: data.createdAt,
         };
     }
@@ -51710,6 +51732,7 @@ const CREATE_PARTIAL_PROFIT_NOTIFICATION_FN = (data) => ({
     pnlPriceClose: data.data.pnl.priceClose,
     pnlCost: data.data.pnl.pnlCost,
     pnlEntries: data.data.pnl.pnlEntries,
+    note: data.data.note,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -51745,6 +51768,7 @@ const CREATE_PARTIAL_LOSS_NOTIFICATION_FN = (data) => ({
     pnlPriceClose: data.data.pnl.priceClose,
     pnlCost: data.data.pnl.pnlCost,
     pnlEntries: data.data.pnl.pnlEntries,
+    note: data.data.note,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -51779,6 +51803,7 @@ const CREATE_BREAKEVEN_NOTIFICATION_FN = (data) => ({
     pnlPriceClose: data.data.pnl.priceClose,
     pnlCost: data.data.pnl.pnlCost,
     pnlEntries: data.data.pnl.pnlEntries,
+    note: data.data.note,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -51820,6 +51845,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51852,6 +51878,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51883,6 +51910,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51915,6 +51943,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51947,6 +51976,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51979,6 +52009,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -52012,6 +52043,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -52035,6 +52067,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlPriceClose: data.pnl.priceClose,
             pnlCost: data.pnl.pnlCost,
             pnlEntries: data.pnl.pnlEntries,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -52058,6 +52091,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlPriceClose: data.pnl.priceClose,
             pnlCost: data.pnl.pnlCost,
             pnlEntries: data.pnl.pnlEntries,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -52099,6 +52133,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
             totalPartials: data.totalPartials,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.signal.note,
             createdAt: data.timestamp,
         };
     }
@@ -52131,6 +52166,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             closeReason: data.closeReason,
+            note: data.signal.note,
             createdAt: data.timestamp,
         };
     }
@@ -53630,6 +53666,7 @@ const CACHE_METHOD_NAME_FILE = "CacheUtils.file";
 const CACHE_METHOD_NAME_FILE_CLEAR = "CacheUtils.file.clear";
 const CACHE_METHOD_NAME_DISPOSE = "CacheUtils.dispose";
 const CACHE_METHOD_NAME_CLEAR = "CacheUtils.clear";
+const CACHE_METHOD_NAME_RESET_COUNTER = "CacheUtils.resetCounter";
 const CACHE_FILE_INSTANCE_METHOD_NAME_RUN = "CacheFileInstance.run";
 const MS_PER_MINUTE$1 = 60000;
 const INTERVAL_MINUTES$1 = {
@@ -53881,7 +53918,7 @@ class CacheFileInstance {
     /**
      * Clears the index counter.
      */
-    static clearCounter() {
+    static resetCounter() {
         CacheFileInstance._indexCounter = 0;
     }
     /**
@@ -54136,11 +54173,17 @@ class CacheUtils {
          */
         this.clear = () => {
             backtest.loggerService.info(CACHE_METHOD_NAME_CLEAR);
-            {
-                this._getFnInstance.clear();
-                this._getFileInstance.clear();
-            }
-            CacheFileInstance.clearCounter();
+            this._getFnInstance.clear();
+            this._getFileInstance.clear();
+        };
+        /**
+         * Resets the CacheFileInstance index counter to zero.
+         * This is useful when process.cwd() changes between strategy iterations to ensure
+         * that new CacheFileInstance objects start with index 0 and do not collide with old instances.
+         */
+        this.resetCounter = () => {
+            backtest.loggerService.info(CACHE_METHOD_NAME_RESET_COUNTER);
+            CacheFileInstance.resetCounter();
         };
     }
 }
@@ -54164,10 +54207,12 @@ const INTERVAL_METHOD_NAME_RUN = "IntervalFnInstance.run";
 const INTERVAL_FILE_INSTANCE_METHOD_NAME_RUN = "IntervalFileInstance.run";
 const INTERVAL_METHOD_NAME_FN = "IntervalUtils.fn";
 const INTERVAL_METHOD_NAME_FN_CLEAR = "IntervalUtils.fn.clear";
+const INTERVAL_METHOD_NAME_FN_GC = "IntervalUtils.fn.gc";
 const INTERVAL_METHOD_NAME_FILE = "IntervalUtils.file";
 const INTERVAL_METHOD_NAME_FILE_CLEAR = "IntervalUtils.file.clear";
 const INTERVAL_METHOD_NAME_DISPOSE = "IntervalUtils.dispose";
 const INTERVAL_METHOD_NAME_CLEAR = "IntervalUtils.clear";
+const INTERVAL_METHOD_NAME_RESET_COUNTER = "IntervalUtils.resetCounter";
 const MS_PER_MINUTE = 60000;
 const INTERVAL_MINUTES = {
     "1m": 1,
@@ -54234,6 +54279,8 @@ const CREATE_KEY_FN = (strategyName, exchangeName, frameName, isBacktest) => {
  *
  * State is kept in memory; use `IntervalFileInstance` for persistence across restarts.
  *
+ * @template F - Concrete function type
+ *
  * @example
  * ```typescript
  * const instance = new IntervalFnInstance(mySignalFn, "1h");
@@ -54249,30 +54296,34 @@ class IntervalFnInstance {
      *
      * @param fn - Function to fire once per interval
      * @param interval - Candle interval that controls the firing boundary
+     * @param key - Optional key generator for argument-based state separation.
+     *              Default: `([symbol]) => symbol`
      */
-    constructor(fn, interval) {
+    constructor(fn, interval, key = ([symbol]) => symbol) {
         this.fn = fn;
         this.interval = interval;
-        /** Stores the last aligned timestamp per context+symbol key. */
+        this.key = key;
+        /** Stores the last aligned timestamp per context+symbol+args key. */
         this._stateMap = new Map();
         /**
          * Execute the signal function with once-per-interval enforcement.
          *
          * Algorithm:
          * 1. Align the current execution context `when` to the interval boundary.
-         * 2. If the stored aligned timestamp for this context+symbol equals the current one → return `null`.
-         * 3. Otherwise call `fn`. If it returns a non-null signal, record the aligned timestamp and return
+         * 2. Build state key from context + key generator result.
+         * 3. If the stored aligned timestamp for this key equals the current one → return `null`.
+         * 4. Otherwise call `fn`. If it returns a non-null signal, record the aligned timestamp and return
          *    the signal. If it returns `null`, leave state unchanged so the next call retries.
          *
          * Requires active method context and execution context.
          *
-         * @param symbol - Trading pair symbol (e.g. "BTCUSDT")
+         * @param args - Arguments forwarded to the wrapped function
          * @returns The value returned by `fn` on the first non-null fire, `null` on all subsequent calls
          *   within the same interval or when `fn` itself returned `null`
          * @throws Error if method context, execution context, or interval is missing
          */
-        this.run = async (symbol) => {
-            backtest.loggerService.debug(INTERVAL_METHOD_NAME_RUN, { symbol });
+        this.run = async (...args) => {
+            backtest.loggerService.debug(INTERVAL_METHOD_NAME_RUN, { args });
             const step = INTERVAL_MINUTES[this.interval];
             {
                 if (!MethodContextService.hasContext()) {
@@ -54286,15 +54337,16 @@ class IntervalFnInstance {
                 }
             }
             const contextKey = CREATE_KEY_FN(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
-            const key = `${contextKey}:${symbol}`;
             const currentWhen = backtest.executionContextService.context.when;
             const currentAligned = align(currentWhen.getTime(), this.interval);
-            if (this._stateMap.get(key) === currentAligned) {
+            const argKey = this.key(args);
+            const stateKey = `${contextKey}:${argKey}`;
+            if (this._stateMap.get(stateKey) === currentAligned) {
                 return null;
             }
-            const result = await this.fn(symbol, currentWhen);
+            const result = await this.fn.apply(null, args);
             if (result !== null) {
-                this._stateMap.set(key, currentAligned);
+                this._stateMap.set(stateKey, currentAligned);
             }
             return result;
         };
@@ -54315,6 +54367,28 @@ class IntervalFnInstance {
                 }
             }
         };
+        /**
+         * Garbage collect expired state entries.
+         *
+         * Removes all entries whose aligned timestamp differs from the current interval boundary.
+         * Call this periodically to free memory from stale state entries.
+         *
+         * Requires active execution context to get current time.
+         *
+         * @returns Number of entries removed
+         */
+        this.gc = () => {
+            const currentWhen = backtest.executionContextService.context.when;
+            const currentAligned = align(currentWhen.getTime(), this.interval);
+            let removed = 0;
+            for (const [key, storedAligned] of this._stateMap.entries()) {
+                if (storedAligned !== currentAligned) {
+                    this._stateMap.delete(key);
+                    removed++;
+                }
+            }
+            return removed;
+        };
     }
 }
 /**
@@ -54328,7 +54402,7 @@ class IntervalFnInstance {
  *
  * Fired state survives process restarts — unlike `IntervalFnInstance` which is in-memory only.
  *
- * @template T - Async function type: `(symbol: string, ...args) => Promise<R | null>`
+ * @template F - Concrete async function type
  *
  * @example
  * ```typescript
@@ -54349,7 +54423,7 @@ class IntervalFileInstance {
      * Resets the index counter to zero.
      * Call this when clearing all instances (e.g. on `IntervalUtils.clear()`).
      */
-    static clearCounter() {
+    static resetCounter() {
         IntervalFileInstance._indexCounter = 0;
     }
     /**
@@ -54358,18 +54432,21 @@ class IntervalFileInstance {
      * @param fn - Async signal function to fire once per interval
      * @param interval - Candle interval that controls the firing boundary
      * @param name - Human-readable bucket name used as the directory prefix
+     * @param key - Dynamic key generator; receives `[symbol, alignMs, ...rest]`.
+     *              Default: `([symbol, alignMs]) => \`${symbol}_${alignMs}\``
      */
-    constructor(fn, interval, name) {
+    constructor(fn, interval, name, key = ([symbol, alignMs]) => `${symbol}_${alignMs}`) {
         this.fn = fn;
         this.interval = interval;
         this.name = name;
+        this.key = key;
         /**
          * Execute the async function with persistent once-per-interval enforcement.
          *
          * Algorithm:
          * 1. Build bucket = `${name}_${interval}_${index}` — fixed per instance, used as directory name.
-         * 2. Align execution context `when` to interval boundary → `alignedTs`.
-         * 3. Build entity key = `${symbol}_${alignedTs}`.
+         * 2. Align execution context `when` to interval boundary → `alignedMs`.
+         * 3. Build entity key from the key generator (receives `[symbol, alignedMs, ...rest]`).
          * 4. Try to read from `PersistIntervalAdapter` using (bucket, entityKey).
          * 5. On hit — return `null` (interval already fired).
          * 6. On miss — call `fn`. If non-null, write to disk and return result. If null, skip write and return null.
@@ -54377,12 +54454,13 @@ class IntervalFileInstance {
          * Requires active method context and execution context.
          *
          * @param symbol - Trading pair symbol (e.g. "BTCUSDT")
+         * @param args - Additional arguments forwarded to the wrapped function
          * @returns The value on the first non-null fire, `null` if already fired this interval
          *   or if `fn` itself returned `null`
          * @throws Error if method context, execution context, or interval is missing
          */
-        this.run = async (symbol) => {
-            backtest.loggerService.debug(INTERVAL_FILE_INSTANCE_METHOD_NAME_RUN, { symbol });
+        this.run = async (...args) => {
+            backtest.loggerService.debug(INTERVAL_FILE_INSTANCE_METHOD_NAME_RUN, { args });
             const step = INTERVAL_MINUTES[this.interval];
             {
                 if (!MethodContextService.hasContext()) {
@@ -54395,15 +54473,16 @@ class IntervalFileInstance {
                     throw new Error(`IntervalFileInstance unknown interval=${this.interval}`);
                 }
             }
+            const [symbol, ...rest] = args;
             const { when } = backtest.executionContextService.context;
-            const alignedTs = align(when.getTime(), this.interval);
+            const alignedMs = align(when.getTime(), this.interval);
             const bucket = `${this.name}_${this.interval}_${this.index}`;
-            const entityKey = `${symbol}_${alignedTs}`;
+            const entityKey = this.key([symbol, alignedMs, ...rest]);
             const cached = await PersistIntervalAdapter.readIntervalData(bucket, entityKey);
             if (cached !== null) {
                 return null;
             }
-            const result = await this.fn(symbol, when);
+            const result = await this.fn.call(null, ...args);
             if (result !== null) {
                 await PersistIntervalAdapter.writeIntervalData({ id: entityKey, data: result, removed: false }, bucket, entityKey);
             }
@@ -54444,12 +54523,12 @@ class IntervalUtils {
          * Memoized factory to get or create an `IntervalFnInstance` for a function.
          * Each function reference gets its own isolated instance.
          */
-        this._getInstance = memoize(([run]) => run, (run, interval) => new IntervalFnInstance(run, interval));
+        this._getInstance = memoize(([run]) => run, (run, interval, key) => new IntervalFnInstance(run, interval, key));
         /**
          * Memoized factory to get or create an `IntervalFileInstance` for an async function.
          * Each function reference gets its own isolated persistent instance.
          */
-        this._getFileInstance = memoize(([run]) => run, (run, interval, name) => new IntervalFileInstance(run, interval, name));
+        this._getFileInstance = memoize(([run]) => run, (run, interval, name, key) => new IntervalFileInstance(run, interval, name, key));
         /**
          * Wrap a signal function with in-memory once-per-interval firing.
          *
@@ -54461,21 +54540,30 @@ class IntervalUtils {
          *
          * @param run - Signal function to wrap
          * @param context.interval - Candle interval that controls the firing boundary
-         * @returns Wrapped function with the same signature as `TIntervalFn<T>`, plus a `clear()` method
+         * @param context.key - Optional key generator for argument-based state separation
+         * @returns Wrapped function with the same signature as `F`, plus a `clear()` method
          *
          * @example
          * ```typescript
+         * // Without extra args
          * const fireOnce = Interval.fn(mySignalFn, { interval: "15m" });
-         *
          * await fireOnce("BTCUSDT"); // → T or null  (fn called)
          * await fireOnce("BTCUSDT"); // → null       (same interval, skipped)
+         *
+         * // With extra args and key
+         * const fireOnce = Interval.fn(mySignalFn, {
+         *   interval: "15m",
+         *   key: ([symbol, period]) => `${symbol}_${period}`,
+         * });
+         * await fireOnce("BTCUSDT", 14); // → T or null
+         * await fireOnce("BTCUSDT", 28); // → T or null (separate state)
          * ```
          */
         this.fn = (run, context) => {
             backtest.loggerService.info(INTERVAL_METHOD_NAME_FN, { context });
-            const wrappedFn = (symbol) => {
-                const instance = this._getInstance(run, context.interval);
-                return instance.run(symbol);
+            const wrappedFn = (...args) => {
+                const instance = this._getInstance(run, context.interval, context.key);
+                return instance.run(...args);
             };
             wrappedFn.clear = () => {
                 backtest.loggerService.info(INTERVAL_METHOD_NAME_FN_CLEAR);
@@ -54489,6 +54577,14 @@ class IntervalUtils {
                 }
                 this._getInstance.get(run)?.clear();
             };
+            wrappedFn.gc = () => {
+                backtest.loggerService.info(INTERVAL_METHOD_NAME_FN_GC);
+                if (!ExecutionContextService.hasContext()) {
+                    backtest.loggerService.warn(`${INTERVAL_METHOD_NAME_FN_GC} called without execution context, skipping`);
+                    return;
+                }
+                return this._getInstance.get(run)?.gc();
+            };
             return wrappedFn;
         };
         /**
@@ -54501,28 +54597,33 @@ class IntervalUtils {
          * The `run` function reference is used as the memoization key for the underlying
          * `IntervalFileInstance`, so each unique function reference gets its own isolated instance.
          *
-         * @template T - Async function type to wrap
+         * @template F - Concrete async function type
          * @param run - Async signal function to wrap with persistent once-per-interval firing
          * @param context.interval - Candle interval that controls the firing boundary
          * @param context.name - Human-readable bucket name; becomes the directory prefix
-         * @returns Wrapped function with the same signature as `T`, plus an async `clear()` method
-         *   that deletes persisted records from disk and disposes the memoized instance
+         * @param context.key - Optional entity key generator. Receives `[symbol, alignMs, ...rest]`.
+         *                      Default: `([symbol, alignMs]) => \`${symbol}_${alignMs}\``
+         * @returns Wrapped function with the same signature as `F`, plus an async `clear()` method
          *
          * @example
          * ```typescript
-         * const fetchSignal = async (symbol: string, when: Date) => { ... };
-         * const fireOnce = Interval.file(fetchSignal, { interval: "1h", name: "fetchSignal" });
-         * await fireOnce.clear(); // delete disk records so the function fires again next call
+         * const fetchSignal = async (symbol: string, period: number) => { ... };
+         * const fireOnce = Interval.file(fetchSignal, {
+         *   interval: "1h",
+         *   name: "fetchSignal",
+         *   key: ([symbol, alignMs, period]) => `${symbol}_${alignMs}_${period}`,
+         * });
+         * await fireOnce("BTCUSDT", 14);
          * ```
          */
         this.file = (run, context) => {
             backtest.loggerService.info(INTERVAL_METHOD_NAME_FILE, { context });
             {
-                this._getFileInstance(run, context.interval, context.name);
+                this._getFileInstance(run, context.interval, context.name, context.key);
             }
-            const wrappedFn = (symbol) => {
-                const instance = this._getFileInstance(run, context.interval, context.name);
-                return instance.run(symbol);
+            const wrappedFn = (...args) => {
+                const instance = this._getFileInstance(run, context.interval, context.name, context.key);
+                return instance.run(...args);
             };
             wrappedFn.clear = async () => {
                 backtest.loggerService.info(INTERVAL_METHOD_NAME_FILE_CLEAR);
@@ -54548,10 +54649,10 @@ class IntervalUtils {
         this.dispose = (run) => {
             backtest.loggerService.info(INTERVAL_METHOD_NAME_DISPOSE, { run });
             this._getInstance.clear(run);
+            this._getFileInstance.clear(run);
         };
         /**
-         * Clears all memoized `IntervalFnInstance` and `IntervalFileInstance` objects and
-         * resets the `IntervalFileInstance` index counter.
+         * Clears all memoized `IntervalFnInstance` and `IntervalFileInstance` objects.
          * Call this when `process.cwd()` changes between strategy iterations
          * so new instances are created with the updated base path.
          */
@@ -54559,7 +54660,15 @@ class IntervalUtils {
             backtest.loggerService.info(INTERVAL_METHOD_NAME_CLEAR);
             this._getInstance.clear();
             this._getFileInstance.clear();
-            IntervalFileInstance.clearCounter();
+        };
+        /**
+         * Resets the IntervalFileInstance index counter to zero.
+         * This is useful when process.cwd() changes between strategy iterations to ensure
+         * that new IntervalFileInstance objects start with index 0 and do not collide with old instances.
+         */
+        this.resetCounter = () => {
+            backtest.loggerService.info(INTERVAL_METHOD_NAME_RESET_COUNTER);
+            IntervalFileInstance.resetCounter();
         };
     }
 }