openalgo-charts 2.5.6 → 2.5.7

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /** Library version string. Matches package.json (including locally prepared releases). */
-declare const VERSION = "2.5.6";
+declare const VERSION = "2.5.7";
 /** Returns the current library version. */
 declare function version(): string;
 
@@ -63,14 +63,6 @@ declare class InvalidateMask {
     merge(other: InvalidateMask): void;
 }
 
-/**
- * Frame scheduler (ARCHITECTURE.md §3.2). Coalesces many `requestFrame()` calls
- * within a single tick into one `onFrame` invocation. The rAF function is
- * injectable so the loop is deterministically testable without a browser.
- */
-type RafScheduler = (cb: () => void) => number;
-type RafCanceller = (handle: number) => void;
-
 /**
  * HiDPI canvas handling (ARCHITECTURE.md §3.1).
  *
@@ -4448,6 +4440,14 @@ declare class Pane {
     yToPrice(y: number): number;
 }
 
+/**
+ * Frame scheduler (ARCHITECTURE.md §3.2). Coalesces many `requestFrame()` calls
+ * within a single tick into one `onFrame` invocation. The rAF function is
+ * injectable so the loop is deterministically testable without a browser.
+ */
+type RafScheduler = (cb: () => void) => number;
+type RafCanceller = (handle: number) => void;
+
 /**
  * Crosshair state + magnet snapping (ARCHITECTURE.md §6). Pure helpers so the
  * snap logic is unit-testable; drawing lives in render/crosshair.ts.
@@ -4574,227 +4574,6 @@ declare class ShortcutManager {
     static shouldIgnore(target: unknown): boolean;
 }
 
-/**
- * Trading visualization API (ARCHITECTURE.md §9). A data-driven layer on top of
- * the chart: your app pushes exchange state (positions, orders, trades) and the
- * chart renders labelled price-line "pills" (with a cancel/close button and
- * drag-to-modify) plus trade-fill markers; user interaction is relayed back as
- * `trading:*` events for the app to send to the exchange. Original,
- * framework-free API.
- */
-
-type PositionSide = 'long' | 'short';
-type TradingOrderSide = 'buy' | 'sell';
-type TradingOrderType = 'limit' | 'stop' | 'stop_limit';
-type TradeMarkerVariant = 'chevron' | 'bubble' | 'count';
-type TradingLineVariant = 'standard' | 'line-only';
-type TradingLineStyle = 'solid' | 'dashed' | 'dotted';
-interface TradingPosition {
-    id: string;
-    side: PositionSide;
-    entryPrice: number;
-    size: number;
-    pnlText?: string;
-    pnlPercent?: string;
-    color?: string;
-    readOnly?: boolean;
-    variant?: TradingLineVariant;
-}
-interface TradingOrder {
-    id: string;
-    type: TradingOrderType;
-    side: TradingOrderSide;
-    price: number;
-    size: number;
-    parentId?: string;
-    bracketRole?: 'tp' | 'sl';
-    color?: string;
-    lineStyle?: TradingLineStyle;
-    lineWidth?: number;
-    readOnly?: boolean;
-    draggable?: boolean;
-    variant?: TradingLineVariant;
-}
-interface TradingTrade {
-    id: string;
-    side: TradingOrderSide;
-    price: number;
-    size: number;
-    /** Execution time in milliseconds. */
-    timestamp: number;
-    variant?: TradeMarkerVariant;
-    color?: string;
-    label?: string;
-}
-interface TradingSyncPayload {
-    positions?: TradingPosition[];
-    orders?: TradingOrder[];
-    trades?: TradingTrade[];
-}
-interface TradingColors {
-    long: string;
-    short: string;
-    order: string;
-    tp: string;
-    sl: string;
-    buy: string;
-    sell: string;
-}
-interface TradingSettings {
-    longColor?: string;
-    shortColor?: string;
-    orderColor?: string;
-    tpColor?: string;
-    slColor?: string;
-    buyColor?: string;
-    sellColor?: string;
-}
-/** What the controller needs from the chart (the Chart implements this). */
-interface TradingHost {
-    addPrimitive(p: IPrimitive): void;
-    removePrimitive(p: IPrimitive): void;
-    subscribeClick(cb: (externalId: string) => void): void;
-    subscribeDrag(onDrag: (externalId: string, price: number) => void, onDragEnd?: (externalId: string, price: number) => void): void;
-    /** Optional: route trading events onto the chart's unified `chart.on(...)` bus. */
-    emit?(event: string, payload: unknown): void;
-    /**
-     * Optional: the instrument's tick schedule when the layer is built. The
-     * layer is built on first use, often after the instrument was applied, and
-     * applying one cannot build the layer early: its click and drag
-     * subscriptions would replace the host's own.
-     */
-    tickSchedule?(): TickSchedule | null;
-}
-declare const DEFAULT_TRADING_COLORS: TradingColors;
-/** Self-contained trade-fill markers (chevron / bubble / count) over the plot. */
-declare class TradeMarkersPrimitive implements IPrimitive {
-    private _trades;
-    private _colors;
-    private _host;
-    constructor(colors: TradingColors);
-    attached(host: PrimitiveHost): void;
-    detached(): void;
-    zOrder(): ZOrder;
-    autoscaleInfo(): null;
-    setTrades(trades: TradingTrade[]): void;
-    setColors(colors: TradingColors): void;
-    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
-}
-declare class TradingController {
-    private readonly _host;
-    private readonly _positions;
-    private readonly _orders;
-    private readonly _trades;
-    private readonly _listeners;
-    private readonly _dragPrev;
-    private _colors;
-    private _markers;
-    private _ticks;
-    constructor(host: TradingHost);
-    on(event: string, cb: (payload: unknown) => void): () => void;
-    off(event: string, cb: (payload: unknown) => void): void;
-    private _emit;
-    setSettings(settings: TradingSettings): void;
-    getSettings(): TradingColors;
-    /**
-     * Snap dragged order and bracket lines, and the price their modify events
-     * carry, to the instrument's ticks. Null, the default, passes the pointer's
-     * price through unrounded, as it always has. The host's own validation stays
-     * authoritative either way; this only stops a drag previewing a price the
-     * instrument cannot trade at. `Instrument.applyTo` and
-     * `chart.setTickSchedule` set it, so call this after either to override it.
-     */
-    setTickSchedule(schedule: TickSchedule | null): void;
-    setPositions(positions: readonly TradingPosition[]): void;
-    setOrders(orders: readonly TradingOrder[]): void;
-    setTrades(trades: readonly TradingTrade[]): void;
-    addTrade(trade: TradingTrade): void;
-    upsertOrder(order: TradingOrder): void;
-    removeOrder(id: string): void;
-    syncState(payload: TradingSyncPayload): void;
-    updatePositionPnl(id: string, unrealizedPnl: number, pnlText?: string, pnlPercent?: string): void;
-    getPositions(): TradingPosition[];
-    getOrders(): TradingOrder[];
-    getTrades(): TradingTrade[];
-    clear(): void;
-    private _renderTrades;
-    private _sync;
-    private _sig;
-    /** Info segment for a position: live P&L text (side/size live in badge/qty). */
-    private _positionPill;
-    private _positionOpts;
-    private _orderOpts;
-    private _onClick;
-    private _onDrag;
-    private _onDragEnd;
-}
-
-/**
- * Interactive value capture (ARCHITECTURE.md §7). A settings input that names a
- * price or a time is declarative and the host renders it, but the *value* can
- * come from pointing at the chart, and only the engine knows what is under the
- * cursor. So the host arms a pick ("the user is now choosing a price"), the next
- * click on the plot answers with one, and the pick disarms itself.
- *
- * Built on the `click` event the draw tier's placement mode already resolves
- * anchors from, rather than a second capture path: same pane resolution, same
- * on-demand autoscale, same payload.
- *
- * Placement mode is deliberately *not* armed while picking. A pick wants panning
- * left alone (scroll back to the bar you mean, then click it), and a drag emits
- * no click outside placement mode, so panning cannot answer the pick by
- * accident. It also keeps a pick from cancelling an active drawing tool.
- */
-
-type PickKind = 'price' | 'time';
-/**
- * What a `'point'` pick answers: the bar time and the price under one click.
- * One capture rather than a time pick and a price pick in turn, so a study
- * input pairing the two is never written half from one click and half from
- * another.
- */
-interface PickPoint {
-    time: number;
-    price: number;
-}
-/** Cancel a capture, or inspect whether this invocation still owns it. */
-interface PickHandle {
-    (): void;
-    readonly active: () => boolean;
-}
-/** Optional target for Chart.beginPick. Times remain absolute UTC seconds. */
-interface PickOptions {
-    paneIndex?: number;
-    priceScaleId?: PriceScaleId;
-}
-/**
- * The slice of the chart a pick needs. Structural, so `Chart` satisfies it with
- * nothing to cast and this module never imports the core (which imports this).
- */
-interface PickHost {
-    on(event: string, cb: (payload: unknown) => void): () => void;
-    emit(event: string, payload: unknown): void;
-    readonly dataLayer: {
-        timeToIndexFloat(time: number): number;
-        indexToTime(index: number): number | undefined;
-    };
-}
-/**
- * Arm the next plot click to resolve to a price, a bar time, or both as a
- * `'point'` ({@link PickPoint}), and hand it to `cb`. Returns a cancel
- * function; calling it (or arming another pick on the same chart) disarms
- * without calling back. The chart emits `pick:start`
- * (`{ kind }`) and `pick:end` (`{ kind, value }`, `value` null when cancelled)
- * so a host can show its own cursor or hint while the pick is live.
- *
- * A time is snapped to the bar the click landed on, because a time between two
- * bars matches no bar and anything anchored to it would never line up. Clicking
- * past the last bar keeps the projected time, which is what a pick in the empty
- * right-hand space means.
- */
-declare function beginPick(host: PickHost, kind: 'point', cb: (value: PickPoint) => void): PickHandle;
-declare function beginPick(host: PickHost, kind: PickKind, cb: (value: number) => void): PickHandle;
-
 /** Time-anchored event badges. Event feeds and detail loading belong to the host. */
 
 interface EventDetailField {
@@ -4962,141 +4741,11 @@ declare class TimeNavigator implements IPrimitive {
 }
 
 /**
- * Declarative chart-settings schema: the tabs and controls a host renders to
- * build the terminal's settings dialog, without hardcoding a list.
- *
- * WHY it reuses `IndicatorInput` rather than inventing a widget vocabulary: a
- * host that can already render the indicator settings form (built from
- * `indicatorStyleInputs`) can render this one with no new widget code. It adds
- * exactly one widget of its own, `colorPair`, because a bullish/bearish pair is
- * one row of the dialog and expressing it as two `color` inputs forces a host
- * into a section header plus two stacked rows: three times the height, for the
- * property a trader changes most.
- *
- * WHY read/write live on the same object as the input: the schema and the
- * accessors are one structure, so a control cannot drift from the option it
- * drives, and there is no second table to keep in step. That is also the rule
- * for what ships here: **every control maps to an option that actually changes
- * what is drawn or stored.** Controls this engine has no backing for are absent
- * rather than inert; a checkbox that does nothing is worse than one that is not
- * there.
- *
- * The tabs are our own five, not a reference terminal's seven. Alerts are not
- * here because the feature is not built, and corporate events are not here
- * because nothing in the engine sources them: an empty tab is worse than an
- * absent one.
- *
- * Keys are dotted paths (`symbol.upColor`, `canvas.grid.vertColor`), so a patch
- * is a flat `Record<string, value>` that survives JSON. They are a wire format
- * a host may have written down, so they stay put when the grouping above them
- * changes: a key names the option it writes, not the tab it is shown on.
- */
-
-/**
- * Tabs of the settings dialog. Five groups, chosen so a trader finds a setting
- * without hunting: what the instrument is painted with, what the header reads
- * out, what the two axes do, what the surface around the data looks like, and
- * what the trade layer draws.
- */
-type ChartSettingsTabId = 'price' | 'readout' | 'axes' | 'appearance' | 'trading';
-/**
- * Two colours on one labelled row, with an optional switch in front of them:
- *
- *     [x] Borders   [up] [down]
- *
- * `key` identifies the row and is not itself a value. The value keys are
- * `up.key`, `down.key` and `enabled.key`, each an ordinary flat key of
- * `ChartSettingsValues`, so a host patches this row exactly the way it patches
- * a plain colour and nothing about read/apply has to know the widget exists.
- *
- * `enabled` is absent when the pair has no visibility flag behind it (a candle
- * body is always drawn), which is the difference between a row whose checkbox
- * does something and one whose checkbox would be a lie.
- *
- * It takes `visibleWhen` and `activeWhen`, and a condition that reads any of
- * its three value keys reads the pair. It takes no `inline`: the row already
- * holds a switch and two swatches, so it always stands on its own.
- */
-interface ChartSettingsColorPairInput extends Omit<IndicatorInputPresentation, 'inline'> {
-    key: string;
-    type: 'colorPair';
-    label: string;
-    group?: string;
-    /** Help text for the row, on the same terms as `IndicatorInput['tooltip']`. */
-    tooltip?: string;
-    enabled?: {
-        key: string;
-        default: boolean;
-    };
-    up: {
-        key: string;
-        label: string;
-        default: string;
-    };
-    down: {
-        key: string;
-        label: string;
-        default: string;
-    };
-}
-/** Everything a host may be handed in `ChartSettingsTab.inputs`. */
-type ChartSettingsInput = IndicatorInput | ChartSettingsColorPairInput;
-interface ChartSettingsTab {
-    id: ChartSettingsTabId;
-    label: string;
-    /** Controls in display order; `input.group` names the sub-heading. */
-    inputs: ChartSettingsInput[];
-}
-type ChartSettingsValue = string | number | boolean;
-/** Flat, JSON-safe snapshot of every control, keyed by the schema's dotted key. */
-type ChartSettingsValues = Record<string, ChartSettingsValue>;
-/**
- * The settings slice of a saved chart state. It is declared here rather than on
- * `ChartState` so this module owns its own persistence: `chart.getState()`
- * returns a `ChartState & ChartSettingsState`, which is still a `ChartState` to
- * every existing consumer, and `restoreState` reads it back.
- *
- * `events` stays in the saved state although the dialog no longer offers the
- * switches: the chart still owns `setEventOptions`, a host that feeds its own
- * corporate actions still sets them, and dropping the field would throw that
- * host's saved layout away.
- */
-interface ChartSettingsState {
-    navigation?: Partial<ChartNavigationOptions>;
-    canvas?: CanvasOptions;
-    statusLine?: LegendStatusLineOptions;
-    watermark?: ChartWatermarkOptions;
-    trading?: TradingSettings;
-    events?: ChartEventOptions;
-    /**
-     * The axis-strip switches. Only the switches: `AxisChromeOptions.clock` is a
-     * callback, which no JSON survives, and a host that supplied one supplies it
-     * again when it builds the chart.
-     */
-    axisChrome?: Pick<AxisChromeOptions, 'sessionClock' | 'barCountdown'>;
-}
-/**
- * The settings dialog, described. Takes the chart because the Price tab depends
- * on the primary series type (a candle has borders, a line has a dash), because
- * the colour defaults come from the live theme, and because the timezone list
- * has to include whatever zone the chart is already in.
- */
-declare function chartSettingsSchema(chart: Chart): ChartSettingsTab[];
-/** Current value of every control in the schema, keyed the same way. */
-declare function readChartSettings(chart: Chart): ChartSettingsValues;
-/**
- * Apply a patch produced by the dialog. Only the keys present are written, so a
- * single changed control is a one-key object; unknown keys are ignored, which is
- * what lets a state saved by a newer build restore into an older one.
- */
-declare function applyChartSettings(chart: Chart, patch: Readonly<Partial<ChartSettingsValues>>): void;
-
-/**
- * Logo / brand watermark (ARCHITECTURE.md §8). Draws a small image (or an
- * already-decoded bitmap) faintly in a corner of the plot, the way charting
- * apps stamp a product/brand mark. Because it draws on the canvas it is captured
- * by `chart.takeScreenshot()`, and an optional `tint` recolors the opaque pixels
- * so a single-color logo reads on both dark and light themes.
+ * Logo / brand watermark (ARCHITECTURE.md §8). Draws a small image (or an
+ * already-decoded bitmap) faintly in a corner of the plot, the way charting
+ * apps stamp a product/brand mark. Because it draws on the canvas it is captured
+ * by `chart.takeScreenshot()`, and an optional `tint` recolors the opaque pixels
+ * so a single-color logo reads on both dark and light themes.
  *
  * Pass a `src` (URL or data URI) or a preloaded `image` for custom artwork.
  * Without a source, the original OpenAlgo glyph draws without a network request.
@@ -5279,10 +4928,16 @@ declare class TextWatermark implements IPrimitive {
 }
 
 /**
- * Top-level chart orchestrator (ARCHITECTURE.md §3.3). Owns the shared
- * DataLayer + time scale, the panes, the invalidate mask, and the render loop.
- * Phase 2 renders static candlesticks with price/time axes; pan/zoom (Phase 3)
- * and live data (Phase 4) build on this.
+ * The public option, event and payload types of the Chart class, with the two
+ * small values published beside them (`compactVolume`, `PRICE_SCALE_MODES`).
+ *
+ * They sit in their own module so chart.ts can be split into internal pieces
+ * without each piece importing the orchestrator for a type. chart.ts re-exports
+ * every name declared here, so an import of './chart' or '../core/chart' keeps
+ * the same names at the same path. `ChartClickEvent` and `PriceAxisState` are
+ * declared in chart.ts instead: they carry deprecated members, and the
+ * deprecation inventory (COMPATIBILITY.md and its test) names chart.ts as
+ * their home.
  */
 
 /** What a wheel zoom holds still. */
@@ -5301,7 +4956,6 @@ interface DoubleClickEvent {
     y: number;
     handled: boolean;
 }
-
 /** Optional background text. Blank text follows the chart's symbol and interval. */
 interface ChartWatermarkOptions extends Partial<TextWatermarkOptions> {
     visible?: boolean;
@@ -5414,8 +5068,8 @@ interface ChartOptions {
     navigation?: Partial<ChartNavigationOptions>;
     /**
      * Where indicator legend rows start inside **one** pane, in media px. A host
-     * that draws its own overlay in a pane's top-left corner — an OHLC readout, a
-     * symbol line, a trade panel — needs to push these clear of it, or the rows
+     * that draws its own overlay in a pane's top-left corner (an OHLC readout, a
+     * symbol line, a trade panel) needs to push these clear of it, or the rows
      * land underneath and their settings / close buttons become invisible and
      * unclickable.
      *
@@ -5433,8 +5087,8 @@ interface ChartOptions {
         left?: number;
     };
     /**
-     * Crosshair behaviour. 'normal' (default) — the cross follows the pointer
-     * exactly. 'magnet' — the horizontal line snaps to the nearest O/H/L/C of the
+     * Crosshair behaviour. 'normal' (default): the cross follows the pointer
+     * exactly. 'magnet': the horizontal line snaps to the nearest O/H/L/C of the
      * bar under the cursor (price pane only).
      */
     crosshairMode?: CrosshairMode;
@@ -5573,7 +5227,7 @@ interface ChartOptions {
     timezone?: string;
     /**
      * Hover-revealed zoom / step controls above the time axis, as terminals show.
-     * `true` by default — they stay invisible until the pointer nears the bottom
+     * `true` by default: they stay invisible until the pointer nears the bottom
      * of the chart. Pass `false` to drop them, or an options object to restyle.
      */
     timeNavigator?: boolean | Partial<TimeNavigatorOptions>;
@@ -5683,25 +5337,505 @@ interface PointerModifiers {
 /** Device behind a pointer gesture. Anything the browser does not name reports as a mouse. */
 type PointerKind = 'mouse' | 'touch' | 'pen';
 /**
- * One position a pointer passed through during a drag, in the same media px
- * space as the payload's `point` (container x, pane-local y). `pressure` is
- * the pointer events convention: 0..1 from hardware that measures it, 0.5
- * while a button that cannot is held, 0 when nothing is known.
+ * One position a pointer passed through during a drag, in the same media px
+ * space as the payload's `point` (container x, pane-local y). `pressure` is
+ * the pointer events convention: 0..1 from hardware that measures it, 0.5
+ * while a button that cannot is held, 0 when nothing is known.
+ */
+interface PointerSample {
+    x: number;
+    y: number;
+    pressure: number;
+}
+/**
+ * What the engine reports about the physical pointer behind a gesture.
+ * `crosshair:move`, `click`, `drag:start`, `drag` and `drag:end` all carry these keys.
+ */
+interface PointerInfo {
+    modifiers: PointerModifiers;
+    pointerType: PointerKind;
+    pressure: number;
+}
+/** An event-strip click, including every member of a clustered marker. */
+interface ChartEventClick extends EventMarkerDetails {
+    /** Chart-container CSS pixels, including the vertical offset of an event pane. */
+    point: {
+        x: number;
+        y: number;
+    };
+    paneIndex: number;
+}
+/** Payload of the `drag` event: a draggable primitive being moved. */
+interface ChartDragEvent extends PointerInfo {
+    id: string;
+    price: number;
+    time: number;
+    paneIndex: number;
+    /** Where the gesture was grabbed, so a delta starts at the press rather than the first move. */
+    fromPrice: number;
+    fromTime: number;
+    /** Current pointer position: container media x, pane-local media y. */
+    point: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Every position the pointer passed through since the previous `drag`,
+     * oldest first, the last one at `point`. Browsers deliver moves at frame
+     * rate and fold the positions between frames into the event; a freehand
+     * stroke drawn from `point` alone is a polyline of frame-rate corners.
+     */
+    samples: PointerSample[];
+}
+/** Payload of `drag:start` (press) and `drag:end` (release) for a primitive drag. */
+interface ChartDragEndEvent extends PointerInfo {
+    id: string;
+    price: number;
+    time: number;
+    paneIndex: number;
+    /** Release position: container media x, pane-local media y. */
+    point: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * What the pointer was over when the context menu was raised. The chart cannot
+ * know which menu items an app wants, but it does know what was hit, which is
+ * the part an app cannot work out for itself: a canvas gives it a pixel, not an
+ * object. `primitive` is anything hit-testable that is not one of the named
+ * kinds (a price line, an order pill, a marker).
+ */
+type ContextMenuTargetKind = 'drawing' | 'indicator' | 'legend' | 'primitive' | 'series' | 'price-scale' | 'time-scale' | 'empty';
+interface ContextMenuTarget {
+    kind: ContextMenuTargetKind;
+    /** Hit-test id of the thing under the pointer, when there was one. */
+    id: string | null;
+    /** Indicator instance id, when `kind` is 'indicator'. */
+    instanceId?: string;
+    /** Exact plot key when a study's plotted series was hit rather than its legend. */
+    plotKey?: string;
+    /** Series type, when `kind` is 'series'. */
+    seriesType?: SeriesType;
+    /** Which axis strip was hit, when `kind` is 'price-scale'. */
+    side?: 'right' | 'left';
+    /**
+     * Which of the pane's scales that strip acts on, when `kind` is
+     * 'price-scale': the side's own scale, or the hidden overlay scale ('') when
+     * the side carries no series of its own and the pane's values are all on the
+     * overlay. It is the argument the `priceAxis*` calls take.
+     */
+    scaleId?: PriceScaleId;
+}
+/** The four price-scale modes, in the order a menu lists them. */
+declare const PRICE_SCALE_MODES: readonly PriceScaleMode[];
+/**
+ * The setters that change what `getState` saves without an event of their
+ * own, and so announce it with `layout:change`.
+ */
+type LayoutSetter = 'setPaneWeight' | 'setPriceAxisOptions' | 'setPriceAxisAutoFit' | 'setPriceAxisLockRatio' | 'setPriceScaleOptions' | 'setAutoScale' | 'setGridOptions' | 'setCanvasOptions' | 'setStatusLineOptions' | 'setWatermarkOptions' | 'setTradingSettings' | 'setAxisChromeOptions' | 'setEventOptions' | 'applyOptions';
+/**
+ * Payload of the `layout:change` event (`chart.on('layout:change', ...)`):
+ * a setter in {@link LayoutSetter} has run and the saved layout may differ.
+ * It fires once per outermost call, after the change is applied: the canvas
+ * block setting the grid on its way is one event, named `setCanvasOptions`.
+ * A call that names no pane or scale the chart has changes nothing and fires
+ * nothing, and neither does a restore, which announces itself with
+ * `state:restore:start` and `state:restore:end`. Compare what you read back
+ * if a no-op matters: setting a value to what it already was still fires.
+ */
+interface LayoutChangeEvent {
+    setter: LayoutSetter;
+}
+/** Payload of the `contextmenu` event (`chart.on('contextmenu', ...)`). */
+interface ContextMenuEvent {
+    paneIndex: number;
+    /** Cursor position in container media px, for placing the menu. */
+    point: {
+        x: number;
+        y: number;
+    };
+    /** Price under the pointer on that pane, or null off the plot. */
+    price: number | null;
+    /** UTC seconds under the pointer, or null when there is no data. */
+    time: number | null;
+    /** Logical bar index under the pointer, or null off the plot. */
+    index: number | null;
+    target: ContextMenuTarget;
+    /** Suppress the browser's own menu. Call it to show your own. */
+    preventDefault(): void;
+}
+/**
+ * Payload of the 'renderer:fallback' event: the chart has moved every pane
+ * from a GPU backend to `canvas2d` for the rest of the session, because the
+ * device's context was lost or turned out unusable. The frame that noticed
+ * was already painted through 2D by the backend itself, so nothing went
+ * blank; this is the host's cue to update anything that shows the renderer.
+ */
+interface RendererFallbackEvent {
+    from: RenderBackendKind;
+    to: 'canvas2d';
+    reason: RendererFallbackReason;
+}
+
+/**
+ * Trading visualization API (ARCHITECTURE.md §9). A data-driven layer on top of
+ * the chart: your app pushes exchange state (positions, orders, trades) and the
+ * chart renders labelled price-line "pills" (with a cancel/close button and
+ * drag-to-modify) plus trade-fill markers; user interaction is relayed back as
+ * `trading:*` events for the app to send to the exchange. Original,
+ * framework-free API.
+ */
+
+type PositionSide = 'long' | 'short';
+type TradingOrderSide = 'buy' | 'sell';
+type TradingOrderType = 'limit' | 'stop' | 'stop_limit';
+type TradeMarkerVariant = 'chevron' | 'bubble' | 'count';
+type TradingLineVariant = 'standard' | 'line-only';
+type TradingLineStyle = 'solid' | 'dashed' | 'dotted';
+interface TradingPosition {
+    id: string;
+    side: PositionSide;
+    entryPrice: number;
+    size: number;
+    pnlText?: string;
+    pnlPercent?: string;
+    color?: string;
+    readOnly?: boolean;
+    variant?: TradingLineVariant;
+}
+interface TradingOrder {
+    id: string;
+    type: TradingOrderType;
+    side: TradingOrderSide;
+    price: number;
+    size: number;
+    parentId?: string;
+    bracketRole?: 'tp' | 'sl';
+    color?: string;
+    lineStyle?: TradingLineStyle;
+    lineWidth?: number;
+    readOnly?: boolean;
+    draggable?: boolean;
+    variant?: TradingLineVariant;
+}
+interface TradingTrade {
+    id: string;
+    side: TradingOrderSide;
+    price: number;
+    size: number;
+    /** Execution time in milliseconds. */
+    timestamp: number;
+    variant?: TradeMarkerVariant;
+    color?: string;
+    label?: string;
+}
+interface TradingSyncPayload {
+    positions?: TradingPosition[];
+    orders?: TradingOrder[];
+    trades?: TradingTrade[];
+}
+interface TradingColors {
+    long: string;
+    short: string;
+    order: string;
+    tp: string;
+    sl: string;
+    buy: string;
+    sell: string;
+}
+interface TradingSettings {
+    longColor?: string;
+    shortColor?: string;
+    orderColor?: string;
+    tpColor?: string;
+    slColor?: string;
+    buyColor?: string;
+    sellColor?: string;
+}
+/** What the controller needs from the chart (the Chart implements this). */
+interface TradingHost {
+    addPrimitive(p: IPrimitive): void;
+    removePrimitive(p: IPrimitive): void;
+    subscribeClick(cb: (externalId: string) => void): void;
+    subscribeDrag(onDrag: (externalId: string, price: number) => void, onDragEnd?: (externalId: string, price: number) => void): void;
+    /** Optional: route trading events onto the chart's unified `chart.on(...)` bus. */
+    emit?(event: string, payload: unknown): void;
+    /**
+     * Optional: the instrument's tick schedule when the layer is built. The
+     * layer is built on first use, often after the instrument was applied, and
+     * applying one cannot build the layer early: its click and drag
+     * subscriptions would replace the host's own.
+     */
+    tickSchedule?(): TickSchedule | null;
+}
+declare const DEFAULT_TRADING_COLORS: TradingColors;
+/** Self-contained trade-fill markers (chevron / bubble / count) over the plot. */
+declare class TradeMarkersPrimitive implements IPrimitive {
+    private _trades;
+    private _colors;
+    private _host;
+    constructor(colors: TradingColors);
+    attached(host: PrimitiveHost): void;
+    detached(): void;
+    zOrder(): ZOrder;
+    autoscaleInfo(): null;
+    setTrades(trades: TradingTrade[]): void;
+    setColors(colors: TradingColors): void;
+    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
+}
+declare class TradingController {
+    private readonly _host;
+    private readonly _positions;
+    private readonly _orders;
+    private readonly _trades;
+    private readonly _listeners;
+    private readonly _dragPrev;
+    private _colors;
+    private _markers;
+    private _ticks;
+    constructor(host: TradingHost);
+    on(event: string, cb: (payload: unknown) => void): () => void;
+    off(event: string, cb: (payload: unknown) => void): void;
+    private _emit;
+    setSettings(settings: TradingSettings): void;
+    getSettings(): TradingColors;
+    /**
+     * Snap dragged order and bracket lines, and the price their modify events
+     * carry, to the instrument's ticks. Null, the default, passes the pointer's
+     * price through unrounded, as it always has. The host's own validation stays
+     * authoritative either way; this only stops a drag previewing a price the
+     * instrument cannot trade at. `Instrument.applyTo` and
+     * `chart.setTickSchedule` set it, so call this after either to override it.
+     */
+    setTickSchedule(schedule: TickSchedule | null): void;
+    setPositions(positions: readonly TradingPosition[]): void;
+    setOrders(orders: readonly TradingOrder[]): void;
+    setTrades(trades: readonly TradingTrade[]): void;
+    addTrade(trade: TradingTrade): void;
+    upsertOrder(order: TradingOrder): void;
+    removeOrder(id: string): void;
+    syncState(payload: TradingSyncPayload): void;
+    updatePositionPnl(id: string, unrealizedPnl: number, pnlText?: string, pnlPercent?: string): void;
+    getPositions(): TradingPosition[];
+    getOrders(): TradingOrder[];
+    getTrades(): TradingTrade[];
+    clear(): void;
+    private _renderTrades;
+    private _sync;
+    private _sig;
+    /** Info segment for a position: live P&L text (side/size live in badge/qty). */
+    private _positionPill;
+    private _positionOpts;
+    private _orderOpts;
+    private _onClick;
+    private _onDrag;
+    private _onDragEnd;
+}
+
+/**
+ * Interactive value capture (ARCHITECTURE.md §7). A settings input that names a
+ * price or a time is declarative and the host renders it, but the *value* can
+ * come from pointing at the chart, and only the engine knows what is under the
+ * cursor. So the host arms a pick ("the user is now choosing a price"), the next
+ * click on the plot answers with one, and the pick disarms itself.
+ *
+ * Built on the `click` event the draw tier's placement mode already resolves
+ * anchors from, rather than a second capture path: same pane resolution, same
+ * on-demand autoscale, same payload.
+ *
+ * Placement mode is deliberately *not* armed while picking. A pick wants panning
+ * left alone (scroll back to the bar you mean, then click it), and a drag emits
+ * no click outside placement mode, so panning cannot answer the pick by
+ * accident. It also keeps a pick from cancelling an active drawing tool.
+ */
+
+type PickKind = 'price' | 'time';
+/**
+ * What a `'point'` pick answers: the bar time and the price under one click.
+ * One capture rather than a time pick and a price pick in turn, so a study
+ * input pairing the two is never written half from one click and half from
+ * another.
+ */
+interface PickPoint {
+    time: number;
+    price: number;
+}
+/** Cancel a capture, or inspect whether this invocation still owns it. */
+interface PickHandle {
+    (): void;
+    readonly active: () => boolean;
+}
+/** Optional target for Chart.beginPick. Times remain absolute UTC seconds. */
+interface PickOptions {
+    paneIndex?: number;
+    priceScaleId?: PriceScaleId;
+}
+/**
+ * The slice of the chart a pick needs. Structural, so `Chart` satisfies it with
+ * nothing to cast and this module never imports the core (which imports this).
+ */
+interface PickHost {
+    on(event: string, cb: (payload: unknown) => void): () => void;
+    emit(event: string, payload: unknown): void;
+    readonly dataLayer: {
+        timeToIndexFloat(time: number): number;
+        indexToTime(index: number): number | undefined;
+    };
+}
+/**
+ * Arm the next plot click to resolve to a price, a bar time, or both as a
+ * `'point'` ({@link PickPoint}), and hand it to `cb`. Returns a cancel
+ * function; calling it (or arming another pick on the same chart) disarms
+ * without calling back. The chart emits `pick:start`
+ * (`{ kind }`) and `pick:end` (`{ kind, value }`, `value` null when cancelled)
+ * so a host can show its own cursor or hint while the pick is live.
+ *
+ * A time is snapped to the bar the click landed on, because a time between two
+ * bars matches no bar and anything anchored to it would never line up. Clicking
+ * past the last bar keeps the projected time, which is what a pick in the empty
+ * right-hand space means.
+ */
+declare function beginPick(host: PickHost, kind: 'point', cb: (value: PickPoint) => void): PickHandle;
+declare function beginPick(host: PickHost, kind: PickKind, cb: (value: number) => void): PickHandle;
+
+/**
+ * Declarative chart-settings schema: the tabs and controls a host renders to
+ * build the terminal's settings dialog, without hardcoding a list.
+ *
+ * WHY it reuses `IndicatorInput` rather than inventing a widget vocabulary: a
+ * host that can already render the indicator settings form (built from
+ * `indicatorStyleInputs`) can render this one with no new widget code. It adds
+ * exactly one widget of its own, `colorPair`, because a bullish/bearish pair is
+ * one row of the dialog and expressing it as two `color` inputs forces a host
+ * into a section header plus two stacked rows: three times the height, for the
+ * property a trader changes most.
+ *
+ * WHY read/write live on the same object as the input: the schema and the
+ * accessors are one structure, so a control cannot drift from the option it
+ * drives, and there is no second table to keep in step. That is also the rule
+ * for what ships here: **every control maps to an option that actually changes
+ * what is drawn or stored.** Controls this engine has no backing for are absent
+ * rather than inert; a checkbox that does nothing is worse than one that is not
+ * there.
+ *
+ * The tabs are our own five, not a reference terminal's seven. Alerts are not
+ * here because the feature is not built, and corporate events are not here
+ * because nothing in the engine sources them: an empty tab is worse than an
+ * absent one.
+ *
+ * Keys are dotted paths (`symbol.upColor`, `canvas.grid.vertColor`), so a patch
+ * is a flat `Record<string, value>` that survives JSON. They are a wire format
+ * a host may have written down, so they stay put when the grouping above them
+ * changes: a key names the option it writes, not the tab it is shown on.
+ */
+
+/**
+ * Tabs of the settings dialog. Five groups, chosen so a trader finds a setting
+ * without hunting: what the instrument is painted with, what the header reads
+ * out, what the two axes do, what the surface around the data looks like, and
+ * what the trade layer draws.
+ */
+type ChartSettingsTabId = 'price' | 'readout' | 'axes' | 'appearance' | 'trading';
+/**
+ * Two colours on one labelled row, with an optional switch in front of them:
+ *
+ *     [x] Borders   [up] [down]
+ *
+ * `key` identifies the row and is not itself a value. The value keys are
+ * `up.key`, `down.key` and `enabled.key`, each an ordinary flat key of
+ * `ChartSettingsValues`, so a host patches this row exactly the way it patches
+ * a plain colour and nothing about read/apply has to know the widget exists.
+ *
+ * `enabled` is absent when the pair has no visibility flag behind it (a candle
+ * body is always drawn), which is the difference between a row whose checkbox
+ * does something and one whose checkbox would be a lie.
+ *
+ * It takes `visibleWhen` and `activeWhen`, and a condition that reads any of
+ * its three value keys reads the pair. It takes no `inline`: the row already
+ * holds a switch and two swatches, so it always stands on its own.
+ */
+interface ChartSettingsColorPairInput extends Omit<IndicatorInputPresentation, 'inline'> {
+    key: string;
+    type: 'colorPair';
+    label: string;
+    group?: string;
+    /** Help text for the row, on the same terms as `IndicatorInput['tooltip']`. */
+    tooltip?: string;
+    enabled?: {
+        key: string;
+        default: boolean;
+    };
+    up: {
+        key: string;
+        label: string;
+        default: string;
+    };
+    down: {
+        key: string;
+        label: string;
+        default: string;
+    };
+}
+/** Everything a host may be handed in `ChartSettingsTab.inputs`. */
+type ChartSettingsInput = IndicatorInput | ChartSettingsColorPairInput;
+interface ChartSettingsTab {
+    id: ChartSettingsTabId;
+    label: string;
+    /** Controls in display order; `input.group` names the sub-heading. */
+    inputs: ChartSettingsInput[];
+}
+type ChartSettingsValue = string | number | boolean;
+/** Flat, JSON-safe snapshot of every control, keyed by the schema's dotted key. */
+type ChartSettingsValues = Record<string, ChartSettingsValue>;
+/**
+ * The settings slice of a saved chart state. It is declared here rather than on
+ * `ChartState` so this module owns its own persistence: `chart.getState()`
+ * returns a `ChartState & ChartSettingsState`, which is still a `ChartState` to
+ * every existing consumer, and `restoreState` reads it back.
+ *
+ * `events` stays in the saved state although the dialog no longer offers the
+ * switches: the chart still owns `setEventOptions`, a host that feeds its own
+ * corporate actions still sets them, and dropping the field would throw that
+ * host's saved layout away.
+ */
+interface ChartSettingsState {
+    navigation?: Partial<ChartNavigationOptions>;
+    canvas?: CanvasOptions;
+    statusLine?: LegendStatusLineOptions;
+    watermark?: ChartWatermarkOptions;
+    trading?: TradingSettings;
+    events?: ChartEventOptions;
+    /**
+     * The axis-strip switches. Only the switches: `AxisChromeOptions.clock` is a
+     * callback, which no JSON survives, and a host that supplied one supplies it
+     * again when it builds the chart.
+     */
+    axisChrome?: Pick<AxisChromeOptions, 'sessionClock' | 'barCountdown'>;
+}
+/**
+ * The settings dialog, described. Takes the chart because the Price tab depends
+ * on the primary series type (a candle has borders, a line has a dash), because
+ * the colour defaults come from the live theme, and because the timezone list
+ * has to include whatever zone the chart is already in.
+ */
+declare function chartSettingsSchema(chart: Chart): ChartSettingsTab[];
+/** Current value of every control in the schema, keyed the same way. */
+declare function readChartSettings(chart: Chart): ChartSettingsValues;
+/**
+ * Apply a patch produced by the dialog. Only the keys present are written, so a
+ * single changed control is a one-key object; unknown keys are ignored, which is
+ * what lets a state saved by a newer build restore into an older one.
  */
-interface PointerSample {
-    x: number;
-    y: number;
-    pressure: number;
-}
+declare function applyChartSettings(chart: Chart, patch: Readonly<Partial<ChartSettingsValues>>): void;
+
 /**
- * What the engine reports about the physical pointer behind a gesture.
- * `crosshair:move`, `click`, `drag:start`, `drag` and `drag:end` all carry these keys.
+ * Top-level chart orchestrator (ARCHITECTURE.md §3.3). Owns the shared
+ * DataLayer + time scale, the panes, the invalidate mask, and the render loop.
+ * Phase 2 renders static candlesticks with price/time axes; pan/zoom (Phase 3)
+ * and live data (Phase 4) build on this.
  */
-interface PointerInfo {
-    modifiers: PointerModifiers;
-    pointerType: PointerKind;
-    pressure: number;
-}
+
 /**
  * Payload of the `click` event (`chart.on('click', ...)`). Its `pressure` is
  * the pressure at the press, not the release, which always reads 0.
@@ -5733,79 +5867,6 @@ interface ChartClickEvent extends PointerInfo {
     /** @deprecated Removed in 3.0.0. Read `modifiers.meta` (since 2.0.0), which carries the same state. */
     metaKey: boolean;
 }
-/** An event-strip click, including every member of a clustered marker. */
-interface ChartEventClick extends EventMarkerDetails {
-    /** Chart-container CSS pixels, including the vertical offset of an event pane. */
-    point: {
-        x: number;
-        y: number;
-    };
-    paneIndex: number;
-}
-/** Payload of the `drag` event: a draggable primitive being moved. */
-interface ChartDragEvent extends PointerInfo {
-    id: string;
-    price: number;
-    time: number;
-    paneIndex: number;
-    /** Where the gesture was grabbed, so a delta starts at the press rather than the first move. */
-    fromPrice: number;
-    fromTime: number;
-    /** Current pointer position: container media x, pane-local media y. */
-    point: {
-        x: number;
-        y: number;
-    };
-    /**
-     * Every position the pointer passed through since the previous `drag`,
-     * oldest first, the last one at `point`. Browsers deliver moves at frame
-     * rate and fold the positions between frames into the event; a freehand
-     * stroke drawn from `point` alone is a polyline of frame-rate corners.
-     */
-    samples: PointerSample[];
-}
-/** Payload of `drag:start` (press) and `drag:end` (release) for a primitive drag. */
-interface ChartDragEndEvent extends PointerInfo {
-    id: string;
-    price: number;
-    time: number;
-    paneIndex: number;
-    /** Release position: container media x, pane-local media y. */
-    point: {
-        x: number;
-        y: number;
-    };
-}
-/**
- * What the pointer was over when the context menu was raised. The chart cannot
- * know which menu items an app wants, but it does know what was hit, which is
- * the part an app cannot work out for itself: a canvas gives it a pixel, not an
- * object. `primitive` is anything hit-testable that is not one of the named
- * kinds (a price line, an order pill, a marker).
- */
-type ContextMenuTargetKind = 'drawing' | 'indicator' | 'legend' | 'primitive' | 'series' | 'price-scale' | 'time-scale' | 'empty';
-interface ContextMenuTarget {
-    kind: ContextMenuTargetKind;
-    /** Hit-test id of the thing under the pointer, when there was one. */
-    id: string | null;
-    /** Indicator instance id, when `kind` is 'indicator'. */
-    instanceId?: string;
-    /** Exact plot key when a study's plotted series was hit rather than its legend. */
-    plotKey?: string;
-    /** Series type, when `kind` is 'series'. */
-    seriesType?: SeriesType;
-    /** Which axis strip was hit, when `kind` is 'price-scale'. */
-    side?: 'right' | 'left';
-    /**
-     * Which of the pane's scales that strip acts on, when `kind` is
-     * 'price-scale': the side's own scale, or the hidden overlay scale ('') when
-     * the side carries no series of its own and the pane's values are all on the
-     * overlay. It is the argument the `priceAxis*` calls take.
-     */
-    scaleId?: PriceScaleId;
-}
-/** The four price-scale modes, in the order a menu lists them. */
-declare const PRICE_SCALE_MODES: readonly PriceScaleMode[];
 /**
  * What a host needs to render a menu over one price axis: which items are on,
  * and which of them mean anything on this axis. See `Chart.priceAxisState`.
@@ -5832,54 +5893,6 @@ interface PriceAxisState {
      */
     movable: boolean;
 }
-/**
- * The setters that change what `getState` saves without an event of their
- * own, and so announce it with `layout:change`.
- */
-type LayoutSetter = 'setPaneWeight' | 'setPriceAxisOptions' | 'setPriceAxisAutoFit' | 'setPriceAxisLockRatio' | 'setPriceScaleOptions' | 'setAutoScale' | 'setGridOptions' | 'setCanvasOptions' | 'setStatusLineOptions' | 'setWatermarkOptions' | 'setTradingSettings' | 'setAxisChromeOptions' | 'setEventOptions' | 'applyOptions';
-/**
- * Payload of the `layout:change` event (`chart.on('layout:change', ...)`):
- * a setter in {@link LayoutSetter} has run and the saved layout may differ.
- * It fires once per outermost call, after the change is applied: the canvas
- * block setting the grid on its way is one event, named `setCanvasOptions`.
- * A call that names no pane or scale the chart has changes nothing and fires
- * nothing, and neither does a restore, which announces itself with
- * `state:restore:start` and `state:restore:end`. Compare what you read back
- * if a no-op matters: setting a value to what it already was still fires.
- */
-interface LayoutChangeEvent {
-    setter: LayoutSetter;
-}
-/** Payload of the `contextmenu` event (`chart.on('contextmenu', ...)`). */
-interface ContextMenuEvent {
-    paneIndex: number;
-    /** Cursor position in container media px, for placing the menu. */
-    point: {
-        x: number;
-        y: number;
-    };
-    /** Price under the pointer on that pane, or null off the plot. */
-    price: number | null;
-    /** UTC seconds under the pointer, or null when there is no data. */
-    time: number | null;
-    /** Logical bar index under the pointer, or null off the plot. */
-    index: number | null;
-    target: ContextMenuTarget;
-    /** Suppress the browser's own menu. Call it to show your own. */
-    preventDefault(): void;
-}
-/**
- * Payload of the 'renderer:fallback' event: the chart has moved every pane
- * from a GPU backend to `canvas2d` for the rest of the session, because the
- * device's context was lost or turned out unusable. The frame that noticed
- * was already painted through 2D by the backend itself, so nothing went
- * blank; this is the host's cue to update anything that shows the renderer.
- */
-interface RendererFallbackEvent {
-    from: RenderBackendKind;
-    to: 'canvas2d';
-    reason: RendererFallbackReason;
-}
 declare class Chart {
     private readonly _container;
     private readonly _doc;
@@ -5906,13 +5919,8 @@ declare class Chart {
     private readonly _timeAxisHeight;
     private _pending;
     private _scaleMutationDepth;
-    private _resizeObserver;
-    /** Watches the canvases' device-pixel boxes, where the browser reports them. */
-    private _deviceObserver;
-    /** Matches the device pixel ratio the canvases were last sized at; made again on every change. */
-    private _ratioQuery;
-    /** The window whose `resize` also re-checks the ratio. */
-    private _ratioView;
+    /** Size and device-pixel-ratio observation; see chart-pixels.ts. */
+    private readonly _pixels;
     /** The device pixel ratio the canvases were last sized at. */
     private _layoutRatio;
     private _width;
@@ -5927,8 +5935,8 @@ declare class Chart {
     private _shortcuts;
     private _trading;
     private _tickSchedule;
-    private _pointerInside;
-    private _keyTarget;
+    /** Pointer, wheel and keyboard routing, hover, and the gesture state they keep; see chart-input.ts. */
+    private readonly _input;
     private readonly _now;
     private readonly _conflate;
     private readonly _conflationFactor;
@@ -5974,38 +5982,16 @@ declare class Chart {
     private _events;
     private _eventMarkers;
     private _eventPane;
-    private readonly _eventVisible;
-    private _cursorPane;
-    private _cursor;
-    private _dragging;
+    /** Attaching, stacking and re-homing primitives, and the event strip's type switches; see chart-primitives.ts. */
+    private readonly _primitives;
     private readonly _navigation;
-    /** A cancelled navigation sequence stays consumed until every held pointer ends. */
-    private _navigationCancelled;
-    private _dragStartX;
-    private _dragStartY;
-    private _lastDragY;
-    /** Pointers whose gesture the missed-release recovery already ended. */
-    private readonly _endedPointers;
-    private readonly _pointers;
-    private _pinch;
-    private _pinchPane;
     private _liveRegion;
-    private _dragStartOffset;
     private _lastDragX;
     private _lastDragT;
     private _dragVelocity;
-    private _kineticHandle;
-    private _kineticEpoch;
-    private _zoomHandle;
-    /** The glide in flight, so a second wheel tick folds into it (see ZoomGlide.add). */
-    private _zoomGlide;
-    private _zoomGlideStart;
-    private _zoomGlideApplied;
+    /** Kinetic pan, the zoom glide and the autoscale easing they start; see chart-motion.ts. */
+    private readonly _motion;
     private readonly _animZoom;
-    private readonly _animAutoscale;
-    private _autoscaleTime;
-    private _autoscaleFrames;
-    private _navigationEpoch;
     private readonly _zoomAnchor;
     private readonly _doubleClick;
     /** `movablePrimaryPane`: without it the price pane stays pinned at slot 0. */
@@ -6029,38 +6015,28 @@ declare class Chart {
      * list was set by the host since, and that list becomes its own.
      */
     private readonly _legendActions;
-    private _restoreGeneration;
+    /** Saving and restoring the chart state; see chart-state.ts. */
+    private readonly _persistence;
     private readonly _indicatorRanges;
     private readonly _ownedScaleRanges;
     private readonly _seriesOwners;
+    /** Making series and the data paths behind their handles; see chart-series.ts. */
+    private readonly _series;
     private _dataContext;
     private _barsProvider;
     private _barsRequests;
     private _barsProviderRevision;
     private _requestedDataRevision;
-    /** Guards indicator recompute against re-entry via its own `series.setData`. */
-    private _recomputing;
+    /** Adding, moving and recomputing studies, and the host they talk to; see chart-studies.ts. */
+    private readonly _studies;
     private _indicatorsDirty;
     private readonly _indicatorRefreshes;
-    private _indicatorWork;
-    private _indicatorProcessed;
     private readonly _indicatorReservedIds;
-    /** Instance id of the indicator whose colours are on the price bars, if any. */
-    private _barColorOwner;
-    private _barColors;
-    /**
-     * Each price bar's own colour, indexed like the series. The overlay overwrites
-     * `Bar.color`, so a bar's own value is only readable the first time we touch
-     * it, and removing the indicator has to put something back.
-     */
-    private readonly _barColorBase;
-    /** Time of bar 0 when the snapshot was taken, to catch a replaced history. */
-    private _barColorAnchor;
     /** Opaque drawing-tier payload, round-tripped through get/restoreState. */
     private _drawingState;
     private _alertState;
-    /** Pane currently maximized, and the weights to restore when it un-maximizes. */
-    private _maximizedPane;
+    /** Making, removing, moving, maximizing and folding panes, and their layout; see chart-panes.ts. */
+    private readonly _layout;
     /**
      * Panes folded to a header strip. Held by pane identity, like `_pricePanes`,
      * so the fold follows its pane through a move or a removal above it without
@@ -6070,12 +6046,8 @@ declare class Chart {
     /** Legend rows per pane, so new ones stack below existing ones. */
     private readonly _legends;
     private readonly _studyLegends;
-    private _indicatorLegendToggle;
-    private _indicatorLegendRow;
-    private _indicatorTogglePress;
-    /** Native double clicks can join a consumed count press to a newly empty plot row. */
-    private _lastPressOnIndicatorToggle;
-    private _previousPressOnIndicatorToggle;
+    /** Legend row stacking and offsets, the study count toggle, and legend button presses; see chart-legends.ts. */
+    private readonly _legendStack;
     /**
      * Pane holding the primary price series (only this pane gets magnet
      * snapping). By identity, for the reason `_primaryPane` is: a move changes
@@ -6084,42 +6056,6 @@ declare class Chart {
     private _firstPane;
     private _historyLoader;
     private _loadingHistory;
-    private _clickCb;
-    private _crosshairCb;
-    private _readoutTime;
-    private _pointerMoved;
-    /** While true, pointer gestures place anchors instead of panning. */
-    private _placementMode;
-    /** Where indicator legend rows start inside a pane (see `legendOffset`). */
-    private readonly _legendOffset;
-    private _downPane;
-    private _downX;
-    private _downLocalY;
-    /** Pressure at the press; a click reports this, since its release always reads 0. */
-    private _downPressure;
-    private _dragId;
-    private _dragPriceScale;
-    private _dragCancelOnEscape;
-    private _hoverId;
-    private _hoverKey;
-    /** Whether that primitive draws below the overlay, so leaving it must repaint the base. */
-    private _hoverOnBase;
-    private _overlayFrozen;
-    private _dragCb;
-    private _dragEndCb;
-    private _axisDrag;
-    /** The scale a price-axis drag is rescaling: either side's, whichever strip was grabbed. */
-    private _axisDragScale;
-    /** Active pane-divider drag: which boundary, and the weights/heights at grab time. */
-    /** True once a primitive drag has actually moved — see the pointerup note. */
-    private _dragMoved;
-    /** Where the drag was grabbed, in data space, so deltas start at the press. */
-    private _dragFrom;
-    private _paneResize;
-    private _axisStartCoord;
-    private _axisStartMin;
-    private _axisStartMax;
-    private _axisStartSpacing;
     private _priceFormatter;
     private _priceScaleOptions;
     /**
@@ -6132,6 +6068,8 @@ declare class Chart {
      * pane is destroyed and nothing else keeps it alive.
      */
     private readonly _pricePanes;
+    /** Which scales a price-scale setting reaches, and one axis' state; see chart-scales.ts. */
+    private readonly _scales;
     private _timeFormatter;
     private _timezone;
     private _leftAxisWidth;
@@ -6144,10 +6082,9 @@ declare class Chart {
     /** Pane the navigator is currently attached to, so it can follow the bottom. */
     private _timeNavPane;
     private _branding;
-    private _brandingOptions;
-    private _brandingPress;
-    private _watermark;
-    private _watermarkOptions;
+    /** Branding options, the background text, the option batch and the exports; see chart-appearance.ts. */
+    private readonly _appearance;
+    private readonly _readByCollaborators;
     constructor(container: HTMLElement, options?: ChartOptions);
     /** Register a callback fired when the user pans near the left (oldest) edge. */
     setHistoryLoader(loader: () => void): void;
@@ -6240,14 +6177,6 @@ declare class Chart {
      * An unregistered type throws before any state changes.
      */
     setSeriesType(series: SeriesApi, type: SeriesType): boolean;
-    private _setSeriesType;
-    /**
-     * `claimPrimary` is false for series the chart creates on a caller's behalf
-     * (indicator plots), so an indicator's line never becomes the price series
-     * that drives the magnet crosshair and the OHLC legend.
-     */
-    private _createSeries;
-    private _applySeriesPriceFormat;
     /**
      * The primary price series: the first one added, and the one the magnet
      * crosshair, the OHLC legend, the market-replay controller and a settings
@@ -6263,16 +6192,6 @@ declare class Chart {
         type: SeriesType;
         style: Readonly<SeriesStyle>;
     } | null;
-    /**
-     * Push a series' `precision` override onto the price scale it maps to.
-     *
-     * It rides the scale's *formatter* rather than `minMove` because minMove also
-     * drives `snapToTick`: precision 0 would start snapping every price to whole
-     * numbers. Going through the formatter covers the axis ticks, the last-value
-     * tag, the crosshair label and the drawing-tool labels at once, since they all
-     * call `priceScale.format`. Clearing it restores the chart-wide formatter.
-     */
-    private _applyPrecision;
     /**
      * Add a horizontal price line (order/SL/TP/alert/level) to a pane. Omitting
      * the pane means the primary price pane, wherever it sits.
@@ -6296,8 +6215,6 @@ declare class Chart {
     /** Turn event types on/off. Unlisted types stay visible. */
     setEventOptions(patch: ChartEventOptions): void;
     eventOptions(): ChartEventOptions;
-    private _ensureEventMarkers;
-    private _syncEvents;
     /**
      * Add a registered indicator. Built-in descriptors live in the lazy
      * `openalgo-charts/indicators` tier — import it (or register your own with
@@ -6330,16 +6247,6 @@ declare class Chart {
         policy?: IndicatorPolicy;
         instanceId?: string;
     }): IndicatorApi;
-    /**
-     * Give a repeated indicator its own colours. Three EMAs all in the
-     * descriptor's default blue are indistinguishable on the chart *and* in the
-     * legend, so the second and later instances rotate through a palette.
-     *
-     * Only fills colour keys the caller left unset, so an explicit colour always
-     * wins, and the first instance is never touched — it keeps the colours the
-     * descriptor chose.
-     */
-    private _distinctColors;
     /**
      * Every live indicator instance, in renderer stacking order.
      *
@@ -6358,7 +6265,6 @@ declare class Chart {
      * policy is not `movable` stays unless `options.force` is set.
      */
     reorderIndicator(instanceId: string, direction: -1 | 1, options?: IndicatorEditOptions): boolean;
-    private _reorderIndicatorResources;
     /** Whether a call may make a change a study's policy reserves for its host. */
     private _policyAllows;
     /**
@@ -6387,30 +6293,12 @@ declare class Chart {
      * layer is the case this exists for. False for a primitive on no pane.
      */
     setPrimitiveStackAbove(primitive: IPrimitive, above: string | null): boolean;
-    /** Each series of a pane that belongs to one of its series-band entries, with that entry's id. */
-    private _stackOwners;
-    /** The series an entry paints last on a pane: what a primitive placed above it paints after. */
-    private _stackSlot;
-    /**
-     * Put the price source where it was placed: directly above its study, or
-     * behind every study of its pane. A source nobody placed stays where it was
-     * added. Host series keep their slots, so only the source record moves, and
-     * only when it is out of place.
-     */
-    private _placeSource;
-    /**
-     * The study directly below the source, read from the band as it stands:
-     * how the source keeps its place when the study it sat on leaves the pane.
-     */
-    private _reanchorSource;
-    private _syncLegendPanes;
     /**
      * Remove one indicator instance by its handle id. Returns true if it existed
      * and went; a study whose policy is not `removable` stays unless
      * `options.force` is set.
      */
     removeIndicator(instanceId: string, options?: IndicatorEditOptions): boolean;
-    private _forgetIndicator;
     /** Optional instrument identity supplied by the host, never inferred from bars. */
     getDataContext(): Readonly<ChartDataContext> | undefined;
     /** Instrument capability from the host. A missing bar reading does not change it. */
@@ -6438,58 +6326,12 @@ declare class Chart {
     setWatermarkOptions(options: boolean | ChartWatermarkOptions): void;
     /** JSON-safe preferences. Automatic text remains blank in this snapshot. */
     watermarkOptions(): Readonly<ChartWatermarkOptions>;
-    private _syncWatermark;
-    private _indicatorHost;
-    private _validPriceScaleId;
-    private _assignIndicatorScale;
-    private _reconcileIndicatorRanges;
-    /**
-     * Take (or withdraw) the price bars' colour overlay on behalf of one
-     * indicator instance.
-     *
-     * Only one overlay can be on the candles, so this is last writer wins. That is
-     * deterministic rather than arbitrary: publishers run inside
-     * `_flushIndicators`, in `addIndicator` order, so the same instance wins
-     * every frame. Withdrawal is gated on ownership, or the first publisher's
-     * teardown would wipe the second one's colours. If the *winner* is removed
-     * while another publisher is still live, the bars go back to their own colours
-     * until that publisher's next recompute.
-     */
-    private _setBarColors;
-    /**
-     * Republish the primary series with the overlay applied.
-     *
-     * The bars in the data layer are the **caller's own objects** (`setData` keeps
-     * the references), so painting a colour onto them in place would reach back
-     * into the host's array and outlive the indicator. Cloning the ones that
-     * change is what keeps that from happening; unchanged bars are passed through,
-     * and a pass where nothing changed writes nothing at all, which is the common
-     * case on a live tick.
-     */
-    private _applyBarColors;
-    /**
-     * Mark every indicator stale after a source-data change, to be recomputed
-     * once before the next paint.
-     *
-     * Recomputing straight from the data update instead costs a full pass over
-     * every bar, for every indicator, for every tick. A busy symbol delivers ticks
-     * in bursts far faster than the display refreshes, so most of those passes are
-     * thrown away unseen: 50 ticks between two frames cost 50 recomputes per
-     * indicator and blocked the main thread for over half a second on a ten
-     * indicator chart. Deferring to the frame makes that one recompute, because
-     * only the last one could ever have been shown.
-     *
-     * `flushIndicators` therefore has to run before anything that can observe a
-     * value, which is the frame and the public `indicators()` accessor.
-     */
-    private _invalidateIndicators;
     /**
-     * Recompute every stale indicator. Reentrant-guarded: an indicator writes its
-     * plots with `series.setData`, which re-enters the same data-mutation path
-     * that marked us dirty.
+     * The `IndicatorHost` a study instance talks to; see chart-studies.ts. Kept
+     * here by name because the restore and tests build a host through it.
      */
-    private _flushIndicators;
-    private _queueIndicatorDependents;
+    private _indicatorHost;
+    private _validPriceScaleId;
     /** Subscribe to clicks on hit-testable primitives (markers, events, lines). */
     subscribeClick(cb: (externalId: string) => void): void;
     /**
@@ -6560,27 +6402,6 @@ declare class Chart {
      * pane, the primary price pane when none is named, or to a chart anchor.
      */
     addPrimitive(primitive: IPrimitive, where?: number | PrimitivePlacement): void;
-    /** The pane a chart anchor currently resolves to. */
-    private _anchorTarget;
-    /**
-     * The pane that wears the price pane's furniture: the primary pane while it
-     * is on screen, else the pane at the top, which is the one maximized over
-     * it. A host's symbol line and OHLC readout describe the price, so they,
-     * the study count, the background text and the legend offset belong with
-     * the price pane wherever it sits, and the price pane is hidden only while
-     * another pane fills the chart in its place.
-     */
-    private _priceCornerIndex;
-    /**
-     * Move every chart-anchored primitive to the pane its anchor now names.
-     *
-     * Called after anything that changes which pane sits at an edge or holds the
-     * price: a pane added, removed, moved, collapsed or maximized. Maximize matters
-     * most and is the case a host cannot easily handle itself: it HIDES the other
-     * panes, so a mark pinned to the price pane vanishes with it rather than
-     * merely sitting in the wrong place.
-     */
-    private _rehomeAnchored;
     /**
      * Map a price to a container-relative Y in media (CSS) px, for positioning DOM
      * overlays (order panels, tooltips) over a pane. Returns null if the pane
@@ -6608,12 +6429,6 @@ declare class Chart {
      * placeholder range.
      */
     plotRect(paneIndex: number): PlotRect | null;
-    /**
-     * A pane whose prices have a place on screen, scaled. A strip has none: the
-     * pointer events report no price there, and a conversion that still did
-     * would put an overlay or a nudged drawing inside a strip nobody can read.
-     */
-    private _mappedPane;
     /**
      * Grid lines at runtime: visibility of each axis, plus its colour, dash,
      * width and spacing. Omitted fields keep their current value. Repaints every
@@ -6661,34 +6476,6 @@ declare class Chart {
      * instrument. A detached copy; empty when nothing was ever set.
      */
     priceScaleDefaults(): Partial<PriceScaleOptions>;
-    /**
-     * A chart-wide price-scale patch as one pane should receive it.
-     *
-     * Every field in it describes the axis, except `minMove`, which describes the
-     * **instrument**: it is the step the symbol trades in, 0.05 on an NSE equity.
-     * A pane that plots something else is quoted in its own units, so handing it
-     * that step is not a coarse answer but an answer to a different question. It
-     * shipped as one: a host setting the instrument's 0.10 tick chart-wide made
-     * `PriceScale.precision` report one decimal on *every* pane, so a William VIX
-     * Fix reading 0.61 was labelled "0.6" and an RSI ladder read "70.0, 50.0,
-     * 30.0". Withheld, those axes fall back to inferring precision from the range
-     * they actually cover, which is the reading their own numbers imply.
-     *
-     * Only the chart-wide setters filter. An axis named outright
-     * (`setPriceAxisOptions`, a series' `priceFormat`) is the caller saying what
-     * that one axis quotes, and is obeyed.
-     */
-    private _scalePatchFor;
-    /**
-     * Record that a pane quotes the instrument, and hand it the tick it was not
-     * given while it did not.
-     *
-     * The primary pane is one from birth. Any other pane starts out an
-     * indicator's, so a host adding a second symbol to a pane of its own has to
-     * be able to promote one after the fact, or the comparison would lose the
-     * tick-sized axis it has always had.
-     */
-    private _claimPricePane;
     /** The primary pane's price-scale options (what the Scales tab reads), wherever it sits. */
     priceScaleOptions(): PriceScaleOptions;
     /**
@@ -6752,9 +6539,6 @@ declare class Chart {
      * studies.
      */
     movePriceAxis(paneIndex: number, from: 'right' | 'left', to: 'right' | 'left'): boolean;
-    private _canMovePriceAxis;
-    /** Measure one scale on demand, the way `_ensureScaled` does for the pane's right one. */
-    private _ensureScaledFor;
     /**
      * Per-field status-line switches, applied to every pane legend on the chart:
      * the host's symbol row and the indicator rows alike, which is what makes one
@@ -6821,28 +6605,8 @@ declare class Chart {
     exportSVG(options?: ExportSvgOptions): string;
     /** Chart-anchored primitives, re-homed by `_rehomeAnchored`. */
     private readonly _anchored;
-    private _addPrimitive;
     /** Remove a primitive from whichever pane holds it. */
     removePrimitive(primitive: IPrimitive): void;
-    /**
-     * Renumber legend rows per pane in insertion order, so removing one closes
-     * the gap instead of leaving a hole where it used to sit.
-     */
-    private _restackLegends;
-    /**
-     * Apply `legendOffset` to the price pane wherever it sits, and to the pane
-     * maximized over it while it is hidden, rather than to a fixed index.
-     *
-     * The offset describes the corner a host covers with its own readout of the
-     * price: a symbol line, an OHLC row. That readout belongs to the price pane,
-     * so it moves with it when the pane is moved below its studies. Maximizing a
-     * study pane hides the price pane, and the maximized pane then renders in
-     * the corner the host overlay covers; pinning the offset to one index left
-     * it drawing its legend straight through the host's readout.
-     *
-     * Host-added legend rows are left alone: the host positions its own.
-     */
-    private _syncLegendOffsets;
     /**
      * A host for the (lazy-loaded) trade layer to attach/detach its primitives
      * on a pane. Without an index it follows the primary price pane, resolved at
@@ -6853,12 +6617,6 @@ declare class Chart {
         addPrimitive(p: IPrimitive): void;
         removePrimitive(p: IPrimitive): void;
     };
-    /** Apply one live bar; auto-scroll only on a genuine right-edge append. */
-    private _updateBar;
-    private _ensurePane;
-    private _setData;
-    /** History paging: merge older bars, preserving the viewport (§4.2). */
-    private _prependData;
     /**
      * The render backend the chart is painting series with right now: what the
      * first pane was given, which is the `renderer` option unless its factory
@@ -6882,7 +6640,6 @@ declare class Chart {
      * path, so nothing was blank in between).
      */
     private _fallbackToCanvas2d;
-    private _addPane;
     /**
      * Set a custom price formatter for every pane's axis labels, last-price tag,
      * and price-line labels at runtime (e.g. switch to a currency format). Pass
@@ -6970,7 +6727,6 @@ declare class Chart {
      * (or `setVisibleLogicalRange`) once the series are populated.
      */
     restoreState(state: unknown, options?: ChartRestoreOptions): RestoreReport;
-    private _restoreState;
     /**
      * The opaque `drawings` slot in the chart state. The base engine only
      * round-trips it; the drawing tier reads and writes it.
@@ -7019,90 +6775,9 @@ declare class Chart {
     setAlertState(document: AlertsDocument | undefined): void;
     private _reserveAlertStudyIds;
     invalidate(build: (mask: InvalidateMask) => void): void;
-    /**
-     * Measure the container once more, a frame after construction.
-     *
-     * The size read in the constructor is only what the browser has resolved so
-     * far. A chart created from a script that runs before the flex/grid layout
-     * settles measures a pre-layout box, lays its panes into it, and then hears
-     * the *same* stale contentRect from the ResizeObserver in that frame, so
-     * nothing corrects it until an unrelated resize: the reported symptom is a
-     * large empty band under the chart that a refresh makes go away.
-     *
-     * Only a real measurement is allowed to win. Zero or absent means a container
-     * that is hidden or not in the document yet, and overwriting a size the host
-     * applied by hand with that would be a worse bug than the one being fixed;
-     * the ResizeObserver still picks such a container up when it appears.
-     */
-    private _remeasure;
     applySize(width: number, height: number): void;
-    /**
-     * Distribute height across panes by weight; sync the shared time-scale width.
-     *
-     * `geometryOnly` sizes the layout arithmetic (pane boxes, scale heights, the
-     * time-scale width) and leaves the DOM and the canvases alone. The vector
-     * export uses it to paint at a size that is not the screen's and then to put
-     * the screen's back, without clearing a canvas or moving a flex box on the
-     * way through.
-     */
-    private _relayout;
-    /**
-     * A hairline between stacked panes: on every pane but the one against the
-     * chart's top, whole device pixels tall, in the form `Pane.setSeparator`
-     * picks for the ratio the panes were laid out at. It sits on the DOM box,
-     * so it is exactly on the boundary the user drags.
-     */
-    private _syncSeparators;
-    /**
-     * The device pixel ratio pane boundaries are rounded at: the one the panes
-     * were last laid out at, so hit testing, `priceToCoordinate` and the DOM
-     * boxes agree even when the ratio has moved with no event to say so (a
-     * scale-only emulation, a browser with neither signal) until the next
-     * relayout. Before the first layout, the ratio now.
-     */
-    private _ratioForLayout;
-    /**
-     * Reserve the chart-wide axis columns: a left one as soon as any pane has a
-     * left price scale in use, and the right one unless every scale in use has
-     * moved off it. A chart with nothing on any scale keeps its right column,
-     * which is where an empty chart's ladder belongs; the columns are chart-wide
-     * rather than per pane because the panes share one time axis and their plots
-     * have to start and end at the same x.
-     */
-    private _recomputeAxisColumns;
-    private _measureAxisColumns;
-    /**
-     * The share of the chart a pane gets. While one pane is maximized it takes
-     * everything and the rest take nothing, so they lay out at zero height and
-     * are hidden outright rather than collapsed to a sliver. A sliver still
-     * paints a strip of squeezed candles and a separator hairline above the very
-     * pane the user asked to see on its own.
-     *
-     * Stored weights are never touched, so restoring is exact and `getState`
-     * cannot persist a placeholder.
-     */
-    private _layoutWeight;
-    /** First pane with a share of the chart: the one that sits against the top edge. */
-    private _topPaneIndex;
-    /**
-     * Last pane with a share of the chart: the one that owns the time axis, even
-     * as a strip, so the axis stays at the foot of the chart. `open` asks for the
-     * last one with a plot instead, which is where chart furniture belongs.
-     */
+    /** Stays on the chart by name: its callers here and tests read the bottom pane through it. */
     private _bottomPaneIndex;
-    /** Drawn as a strip right now: a maximized pane shows whole whatever it is set to. */
-    private _collapsedShown;
-    /** Grab tolerance around a pane boundary, in media px. */
-    private static readonly DIVIDER_GRAB;
-    /**
-     * The two panes a press at `y` resizes, or null. Boundary `i` separates pane
-     * `i` from pane `i + 1`; the last pane's bottom is the chart edge and is not
-     * draggable. A strip keeps its height, so a boundary beside one moves height
-     * between the nearest open panes either side of it. A pane hidden behind a
-     * maximized one is never a side: dragging it would rewrite a weight nobody
-     * can see.
-     */
-    private _dividerAt;
     /**
      * Set a pane's relative height weight. Panes share the chart height in
      * proportion to their weights, so only the ratio matters.
@@ -7121,16 +6796,6 @@ declare class Chart {
      * `options.force` is set.
      */
     removePane(index: number, options?: IndicatorEditOptions): boolean;
-    /**
-     * Keep the saved drawings' slots in step with a pane that moved or went,
-     * for the draw tier that has not loaded yet: it reads them from
-     * `drawingState()` whenever it arrives, and a stale slot would put a drawing
-     * on the wrong pane or recreate one that is gone. The slot is the draw
-     * tier's document and opaque here, so only its pane field is touched, on a
-     * copy, and a drawing on a removed pane goes with it, as the tier drops it.
-     * A tier that is listening writes its own document right after the event.
-     */
-    private _remapSavedDrawings;
     /**
      * Move a pane up or down one slot, swapping it with its neighbour.
      *
@@ -7168,8 +6833,6 @@ declare class Chart {
     setPrimaryPaneIndex(index: number): boolean;
     /** The primary pane's slot; 0 once the chart is torn down and there are no panes. */
     private _primaryIndex;
-    /** Slot of the pane holding the primary series, the price pane before there is one. */
-    private _firstPaneSlot;
     /**
      * Expand one pane to fill the chart, hiding the others. Calling it again (or
      * on another pane) puts the stack back exactly as it was, since the stored
@@ -7201,28 +6864,10 @@ declare class Chart {
     setPaneCollapsed(index: number, collapsed: boolean): boolean;
     /** Whether a pane is collapsed to its header strip. The primary price pane never is. */
     paneCollapsed(index: number): boolean;
-    /**
-     * Route a pane-legend button press. Ids look like `indicator:<instanceId>::close`.
-     * Returns true when the id was ours and was handled.
-     */
+    /** Stays on the chart by name: the pointer release and tests route a legend press through it. */
     private _handleLegendAction;
-    private _indicatorLegendHit;
-    /**
-     * Cumulative top + height of each pane: the source of truth for the DOM
-     * boxes, the canvases and hit-testing alike. A collapsed pane is a fixed
-     * strip one legend row tall, with the time axis under it when it is the
-     * bottom pane, and the open panes share what is left by weight, so folding
-     * one never rewrites a stored weight.
-     *
-     * Every boundary between panes sits on a device pixel (`alignToDevicePixels`)
-     * of the ratio the panes are laid out at (`_ratioForLayout`), so each canvas
-     * covers a whole number of device pixels and the separator gets rows of its
-     * own. It is done here rather than where the boxes are sized, so hit testing
-     * reads the same boxes the DOM shows.
-     */
+    /** Stays on the chart by name: its callers here and tests read the pane boxes through it. */
     private _paneLayout;
-    /** The layout by weight and strip height alone, before device-pixel rounding. */
-    private _paneShares;
     /**
      * Keyboard hints for the navigator tooltips, read from the live keymap so a
      * rebind shows up in the tooltip instead of a stale hardcoded string. The
@@ -7256,34 +6901,7 @@ declare class Chart {
      * switched timeframe mid-session has to follow within a screen of bars.
      */
     private _barCountdownOptions;
-    private _observeSize;
-    /** Start or stop reading a pane's canvases' device-pixel boxes. */
-    private _observeCanvases;
-    /**
-     * Give each canvas the backing store the browser says its box covers. A
-     * canvas that starts part way into a device pixel is snapped to one pixel
-     * more or fewer than `media x dpr`, and a store one pixel off is stretched
-     * over the box, blurring every line on it.
-     */
-    private _onDevicePixels;
-    private _canvasLayerOf;
-    /** The window the chart's document shows in, or null outside a browser. */
-    private _view;
-    /**
-     * Follow the device pixel ratio. It changes with no box changing size when
-     * the window moves to a screen of another density, and no size observer
-     * hears of that, so the canvases would stay at the old ratio, stretched and
-     * blurred. A resolution query matches the one ratio it was made for, so
-     * each change makes a new one for the ratio now in force.
-     *
-     * The window's `resize` is heard too: a zoom fires it, and it is the one
-     * signal left in a browser whose query list takes no change listener. It
-     * costs a comparison when the ratio has not moved.
-     */
-    private _watchPixelRatio;
-    private _unwatchPixelRatio;
     private readonly _onPixelRatio;
-    /** Size the canvases again if the ratio is no longer the one they were sized at. */
     private readonly _checkPixelRatio;
     /**
      * Run the pending frame now rather than on the next animation frame, for
@@ -7297,115 +6915,28 @@ declare class Chart {
      */
     private _paintNow;
     private _onFrame;
-    private _attachInput;
     private readonly _onPointerEnter;
-    /**
-     * The chart renders as stacked canvases, so the browser's right-click
-     * "Save image as…" would capture only the topmost (transparent overlay)
-     * layer — a blank image. Just before the native menu opens, composite the
-     * clicked pane's base layer *beneath* its overlay bitmap so the saved image
-     * is the visible chart, and freeze overlay repaints (live ticks repaint every
-     * few hundred ms and would wipe the snapshot while the menu is open). The
-     * freeze lifts on the next pointer/wheel/key input after the menu closes.
-     * Apps that present their own menu (preventDefault on contextmenu) are
-     * unaffected. Multi-pane note: the native save captures the clicked pane
-     * only — use `downloadScreenshot()` for the full multi-pane composite.
-     *
-     * A listener on the `contextmenu` **chart** event takes over entirely: it is
-     * told what was hit, and the snapshot is skipped, since the app is raising a
-     * menu of its own instead of the browser's.
-     */
     private readonly _onContextMenu;
-    /** Build the `contextmenu` payload: where the pointer is, and what it is over. */
-    private _contextMenuEvent;
-    /**
-     * Classify what the pointer is over. A canvas hands an app a pixel, not an
-     * object, so this is the part it cannot work out for itself, and the part
-     * that decides which menu items make sense.
-     */
-    private _contextTarget;
-    /** Vacant aligned cells have no scale target, even if a hidden scale exists. */
-    private _axisAt;
-    /**
-     * Which series the pointer sits on, if any. A pane is one bitmap, so "on the
-     * candle" has to be recomputed rather than looked up: take each series'
-     * autoscale extents for the bar under the cursor and test the band they span,
-     * with a few px of slack so a 1px line is still a target.
-     */
-    private _seriesAt;
-    /**
-     * The price under a pane-local y, for an event payload. Null on a strip: it
-     * plots nothing, so a price read off it would place a drawing, an alert or a
-     * pick somewhere nobody can see.
-     */
-    private _priceAt;
-    /** Resume overlay repaints after the native context menu closes. */
-    private _unfreezeOverlay;
-    private _localPoint;
-    /** Container media px to the pane under it and that pane's local y. */
-    private _project;
-    /**
-     * Every position a drag passed through since the previous move event, in
-     * the same space as the payload's `point`. The rect and layout are read once
-     * for the batch: a fast stroke coalesces several positions per frame, and
-     * each one going back to the DOM is layout work on the pointer path.
-     */
-    private _dragSamples;
-    /**
-     * Pointer facts for a click. Modifiers and device come from the release,
-     * pressure from the press: a release always reads 0, which would leave the
-     * field carrying nothing on any device.
-     */
-    private _clickInfo;
     private readonly _onPointerDown;
     private readonly _onPointerMove;
     private readonly _onPointerUp;
-    /**
-     * DOM pointerup entry point. Mirrors the primary-button guard in
-     * `_onPointerDown`: a right-click (or any non-primary mouse button) fires
-     * pointerdown *and* pointerup, but `_onPointerDown` ignores it — so the
-     * down state (`_downX`/`_downLocalY`/`_downPane`/`_pointerMoved`) is never
-     * refreshed and still holds the *previous* left-click. Letting a non-primary
-     * pointerup through would re-run the click branch against that stale position
-     * and replay the last click (e.g. re-firing a Buy/Sell button → a phantom
-     * order). Touch and pen tip contact use button 0. The internal
-     * recovery call from `_onPointerMove` invokes `_onPointerUp` directly, so it
-     * bypasses this filter and still ends a drag when a button release is missed.
-     */
     private readonly _onPointerUpNative;
     private readonly _onPointerCancel;
     private readonly _onLostPointerCapture;
-    /** The corner mark's hit at a container x and pane y, whatever else is there. */
-    private _brandingHit;
-    /**
-     * What the pointer is over on a pane, at a container x and pane y. The
-     * corner mark comes last: a note pinned over it, or anything else there,
-     * is what the user can see and means to grab, and the mark is only a link.
-     */
-    private _hitAt;
     private readonly _onPointerLeave;
     private readonly _onWheel;
-    /** One zoom step, applied now. Shared by the instant path and each glide frame. */
-    private _applyZoom;
-    private _startZoomGlide;
-    private _beginAutoscaleMotion;
-    private _stopNavigationMotion;
-    private _stopZoomGlide;
+    private readonly _onDblClick;
+    private readonly _onKeyDown;
+    /** Stays on the chart by name: the navigator's buttons and tests run a command through it. */
+    private _runShortcut;
+    /** Stays on the chart by name, for the frame and for tests; the pointer handlers set it. */
+    private get _cursor();
     /**
      * Restore the preferred visible bar count and re-enable
      * auto-scaling on every price axis (undoing any pan/zoom or manual axis drag).
      * Same as double-clicking the chart.
      */
     resetScale(): void;
-    private readonly _onDblClick;
-    private _beginPinch;
-    private _updatePinch;
-    private _cancelPrimitiveDrag;
-    private readonly _onKeyDown;
-    /** Scope gating: hover keeps keys chart-local; global always acts. */
-    private _shortcutsActive;
-    /** Execute a built-in command; returns false for unknown (custom) commands. */
-    private _runShortcut;
     /**
      * Composite the full chart (all panes + overlays) and trigger a PNG download.
      * This is what the screenshot keyboard shortcut runs; call it from a toolbar
@@ -7415,23 +6946,9 @@ declare class Chart {
     downloadScreenshot(filename?: string): void;
     /** Refresh the polite live-region summary screen readers announce. */
     private _updateAccessibleSummary;
-    /**
-     * Track the primitive under the pointer: apply its cursor hint to the
-     * container and repaint on hover enter/leave so lines/pills can render
-     * hover states (they read `hoverId` off the render context).
-     */
-    private _setHover;
-    private _updateCursor;
     private _maybeLoadHistory;
-    /**
-     * Coast after a flick. Runs on the INJECTED scheduler, not the global
-     * requestAnimationFrame: a host that supplies its own raf expects to own
-     * every frame this chart schedules, and reaching past it also made the
-     * glide untestable, which is why the missing pan event on each frame went
-     * unnoticed until a browser drove it.
-     */
+    /** Stays on the chart by name: the pointer release and tests start a glide through it. */
     private _startKinetic;
-    private _stopKinetic;
     /**
      * True once `destroy()` has run. Anything holding a chart it did not create
      * (a link group, a controller, a host cache) needs to know the object is a