@luxalgo/vela 0.5.0

package/dist/widget.d.ts

@@ -0,0 +1,799 @@
+import { W as WidgetContext, V as Vela, y as SidePanelButton } from './contributions-hX3EUyjG.js';
+export { ah as DEFAULT_PANEL_ORDER, z as SidePanelDescriptor, A as SidePanelHandle, U as WidgetActionDescriptor, X as WidgetActionTarget, Y as WidgetAttachment, a4 as registerSidePanel, a5 as registerWidgetAction, a6 as registerWidgetAttachment, a8 as sidePanels, ac as unregisterSidePanel, ad as unregisterWidgetAction, ae as unregisterWidgetAttachment, af as widgetActions, ag as widgetAttachments } from './contributions-hX3EUyjG.js';
+import { b as VelaOptions, q as DataWindowReadout } from './options-Q-576hIi.js';
+import { K as KeymapManager } from './keymap-CGOz5F5f.js';
+import { W as WidgetHistory, b as VelaShellOptions, e as WorkspaceState, a as RangePreset, i as PersistedState, P as PanelsState } from './history-Dzxz-MQj.js';
+export { B as Bottombar, j as BottombarOptions, C as CellState, f as ChartState, I as IndicatorLoader, k as IndicatorManifest, l as IndicatorManifestEntry, m as RANGE_PRESETS, R as ResolvedIndicator, V as VelaStorage, n as WidgetStorage, g as decodeState, h as encodeState, o as legacyWidgetState, p as loadPersisted, q as localStorageAdapter, r as parsePersisted, t as resolveIndicators, s as sanitizeState, u as savePersisted } from './history-Dzxz-MQj.js';
+import { a as SymbolDescriptor } from './DataProvider-Dzd-Erlk.js';
+import { d as SidePanel } from './side-panel-CT9ZwIGz.js';
+export { D as DEFAULT_PANEL_MAX_WIDTH, a as DEFAULT_PANEL_MIN_WIDTH, b as DEFAULT_PANEL_WIDTH, S as SidePanelOptions, c as clampPanelWidth } from './side-panel-CT9ZwIGz.js';
+
+interface VelaWidgetOptions extends VelaOptions, VelaShellOptions {
+    /** Mirror symbol/timeframe/style/timezone in the URL query (shareable links). A URL
+     *  param wins over persisted state at load. Default false. */
+    urlState?: boolean;
+}
+declare class VelaWidget {
+    readonly root: HTMLElement;
+    /** The shortcut system — widget modules and plugins register their bindings here. */
+    readonly keymap: KeymapManager;
+    private readonly opts;
+    private readonly chartHost;
+    private readonly topbar;
+    private readonly statusline;
+    private readonly watermark;
+    private readonly bottombar;
+    private readonly objectTree;
+    private readonly dataWindow;
+    /** The side-panel column: the two panels above, plus every contributed one. */
+    private readonly dock;
+    private shortcutsHelp;
+    private readonly contextMenu;
+    private readonly symbolPicker;
+    private readonly indicatorPicker;
+    private readonly tfQuick;
+    private inner;
+    /** The manifest library (loaded once). */
+    private manifest;
+    /** Live instances — the SAME entry may be added several times. */
+    private instances;
+    /** Native-indicator catalog of the CURRENT chart (refreshed per rebuild/change). */
+    private nativeCatalog;
+    /** Present native types, mirrored SYNC from the chart (see syncPresentNatives). */
+    private presentNatives;
+    private readonly storageKey;
+    private readonly storage;
+    private openDialogs;
+    private readonly onRootKeydown;
+    private symbol;
+    private timeframe;
+    private priceStyle;
+    private timezone;
+    private bars;
+    private watermarkOn;
+    /** Indicator titles (the in-chart legend rows) shown — reapplied across rebuilds. */
+    private indicatorTitlesOn;
+    private pendingRange;
+    /** Symbol already reported as unservable (the core re-reports on every index settle). */
+    private unresolvedToasted;
+    /** Extra fetch depth the ACTIVE range chip needs — a view concern, kept apart from the
+     *  user's own `bars` setting so a preset never overwrites their preference. */
+    private rangeBars;
+    private toast;
+    private alerts;
+    private alertsMenu;
+    private readonly glider;
+    /** Unified app+drawings undo timeline (Ctrl+Z / Ctrl+Y). Late-resolves the CURRENT
+     *  inner chart so steps recorded before a rebuild never act on a destroyed instance. */
+    readonly history: WidgetHistory;
+    private lastCrossPrice;
+    private lastCrossTime;
+    /** Renderer cosmetic template carried across rebuilds (and persisted when enabled). */
+    private savedConfig;
+    /** User-drawings document carried across rebuilds (and persisted when enabled). */
+    private savedDrawings;
+    /** A restored indicator ledger waiting for the manifest to resolve. */
+    private pendingIndicators;
+    /** Volume presence decided by a RESTORED ledger (null = follow the option). */
+    private ledgerVolume;
+    /** The manifest can no longer change the instance set: it resolved, or no `indicators`
+     *  option exists so nothing will ever resolve. Gates the ledger's pending fallback —
+     *  once settled, a live empty set means "the user removed everything" and persists so. */
+    private manifestSettled;
+    /** The volume auto-add rides the first candles (`load:end`); until then the registry
+     *  can't show it and the persisted ledger reports the INTENT instead. */
+    private volumeMayBePending;
+    /** True when the boot state came from the LEGACY three-key layout — the first
+     *  unified save then drops the old `:config`/`:drawings` sub-keys. */
+    private legacyKeys;
+    private stateTimer;
+    private readonly stateListeners;
+    /** Favorite drawing-tool types — mirrored from chart events, reapplied on rebuilds. */
+    private favs;
+    /** Mounted attachment disposers (by id), torn down at destroy. */
+    private readonly attachmentDisposers;
+    private readonly onUnload;
+    private indicatorsPromise;
+    private destroyed;
+    private buildSeq;
+    constructor(container: HTMLElement | string, opts: VelaWidgetOptions);
+    /** Mount registered attachments not yet mounted on this widget (idempotent per id). */
+    private mountAttachments;
+    /** The context handed to contributed actions (see `registerWidgetAction`). */
+    context(): WidgetContext;
+    /** The recent engine alerts (topbar bell). */
+    private openAlertsMenu;
+    /** Re-project contributed topbar actions and side panels (after late registrations). */
+    refreshActions(): void;
+    /** The inner headless chart of the CURRENT build — becomes a new instance after a
+     *  symbol/timeframe change; don't cache it across awaits. */
+    get chart(): Vela;
+    /** Chrome that must follow the timeframe wherever it changes from (menu, quick entry,
+     *  range chip, API). Keeping it in one place is what stopped the status line from
+     *  drifting out of sync with the topbar. */
+    private syncTimeframeChrome;
+    /**
+     * The provider name to show: the one that RESOLVED the symbol, not the one configured.
+     * They differ whenever the `provider` option is just a default (or names something that
+     * isn't registered) — the status line must not claim a venue that served nothing.
+     */
+    private providerLabel;
+    setTimeframe(tf: string): void;
+    /**
+     * Switch the chart symbol in place. An `EXCHANGE:` prefix pins the venue (the
+     * symbol picker composes one from the row the user pointed at) — a bare ticker
+     * resolves against the registered providers in declaration order.
+     */
+    setSymbol(symbol: string): void;
+    /**
+     * Snapshot the COMPLETE widget state as the unified shell document — the SAME
+     * format `VelaWorkspace.getState()` returns, with a single `c1` cell: market,
+     * display prefs, the renderer config document, the user-drawings document, and
+     * the indicator ledger. This is what `persist` writes; hosts build custom flows
+     * on it (server snapshots, share links, templates) — and a saved widget state
+     * drops into a workspace slot as-is.
+     */
+    getState(): WorkspaceState;
+    /**
+     * Restore a state document produced by {@link getState} — or by a WORKSPACE (the
+     * first cell of a multi-cell document applies). Untrusted-safe: malformed fields
+     * are dropped. Applied IN PLACE: the chart instance survives (market switches via
+     * `setMarket`), config/drawings/indicators are replaced. With `urlState` enabled,
+     * URL params still win over the document's market/prefs fields.
+     */
+    applyState(state: unknown): void;
+    /** Subscribe to `state:changed` — the persistable state changed (debounced ~500ms);
+     *  re-pull {@link getState}. Returns an unsubscribe function. */
+    on(event: 'state:changed', handler: () => void): () => void;
+    /** Replace the indicator ledger: natives converge to the listed set (volume
+     *  included — removing it sticks, the core's auto-add respects the opt-out),
+     *  manifest instances are re-created by name — held until the manifest resolves. */
+    private applyIndicatorLedger;
+    /** SYNC boot fallback: a LEGACY three-key payload read at construction. */
+    private bootLegacySync;
+    /** ASYNC boot: resolve the unified document (or migrate a legacy payload), then
+     *  late-apply it — the widget built with option defaults in the meantime. */
+    private bootAsync;
+    /** Show/hide the symbol watermark behind the chart (persisted). */
+    setWatermarkVisible(visible: boolean): void;
+    /** Show/hide the indicator titles — the in-chart legend rows (persisted). */
+    setIndicatorTitlesVisible(visible: boolean): void;
+    /** Applied LIVE (renderer feature) — no rebuild; persists across rebuilds. */
+    setPriceStyle(style: string): void;
+    /** OHLC/change ink in the status line follows the ACTIVE price style's configured
+     *  colors and direction rule (candle bodies by close-vs-open, baseline by position
+     *  against the live baseline price, …) instead of the fixed theme tokens. */
+    private syncStatuslineColors;
+    /** The widget shell (topbar, panels) keeps the app theme; the chart host's tokens
+     *  re-derive from the LIVE plot surface (see {@link applyPlotOverlayTokens}). */
+    private syncPlotOverlayTokens;
+    /**
+     * Swap the widget theme at runtime — `'dark'`, `'light'`, or a full custom theme.
+     * Applied LIVE: the inner chart re-skins through `Vela.setTheme` and its
+     * `theme:changed` event re-tokens the widget chrome (topbar, menus, panels) in
+     * place; the choice also persists into rebuilds. Same switch the user reaches from
+     * chart settings → Canvas → Theme.
+     */
+    setTheme(theme: NonNullable<VelaOptions['theme']>): void;
+    /** Applied LIVE (renderer feature) — no rebuild; persists across rebuilds. */
+    setTimezone(zone: string): void;
+    /**
+     * Range chip: switch to the preset's timeframe, fetch enough history for its window,
+     * and frame it once ready. The in-place `setMarket` loads the depth, so it also runs
+     * when only the DEPTH grows (same timeframe, deeper window).
+     */
+    applyRange(preset: RangePreset): void;
+    destroy(): void;
+    /** Destroy + recreate the inner chart with the current symbol/timeframe, then
+     *  re-register providers/engines, rebind chrome, and re-add manifest indicators. */
+    private rebuild;
+    /** Refresh the native catalog (supported/present flags) for the current chart. */
+    private refreshNativeCatalog;
+    /** Add a native indicator (single-instance per type — the core dedupes). */
+    private addNative;
+    private removeNative;
+    /** Sync mirror of the chart's present native types — the removal handler diffs
+     *  against it to identify (and record) whichever type was just removed. */
+    private syncPresentNatives;
+    /** Add ONE instance of a manifest entry (repeatable — duplicates are legitimate). */
+    private addInstance;
+    /** Remove one live instance (picker trash). */
+    private removeInstance;
+    private dropInstance;
+    private syncIndicatorCount;
+    private addToChart;
+    /** Bare-typing router: letters → symbol search (seeded), digits → timeframe entry. */
+    private routeTyping;
+    private trackDialog;
+    private downloadScreenshot;
+    /** The persistable state changed: debounce (~500ms), then notify `state:changed`
+     *  listeners and flush — the same cadence as the workspace. */
+    private markStateDirty;
+    /** Write the unified state document through the adapter (persist mode only) — also
+     *  the unload/destroy flush. The first save after a LEGACY boot rewrites the main
+     *  key in the unified format and drops the old `:config`/`:drawings` sub-keys. */
+    private persistNow;
+}
+
+declare function priceStyleLabel(id: string): string;
+interface TopbarOptions {
+    symbol: string;
+    onSymbolClick?: () => void;
+    timeframe: string;
+    timeframes: readonly string[];
+    priceStyle: string;
+    onTimeframe: (tf: string) => void;
+    onPriceStyle: (style: string) => void;
+    /** Optional workspace LAYOUT dropdown (rendered after the style dropdown when given).
+     *  `options` is read live, so plugin-registered layouts appear automatically. */
+    layout?: {
+        current: string;
+        options: () => Array<{
+            id: string;
+            label: string;
+        }>;
+        onSelect: (id: string) => void;
+        /** Optional TOGGLE rows appended under the layout presets (e.g. the workspace's
+         *  "Sync crosshair"). Re-read on every open/refresh; `onToggle` flips one. */
+        toggles?: () => Array<{
+            id: string;
+            label: string;
+            checked: boolean;
+        }>;
+        onToggle?: (id: string) => void;
+    };
+    onIndicatorsClick?: () => void;
+    /** Unified undo/redo (same stack as Ctrl+Z / Ctrl+Y). Enabled state is pushed with
+     *  {@link Topbar.setHistoryState}. */
+    onUndoClick?: () => void;
+    onRedoClick?: () => void;
+    onScreenshotClick?: () => void;
+    onAlertsClick?: (anchor: HTMLElement) => void;
+    /** Live widget context for contributed actions (topbar target). */
+    getContext?: () => WidgetContext;
+}
+declare class Topbar {
+    readonly el: HTMLElement;
+    private readonly symbolEl;
+    private readonly tfButton;
+    private readonly styleButton;
+    private layoutButton;
+    private layoutMenu;
+    private layoutId;
+    private readonly tfMenu;
+    private readonly styleMenu;
+    private readonly tooltips;
+    private readonly actionsHost;
+    /** The side-panel toggle group — filled by the dock through {@link setPanelButtons}. */
+    private readonly panelsHost;
+    private undoBtn;
+    private redoBtn;
+    private alertsBtn;
+    private panelBtns;
+    private panelTooltips;
+    private readonly host;
+    private alertsBadge;
+    private readonly opts;
+    private timeframe;
+    private priceStyle;
+    private readonly onHairlineSync;
+    private hairlineRo;
+    private hairlineRaf;
+    constructor(host: HTMLElement, opts: TopbarOptions);
+    setSymbol(symbol: string): void;
+    setTimeframe(tf: string): void;
+    setPriceStyle(style: string): void;
+    /** Reflect the current workspace layout (no-op without the layout dropdown). */
+    setLayout(id: string): void;
+    private renderLayoutButton;
+    private layoutItems;
+    private renderStyleButton;
+    /** Re-project the contributed topbar actions (call after registrations change). */
+    renderActions(): void;
+    setIndicatorCount(_n: number): void;
+    /** Enable/disable the undo and redo tools from the host's unified history. */
+    setHistoryState(canUndo: boolean, canRedo: boolean): void;
+    setAlertCount(n: number): void;
+    /**
+     * Replace the side-panel toggle group — one icon button per docked panel, in the dock's own
+     * order. The dock calls this whenever its panel set changes (built-ins at construction,
+     * contributed panels on every `refreshActions()`), then pushes each pressed state.
+     */
+    setPanelButtons(buttons: readonly SidePanelButton[], onClick: (id: string) => void): void;
+    /** Reflect a docked side panel's open state on its button — the panels toggle each other,
+     *  so the dock pushes the state rather than the button assuming it. */
+    setPanelActive(id: string, open: boolean): void;
+    destroy(): void;
+    /** One icon-only tool button with its kit tooltip, parked in `sink` for disposal. */
+    private toolButton;
+    /** Paint each `.vela-sep` as exactly one device pixel, snapped to the pixel grid. */
+    private syncHairlines;
+    private tfItems;
+    private styleItems;
+}
+
+/** How the status line reads a bar out: the four O/H/L/C values (bar-shaped styles),
+ *  or the single plotted value — the close — for one-line styles (line/area/baseline). */
+type StatuslineReadout = 'ohlc' | 'value';
+/** The market session states the status badge can wear. Crypto venues trade
+ *  continuously and stay 'open'; the full vocabulary is ready for providers that
+ *  carry a session model (equities RTH/ETH, exchange holidays). */
+type MarketStatus = 'open' | 'pre' | 'post' | 'closed' | 'holiday';
+declare class Statusline {
+    private readonly host;
+    readonly el: HTMLElement;
+    private readonly ohlcEl;
+    private readonly changeEl;
+    private readonly symbolEl;
+    private readonly marketEl;
+    private marketTip;
+    private avatarEl;
+    private metaEl;
+    private readonly parts;
+    private lastBar;
+    private hoverBar;
+    private unsubs;
+    /** Up/down ink for the OHLC + change values — the ACTIVE price style's configured
+     *  colors (candle bodies, bar ticks, the line color, …); null falls back to the theme
+     *  tokens. `isUp` overrides the close-vs-open direction rule where the style paints by
+     *  something else (baseline: position against the baseline price). */
+    private upColor;
+    private downColor;
+    private isUp;
+    /** 'ohlc' for bar-shaped styles; 'value' (the single plotted close) for line styles. */
+    private readout;
+    constructor(host: HTMLElement, symbol: string);
+    setSymbol(symbol: string): void;
+    /** Shape + color the value readout after the active price style: its own up/down
+     *  colors (candle bodies, bar ticks, the line color, …), the direction rule that
+     *  picks between them (`isUp` replaces close-vs-open where the style paints by
+     *  something else — baseline by position), and whether the readout is the four
+     *  O/H/L/C values or the single plotted value (one-line styles). Null colors fall
+     *  back to the theme's up/down tokens. See {@link statuslineInkOf}, which derives
+     *  all of it from the live renderer. */
+    setDirectionColors(up: string | null, down: string | null, isUp?: ((bar: {
+        open: number;
+        close: number;
+    }) => boolean) | null, readout?: StatuslineReadout): void;
+    /** Show/hide one part (the settings dialog's Status line tab drives these). */
+    /** The "· BINANCE · 1h" segment after the symbol — venue first, then resolution. */
+    setMeta(timeframe: string, provider: string): void;
+    /** Dress the market badge for a session state: its icon, tinted circle, and the
+     *  hover label. Callers with no session model leave the constructor's 'open'. */
+    setMarketStatus(status: MarketStatus): void;
+    setPartVisible(part: 'name' | 'market' | 'ohlc' | 'change', visible: boolean): void;
+    partVisible(part: 'name' | 'market' | 'ohlc' | 'change'): boolean;
+    /** (Re)bind to a chart instance — called after every widget rebuild. */
+    onChart(chart: Vela): void;
+    destroy(): void;
+    private detach;
+    private render;
+}
+
+declare class Watermark {
+    readonly el: HTMLElement;
+    constructor(host: HTMLElement, symbol: string, timeframe: string);
+    setVisible(visible: boolean): void;
+    update(symbol: string, timeframe: string): void;
+    destroy(): void;
+}
+
+/**
+ * Rank: ticker prefix > ticker substring > description substring > venue-name substring (typing
+ * `binance` surfaces that venue's symbols after any literal matches). An optional venue prefix
+ * (see {@link parseQuery}) scopes the pool first — venue alone browses it whole, alphabetically.
+ * Pure — unit-tested.
+ */
+declare function filterSymbols(list: readonly SymbolDescriptor[], query: string, limit?: number): SymbolDescriptor[];
+interface SymbolPickerOptions {
+    /** `provider` is the venue of the chosen row — absent only for a source that has none. */
+    /** Called with the CHOSEN symbol — `EXCHANGE:`-prefixed when the row named a venue,
+     *  so the selection pins the venue the user actually pointed at. */
+    onSelect: (symbol: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    host?: HTMLElement;
+}
+declare class SymbolPicker {
+    private readonly dialog;
+    private readonly input;
+    private readonly list;
+    private source;
+    private rows;
+    private highlighted;
+    private seed;
+    private activeTab;
+    private tabs;
+    constructor(opts: SymbolPickerOptions);
+    /** Wire where symbols come from (re-called on every widget rebuild). */
+    setSource(source: () => readonly SymbolDescriptor[]): void;
+    open(initialQuery?: string): void;
+    close(): void;
+    destroy(): void;
+    private select;
+    private moveHighlight;
+    private renderHighlight;
+    private refresh;
+}
+
+interface IndicatorRow {
+    name: string;
+    language?: string;
+    category?: string;
+    /** Core-computed (native) indicator — accent styling + 'native' routing. */
+    native?: boolean;
+    /** Native type id (routing key for add/remove). */
+    nativeType?: string;
+    /** Beta badge (native catalog flag). */
+    beta?: boolean;
+}
+interface IndicatorPickerOptions {
+    /** The manifest library — clicking a row ADDS an instance (repeatable). */
+    library: () => readonly IndicatorRow[];
+    /** The live instances on the chart — the trash removes one. */
+    onChart: () => readonly IndicatorRow[];
+    onAdd: (libraryIndex: number) => void;
+    onRemove: (instanceIndex: number) => void;
+    onOpenChange?: (open: boolean) => void;
+    host?: HTMLElement;
+}
+declare class IndicatorPicker {
+    private readonly dialog;
+    private readonly list;
+    private readonly search;
+    private readonly opts;
+    private isOpen;
+    constructor(opts: IndicatorPickerOptions);
+    open(): void;
+    /** Re-render the lists if the dialog is open (async catalog updates land late). */
+    sync(): void;
+    close(): void;
+    destroy(): void;
+    private refresh;
+}
+
+interface TimeframeQuickOptions {
+    onApply: (canonical: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    host?: HTMLElement;
+}
+declare class TimeframeQuick {
+    private readonly dialog;
+    private readonly input;
+    private readonly hint;
+    constructor(opts: TimeframeQuickOptions);
+    open(seed?: string): void;
+    close(): void;
+    destroy(): void;
+    private renderHint;
+}
+
+declare function readUrlState(search: string): PersistedState;
+declare function writeUrlState(state: PersistedState): void;
+
+/** What the dock needs from whatever chrome shows its toggles. */
+interface PanelChrome {
+    /** Replace the panel toggle group (dock order). `onClick` receives the panel id. */
+    setPanelButtons(buttons: readonly SidePanelButton[], onClick: (id: string) => void): void;
+    /** Reflect one panel's open state on its button. */
+    setPanelActive(id: string, open: boolean): void;
+}
+interface PanelDockDeps {
+    chrome: PanelChrome;
+    /** Live widget context, handed to contributed panels' `mount`. */
+    context(): WidgetContext;
+    /** The dock's persistable state changed (open panel, or a width). */
+    changed?(): void;
+}
+/** A panel the SHELL owns and destroys — the dock only docks it. */
+interface BuiltInPanel {
+    id: string;
+    title: string;
+    icon: string;
+    order: number;
+    panel: SidePanel;
+    /** Rebind hook, called by {@link PanelDock.onChart}. */
+    onChart?(chart: Vela): void;
+}
+declare class PanelDock {
+    private readonly host;
+    private readonly deps;
+    private readonly entries;
+    /** Widths the USER settled, by panel id — the only ones worth persisting. */
+    private readonly widths;
+    /** A restored `open` naming a panel that has not registered yet: honored when it docks. */
+    private pendingOpen;
+    private chart;
+    constructor(host: HTMLElement, deps: PanelDockDeps);
+    /** Dock a panel the shell owns (created and destroyed by it). */
+    addBuiltIn(entry: BuiltInPanel): void;
+    /**
+     * (Re)build the CONTRIBUTED panels from the registry — call once after the built-ins, and
+     * again on `refreshActions()` so a late registration appears. Contributed panels that are
+     * gone from the registry are dropped; the ones still there are rebuilt, so a replaced
+     * descriptor takes effect.
+     */
+    refresh(): void;
+    /** Bind (or rebind) every docked panel to a chart instance. */
+    onChart(chart: Vela): void;
+    /** Open/close one panel by id — a bare call flips it. Unknown ids are ignored. */
+    toggle(id: string, open?: boolean): void;
+    /** The open panel's id, or null when the column is closed. */
+    get openId(): string | null;
+    /** The dock's persistable state, or null when there is nothing worth saving. */
+    getState(): PanelsState | null;
+    /**
+     * Restore a persisted dock state. Widths apply to any panel present, and are remembered for
+     * panels that register later; `open` opens that panel, and its absence closes the column —
+     * a document that predates the dock has no `panels` field at all, so the shell never calls
+     * this and the default (everything closed) stands. An `open` naming a panel that has not
+     * registered yet is held until it docks (a plugin loaded after the restore), unless the user
+     * opens something in the meantime.
+     */
+    applyState(state: PanelsState | undefined): void;
+    /** Drop the contributed panels (the shell destroys its own). */
+    destroy(): void;
+    private add;
+    private drop;
+    /** Push the current toggle group to the chrome, pressed states included. */
+    private publish;
+}
+
+declare class ObjectTree extends SidePanel {
+    private chart;
+    private selectedDrawing;
+    private symbolName;
+    /** Drawing bundles — a view-side grouping, held for the panel's lifetime and never persisted.
+     *  Kept per chart because a workspace points this one panel at whichever chart is active, and
+     *  each chart's bundles have to survive the switch. */
+    private readonly groupsPerChart;
+    /** Group ids currently folded shut. Ids are never reused, so entries left behind by a group
+     *  that is gone are inert and can outlive it. */
+    private collapsed;
+    /** Drawings picked IN THE PANEL — what the selection bar and "group selection" act on. */
+    private picked;
+    /** The group showing its rename field, if any. */
+    private renaming;
+    /** Set while the panel pushes its pick to the chart, so the `drawing:selected` that comes
+     *  back is recognised as our own echo instead of a fresh chart-side selection. */
+    private syncingSelection;
+    private groupSeq;
+    private unsubs;
+    private get groups();
+    private set groups(value);
+    /** The last render's model, kept so a right-click reads the same state the rows show. */
+    private pass;
+    private menu;
+    private menuActions;
+    private drag;
+    constructor(host: HTMLElement);
+    toggle(open?: boolean): void;
+    setSymbol(symbol: string): void;
+    /** (Re)bind to a chart instance — called after every widget rebuild. */
+    onChart(chart: Vela): void;
+    destroy(): void;
+    private detach;
+    /** Read the chart into the layout's input. Every chart query happens here, once a pass. */
+    private snapshot;
+    /**
+     * Repaint because something changed — unless the panel is mid-interaction. A live drag
+     * resolves drops against the rows as currently rendered, and a rename lives in an input
+     * that a repaint would destroy mid-word. Both end by painting themselves.
+     */
+    private refresh;
+    private render;
+    /** What the panel itself can do to the selected drawings: bundle them into a group, or
+     *  duplicate all of them. Always in place, dim until there is a selection to act on. */
+    private selectionBar;
+    /** The band between two pane blocks. With re-paning available it is a drop zone that opens
+     *  a fresh pane there; otherwise it is just the separator. `before`/`after` name the panes
+     *  it sits between (either end is open at the edges of the list). */
+    private gapEl;
+    /**
+     * A pane, read top to bottom as front to back: ONE column holding its drawings, its
+     * indicators and (in the main pane) the candles, in draw order. Every child of the stack
+     * element is one slot, so a drop position is read straight off the rendered geometry.
+     */
+    private paneBlock;
+    /** One top-level drawing entry: a lone drawing's row, or a group block — its header plus,
+     *  unfolded, a member row for each drawing it holds. */
+    private unitEl;
+    /** The pane's name plus its ops: a study pane can move in the stack and collapse; every
+     *  pane can be maximized. */
+    private paneHead;
+    private rowEl;
+    /** A group's header: fold arrow, its name (or the rename field), then actions that apply to
+     *  every member at once. Reports "all hidden"/"all locked" rather than a mixed state.
+     *
+     * The state comes from the whole bundle, not from the members listed under this pane: should
+     * a member end up on another pane, the header still speaks for the group its actions affect.
+     */
+    private groupRow;
+    private drawRow;
+    /** Clicking a drawing picks it; holding the platform's modifier extends the pick, and
+     *  clicking the only picked row clears it. The chart mirrors whatever comes out. */
+    private onDrawClick;
+    /** Push the panel's pick onto the chart, muting the `drawing:selected` echo it causes. */
+    private selectOnChart;
+    /** The shared row shell: icon, name, optional tag, then the action buttons. */
+    private row;
+    private btn;
+    /** Bundle drawings into a fresh group, which takes over the pick. */
+    private makeGroup;
+    private commitRename;
+    /** Dissolve a group. `withMembers` also deletes the drawings it held. */
+    private removeGroup;
+    /** Apply one patch to every member of a group as a single undo step. */
+    private setMembers;
+    /** Duplicate a drawing, keeping the copy in the same group as its original — the chart has
+     *  no notion of our groups, so the new id has to be spotted and filed here. */
+    private cloneInto;
+    private onPointerDown;
+    private onDragMove;
+    private beginDrag;
+    /** The rendered row a session started from — scanned rather than selected, so an id
+     *  carrying CSS-special characters needs no escaping. */
+    private sourceRow;
+    /** What a drop at this point would do. Measured off the live geometry, which is why a
+     *  refresh is suspended for the duration of the drag. */
+    private resolveDrop;
+    private paintDropHint;
+    /** Close the session out: `apply` false abandons the move (a cancelled pointer, a teardown). */
+    private endDrag;
+    private applyDrop;
+    /**
+     * Land a drop in a pane's stack: place the dragged tokens (the candles, an indicator, a
+     * drawing, or a group's whole run of drawings) at the measured position, then renormalize
+     * the pane's z keys in one sweep — `candleZOrder`/`seriesOrder` for the series, a single
+     * `updateMany` (one undo step) for the drawings, re-paning the ones that crossed panes.
+     */
+    private applySlotDrop;
+    /** Renormalize one pane's z keys from a placed token stack: the series through the
+     *  renderer's order settings, the drawings as ONE `updateMany` (a single undo step),
+     *  re-paning the dragged ones that arrived from another pane. */
+    private writeStack;
+    /** Move a group's whole run to an end of its pane's stack — the menu twin of dragging it
+     *  to the top or the bottom of the column. */
+    private restackGroup;
+    /** The drawings a session moves: a group carries every member, front-most first, so the
+     *  bundle keeps its own stacking wherever it lands. */
+    private draggedDrawings;
+    private onContextMenu;
+    private itemsForRow;
+    /** The nearest kit host, which is where anything floating has to mount: outside it the
+     *  theme's custom properties don't resolve and the surface renders unstyled. */
+    private uiHost;
+    /** The menu, built on first use — by then the panel is mounted, so the theme host resolves. */
+    private ensureMenu;
+    private findIndicatorRow;
+    private priceMenu;
+    /** The pane's stacking extremes as of now — what a front/back command has to beat. The z
+     *  keys are plain numbers, not commands, so the writer beats the extremes itself; with a
+     *  shared draw-order space the drawings' keys count too. */
+    private stackBounds;
+    private indicatorMenu;
+    /** "Move to …" entries for an indicator — only the moves that would change something. */
+    private moveItems;
+    private drawingMenu;
+    /** The grouping half of a drawing's menu: what it can do about the bundle it is (or isn't)
+     *  part of. Only the moves that mean something for this row are offered. */
+    private groupingItems;
+    private groupMenu;
+    /** Forget everything that refers to a drawing or group the chart no longer has — otherwise a
+     *  deleted drawing would keep a group alive, or stay counted in the selection bar. */
+    private prune;
+}
+
+/** One readout line. `color` empty ⇒ the value inherits the panel's text color. */
+interface DataWindowLine {
+    label: string;
+    value: string;
+    color: string;
+}
+/** A titled block of readout lines. */
+interface DataWindowSection {
+    title: string;
+    lines: DataWindowLine[];
+}
+/**
+ * Lay a readout out as sections: the bar's Time, its Price block (tinted with the bar's
+ * direction), then one section per indicator with a line per plot in the plot's own color.
+ * Empty when the chart holds no bar to read.
+ */
+declare function dataWindowSections(readout: DataWindowReadout): DataWindowSection[];
+declare class DataWindow extends SidePanel {
+    private chart;
+    private unsubs;
+    constructor(host: HTMLElement);
+    toggle(open?: boolean): void;
+    /** (Re)bind to a chart instance — called after every widget rebuild. */
+    onChart(chart: Vela): void;
+    destroy(): void;
+    private detach;
+    private refresh;
+}
+
+declare class ShortcutsHelp {
+    private readonly dialog;
+    private readonly list;
+    private readonly keymap;
+    constructor(keymap: KeymapManager, host?: HTMLElement, onOpenChange?: (open: boolean) => void);
+    open(): void;
+    close(): void;
+    destroy(): void;
+    private refresh;
+}
+
+interface ContextMenuCallbacks {
+    /** Reset the view (all history, autoscale back on). */
+    resetView: () => void;
+    /** The display timezone the host holds (the time-axis menu checks it). */
+    timezone?: () => string;
+    /** Switch the display timezone through the host, so its own chrome follows. */
+    setTimezone?: (zone: string) => void;
+    /** Live widget context for contributed `context:*` actions. */
+    getContext?: () => WidgetContext;
+}
+declare class ChartContextMenu {
+    private readonly cbs;
+    private readonly menu;
+    private readonly host;
+    private chart;
+    private lastZone;
+    /** The pane whose scale the open price-axis menu targets (null ⇒ the main scale). */
+    private lastPane;
+    private readonly onContextMenu;
+    constructor(host: HTMLElement, cbs: ContextMenuCallbacks);
+    /** (Re)bind to a chart instance — called after every widget rebuild. */
+    onChart(chart: Vela): void;
+    destroy(): void;
+    private zoneOf;
+    /** The pane under the pointer, so every pane's price scale has its own menu. */
+    private paneAt;
+    private flag;
+    private contributed;
+    private itemsFor;
+    private run;
+}
+
+interface ParsedTimeframe {
+    valid: boolean;
+    count?: number;
+    unit?: string;
+    ms?: number;
+    /** What the chart consumes ("180" for 3h). */
+    canonical?: string;
+    /** Human line ("3 months"). */
+    label?: string;
+    /** Compact chip ("3M"). */
+    short?: string;
+}
+/** Parse a typed timeframe string. `valid` is false for empty/garbage input (count ≥ 1). */
+declare function parseTimeframe(text: string): ParsedTimeframe;
+/** Duration in ms of an existing timeframe value (`1`, `60`, `4h`, `D`, `W`, …), NaN if unknown. */
+declare function timeframeMs(value: string): number;
+/** Compact display label for any timeframe value ("60" → "1h", "D" → "1D"). */
+declare function timeframeLabel(value: string): string;
+
+interface TimezoneEntry {
+    value: string;
+    label: string;
+}
+declare const TIMEZONES: readonly TimezoneEntry[];
+/** The renderer's config default is the bare `'UTC'` alias — fold it (and any other
+ *  UTC spelling) onto the catalog's `'Etc/UTC'` so selection checks land on one entry. */
+declare function normalizeTimezone(zone: string): string;
+/** Current UTC offset of an IANA zone as `"UTC"`, `"UTC+2"` or `"UTC-9:30"`. */
+declare function tzOffset(zone: string, date?: Date): string;
+/** Dropdown row label — UTC omits the offset prefix. */
+declare function tzMenuLabel(zone: string, location: string): string;
+/** Compact label for the bottom-bar button ("UTC", "UTC+2 Paris"). */
+declare function tzButtonLabel(zone: string): string;
+
+/** Sensible decimal count for a price magnitude (crypto-friendly). */
+declare function decimalsFor(ref: number): number;
+/** Locale-formatted price; `'—'` for null/non-finite. */
+declare function fmtPrice(n: number | null | undefined, dp?: number): string;
+/** Signed change + percent ("+123.45 (+1.23%)") from open→close; `''` when unavailable. */
+declare function fmtChange(open: number | null | undefined, close: number | null | undefined): string;
+
+export { type BuiltInPanel, ChartContextMenu, type ContextMenuCallbacks, DataWindow, type DataWindowLine, type DataWindowSection, IndicatorPicker, type IndicatorPickerOptions, type IndicatorRow, ObjectTree, type PanelChrome, PanelDock, type PanelDockDeps, PanelsState, type ParsedTimeframe, PersistedState, RangePreset, ShortcutsHelp, SidePanel, SidePanelButton, Statusline, SymbolPicker, type SymbolPickerOptions, TIMEZONES, TimeframeQuick, type TimeframeQuickOptions, type TimezoneEntry, Topbar, type TopbarOptions, VelaShellOptions, VelaWidget, type VelaWidgetOptions, Watermark, WidgetContext, WorkspaceState, dataWindowSections, decimalsFor, filterSymbols, fmtChange, fmtPrice, normalizeTimezone, parseTimeframe, priceStyleLabel, readUrlState, timeframeLabel, timeframeMs, tzButtonLabel, tzMenuLabel, tzOffset, writeUrlState };