backtest-kit 9.8.2 → 9.8.3

package/build/index.cjs

@@ -808,11 +808,23 @@ const maxDrawdownSubject = new functoolsKit.Subject();
  * Emits when a strategy calls commitSignalInfo() to broadcast a custom annotation.
  */
 const signalNotifySubject = new functoolsKit.Subject();
+/**
+ * Before start emitter for strategy initialization events.
+ * Emits when the engine is about to start a new strategy execution.
+ */
+const beforeStartSubject = new functoolsKit.Subject();
+/**
+ * After end emitter for strategy completion events.
+ * Emits when the engine has completed processing a signal.
+ */
+const afterEndSubject = new functoolsKit.Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
     activePingSubject: activePingSubject,
+    afterEndSubject: afterEndSubject,
     backtestScheduleOpenSubject: backtestScheduleOpenSubject,
+    beforeStartSubject: beforeStartSubject,
     breakevenSubject: breakevenSubject,
     doneBacktestSubject: doneBacktestSubject,
     doneLiveSubject: doneLiveSubject,
@@ -20420,6 +20432,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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Public service for backtest orchestration with context management.
  *
@@ -20448,30 +20564,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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
         };
-    }
-}
-
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Public service for live trading orchestration with context management.
  *
@@ -20507,28 +20727,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);
+        }
     }
 }
 
@@ -34732,6 +34955,21 @@ class TimeMetaService {
          * Instances are cached until clear() is called.
          */
         this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.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.
          *
@@ -36402,7 +36640,7 @@ const PRINT_PROGRESS_FN = (fetched, total, symbol, interval) => {
  */
 const CACHE_CANDLES_FN = functoolsKit.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,
@@ -36412,7 +36650,7 @@ const CACHE_CANDLES_FN = functoolsKit.retry(async (interval, dto, onWarmStart, o
         });
     }
     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,
@@ -36945,11 +37183,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";
@@ -37116,113 +37349,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.
  *
@@ -40763,6 +40889,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.
  *
@@ -42233,6 +42363,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(functoolsKit.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(functoolsKit.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";
@@ -48921,6 +49113,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";
@@ -54965,6 +55279,8 @@ const SUBJECT_ISOLATION_LIST = [
     syncSubject,
     validationSubject,
     signalNotifySubject,
+    beforeStartSubject,
+    afterEndSubject
 ];
 /**
  * Creates a snapshot function for a given subject by clearing its internal
@@ -64303,7 +64619,11 @@ exports.listStrategySchema = listStrategySchema;
 exports.listWalkerSchema = listWalkerSchema;
 exports.listenActivePing = listenActivePing;
 exports.listenActivePingOnce = listenActivePingOnce;
+exports.listenAfterEnd = listenAfterEnd;
+exports.listenAfterEndOnce = listenAfterEndOnce;
 exports.listenBacktestProgress = listenBacktestProgress;
+exports.listenBeforeStart = listenBeforeStart;
+exports.listenBeforeStartOnce = listenBeforeStartOnce;
 exports.listenBreakevenAvailable = listenBreakevenAvailable;
 exports.listenBreakevenAvailableOnce = listenBreakevenAvailableOnce;
 exports.listenDoneBacktest = listenDoneBacktest;