backtest-kit 13.6.0 → 14.1.0

package/types.d.ts

@@ -1122,6 +1122,181 @@ interface SchedulePingContract {
     timestamp: number;
 }
 
+/**
+ * Contract for scheduled signal lifecycle events (creation and cancellation).
+ *
+ * Emitted by scheduleEventSubject when a scheduled signal is created (added) or cancelled
+ * during tick()/backtest() processing. Lets consumers track the scheduled phase of a signal
+ * without subscribing to the full signal stream.
+ *
+ * IMPORTANT: The scheduled -> active transition (activation) is intentionally NOT emitted here.
+ * Activation produces an "opened" signal on the regular signal emitters; this contract only
+ * covers a scheduled signal being put in place and being removed before it ever opened.
+ *
+ * Consumers:
+ * - User callbacks via listenScheduleEvent() / listenScheduleEventOnce()
+ *
+ * @example
+ * ```typescript
+ * import { listenScheduleEvent } from "backtest-kit";
+ *
+ * listenScheduleEvent((event) => {
+ *   if (event.action === "scheduled") {
+ *     console.log(`Scheduled ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Cancelled ${event.symbol} (reason: ${event.reason})`);
+ *   }
+ * });
+ * ```
+ */
+interface ScheduleEventContract {
+    /**
+     * Lifecycle action for the scheduled signal.
+     * - "scheduled": a new scheduled signal was created (waiting for priceOpen activation)
+     * - "cancelled": the scheduled signal was removed before activation (timeout / price reject / user)
+     */
+    action: "scheduled" | "cancelled";
+    /**
+     * Trading pair symbol (e.g., "BTCUSDT").
+     * Identifies which market this event belongs to.
+     */
+    symbol: string;
+    /**
+     * Strategy name that owns this scheduled signal.
+     */
+    strategyName: StrategyName;
+    /**
+     * Exchange name where this scheduled signal lives.
+     */
+    exchangeName: ExchangeName;
+    /**
+     * Frame name (timeframe / date range) for the run. Empty string in live mode.
+     * Same value as the signal's `frameName` (`data.frameName`).
+     */
+    frameName: FrameName;
+    /**
+     * Complete scheduled signal row data in public form.
+     * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss, etc.
+     */
+    data: IPublicSignalRow;
+    /**
+     * Cancellation reason. Present only when `action === "cancelled"`:
+     * - "timeout": CC_SCHEDULE_AWAIT_MINUTES elapsed without reaching priceOpen
+     * - "price_reject": price hit stop-loss before activation
+     * - "user": cancelled via cancelScheduled()
+     *
+     * Always undefined when `action === "scheduled"`.
+     */
+    reason?: StrategyCancelReason;
+    /**
+     * Current market price of the symbol at the time of the event.
+     */
+    currentPrice: number;
+    /**
+     * Execution mode flag.
+     * - true: Event from backtest execution (historical candle data)
+     * - false: Event from live trading (real-time tick)
+     */
+    backtest: boolean;
+    /**
+     * Event timestamp in milliseconds since Unix epoch.
+     *
+     * Timing semantics:
+     * - Live mode: when.getTime() at the moment of the event
+     * - Backtest mode: candle.timestamp of the candle being processed
+     */
+    timestamp: number;
+}
+
+/**
+ * Contract for pending signal lifecycle events (open and close).
+ *
+ * Emitted by signalEventSubject when a pending position is opened (action "opened") or closed
+ * (action "closed") during tick()/backtest() processing. Lets consumers track the active phase
+ * of a signal without subscribing to the full signal stream.
+ *
+ * Covers every way a position opens (new signal, immediate entry, scheduled activation, user
+ * activation) and every way it closes (take_profit / stop_loss / time_expired / user-close /
+ * broker fill / order no longer pending).
+ *
+ * Consumers:
+ * - User callbacks via listenSignalEvent() / listenSignalEventOnce()
+ *
+ * @example
+ * ```typescript
+ * import { listenSignalEvent } from "backtest-kit";
+ *
+ * listenSignalEvent((event) => {
+ *   if (event.action === "opened") {
+ *     console.log(`Opened ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Closed ${event.symbol} (reason: ${event.closeReason})`);
+ *   }
+ * });
+ * ```
+ */
+interface SignalEventContract {
+    /**
+     * Lifecycle action for the pending signal.
+     * - "opened": a pending position was opened (new signal / immediate / scheduled or user activation)
+     * - "closed": the pending position was closed (TP / SL / time_expired / user / broker fill / ping)
+     */
+    action: "opened" | "closed";
+    /**
+     * Trading pair symbol (e.g., "BTCUSDT").
+     * Identifies which market this event belongs to.
+     */
+    symbol: string;
+    /**
+     * Strategy name that owns this pending signal.
+     */
+    strategyName: StrategyName;
+    /**
+     * Exchange name where this pending signal lives.
+     */
+    exchangeName: ExchangeName;
+    /**
+     * Frame name (timeframe / date range) for the run. Empty string in live mode.
+     * Same value as the signal's `frameName` (`data.frameName`).
+     */
+    frameName: FrameName;
+    /**
+     * Complete pending signal row data in public form.
+     * Contains all signal information: id, position, priceOpen, priceTakeProfit, priceStopLoss,
+     * effective entry / trailing SL/TP, PnL, etc.
+     */
+    data: IPublicSignalRow;
+    /**
+     * Close reason. Present only when `action === "closed"`:
+     * - "take_profit": effective take-profit level reached
+     * - "stop_loss": effective stop-loss level reached
+     * - "time_expired": position exceeded minuteEstimatedTime
+     * - "closed": closed by user (closePending) or because the order is no longer open on the exchange
+     *
+     * Always undefined when `action === "opened"`.
+     */
+    closeReason?: StrategyCloseReason;
+    /**
+     * Current market price of the symbol at the time of the event.
+     * For "opened" this is the effective entry (priceOpen); for "closed" the close price.
+     */
+    currentPrice: number;
+    /**
+     * Execution mode flag.
+     * - true: Event from backtest execution (historical candle data)
+     * - false: Event from live trading (real-time tick)
+     */
+    backtest: boolean;
+    /**
+     * Event timestamp in milliseconds since Unix epoch.
+     *
+     * Timing semantics:
+     * - Live mode: when.getTime() at the moment of the event
+     * - Backtest mode: candle.timestamp of the candle being processed
+     */
+    timestamp: number;
+}
+
 /**
  * Contract for active ping events during active pending signal monitoring.
  *
@@ -1521,8 +1696,8 @@ type SignalSyncContract = SignalOpenContract | SignalCloseContract;
  * Backtest never emits this event — there is no live exchange to query.
  *
  * Consumers:
- * - Broker adapter via `onOrderPing` (syncPendingSubject subscription)
- * - Registered actions via `orderPing` / `onOrderPing`
+ * - Broker adapter via `onOrderCheck` (syncPendingSubject subscription)
+ * - Registered actions via `orderCheck` / `onOrderCheck`
  */
 interface SignalPingContract {
     /** Discriminator for pending-ping action */
@@ -1834,6 +2009,96 @@ interface IActionCallbacks {
      * @param backtest - True for backtest mode, false for live trading
      */
     onPingScheduled(event: SchedulePingContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
+    /**
+     * Called on scheduled signal lifecycle events (creation / cancellation).
+     *
+     * Triggered by: StrategyConnectionService via scheduleEventSubject
+     * Frequency: Once on creation (action "scheduled") and once on cancellation before activation
+     * (action "cancelled": timeout / price_reject / user). The scheduled -> active transition is
+     * NOT reported here — activation surfaces as an "opened" signal instead.
+     *
+     * Manual wiring — EVENT-BASED (driving the exchange from an action registered via `addActionSchema`)
+     *
+     * An action is the alternative to a Broker adapter for binding the framework to a real exchange:
+     * both run inside the strategy tick, so the commit-functions from `src/function/strategy.ts` are
+     * callable here and take effect on the next tick. On `event.action === "scheduled"` place the real
+     * resting/limit order (tag it with `event.data.id`) and, if it resolves at once, call
+     * `commitActivateScheduled(event.symbol, { id })`; on a reject call
+     * `commitCancelScheduled(event.symbol, { id })`. On `event.action === "cancelled"` (the strategy has
+     * already dropped the scheduled signal) cancel the matching exchange order; `event.reason` says why.
+     * For ongoing polling of the resting order use `onPingScheduled` (every tick).
+     *
+     * @param event - Scheduled lifecycle data (action discriminates created vs cancelled)
+     * @param actionName - Action identifier
+     * @param strategyName - Strategy identifier
+     * @param frameName - Timeframe identifier
+     * @param backtest - True for backtest mode, false for live trading
+     *
+     * @example
+     * ```typescript
+     * import { addActionSchema, commitActivateScheduled, commitCancelScheduled } from "backtest-kit";
+     *
+     * addActionSchema({
+     *   actionName: "exchange-bridge",
+     *   callbacks: {
+     *     async onScheduleEvent(event) {
+     *       if (event.action === "scheduled") {
+     *         const order = await exchange.placeLimit(event.symbol, event.data.priceOpen, event.data.id);
+     *         if (order.status === "filled") await commitActivateScheduled(event.symbol, { id: order.id });
+     *       } else {
+     *         await exchange.cancelOrderById(event.data.id);
+     *       }
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    onScheduleEvent(event: ScheduleEventContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
+    /**
+     * Called on pending signal lifecycle events (open / close).
+     *
+     * Triggered by: StrategyConnectionService via signalEventSubject
+     * Frequency: Once when a pending position is opened (action "opened": new signal / immediate /
+     * scheduled or user activation) and once when it is closed (action "closed" with closeReason
+     * take_profit / stop_loss / time_expired / closed).
+     *
+     * Manual wiring — EVENT-BASED (driving the exchange from an action registered via `addActionSchema`)
+     *
+     * Alternative to a Broker adapter — the commit-functions from `src/function/strategy.ts` are
+     * callable here (same tick context) and apply on the next tick. On `event.action === "opened"`
+     * place the real entry + protective TP/SL orders; on `event.action === "closed"` (the strategy has
+     * already removed the signal) flatten the real position and cancel leftover orders.
+     *
+     * Note: `onPendingEvent` fires only at open/close — it is NOT a per-tick monitor. To translate
+     * intra-position exchange fills into `commitCreateTakeProfit` / `commitCreateStopLoss` /
+     * `commitClosePending` on every tick, use `onPingActive` (fires each tick while the position is open).
+     *
+     * @param event - Pending lifecycle data (action discriminates opened vs closed)
+     * @param actionName - Action identifier
+     * @param strategyName - Strategy identifier
+     * @param frameName - Timeframe identifier
+     * @param backtest - True for backtest mode, false for live trading
+     *
+     * @example
+     * ```typescript
+     * import { addActionSchema, commitClosePending } from "backtest-kit";
+     *
+     * addActionSchema({
+     *   actionName: "exchange-bridge",
+     *   callbacks: {
+     *     async onPendingEvent(event) {
+     *       if (event.action === "opened") await exchange.openWithProtection(event.symbol, event.data);
+     *       else await exchange.flatten(event.symbol, event.data.id);
+     *     },
+     *     async onPingActive(event) { // per-tick fills -> close
+     *       const order = await exchange.getOrderById(event.data.id);
+     *       if (order?.status === "no_counterparty") await commitClosePending(event.symbol, { id: order.id });
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    onPendingEvent(event: SignalEventContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
     /**
      * Called during active pending signal monitoring (every minute while position is active).
      *
@@ -1881,6 +2146,13 @@ interface IActionCallbacks {
      * They propagate up to CREATE_SYNC_FN which catches them and returns false.
      * Throw to reject the operation — framework will retry on next tick.
      *
+     * MANUAL WIRING — EXCEPTION-BASED GATE: the action-side equivalent of the Broker
+     * `onSignalOpenCommit` / `onSignalCloseCommit` gate. Throwing (or returning false) on
+     * `event.action === "signal-open"` rolls the open back to idle (a scheduled activation is
+     * cancelled); on `"signal-close"` it skips the close and leaves the position open — retried next
+     * tick. Rides the same `syncSubject` emission as the Broker commit hooks, so a throw from either is
+     * collapsed to false by `CREATE_SYNC_FN`. Backtest short-circuits the gate to true (live-only).
+     *
      * @param event - Sync event with action "signal-open" or "signal-close"
      * @param actionName - Action identifier
      * @param strategyName - Strategy identifier
@@ -1903,15 +2175,21 @@ interface IActionCallbacks {
      * NOTE: Like onSignalSync, exceptions from this method are NOT swallowed. They propagate up to
      * CREATE_SYNC_PENDING_FN which catches them and returns false.
      *
+     * MANUAL WIRING — EXCEPTION-BASED GATE: the action-side equivalent of the Broker `onOrderCheck`.
+     * A THROW on a confirmed "order not found by id" closes the position with closeReason "closed"
+     * (retried via CREATE_SYNC_PENDING_FN). This is the throw-driven alternative to the imperative
+     * `commitClosePending` (call it from `pingActive` instead) — pick one, not both, for the same
+     * "order gone" condition. Backtest short-circuits the gate (live-only).
+     *
      * @deprecated This callback is not recommended for use. Exchange integration should be implemented
-     * in Broker.useBrokerAdapter (the infrastructure domain layer) via onOrderPing instead.
+     * in Broker.useBrokerAdapter (the infrastructure domain layer) via onOrderCheck instead.
      * @param event - Pending-ping event with action "signal-ping"
      * @param actionName - Action identifier
      * @param strategyName - Strategy identifier
      * @param frameName - Timeframe identifier
      * @param backtest - True for backtest mode, false for live trading
      */
-    onOrderPing(event: SignalPingContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
+    onOrderCheck(event: SignalPingContract, actionName: ActionName, strategyName: StrategyName, frameName: FrameName, backtest: boolean): void | Promise<void>;
 }
 /**
  * Action schema registered via addActionSchema().
@@ -2142,6 +2420,35 @@ interface IAction {
      * @param event - Scheduled signal monitoring data
      */
     pingScheduled(event: SchedulePingContract): void | Promise<void>;
+    /**
+     * Handles scheduled signal lifecycle events (creation / cancellation).
+     *
+     * Emitted by: StrategyConnectionService via scheduleEventSubject
+     * Source: CREATE_COMMIT_SCHEDULE_EVENT_FN callback in StrategyConnectionService
+     * Frequency: Once when a scheduled signal is created ("scheduled") and once when it is
+     * cancelled before activation ("cancelled": timeout / price_reject / user). The
+     * scheduled -> active transition is NOT reported here.
+     *
+     * Manual wiring — EVENT-BASED: implement the user-facing callback {@link IActionCallbacks.onScheduleEvent} (via
+     * `addActionSchema`) to drive the exchange (`commitActivateScheduled` / `commitCancelScheduled`).
+     *
+     * @param event - Scheduled lifecycle data (action discriminates created vs cancelled)
+     */
+    scheduleEvent(event: ScheduleEventContract): void | Promise<void>;
+    /**
+     * Handles pending signal lifecycle events (open / close).
+     *
+     * Emitted by: StrategyConnectionService via signalEventSubject
+     * Source: CREATE_COMMIT_SIGNAL_EVENT_FN callback in StrategyConnectionService
+     * Frequency: Once when a pending position is opened (action "opened") and once when it is
+     * closed (action "closed" with closeReason take_profit / stop_loss / time_expired / closed).
+     *
+     * Manual wiring — EVENT-BASED: implement the user-facing callback {@link IActionCallbacks.onPendingEvent} (via
+     * `addActionSchema`) to drive the exchange; for per-tick fills use `onPingActive`.
+     *
+     * @param event - Pending lifecycle data (action discriminates opened vs closed)
+     */
+    pendingEvent(event: SignalEventContract): void | Promise<void>;
     /**
      * Handles active ping events during active pending signal monitoring.
      *
@@ -2178,6 +2485,12 @@ interface IAction {
      *
      * NOTE: Exceptions are NOT swallowed here — they propagate to CREATE_SYNC_FN.
      *
+     * MANUAL WIRING — EXCEPTION-BASED GATE: action-side equivalent of the Broker
+     * `onSignalOpenCommit` / `onSignalCloseCommit`. Throw on "signal-open" → open rolls back to idle
+     * (scheduled activation cancelled); throw on "signal-close" → close skipped, position stays open;
+     * retried next tick. Same `syncSubject` emission as the Broker commit hooks (collapsed to false by
+     * CREATE_SYNC_FN). Live-only. Implement via the {@link IActionCallbacks.onSignalSync} callback.
+     *
      * @deprecated This method is not recommended for use. Implement custom logic in signal(), signalLive(), or signalBacktest() instead.
      * If you need to implement custom logic on signal open/close, please use signal(), signalBacktest(), signalLive() instead.
      * If Action::signalSync throws the exchange will not execute the order!
@@ -2198,12 +2511,18 @@ interface IAction {
      *
      * NOTE: Exceptions are NOT swallowed here — they propagate to CREATE_SYNC_PENDING_FN.
      *
+     * MANUAL WIRING — EXCEPTION-BASED GATE: action-side equivalent of the Broker `onOrderCheck`. A
+     * throw on a confirmed "order not found by id" closes the position with closeReason "closed"
+     * (retried via CREATE_SYNC_PENDING_FN). Throw-driven alternative to the imperative
+     * `commitClosePending` (call it from `pingActive`) — pick one, not both. Live-only. Implement via
+     * the {@link IActionCallbacks.onOrderCheck} callback.
+     *
      * @deprecated This method is not recommended for use. Exchange integration should be implemented
-     * in Broker.useBrokerAdapter (the infrastructure domain layer) via onOrderPing instead.
-     * If Action::orderPing throws the framework will close the position with closeReason "closed"!
+     * in Broker.useBrokerAdapter (the infrastructure domain layer) via onOrderCheck instead.
+     * If Action::orderCheck throws the framework will close the position with closeReason "closed"!
      * @param event - Pending-ping event with action "signal-ping"
      */
-    orderPing(event: SignalPingContract): void | Promise<void>;
+    orderCheck(event: SignalPingContract): void | Promise<void>;
     /**
      * Cleans up resources and subscriptions when action handler is no longer needed.
      *
@@ -2564,6 +2883,20 @@ type StrategyStatus = {
     cancelledSignal: IScheduledSignalCancelRow | null;
     /** Deferred user-initiated scheduled activate (activateScheduled), or null if none pending */
     activatedSignal: IScheduledSignalActivateRow | null;
+    /**
+     * Deferred broker-confirmed take-profit fill (createTakeProfit), or null if none pending.
+     * Set when the external order management system reports the position's TP order was actually
+     * filled on the exchange (e.g. by candle high/low) — independent of the VWAP-based TP check.
+     * Drained on the next tick/backtest to close the position with closeReason "take_profit".
+     */
+    takeProfitSignal: ISignalCloseRow | null;
+    /**
+     * Deferred broker-confirmed stop-loss fill (createStopLoss), or null if none pending.
+     * Set when the external order management system reports the position's SL order was actually
+     * filled on the exchange (e.g. by candle high/low) — independent of the VWAP-based SL check.
+     * Drained on the next tick/backtest to close the position with closeReason "stop_loss".
+     */
+    stopLossSignal: ISignalCloseRow | null;
 };
 /**
  * Commit payload for strategy commits.
@@ -3584,6 +3917,44 @@ interface IStrategy {
      * @returns Promise that resolves when the DTO is queued
      */
     createSignal: (symbol: string, currentPrice: number, dto: ISignalDto) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that does not wait for the VWAP-based TP check.
+     *
+     * The exchange and the strategy are parallel states: ClientStrategy evaluates TP/SL against
+     * VWAP, but the real order may close on high/low. This method bridges that gap — the broker
+     * confirms the fill out of the async-hooks execution context, and the close is deferred:
+     * a snapshot of the current pending signal is stored and drained on the next tick/backtest,
+     * which closes the position with closeReason "take_profit" at the effective take-profit level.
+     *
+     * No-op if no pending signal exists. Persisted (live mode only) so a crash before the next
+     * tick does not lose the deferred close.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param payload - Optional commit id/note attached to the close
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    createTakeProfit: (symbol: string, backtest: boolean, payload: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that does not wait for the VWAP-based SL check.
+     *
+     * The exchange and the strategy are parallel states: ClientStrategy evaluates TP/SL against
+     * VWAP, but the real order may close on high/low. This method bridges that gap — the broker
+     * confirms the fill out of the async-hooks execution context, and the close is deferred:
+     * a snapshot of the current pending signal is stored and drained on the next tick/backtest,
+     * which closes the position with closeReason "stop_loss" at the effective stop-loss level.
+     *
+     * No-op if no pending signal exists. Persisted (live mode only) so a crash before the next
+     * tick does not lose the deferred close.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param payload - Optional commit id/note attached to the close
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    createStopLoss: (symbol: string, backtest: boolean, payload: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the deferred strategy-state snapshot held in memory for this iteration — exactly
      * what would be written to persist (queued createSignal, commit queue, deferred user-action
@@ -6635,6 +7006,52 @@ declare function commitSignalNotify(symbol: string, payload?: Partial<SignalNoti
  * ```
  */
 declare function commitCreateSignal(symbol: string, dto: ISignalDto): Promise<void>;
+/**
+ * Reports that the pending position's take-profit order was actually filled on the exchange
+ * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+ *
+ * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+ * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+ * "take_profit" on the next tick. No-op if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param payload - Optional commit payload with id and note
+ * @returns Promise that resolves when the take-profit fill is queued
+ *
+ * @example
+ * ```typescript
+ * import { commitCreateTakeProfit } from "backtest-kit";
+ *
+ * // Report TP fill confirmed on the exchange
+ * await commitCreateTakeProfit("BTCUSDT", { id: "tp-fill-001" });
+ * ```
+ */
+declare function commitCreateTakeProfit(symbol: string, payload?: Partial<CommitPayload>): Promise<void>;
+/**
+ * Reports that the pending position's stop-loss order was actually filled on the exchange
+ * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+ *
+ * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+ * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+ * "stop_loss" on the next tick. No-op if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param payload - Optional commit payload with id and note
+ * @returns Promise that resolves when the stop-loss fill is queued
+ *
+ * @example
+ * ```typescript
+ * import { commitCreateStopLoss } from "backtest-kit";
+ *
+ * // Report SL fill confirmed on the exchange
+ * await commitCreateStopLoss("BTCUSDT", { id: "sl-fill-001" });
+ * ```
+ */
+declare function commitCreateStopLoss(symbol: string, payload?: Partial<CommitPayload>): Promise<void>;
 /**
  * Returns the in-memory deferred strategy-state snapshot for the current iteration: the queued
  * createSignal, commit queue and deferred user-action flags, plus the current pending signal id.
@@ -9524,6 +9941,111 @@ declare function listenSchedulePing(fn: (event: SchedulePingContract) => void):
  * ```
  */
 declare function listenSchedulePingOnce(filterFn: (event: SchedulePingContract) => boolean, fn: (event: SchedulePingContract) => void): () => void;
+/**
+ * Subscribes to scheduled signal lifecycle events (creation and cancellation) with queued async processing.
+ *
+ * Emitted when a scheduled signal is created (action "scheduled") or cancelled before activation
+ * (action "cancelled" with reason "timeout" / "price_reject" / "user"), in both live and backtest.
+ *
+ * IMPORTANT: The scheduled -> active transition (activation) is NOT reported here. Activation
+ * produces an "opened" event on the regular signal emitters (listenSignal) instead.
+ *
+ * Events are processed sequentially in order received, even if callback is async.
+ *
+ * @param fn - Callback function to handle scheduled lifecycle events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenScheduleEvent } from "./function/event";
+ *
+ * const unsubscribe = listenScheduleEvent((event) => {
+ *   if (event.action === "scheduled") {
+ *     console.log(`Scheduled ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Cancelled ${event.symbol} (reason: ${event.reason})`);
+ *   }
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenScheduleEvent(fn: (event: ScheduleEventContract) => void): () => void;
+/**
+ * Subscribes to filtered scheduled lifecycle events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for a specific scheduled creation
+ * or cancellation.
+ *
+ * @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 { listenScheduleEventOnce } from "./function/event";
+ *
+ * // Wait for the first cancellation on BTCUSDT
+ * listenScheduleEventOnce(
+ *   (event) => event.symbol === "BTCUSDT" && event.action === "cancelled",
+ *   (event) => console.log("BTCUSDT scheduled cancelled:", event.reason)
+ * );
+ * ```
+ */
+declare function listenScheduleEventOnce(filterFn: (event: ScheduleEventContract) => boolean, fn: (event: ScheduleEventContract) => void): () => void;
+/**
+ * Subscribes to pending signal lifecycle events (open and close) with queued async processing.
+ *
+ * Emitted when a pending position is opened (action "opened": new signal / immediate / scheduled
+ * or user activation) or closed (action "closed" with closeReason "take_profit" / "stop_loss" /
+ * "time_expired" / "closed"), in both live and backtest.
+ *
+ * Events are processed sequentially in order received, even if callback is async.
+ *
+ * @param fn - Callback function to handle pending lifecycle events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenSignalEvent } from "./function/event";
+ *
+ * const unsubscribe = listenSignalEvent((event) => {
+ *   if (event.action === "opened") {
+ *     console.log(`Opened ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Closed ${event.symbol} (reason: ${event.closeReason})`);
+ *   }
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+declare function listenSignalEvent(fn: (event: SignalEventContract) => void): () => void;
+/**
+ * Subscribes to filtered pending lifecycle events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for a specific open or close.
+ *
+ * @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 { listenSignalEventOnce } from "./function/event";
+ *
+ * // Wait for the first close on BTCUSDT
+ * listenSignalEventOnce(
+ *   (event) => event.symbol === "BTCUSDT" && event.action === "closed",
+ *   (event) => console.log("BTCUSDT closed:", event.closeReason)
+ * );
+ * ```
+ */
+declare function listenSignalEventOnce(filterFn: (event: SignalEventContract) => boolean, fn: (event: SignalEventContract) => void): () => void;
 /**
  * Subscribes to active ping events with queued async processing.
  *
@@ -14350,6 +14872,18 @@ type StrategyData = {
     cancelledSignal: IScheduledSignalCancelRow | null;
     /** Deferred user-initiated scheduled activate (activateScheduled), or null if none pending */
     activatedSignal: IScheduledSignalActivateRow | null;
+    /**
+     * Deferred broker-confirmed take-profit fill (createTakeProfit), or null if none pending.
+     * Set when the exchange reports the TP order was actually filled (e.g. by candle high/low),
+     * independent of the VWAP-based TP check. Drained on the next tick to close with "take_profit".
+     */
+    takeProfitSignal: ISignalCloseRow | null;
+    /**
+     * Deferred broker-confirmed stop-loss fill (createStopLoss), or null if none pending.
+     * Set when the exchange reports the SL order was actually filled (e.g. by candle high/low),
+     * independent of the VWAP-based SL check. Drained on the next tick to close with "stop_loss".
+     */
+    stopLossSignal: ISignalCloseRow | null;
 };
 /**
  * Per-context deferred strategy state persistence instance interface.
@@ -18979,6 +19513,62 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }, dto: ISignalDto) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+     *
+     * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+     * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+     * "take_profit" on the next backtest tick. No-op if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the take-profit fill is queued
+     *
+     * @example
+     * ```typescript
+     * // Report TP fill confirmed on the exchange
+     * await Backtest.commitCreateTakeProfit("BTCUSDT", {
+     *   exchangeName: "binance",
+     *   strategyName: "my-strategy",
+     *   frameName: "1m"
+     * }, { id: "tp-fill-001" });
+     * ```
+     */
+    commitCreateTakeProfit: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+     *
+     * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+     * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+     * "stop_loss" on the next backtest tick. No-op if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the stop-loss fill is queued
+     *
+     * @example
+     * ```typescript
+     * // Report SL fill confirmed on the exchange
+     * await Backtest.commitCreateStopLoss("BTCUSDT", {
+     *   exchangeName: "binance",
+     *   strategyName: "my-strategy",
+     *   frameName: "1m"
+     * }, { id: "sl-fill-001" });
+     * ```
+     */
+    commitCreateStopLoss: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the in-memory deferred strategy-state snapshot for the current backtest iteration.
      *
@@ -20489,6 +21079,40 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }, dto: ISignalDto) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+     *
+     * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+     * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+     * "take_profit" on the next live tick. No-op if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    commitCreateTakeProfit: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+     *
+     * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+     * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+     * "stop_loss" on the next live tick. No-op if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    commitCreateStopLoss: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the in-memory deferred strategy-state snapshot for the current live iteration.
      *
@@ -28795,7 +29419,7 @@ type BrokerSignalClosePayload = {
  *
  * Emitted automatically via syncPendingSubject on every live tick while a pending signal is
  * monitored, BEFORE the framework evaluates TP/SL/time. Forwarded to the registered IBroker
- * adapter via `onOrderPing`.
+ * adapter via `onOrderCheck`.
  *
  * The adapter should query the exchange by `signalId` and THROW ONLY when the order is
  * definitively NOT FOUND by that id (filled, cancelled, or liquidated externally). A throw
@@ -28854,6 +29478,316 @@ type BrokerSignalPendingPayload = {
     /** true when called during a backtest run — adapter should skip exchange calls */
     backtest: boolean;
 };
+/**
+ * Payload for the active-ping broker event.
+ *
+ * Emitted automatically via activePingSubject on every live tick while a pending (open) signal is
+ * monitored. Forwarded to the registered IBroker adapter via `onSignalActivePing`. Purely
+ * informational — unlike `onOrderCheck` a throw here does NOT close the position.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerActivePingPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 50500,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerActivePingPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the monitored position */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of the ping */
+    currentPrice: number;
+    /** Effective entry price (may differ from priceOpen after DCA averaging) */
+    priceOpen: number;
+    /** Effective take-profit price at the moment of the ping */
+    priceTakeProfit: number;
+    /** Effective stop-loss price at the moment of the ping */
+    priceStopLoss: number;
+    /** Unrealized PnL of the open position at the moment of the ping */
+    pnl: IStrategyPnL;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the schedule-ping broker event.
+ *
+ * Emitted automatically via schedulePingSubject on every live tick while a scheduled signal is
+ * monitored (waiting for priceOpen activation). Forwarded to the registered IBroker adapter via
+ * `onSignalSchedulePing`. Purely informational.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerSchedulePingPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 49800,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerSchedulePingPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the scheduled signal */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of the ping */
+    currentPrice: number;
+    /** Pending entry price the scheduled signal is waiting for */
+    priceOpen: number;
+    /** Take-profit price configured for the scheduled signal */
+    priceTakeProfit: number;
+    /** Stop-loss price configured for the scheduled signal */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the idle-ping broker event.
+ *
+ * Emitted automatically via idlePingSubject on every live tick while the strategy has no pending or
+ * scheduled signal. Forwarded to the registered IBroker adapter via `onSignalIdlePing`. Purely
+ * informational — carries no signal because none is active.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerIdlePingPayload = {
+ *   symbol: "BTCUSDT",
+ *   currentPrice: 50500,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerIdlePingPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Market price at the moment of the ping */
+    currentPrice: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the scheduled-signal-open broker event.
+ *
+ * Emitted automatically via scheduleEventSubject (action "scheduled") when a new scheduled signal is
+ * created and starts waiting for priceOpen activation. Forwarded to the registered IBroker adapter
+ * via `onSignalScheduleOpen`. The scheduled -> active transition is NOT reported here — activation
+ * arrives through `onSignalOpenCommit`.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerScheduleOpenPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 49800,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerScheduleOpenPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the scheduled signal */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment the scheduled signal was created */
+    currentPrice: number;
+    /** Pending entry price the scheduled signal waits for */
+    priceOpen: number;
+    /** Take-profit price configured for the scheduled signal */
+    priceTakeProfit: number;
+    /** Stop-loss price configured for the scheduled signal */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the scheduled-signal-cancelled broker event.
+ *
+ * Emitted automatically via scheduleEventSubject (action "cancelled") when a scheduled signal is
+ * removed before it ever activated. Forwarded to the registered IBroker adapter via
+ * `onSignalScheduleCancelled`. The `reason` distinguishes timeout / price reject / user cancel.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerScheduleCancelledPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 47500,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   reason: "price_reject",
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerScheduleCancelledPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the cancelled scheduled signal */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of cancellation */
+    currentPrice: number;
+    /** Pending entry price the scheduled signal had been waiting for */
+    priceOpen: number;
+    /** Take-profit price that had been configured for the scheduled signal */
+    priceTakeProfit: number;
+    /** Stop-loss price that had been configured for the scheduled signal */
+    priceStopLoss: number;
+    /** Why the scheduled signal was cancelled: "timeout" / "price_reject" / "user" */
+    reason?: StrategyCancelReason;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the pending-signal-open broker event.
+ *
+ * Emitted automatically via signalEventSubject (action "opened") when a pending position is opened
+ * (new signal / immediate entry / scheduled or user activation). Forwarded to the registered IBroker
+ * adapter via `onSignalPendingOpen`.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerPendingOpenPayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 50000,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerPendingOpenPayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the opened position */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Effective entry price at the moment the position opened */
+    currentPrice: number;
+    /** Effective entry price (may differ from currentPrice after DCA averaging) */
+    priceOpen: number;
+    /** Take-profit price configured for the position */
+    priceTakeProfit: number;
+    /** Stop-loss price configured for the position */
+    priceStopLoss: number;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
+/**
+ * Payload for the pending-signal-close broker event.
+ *
+ * Emitted automatically via signalEventSubject (action "closed") when a pending position is closed.
+ * Forwarded to the registered IBroker adapter via `onSignalPendingClose`. The `closeReason`
+ * distinguishes take_profit / stop_loss / time_expired / user-close / broker fill / order gone.
+ *
+ * @example
+ * ```typescript
+ * const payload: BrokerPendingClosePayload = {
+ *   symbol: "BTCUSDT",
+ *   position: "long",
+ *   currentPrice: 55000,
+ *   priceOpen: 50000,
+ *   priceTakeProfit: 55000,
+ *   priceStopLoss: 48000,
+ *   closeReason: "take_profit",
+ *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+ *   backtest: false,
+ * };
+ * ```
+ */
+type BrokerPendingClosePayload = {
+    /** Trading pair symbol, e.g. "BTCUSDT" */
+    symbol: string;
+    /** Unique signal identifier (UUID v4) of the closed position */
+    signalId: string;
+    /** Position direction */
+    position: "long" | "short";
+    /** Market price at the moment of close */
+    currentPrice: number;
+    /** Effective entry price of the closed position */
+    priceOpen: number;
+    /** Effective take-profit price of the closed position */
+    priceTakeProfit: number;
+    /** Effective stop-loss price of the closed position */
+    priceStopLoss: number;
+    /** Why the position closed: "take_profit" / "stop_loss" / "time_expired" / "closed" */
+    closeReason?: StrategyCloseReason;
+    /** Strategy/exchange/frame routing context */
+    context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName?: FrameName;
+    };
+    /** true when called during a backtest run — adapter should skip exchange calls */
+    backtest: boolean;
+};
 /**
  * Payload for a partial-profit close broker event.
  *
@@ -29143,9 +30077,36 @@ type BrokerAverageBuyPayload = {
 interface IBroker {
     /** Called once before first use. Connect to exchange, load credentials, etc. */
     waitForInit(): Promise<void>;
-    /** Called when a new signal is closed (take-profit, stop-loss, or manual close). */
+    /**
+     * Called when a signal is being closed (take-profit, stop-loss, or manual close). Emitted via
+     * syncSubject BEFORE the framework mutates strategy state, so it is also the close **gate**.
+     *
+     * MANUAL WIRING — EXCEPTION-BASED: place the real exit order here (tag/look up by `payload.signalId`)
+     * and record final PnL. This is the confirmed-close commit; like `onSignalSync` (signal-close) it
+     * shares the gate semantics — a THROW means "the exchange did not close the position" and the
+     * framework SKIPS the close, leaving the position open and retrying on the next tick. Return
+     * normally to let the close proceed. Backtest short-circuits this (no live exchange), so the gate is
+     * live-only.
+     *
+     * This differs from `onSignalPendingClose`, which is the informational lifecycle hook that fires
+     * AFTER the close is committed (and cannot veto it).
+     */
     onSignalCloseCommit(payload: BrokerSignalClosePayload): Promise<void>;
-    /** Called when a new signal is opened (position entry confirmed). */
+    /**
+     * Called when a signal is being opened (position entry). Emitted via syncSubject BEFORE the
+     * framework mutates strategy state, so it is also the open **gate**.
+     *
+     * MANUAL WIRING — EXCEPTION-BASED: place the real entry order here (tag the exchange order with
+     * `payload.signalId` so later `onOrderCheck` / `onSignalActivePing` can find it). Like `onSignalSync`
+     * (signal-open) it shares the gate semantics — a THROW means "the exchange did not fill the entry"
+     * (e.g. limit order rejected) and the framework ROLLS BACK the open: the pending signal returns to
+     * idle (a scheduled activation is cancelled) and is retried on the next tick. Return normally to let
+     * the open proceed. Also the point where a scheduled signal's activation surfaces. Backtest
+     * short-circuits this, so the gate is live-only.
+     *
+     * This differs from `onSignalPendingOpen`, which is the informational lifecycle hook that fires
+     * AFTER the open is committed (and cannot veto it).
+     */
     onSignalOpenCommit(payload: BrokerSignalOpenPayload): Promise<void>;
     /**
      * Called on every live tick while a pending signal is monitored, BEFORE TP/SL/time evaluation.
@@ -29156,8 +30117,186 @@ interface IBroker {
      * CRITICAL: swallow transient/network errors (timeout, 5xx, rate limit, disconnect) — return
      * normally instead of throwing, otherwise a connectivity blip would wrongly close an open
      * position. Throw exclusively on a confirmed "order not found by id" result.
+     *
+     * Manual wiring — EXCEPTION-BASED VARIANT
+     *
+     * This is the throw-driven **alternative** to the imperative commit-function wiring in
+     * `onSignalActivePing`:
+     * - **Exception-based (here):** THROW → framework closes the position with closeReason "closed".
+     *   One binary gate, no reason distinction. Good when "order gone" is the only condition you handle.
+     * - **Imperative (`onSignalActivePing` + `src/function/strategy.ts`):** call
+     *   `commitClosePending` / `commitCreateTakeProfit` / `commitCreateStopLoss` to close with the
+     *   correct reason and handle TP vs SL vs no-counterparty separately.
+     *
+     * Pick ONE per condition — do not both throw here AND `commitClosePending` in the active-ping for
+     * the same "order gone" event.
+     *
+     * @example
+     * ```typescript
+     * async onOrderCheck(payload: BrokerSignalPendingPayload) {
+     *   let order: Order | null;
+     *   try {
+     *     order = await this.exchange.getOrderById(payload.signalId);
+     *   } catch (networkError) {
+     *     return; // transient — keep the position open, retry next tick
+     *   }
+     *   if (!order) {
+     *     throw new Error(`Order ${payload.signalId} not found`); // confirmed gone -> close "closed"
+     *   }
+     * }
+     * ```
+     */
+    onOrderCheck(payload: BrokerSignalPendingPayload): Promise<void>;
+    /**
+     * Called on every live tick while a pending (open) signal is monitored.
+     * Purely informational mirror of the active-ping lifecycle — a throw here does NOT close the
+     * position (unlike `onOrderCheck`).
+     *
+     * Manual wiring — EVENT-BASED (driving an open position from real exchange state)
+     *
+     * Primary per-tick **event-based** hook for an open position (a throw does NOT close it — react to
+     * the event and decide imperatively). This is where you reconcile the framework's VWAP view with
+     * real fills: catch a **SL that gapped through** the level, or a **TP that filled before VWAP**
+     * reached it. Poll your real order and translate its state into strategy state via the
+     * commit-functions from `src/function/strategy.ts` (callable here because the ping is emitted inside
+     * the strategy tick; effects are deferred to the next tick):
+     * - `commitCreateTakeProfit(symbol, { id })` — real TP order filled (possibly before VWAP reached
+     *   the level) → force close, reason "take_profit".
+     * - `commitCreateStopLoss(symbol, { id })` — real SL order filled (e.g. price gapped through SL) →
+     *   force close, reason "stop_loss".
+     * - `commitClosePending(symbol, { id })` — no counterparty (no buyer/seller, liquidity gap) → close
+     *   now with reason "closed", instead of throwing.
+     *
+     * @example
+     * ```typescript
+     * import { commitCreateTakeProfit, commitCreateStopLoss, commitClosePending } from "backtest-kit";
+     *
+     * async onSignalActivePing(payload: BrokerActivePingPayload) {
+     *   const order = await this.exchange.getOrderById(payload.signalId);
+     *   if (order?.status === "filled" && order.kind === "take_profit") {
+     *     await commitCreateTakeProfit(payload.symbol, { id: order.id });
+     *   } else if (order?.status === "filled" && order.kind === "stop_loss") {
+     *     await commitCreateStopLoss(payload.symbol, { id: order.id });
+     *   } else if (order?.status === "no_counterparty") {
+     *     await commitClosePending(payload.symbol, { id: order.id });
+     *   }
+     * }
+     * ```
+     */
+    onSignalActivePing(payload: BrokerActivePingPayload): Promise<void>;
+    /**
+     * Called on every live tick while a scheduled signal is monitored (waiting for priceOpen
+     * activation). Purely informational.
+     *
+     * Manual wiring — EVENT-BASED (driving the scheduled phase from real exchange state)
+     *
+     * Per-tick **event-based** hook (a throw does NOT veto anything — react and decide imperatively).
+     * Poll your real resting/limit order and translate it via the commit-functions from
+     * `src/function/strategy.ts` (deferred to the next tick):
+     * - `commitActivateScheduled(symbol, { id })` — resting order filled/resolved → activate now,
+     *   without waiting for VWAP to reach priceOpen (surfaces as `onSignalOpenCommit` next tick).
+     * - `commitCancelScheduled(symbol, { id })` — resting order cancelled/rejected externally → drop it.
+     *
+     * @example
+     * ```typescript
+     * import { commitActivateScheduled, commitCancelScheduled } from "backtest-kit";
+     *
+     * async onSignalSchedulePing(payload: BrokerSchedulePingPayload) {
+     *   const order = await this.exchange.getOrderById(payload.signalId);
+     *   if (order?.status === "filled" || order?.status === "resolved") {
+     *     await commitActivateScheduled(payload.symbol, { id: order.id });
+     *   } else if (order?.status === "cancelled" || order?.status === "rejected") {
+     *     await commitCancelScheduled(payload.symbol, { id: order.id });
+     *   }
+     * }
+     * ```
+     */
+    onSignalSchedulePing(payload: BrokerSchedulePingPayload): Promise<void>;
+    /**
+     * Called on every live tick while the strategy is idle (no pending or scheduled signal).
+     * Purely informational.
+     *
+     * MANUAL WIRING — EVENT-BASED: no signal is active, so there is nothing to commit; use it for idle
+     * heartbeats / housekeeping. A throw does not affect strategy state.
+     */
+    onSignalIdlePing(payload: BrokerIdlePingPayload): Promise<void>;
+    /**
+     * Called when a new scheduled signal is created and starts waiting for priceOpen activation.
+     * The scheduled -> active transition is reported via `onSignalOpenCommit`, not here.
+     *
+     * Manual wiring — EVENT-BASED (placing the resting order)
+     *
+     * Fires ONCE at creation — place the real resting/limit order (tag it with `payload.signalId` so
+     * `onSignalSchedulePing` can poll it later). If it resolves immediately, promote it with
+     * `commitActivateScheduled(symbol, { id })`; if rejected, drop it with
+     * `commitCancelScheduled(symbol, { id })`. Use `onSignalSchedulePing` for ongoing polling.
+     *
+     * @example
+     * ```typescript
+     * import { commitActivateScheduled, commitCancelScheduled } from "backtest-kit";
+     *
+     * async onSignalScheduleOpen(payload: BrokerScheduleOpenPayload) {
+     *   const order = await this.exchange.placeLimitOrder({
+     *     id: payload.signalId,
+     *     symbol: payload.symbol,
+     *     side: payload.position,
+     *     price: payload.priceOpen,
+     *   });
+     *   if (order.status === "filled") await commitActivateScheduled(payload.symbol, { id: order.id });
+     *   else if (order.status === "rejected") await commitCancelScheduled(payload.symbol, { id: order.id });
+     * }
+     * ```
+     */
+    onSignalScheduleOpen(payload: BrokerScheduleOpenPayload): Promise<void>;
+    /**
+     * Called when a scheduled signal is cancelled before it ever activated
+     * (reason: timeout / price_reject / user).
+     *
+     * Manual wiring — EVENT-BASED (tearing down the resting order)
+     *
+     * Outbound side — the framework has already dropped the scheduled signal, so there is nothing to
+     * `commitCancelScheduled` here; instead cancel the real resting order you placed in
+     * `onSignalScheduleOpen` (look it up by `payload.signalId`). `payload.reason` tells you why.
+     *
+     * @example
+     * ```typescript
+     * async onSignalScheduleCancelled(payload: BrokerScheduleCancelledPayload) {
+     *   await this.exchange.cancelOrderById(payload.signalId);
+     * }
+     * ```
+     */
+    onSignalScheduleCancelled(payload: BrokerScheduleCancelledPayload): Promise<void>;
+    /**
+     * Called when a pending position is opened (new signal / immediate / scheduled or user
+     * activation). Purely informational lifecycle hook for the active phase of a signal.
+     *
+     * Manual wiring — EVENT-BASED (placing entry + protective orders)
+     *
+     * Fires ONCE at open — place the real entry confirmation and protective TP/SL orders (tag them with
+     * `payload.signalId`). Drive the rest per-tick from `onSignalActivePing`. This hook does not gate
+     * the position; for a true entry gate use `onSignalSync` (signal-open).
      */
-    onOrderPing(payload: BrokerSignalPendingPayload): Promise<void>;
+    onSignalPendingOpen(payload: BrokerPendingOpenPayload): Promise<void>;
+    /**
+     * Called when a pending position is closed
+     * (reason: take_profit / stop_loss / time_expired / closed).
+     *
+     * Manual wiring — EVENT-BASED (tearing down the position)
+     *
+     * Outbound side — the framework has already removed the pending signal, so there is nothing to
+     * `commitClosePending` here; instead flatten the real position and cancel leftover TP/SL orders by
+     * `payload.signalId`, and record final PnL. `payload.closeReason` says which path closed it. If you
+     * need to FORCE the close yourself (e.g. no counterparty), do it earlier in `onSignalActivePing`.
+     *
+     * @example
+     * ```typescript
+     * async onSignalPendingClose(payload: BrokerPendingClosePayload) {
+     *   await this.exchange.flatten(payload.symbol);
+     *   await this.exchange.cancelProtectiveOrders(payload.signalId);
+     * }
+     * ```
+     */
+    onSignalPendingClose(payload: BrokerPendingClosePayload): Promise<void>;
     /** Called when a partial profit close is committed. */
     onPartialProfitCommit(payload: BrokerPartialProfitPayload): Promise<void>;
     /** Called when a partial loss close is committed. */
@@ -29290,6 +30429,72 @@ declare class BrokerAdapter {
      * @param payload - Pending ping details: symbol, position, prices, pnl, context, backtest flag
      */
     commitSignalPending: (payload: BrokerSignalPendingPayload) => Promise<void>;
+    /**
+     * Forwards an active-ping to the registered broker adapter.
+     *
+     * Called automatically via activePingSubject when `enable()` is active, on every live tick while a
+     * pending signal is monitored. Skipped silently in backtest mode or when no adapter is registered.
+     * Purely informational — a throw does NOT close the position.
+     *
+     * @param payload - Active ping details: symbol, signalId, position, prices, pnl, context, backtest
+     */
+    commitActivePing: (payload: BrokerActivePingPayload) => Promise<void>;
+    /**
+     * Forwards a schedule-ping to the registered broker adapter.
+     *
+     * Called automatically via schedulePingSubject when `enable()` is active, on every live tick while
+     * a scheduled signal is monitored. Skipped silently in backtest mode or when no adapter is
+     * registered. Purely informational.
+     *
+     * @param payload - Schedule ping details: symbol, signalId, position, prices, context, backtest
+     */
+    commitSchedulePing: (payload: BrokerSchedulePingPayload) => Promise<void>;
+    /**
+     * Forwards an idle-ping to the registered broker adapter.
+     *
+     * Called automatically via idlePingSubject when `enable()` is active, on every live tick while the
+     * strategy has no pending or scheduled signal. Skipped silently in backtest mode or when no adapter
+     * is registered. Purely informational.
+     *
+     * @param payload - Idle ping details: symbol, currentPrice, context, backtest
+     */
+    commitIdlePing: (payload: BrokerIdlePingPayload) => Promise<void>;
+    /**
+     * Forwards a scheduled-signal-open to the registered broker adapter.
+     *
+     * Called automatically via scheduleEventSubject (action "scheduled") when a scheduled signal is
+     * created. Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Scheduled open details: symbol, signalId, position, prices, context, backtest
+     */
+    commitScheduleOpen: (payload: BrokerScheduleOpenPayload) => Promise<void>;
+    /**
+     * Forwards a scheduled-signal-cancelled to the registered broker adapter.
+     *
+     * Called automatically via scheduleEventSubject (action "cancelled") when a scheduled signal is
+     * removed before activation. Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Scheduled cancel details: symbol, signalId, position, prices, reason, context, backtest
+     */
+    commitScheduleCancelled: (payload: BrokerScheduleCancelledPayload) => Promise<void>;
+    /**
+     * Forwards a pending-signal-open to the registered broker adapter.
+     *
+     * Called automatically via signalEventSubject (action "opened") when a pending position is opened.
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Pending open details: symbol, signalId, position, prices, context, backtest
+     */
+    commitPendingOpen: (payload: BrokerPendingOpenPayload) => Promise<void>;
+    /**
+     * Forwards a pending-signal-close to the registered broker adapter.
+     *
+     * Called automatically via signalEventSubject (action "closed") when a pending position is closed.
+     * Skipped silently in backtest mode or when no adapter is registered.
+     *
+     * @param payload - Pending close details: symbol, signalId, position, prices, closeReason, context, backtest
+     */
+    commitPendingClose: (payload: BrokerPendingClosePayload) => Promise<void>;
     /**
      * Intercepts a partial-profit close before DI-core mutation.
      *
@@ -29606,24 +30811,32 @@ declare class BrokerBase implements IBroker {
      */
     waitForInit(): Promise<void>;
     /**
-     * Called when a new position is opened (signal activated).
+     * Called when a position is being opened (signal activated).
      *
      * Triggered automatically via syncSubject when a scheduled signal's priceOpen is hit.
      * Use to place the actual entry order on the exchange.
      *
      * Default implementation: Logs signal-open event.
      *
+     * Manual wiring — EXCEPTION-BASED GATE: emitted BEFORE the framework mutates state, so a THROW here
+     * (e.g. limit order rejected) rolls back the open — the pending signal returns to idle and retries
+     * next tick; return normally to let it open. Live-only (backtest short-circuits). See
+     * {@link IBroker.onSignalOpenCommit} for the full semantics.
+     *
      * @param payload - Signal open details: symbol, cost, position, priceOpen, priceTakeProfit, priceStopLoss, context, backtest
      *
      * @example
      * ```typescript
      * async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
      *   super.onSignalOpenCommit(payload); // Keep parent logging
-     *   await this.exchange.placeMarketOrder({
+     *   const order = await this.exchange.placeMarketOrder({
      *     symbol: payload.symbol,
      *     side: payload.position === "long" ? "BUY" : "SELL",
      *     quantity: payload.cost / payload.priceOpen,
      *   });
+     *   if (!order.filled) {
+     *     throw new Error(`Entry not filled for ${payload.symbol}`); // -> roll back the open, retry next tick
+     *   }
      * }
      * ```
      */
@@ -29640,42 +30853,118 @@ declare class BrokerBase implements IBroker {
      * normally instead of throwing. A thrown network error would wrongly close an open position; only
      * a confirmed "order not found by id" response is a valid reason to throw.
      *
+     * Manual wiring — EXCEPTION-BASED VARIANT: the throw-driven alternative to the imperative
+     * commit-function wiring in `onSignalActivePing`. See {@link IBroker.onOrderCheck} for the full
+     * comparison and example.
+     *
      * @param payload - Pending ping details: symbol, signalId, position, prices, pnl, context, backtest
+     */
+    onOrderCheck(payload: BrokerSignalPendingPayload): Promise<void>;
+    /**
+     * Called on every live tick while a pending (open) signal is monitored.
      *
-     * @example
-     * ```typescript
-     * async onOrderPing(payload: BrokerSignalPendingPayload) {
-     *   super.onOrderPing(payload); // Keep parent logging
-     *   let order: Order | null;
-     *   try {
-     *     order = await this.exchange.getOrderById(payload.signalId);
-     *   } catch (networkError) {
-     *     // Transient/network error — swallow and keep the position open, retry next tick
-     *     return;
-     *   }
-     *   if (!order) {
-     *     // Confirmed not found by id — close the position
-     *     throw new Error(`Order ${payload.signalId} not found on the exchange`);
-     *   }
-     * }
-     * ```
+     * Purely informational mirror of the active-ping lifecycle — unlike `onOrderCheck`, a throw here
+     * does NOT close the position. Override to mirror live monitoring state into your own systems.
+     * The default implementation logs.
+     *
+     * Manual wiring — EVENT-BASED: this is the primary per-tick hook to drive an open position from real exchange
+     * state (`commitCreateTakeProfit` / `commitCreateStopLoss` / `commitClosePending`). See the
+     * {@link IBroker.onSignalActivePing} contract docs for the full guidance and example.
+     *
+     * @param payload - Active ping details: symbol, signalId, position, prices, pnl, context, backtest
+     */
+    onSignalActivePing(payload: BrokerActivePingPayload): Promise<void>;
+    /**
+     * Called on every live tick while a scheduled signal is monitored (waiting for priceOpen).
+     *
+     * Purely informational. Override to mirror scheduled-monitoring state. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: per-tick hook to drive a scheduled (resting) order from real exchange state
+     * (`commitActivateScheduled` / `commitCancelScheduled`). See {@link IBroker.onSignalSchedulePing}
+     * for full guidance and example.
+     *
+     * @param payload - Schedule ping details: symbol, signalId, position, prices, context, backtest
      */
-    onOrderPing(payload: BrokerSignalPendingPayload): Promise<void>;
+    onSignalSchedulePing(payload: BrokerSchedulePingPayload): Promise<void>;
     /**
-     * Called when a position is fully closed (SL/TP hit or manual close).
+     * Called on every live tick while the strategy is idle (no pending or scheduled signal).
+     *
+     * Purely informational. Override to track idle heartbeats. The default logs.
+     *
+     * @param payload - Idle ping details: symbol, currentPrice, context, backtest
+     */
+    onSignalIdlePing(payload: BrokerIdlePingPayload): Promise<void>;
+    /**
+     * Called when a new scheduled signal is created and starts waiting for priceOpen activation.
+     *
+     * The scheduled -> active transition is reported via `onSignalOpenCommit`, not here. Override to
+     * place a resting/limit order on the exchange. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: fires ONCE at creation — place the real resting order (tag it with
+     * `payload.signalId`) and optionally `commitActivateScheduled` / `commitCancelScheduled`. See
+     * {@link IBroker.onSignalScheduleOpen} for full guidance and example.
+     *
+     * @param payload - Scheduled open details: symbol, signalId, position, prices, context, backtest
+     */
+    onSignalScheduleOpen(payload: BrokerScheduleOpenPayload): Promise<void>;
+    /**
+     * Called when a scheduled signal is cancelled before activation (timeout / price_reject / user).
+     *
+     * Override to cancel the resting/limit order on the exchange. The default logs.
+     *
+     * Manual wiring — EVENT-BASED (outbound): the strategy already dropped the scheduled signal — cancel the matching
+     * exchange order by `payload.signalId`. See {@link IBroker.onSignalScheduleCancelled}.
+     *
+     * @param payload - Scheduled cancel details: symbol, signalId, position, prices, reason, context, backtest
+     */
+    onSignalScheduleCancelled(payload: BrokerScheduleCancelledPayload): Promise<void>;
+    /**
+     * Called when a pending position is opened (new signal / immediate / scheduled or user activation).
+     *
+     * Informational lifecycle hook. Override to mirror the open into your own systems. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: fires ONCE at open — place entry + protective TP/SL orders (tag with
+     * `payload.signalId`), then drive per-tick from `onSignalActivePing`. See
+     * {@link IBroker.onSignalPendingOpen}.
+     *
+     * @param payload - Pending open details: symbol, signalId, position, prices, context, backtest
+     */
+    onSignalPendingOpen(payload: BrokerPendingOpenPayload): Promise<void>;
+    /**
+     * Called when a pending position is closed (take_profit / stop_loss / time_expired / closed).
+     *
+     * Informational lifecycle hook. Override to mirror the close into your own systems. The default logs.
+     *
+     * Manual wiring — EVENT-BASED (outbound): the strategy already removed the pending signal — flatten the real
+     * position and cancel leftover TP/SL orders by `payload.signalId`. See
+     * {@link IBroker.onSignalPendingClose}.
+     *
+     * @param payload - Pending close details: symbol, signalId, position, prices, closeReason, context, backtest
+     */
+    onSignalPendingClose(payload: BrokerPendingClosePayload): Promise<void>;
+    /**
+     * Called when a position is being closed (SL/TP hit or manual close).
      *
      * Triggered automatically via syncSubject when a pending signal is closed.
      * Use to place the exit order and record final PnL.
      *
      * Default implementation: Logs signal-close event.
      *
+     * Manual wiring — EXCEPTION-BASED GATE: emitted BEFORE the framework mutates state, so a THROW here
+     * (e.g. exit order failed) SKIPS the close — the position stays open and the close retries next
+     * tick; return normally to let it close. Live-only (backtest short-circuits). See
+     * {@link IBroker.onSignalCloseCommit} for the full semantics.
+     *
      * @param payload - Signal close details: symbol, cost, position, currentPrice, pnl, totalEntries, totalPartials, context, backtest
      *
      * @example
      * ```typescript
      * async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
      *   super.onSignalCloseCommit(payload); // Keep parent logging
-     *   await this.exchange.closePosition(payload.symbol);
+     *   const ok = await this.exchange.closePosition(payload.symbol);
+     *   if (!ok) {
+     *     throw new Error(`Exit not filled for ${payload.symbol}`); // -> keep position open, retry next tick
+     *   }
      *   await this.db.recordTrade({ symbol: payload.symbol, pnl: payload.pnl });
      * }
      * ```
@@ -29993,6 +31282,22 @@ declare const riskSubject: Subject<RiskContract>;
  * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
  */
 declare const schedulePingSubject: Subject<SchedulePingContract>;
+/**
+ * Scheduled signal lifecycle emitter (creation and cancellation).
+ * Emits when a scheduled signal is created (action "scheduled") or cancelled before
+ * activation (action "cancelled": timeout / price_reject / user) during tick()/backtest().
+ *
+ * The scheduled -> active transition (activation) is intentionally NOT emitted here — that
+ * produces an "opened" signal on the regular signal emitters instead.
+ */
+declare const scheduleEventSubject: Subject<ScheduleEventContract>;
+/**
+ * Pending signal lifecycle emitter (open and close).
+ * Emits when a pending position is opened (action "opened": new signal / immediate / scheduled
+ * or user activation) or closed (action "closed" with closeReason take_profit / stop_loss /
+ * time_expired / closed) during tick()/backtest().
+ */
+declare const signalEventSubject: Subject<SignalEventContract>;
 /**
  * Active ping emitter for active pending signal monitoring events.
  * Emits every minute when an active pending signal is being monitored.
@@ -30081,10 +31386,12 @@ declare const emitters_performanceEmitter: typeof performanceEmitter;
 declare const emitters_progressBacktestEmitter: typeof progressBacktestEmitter;
 declare const emitters_progressWalkerEmitter: typeof progressWalkerEmitter;
 declare const emitters_riskSubject: typeof riskSubject;
+declare const emitters_scheduleEventSubject: typeof scheduleEventSubject;
 declare const emitters_schedulePingSubject: typeof schedulePingSubject;
 declare const emitters_shutdownEmitter: typeof shutdownEmitter;
 declare const emitters_signalBacktestEmitter: typeof signalBacktestEmitter;
 declare const emitters_signalEmitter: typeof signalEmitter;
+declare const emitters_signalEventSubject: typeof signalEventSubject;
 declare const emitters_signalLiveEmitter: typeof signalLiveEmitter;
 declare const emitters_signalNotifySubject: typeof signalNotifySubject;
 declare const emitters_strategyCommitSubject: typeof strategyCommitSubject;
@@ -30095,7 +31402,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_activePingSubject as activePingSubject, emitters_afterEndSubject as afterEndSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_beforeStartSubject as beforeStartSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_entrySubject as entrySubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_idlePingSubject as idlePingSubject, emitters_maxDrawdownSubject as maxDrawdownSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_signalNotifySubject as signalNotifySubject, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncPendingSubject as syncPendingSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_activePingSubject as activePingSubject, emitters_afterEndSubject as afterEndSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_beforeStartSubject as beforeStartSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_entrySubject as entrySubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_idlePingSubject as idlePingSubject, emitters_maxDrawdownSubject as maxDrawdownSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_scheduleEventSubject as scheduleEventSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalEventSubject as signalEventSubject, emitters_signalLiveEmitter as signalLiveEmitter, emitters_signalNotifySubject as signalNotifySubject, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncPendingSubject as syncPendingSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -31228,6 +32535,38 @@ declare class ActionCoreService implements TAction$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Routes a scheduled signal lifecycle event (creation / cancellation) to all registered actions.
+     *
+     * Retrieves action list from strategy schema (IStrategySchema.actions) and invokes the
+     * scheduleEvent handler on each ClientAction instance sequentially. Called once on creation
+     * (action "scheduled") and once on cancellation before activation (action "cancelled").
+     *
+     * @param backtest - Whether running in backtest mode (true) or live mode (false)
+     * @param event - Scheduled lifecycle event data (action discriminates created vs cancelled)
+     * @param context - Strategy execution context with strategyName, exchangeName, frameName
+     */
+    scheduleEvent: (backtest: boolean, event: ScheduleEventContract, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Routes a pending signal lifecycle event (open / close) to all registered actions.
+     *
+     * Retrieves action list from strategy schema (IStrategySchema.actions) and invokes the
+     * pendingEvent handler on each ClientAction instance sequentially. Called once on open
+     * (action "opened") and once on close (action "closed").
+     *
+     * @param backtest - Whether running in backtest mode (true) or live mode (false)
+     * @param event - Pending lifecycle event data (action discriminates opened vs closed)
+     * @param context - Strategy execution context with strategyName, exchangeName, frameName
+     */
+    pendingEvent: (backtest: boolean, event: SignalEventContract, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
     /**
      * Routes active ping event to all registered actions for the strategy.
      *
@@ -31298,7 +32637,7 @@ declare class ActionCoreService implements TAction$1 {
      * @param event - Pending-ping event with action "signal-ping"
      * @param context - Strategy execution context
      */
-    orderPing: (backtest: boolean, event: SignalPingContract, context: {
+    orderCheck: (backtest: boolean, event: SignalPingContract, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
@@ -32707,6 +34046,42 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+     *
+     * Delegates to ClientStrategy.createTakeProfit(). The close is deferred and emitted with
+     * closeReason "take_profit" on the next tick()/backtest(). Works out of the execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    createTakeProfit: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+     *
+     * Delegates to ClientStrategy.createStopLoss(). The close is deferred and emitted with
+     * closeReason "stop_loss" on the next tick()/backtest(). Works out of the execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    createStopLoss: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the in-memory deferred strategy-state snapshot for this iteration.
      *
@@ -33328,6 +34703,27 @@ declare class ActionProxy implements IPublicAction {
      * @returns Promise resolving to user's pingScheduled() result or null on error
      */
     pingScheduled(event: SchedulePingContract): Promise<any>;
+    /**
+     * Handles scheduled signal lifecycle events with error capture.
+     *
+     * Wraps the user's scheduleEvent() method to catch and log any errors. Called once when a
+     * scheduled signal is created (action "scheduled") and once when it is cancelled before
+     * activation (action "cancelled").
+     *
+     * @param event - Scheduled lifecycle data (action discriminates created vs cancelled)
+     * @returns Promise resolving to user's scheduleEvent() result or null on error
+     */
+    scheduleEvent(event: ScheduleEventContract): Promise<any>;
+    /**
+     * Handles pending signal lifecycle events with error capture.
+     *
+     * Wraps the user's pendingEvent() method to catch and log any errors. Called once when a
+     * pending position is opened (action "opened") and once when it is closed (action "closed").
+     *
+     * @param event - Pending lifecycle data (action discriminates opened vs closed)
+     * @returns Promise resolving to user's pendingEvent() result or null on error
+     */
+    pendingEvent(event: SignalEventContract): Promise<any>;
     /**
      * Handles active ping events with error capture.
      *
@@ -33371,7 +34767,7 @@ declare class ActionProxy implements IPublicAction {
      *
      * @param event - Pending-ping event with action "signal-ping"
      */
-    orderPing(event: SignalPingContract): Promise<void>;
+    orderCheck(event: SignalPingContract): Promise<void>;
     /**
      * Cleans up resources with error capture.
      *
@@ -33506,6 +34902,22 @@ declare class ClientAction implements IAction {
      * Handles scheduled ping events during scheduled signal monitoring.
      */
     pingScheduled(event: SchedulePingContract): Promise<void>;
+    /**
+     * Handles scheduled signal lifecycle events (creation / cancellation).
+     *
+     * Manual wiring — EVENT-BASED: users implement {@link IActionCallbacks.onScheduleEvent} (via `addActionSchema`)
+     * to drive the exchange (`commitActivateScheduled` / `commitCancelScheduled`); see that contract
+     * for the full guidance and example. This internal dispatch forwards to the handler/callback.
+     */
+    scheduleEvent(event: ScheduleEventContract): Promise<void>;
+    /**
+     * Handles pending signal lifecycle events (open / close).
+     *
+     * Manual wiring — EVENT-BASED: users implement {@link IActionCallbacks.onPendingEvent} (via `addActionSchema`) to
+     * drive the exchange; for per-tick fills use `onPingActive`. See that contract for the full
+     * guidance and example. This internal dispatch forwards to the handler/callback.
+     */
+    pendingEvent(event: SignalEventContract): Promise<void>;
     /**
      * Handles active ping events during active pending signal monitoring.
      */
@@ -33527,7 +34939,7 @@ declare class ClientAction implements IAction {
      * Gate for the pending-order ping (order still open on exchange?).
      * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
      */
-    orderPing(event: SignalPingContract): Promise<void>;
+    orderCheck(event: SignalPingContract): Promise<void>;
     /**
      * Cleans up resources and subscriptions when action handler is no longer needed.
      * Uses singleshot pattern to ensure cleanup happens exactly once.
@@ -33693,6 +35105,32 @@ declare class ActionConnectionService implements TAction {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Routes a scheduled signal lifecycle event (creation / cancellation) to the ClientAction instance.
+     *
+     * @param event - Scheduled lifecycle event data (action discriminates created vs cancelled)
+     * @param backtest - Whether running in backtest mode
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
+     */
+    scheduleEvent: (event: ScheduleEventContract, backtest: boolean, context: {
+        actionName: ActionName;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
+    /**
+     * Routes a pending signal lifecycle event (open / close) to the ClientAction instance.
+     *
+     * @param event - Pending lifecycle event data (action discriminates opened vs closed)
+     * @param backtest - Whether running in backtest mode
+     * @param context - Execution context with action name, strategy name, exchange name, frame name
+     */
+    pendingEvent: (event: SignalEventContract, backtest: boolean, context: {
+        actionName: ActionName;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<void>;
     /**
      * Routes active ping event to appropriate ClientAction instance.
      *
@@ -33748,14 +35186,14 @@ declare class ActionConnectionService implements TAction {
         frameName: FrameName;
     }) => Promise<void>;
     /**
-     * Routes orderPing event to appropriate ClientAction instance.
+     * Routes orderCheck event to appropriate ClientAction instance.
      * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
      *
      * @param event - Pending-ping event with action "signal-ping"
      * @param backtest - Whether running in backtest mode
      * @param context - Execution context
      */
-    orderPing: (event: SignalPingContract, backtest: boolean, context: {
+    orderCheck: (event: SignalPingContract, backtest: boolean, context: {
         actionName: ActionName;
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -34344,6 +35782,44 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<void>;
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+     *
+     * Validates the context, then delegates to StrategyConnectionService.createTakeProfit().
+     * The close is deferred and emitted with closeReason "take_profit" on the next tick/backtest.
+     * Does not require execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    createTakeProfit: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+     *
+     * Validates the context, then delegates to StrategyConnectionService.createStopLoss().
+     * The close is deferred and emitted with closeReason "stop_loss" on the next tick/backtest.
+     * Does not require execution context.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @param payload - Optional commit payload with id and note
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    createStopLoss: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, payload?: Partial<CommitPayload>) => Promise<void>;
     /**
      * Returns the in-memory deferred strategy-state snapshot for this iteration.
      *
@@ -38100,4 +39576,4 @@ declare const getTotalClosed: (signal: Signal) => {
  */
 declare const getPriceScale: (value: number) => 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 BrokerSignalPendingPayload, 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 IPersistStrategyInstance, 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 IRuntimeInfo, type IRuntimeRange, 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, PersistStrategyAdapter, PersistStrategyInstance, 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, type RuntimeData, 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 SignalPingContract, 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 StrategyData, type StrategyEvent, type StrategyStatisticsModel, type StrategyStatus, 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 TPersistStrategyInstanceCtor, 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, commitCreateSignal, 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, getPriceScale, getRawCandles, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getStrategyStatus, 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, validateCandles, 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 BrokerActivePingPayload, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerIdlePingPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerPendingClosePayload, type BrokerPendingOpenPayload, type BrokerScheduleCancelledPayload, type BrokerScheduleOpenPayload, type BrokerSchedulePingPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerSignalPendingPayload, 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 IPersistStrategyInstance, 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 IRuntimeInfo, type IRuntimeRange, 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, PersistStrategyAdapter, PersistStrategyInstance, 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, type RuntimeData, Schedule, type ScheduleData, type ScheduleEventContract, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, Session, SessionBacktest, type SessionData, SessionLive, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalEventContract, type SignalInfoContract, type SignalInfoNotification, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalPingContract, 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 StrategyData, type StrategyEvent, type StrategyStatisticsModel, type StrategyStatus, 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 TPersistStrategyInstanceCtor, 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, commitCreateSignal, commitCreateStopLoss, commitCreateTakeProfit, 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, getPriceScale, getRawCandles, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getStrategyStatus, 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, listenScheduleEvent, listenScheduleEventOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalEvent, listenSignalEventOnce, 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, validateCandles, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };