backtest-kit 1.1.1 → 1.1.2

package/README.md

@@ -19,6 +19,7 @@
 - ⚡ **Memory Optimized** - Prototype methods + memoization + streaming
 - 🔌 **Flexible Architecture** - Plug your own exchanges and strategies
 - 📝 **Markdown Reports** - Auto-generated trading reports with statistics (win rate, avg PNL)
+- 🛑 **Graceful Shutdown** - Live.background() waits for open positions to close before stopping
 
 ## Installation
 
@@ -145,7 +146,7 @@ addFrame({
 ### 4. Run Backtest
 
 ```typescript
-import { Backtest, listenSignalBacktest, listenError } from "backtest-kit";
+import { Backtest, listenSignalBacktest, listenError, listenDone } from "backtest-kit";
 
 // Run backtest in background
 const stopBacktest = Backtest.background("BTCUSDT", {
@@ -166,15 +167,20 @@ listenError((error) => {
   console.error("Error:", error.message);
 });
 
-// Generate and save report
-const markdown = await Backtest.getReport("my-strategy");
-await Backtest.dump("my-strategy"); // ./logs/backtest/my-strategy.md
+// Listen to completion
+listenDone((event) => {
+  if (event.backtest) {
+    console.log("Backtest completed:", event.symbol);
+    // Generate and save report
+    Backtest.dump(event.strategyName); // ./logs/backtest/my-strategy.md
+  }
+});
 ```
 
 ### 5. Run Live Trading (Crash-Safe)
 
 ```typescript
-import { Live, listenSignalLive, listenError } from "backtest-kit";
+import { Live, listenSignalLive, listenError, listenDone } from "backtest-kit";
 
 // Run live trading in background (infinite loop, crash-safe)
 const stop = Live.background("BTCUSDT", {
@@ -204,6 +210,13 @@ listenError((error) => {
   console.error("Error:", error.message);
 });
 
+// Listen to completion
+listenDone((event) => {
+  if (!event.backtest) {
+    console.log("Live trading stopped:", event.symbol);
+  }
+});
+
 // Stop when needed: stop();
 ```
 
@@ -285,6 +298,67 @@ All signals are validated automatically before execution:
 
 Validation errors include detailed messages for debugging.
 
+## Custom Persistence Adapter
+
+By default, signals are persisted to disk using atomic file writes (`./logs/data/signal/`). You can override the persistence layer with a custom adapter (e.g., Redis, MongoDB):
+
+```typescript
+import { PersistBase, PersistSignalAdaper, ISignalData, EntityId } from "backtest-kit";
+import Redis from "ioredis";
+
+// Create custom Redis adapter
+class RedisPersist extends PersistBase {
+  private redis = new Redis({
+    host: "localhost",
+    port: 6379,
+  });
+
+  async waitForInit(initial: boolean): Promise<void> {
+    // Initialize Redis connection if needed
+    await this.redis.ping();
+  }
+
+  async readValue(entityId: EntityId): Promise<ISignalData> {
+    const key = `${this.entityName}:${entityId}`;
+    const data = await this.redis.get(key);
+
+    if (!data) {
+      throw new Error(`Entity ${this.entityName}:${entityId} not found`);
+    }
+
+    return JSON.parse(data);
+  }
+
+  async hasValue(entityId: EntityId): Promise<boolean> {
+    const key = `${this.entityName}:${entityId}`;
+    const exists = await this.redis.exists(key);
+    return exists === 1;
+  }
+
+  async writeValue(entityId: EntityId, entity: ISignalData): Promise<void> {
+    const key = `${this.entityName}:${entityId}`;
+    await this.redis.set(key, JSON.stringify(entity));
+  }
+}
+
+// Register custom adapter
+PersistSignalAdaper.usePersistSignalAdapter(RedisPersist);
+
+// Now all signal persistence uses Redis
+Live.background("BTCUSDT", {
+  strategyName: "my-strategy",
+  exchangeName: "binance"
+});
+```
+
+**Key methods to implement:**
+- `waitForInit(initial)` - Initialize storage connection
+- `readValue(entityId)` - Read entity from storage
+- `hasValue(entityId)` - Check if entity exists
+- `writeValue(entityId, entity)` - Write entity to storage
+
+The adapter is registered globally and applies to all strategies.
+
 ## Interval Throttling
 
 Prevent signal spam with automatic throttling:
@@ -493,9 +567,55 @@ Live.background("BTCUSDT", {
 - `listenSignalBacktestOnce(filter, callback)` - Subscribe to backtest signals once
 - `listenSignalLive(callback)` - Subscribe to live signals only
 - `listenSignalLiveOnce(filter, callback)` - Subscribe to live signals once
+- `listenError(callback)` - Subscribe to background execution errors
+- `listenDone(callback)` - Subscribe to background completion events
+- `listenDoneOnce(filter, callback)` - Subscribe to background completion once
 
 All listeners return an `unsubscribe` function. All callbacks are processed sequentially using queued async execution.
 
+### Listen to Background Completion
+
+```typescript
+import { listenDone, listenDoneOnce, Backtest, Live } from "backtest-kit";
+
+// Listen to all completion events
+listenDone((event) => {
+  console.log("Execution completed:", {
+    mode: event.backtest ? "backtest" : "live",
+    symbol: event.symbol,
+    strategy: event.strategyName,
+    exchange: event.exchangeName,
+  });
+
+  // Auto-generate report on completion
+  if (event.backtest) {
+    Backtest.dump(event.strategyName);
+  } else {
+    Live.dump(event.strategyName);
+  }
+});
+
+// Wait for specific backtest to complete
+listenDoneOnce(
+  (event) => event.backtest && event.symbol === "BTCUSDT",
+  (event) => {
+    console.log("BTCUSDT backtest finished");
+    // Start next backtest or live trading
+    Live.background(event.symbol, {
+      strategyName: event.strategyName,
+      exchangeName: event.exchangeName,
+    });
+  }
+);
+
+// Run backtests
+Backtest.background("BTCUSDT", {
+  strategyName: "my-strategy",
+  exchangeName: "binance",
+  frameName: "1d-backtest"
+});
+```
+
 ## API Reference
 
 ### High-Level Functions

package/build/index.cjs

@@ -1585,6 +1585,11 @@ const signalBacktestEmitter = new functoolsKit.Subject();
  * Emits errors caught in background tasks (Live.background, Backtest.background).
  */
 const errorEmitter = new functoolsKit.Subject();
+/**
+ * Done emitter for background execution completion.
+ * Emits when background tasks complete (Live.background, Backtest.background).
+ */
+const doneEmitter = new functoolsKit.Subject();
 
 /**
  * Connection service routing strategy operations to correct ClientStrategy instance.
@@ -1651,12 +1656,12 @@ class StrategyConnectionService {
             const tick = await strategy.tick();
             {
                 if (this.executionContextService.context.backtest) {
-                    signalBacktestEmitter.next(tick);
+                    await signalBacktestEmitter.next(tick);
                 }
                 if (!this.executionContextService.context.backtest) {
-                    signalLiveEmitter.next(tick);
+                    await signalLiveEmitter.next(tick);
                 }
-                signalEmitter.next(tick);
+                await signalEmitter.next(tick);
             }
             return tick;
         };
@@ -1678,9 +1683,9 @@ class StrategyConnectionService {
             const tick = await strategy.backtest(candles);
             {
                 if (this.executionContextService.context.backtest) {
-                    signalBacktestEmitter.next(tick);
+                    await signalBacktestEmitter.next(tick);
                 }
-                signalEmitter.next(tick);
+                await signalEmitter.next(tick);
             }
             return tick;
         };
@@ -3724,6 +3729,8 @@ const LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME = "event.listenSignalLiveOnce";
 const LISTEN_SIGNAL_BACKTEST_METHOD_NAME = "event.listenSignalBacktest";
 const LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME = "event.listenSignalBacktestOnce";
 const LISTEN_ERROR_METHOD_NAME = "event.listenError";
+const LISTEN_DONE_METHOD_NAME = "event.listenDone";
+const LISTEN_DONE_ONCE_METHOD_NAME = "event.listenDoneOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -3914,6 +3921,71 @@ function listenError(fn) {
     backtest$1.loggerService.log(LISTEN_ERROR_METHOD_NAME);
     return errorEmitter.subscribe(functoolsKit.queued(async (error) => fn(error)));
 }
+/**
+ * Subscribes to background execution completion events with queued async processing.
+ *
+ * Emits when Live.background() or Backtest.background() completes execution.
+ * 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 completion events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenDone, Live } from "backtest-kit";
+ *
+ * const unsubscribe = listenDone((event) => {
+ *   console.log("Completed:", event.strategyName, event.exchangeName, event.symbol);
+ *   if (event.backtest) {
+ *     console.log("Backtest mode completed");
+ *   }
+ * });
+ *
+ * Live.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenDone(fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_METHOD_NAME);
+    return doneEmitter.subscribe(functoolsKit.queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered background execution completion events with one-time execution.
+ *
+ * Emits when Live.background() or Backtest.background() completes execution.
+ * 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)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenDoneOnce, Backtest } from "backtest-kit";
+ *
+ * // Wait for first backtest completion
+ * listenDoneOnce(
+ *   (event) => event.backtest && event.symbol === "BTCUSDT",
+ *   (event) => console.log("BTCUSDT backtest completed:", event.strategyName)
+ * );
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ * ```
+ */
+function listenDoneOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_ONCE_METHOD_NAME);
+    return doneEmitter.filter(filterFn).once(fn);
+}
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
@@ -4131,6 +4203,12 @@ class BacktestUtils {
                         break;
                     }
                 }
+                await doneEmitter.next({
+                    exchangeName: context.exchangeName,
+                    strategyName: context.strategyName,
+                    backtest: true,
+                    symbol,
+                });
             };
             task().catch((error) => errorEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
@@ -4293,6 +4371,12 @@ class LiveUtils {
                         break;
                     }
                 }
+                await doneEmitter.next({
+                    exchangeName: context.exchangeName,
+                    strategyName: context.strategyName,
+                    backtest: false,
+                    symbol,
+                });
             };
             task().catch((error) => errorEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
@@ -4374,6 +4458,8 @@ exports.getCandles = getCandles;
 exports.getDate = getDate;
 exports.getMode = getMode;
 exports.lib = backtest;
+exports.listenDone = listenDone;
+exports.listenDoneOnce = listenDoneOnce;
 exports.listenError = listenError;
 exports.listenSignal = listenSignal;
 exports.listenSignalBacktest = listenSignalBacktest;

package/build/index.mjs

@@ -1583,6 +1583,11 @@ const signalBacktestEmitter = new Subject();
  * Emits errors caught in background tasks (Live.background, Backtest.background).
  */
 const errorEmitter = new Subject();
+/**
+ * Done emitter for background execution completion.
+ * Emits when background tasks complete (Live.background, Backtest.background).
+ */
+const doneEmitter = new Subject();
 
 /**
  * Connection service routing strategy operations to correct ClientStrategy instance.
@@ -1649,12 +1654,12 @@ class StrategyConnectionService {
             const tick = await strategy.tick();
             {
                 if (this.executionContextService.context.backtest) {
-                    signalBacktestEmitter.next(tick);
+                    await signalBacktestEmitter.next(tick);
                 }
                 if (!this.executionContextService.context.backtest) {
-                    signalLiveEmitter.next(tick);
+                    await signalLiveEmitter.next(tick);
                 }
-                signalEmitter.next(tick);
+                await signalEmitter.next(tick);
             }
             return tick;
         };
@@ -1676,9 +1681,9 @@ class StrategyConnectionService {
             const tick = await strategy.backtest(candles);
             {
                 if (this.executionContextService.context.backtest) {
-                    signalBacktestEmitter.next(tick);
+                    await signalBacktestEmitter.next(tick);
                 }
-                signalEmitter.next(tick);
+                await signalEmitter.next(tick);
             }
             return tick;
         };
@@ -3722,6 +3727,8 @@ const LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME = "event.listenSignalLiveOnce";
 const LISTEN_SIGNAL_BACKTEST_METHOD_NAME = "event.listenSignalBacktest";
 const LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME = "event.listenSignalBacktestOnce";
 const LISTEN_ERROR_METHOD_NAME = "event.listenError";
+const LISTEN_DONE_METHOD_NAME = "event.listenDone";
+const LISTEN_DONE_ONCE_METHOD_NAME = "event.listenDoneOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -3912,6 +3919,71 @@ function listenError(fn) {
     backtest$1.loggerService.log(LISTEN_ERROR_METHOD_NAME);
     return errorEmitter.subscribe(queued(async (error) => fn(error)));
 }
+/**
+ * Subscribes to background execution completion events with queued async processing.
+ *
+ * Emits when Live.background() or Backtest.background() completes execution.
+ * 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 completion events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenDone, Live } from "backtest-kit";
+ *
+ * const unsubscribe = listenDone((event) => {
+ *   console.log("Completed:", event.strategyName, event.exchangeName, event.symbol);
+ *   if (event.backtest) {
+ *     console.log("Backtest mode completed");
+ *   }
+ * });
+ *
+ * Live.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenDone(fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_METHOD_NAME);
+    return doneEmitter.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered background execution completion events with one-time execution.
+ *
+ * Emits when Live.background() or Backtest.background() completes execution.
+ * 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)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenDoneOnce, Backtest } from "backtest-kit";
+ *
+ * // Wait for first backtest completion
+ * listenDoneOnce(
+ *   (event) => event.backtest && event.symbol === "BTCUSDT",
+ *   (event) => console.log("BTCUSDT backtest completed:", event.strategyName)
+ * );
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ * ```
+ */
+function listenDoneOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_ONCE_METHOD_NAME);
+    return doneEmitter.filter(filterFn).once(fn);
+}
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
@@ -4129,6 +4201,12 @@ class BacktestUtils {
                         break;
                     }
                 }
