@luxalgo/vela 0.6.5 → 0.6.7

package/README.md

@@ -1,35 +1,35 @@
 # Vela
 
 A fast, extensible financial charting library with its own native canvas renderer, a
-headless core, a batteries-included widget, and a plugin SDK for custom chart types and
+headless core, a batteries-included shell, and a plugin SDK for custom chart types and
 renderer layers.
 
 - **`vela`** — the headless chart: data model, engines, drawings, providers, native renderer.
-- **`vela/widget`** — the full chart app: topbar (symbol / timeframe / style / indicators),
-  status line, watermark, bottom bar (ranges, clock, timezone), object tree, keyboard-first UX.
-- **`vela/ui`** — the component kit the widget is built on: design tokens, overlay chrome
+- **`vela/workspace`** — the full chart app: one chart (`layout: false`) or a grid of
+  them under one shared topbar (symbol / timeframe / style / indicators), status line,
+  watermark, bottom bar (ranges, clock, timezone), object tree, keyboard-first UX,
+  named cells, sync groups and one persisted state document.
+- **`vela/ui`** — the component kit the shell is built on: design tokens, overlay chrome
   ([Zag.js](https://zagjs.com) menu/dialog/drawer/tooltip), form primitives (switch, select,
   number, text, color, popover), and the `KeymapManager`.
 - **`vela/plugin`** — the extension SDK: chart types, renderer layers, native indicators.
-- **`vela/workspace`** — the multi-chart shell: a grid of full charts under one shared
-  topbar, with named cells, sync groups and one persisted state document.
 - **`vela/providers/*`** — data providers (Binance, Coinbase, Hyperliquid).
 
 ## Quick start
 
 ```ts
-import { VelaWidget } from 'vela/widget';
+import { VelaWorkspace } from 'vela/workspace';
 import { BinanceProvider } from 'vela/providers/binance';
 
-const widget = new VelaWidget('#chart', {
+const chart = new VelaWorkspace('#chart', {
+    layout: false, // one chart; '2h' | '4' | '8' | … for a multi-chart grid
     symbol: 'BTCUSDT', // bare = first declared provider listing it; 'binance:BTCUSDT' pins the venue
     timeframe: '60',
     live: true,
     theme: 'dark',
     providers: { binance: () => new BinanceProvider() },
-    persist: true,   // restore the full state document — market, style, timezone, renderer
-                     // config, drawings and indicators — from localStorage
-    urlState: true,  // ?symbol=…&interval=… shareable links
+    persist: true, // restore the full state document — market, style, timezone, renderer
+                   // config, drawings and indicators — from localStorage
 });
 ```
 
@@ -67,11 +67,11 @@ value** — via `handle.context()` (read-only snapshots, worker-safe). See the
 [API reference](docs/user/api-reference.md#reading-a-scripts-execution-context), and
 [Scripting engines](docs/user/scripting-engines.md) for the addon and for writing your own.
 
-The widget takes an **indicator manifest** — inline JSON, a URL returning it, or an async
+The shell takes an **indicator manifest** — inline JSON, a URL returning it, or an async
 loader (`() => Promise<manifest>`):
 
 ```ts
-new VelaWidget('#chart', {
+new VelaWorkspace('#chart', {
     // …
     engines: { pine: () => new PineEngine() },
     indicators: '/indicators.json', // or an inline [{ name, script | url, language?, enabled? }]
@@ -82,7 +82,7 @@ new VelaWidget('#chart', {
 
 Type a **letter** → symbol search. Type a **digit** → timeframe entry (`15`, `4h`, `D`, `3M`…).
 `mod+alt+S` (Ctrl+Alt+S, ⌥⌘S on macOS) → screenshot. `?` → the shortcuts panel. Bindings are declarative
-(`widget.keymap.register({...})`) — plugins register theirs the same way.
+(`chart.keymap.register({...})`) — plugins register theirs the same way.
 
 ## Extending (plugin SDK)
 
@@ -104,14 +104,14 @@ registerRendererLayer({
 });
 ```
 
-A registered chart type automatically appears in the widget's style dropdown; a chart
+A registered chart type automatically appears in the shell's style dropdown; a chart
 type's `dataEngine` pushes to its layer's channel with zero extra wiring. See
 [docs/contributing/plugin-sdk.md](docs/contributing/plugin-sdk.md).
 
 ## Documentation
 
 Full documentation lives in [docs/](docs/index.md) — user guides ([quickstart](docs/user/quickstart.md),
-[the widget](docs/user/widget.md), [options](docs/user/options.md), [API reference](docs/user/api-reference.md)),
+[the workspace](docs/user/workspace.md), [options](docs/user/options.md), [API reference](docs/user/api-reference.md)),
 [architecture](docs/architecture/overview.md), and [contributing](docs/contributing/setup.md) guides
 including the [plugin SDK](docs/contributing/plugin-sdk.md).
 

package/dist/{DataProvider-BmHkcwvJ.d.ts → DataProvider-BSLlBpB9.d.ts}

@@ -1,4 +1,4 @@
-import { M as MarketConfig, O as OHLCV, U as Unsubscribe } from './options-YdiaaVjt.js';
+import { M as MarketConfig, O as OHLCV, U as Unsubscribe } from './options-BaVTMXaO.js';
 
 /**
  * Symbol metadata an engine may need (e.g. Pine `syminfo.*`). Free-form beyond
@@ -131,6 +131,16 @@ interface DataProvider {
     listSymbols?(): Promise<SymbolDescriptor[]>;
     /** Per-symbol metadata for engine `syminfo.*`. Absent ⇒ the engine synthesizes a fallback. */
     getSymbolInfo?(ticker: string): Promise<SymbolInfo | undefined>;
+    /**
+     * The icon URL for one of THIS provider's symbols — the provider owns the knowledge
+     * of where its asset class's icons live (a crypto CDN, a self-hosted store), the
+     * shells own the rendering (round badge, colored-initials fallback). Called lazily,
+     * per RENDERED row — never per index build — so it must be cheap and synchronous.
+     * `undefined` ⇒ no icon (the initials badge shows). Absent ⇒ same. The URL must be
+     * CORS-clean (`Access-Control-Allow-Origin`) or drawing it taints the canvas and
+     * breaks the PNG export — a load error falls back to initials either way.
+     */
+    resolveSymbolIcon?(symbol: SymbolDescriptor): string | undefined;
     /**
      * Open a true live stream for `ticker`/`timeframe`. Each call to `onBar` delivers
      * the forming candle (or a freshly-closed one). Returns an unsubscribe fn. Absent

package/dist/{DataProvider-DrN7ZIou.d.cts → DataProvider-BsQM2WNH.d.cts}

@@ -1,4 +1,4 @@
-import { M as MarketConfig, O as OHLCV, U as Unsubscribe } from './options-YdiaaVjt.cjs';
+import { M as MarketConfig, O as OHLCV, U as Unsubscribe } from './options-BaVTMXaO.cjs';
 
 /**
  * Symbol metadata an engine may need (e.g. Pine `syminfo.*`). Free-form beyond
@@ -131,6 +131,16 @@ interface DataProvider {
     listSymbols?(): Promise<SymbolDescriptor[]>;
     /** Per-symbol metadata for engine `syminfo.*`. Absent ⇒ the engine synthesizes a fallback. */
     getSymbolInfo?(ticker: string): Promise<SymbolInfo | undefined>;
+    /**
+     * The icon URL for one of THIS provider's symbols — the provider owns the knowledge
+     * of where its asset class's icons live (a crypto CDN, a self-hosted store), the
+     * shells own the rendering (round badge, colored-initials fallback). Called lazily,
+     * per RENDERED row — never per index build — so it must be cheap and synchronous.
+     * `undefined` ⇒ no icon (the initials badge shows). Absent ⇒ same. The URL must be
+     * CORS-clean (`Access-Control-Allow-Origin`) or drawing it taints the canvas and
+     * breaks the PNG export — a load error falls back to initials either way.
+     */
+    resolveSymbolIcon?(symbol: SymbolDescriptor): string | undefined;
     /**
      * Open a true live stream for `ticker`/`timeframe`. Each call to `onBar` delivers
      * the forming candle (or a freshly-closed one). Returns an unsubscribe fn. Absent

package/dist/{history-BmyjaVir.d.cts → bottombar-Br4rzx_R.d.ts}

@@ -1,101 +1,6 @@
-import { V as VisibleRangePreset } from './options-YdiaaVjt.cjs';
-import { D as DataProvider } from './DataProvider-DrN7ZIou.cjs';
-import { S as ScriptingEngine, V as Vela } from './contributions-2bEmCF9S.cjs';
-
-interface RangePreset {
-    /** Button label. */
-    id: string;
-    /** Timeframe to switch to for this range. */
-    tf: string;
-    /** The core visible-range preset framed once the chart is ready. */
-    preset: VisibleRangePreset;
-    /**
-     * Bars the window needs AT `tf` — the fetch budget for the rebuild. Without it the
-     * chart loads its default depth and the framed window is clipped to whatever
-     * history happens to be loaded (a "1D" that only shows 16 hours). Includes a small
-     * margin; `ALL` asks for as much history as the provider will serve.
-     */
-    bars: number;
-}
-/**
- * Range chips — each pairs a timeframe, a visible window, and the fetch depth that
- * window needs. Resolutions follow the reference: the shorter the range, the finer the
- * bars (1 day of 1-minute bars … 5 years of weekly bars).
- */
-declare const RANGE_PRESETS: readonly RangePreset[];
-interface BottombarOptions {
-    timezone: string;
-    onRange: (preset: RangePreset) => void;
-    onTimezone: (zone: string) => void;
-    /** RTH/ETH toggled by the user. Fires only while the toggle is ENABLED (see {@link Bottombar.setSession}). */
-    onSession?: (session: 'regular' | 'extended') => void;
-    onSettingsClick?: () => void;
-}
-declare class Bottombar {
-    readonly el: HTMLElement;
-    private readonly clockEl;
-    private readonly tzLabelEl;
-    private readonly tzButton;
-    private readonly tzMenu;
-    private readonly settingsTip;
-    private readonly rangeButtons;
-    private readonly sessionButtons;
-    private sessionEl;
-    private timezone;
-    private timer;
-    constructor(host: HTMLElement, opts: BottombarOptions);
-    setTimezone(zone: string): void;
-    /** Highlight (or clear with null) the active range chip — cleared on manual tf changes. */
-    setActiveRange(id: string | null): void;
-    /**
-     * Reflect the ACTIVE chart's session posture. `enabled: false` (a continuous
-     * market, or metadata not landed yet) HIDES the toggle entirely — RTH/ETH is
-     * meaningless there. Enabled, the chips appear and the active one tracks the
-     * chart's current session.
-     */
-    setSession(state: {
-        session: 'regular' | 'extended';
-        enabled: boolean;
-    }): void;
-    destroy(): void;
-    private tzItems;
-    private tick;
-}
-
-interface IndicatorManifestEntry {
-    name: string;
-    /** Inline script source (one of script/url required). */
-    script?: string;
-    /** Fetch the source from here instead (resolved relative to the manifest URL). */
-    url?: string;
-    /** Engine language (default: the chart's default engine). */
-    language?: string;
-    /** Add to the chart at startup (default true). Disabled entries only appear in pickers. */
-    enabled?: boolean;
-    /** Picker grouping (default 'Indicators'). */
-    category?: string;
-}
-type IndicatorManifest = IndicatorManifestEntry[] | {
-    indicators: IndicatorManifestEntry[];
-};
-/** A manifest entry with its source resolved and ready for `chart.addIndicator`. */
-interface ResolvedIndicator {
-    name: string;
-    script: string;
-    language?: string;
-    enabled: boolean;
-    category?: string;
-}
-/** An async manifest source — called once at resolution time. The escape hatch for
- *  manifests that a URL can't express: a filesystem read, an authenticated API, a
- *  bundler dynamic import. A rejection behaves like a failing manifest URL. */
-type IndicatorLoader = () => Promise<IndicatorManifest>;
-/** Load the indicator list: a manifest object, a URL string returning the manifest JSON,
- *  or an async loader function returning the manifest. Entries with `url` sources are
- *  fetched here too (relative to the manifest URL when there is one). Entries that fail
- *  to resolve are dropped with a console warning — one broken script must not take the
- *  chart down. */
-declare function resolveIndicators(config: string | IndicatorManifest | IndicatorLoader, fetchImpl?: typeof fetch): Promise<ResolvedIndicator[]>;
+import { D as DataProvider } from './DataProvider-BSLlBpB9.js';
+import { S as ScriptingEngine, V as Vela } from './contributions-Z12BrWCy.js';
+import { V as VisibleRangePreset } from './options-BaVTMXaO.js';
 
 /** The linkable dimensions. `crosshair` mirrors the pointer time onto same-group
  *  cells as GHOST crosshairs (renderers without the optional `setExternalCrosshair`
@@ -161,6 +66,12 @@ interface CellState {
         manifest: string[];
         natives: string[];
     };
+    /** Third-party per-chart state, by namespaced key (`'vendor.feature'`) — written and
+     *  read by registered state-persistence handlers (`registerStatePersistence`, scope
+     *  `'cell'`). Values are OPAQUE here: the codec preserves entries verbatim — a key
+     *  whose handler is absent this session still round-trips — and each handler
+     *  validates its own payload at restore. JSON-serializable values only. */
+    ext?: Record<string, unknown>;
 }
 /** One entry of the document's `charts` array: a chart's state plus its cell IDENTITY. */
 interface ChartState extends CellState {
@@ -191,6 +102,9 @@ interface WorkspaceState {
     /** Per-chart state, one entry per SLOT (a single `c1` entry for the widget).
      *  Ids are unique — the codec drops id-less entries and keeps the LAST duplicate. */
     charts: ChartState[];
+    /** Third-party document-level state, by namespaced key (`'vendor.feature'`) — the
+     *  `scope: 'global'` counterpart of {@link CellState.ext}, same opacity contract. */
+    ext?: Record<string, unknown>;
 }
 declare function encodeState(state: WorkspaceState): string;
 /** Parse + sanitize a persisted payload. Null on anything unusable (wrong version,
@@ -203,8 +117,43 @@ declare function decodeState(raw: string): WorkspaceState | null;
  */
 declare function sanitizeState(doc: unknown): WorkspaceState | null;
 
-/** The storage contract BOTH shells persist through (the widget and the workspace —
- *  one name, one shape). Methods may be synchronous or return promises. */
+interface IndicatorManifestEntry {
+    name: string;
+    /** Inline script source (one of script/url required). */
+    script?: string;
+    /** Fetch the source from here instead (resolved relative to the manifest URL). */
+    url?: string;
+    /** Engine language (default: the chart's default engine). */
+    language?: string;
+    /** Add to the chart at startup (default true). Disabled entries only appear in pickers. */
+    enabled?: boolean;
+    /** Picker grouping (default 'Indicators'). */
+    category?: string;
+}
+type IndicatorManifest = IndicatorManifestEntry[] | {
+    indicators: IndicatorManifestEntry[];
+};
+/** A manifest entry with its source resolved and ready for `chart.addIndicator`. */
+interface ResolvedIndicator {
+    name: string;
+    script: string;
+    language?: string;
+    enabled: boolean;
+    category?: string;
+}
+/** An async manifest source — called once at resolution time. The escape hatch for
+ *  manifests that a URL can't express: a filesystem read, an authenticated API, a
+ *  bundler dynamic import. A rejection behaves like a failing manifest URL. */
+type IndicatorLoader = () => Promise<IndicatorManifest>;
+/** Load the indicator list: a manifest object, a URL string returning the manifest JSON,
+ *  or an async loader function returning the manifest. Entries with `url` sources are
+ *  fetched here too (relative to the manifest URL when there is one). Entries that fail
+ *  to resolve are dropped with a console warning — one broken script must not take the
+ *  chart down. */
+declare function resolveIndicators(config: string | IndicatorManifest | IndicatorLoader, fetchImpl?: typeof fetch): Promise<ResolvedIndicator[]>;
+
+/** The storage contract BOTH shells persist through (the widget wrapper and the
+ *  workspace — one name, one shape). Methods may be synchronous or return promises. */
 interface VelaStorage {
     get(key: string): string | null | Promise<string | null>;
     set(key: string, value: string): void | Promise<void>;
@@ -222,32 +171,37 @@ type WidgetStorage = VelaStorage;
  * shell's own key is used as-is (the historical behavior).
  */
 declare function localStorageAdapter(storageKey?: string): WidgetStorage;
-interface PersistedState {
-    symbol?: string;
-    timeframe?: string;
-    priceStyle?: string;
-    timezone?: string;
-    bars?: string;
-    /** Trading session (`regular` | `extended`) — URL param `session`. */
-    session?: string;
-    watermark?: string;
-    /** Comma-joined favorite drawing-tool types. */
-    favorites?: string;
+
+/** The host-facing option: visible entries per side, in render order. An undeclared
+ *  side falls back to its default list. */
+interface TopbarComposition {
+    left?: readonly string[];
+    right?: readonly string[];
 }
-/** Parse a LEGACY prefs payload (never throws — junk yields `{}`). */
-declare function parsePersisted(raw: string | null): PersistedState;
-/** Load the persisted state — synchronous result for sync storages, else a promise. */
-declare function loadPersisted(storage: WidgetStorage, storageKey: string): PersistedState | Promise<PersistedState>;
-/** Save (fire-and-forget — async adapter failures are the adapter's concern). */
-declare function savePersisted(storage: WidgetStorage, storageKey: string, state: PersistedState): void;
-/**
- * LEGACY migration — convert the widget's pre-unified three-key layout (prefs under
- * the main key, renderer config under `<key>:config`, drawings under `<key>:drawings`)
- * into ONE unified state document (the same format the workspace persists, with a
- * single `c1` cell). Null when the payload holds no usable state. Pure — the caller
- * reads the keys, then rewrites the main key and drops the legacy sub-keys.
- */
-declare function legacyWidgetState(prefs: PersistedState, rawConfig: string | null, rawDrawings: string | null): WorkspaceState | null;
+/** The built-in entry vocabulary (everything else in a list is a contributed-action id).
+ *  `'layout'` renders only on multi-chart shells and `'indicators'` only while an
+ *  indicator surface exists — the built-in picker (the deprecated `indicatorPicker:
+ *  false` still removes it) or a slot OVERRIDE replacing it — so listing them is
+ *  necessary but not sufficient. */
+declare const TOPBAR_BUILTIN_IDS: readonly ["symbol", "timeframes", "style", "layout", "indicators", "actions", "undo-redo", "alerts", "panels", "screenshot"];
+/** The default left side — the current shell composition, verbatim. */
+declare const TOPBAR_DEFAULT_LEFT: readonly string[];
+/** The default right side (the `margin-left: auto` cluster). */
+declare const TOPBAR_DEFAULT_RIGHT: readonly string[];
+/** A composition with both sides resolved (defaults applied, duplicates dropped). */
+interface ResolvedTopbarComposition {
+    left: string[];
+    right: string[];
+}
+/** Resolve the host option: absent side ⇒ its default list; a duplicated id keeps its
+ *  FIRST occurrence (left before right) so an entry never renders twice. `'actions'`
+ *  is the exception — it is a flow SLOT each side legitimately owns (the defaults
+ *  carry one on both), so it dedupes per side only. */
+declare function resolveTopbarComposition(opt?: TopbarComposition): ResolvedTopbarComposition;
+/** Whether an entry id is visible anywhere in the resolved composition. */
+declare function topbarHas(comp: ResolvedTopbarComposition, id: string): boolean;
+/** The non-built-in entries — contributed-action ids PINNED to a list position. */
+declare function pinnedTopbarActionIds(comp: ResolvedTopbarComposition): string[];
 
 /** What a shell (widget or workspace) accepts BEYOND the chart options themselves. */
 interface VelaShellOptions {
@@ -274,10 +228,25 @@ interface VelaShellOptions {
     statusline?: boolean;
     watermark?: boolean;
     bottombar?: boolean;
+    /** Declarative topbar composition: `{ left, right }` lists of the VISIBLE entries,
+     *  in render order — built-in ids (`'symbol'`, `'timeframes'`, `'style'`,
+     *  `'layout'`, `'indicators'`, `'actions'`, `'undo-redo'`, `'alerts'`, `'panels'`,
+     *  `'screenshot'`) and/or contributed-action ids (naming one PINS it there,
+     *  overriding its `align`/`order`; `'actions'` is where the unlisted ones flow).
+     *  An undeclared side keeps its default. An explicit list is that side's complete
+     *  contract — it also FREEZES it: chrome a future release adds will not appear.
+     *  Hiding a built-in removes its mobile entry and keyboard chord too (`mod+alt+S`
+     *  for `'screenshot'`); Ctrl+Z / Ctrl+Y stay — they belong to editing, not to the
+     *  `'undo-redo'` buttons. */
+    topbar?: TopbarComposition;
     /** The built-in indicator picker's entry points — the topbar button, the mobile-bar
-     *  item, and the `/` shortcut. `false` removes them, for hosts that replace the
-     *  picker with their own indicator UI (e.g. a contributed topbar action opening a
-     *  custom dialog). The `indicators` manifest still resolves and auto-adds. */
+     *  item, and the `/` shortcut. `false` removes them. The `indicators` manifest
+     *  still resolves and auto-adds.
+     *  @deprecated Removed in 0.7.0. To HIDE the built-in surface, omit `'indicators'`
+     *  from `topbar.left` (same effect: no button, no mobile stop, no `/`, no dialog).
+     *  To REPLACE it, a plugin registers its action under the id `'indicators'`
+     *  (`registerWidgetAction`) — the override takes the slot's whole surface and
+     *  needs no shell option at all. */
     indicatorPicker?: boolean;
     /** Chrome size class. `'auto'` (default) follows the CONTAINER width plus a
      *  coarse-pointer heuristic; `'mobile'` / `'desktop'` pin it. Mobile swaps the
@@ -332,4 +301,64 @@ declare class WidgetHistory {
     private notify;
 }
 
-export { Bottombar as B, type CellState as C, type IndicatorLoader as I, type PanelsState as P, type ResolvedIndicator as R, type SyncSetting as S, type TrackSizes as T, type VelaStorage as V, WidgetHistory as W, type RangePreset as a, type VelaShellOptions as b, type SyncOptions as c, type SyncKind as d, type WorkspaceState as e, type ChartState as f, decodeState as g, encodeState as h, type PersistedState as i, type BottombarOptions as j, type IndicatorManifest as k, type IndicatorManifestEntry as l, RANGE_PRESETS as m, type WidgetStorage as n, legacyWidgetState as o, loadPersisted as p, localStorageAdapter as q, parsePersisted as r, sanitizeState as s, resolveIndicators as t, savePersisted as u };
+interface RangePreset {
+    /** Button label. */
+    id: string;
+    /** Timeframe to switch to for this range. */
+    tf: string;
+    /** The core visible-range preset framed once the chart is ready. */
+    preset: VisibleRangePreset;
+    /**
+     * Bars the window needs AT `tf` — the fetch budget for the rebuild. Without it the
+     * chart loads its default depth and the framed window is clipped to whatever
+     * history happens to be loaded (a "1D" that only shows 16 hours). Includes a small
+     * margin; `ALL` asks for as much history as the provider will serve.
+     */
+    bars: number;
+}
+/**
+ * Range chips — each pairs a timeframe, a visible window, and the fetch depth that
+ * window needs. Resolutions follow the reference: the shorter the range, the finer the
+ * bars (1 day of 1-minute bars … 5 years of weekly bars).
+ */
+declare const RANGE_PRESETS: readonly RangePreset[];
+interface BottombarOptions {
+    timezone: string;
+    onRange: (preset: RangePreset) => void;
+    onTimezone: (zone: string) => void;
+    /** RTH/ETH toggled by the user. Fires only while the toggle is ENABLED (see {@link Bottombar.setSession}). */
+    onSession?: (session: 'regular' | 'extended') => void;
+    onSettingsClick?: () => void;
+}
+declare class Bottombar {
+    readonly el: HTMLElement;
+    private readonly clockEl;
+    private readonly tzLabelEl;
+    private readonly tzButton;
+    private readonly tzMenu;
+    private readonly settingsTip;
+    private readonly rangeButtons;
+    private readonly sessionButtons;
+    private sessionEl;
+    private timezone;
+    private timer;
+    constructor(host: HTMLElement, opts: BottombarOptions);
+    setTimezone(zone: string): void;
+    /** Highlight (or clear with null) the active range chip — cleared on manual tf changes. */
+    setActiveRange(id: string | null): void;
+    /**
+     * Reflect the ACTIVE chart's session posture. `enabled: false` (a continuous
+     * market, or metadata not landed yet) HIDES the toggle entirely — RTH/ETH is
+     * meaningless there. Enabled, the chips appear and the active one tracks the
+     * chart's current session.
+     */
+    setSession(state: {
+        session: 'regular' | 'extended';
+        enabled: boolean;
+    }): void;
+    destroy(): void;
+    private tzItems;
+    private tick;
+}
+
+export { Bottombar as B, type CellState as C, type IndicatorLoader as I, type PanelsState as P, type ResolvedIndicator as R, type SyncSetting as S, type TrackSizes as T, type VelaStorage as V, WidgetHistory as W, type RangePreset as a, type VelaShellOptions as b, type SyncOptions as c, type SyncKind as d, type WorkspaceState as e, type ChartState as f, decodeState as g, encodeState as h, type TopbarComposition as i, type BottombarOptions as j, type IndicatorManifest as k, type IndicatorManifestEntry as l, RANGE_PRESETS as m, type ResolvedTopbarComposition as n, TOPBAR_BUILTIN_IDS as o, TOPBAR_DEFAULT_LEFT as p, TOPBAR_DEFAULT_RIGHT as q, type WidgetStorage as r, sanitizeState as s, localStorageAdapter as t, pinnedTopbarActionIds as u, resolveIndicators as v, resolveTopbarComposition as w, topbarHas as x };