@christtrade/depth 0.12.24 → 0.12.26

package/types/core/TypedEventBus.d.ts

@@ -1,6 +1,7 @@
 import { LiveTransformer } from '../interfaces/ICoordinateTransformer';
 import { ChartSettings } from '../lib/types/chart-settings';
 import { type SessionStatus } from './SessionUtils';
+import type { StrategyEquityPoint, StrategyPosition, StrategyStats, StrategyTrade } from './strategy-runtime';
 import { BarPreviewResponse, OhlcvBar, SymbolInfo, SymbolSearchMode, SymbolSearchRequest, TradingSession } from '../interfaces/IDataAdapter';
 import { DataLevel } from '../interfaces/IDataAdapter';
 import { IExecutionAdapter } from '../interfaces/IExecutionAdapter';
@@ -26,6 +27,12 @@ export interface ChartEvents {
     } | null;
     'chart:ready': void;
     'chart:reset-view': void;
+    'chart:goto-range': {
+        fromNs: bigint;
+        toNs?: bigint;
+        /** Fraction of the span to leave either side. Default 0.25. */
+        padding?: number;
+    };
     'chart:set-tool': {
         tool: ActiveDrawingTool;
     };
@@ -88,7 +95,7 @@ export interface ChartEvents {
     'timeframe:change': {
         tf: Timeframe;
     };
-    /** Runtime entitlement change (see `chart.allowTimeframes`). The UI re-reads
+    /** Runtime entitlement change. The UI re-reads
      *  `features` so locks and gates reflect what is allowed now. */
     'features:change': void;
     'timeframe:add-failed': {
@@ -542,6 +549,184 @@ export interface ChartEvents {
     'plugin:indicator-updated': {
         id: string;
     };
+    'plugin:strategy-updated': {
+        id: string;
+        name: string;
+        stats: StrategyStats;
+        trades: StrategyTrade[];
+        equity: StrategyEquityPoint[];
+        /** Still open at the last bar, if the run ended holding something. */
+        position: StrategyPosition | null;
+        /** The parameter values that produced these numbers. */
+        params: Record<string, unknown>;
+        /**
+         * The script's parameter declarations, so a sweep UI can offer a range
+         * for each without the author declaring anything extra - a numeric
+         * ParamDef already carries min, max and step.
+         */
+        paramDefs: Record<string, unknown>;
+        /** Bars this run actually covered - not always what was asked for. `clipped` is false for a run over everything loaded. */
+        range: {
+            fromNs: bigint | null;
+            toNs: bigint | null;
+            bars: number;
+            totalBars: number;
+            clipped: boolean;
+            /** Span the loaded data covers, so a picker can bound itself. */
+            dataFromNs: bigint | null;
+            dataToNs: bigint | null;
+        };
+    };
+    'plugin:apply-params': {
+        id: string;
+        params: Record<string, unknown>;
+    };
+    'plugin:strategy-range': {
+        id: string;
+        range: {
+            fromNs?: bigint;
+            toNs?: bigint;
+        } | null;
+        /**
+         * Fetch the span instead of clipping to what the chart holds. Opt-in -
+         * clipping is free and covers almost every range, fetching walks the
+         * network a chunk at a time. Requires `fromNs`; no streaming backwards
+         * from an open-ended start.
+         */
+        fetch?: boolean;
+    };
+    'plugin:strategy-run': {
+        id: string;
+        /** `null` clears any bound and runs over everything loaded; omitted keeps the stored bound. */
+        range?: {
+            fromNs?: bigint;
+            toNs?: bigint;
+        } | null;
+        /** As on 'plugin:strategy-range' - go get the span, don't clip. */
+        fetch?: boolean;
+    };
+    'plugin:strategy-mode': {
+        id: string;
+        manual: boolean;
+    };
+    'plugin:strategy-stale': {
+        id: string;
+        name: string;
+        /** Bars arrived since the last run, or 0. */
+        newBars: number;
+        /** Params edited since the last run. Empty when none. */
+        params: Record<string, unknown>;
+    };
+    'plugin:strategy-progress': {
+        id: string;
+        name: string;
+        phase: 'fetching' | 'running' | 'analysing' | 'done' | 'failed';
+        done: number;
+        total: number;
+        error?: string;
+    };
+    'plugin:strategy-sweep': {
+        id: string;
+        grid: Array<Record<string, unknown>>;
+        /** Fraction held back from the end as out-of-sample. */
+        oosFraction?: number;
+        /**
+         * What each grid point patches over. Pass what the settings dialog
+         * currently holds, so parameters that are not being swept keep the value
+         * the user set. Omitted falls back to the script's declared defaults.
+         */
+        params?: Record<string, unknown>;
+    };
+    'plugin:strategy-sweep-cancel': {
+        id: string;
+    };
+    'plugin:strategy-sweep-progress': {
+        id: string;
+        done: number;
+        total: number;
+    };
+    'plugin:strategy-sweep-done': {
+        id: string;
+        /** One entry per grid point, in grid order. `error` instead of `stats`
+         *  for a combination that threw. */
+        results: Array<{
+            params: Record<string, unknown>;
+            stats?: StrategyStats;
+            inSample?: StrategyStats;
+            outOfSample?: StrategyStats;
+            error?: string;
+        }>;
+    };
+    'plugin:strategy-sweep-cancelled': {
+        id: string;
+        done: number;
+    };
+    'plugin:strategy-sweep-rejected': {
+        id: string;
+        name: string;
+        combos: number;
+        bars: number;
+        iterations: number;
+        reason: string;
+    };
+    'plugin:strategy-walkforward': {
+        id: string;
+        grid: Array<Record<string, unknown>>;
+        params?: Record<string, unknown>;
+        /** Out-of-sample segments to test. Default 4. */
+        windows?: number;
+        /** In-sample length as a multiple of out-of-sample. Default 3. */
+        isMultiple?: number;
+        /** Fixed in-sample start rather than a sliding window. */
+        anchored?: boolean;
+        /** Which statistic the optimiser maximises. Default 'netPnl'. */
+        objective?: string;
+        /** False for drawdown-like objectives. */
+        higherIsBetter?: boolean;
+    };
+    'plugin:strategy-walkforward-cancel': {
+        id: string;
+    };
+    'plugin:strategy-walkforward-progress': {
+        id: string;
+        done: number;
+        total: number;
+    };
+    'plugin:strategy-walkforward-done': {
+        id: string;
+        results: Array<{
+            window: {
+                index: number;
+                isFrom: number;
+                isTo: number;
+                oosFrom: number;
+                oosTo: number;
+            };
+            params?: Record<string, unknown>;
+            inSample?: StrategyStats;
+            outOfSample?: StrategyStats;
+            /** The test segment's own curve. Stitched across windows, this is the
+             *  equity of parameters never fitted to the data they run over. */
+            outOfSampleEquity?: StrategyEquityPoint[];
+            error?: string;
+        }>;
+    };
+    'plugin:strategy-walkforward-cancelled': {
+        id: string;
+        done: number;
+    };
+    'plugin:strategy-walkforward-rejected': {
+        id: string;
+        name: string;
+        reason: string;
+    };
+    'plugin:strategy-rejected': {
+        id: string;
+        name: string;
+        bars: number;
+        maxBars: number;
+        reason: string;
+    };
     'plugin:update-code': {
         id: string;
         code: string;

package/types/core/index.d.ts

@@ -25,6 +25,14 @@ export type { ChartModelInit, ChartPluginRef, ChartPaneState } from './ChartMode
 export { DrawingStore } from './DrawingStore';
 export type { ChartPlugin, PluginType, Permission, PluginManifest, PluginContext, PluginDataSnapshot, DrawingPlugin, ChartTypePlugin, ChartTypeRenderContext, DataSourcePlugin, IndicatorPlugin, IndicatorRenderContext, } from '../interfaces/plugins';
 export { createScriptedPlugin } from './ScriptedPlugin';
+export { StrategyEngine, DEFAULT_STRATEGY_CONFIG, reconcileIntrabar } from './strategy-runtime';
+export { axisValues, checkSweepBudget, expandGrid, splitIndex, MAX_SWEEP_COMBOS, MAX_SWEEP_BAR_ITERATIONS, } from './strategy-sweep';
+export type { SweepAxis, SweepSpec, SweepResult, SweepBudget } from './strategy-sweep';
+export { clipRange, hasRange, emptyRangeReason } from './strategy-range';
+export type { StrategyRange, ClippedRange } from './strategy-range';
+export { planWalkForward, walkForwardEfficiency, parameterStability, pickBest, } from './strategy-walkforward';
+export type { WalkForwardSpec, WalkForwardWindow, WalkForwardWindowResult, ParameterStability, } from './strategy-walkforward';
+export type { BrokerApi, StrategyEquityPoint, ExitReason, OrderOpts, Side, StrategyBar, StrategyConfig, StrategyOrder, StrategyPosition, StrategyResult, StrategyStats, StrategyTrade, } from './strategy-runtime';
 export { isCompatible, DATA_LEVEL_LABELS, incompatibleReason } from './processing/data-level';
 export { processL3Chunk, mergeL3Chunks } from './processing/l3-processor';
 export type { ProcessedL3Chunk, L3DataChunk } from './processing/l3-processor';

package/types/core/script-dsl.d.ts

@@ -4,6 +4,7 @@ export declare const PluginType: Readonly<{
     readonly chartType: "chart-type";
     readonly dataSource: "data-source";
     readonly extension: "extension";
+    readonly strategy: "strategy";
 }>;
 export declare const DataLevel: Readonly<{
     readonly mbo: "l3";
@@ -16,5 +17,13 @@ export declare const Layout: Readonly<{
     readonly overlay: "overlay";
     readonly pane: "pane";
 }>;
+/** Why a strategy position closed. Mirrors ExitReason in strategy-runtime.ts. */
+export declare const ExitReason: Readonly<{
+    readonly signal: "signal";
+    readonly stop: "stop";
+    readonly target: "target";
+    readonly reverse: "reverse";
+    readonly endOfData: "end-of-data";
+}>;
 /** The DSL globals as one bag, for splatting into an eval scope. */
 export declare const SCRIPT_DSL: Record<string, unknown>;

package/types/core/script-runtime.d.ts

@@ -1,7 +1,15 @@
 import { STDLIB } from '../lib/indicator-stdlib';
-import { PluginType, DataLevel, Layout, SCRIPT_DSL } from './script-dsl';
-export { STDLIB, SCRIPT_DSL, PluginType, DataLevel, Layout };
+import { PluginType, DataLevel, Layout, ExitReason, SCRIPT_DSL } from './script-dsl';
+export { STDLIB, SCRIPT_DSL, PluginType, DataLevel, Layout, ExitReason };
 export type { OhlcvBar, DrawCommand } from '../lib/indicator-stdlib';
+export { StrategyEngine, DEFAULT_STRATEGY_CONFIG, reconcileIntrabar } from './strategy-runtime';
+export { axisValues, checkSweepBudget, expandGrid, splitIndex } from './strategy-sweep';
+export { clipRange, hasRange, emptyRangeReason } from './strategy-range';
+export type { StrategyRange, ClippedRange } from './strategy-range';
+export type { SweepAxis, SweepSpec, SweepResult, SweepBudget } from './strategy-sweep';
+export { planWalkForward, walkForwardEfficiency, parameterStability, pickBest, } from './strategy-walkforward';
+export type { WalkForwardSpec, WalkForwardWindow, WalkForwardWindowResult, ParameterStability, } from './strategy-walkforward';
+export type { BrokerApi, StrategyEquityPoint, OrderOpts, Side, StrategyBar, StrategyConfig, StrategyOrder, StrategyPosition, StrategyResult, StrategyStats, StrategyTrade, } from './strategy-runtime';
 export interface ScriptScopeOptions {
     /** What the script's `plugin({...})` call resolves to. */
     plugin: (decl: unknown) => unknown;
@@ -38,6 +46,7 @@ export declare function buildScriptScope(opts: ScriptScopeOptions): Record<strin
  * script makes while evaluating.
  */
 export declare function evalScriptInScope(src: string, opts: ScriptScopeOptions): void;
+export declare function defaultStrategyDraw(state: unknown, layout: 'overlay' | 'pane'): unknown[];
 /**
  * Identifies the stdlib surface this build exposes, for a client and a server
  * runner to agree they are talking about the same one.

package/types/core/strategy-range.d.ts

@@ -0,0 +1,41 @@
+import type { StrategyBar } from './strategy-runtime';
+/** Inclusive both ends, nanoseconds. An omitted end means "as far as the data goes". */
+export interface StrategyRange {
+    fromNs?: bigint;
+    toNs?: bigint;
+}
+/** Where a range lands in a bar array, plus what it cost. */
+export interface ClippedRange {
+    /** First bar in range. */
+    from: number;
+    /** One past the last bar in range, so `bars.slice(from, to)` is the run. */
+    to: number;
+    /** How many bars the run will see. */
+    count: number;
+    /** How many bars were available before clipping. */
+    total: number;
+    /** Timestamps of the first and last bar actually in range. */
+    firstTs: bigint | null;
+    lastTs: bigint | null;
+    /** Span the whole data set covers, ignoring the range - lets a picker bound itself to what exists. */
+    dataFromNs: bigint | null;
+    dataToNs: bigint | null;
+}
+/**
+ * Resolve a range against a sorted bar array. `toNs` includes the bar that opens
+ * exactly on it. Binary search, not a filter - this runs once per sweep
+ * combination, and a linear scan over a million bars twenty thousand times
+ * turns a sweep into a hang.
+ *
+ * No warmup before `from`: feeding a run bars it isn't allowed to trade is how
+ * an out-of-sample window quietly stops being out of sample.
+ */
+export declare function clipRange(bars: readonly StrategyBar[], range?: StrategyRange): ClippedRange;
+/** True when the range asks for something, rather than being absent or empty. */
+export declare function hasRange(range?: StrategyRange): boolean;
+/**
+ * Why a clipped run has nothing to run over. Spelled out rather than an empty
+ * result, since a strategy with no trades and one given no bars look identical
+ * in a results panel, and only one of those is the user's fault.
+ */
+export declare function emptyRangeReason(clipped: ClippedRange, range?: StrategyRange): string;

package/types/core/strategy-runtime.d.ts

@@ -0,0 +1,365 @@
+/** Which way a position or fill points. */
+export type Side = 'long' | 'short' | 'flat';
+export type OrderKind = 'market' | 'limit' | 'stop';
+/** Why a position closed, for the trade log and the markers on the chart. */
+export type ExitReason = 'signal' | 'stop' | 'target' | 'reverse' | 'end-of-data';
+export interface StrategyOrder {
+    id: number;
+    side: 'buy' | 'sell';
+    qty: number;
+    kind: OrderKind;
+    /** Trigger price for limit/stop. Ignored for market. */
+    price?: number;
+    /** Protective stop attached to the position this order opens. */
+    sl?: number;
+    /** Profit target attached to the position this order opens. */
+    tp?: number;
+    tag?: string;
+    /** Bar index the order was placed on. It becomes eligible on the next one. */
+    placedIndex: number;
+}
+export interface StrategyPosition {
+    side: Side;
+    qty: number;
+    avgPrice: number;
+    entryTs: bigint;
+    entryIndex: number;
+    sl?: number;
+    tp?: number;
+    tag?: string;
+    /**
+     * Best/worst price while open, from the entry bar's full range. Exact for
+     * a market fill; an upper bound for a limit/stop filling mid-bar - don't
+     * read MAE as gospel on a one-bar trade.
+     */
+    highWatermark: number;
+    lowWatermark: number;
+    /** Bar index and timestamp of the best excursion, for efficiency analysis. */
+    mfeIndex: number;
+    mfeTs: bigint;
+    maeIndex: number;
+    maeTs: bigint;
+    /**
+     * |entry - stop| per unit, locked at entry. Undefined when the position
+     * opened without a stop, which makes every R-multiple on it meaningless
+     * rather than zero - the difference matters, so it stays undefined.
+     */
+    initialRiskPerUnit?: number;
+    /** Fills that have gone into this position. Checked against `pyramiding`. */
+    entries: number;
+    /**
+     * Commission already paid to open the quantity still held. Carried so the
+     * exit's trade record can report the round-trip fee - otherwise pnl
+     * wouldn't sum to the equity curve.
+     */
+    entryFees: number;
+}
+export interface StrategyTrade {
+    id: number;
+    side: Exclude<Side, 'flat'>;
+    qty: number;
+    entryTs: bigint;
+    entryPrice: number;
+    exitTs: bigint;
+    exitPrice: number;
+    /** Net of fees, in account currency. */
+    pnl: number;
+    /** Before fees. */
+    pnlGross: number;
+    /** Net return on the notional put at risk, as a fraction. */
+    pnlPct: number;
+    fees: number;
+    /** The fee split, because a strategy killed by commission and one killed by
+     *  slippage need different fixes. */
+    commission: number;
+    slippage: number;
+    /** How many bars the position was held. */
+    bars: number;
+    /** Wall-clock time held, in nanoseconds. */
+    durationNs: bigint;
+    tag?: string;
+    reason: ExitReason;
+    /**
+     * Stop and target both sat inside the resolving bar, so which came first
+     * was assumed (stop wins) rather than observed. Intrabar data shrinks how
+     * often this happens but never zeroes it.
+     */
+    ambiguousExit?: boolean;
+    /** Worst the price went against this position before it closed. */
+    maeAbs: number;
+    /** Best the price went in favour of it. */
+    mfeAbs: number;
+    /** The same two, in account currency. */
+    maePnl: number;
+    mfePnl: number;
+    /** When the best and worst excursions happened. */
+    mfeTs: bigint;
+    maeTs: bigint;
+    /** Bars from entry to the best excursion. Tells you if you exit too late. */
+    barsToMfe: number;
+    /** |entry - stop| per unit at entry. */
+    initialRiskPerUnit?: number;
+    /** Total risk taken: initialRiskPerUnit x qty x contractSize. */
+    initialRiskTotal?: number;
+    /** Result in R. */
+    realizedR?: number;
+    /** Best and worst R reached while open. */
+    maxFavorableR?: number;
+    maxAdverseR?: number;
+    /**
+     * How much of the favourable excursion the exit actually captured, 0..1.
+     * A strategy averaging 0.2 here is right about direction and wrong about
+     * exits, which is a different problem from one that is simply wrong.
+     */
+    efficiency?: number;
+    /** Peak-to-exit give-back within this position, in account currency. */
+    maxDrawdownAbs: number;
+    maxDrawdownPct: number;
+    /** The protective levels this position opened with, if any. */
+    sl?: number;
+    tp?: number;
+}
+export interface StrategyEquityPoint {
+    ts: bigint;
+    /** Mark-to-market account value at this bar's close. */
+    equity: number;
+    /** Fraction below the running peak, 0 at a new high. */
+    drawdown: number;
+}
+export interface StrategyStats {
+    netPnl: number;
+    grossProfit: number;
+    grossLoss: number;
+    /** grossProfit / |grossLoss|. Infinity with no losers, 0 with no winners. */
+    profitFactor: number;
+    totalTrades: number;
+    wins: number;
+    losses: number;
+    /** Fraction, not percent. */
+    winRate: number;
+    avgWin: number;
+    avgLoss: number;
+    /** Expected P&L per trade. */
+    expectancy: number;
+    maxDrawdown: number;
+    maxDrawdownPct: number;
+    /** Annualised, from per-bar returns and the bar period. 0 without one. */
+    sharpe: number;
+    returnPct: number;
+    /** Fraction of bars holding a position. */
+    exposure: number;
+    finalEquity: number;
+    largestWin: number;
+    largestLoss: number;
+    /** Median trade P&L. The mean is what one outlier moves; this is not. */
+    medianPnl: number;
+    /** avgWin / |avgLoss|. How much bigger a winner is than a loser. */
+    payoffRatio: number;
+    /** Trades that closed exactly flat, counted separately from wins and losses. */
+    breakEvens: number;
+    maxWinStreak: number;
+    maxLossStreak: number;
+    /** Signed: positive means the run ended on N wins, negative on N losses. */
+    currentStreak: number;
+    avgBarsHeld: number;
+    avgWinBarsHeld: number;
+    avgLossBarsHeld: number;
+    /** Total bars in the run, for anything wanting to re-derive a rate. */
+    totalBars: number;
+    /** Like Sharpe but only downside deviation is punished. */
+    sortino: number;
+    /** Annualised return over max drawdown. */
+    calmar: number;
+    /** Net profit over max drawdown - how much the strategy makes per unit of pain. */
+    recoveryFactor: number;
+    /** RMS of the drawdown series. Punishes long shallow drawdowns Sharpe ignores. */
+    ulcerIndex: number;
+    /** System Quality Number: sqrt(n) x mean / stdev of trade P&L. */
+    sqn: number;
+    /** Kelly fraction from win rate and payoff. Negative means no edge. */
+    kelly: number;
+    /** Compound annual growth rate, from the run's wall-clock span. */
+    cagr: number;
+    /** How many trades carried a stop, and so have an R at all. */
+    tradesWithRisk: number;
+    avgR: number;
+    /** Sum of R. The expectancy curve most people actually track. */
+    totalR: number;
+    /** Mean of realizedR / maxFavorableR - how much of the move exits capture. */
+    avgEfficiency: number;
+    avgMae: number;
+    avgMfe: number;
+    longTrades: number;
+    shortTrades: number;
+    longWinRate: number;
+    shortWinRate: number;
+    longPnl: number;
+    shortPnl: number;
+    totalFees: number;
+    totalCommission: number;
+    /**
+     * What slippage cost, in account currency - already inside netPnl via the
+     * fill prices, reported here rather than deducted again.
+     */
+    totalSlippage: number;
+    /** What the run would have made with no commission at all. */
+    grossPnlBeforeCosts: number;
+    /** Chart bars whose fills were resolved against finer intrabar data. */
+    intrabarBars: number;
+    /**
+     * Bars given intrabar data that didn't reconcile with the aggregate and
+     * fell back to it. Non-zero means the finer feed has holes - the run is
+     * still valid, just not the run the intrabar toggle implies.
+     */
+    intrabarFallbacks: number;
+    /**
+     * Exits where stop and target shared a resolving bar and the stop was
+     * assumed first. Compare against `totalTrades` for how much of the result
+     * rests on that assumption.
+     */
+    ambiguousExits: number;
+}
+export interface StrategyConfig {
+    initialCapital: number;
+    /** Charged per contract per side. */
+    commission: number;
+    /** Applied against the trader, in ticks, on market and stop fills. */
+    slippageTicks: number;
+    tickSize: number;
+    /** Account-currency value of one point of price movement, per contract. */
+    contractSize: number;
+    /** How many entries may stack in the same direction. */
+    pyramiding: number;
+    /**
+     * Whether an opposite-side order flips a position or just closes it. True
+     * matches how most scripts read: sell() while long means "get out and go
+     * short".
+     */
+    allowReverse: boolean;
+    /**
+     * Smallest tradable quantity increment; order sizes floor to it. 1 for a
+     * listed future, fractional for spot - comes from the instrument, not
+     * assumed.
+     */
+    qtyStep: number;
+}
+export declare const DEFAULT_STRATEGY_CONFIG: StrategyConfig;
+export interface StrategyResult {
+    trades: StrategyTrade[];
+    equity: StrategyEquityPoint[];
+    stats: StrategyStats;
+    position: StrategyPosition | null;
+    openOrders: StrategyOrder[];
+}
+/** One OHLCV bar, structurally what the stdlib and the data engine already use. */
+export interface StrategyBar {
+    ts: bigint;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+/**
+ * Do these finer bars actually subdivide this one?
+ *
+ * A feed with a hole in it is worse than none at all - it'd resolve a stop
+ * against a range missing the second price actually traded through. Rejected
+ * whole rather than repaired, since fixing it would mean inventing the
+ * ordering inside the gap.
+ *
+ * @param tolerance Half a tick - two aggregation paths over the same trades
+ * agree to the tick, not the float.
+ */
+export declare function reconcileIntrabar(bar: StrategyBar, sub: readonly StrategyBar[] | undefined, tolerance: number): boolean;
+export interface OrderOpts {
+    /** Place a limit instead of a market order. */
+    limit?: number;
+    /** Place a stop instead of a market order. */
+    stop?: number;
+    /** Protective stop for the resulting position, as an absolute price. */
+    sl?: number;
+    /** Profit target for the resulting position, as an absolute price. */
+    tp?: number;
+    /** Free label, carried onto the trade and shown on the chart marker. */
+    tag?: string;
+}
+/** What a strategy script sees as `broker`. */
+export interface BrokerApi {
+    buy(qty?: number, opts?: OrderOpts): number;
+    sell(qty?: number, opts?: OrderOpts): number;
+    /** Flatten at the next bar's open. No-op when already flat. */
+    close(): void;
+    cancelAll(): void;
+    readonly position: Readonly<StrategyPosition> | null;
+    readonly equity: number;
+    readonly cash: number;
+    readonly openOrders: readonly StrategyOrder[];
+}
+export declare class StrategyEngine {
+    private cfg;
+    private pending;
+    private pos;
+    private trades;
+    private equityCurve;
+    private realized;
+    private peak;
+    private nextOrderId;
+    private index;
+    private barsInPosition;
+    private barCount;
+    private markPrice;
+    private closeRequested;
+    private barNs;
+    private slippagePaid;
+    private usedIntrabar;
+    private intrabarBars;
+    private intrabarFallbacks;
+    private ambiguousExits;
+    private pendingEquity;
+    private equityCount;
+    private firstTs;
+    private lastTs;
+    private lastEquity;
+    private prevEquity;
+    private maxDdAbs;
+    private maxDdPct;
+    private ulcerSum;
+    private retN;
+    private retMean;
+    private retM2;
+    private downSum;
+    private downCount;
+    private curvePhase;
+    private curveStride;
+    private lastFolded;
+    constructor(cfg?: Partial<StrategyConfig>);
+    setBarNs(ns: bigint): void;
+    beginBar(bar: StrategyBar, index: number, sub?: readonly StrategyBar[]): void;
+    endBar(bar: StrategyBar): void;
+    private foldPending;
+    private keepInCurve;
+    finish(lastBar: StrategyBar | undefined): void;
+    get equity(): number;
+    get result(): StrategyResult;
+    api(): BrokerApi;
+    private place;
+    private processPending;
+    private fillPrice;
+    private execute;
+    private maxEntries;
+    private roundQty;
+    private enter;
+    private slippageCost;
+    private exit;
+    private checkBrackets;
+    private trackExcursion;
+    private commissionFor;
+    private unrealized;
+    private computeStats;
+    private runYears;
+    private cagr;
+    private sortino;
+    private barsInPositionTotal;
+    private sharpe;
+}