backtest-kit 9.8.4 → 10.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "9.8.4",
+  "version": "10.1.0",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",

package/types.d.ts

@@ -2424,6 +2424,8 @@ type SignalInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h";
 interface ISignalDto {
     /** Optional signal ID (auto-generated if not provided) */
     id?: string;
+    /** Symbol of a ticker on exchange */
+    symbol?: string;
     /** Trade direction: "long" (buy) or "short" (sell) */
     position: "long" | "short";
     /** Human-readable description of signal reason */
@@ -26141,6 +26143,410 @@ declare class IntervalUtils {
  */
 declare const Interval: IntervalUtils;
 
+/**
+ * Callback signature for a cron entry handler.
+ *
+ * Invocation cardinality depends on `entry.symbols` (see {@link CronEntry}):
+ * - **Global mode** (`symbols` empty/undefined): invoked once per aligned
+ *   boundary across all parallel backtests. The first symbol to reach the
+ *   boundary opens the slot and runs the handler; others await the same
+ *   promise.
+ * - **Fan-out mode** (`symbols` non-empty): invoked once per aligned
+ *   boundary **per whitelisted symbol**. Each symbol has its own slot.
+ *
+ * @param symbol - In global mode: the symbol of the backtest that first
+ *   reached the boundary (the singleshot "winner"). In fan-out mode: the
+ *   whitelisted symbol whose tick produced this invocation.
+ * @param when - The aligned virtual time at which the entry fires.
+ *   Already aligned to the entry's `interval` boundary (e.g. for `1h`,
+ *   minutes/seconds/ms are zero). In fire-once mode this is the tick time
+ *   aligned to the 1-minute boundary (the base alignment `_tick` applies
+ *   to every incoming tick), not raw wall-clock with sub-second precision.
+ * @param backtest - Execution-mode flag taken from the originating lifecycle
+ *   event (`beforeStart` / `idlePing` / `activePing` / `schedulePing`,
+ *   wired by `Cron.enable()`). `true` for backtest runs, `false` for live.
+ *   The value reflects the **opening** tick that won the singleshot for
+ *   this slot — all parallel awaiters of the same slot observe the same
+ *   value, even if a later concurrent tick carried a different one.
+ */
+type CronCallback = (symbol: string, when: Date, backtest: boolean) => void | Promise<void>;
+/**
+ * Configuration for a registered cron entry.
+ */
+interface CronEntry {
+    /**
+     * Unique name of the entry. Used as the dedup key on `register` (re-registering
+     * the same name replaces the previous entry) and as part of the singleshot
+     * coordination key.
+     *
+     * Must be non-empty and must not contain `:` — `:` is reserved as the slot-key
+     * segment separator and would otherwise create ambiguity between global and
+     * fan-out fire-once keys.
+     */
+    name: string;
+    /**
+     * Candle interval at whose boundaries the handler fires.
+     * Same scale as {@link CandleInterval} used by `Interval` and `Cache`:
+     * `"1m" | "5m" | "1h" | "1d"` etc.
+     *
+     * If omitted, the entry switches to **fire-once** mode: the handler is
+     * invoked on the very first matching tick (no boundary check) and never
+     * again. If the handler throws, the entry is **not** marked as fired and
+     * will retry on the next tick.
+     */
+    interval?: CandleInterval;
+    /**
+     * Symbol whitelist that doubles as the fan-out switch.
+     *
+     * - **Empty/undefined → global singleshot**: across all parallel backtests
+     *   the handler runs **once** per boundary. The first symbol to reach the
+     *   boundary opens the slot; others await the same promise.
+     * - **Non-empty → per-symbol fan-out**: ticks whose `symbol` is not in the
+     *   list are skipped, and ticks whose `symbol` *is* in the list each open
+     *   their own slot. The handler runs **once per whitelisted symbol** per
+     *   boundary.
+     *
+     * The same rule applies in fire-once mode: global → handler runs once
+     * total; fan-out → once per whitelisted symbol.
+     *
+     * Each symbol must not contain `:` (same reason as {@link CronEntry.name}).
+     */
+    symbols?: string[];
+    /** Handler invoked on the first parallel tick to reach a new boundary. */
+    handler: CronCallback;
+}
+/**
+ * Handle returned from `register`. Call it to unregister the entry —
+ * equivalent to `Cron.unregister(name)`.
+ *
+ * @example
+ * ```typescript
+ * const dispose = Cron.register({
+ *   name: "x",
+ *   interval: "1h",
+ *   handler: async (symbol, when, backtest) => { ... },
+ * });
+ * dispose(); // unregisters
+ * ```
+ */
+interface CronHandle {
+    (): void;
+}
+/**
+ * Utility class for registering periodic tasks that fire on candle-interval
+ * boundaries of the virtual time produced by parallel backtests.
+ *
+ * Exported as singleton instance `Cron` for convenient usage.
+ *
+ * Key property — **singleshot coordination across parallel backtests**:
+ * when several `Backtest.background(symbol, ...)` runs hit the same aligned
+ * boundary concurrently, the handler is invoked exactly once. Every parallel
+ * `tick` for that boundary awaits the same in-flight promise and is released
+ * together when the promise settles. After settlement the slot is cleared and
+ * the next boundary produces a fresh promise.
+ *
+ * Typical wiring:
+ *
+ * @example
+ * ```typescript
+ * import { Cron, Backtest } from "backtest-kit";
+ *
+ * Cron.register({
+ *   name: "tg-signal-parser",
+ *   interval: "1h",
+ *   handler: async (symbol, when, backtest) => {
+ *     await parseTelegramSignalsToMongo(when);
+ *   },
+ * });
+ *
+ * // Subscribe Cron to the engine's lifecycle subjects (beforeStart,
+ * // idlePing, activePing, schedulePing) once at startup. After this every
+ * // strategy tick is forwarded into Cron automatically.
+ * Cron.enable();
+ *
+ * for (const symbol of ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "TRXUSDT"]) {
+ *   Backtest.background(symbol, { strategyName, exchangeName, frameName });
+ * }
+ *
+ * // On shutdown:
+ * // Cron.disable();
+ * ```
+ */
+declare class CronUtils {
+    /**
+     * Registered entries by `name`.
+     *
+     * Each record carries a monotonically increasing `generation` counter that
+     * is bumped on every `register(entry)` call for the same name. The
+     * generation participates in `firedKey` so writes from a still-in-flight
+     * handler of a previous incarnation cannot poison `_firedOnce` for the
+     * current incarnation — their key has a different generation suffix and
+     * is simply ignored on lookup.
+     */
+    private readonly _entries;
+    /** Monotonic counter used to mint new entry generations on `register`. */
+    private _generationCounter;
+    /**
+     * In-flight handler slots.
+     *
+     * Slot key shape (always includes the generation suffix `:g${generation}`;
+     * the `:${symbol}` scope is present only in fan-out mode):
+     * - Periodic global: `${name}:${alignedMs}:g${generation}`.
+     * - Periodic fan-out: `${name}:${alignedMs}:${symbol}:g${generation}`.
+     * - Fire-once global: `${name}:once:g${generation}`.
+     * - Fire-once fan-out: `${name}:once:${symbol}:g${generation}`.
+     *
+     * Value is the shared in-flight handler promise. Every parallel `tick` for
+     * the same slot key awaits this exact promise (mutex semantics) and is
+     * released together when it settles. `_inFlight` is owned exclusively by
+     * `_runEntry` — `clear()` does **not** touch it, so the singleshot promise
+     * survives concurrent `clear` calls and continues to coordinate parallel
+     * ticks until it settles.
+     */
+    private readonly _inFlight;
+    /**
+     * Keys of fire-once entries whose handler has already settled successfully.
+     *
+     * Key shape (always includes the entry generation suffix `:g${generation}`):
+     * - Global fire-once: `${name}:g${generation}`.
+     * - Fan-out fire-once: `${name}:${symbol}:g${generation}` — one entry per
+     *   whitelisted symbol.
+     *
+     * The generation suffix isolates incarnations of the same `name`: writes
+     * landing from a still-in-flight handler of a previous `register()` carry
+     * the old generation and are never matched by the new entry's lookup.
+     * Stale entries are pruned by `_clearFiredOnceFor` on `register`/`unregister`
+     * and wiped by `clear()`.
+     *
+     * Looked up by `_tick` to decide whether to skip; written by `_runEntry`
+     * on successful settle.
+     */
+    private readonly _firedOnce;
+    /**
+     * Garbage-collect every `_firedOnce` key that belongs to the entry `name`
+     * (any generation, global or fan-out).
+     *
+     * Called from `register`/`unregister` to free memory; **not** required
+     * for correctness — the generation suffix already isolates re-registrations,
+     * so leftover keys from old generations can never block a new entry.
+     * They just sit unused until they are GC'd here or wiped by `clear()`.
+     */
+    private _clearFiredOnceFor;
+    /**
+     * Build the singleshot promise for a single in-flight slot.
+     *
+     * Invokes `entry.handler(symbol, aligned, backtest)`, swallows and logs
+     * any error via `console.error`, and clears the `_inFlight` slot
+     * in `.finally()` so the next boundary produces a fresh promise. For
+     * fire-once entries `firedKey` is added to `_firedOnce` on success so
+     * subsequent ticks skip it.
+     *
+     * @param firedKey - Key to add to `_firedOnce` on success, or `null` for
+     *   periodic entries (which never populate `_firedOnce`).
+     * @param backtest - Value forwarded as the third handler argument; the
+     *   "winner" tick's flag is what all parallel awaiters of this slot see.
+     */
+    private _runEntry;
+    /**
+     * Register a periodic cron entry.
+     *
+     * Idempotent on `name`: re-registering the same name replaces the previous
+     * entry (interval/symbols/handler can all change). Re-registration does
+     * **not** clear in-flight promises — entries still resolving complete with
+     * the previous handler.
+     *
+     * @param entry - Entry configuration; see {@link CronEntry}.
+     * @returns Disposer function — call it to unregister the entry.
+     *
+     * @example
+     * ```typescript
+     * const dispose = Cron.register({
+     *   name: "fetch-funding",
+     *   interval: "8h",
+     *   symbols: ["BTCUSDT", "ETHUSDT"],
+     *   handler: async (symbol, when, backtest) => { ... },
+     * });
+     * // Later:
+     * dispose();
+     * ```
+     */
+    register: (entry: CronEntry) => CronHandle;
+    /**
+     * Remove a registered entry by name.
+     *
+     * Does not cancel handlers already in flight — those resolve on their own
+     * and clear their slot via `.finally()`.
+     *
+     * @param name - Name passed to `register`.
+     */
+    unregister: (name: string) => void;
+    /**
+     * Clear fire-once marks so that fire-once entries can fire again.
+     *
+     * Does **not** touch `_inFlight` — that map holds shared in-flight handler
+     * promises through which parallel `tick`s coordinate. Wiping it mid-flight
+     * would let a new `tick` start a second handler for a boundary that's
+     * already running, breaking the singleshot contract.
+     *
+     * Two modes:
+     * - **Per-symbol** (`symbol` provided): clears only fan-out fire-once
+     *   marks for that symbol — keys of the shape `${name}:${symbol}:g${gen}`.
+     *   Global fire-once marks (`${name}:g${gen}`, no symbol component) are
+     *   left intact, since they are not attributable to a single symbol.
+     *   Useful for re-arming fan-out fire-once entries when a particular
+     *   symbol's run finishes and you want a future re-run to fire again.
+     * - **All** (no argument): wipes every fire-once mark across all entries
+     *   and symbols. Registered entries are not removed — use `unregister`
+     *   (or the disposer returned by `register`) for that.
+     *
+     * **Race with in-flight handlers.** `_firedOnce` is written in
+     * `_runEntry`'s `.finally()`, which can run *after* a concurrent
+     * `clear()` call. In that case the fire-once mark reappears immediately
+     * after being wiped, and the next tick will treat the entry as already
+     * fired. This is consistent with the singleshot promise itself surviving
+     * `clear()` — the handler is allowed to finish — and the entry's
+     * generation suffix in `firedKey` guarantees the stale mark cannot
+     * outlive a subsequent `register()` of the same name. If you need a hard
+     * re-arm, `unregister` + `register` bumps the generation and makes any
+     * late write a no-op.
+     *
+     * @param symbol - Optional symbol filter; if omitted, clears all fire-once
+     *   marks.
+     */
+    clear: (symbol?: string) => void;
+    /**
+     * Process a virtual-time tick for `symbol` and fire any due cron entries.
+     *
+     * **Private.** Invoked exclusively by the lifecycle bridge installed in
+     * {@link enable} — `beforeStart` / `idlePing` / `activePing` / `schedulePing`
+     * are funneled here through a shared `singlerun` queue, so calls to
+     * `_tick` are serialised end-to-end. Do not call directly.
+     *
+     * Algorithm (per registered entry):
+     * 0. Base-align the incoming `when` down to the 1-minute boundary (`ts`).
+     *    Lifecycle subjects may emit with sub-second jitter; rounding here
+     *    guarantees that `beforeStart` / `idlePing` / `activePing` /
+     *    `schedulePing` for the same virtual minute all hash to the same
+     *    slot key.
+     * 1. If `entry.symbols` is non-empty and does not include `symbol`, skip.
+     * 2. Decide scope from `entry.symbols`:
+     *    - Empty/undefined → **global** (slot key has no symbol component).
+     *    - Non-empty → **fan-out**, slot key carries `:${symbol}` so each
+     *      whitelisted symbol gets its own slot and handler invocation.
+     * 3. Append the current entry generation suffix `:g${generation}` to both
+     *    slot key and fired-once key. This isolates incarnations of the same
+     *    `name`: a `register()` after an in-flight handler bumps the
+     *    generation, so the late `_firedOnce` write from the old handler can
+     *    never block the new entry.
+     * 4. **Fire-once** (`entry.interval === undefined`):
+     *    - If the entry's fired-once key is already in `_firedOnce`, skip.
+     *    - Slot key: `${name}:once` (+ scope) (+ gen).
+     *    - `aligned` = the 1-minute-aligned `when` from step 0.
+     * 5. **Periodic** (`entry.interval` set):
+     *    - Align `when` further to the entry's interval via {@link alignToInterval}.
+     *    - If `ts !== alignedMs`, the tick is mid-interval — skip.
+     *      (This is the "remainder === 0" boundary check from the spec;
+     *      since `ts` is already on the 1-minute boundary, the check is exact
+     *      for `1m` and consistent for higher intervals.)
+     *    - Slot key: `${name}:${alignedMs}` (+ scope) (+ gen).
+     * 6. Singleshot per slot key: look up the slot in `_inFlight`. If a promise
+     *    already exists, `await` the same promise. Otherwise invoke
+     *    `entry.handler`, store the promise, and `await` it. The slot is
+     *    removed in `.finally()` so the next boundary creates a fresh promise;
+     *    for fire-once entries the fired-once key is also added to
+     *    `_firedOnce` on success so subsequent ticks skip it.
+     *
+     * Errors thrown by `handler` are caught, logged via `console.error`, and
+     * **not** rethrown — a failing handler must not break the per-symbol
+     * tick loop or unblock other parallel backtests with an unhandled
+     * rejection. A failed fire-once handler is **not** marked as fired and
+     * will retry on the next tick.
+     *
+     * Requires active method context and execution context.
+     *
+     * @param symbol - Trading symbol from the current tick.
+     * @param when - Virtual time of the current tick.
+     * @param backtest - `true` for backtest ticks, `false` for live ticks.
+     *   Forwarded as the third argument to `entry.handler`. Only the value
+     *   from the tick that **opens** a given slot is observed by all parallel
+     *   awaiters of that slot.
+     * @throws Error if method or execution context is missing.
+     */
+    private _tick;
+    /**
+     * Subscribe `Cron` to the engine's strategy lifecycle subjects so registered
+     * entries fire automatically — no manual wiring of `listenTickBacktest` /
+     * `listenSchedulePing` etc. needed.
+     *
+     * Subjects funneled into {@link _tick}:
+     * - `beforeStartSubject` — first event of every run.
+     * - `idlePingSubject` — every tick when no signal is pending or scheduled.
+     * - `activePingSubject` — every tick while a pending signal is being monitored.
+     * - `schedulePingSubject` — every tick while a scheduled signal is being monitored.
+     *
+     * All four subjects are subscribed to a single `singlerun`-wrapped
+     * handler that builds `_tick(event.symbol, new Date(event.timestamp),
+     * event.backtest)`. `singlerun` merges the four streams into one serial
+     * queue: at most one `_tick` runs at a time, the next waits. This matters
+     * because the engine can emit `beforeStart` and an immediate `idlePing`
+     * on the very same minute, and concurrent `_tick`s on the same
+     * `(symbol, minute)` would otherwise race to open the same `_inFlight`
+     * slot before either commit. Together these four sources cover every
+     * tick the engine processes for every `(symbol, virtual-minute)` pair
+     * regardless of whether the strategy is idle, active, or scheduled.
+     *
+     * `enable` itself is wrapped in `singleshot`, so calling it repeatedly is
+     * a no-op — subsequent calls return the same disposer. The disposer
+     * unsubscribes from every subject and resets the singleshot so a future
+     * `enable()` can re-subscribe cleanly. Equivalent to the
+     * `RecentAdapter.enable` pattern.
+     *
+     * The `.subscribe` callbacks are synchronous wrappers around the
+     * `singlerun`-async handler; `_tick`'s returned promise is awaited inside
+     * `singlerun` to enforce ordering but not bubbled back to the subject.
+     * Errors are caught and logged inside `_runEntry`.
+     *
+     * @returns Cleanup function that unsubscribes from all four subjects and
+     *   resets the singleshot. Idempotent.
+     *
+     * @example
+     * ```typescript
+     * import { Cron } from "backtest-kit";
+     *
+     * Cron.register({ name: "tg-parser", interval: "1h", handler });
+     * Cron.enable(); // wire once at startup
+     * // ... run backtests / live as usual
+     * Cron.disable(); // on shutdown
+     * ```
+     */
+    enable: (() => (...args: any[]) => any) & functools_kit.ISingleshotClearable<() => (...args: any[]) => any>;
+    /**
+     * Tear down the lifecycle subscriptions installed by {@link enable}.
+     *
+     * Safe to call multiple times and safe to call before `enable()` — both
+     * are no-ops. Does **not** unregister entries, does **not** touch
+     * `_inFlight`, and does **not** wipe `_firedOnce` (use `unregister` or
+     * `clear()` for those).
+     */
+    disable: () => void;
+}
+/**
+ * Singleton instance of {@link CronUtils} for registering periodic tasks
+ * coordinated across parallel `Backtest.background` runs.
+ *
+ * @example
+ * ```typescript
+ * import { Cron } from "backtest-kit";
+ *
+ * Cron.register({
+ *   name: "tg-parser",
+ *   interval: "1h",
+ *   handler: async (symbol, when, backtest) => { ... },
+ * });
+ * ```
+ */
+declare const Cron: CronUtils;
+
 /**
  * Type alias for column configuration used in breakeven markdown reports.
  *
@@ -28808,6 +29214,73 @@ interface IParseArgsResult extends IParseArgsParams {
  */
 declare const parseArgs: ({ symbol, strategyName, exchangeName, frameName, }?: Partial<IParseArgsParams>) => IParseArgsResult;
 
+/**
+ * Wraps a function so it always runs outside any active method or execution context.
+ *
+ * When the wrapped function is called, `beginContext` checks whether
+ * `MethodContextService` or `ExecutionContextService` currently have an active
+ * scope and, if so, escapes each one with `runOutOfContext` before invoking `run`.
+ * This prevents accidental context leakage from a caller into a logically independent
+ * operation (e.g. an internal runner that must establish its own fresh context).
+ *
+ * The returned wrapper preserves the original function's parameter and return types,
+ * so it is a transparent drop-in replacement.
+ *
+ * @template T - Type of the wrapped function.
+ * @param run - Function to wrap.
+ * @returns A new function with the same signature as `run` that escapes any
+ *   active context before executing.
+ *
+ * @example
+ * ```typescript
+ * const runInContextInternal = beginContext(
+ *   async (run: () => Promise<void>, context: IRunContext) => {
+ *     return await MethodContextService.runInContext(
+ *       () => ExecutionContextService.runInContext(run, context),
+ *       context,
+ *     );
+ *   },
+ * );
+ * ```
+ */
+declare const beginContext: <T extends (...args: any[]) => any>(run: T) => ((...args: Parameters<T>) => ReturnType<T>);
+
+/**
+ * Wraps a function to execute it outside of the current execution context if one exists.
+ *
+ * This utility ensures that the wrapped function runs in isolation from any existing
+ * ExecutionContext, preventing context leakage and unintended context sharing between
+ * async operations.
+ *
+ * @template T - Function type with any parameters and return type
+ * @param {T} run - The function to be wrapped and executed outside of context
+ * @returns {Function} A curried function that accepts the original function's parameters
+ *                     and executes it outside of the current context if one exists
+ *
+ * @example
+ * ```ts
+ * const myFunction = async (param: string) => {
+ *   // This code will run outside of any ExecutionContext
+ *   return param.toUpperCase();
+ * };
+ *
+ * const wrappedFunction = beginTime(myFunction);
+ * const result = wrappedFunction('hello'); // Returns 'HELLO'
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Usage with trycatch wrapper
+ * const safeFunction = trycatch(
+ *   beginTime(async (id: number) => {
+ *     // Function body runs isolated from parent context
+ *     return await fetchData(id);
+ *   })
+ * );
+ * ```
+ */
+declare const beginTime: <T extends (...args: any[]) => any>(run: T) => ((...args: Parameters<T>) => ReturnType<T>);
+
 /**
  * Retrieves a value from an object using a given path.
  *
@@ -36308,6 +36781,13 @@ interface Signal$2 extends ISignalDto {
  */
 declare const toProfitLossDto: (signal: Signal$2, priceClose: number) => IStrategyPnL;
 
+/**
+ * Converts markdown content to plain text with minimal formatting
+ * @param content - Markdown string to convert
+ * @returns Plain text representation
+ */
+declare const toPlainString: (content: string) => string;
+
 interface Signal$1 extends ISignalDto {
     priceOpen: number;
     _entry?: ISignalRow['_entry'];
@@ -36359,4 +36839,4 @@ declare const getTotalClosed: (signal: Signal) => {
     remainingCostBasis: number;
 };
 
-export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AfterEndContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, type BeforeStartContract, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, type CommitPayload, Constant, type CriticalErrorNotification, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPersistBreakevenInstance, type IPersistCandleInstance, type IPersistIntervalInstance, type IPersistLogInstance, type IPersistMeasureInstance, type IPersistMemoryInstance, type IPersistNotificationInstance, type IPersistPartialInstance, type IPersistRecentInstance, type IPersistRiskInstance, type IPersistScheduleInstance, type IPersistSessionInstance, type IPersistSignalInstance, type IPersistStateInstance, type IPersistStorageInstance, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IRecentUtils, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISessionInstance, type ISignalDto, type ISignalIntervalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStateInstance, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type IdlePingContract, type InfoErrorNotification, Interval, type IntervalData, Live, type LiveStatisticsModel, Log, type LogData, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, MarkdownWriter, MaxDrawdown, type MaxDrawdownContract, type MaxDrawdownEvent, type MaxDrawdownStatisticsModel, type MeasureData, Memory, MemoryBacktest, MemoryBacktestAdapter, type MemoryData, MemoryLive, MemoryLiveAdapter, type MessageModel, type MessageRole, type MessageToolCall, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, 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, type ProgressBacktestContract, type ProgressWalkerContract, Recent, RecentBacktest, type RecentData, RecentLive, Reflect, Report, ReportBase, type ReportName, ReportWriter, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, Session, SessionBacktest, type SessionData, SessionLive, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInfoContract, type SignalInfoNotification, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, State, StateBacktest, StateBacktestAdapter, type StateData, StateLive, StateLiveAdapter, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, System, type TBrokerCtor, type TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TPersistBreakevenInstanceCtor, type TPersistCandleInstanceCtor, type TPersistIntervalInstanceCtor, type TPersistLogInstanceCtor, type TPersistMeasureInstanceCtor, type TPersistMemoryInstanceCtor, type TPersistNotificationInstanceCtor, type TPersistPartialInstanceCtor, type TPersistRecentInstanceCtor, type TPersistRiskInstanceCtor, type TPersistScheduleInstanceCtor, type TPersistSessionInstanceCtor, type TPersistSignalInstanceCtor, type TPersistStateInstanceCtor, type TPersistStorageInstanceCtor, type TRecentUtilsCtor, type TReportBase, type TSessionInstanceCtor, type TStateInstanceCtor, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, 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 };
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AfterEndContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, type BeforeStartContract, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, type CommitPayload, Constant, type CriticalErrorNotification, Cron, type CronCallback, type CronEntry, type CronHandle, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPersistBreakevenInstance, type IPersistCandleInstance, type IPersistIntervalInstance, type IPersistLogInstance, type IPersistMeasureInstance, type IPersistMemoryInstance, type IPersistNotificationInstance, type IPersistPartialInstance, type IPersistRecentInstance, type IPersistRiskInstance, type IPersistScheduleInstance, type IPersistSessionInstance, type IPersistSignalInstance, type IPersistStateInstance, type IPersistStorageInstance, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IRecentUtils, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISessionInstance, type ISignalDto, type ISignalIntervalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStateInstance, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type IdlePingContract, type InfoErrorNotification, Interval, type IntervalData, Live, type LiveStatisticsModel, Log, type LogData, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, MarkdownWriter, MaxDrawdown, type MaxDrawdownContract, type MaxDrawdownEvent, type MaxDrawdownStatisticsModel, type MeasureData, Memory, MemoryBacktest, MemoryBacktestAdapter, type MemoryData, MemoryLive, MemoryLiveAdapter, type MessageModel, type MessageRole, type MessageToolCall, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, 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, type ProgressBacktestContract, type ProgressWalkerContract, Recent, RecentBacktest, type RecentData, RecentLive, Reflect, Report, ReportBase, type ReportName, ReportWriter, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, Session, SessionBacktest, type SessionData, SessionLive, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInfoContract, type SignalInfoNotification, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, State, StateBacktest, StateBacktestAdapter, type StateData, StateLive, StateLiveAdapter, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, System, type TBrokerCtor, type TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TPersistBreakevenInstanceCtor, type TPersistCandleInstanceCtor, type TPersistIntervalInstanceCtor, type TPersistLogInstanceCtor, type TPersistMeasureInstanceCtor, type TPersistMemoryInstanceCtor, type TPersistNotificationInstanceCtor, type TPersistPartialInstanceCtor, type TPersistRecentInstanceCtor, type TPersistRiskInstanceCtor, type TPersistScheduleInstanceCtor, type TPersistSessionInstanceCtor, type TPersistSignalInstanceCtor, type TPersistStateInstanceCtor, type TPersistStorageInstanceCtor, type TRecentUtilsCtor, type TReportBase, type TSessionInstanceCtor, type TStateInstanceCtor, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, 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, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };