backtest-kit 9.8.2 → 9.8.3

package/build/index.mjs

@@ -788,11 +788,23 @@ const maxDrawdownSubject = new Subject();
  * Emits when a strategy calls commitSignalInfo() to broadcast a custom annotation.
  */
 const signalNotifySubject = new Subject();
+/**
+ * Before start emitter for strategy initialization events.
+ * Emits when the engine is about to start a new strategy execution.
+ */
+const beforeStartSubject = new Subject();
+/**
+ * After end emitter for strategy completion events.
+ * Emits when the engine has completed processing a signal.
+ */
+const afterEndSubject = new Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
     activePingSubject: activePingSubject,
+    afterEndSubject: afterEndSubject,
     backtestScheduleOpenSubject: backtestScheduleOpenSubject,
+    beforeStartSubject: beforeStartSubject,
     breakevenSubject: breakevenSubject,
     doneBacktestSubject: doneBacktestSubject,
     doneLiveSubject: doneLiveSubject,
@@ -20400,6 +20412,110 @@ class WalkerLogicPrivateService {
     }
 }
 
+/**
+ * Run iterator function for backtest logic.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param context - Execution context with strategy, exchange, and frame names
+ * @param self - Instance of BacktestLogicPublicService
+ * @returns Async iterator for backtest results
+ */
+const RUN_ITERATOR_FN$1 = (self, symbol, context) => {
+    return MethodContextService.runAsyncIterator(self.backtestLogicPrivateService.run(symbol), {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: context.frameName,
+    });
+};
+/**
+ * Call before start execution for backtest logic.
+ * This function is responsible for triggering the beforeStartSubject
+ * with the appropriate context and symbol information.
+ */
+const CALL_BEFORE_START_FN$1 = trycatch(async (self, symbol, context) => {
+    const { startDate } = self.frameSchemaService.get(context.frameName);
+    const when = alignToInterval(startDate, "1m");
+    await MethodContextService.runInContext(async () => {
+        await ExecutionContextService.runInContext(async () => {
+            const currentPrice = await self.exchangeConnectionService.getAveragePrice(symbol);
+            await beforeStartSubject.next({
+                symbol,
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+                backtest: true,
+                when,
+                timestamp: when.getTime(),
+                currentPrice,
+            });
+        }, {
+            symbol,
+            when,
+            backtest: true,
+        });
+    }, {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: context.frameName,
+    });
+}, {
+    fallback: (error, self) => {
+        const message = "BacktestLogicPublicService CALL_BEFORE_START_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Call after end execution for backtest logic.
+ * This function is responsible for triggering the afterEndSubject
+ * with the appropriate context and symbol information.
+ */
+const CALL_AFTER_END_FN$1 = trycatch(async (self, symbol, context) => {
+    const { startDate } = self.frameSchemaService.get(context.frameName);
+    const timestamp = self.timeMetaService.hasTimestamp(symbol, context, true)
+        ? await self.timeMetaService.getTimestamp(symbol, context, true)
+        : startDate.getTime();
+    const when = new Date(timestamp);
+    await MethodContextService.runInContext(async () => {
+        await ExecutionContextService.runInContext(async () => {
+            const currentPrice = await self.exchangeConnectionService.getAveragePrice(symbol);
+            await afterEndSubject.next({
+                symbol,
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+                backtest: true,
+                when,
+                timestamp,
+                currentPrice,
+            });
+        }, {
+            symbol,
+            when,
+            backtest: true,
+        });
+    }, {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: context.frameName,
+    });
+}, {
+    fallback: (error, self) => {
+        const message = "BacktestLogicPublicService CALL_AFTER_END_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Public service for backtest orchestration with context management.
  *
@@ -20428,30 +20544,134 @@ class BacktestLogicPublicService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.backtestLogicPrivateService = inject(TYPES.backtestLogicPrivateService);
-        /**
-         * Runs backtest for a symbol with context propagation.
-         *
-         * Streams closed signals as async generator. Context is automatically
-         * injected into all framework functions called during iteration.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param context - Execution context with strategy, exchange, and frame names
-         * @returns Async generator yielding closed signals with PNL
-         */
-        this.run = (symbol, context) => {
-            this.loggerService.log("backtestLogicPublicService run", {
+        this.timeMetaService = inject(TYPES.timeMetaService);
+        this.frameSchemaService = inject(TYPES.frameSchemaService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+    }
+    /**
+     * Runs backtest for a symbol with context propagation.
+     *
+     * Streams closed signals as async generator. Context is automatically
+     * injected into all framework functions called during iteration.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy, exchange, and frame names
+     * @returns Async generator yielding closed signals with PNL
+     */
+    async *run(symbol, context) {
+        this.loggerService.log("backtestLogicPublicService run", {
+            symbol,
+            context,
+        });
+        await CALL_BEFORE_START_FN$1(this, symbol, context);
+        try {
+            yield* RUN_ITERATOR_FN$1(this, symbol, context);
+        }
+        finally {
+            await CALL_AFTER_END_FN$1(this, symbol, context);
+        }
+    }
+}
+
+/**
+ * Run iterator function for live logic.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param context - Execution context with strategy and exchange names
+ * @param self - Instance of LiveLogicPublicService
+ * @returns Async iterator for live trading results
+ */
+const RUN_ITERATOR_FN = (self, symbol, context) => {
+    return MethodContextService.runAsyncIterator(self.liveLogicPrivateService.run(symbol), {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: "",
+    });
+};
+/**
+ * Call before start execution for live logic.
+ * This function is responsible for triggering the beforeStartSubject
+ * with the appropriate context and symbol information.
+ */
+const CALL_BEFORE_START_FN = trycatch(async (self, symbol, context) => {
+    const when = alignToInterval(new Date(), "1m");
+    await MethodContextService.runInContext(async () => {
+        await ExecutionContextService.runInContext(async () => {
+            const currentPrice = await self.exchangeConnectionService.getAveragePrice(symbol);
+            await beforeStartSubject.next({
                 symbol,
-                context,
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: "",
+                backtest: false,
+                currentPrice,
+                when,
+                timestamp: when.getTime(),
             });
-            return MethodContextService.runAsyncIterator(this.backtestLogicPrivateService.run(symbol), {
+        }, {
+            symbol,
+            when,
+            backtest: false,
+        });
+    }, {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: "",
+    });
+}, {
+    fallback: (error, self) => {
+        const message = "LiveLogicPublicService CALL_BEFORE_START_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Call after end execution for live logic.
+ * This function is responsible for triggering the afterEndSubject
+ * with the appropriate context and symbol information.
+ */
+const CALL_AFTER_END_FN = trycatch(async (self, symbol, context) => {
+    const when = alignToInterval(new Date(), "1m");
+    await MethodContextService.runInContext(async () => {
+        await ExecutionContextService.runInContext(async () => {
+            const currentPrice = await self.exchangeConnectionService.getAveragePrice(symbol);
+            await afterEndSubject.next({
+                symbol,
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
-                frameName: context.frameName,
+                frameName: "",
+                backtest: false,
+                currentPrice,
+                when,
+                timestamp: when.getTime(),
             });
+        }, {
+            symbol,
+            when,
+            backtest: false,
+        });
+    }, {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: "",
+    });
+}, {
+    fallback: (error, self) => {
+        const message = "LiveLogicPublicService CALL_AFTER_END_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
         };
-    }
-}
-
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Public service for live trading orchestration with context management.
  *
@@ -20487,28 +20707,31 @@ class LiveLogicPublicService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.liveLogicPrivateService = inject(TYPES.liveLogicPrivateService);
-        /**
-         * Runs live trading for a symbol with context propagation.
-         *
-         * Streams opened and closed signals as infinite async generator.
-         * Context is automatically injected into all framework functions.
-         * Process can crash and restart - state will be recovered from disk.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param context - Execution context with strategy and exchange names
-         * @returns Infinite async generator yielding opened and closed signals
-         */
-        this.run = (symbol, context) => {
-            this.loggerService.log("liveLogicPublicService run", {
-                symbol,
-                context,
-            });
-            return MethodContextService.runAsyncIterator(this.liveLogicPrivateService.run(symbol), {
-                exchangeName: context.exchangeName,
-                strategyName: context.strategyName,
-                frameName: "",
-            });
-        };
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+    }
+    /**
+     * Runs live trading for a symbol with context propagation.
+     *
+     * Streams opened and closed signals as infinite async generator.
+     * Context is automatically injected into all framework functions.
+     * Process can crash and restart - state will be recovered from disk.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy and exchange names
+     * @returns Infinite async generator yielding opened and closed signals
+     */
+    async *run(symbol, context) {
+        this.loggerService.log("liveLogicPublicService run", {
+            symbol,
+            context,
+        });
+        await CALL_BEFORE_START_FN(this, symbol, context);
+        try {
+            yield* RUN_ITERATOR_FN(this, symbol, context);
+        }
+        finally {
+            await CALL_AFTER_END_FN(this, symbol, context);
+        }
     }
 }
 
@@ -34712,6 +34935,21 @@ class TimeMetaService {
          * Instances are cached until clear() is called.
          */
         this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        /**
+         * Checks if a timestamp exists for the given symbol and context.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns True if a timestamp is available, false otherwise
+         */
+        this.hasTimestamp = (symbol, context, backtest) => {
+            const key = CREATE_KEY_FN$a(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            if (!this.getSource.has(key)) {
+                return false;
+            }
+            return !!this.getSource.get(key)?.data;
+        };
         /**
          * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
          *
@@ -36382,7 +36620,7 @@ const PRINT_PROGRESS_FN = (fetched, total, symbol, interval) => {
  */
 const CACHE_CANDLES_FN = retry(async (interval, dto, onWarmStart, onCheckStart) => {
     try {
-        onWarmStart && onWarmStart(dto.symbol, interval, dto.from, dto.to);
+        onCheckStart && onCheckStart(dto.symbol, interval, dto.from, dto.to);
         await checkCandles({
             exchangeName: dto.exchangeName,
             from: dto.from,
@@ -36392,7 +36630,7 @@ const CACHE_CANDLES_FN = retry(async (interval, dto, onWarmStart, onCheckStart)
         });
     }
     catch (error) {
-        onCheckStart && onCheckStart(dto.symbol, interval, dto.from, dto.to);
+        onWarmStart && onWarmStart(dto.symbol, interval, dto.from, dto.to);
         await warmCandles({
             symbol: dto.symbol,
             exchangeName: dto.exchangeName,
@@ -36925,11 +37163,6 @@ const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
 const GET_CLOSE_PRICE_METHOD_NAME = "exchange.getClosePrice";
 const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
 const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
-const GET_DATE_METHOD_NAME = "exchange.getDate";
-const GET_TIMESTAMP_METHOD_NAME = "exchange.getTimestamp";
-const GET_MODE_METHOD_NAME = "exchange.getMode";
-const GET_SYMBOL_METHOD_NAME = "exchange.getSymbol";
-const GET_CONTEXT_METHOD_NAME = "exchange.getContext";
 const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
 const GET_ORDER_BOOK_METHOD_NAME = "exchange.getOrderBook";
 const GET_RAW_CANDLES_METHOD_NAME = "exchange.getRawCandles";
@@ -37096,113 +37329,6 @@ async function formatQuantity(symbol, quantity) {
     }
     return await backtest.exchangeConnectionService.formatQuantity(symbol, quantity);
 }
-/**
- * Gets the current date from execution context.
- *
- * In backtest mode: returns the current timeframe date being processed
- * In live mode: returns current real-time date
- *
- * @returns Promise resolving to current execution context date
- *
- * @example
- * ```typescript
- * const date = await getDate();
- * console.log(date); // 2024-01-01T12:00:00.000Z
- * ```
- */
-async function getDate() {
-    backtest.loggerService.info(GET_DATE_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getDate requires an execution context");
-    }
-    const { when } = backtest.executionContextService.context;
-    return new Date(when.getTime());
-}
-/**
- * Gets the current timestamp from execution context.
- *
- * In backtest mode: returns the current timeframe timestamp being processed
- * In live mode: returns current real-time timestamp
- *
- * @returns Promise resolving to current execution context timestamp in milliseconds
- * @example
- * ```typescript
- * const timestamp = await getTimestamp();
- * console.log(timestamp); // 1700000000000
- * ```
- */
-async function getTimestamp() {
-    backtest.loggerService.info(GET_TIMESTAMP_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getTimestamp requires an execution context");
-    }
-    return getContextTimestamp();
-}
-/**
- * Gets the current execution mode.
- *
- * @returns Promise resolving to "backtest" or "live"
- *
- * @example
- * ```typescript
- * const mode = await getMode();
- * if (mode === "backtest") {
- *   console.log("Running in backtest mode");
- * } else {
- *   console.log("Running in live mode");
- * }
- * ```
- */
-async function getMode() {
-    backtest.loggerService.info(GET_MODE_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getMode requires an execution context");
-    }
-    const { backtest: bt } = backtest.executionContextService.context;
-    return bt ? "backtest" : "live";
-}
-/**
- * Gets the current trading symbol from execution context.
- *
- * @returns Promise resolving to the current trading symbol (e.g., "BTCUSDT")
- * @throws Error if execution context is not active
- *
- * @example
- * ```typescript
- * const symbol = await getSymbol();
- * console.log(symbol); // "BTCUSDT"
- * ```
- */
-async function getSymbol() {
-    backtest.loggerService.info(GET_SYMBOL_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getSymbol requires an execution context");
-    }
-    const { symbol } = backtest.executionContextService.context;
-    return symbol;
-}
-/**
- * Gets the current method context.
- *
- * Returns the context object from the method context service, which contains
- * information about the current method execution environment.
- *
- * @returns Promise resolving to the current method context object
- * @throws Error if method context is not active
- *
- * @example
- * ```typescript
- * const context = await getContext();
- * console.log(context); // { ...method context data... }
- * ```
- */
-async function getContext() {
-    backtest.loggerService.info(GET_CONTEXT_METHOD_NAME);
-    if (!MethodContextService.hasContext()) {
-        throw new Error("getContext requires a method context");
-    }
-    return backtest.methodContextService.context;
-}
 /**
  * Fetches order book for a trading pair from the registered exchange.
  *
@@ -40743,6 +40869,10 @@ const LISTEN_MAX_DRAWDOWN_METHOD_NAME = "event.listenMaxDrawdown";
 const LISTEN_MAX_DRAWDOWN_ONCE_METHOD_NAME = "event.listenMaxDrawdownOnce";
 const LISTEN_SIGNAL_NOTIFY_METHOD_NAME = "event.listenSignalNotify";
 const LISTEN_SIGNAL_NOTIFY_ONCE_METHOD_NAME = "event.listenSignalNotifyOnce";
+const LISTEN_BEFORE_START_METHOD_NAME = "event.listenBeforeStart";
+const LISTEN_BEFORE_START_ONCE_METHOD_NAME = "event.listenBeforeStartOnce";
+const LISTEN_AFTER_END_METHOD_NAME = "event.listenAfterEnd";
+const LISTEN_AFTER_END_ONCE_METHOD_NAME = "event.listenAfterEndOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -42213,6 +42343,68 @@ function listenSignalNotifyOnce(filterFn, fn) {
     };
     return disposeFn = listenSignalNotify(wrappedFn);
 }
+/**
+ * Subscribes to before start events with queued async processing.
+ * Emits when the engine is about to start a new strategy execution for a symbol.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * @param fn - Callback function to handle before start events
+ * @return Unsubscribe function to stop listening to events
+ */
+function listenBeforeStart(fn) {
+    backtest.loggerService.log(LISTEN_BEFORE_START_METHOD_NAME);
+    return beforeStartSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered before start events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes.
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @return Unsubscribe function to cancel the listener before it fires
+ */
+function listenBeforeStartOnce(filterFn, fn) {
+    backtest.loggerService.log(LISTEN_BEFORE_START_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenBeforeStart(wrappedFn);
+}
+/**
+ * Subscribes to after end events with queued async processing.
+ * Emits when the engine has completed processing a strategy execution for a symbol.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * @param fn - Callback function to handle after end events
+ * @return Unsubscribe function to stop listening to events
+ */
+function listenAfterEnd(fn) {
+    backtest.loggerService.log(LISTEN_AFTER_END_METHOD_NAME);
+    return afterEndSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered after end events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes.
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @return Unsubscribe function to cancel the listener before it fires
+ */
+function listenAfterEndOnce(filterFn, fn) {
+    backtest.loggerService.log(LISTEN_AFTER_END_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenAfterEnd(wrappedFn);
+}
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
@@ -48901,6 +49093,128 @@ async function listRiskSchema() {
     return await backtest.riskValidationService.list();
 }
 
+const GET_DATE_METHOD_NAME = "meta.getDate";
+const GET_TIMESTAMP_METHOD_NAME = "meta.getTimestamp";
+const GET_MODE_METHOD_NAME = "meta.getMode";
+const GET_SYMBOL_METHOD_NAME = "meta.getSymbol";
+const GET_CONTEXT_METHOD_NAME = "meta.getContext";
+/**
+ * Gets the current date from execution context.
+ *
+ * In backtest mode: returns the current timeframe date being processed
+ * In live mode: returns current real-time date
+ *
+ * @returns Promise resolving to current execution context date
+ *
+ * @example
+ * ```typescript
+ * const date = await getDate();
+ * console.log(date); // 2024-01-01T12:00:00.000Z
+ * ```
+ */
+async function getDate() {
+    backtest.loggerService.info(GET_DATE_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getDate requires an execution context");
+    }
+    const { when } = backtest.executionContextService.context;
+    return new Date(when.getTime());
+}
+/**
+ * Gets the current timestamp from execution context.
+ *
+ * In backtest mode: returns the current timeframe timestamp being processed
+ * In live mode: returns current real-time timestamp
+ *
+ * @returns Promise resolving to current execution context timestamp in milliseconds
+ * @example
+ * ```typescript
+ * const timestamp = await getTimestamp();
+ * console.log(timestamp); // 1700000000000
+ * ```
+ */
+async function getTimestamp() {
+    backtest.loggerService.info(GET_TIMESTAMP_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getTimestamp requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getTimestamp requires a method context");
+    }
+    const { symbol, backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return backtest.timeMetaService.getTimestamp(symbol, {
+        exchangeName,
+        frameName,
+        strategyName,
+    }, isBacktest);
+}
+/**
+ * Gets the current execution mode.
+ *
+ * @returns Promise resolving to "backtest" or "live"
+ *
+ * @example
+ * ```typescript
+ * const mode = await getMode();
+ * if (mode === "backtest") {
+ *   console.log("Running in backtest mode");
+ * } else {
+ *   console.log("Running in live mode");
+ * }
+ * ```
+ */
+async function getMode() {
+    backtest.loggerService.info(GET_MODE_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getMode requires an execution context");
+    }
+    const { backtest: bt } = backtest.executionContextService.context;
+    return bt ? "backtest" : "live";
+}
+/**
+ * Gets the current trading symbol from execution context.
+ *
+ * @returns Promise resolving to the current trading symbol (e.g., "BTCUSDT")
+ * @throws Error if execution context is not active
+ *
+ * @example
+ * ```typescript
+ * const symbol = await getSymbol();
+ * console.log(symbol); // "BTCUSDT"
+ * ```
+ */
+async function getSymbol() {
+    backtest.loggerService.info(GET_SYMBOL_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getSymbol requires an execution context");
+    }
+    const { symbol } = backtest.executionContextService.context;
+    return symbol;
+}
+/**
+ * Gets the current method context.
+ *
+ * Returns the context object from the method context service, which contains
+ * information about the current method execution environment.
+ *
+ * @returns Promise resolving to the current method context object
+ * @throws Error if method context is not active
+ *
+ * @example
+ * ```typescript
+ * const context = await getContext();
+ * console.log(context); // { ...method context data... }
+ * ```
+ */
+async function getContext() {
+    backtest.loggerService.info(GET_CONTEXT_METHOD_NAME);
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getContext requires a method context");
+    }
+    return backtest.methodContextService.context;
+}
+
 const RECENT_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentPersistBacktestUtils.handleActivePing";
 const RECENT_PERSIST_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL = "RecentPersistBacktestUtils.getLatestSignal";
 const RECENT_PERSIST_LIVE_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentPersistLiveUtils.handleActivePing";
@@ -54945,6 +55259,8 @@ const SUBJECT_ISOLATION_LIST = [
     syncSubject,
     validationSubject,
     signalNotifySubject,
+    beforeStartSubject,
+    afterEndSubject
 ];
 /**
  * Creates a snapshot function for a given subject by clearing its internal
@@ -64077,4 +64393,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };