acttrader-charts 1.3.0-beta.2 → 1.3.0-beta.21

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ChartConfig, O as OHLCVBar, I as IIndicator, a as IndicatorParams, b as ChartEventMap, T as Timeframe, S as SeriesType, c as ChartState, D as DrawingToolType, d as IDrawing, A as AnyDrawingStyle, e as IWebSocketAdapter, f as TradeLevelType, L as LayoutSyncState, g as ChartTheme, h as AnyLevel, i as DrawingPoint, j as ScaleManager, V as Viewport, P as PriceRange$1, k as DrawingHandle, l as SerializedDrawing, m as Tick, n as StreamStatus } from './MACD-D1i-sEFR.js';
-export { o as ActiveIndicatorState, B as BollingerBands, p as BottomBarColors, q as BottomBarLabels, r as BottomBarUiConfig, s as CanvasColorSettings, t as ChartLabels, u as ChartMiscLabels, v as ChartThemeUi, w as CrosshairPosition, x as CrosshairUiConfig, y as DARK_THEME, z as DEFAULT_BOTTOM_BAR_CONFIG, E as DEFAULT_CROSSHAIR_CONFIG, F as DEFAULT_DRAWING_TOOLBAR_CONFIG, G as DEFAULT_INDICATOR_OVERLAY_CONFIG, H as DEFAULT_LABELS, J as DEFAULT_LAYOUT_SYNC, K as DEFAULT_PRICE_AXIS_CONFIG, M as DEFAULT_TIME_AXIS_CONFIG, N as DEFAULT_TOP_BAR_CONFIG, Q as DEFAULT_TRADE_BUTTON_CONFIG, R as DEFAULT_UI_CONFIG, U as DataLoaderParams, W as DeepPartial, X as DeepPartialChartTheme, Y as DialogLabels, Z as DrawingToolbarColors, _ as DrawingToolbarLabels, $ as DrawingToolbarUiConfig, a0 as Duration, a1 as EMA, a2 as IndicatorOverlayColors, a3 as IndicatorOverlayUiConfig, a4 as IndicatorResult, a5 as IndicatorStateEntry, a6 as LAYOUT_PRESETS, a7 as LIGHT_THEME, a8 as LayoutPreset, a9 as MACD, aa as OhlcLabels, ab as OrderSubmit, ac as PRESETS_BY_COUNT, ad as PRESET_COUNTS, ae as PRESET_LABEL, af as Padding, ag as PendingOrderLevel, ah as PositionLevel, ai as PositionRenderStyle, aj as PriceAxisUiConfig, ak as RSI, al as SMA, am as Theme, an as ThemeOverrides, ao as TimeAxisUiConfig, ap as TopBarColors, aq as TopBarLabels, ar as TopBarUiConfig, as as TradeButtonUiConfig, at as TradeDisplayFilter, au as TradeLabels, av as TradeLevel, aw as TradeLevelColors, ax as TradePanelColors, ay as UiConfig, az as deepMergeTheme, aA as getAllPresets, aB as getCustomPresets, aC as getPreset, aD as registerCustomPreset, aE as resolveCssVarsInTheme, aF as resolveLabels, aG as resolveUiConfig, aH as unregisterCustomPreset } from './MACD-D1i-sEFR.js';
+import { C as ChartConfig, O as OHLCVBar, I as IIndicator, a as IndicatorParams, b as ChartEventMap, T as Timeframe, D as Duration, S as SeriesType, c as ChartState, d as InstrumentSpec, R as ResolvedInstrument, A as AccountSpec, e as DrawingToolType, f as IDrawing, g as AnyDrawingStyle, h as IWebSocketAdapter, i as TradeLevelType, L as LayoutSyncState, j as ChartTheme, P as PositionLevel, k as AnyLevel, l as DrawingPoint, m as ScaleManager, V as Viewport, n as PriceRange$1, o as DrawingHandle, p as DrawingRenderContext, q as SerializedDrawing, r as Tick, s as StreamStatus } from './MACD-B6SoR6iH.js';
+export { t as ActiveIndicatorState, B as BollingerBands, u as BottomBarColors, v as BottomBarLabels, w as BottomBarUiConfig, x as CanvasColorSettings, y as ChartLabels, z as ChartMiscLabels, E as ChartThemeUi, F as CrosshairPosition, G as CrosshairUiConfig, H as DARK_THEME, J as DEFAULT_BOTTOM_BAR_CONFIG, K as DEFAULT_CROSSHAIR_CONFIG, M as DEFAULT_DRAWING_TOOLBAR_CONFIG, N as DEFAULT_INDICATOR_OVERLAY_CONFIG, Q as DEFAULT_LABELS, U as DEFAULT_LAYOUT_SYNC, W as DEFAULT_PRICE_AXIS_CONFIG, X as DEFAULT_TIME_AXIS_CONFIG, Y as DEFAULT_TOP_BAR_CONFIG, Z as DEFAULT_TRADE_BUTTON_CONFIG, _ as DEFAULT_UI_CONFIG, $ as DataLoaderParams, a0 as DeepPartial, a1 as DeepPartialChartTheme, a2 as DialogLabels, a3 as DrawingToolbarColors, a4 as DrawingToolbarLabels, a5 as DrawingToolbarUiConfig, a6 as EMA, a7 as IndicatorOverlayColors, a8 as IndicatorOverlayUiConfig, a9 as IndicatorResult, aa as IndicatorStateEntry, ab as LAYOUT_PRESETS, ac as LIGHT_THEME, ad as LayoutPreset, ae as MACD, af as OhlcLabels, ag as OrderSubmit, ah as PRESETS_BY_COUNT, ai as PRESET_COUNTS, aj as PRESET_LABEL, ak as Padding, al as PendingOrderLevel, am as PnlPillConfig, an as PnlPillLabels, ao as PositionRenderStyle, ap as PriceAxisUiConfig, aq as RSI, ar as SMA, as as Theme, at as ThemeOverrides, au as TimeAxisUiConfig, av as TopBarColors, aw as TopBarLabels, ax as TopBarUiConfig, ay as TradeButtonUiConfig, az as TradeDisplayFilter, aA as TradeLabels, aB as TradeLevel, aC as TradeLevelColors, aD as TradePanelColors, aE as UiConfig, aF as deepMergeTheme, aG as formatDuration, aH as formatVolume, aI as getAllPresets, aJ as getCustomPresets, aK as getPreset, aL as inferPipSize, aM as registerCustomPreset, aN as resolveCssVarsInTheme, aO as resolveInstrument, aP as resolveLabels, aQ as resolveUiConfig, aR as toMoney, aS as toPips, aT as unregisterCustomPreset } from './MACD-B6SoR6iH.js';
 
 declare class ChartEngine {
     private wrapper;
@@ -49,6 +49,9 @@ declare class ChartEngine {
     private chartSettingsDialog;
     private tradeButton;
     private tradePopover;
+    /** Segmented click bar (`features.tradeActionBar`); replaces the popover as the trade button's target. */
+    private tradeActionBar;
+    private _onAddAlert;
     private drawingStylePopover;
     private draftOrderLabel;
     private _minLots;
@@ -71,11 +74,28 @@ declare class ChartEngine {
     private scaleManager;
     private emitter;
     private theme;
+    /**
+     * Theme for the DOM chrome (toolbars, dialogs, popovers). Tracks `theme`
+     * except that the user's Chart Settings surface picks are excluded, so a
+     * custom canvas background/axis colour cannot repaint the surrounding UI.
+     */
+    private chromeTheme;
     private themeName;
     private _debug;
     private series;
     private showVolume;
     private symbol;
+    /** Contract specs for the current symbol, as supplied by the host. */
+    private instrumentSpec;
+    /**
+     * `instrumentSpec` with fallbacks applied, rebuilt only when the spec or the
+     * feed's decimal count changes — resolving it per frame would re-derive the
+     * inferred pip size on every render.
+     */
+    private resolvedInstrument;
+    private resolvedInstrumentPrecision;
+    /** Account equity and per-trade risk used to size the position tools. */
+    private accountSpec;
     private showBidAskLines;
     /** Per-line visibility checks. `undefined` falls back to the legacy
      *  `showBidAskLines` behavior (both when true, source side when false). */
@@ -85,6 +105,11 @@ declare class ChartEngine {
     private hideLevelConfirmCancel;
     private deselectActiveOnOutsideClick;
     private tradeLevelButtonScale;
+    /** `tradeLevelBadgeScale` / `tradeLevelBadgeAnchor` — size and horizontal home of the main-level tag. */
+    private tradeLevelBadgeScale;
+    private tradeLevelBadgeAnchor;
+    /** What the SL/TP bracket pills read — see `ChartConfig.bracketLabelMode`. */
+    private _bracketLabel;
     private levelClusteringEnabled;
     private clusterThresholdDistance;
     private enableThemeToggle;
@@ -114,6 +139,13 @@ declare class ChartEngine {
     /** Pending resize — committed only after mouse moves past DRAW_GESTURE_THRESHOLD. */
     private _pendingDrawResize;
     private static readonly DRAW_GESTURE_THRESHOLD;
+    /**
+     * Extra px of reach when hit-testing drawing handles from a touch. Drawings
+     * use a ~8px mouse-sized radius; a fingertip is far wider, so without this a
+     * grab that looks on-target misses and the gesture falls through to
+     * pan/pinch — the chart zooms instead of resizing the shape.
+     */
+    private static readonly TOUCH_HANDLE_SLOP_PX;
     /**
      * Pending trade-level drag — committed only after mouse moves past TRADE_DRAG_PIXEL_THRESHOLD.
      * A mouseup before the threshold means it was a click: route to _openTradeLevelEditForm instead
@@ -121,6 +153,8 @@ declare class ChartEngine {
      */
     private _pendingTradeDrag;
     private static readonly TRADE_DRAG_PIXEL_THRESHOLD;
+    /** Movement a dual-axis badge grab needs before it commits to time vs price. */
+    private static readonly AXIS_LOCK_PIXEL_THRESHOLD;
     private paneHeightOverrides;
     private separatorDrag;
     private readonly priceAxisWidth;
@@ -189,6 +223,8 @@ declare class ChartEngine {
     /** Last traded price from the most recent tick that carried one ('ltp' source mode). */
     private liveLtp;
     private tickClosePriceSource;
+    /** Re-fetch history through `dataLoader` when the price source changes (`reloadOnPriceSourceChange`). */
+    private _reloadOnPriceSourceChange;
     /** Visibility of the LTP price marker (dashed line + axis tag). `undefined`
      *  follows `tickClosePriceSource` — marker shown only in 'ltp' mode. */
     private showLtpPrice;
@@ -228,6 +264,18 @@ declare class ChartEngine {
     private orderTimeDragHandler;
     /** Live (clamped) bar index of the badge during a horizontal time-drag; null when idle. */
     private tradeDragNewBarIndex;
+    /** The host's `features` block, forwarded to drawings that gate their output. */
+    private _features;
+    /** Floating P/L pill (`features.pnlPill`); null when the feature is off. */
+    private pnlPill;
+    /** "Positions shown" mode — the pill body was clicked; every position cluster stays fanned out. */
+    private pnlPillExpanded;
+    /** Re-entrancy guard for the one extra trade-layer pass that mode needs. */
+    private _pnlPillExpandPass;
+    /** The user's P/L pill preference (header switch / `setPnlPillVisible`). */
+    private pnlPillVisible;
+    /** Names of the `features` flags the host switched on, for gated UI. */
+    private _enabledGates;
     /** Whether horizontal order-line time-drag is enabled (`features.orderLineTimeDrag`). */
     private _orderTimeDragEnabled;
     /** Snap a horizontally-dragged order line to the nearest candle on release (`orderLineDragSnap`). */
@@ -238,6 +286,15 @@ declare class ChartEngine {
      * `timestamp` back via `setLevels` (auto-released on match). Survives PnL-only refreshes.
      */
     private _timeAnchorOverride;
+    /**
+     * Time anchors persisted in localStorage (`orderLineAnchorPersistence`), keyed by level
+     * label — the candle each badge was last dropped on. Restored at construction so a
+     * horizontally-dragged order line comes back where the user left it after a reload.
+     * Null when persistence is disabled or time-drag is off.
+     */
+    private _orderLineAnchorStore;
+    /** Where an un-dragged `timeDraggable` badge sits (`orderLineDefaultAnchor`). */
+    private _orderLineDefaultAnchor;
     private tradeDragNewPrice;
     /** Derived SL preview price during an entry drag in follow-brackets mode. */
     private tradeDragNewSLPrice;
@@ -253,6 +310,8 @@ declare class ChartEngine {
     private _isBracketNew;
     private pendingLevelDrags;
     private tfcEnabled;
+    /** Mouse crosshair (and the trade button that rides on it) — `ChartConfig.crosshairEnabled`. */
+    private crosshairEnabled;
     private tfcActive;
     private tradeDisplayFilter;
     private positionRenderStyle;
@@ -265,6 +324,8 @@ declare class ChartEngine {
     private noMoreData;
     private _loadGeneration;
     private maxCandles;
+    /** Duration → timeframe pairing (built-in defaults merged with the host's overrides). */
+    private _durationTimeframeMap;
     private minInitialBars;
     private maxLookbackMs;
     private prefetchThreshold;
@@ -278,11 +339,16 @@ declare class ChartEngine {
     private showCandleCountdown;
     private candleCountdownTimeframes;
     private showTradeLevelsAlways;
+    /** Widen the price axis when a level gains an SL/TP outside the visible range (`revealNewBrackets`). */
+    private _revealNewBrackets;
     private showPriceAxisCountdown;
     private readonly SHOW_SLTP_ALWAYS_LS_KEY;
     private readonly PRICE_AXIS_COUNTDOWN_LS_KEY;
     private loadingOverlayEl;
     private noDataOverlayEl;
+    /** Label pills inside the two overlays — painted by `applyOverlayLabelStyles()`. */
+    private loadingLabelEl;
+    private noDataLabelEl;
     private logoImage;
     constructor(config: ChartConfig);
     /**
@@ -358,11 +424,91 @@ declare class ChartEngine {
     private openIndicatorSettings;
     private updateIndicatorParams;
     on<K extends keyof ChartEventMap>(event: K, listener: (payload: ChartEventMap[K]) => void): () => void;
+    /**
+     * Turn the user's Chart Settings colour picks into a theme override.
+     *
+     * `includeSurface` decides whether the *surface* colours the settings dialog
+     * exposes — background, grid, axis text, axis border, crosshair — are part of
+     * the result. Those five belong to the canvas alone. The very same
+     * `background` / `axisText` / `axisBorder` tokens also drive every panel,
+     * dialog, toolbar and popover in the chart chrome, so merging a canvas pick
+     * into the chrome theme repainted the top/bottom/left bars with the chart
+     * background and put the user's "Axis Border" colour on the borders of the
+     * settings dialog itself. Series colours (candle / volume) are included
+     * either way — legends and indicator pills are meant to track them.
+     */
+    private canvasColorOverride;
+    /**
+     * Colour for the text laid directly over the canvas — the symbol name and
+     * the OHLC strip.
+     *
+     * Those labels sit on the chart background, so once the user picks their own
+     * background the fixed theme grey can land dark-on-dark and become
+     * unreadable (the reported symptom). Precedence: an explicit "Axis Text"
+     * pick wins; otherwise, if the user chose a custom background, use maximum
+     * contrast against it; otherwise return the stock theme colour untouched, so
+     * the default dark and light themes render exactly as before.
+     */
+    private overlayTextColor;
+    /** Theme used to paint the canvas — includes the user's surface picks. */
     private buildTheme;
+    /**
+     * Theme used to paint the chart *chrome* — toolbars, dialogs, popovers.
+     * Identical to the canvas theme except that the user's canvas surface picks
+     * are left out, so recolouring the chart background or axis no longer
+     * repaints the surrounding controls.
+     */
+    private buildChromeTheme;
+    /**
+     * Push the freshly built themes into every sub-component.
+     *
+     * Chrome components (bars, dialogs, popovers) get `chromeTheme`; components
+     * that are drawn over the canvas and must relate to it — the trade button,
+     * indicator pills, compare legend, sub-pane overlays — get the canvas
+     * `theme`. Called from every place that rebuilds the theme so the routing
+     * lives in exactly one spot.
+     */
+    /** Build the floating P/L pill and keep it in step with the levels, the TFC state and the theme. */
+    private initPnlPill;
+    /** Recount the positions on the chart for the pill. No-op without the feature. */
+    private refreshPnlPill;
+    /**
+     * Show or hide the on-chart P/L pill on the user's behalf — what the header's
+     * P/L switch does. Hidden wins over the position count; the switch and the
+     * pill stay in step either way, and `pnlPillToggle` tells the host so it can
+     * persist the choice. Requires `features.pnlPill`.
+     */
+    setPnlPillVisible(visible: boolean): this;
+    /**
+     * The pill body was clicked. On: switch TFC on if it was off and keep every
+     * position cluster fanned out (see the tail of `renderTradeLayer`), so the
+     * trader sees each position's own badge — P/L, side, quantity, edit, close.
+     * Off: collapse them again. Escape also leaves the mode.
+     */
+    private togglePnlPillExpanded;
+    /** The pill's ✕: hand every counted position to the host, which owns the broker call. */
+    private emitPnlPillCloseAll;
+    private applyThemeToComponents;
     setTheme(theme: 'dark' | 'light'): this;
     /** Current active timeframe — lightweight read for cross-pane sync. */
     getTimeframe(): Timeframe;
     /** Programmatically change the active timeframe and reload data. */
+    /**
+     * Change the duration programmatically — the same path the bottom-bar
+     * buttons take, so the paired timeframe, the x-axis and the data all move
+     * together.
+     *
+     * Pairs the timeframe from `durationTimeframeMap` unless `timeframe` is
+     * given explicitly, updates the bottom/top bars, emits `durationChange`,
+     * and refetches through `dataLoader`. The x-axis rescales from the new
+     * bars, so no reinitialisation is needed and nothing stale is left behind.
+     *
+     * @param d         Duration to select.
+     * @param timeframe Optional override for the paired timeframe.
+     */
+    setDuration(d: Duration, timeframe?: Timeframe): this;
+    /** Currently selected duration, or `null` when the user is on a free timeframe. */
+    getDuration(): Duration | null;
     setTimeframe(tf: Timeframe): this;
     /**
      * Programmatically place the crosshair at a given bar index + price, or clear it.
@@ -396,6 +542,18 @@ declare class ChartEngine {
     timeToBarIndex(timeMs: number): number | null;
     /** Update per-theme deep-partial color overrides and rebuild the active theme. */
     setThemeOverrides(overrides: ChartConfig['themeOverrides']): this;
+    /**
+     * Recolour the **canvas only** at runtime — the same per-theme picks the Chart
+     * Settings dialog offers (`canvasColors`): `background`, `grid`, `axisText`,
+     * `axisBorder`, `crosshair` repaint the plot and its axes and leave the chrome
+     * (header, bottom bar, drawing toolbar, dialogs, popovers) on the theme from
+     * `themeOverrides`; candle / volume picks apply everywhere so legends track them.
+     * Use this rather than `setThemeOverrides({ dark: { background } })` when a host
+     * wants a chart background that must not bleed into the toolbars. Replaces the
+     * current picks (partial per theme); `null` clears them. Persisted in `getState()`
+     * like the dialog's own picks, and `stateChange` fires.
+     */
+    setCanvasColors(colors: ChartConfig['canvasColors'] | null): this;
     /**
      * Changes the display timezone for all time-axis and crosshair labels.
      * Accepts any IANA string (e.g. `"America/New_York"`), `"UTC"`, or `"local"`.
@@ -408,6 +566,16 @@ declare class ChartEngine {
      * Only functional when `tfcEnabled` config option is `true` (default).
      */
     setTfcActive(enabled: boolean): this;
+    /**
+     * Show or hide the mouse crosshair at runtime — and with it the floating
+     * "place order at this price" button, which rides on the crosshair's
+     * horizontal line and should not appear once the line is gone.
+     * Off: the current crosshair is cleared (listeners get `crosshair: null`),
+     * mouse moves no longer place one, `setCrosshair()` mirrors are ignored, the
+     * mobile long-press crosshair does not arm, and the trade button hides.
+     * Trade levels, drawings and the TFC state are untouched.
+     */
+    setCrosshairEnabled(enabled: boolean): this;
     private clearDuration;
     setVolume(show: boolean): this;
     /**
@@ -495,6 +663,22 @@ declare class ChartEngine {
      * and emits a `stateChange` event so consumers can persist the cleared state.
      */
     resetChartSettings(): this;
+    /**
+     * Replaces the contract specs used by measurement and position tools. Call it
+     * alongside `setSymbol()` — specs belong to the instrument, and a stale
+     * pip size silently reports the wrong number rather than failing visibly.
+     */
+    setInstrument(instrument: InstrumentSpec | undefined): this;
+    /** Contract specs with fallbacks applied, as the drawing tools see them. */
+    getInstrument(): ResolvedInstrument;
+    /**
+     * Updates the account equity and per-trade risk the Long/Short position
+     * tools size against. Push it whenever equity moves — a sketch drawn against
+     * a stale balance quietly reports the wrong quantity.
+     */
+    setAccount(account: AccountSpec | undefined): this;
+    /** Account figures currently used to size the position tools. */
+    getAccount(): AccountSpec | undefined;
     setSymbol(symbol: string): this;
     /**
      * Update the list of symbols available in the ISIN picker modal.
@@ -513,6 +697,20 @@ declare class ChartEngine {
      * @param qty  Lot size to display and submit.
      */
     setDraftQty(qty: number): this;
+    /**
+     * Update the quantity (lots) shown on an EXISTING level's pill — the
+     * host-panel counterpart of the chart's own qty-pill editing, mirroring
+     * `updateLevelBracket` / `updateLevelMainPrice` for the quantity field.
+     *
+     * Exists because a modify panel that edits lots had no way to reflect the
+     * change on the chart: `setLevelQty` was private and only reachable for
+     * drafts, so the pill kept the server's old size until the broker echoed
+     * the modify (reported: panel showed 0.13 while the chart pill stayed
+     * 0.07). Goes through the same staging as chart-side qty edits, so the
+     * value survives `setLevels` refreshes and is included in `tradeLevelEdit`
+     * / reverted by `cancelCurrentEdit` exactly like a pill edit.
+     */
+    updateLevelQty(label: string, qty: number): this;
     private setLevelQty;
     private openDraftQtyFlyout;
     /**
@@ -544,6 +742,28 @@ declare class ChartEngine {
     updateDrawingStyle(id: string, patch: Partial<AnyDrawingStyle>): this;
     connectStream(adapter: IWebSocketAdapter): this;
     disconnectStream(): this;
+    /** Switch which price drives candle close/high/low at runtime
+     *  (`'bid'`, `'ask'` or `'ltp'`). Also syncs the header price-source
+     *  dropdown when `priceSourceSelector` is enabled, and — unless
+     *  `reloadOnPriceSourceChange` is `false` — re-runs `dataLoader` with the
+     *  new `params.priceSource` so the loaded history is rebuilt from that
+     *  price too. Programmatic calls do not emit `priceSourceChange` — that
+     *  event is reserved for user picks from the dropdown. */
+    setTickClosePriceSource(source: 'bid' | 'ask' | 'ltp'): this;
+    /**
+     * Applies a new candle price source. Shared by the header dropdown pick and
+     * `setTickClosePriceSource()`.
+     *
+     * Switching the field alone only changes how the NEXT live ticks extend the
+     * last candle; every bar already on screen was fetched with the previous
+     * source, so the chart kept showing e.g. bid history under an "LTP" label.
+     * When the source actually changes and a `dataLoader` is configured, the
+     * whole window is therefore re-fetched (`triggerLoad('priceSource')`) — the
+     * loader receives the source as `params.priceSource` to forward to its API.
+     * The visible time window is restored after the reload so the user does not
+     * lose their scroll/zoom position.
+     */
+    private _applyPriceSource;
     /** Show/hide the LTP (last traded price) marker — dashed line + axis tag.
      *  `true` always shows it when the feed supplies an LTP, `false` hides it
      *  even in `'ltp'` mode; pass `undefined` to restore the default
@@ -648,6 +868,13 @@ declare class ChartEngine {
      * Pass `null` to clear the text.
      * Use this to display the consumer-calculated estimated profit/loss next to the bracket.
      */
+    /**
+     * Switch the SL/TP bracket pills between the bracket price and the money
+     * that bracket is worth. `'amount'` needs each level to carry `lots` plus
+     * `contractSize` / `valuePerPoint`; any level missing them keeps showing its
+     * price, so a partial rollout degrades level by level rather than all at once.
+     */
+    setBracketLabelMode(mode: 'price' | 'amount' | 'priceAndAmount', currencySymbol?: string): this;
     setDraftBracketPnl(type: 'sl' | 'tp', pnlText: string | null): this;
     /**
      * Update the stop-loss or take-profit price on the current draft order.
@@ -754,17 +981,34 @@ declare class ChartEngine {
     private toggleDrawingTools;
     private _applyCssFullscreen;
     private toggleFullscreen;
+    /** The style the user picked, or the auto rule (dot above the threshold) — what persists and what the settings dialog shows. */
+    private baseRenderStyle;
     private recomputeRenderStyle;
     private renderTradeLayer;
     /**
      * Resolves the horizontal badge center X (canvas px) for a level during render, or `null`
      * to keep the legacy chart-centered placement. Priority:
      *   1. the live drag bar index, for the level currently being time-dragged;
-     *   2. a staged drop override (set on the last drag release);
-     *   3. the level's own `timestamp`.
+     *   2. the resolved time anchor — see `_resolvedTimeAnchor`.
      * Returns `null` when time-drag is disabled or the level has no time anchor.
      */
     private _orderLineAnchorX;
+    /**
+     * The unix-ms time anchor a level's badge should sit at (ignoring any live drag), or
+     * `undefined` for the legacy chart-centered placement. Priority:
+     *   1. a drop override staged this session (set on the last drag release);
+     *   2. the anchor persisted in localStorage from an earlier session
+     *      (`orderLineAnchorPersistence`);
+     *   3. the level's own `timestamp` — unless `orderLineDefaultAnchor: 'center'` and the
+     *      level is `timeDraggable`, in which case an un-dragged badge stays centered.
+     */
+    private _resolvedTimeAnchor;
+    /**
+     * Whether a level's own `timestamp` positions its badge. False only for `timeDraggable`
+     * levels under `orderLineDefaultAnchor: 'center'`, whose un-dragged badge is centered
+     * regardless of `timestamp` (a dragged one is positioned by its override / persisted anchor).
+     */
+    private _honorsLevelTimestamp;
     /** Returns the effective entry price for a level, preferring any staged main drag. */
     private _effectiveEntryPrice;
     /**
@@ -886,11 +1130,27 @@ declare class ChartEngine {
      * label, so repeat opens (e.g. pencil click followed by drag) don't spam the event.
      */
     private _openTradeLevelEditForm;
+    /**
+     * Whether grabbing `dragHit` must wait for the drag direction before choosing an axis:
+     * the badge of a `timeDraggable` level that can ALSO be price-dragged (pending orders,
+     * entry-editable positions). Fixed-price positions keep the immediate horizontal drag.
+     */
+    private _needsDragAxisLock;
+    /**
+     * Upgrades an armed `_pendingTradeDrag` to a real drag once the pointer has moved far
+     * enough from where it went down. A dual-axis badge (`axisLock`) commits to the dominant
+     * direction: sideways → horizontal time-drag (price locked), up/down → the default
+     * vertical price-drag, started from the same hit with its `timeDrag` flag cleared.
+     * Returns true when a drag started, false while still waiting for movement.
+     */
+    private _upgradePendingTradeDrag;
     /**
      * Shared helper: initiate a trade level drag from a hit area.
      * Starts a HORIZONTAL (time-axis) drag when the hit area is the badge of a `timeDraggable`
      * level and `features.orderLineTimeDrag` is on; otherwise starts the default vertical
      * price drag. `hitX` is required for the horizontal path (defaults to the badge anchor).
+     * Dual-axis badges never reach this directly — `_upgradePendingTradeDrag` resolves the
+     * axis first and clears `timeDrag` on the hit when the drag is vertical.
      */
     private _startTradeDragFromHit;
     /**
@@ -946,10 +1206,31 @@ declare class ChartEngine {
      * Used by off-viewport level indicator clicks.
      */
     private scrollToCenterPrice;
+    /**
+     * Bring `prices` into the visible price range by WIDENING (compressing) the axis —
+     * never by panning the current view away — so a freshly placed SL/TP and the candles
+     * the trader was looking at stay on screen together (`revealNewBrackets`). No-op while
+     * every price is already inside the range, in compare (percent) mode, or without data.
+     * Expressed as the same scale + pan knobs the axis drag uses, on top of the range the
+     * trader currently sees, and animated like the off-viewport pill's scroll.
+     */
+    private _revealPrices;
+    /**
+     * The price the header's Alert entry hands to `onAddAlert`: the live ask (what a
+     * host's alert form seeds with), else the live bid, else the last bar's close.
+     */
+    private _currentMarketPrice;
     private resetPriceAxis;
     private resetTimeAxis;
     /** Reset both price and time axes to their default state. */
     resetView(): void;
+    /**
+     * Paints the "Loading…" / "No data available" pills from the theme. They used
+     * to be a hardcoded dark scrim with pale grey text, which read as a black box
+     * on the light theme; they now track `tooltip` like every other floating
+     * label and are repainted on `setTheme`.
+     */
+    private applyOverlayLabelStyles;
     private applyResetViewBtnStyles;
     private applyScrollToEndBtnStyles;
 }
@@ -961,6 +1242,15 @@ declare class AdvancedToolbar {
     private onLayoutClick?;
     private onOneClickTradeToggle?;
     private onScreenshotClick?;
+    private onPriceSourceChange;
+    private onCrosshairToggle;
+    private onPnlPillToggle;
+    /**
+     * ⋯ menu "Alert" entry (`headerOverflowMenu`). Set when the host configured
+     * `onAddAlert`; the engine hands the host the current market price so the same
+     * Create Alert form the trade action bar's chip opens comes up. Null leaves it out.
+     */
+    private onAlertClick;
     readonly el: HTMLDivElement;
     private theme;
     private currentSeries;
@@ -972,18 +1262,51 @@ declare class AdvancedToolbar {
     private layoutBtn;
     private layoutIconEl;
     private snapshotBtn;
+    private crosshairBtn;
+    private crosshairEnabled;
+    private pnlPillBtn;
+    private pnlPillVisible;
+    private pnlPillSymbol;
+    /** `headerOverflowMenu`: Indicators / Compare / Snapshot / Settings live in a ⋯ menu; Layout is icon-only. */
+    private overflowMenu;
+    private moreBtn;
+    private showSnapshotItem;
+    private onSettingsClickCb;
+    private onDrawingToolsToggleCb;
+    private drawingActive;
+    private tfMoreBtn;
+    /** Timeframes hidden behind the ⌄ in the reference header. */
+    private tfMore;
+    private onTimeframeChangeCb;
     private tfBtns;
     private indBtn;
     private indicatorOptions;
     private activeIndicators;
     private volHasData;
+    private priceSourceBtn;
+    private priceSourceOptions;
+    private currentPriceSource;
     private flyout;
     private openFlyout;
     private docClickHandler;
-    constructor(onSeriesChange: (s: SeriesType) => void, onTimeframeChange: (tf: Timeframe) => void, onAddIndicator: (name: string) => void, onSettingsClick: () => void, onFullscreenToggle: () => void, onDrawingToolsToggle: (() => void) | null, showDrawingBtn: boolean, _showSettingsBtn: boolean, showFullscreenBtn: boolean, initialSeries: SeriesType, initialTf: Timeframe, theme: ChartTheme, onCompareClick?: (() => void) | undefined, onLayoutClick?: (() => void) | undefined, onOneClickTradeToggle?: ((active: boolean) => void) | undefined, onScreenshotClick?: (() => void) | undefined, showLayoutBtn?: boolean, showSnapshotBtn?: boolean);
+    constructor(onSeriesChange: (s: SeriesType) => void, onTimeframeChange: (tf: Timeframe) => void, onAddIndicator: (name: string) => void, onSettingsClick: () => void, onFullscreenToggle: () => void, onDrawingToolsToggle: (() => void) | null, showDrawingBtn: boolean, _showSettingsBtn: boolean, showFullscreenBtn: boolean, initialSeries: SeriesType, initialTf: Timeframe, theme: ChartTheme, onCompareClick?: (() => void) | undefined, onLayoutClick?: (() => void) | undefined, onOneClickTradeToggle?: ((active: boolean) => void) | undefined, onScreenshotClick?: (() => void) | undefined, showLayoutBtn?: boolean, showSnapshotBtn?: boolean, priceSourceOptions?: Array<'bid' | 'ask' | 'ltp'> | null, initialPriceSource?: 'bid' | 'ask' | 'ltp', onPriceSourceChange?: ((source: 'bid' | 'ask' | 'ltp') => void) | null, showCrosshairBtn?: boolean, initialCrosshairEnabled?: boolean, onCrosshairToggle?: ((enabled: boolean) => void) | null, showPnlPillBtn?: boolean, initialPnlPillVisible?: boolean, onPnlPillToggle?: ((visible: boolean) => void) | null, overflowMenu?: boolean, 
+    /** `ChartConfig.timeframes` — the header's timeframe list; null keeps the classic set. */
+    timeframes?: Timeframe[] | null, 
+    /**
+     * ⋯ menu "Alert" entry (`headerOverflowMenu`). Set when the host configured
+     * `onAddAlert`; the engine hands the host the current market price so the same
+     * Create Alert form the trade action bar's chip opens comes up. Null leaves it out.
+     */
+    onAlertClick?: (() => void) | null);
     setTimeframe(tf: Timeframe): void;
     setFullscreen(active: boolean): void;
     setDrawingsBtnActive(active: boolean): void;
+    /** Icon size on the right cluster: 12px in the reference header, 14px otherwise. */
+    private iconSize;
+    /** Reflect the crosshair on/off state in the header switch. No-op when the button is not rendered. */
+    setCrosshairActive(enabled: boolean): void;
+    /** Reflect the P/L pill's shown/hidden state (and the symbol named in the tooltip) in the header switch. */
+    setPnlPillActive(visible: boolean, symbol?: string): void;
     setIndicatorOptions(options: {
         value: string;
         label: string;
@@ -993,6 +1316,10 @@ declare class AdvancedToolbar {
     setVolumeControl(_show: boolean, hasVol: boolean): void;
     setTheme(theme: ChartTheme): void;
     setSeries(series: SeriesType): void;
+    /** Sync the price-source dropdown to `source` (e.g. after a programmatic
+     *  `setTickClosePriceSource()` from the host's trade settings). No-op when
+     *  the dropdown isn't enabled. Does not fire `onPriceSourceChange`. */
+    setPriceSource(source: 'bid' | 'ask' | 'ltp'): void;
     /** Update the Layout button's preset icon and mark it active/inactive. No-op if the Layout button is disabled. */
     setLayoutPresetIcon(svgHtml: string, active?: boolean): void;
     /** Mark the Layout button as active (selected) or inactive without changing the icon. */
@@ -1022,9 +1349,15 @@ declare class AdvancedToolbar {
     private makeGroup;
     private makeIconBtn;
     private applyIconBtnStyles;
+    private applyCrosshairBtnStyles;
+    private applyPnlPillBtnStyles;
+    private applyOverflowIconBtnStyles;
+    /** Layout is a labelled text button by default and an icon-only square in overflow mode. */
+    private styleLayoutBtn;
     private makeTextBtn;
     private applyTextBtnStyles;
     private applyTfPillStyles;
+    private applyTfMoreStyles;
     private addHover;
     private makeCategoryHeader;
     private makeRow;
@@ -1043,12 +1376,16 @@ declare class AdvancedToolbar {
 declare class CompactToolbar {
     private onSeriesChange;
     private onAddIndicator;
+    private onCrosshairToggle;
     readonly el: HTMLDivElement;
     private theme;
     private currentSeries;
     private currentTf;
     private seriesBtn;
     private indBtn;
+    /** Crosshair on/off switch (`enableCrossHairHeader`) — null when not requested. */
+    private crosshairBtn;
+    private crosshairEnabled;
     private tfBtns;
     private indicatorOptions;
     private activeIndicators;
@@ -1056,7 +1393,7 @@ declare class CompactToolbar {
     private flyout;
     private openFlyout;
     private docClickHandler;
-    constructor(onSeriesChange: (s: SeriesType) => void, onTimeframeChange: (tf: Timeframe) => void, onAddIndicator: (name: string) => void, initialSeries: SeriesType, initialTf: Timeframe, theme: ChartTheme);
+    constructor(onSeriesChange: (s: SeriesType) => void, onTimeframeChange: (tf: Timeframe) => void, onAddIndicator: (name: string) => void, initialSeries: SeriesType, initialTf: Timeframe, theme: ChartTheme, showCrosshairBtn?: boolean, initialCrosshairEnabled?: boolean, onCrosshairToggle?: ((enabled: boolean) => void) | null);
     setTimeframe(tf: Timeframe): void;
     setSeries(series: SeriesType): void;
     setIndicatorOptions(options: {
@@ -1066,6 +1403,8 @@ declare class CompactToolbar {
     }[]): void;
     setIndicatorOptionActive(name: string, active: boolean, _count?: number): void;
     setVolumeControl(_show: boolean, hasVol: boolean): void;
+    /** Reflect the crosshair on/off state in the header switch. No-op when the button is not rendered. */
+    setCrosshairActive(enabled: boolean): void;
     setTheme(theme: ChartTheme): void;
     closeDropdown(): void;
     get hasOpenDropdown(): boolean;
@@ -1092,6 +1431,7 @@ declare class CompactToolbar {
     private applyBarStyles;
     private applyFlyoutStyles;
     private makeIconBtn;
+    private applyCrosshairBtnStyles;
     private applyIconBtnStyles;
     private applyTfPillStyles;
     private addHover;
@@ -1283,6 +1623,80 @@ declare class ChartGroup {
  */
 declare function aggregateCandles(bars: OHLCVBar[], targetIntervalMs: number): OHLCVBar[];
 
+/**
+ * What the on-chart P/L pill shows for the levels currently on the chart.
+ * Pure — derived from the `setLevels` payload only, so it stays in step with
+ * the lines actually drawn. The chart never computes money itself: `pnl` is
+ * the sum of the numeric `pnl` values the host attached to each position.
+ */
+interface PnlPillSummary {
+    /** Open positions among the levels. Entry orders and an unconfirmed draft are not counted. */
+    count: number;
+    /** Sum of the counted positions' numeric `pnl`. `0` when none carried one — check `hasPnl`. */
+    pnl: number;
+    /** True when at least one counted position carried a finite numeric `pnl`. */
+    hasPnl: boolean;
+    /** The counted positions, in level order — the set a close-all acts on. */
+    positions: PositionLevel[];
+    /** Counted positions per side (a position without `side` counts for neither). */
+    buys: number;
+    sells: number;
+    /** Both directions open at once — one SL / TP price cannot be valid for both, so bulk levels are off. */
+    mixed: boolean;
+}
+/**
+ * Count the open positions in `levels` and total their `pnl`.
+ *
+ * Pending orders never count. Neither do `entryPriceEditable` positions — those
+ * are entry (EL/ES) orders the host renders position-style — nor the level whose
+ * label is `draftLabel`, the client-side draft that has not reached the broker.
+ * A position without a numeric `pnl` still counts but adds nothing to the total.
+ */
+declare function summarisePositionLevels(levels: readonly AnyLevel[], draftLabel?: string | null): PnlPillSummary;
+/**
+ * Default money text for the pill: an explicit sign, two decimals and the
+ * currency code after a space — `+72.65 USD`, `-8.10 USD`. Zero and amounts
+ * that round to zero read `+0.00` so the pill never shows `-0.00`. Without a
+ * currency the code and its space are left off.
+ */
+declare function formatPnlPillValue(pnl: number, currency?: string): string;
+
+/** Which bracket the SL / TP / TSL chips ask the host to set on every open position. */
+type BulkLevelKind = 'sl' | 'tp' | 'tsl';
+/** What the Pending sub-menu needs to know about the clicked price. */
+interface TradeActionBarContext {
+    pricePrecision: number;
+    /** Order type a buy at this price would be — `limit` below the market, `stop` above. */
+    buyOrderType: 'limit' | 'stop';
+    sellOrderType: 'limit' | 'stop';
+    /** Symbol named in the chips' "unavailable" tooltips. */
+    symbol?: string;
+    /** Open positions on the symbol; `0` greys the SL / TP / TSL chips out. Omit to keep them available. */
+    positionCount?: number;
+    /** Buys and sells both open — one price cannot suit both directions, so the chips grey out. */
+    mixedSides?: boolean;
+}
+
+/** Per-render sizes of the main-level info box; everything scales together with `tradeLevelBadgeScale`. */
+interface BadgeMetrics {
+    /** Effective scale, clamped to [0.5, 1]. */
+    k: number;
+    padX: number;
+    padY: number;
+    rowH: number;
+    pillPadX: number;
+    pillGap: number;
+    pnlGap: number;
+    fontMain: string;
+    fontPnl: string;
+    gripW: number;
+    gripDotR: number;
+    /** Plot-edge margin for a left-homed tag (`tradeLevelBadgeAnchor: 'left'`). */
+    leftMargin: number;
+}
+/** Sizes for a badge scale — `1` reproduces the long-standing constants exactly. */
+declare function badgeMetrics(scale: number): BadgeMetrics;
+type BadgeAnchor = 'auto' | 'left';
 /** Drag handle hit area for the main level line (non-bracket). */
 interface TradeLevelDragArea {
     label: string;
@@ -1301,10 +1715,12 @@ interface TradeLevelDragArea {
      */
     isBox?: boolean;
     /**
-     * True when grabbing this area should start a HORIZONTAL (time-axis) drag instead of the
+     * True when grabbing this area can start a HORIZONTAL (time-axis) drag instead of the
      * default vertical price drag. Set only on the badge/box area of a `timeDraggable` level
-     * when `features.orderLineTimeDrag` is enabled. The full-width line area stays vertical,
-     * so price-drag remains reachable by grabbing the line.
+     * when `features.orderLineTimeDrag` is enabled. For a level that is also price-draggable
+     * (pending orders, entry-editable positions) ChartEngine waits for the first movement and
+     * picks the axis from its direction; for fixed-price positions the grab is horizontal at
+     * once. The full-width line area always stays vertical.
      */
     timeDrag?: boolean;
 }
@@ -1334,12 +1750,81 @@ interface TradeLevelBracketDragArea {
 }
 type AnyDragArea = TradeLevelDragArea | TradeLevelBracketDragArea;
 
+/**
+ * Money maths for trade levels.
+ *
+ * The chart has no access to a broker's contract specs or account currency, so
+ * everything needed to turn a price distance into money is supplied per level:
+ * `lots`, `contractSize`, and `valuePerPoint` (which folds in any quote →
+ * account currency conversion). Hosts that would rather compute the figure
+ * themselves can keep passing a pre-formatted `pnlText` instead.
+ */
+/** Inputs for a single bracket's money value. */
+interface BracketPnlInput {
+    /** Level entry price. */
+    entryPrice: number;
+    /** SL or TP price. */
+    bracketPrice: number;
+    /** Position direction — a sell profits when price falls. */
+    side: 'buy' | 'sell';
+    /** Position size in lots. */
+    lots: number;
+    /** Units per lot (e.g. 100 for XAUUSD, 100_000 for most FX pairs). Default 1. */
+    contractSize?: number;
+    /** Account-currency value of one price unit per contract unit. Default 1. */
+    valuePerPoint?: number;
+}
+/**
+ * Money the position gains (positive) or loses (negative) if price reaches the
+ * bracket. Returns `null` when an input is missing or non-finite, so callers can
+ * fall back to showing the price rather than rendering `NaN`.
+ */
+declare function bracketPnl(input: BracketPnlInput): number | null;
+/**
+ * Formats money with the currency symbol in front of the number and the sign in
+ * front of the symbol — `-$290.80`, `+$18.92` — matching how hosts format the
+ * `pnlText` already shown on the main info box.
+ *
+ * A value that rounds to zero is rendered without a sign (`$0.00`) rather than
+ * as a misleading `+$0.00`/`-$0.00`.
+ */
+declare function formatMoney(amount: number, symbol?: string, decimals?: number): string;
+/** Inputs for sizing a position from an account's risk budget. */
+interface PositionSizeInput {
+    /** Intended entry price. */
+    entryPrice: number;
+    /** Protective stop price. */
+    stopPrice: number;
+    /** Account equity in the account currency. */
+    accountSize: number;
+    /** Percent of the account risked if the stop is hit. */
+    riskPercent: number;
+    /** Account-currency value of one price unit per contract unit. Default 1. */
+    valuePerPoint?: number;
+}
+/**
+ * Position size in contract units such that hitting the stop costs exactly
+ * `riskPercent` of the account.
+ *
+ * Returns `null` when an input is missing, non-finite, or would divide by zero
+ * (entry and stop at the same price), so callers can omit the quantity rather
+ * than rendering `Infinity`.
+ */
+declare function positionQty(input: PositionSizeInput): number | null;
+/**
+ * Reward divided by risk — how many times the stop distance the target sits
+ * away. `null` when the stop is at the entry, which has no defined ratio.
+ */
+declare function riskRewardRatio(entryPrice: number, targetPrice: number, stopPrice: number): number | null;
+
 declare class DrawingManager {
     private drawings;
     private activeDrawing;
     private selectedDrawing;
     private activeTool;
     private state;
+    /** `features.enableForecasting` — see `canDrawFreehand`. */
+    private freehandEnabled;
     private history;
     private redoStack;
     private onCompleteCallback;
@@ -1366,8 +1851,16 @@ declare class DrawingManager {
     private dragStartPoints;
     private resizeDrawing;
     private resizePointIndex;
+    /** Handle being dragged — carries the axis split for compound corners. */
+    private resizeHandle;
     /** Called by ChartEngine to be notified when a drawing is finished. */
     setOnComplete(cb: () => void): void;
+    /**
+     * Enables press-drag-release drawing for Brush and Highlighter
+     * (`ChartConfig.features.enableForecasting`). When off they behave as
+     * click-per-point tools ended by a double-click, as they always have.
+     */
+    setFreehandEnabled(enabled: boolean): void;
     /** Toggle the text-editing guard so Delete/Backspace are not intercepted. */
     setEditingText(editing: boolean): void;
     setActiveTool(tool: DrawingToolType | null): void;
@@ -1375,9 +1868,22 @@ declare class DrawingManager {
     /** Returns true if the drawing system consumed the event */
     onMouseDown(point: DrawingPoint): boolean;
     onMouseMove(point: DrawingPoint): void;
+    /** True while a freehand stroke is in progress (pointer still down). */
+    isFreehandStroke(): boolean;
     /**
-     * Finalizes an open-ended drawing (Polyline, Path, Brush, Highlighter)
-     * on double-click. Removes the dangling preview point and marks complete.
+     * Ends a freehand stroke on pointer-up: thins the samples down to the ones
+     * that carry the shape, then completes the drawing. Returns true when a
+     * stroke was ended, so the caller knows the event was consumed.
+     *
+     * Thinning happens here rather than during the drag because the tolerance is
+     * a screen distance — it can only be applied against the scale the stroke was
+     * actually drawn at, and re-measuring every sample on every move would cost
+     * more than it saves.
+     */
+    finishFreehand(scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
+    /**
+     * Finalizes an open-ended drawing (Polyline, Path) on double-click.
+     * Removes the dangling preview point and marks complete.
      */
     finalizePlacing(): void;
     startDrag(drawing: IDrawing, mouse: DrawingPoint): void;
@@ -1385,13 +1891,22 @@ declare class DrawingManager {
     isDraggingDrawing(): boolean;
     /** True when a multi-point drawing has been started and is awaiting further touch/click input. */
     isPlacing(): boolean;
-    startResize(drawing: IDrawing, pointIndex: number): void;
+    startResize(drawing: IDrawing, pointIndex: number, handle?: DrawingHandle): void;
     endResize(): void;
     isResizingDrawing(): boolean;
     /** Shift all drawings' barIndex values by `delta` (called when bars are prepended to DataStore). */
     shiftBarIndices(delta: number): void;
     /** Returns the handle under (x,y) across all complete drawings, or null */
-    getHandleAtPoint(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): {
+    getHandleAtPoint(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, 
+    /**
+     * Extra reach in px, for touch. Drawings hit-test their handles against a
+     * mouse-sized radius (~8px); a fingertip covers far more than that, so a
+     * grab that looks on-target misses and the gesture falls through to
+     * pan/pinch — the chart zooms instead of resizing the shape. Rather than
+     * widen the tolerance in all 69 drawing classes, probe outward in rings
+     * from the touch point and take the nearest handle found.
+     */
+    searchRadius?: number): {
         drawing: IDrawing;
         handle: DrawingHandle;
     } | null;
@@ -1415,7 +1930,7 @@ declare class DrawingManager {
     showAll(): void;
     lockAll(): void;
     unlockAll(): void;
-    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, pricePrecision?: number, theme?: ChartTheme): void;
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, pricePrecision?: number, theme?: ChartTheme, context?: DrawingRenderContext): void;
     getDrawings(): IDrawing[];
     /** Returns a JSON-serializable snapshot of all drawings (data fields only, no methods). */
     getDrawingsSnapshot(): SerializedDrawing[];
@@ -1428,6 +1943,72 @@ declare class DrawingManager {
     private createDrawing;
 }
 
+/**
+ * Risk/reward sketch for a trade that hasn't been placed.
+ *
+ * Three prices — entry, target, stop — drawn as a green profit zone and a red
+ * risk zone over a span of bars, with the money and quantity the account's risk
+ * budget implies. Requested on AWT-2642 as the headline gap against TradingView.
+ *
+ * Deliberately **not** Trade-From-Chart: `setLevels` draws real broker orders and
+ * committing one sends it. This is a drawing. Nothing here reaches the broker.
+ *
+ * Points, in order:
+ *  - `0` entry price, and the left edge of the span
+ *  - `1` target price, and the right edge of the span
+ *  - `2` stop price (its `barIndex` is unused — the span comes from 0 and 1)
+ *
+ * The user places 0 and 1; [`onPlaced`](../core/types.ts) materialises 2 at
+ * [`DEFAULT_RR`], so the common case is two clicks rather than three.
+ */
+declare abstract class PositionTool implements IDrawing {
+    readonly id: string;
+    abstract readonly type: 'longPosition' | 'shortPosition';
+    /** Long profits above entry; short profits below. Flips zones and P&L sign. */
+    protected abstract readonly isLong: boolean;
+    readonly requiredPoints = 2;
+    points: DrawingPoint[];
+    complete: boolean;
+    style?: AnyDrawingStyle;
+    /**
+     * Per-instance overrides for the account figures. Seeded from the chart's
+     * `account` config on first render; set them to let one sketch size against
+     * different assumptions than the rest of the chart.
+     */
+    accountSize?: number;
+    riskPercent?: number;
+    constructor(first: DrawingPoint, idPrefix: string);
+    /**
+     * Places the stop once entry and target are known.
+     *
+     * Two clicks give a direction and a reward; the risk that pairs with them is
+     * a convention, not information the user supplied — so the tool assumes
+     * [`DEFAULT_RR`] and leaves the handle there to be dragged.
+     */
+    onPlaced(): void;
+    /** Entry / target / stop, with the stop derived if placement hasn't finished. */
+    protected prices(): {
+        entry: number;
+        target: number;
+        stop: number;
+    };
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme, context?: DrawingRenderContext): void;
+    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
+    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
+}
+/** Profit above entry, risk below. */
+declare class LongPosition extends PositionTool {
+    readonly type: "longPosition";
+    protected readonly isLong = true;
+    constructor(first: DrawingPoint);
+}
+/** Profit below entry, risk above. */
+declare class ShortPosition extends PositionTool {
+    readonly type: "shortPosition";
+    protected readonly isLong = false;
+    constructor(first: DrawingPoint);
+}
+
 declare class HorizontalLine implements IDrawing {
     readonly id: string;
     readonly type: "horizontalLine";
@@ -1807,14 +2388,54 @@ declare class DatePriceRange implements IDrawing {
     getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
 }
 
+/**
+ * Measures a move: how far in price, percent and pips, over how many bars and
+ * how much wall-clock time, on what volume.
+ *
+ * Replaces a version that drew a bare line labelled with a bar count and a raw
+ * price difference. The client's feedback (AWT-2642) was that the tool is
+ * unusable next to TradingView's, whose readout answers all of those at once —
+ * and a forex desk asking for a "pip counter" is asking for the pips line
+ * specifically, which the old tool could not produce at all.
+ */
 declare class Ruler implements IDrawing {
     readonly id: string;
     readonly type: "ruler";
     points: DrawingPoint[];
     complete: boolean;
     style?: AnyDrawingStyle;
+    /**
+     * Last-seen value of `features.enableForecasting`, cached during `render`.
+     *
+     * `hitTest` and `getHandle` need it too — the measured box grabs on its four
+     * edges, the classic line grabs along itself — but their signatures carry no
+     * render context. A drawing is always rendered before it can be clicked, so
+     * the cache is populated by then; it defaults to the classic behaviour.
+     */
+    private detailed;
     constructor(first: DrawingPoint);
-    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
+    /**
+     * Volume traded across the measured span, or `null` when the host didn't
+     * pass bars (the readout then drops the line rather than showing a zero that
+     * would read as "no volume traded").
+     */
+    private rangeVolume;
+    /**
+     * The readout, one entry per line.
+     *
+     * Two shapes, chosen by `features.enableForecasting`: the historical bar-count
+     * and raw-delta pair, or the full measurement with percent, pips, duration
+     * and volume. Gated because it changes what an existing tool reports.
+     */
+    private buildLabel;
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme, context?: DrawingRenderContext): void;
+    /**
+     * The ruler exactly as it was before AWT-2642: a styled line with two
+     * perpendicular end ticks, a bar count and a raw price delta at the midpoint,
+     * and endpoint dots. Used whenever `features.enableForecasting` is off, so an
+     * un-flagged host sees no change at all.
+     */
+    private renderClassic;
     hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
     getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
 }
@@ -2230,12 +2851,32 @@ declare class ElliottWxy implements IDrawing {
 declare class Brush implements IDrawing {
     readonly id: string;
     readonly type: "brush";
+    /**
+     * Drawn in one press-drag-release gesture: points are sampled continuously
+     * along the pointer path rather than placed one click at a time. See
+     * DrawingManager's freehand branch.
+     */
+    readonly freehand = true;
+    /**
+     * Also declared open-ended so the tool still works when
+     * `features.enableForecasting` is off: DrawingManager checks freehand first and
+     * falls through to this click-per-point path when the flag is not set.
+     */
     readonly openEnded = true;
     points: DrawingPoint[];
     complete: boolean;
     style?: AnyDrawingStyle;
+    /**
+     * Last-seen value of `features.enableForecasting`, cached during `render`.
+     *
+     * `hitTest` takes no render context but must agree with what was drawn: a
+     * freehand stroke has no dangling preview point, a click-per-point one does.
+     * A drawing is always rendered before it can be clicked, so the cache is
+     * populated by then; it defaults to the classic behaviour.
+     */
+    private freehandMode;
     constructor(first: DrawingPoint);
-    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme, context?: DrawingRenderContext): void;
     hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
     getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
 }
@@ -2243,12 +2884,32 @@ declare class Brush implements IDrawing {
 declare class Highlighter implements IDrawing {
     readonly id: string;
     readonly type: "highlighter";
+    /**
+     * Drawn in one press-drag-release gesture: points are sampled continuously
+     * along the pointer path rather than placed one click at a time. See
+     * DrawingManager's freehand branch.
+     */
+    readonly freehand = true;
+    /**
+     * Also declared open-ended so the tool still works when
+     * `features.enableForecasting` is off: DrawingManager checks freehand first and
+     * falls through to this click-per-point path when the flag is not set.
+     */
     readonly openEnded = true;
     points: DrawingPoint[];
     complete: boolean;
     style?: AnyDrawingStyle;
+    /**
+     * Last-seen value of `features.enableForecasting`, cached during `render`.
+     *
+     * `hitTest` takes no render context but must agree with what was drawn: a
+     * freehand stroke has no dangling preview point, a click-per-point one does.
+     * A drawing is always rendered before it can be clicked, so the cache is
+     * populated by then; it defaults to the classic behaviour.
+     */
+    private freehandMode;
     constructor(first: DrawingPoint);
-    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme, context?: DrawingRenderContext): void;
     hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
     getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
 }
@@ -2359,4 +3020,4 @@ declare class WebSocketAdapter implements IWebSocketAdapter {
     private emitStatus;
 }
 
-export { AbcdPattern, AdvancedToolbar, AnchoredNote, AnchoredVP, type AnyDragArea, AnyLevel, Arc, ArrowDown, ArrowMarker, ArrowUp, BatPattern, Brush, ButterflyPattern, Callout, ChartConfig, ChartEngine, ChartEventMap, ChartGroup, ChartState, ChartTheme, Circle, CompactToolbar, CrabPattern, CrossLine, CyclicLines, CypherPattern, DatePriceRange, DateRange, DisjointChannel, DrawingHandle, DrawingManager, DrawingPoint, DrawingToolType, ElliottCombination, ElliottCorrective, ElliottImpulse, ElliottTriangle, ElliottWxy, Ellipse, FibChannel, FibCircles, FibExtension, FibFan, FibProjection, FibRetracement, FibSpiral, FibTimezone, FixedRangeVP, Flag, FlatChannel, GannBox, GannFan, GannSquare, GartleyPattern, GhostFeed, HeadShoulders, Highlighter, HorizontalLine, IDrawing, IIndicator, IWebSocketAdapter, IndicatorParams, InsidePitchfork, LayoutPopover, LayoutSyncState, ModifiedSchiff, OHLCVBar, ParallelChannel, Path, Pitchfork, Polyline, PriceLabel, PriceNote, PriceProjection, PriceRange, PriceRange$1 as PriceRangeType, Projection, Rectangle, RegressionTrend, RotatedRectangle, Ruler, SchiffPitchfork, SerializedDrawing, SeriesType, SharkPattern, SineLine, type SnapshotAction, SnapshotPopover, StreamStatus, Text, ThreeDrives, Tick, TimeCycles, Timeframe, type TradeLevelBracketDragArea, type TradeLevelDragArea, TradeLevelType, TrendAngle, TrendLine, Triangle, TrianglePattern, VerticalLine, Viewport, VolumeProfile, WebSocketAdapter, aggregateCandles };
+export { AbcdPattern, AccountSpec, AdvancedToolbar, AnchoredNote, AnchoredVP, type AnyDragArea, AnyLevel, Arc, ArrowDown, ArrowMarker, ArrowUp, type BadgeAnchor, type BadgeMetrics, BatPattern, type BracketPnlInput, Brush, type BulkLevelKind, ButterflyPattern, Callout, ChartConfig, ChartEngine, ChartEventMap, ChartGroup, ChartState, ChartTheme, Circle, CompactToolbar, CrabPattern, CrossLine, CyclicLines, CypherPattern, DatePriceRange, DateRange, DisjointChannel, DrawingHandle, DrawingManager, DrawingPoint, DrawingRenderContext, DrawingToolType, Duration, ElliottCombination, ElliottCorrective, ElliottImpulse, ElliottTriangle, ElliottWxy, Ellipse, FibChannel, FibCircles, FibExtension, FibFan, FibProjection, FibRetracement, FibSpiral, FibTimezone, FixedRangeVP, Flag, FlatChannel, GannBox, GannFan, GannSquare, GartleyPattern, GhostFeed, HeadShoulders, Highlighter, HorizontalLine, IDrawing, IIndicator, IWebSocketAdapter, IndicatorParams, InsidePitchfork, InstrumentSpec, LayoutPopover, LayoutSyncState, LongPosition, ModifiedSchiff, OHLCVBar, ParallelChannel, Path, Pitchfork, type PnlPillSummary, Polyline, PositionLevel, type PositionSizeInput, PositionTool, PriceLabel, PriceNote, PriceProjection, PriceRange, PriceRange$1 as PriceRangeType, Projection, Rectangle, RegressionTrend, ResolvedInstrument, RotatedRectangle, Ruler, SchiffPitchfork, SerializedDrawing, SeriesType, SharkPattern, ShortPosition, SineLine, type SnapshotAction, SnapshotPopover, StreamStatus, Text, ThreeDrives, Tick, TimeCycles, Timeframe, type TradeActionBarContext, type TradeLevelBracketDragArea, type TradeLevelDragArea, TradeLevelType, TrendAngle, TrendLine, Triangle, TrianglePattern, VerticalLine, Viewport, VolumeProfile, WebSocketAdapter, aggregateCandles, badgeMetrics, bracketPnl, formatMoney, formatPnlPillValue, positionQty, riskRewardRatio, summarisePositionLevels };