+                await doneEmitter.next({
+                    exchangeName: context.exchangeName,
+                    strategyName: context.strategyName,
+                    backtest: true,
+                    symbol,
+                });
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
@@ -4291,6 +4369,12 @@ class LiveUtils {
                         break;
                     }
                 }
+                await doneEmitter.next({
+                    exchangeName: context.exchangeName,
+                    strategyName: context.strategyName,
+                    backtest: false,
+                    symbol,
+                });
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
@@ -4356,4 +4440,4 @@ class LiveUtils {
  */
 const Live = new LiveUtils();
 
-export { Backtest, ExecutionContextService, Live, MethodContextService, PersistBase, PersistSignalAdaper, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listenError, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };
+export { Backtest, ExecutionContextService, Live, MethodContextService, PersistBase, PersistSignalAdaper, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listenDone, listenDoneOnce, listenError, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",
@@ -42,7 +42,7 @@
     "build:docs": "rimraf docs && mkdir docs && node ./scripts/dts-docs.cjs ./types.d.ts ./docs",
     "docs:gpt": "npm run build && node ./scripts/gpt-docs.mjs",
     "docs:uml": "npm run build && node ./scripts/uml.mjs",
-    "docs:www": "rimraf docs/wwwroot && typedoc",
+    "docs:www": "rimraf docs/wwwroot && typedoc && node ./packages/typedoc-yandex-metrica/index.mjs",
     "repl": "dotenv -e .env -- npm run build && node -e \"import('./scripts/repl.mjs')\" --interactive"
   },
   "main": "build/index.cjs",

package/types.d.ts

@@ -645,6 +645,36 @@ declare function addExchange(exchangeSchema: IExchangeSchema): void;
  */
 declare function addFrame(frameSchema: IFrameSchema): void;
 
+/**
+ * Contract for background execution completion events.
+ *
+ * Emitted when Live.background() or Backtest.background() completes execution.
+ * Contains metadata about the completed execution context.
+ *
+ * @example
+ * ```typescript
+ * import { listenDone } from "backtest-kit";
+ *
+ * listenDone((event) => {
+ *   if (event.backtest) {
+ *     console.log("Backtest completed:", event.symbol);
+ *   } else {
+ *     console.log("Live trading completed:", event.symbol);
+ *   }
+ * });
+ * ```
+ */
+interface DoneContract {
+    /** exchangeName - Name of the exchange used in execution */
+    exchangeName: string;
+    /** strategyName - Name of the strategy that completed */
+    strategyName: string;
+    /** backtest - True if backtest mode, false if live mode */
+    backtest: boolean;
+    /** symbol - Trading symbol (e.g., "BTCUSDT") */
+    symbol: string;
+}
+
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -814,6 +844,65 @@ declare function listenSignalBacktestOnce(filterFn: (event: IStrategyTickResult)
  * ```
  */
 declare function listenError(fn: (error: Error) => void): () => void;
+/**
+ * Subscribes to background execution completion events with queued async processing.
+ *
+ * Emits when Live.background() or Backtest.background() completes execution.
+ * 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 completion events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenDone, Live } from "backtest-kit";
+ *
+ * const unsubscribe = listenDone((event) => {
+ *   console.log("Completed:", event.strategyName, event.exchangeName, event.symbol);
+ *   if (event.backtest) {
+ *     console.log("Backtest mode completed");
+ *   }
+ * });
+ *
+ * Live.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenDone(fn: (event: DoneContract) => void): () => void;
+/**
+ * Subscribes to filtered background execution completion events with one-time execution.
+ *
+ * Emits when Live.background() or Backtest.background() completes execution.
+ * 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)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenDoneOnce, Backtest } from "backtest-kit";
+ *
+ * // Wait for first backtest completion
+ * listenDoneOnce(
+ *   (event) => event.backtest && event.symbol === "BTCUSDT",
+ *   (event) => console.log("BTCUSDT backtest completed:", event.strategyName)
+ * );
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ * ```
+ */
+declare function listenDoneOnce(filterFn: (event: DoneContract) => boolean, fn: (event: DoneContract) => void): () => void;
 
 /**
  * Fetches historical candle data from the registered exchange.
@@ -2588,4 +2677,4 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { Backtest, type CandleInterval, ExecutionContextService, type FrameInterval, type ICandleData, type IExchangeSchema, type IFrameSchema, type IPersistBase, type ISignalDto, type ISignalRow, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, Live, MethodContextService, PersistBase, PersistSignalAdaper, type SignalInterval, type TPersistBase, type TPersistBaseCtor, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listenError, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };
+export { Backtest, type CandleInterval, type EntityId, ExecutionContextService, type FrameInterval, type ICandleData, type IExchangeSchema, type IFrameSchema, type IPersistBase, type ISignalData, type ISignalDto, type ISignalRow, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, Live, MethodContextService, PersistBase, PersistSignalAdaper, type SignalInterval, type TPersistBase, type TPersistBaseCtor, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listenDone, listenDoneOnce, listenError, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };