@luxalgo/vela 0.5.0

package/dist/workspace.d.cts

@@ -0,0 +1,579 @@
+import { O as OHLCV, V as VisibleRangePreset, a as VisibleRange, b as VelaOptions, c as VelaTheme, N as NativeBackend } from './options-Q-576hIi.cjs';
+import { S as SyncSetting, V as VelaStorage, C as CellState, W as WidgetHistory, R as ResolvedIndicator, a as RangePreset, T as TrackSizes, b as VelaShellOptions, c as SyncOptions, d as SyncKind, e as WorkspaceState } from './history-LJkz4-sS.cjs';
+export { f as ChartState, P as PanelsState, g as decodeState, h as encodeState, s as sanitizeState } from './history-LJkz4-sS.cjs';
+import { K as KeymapManager } from './keymap-CGOz5F5f.cjs';
+import { I as IndicatorHandle, S as ScriptingEngine, W as WidgetContext, V as Vela, a as ScriptRun } from './contributions-o1GRKPI_.cjs';
+import { M as MarketDataFeed } from './DataProvider-DKNDHpNv.cjs';
+
+/** The cells that follow `originId` under `setting` — PURE (never includes the origin). */
+declare function syncTargets(originId: string, setting: SyncSetting | undefined, cellIds: readonly string[]): string[];
+/** Whether two visible ranges agree within `epsMs` on both edges — the short-circuit
+ *  that stops viewport echo (a followers' re-emission never re-propagates). */
+declare function rangesWithin(a: {
+    from: number;
+    to: number;
+}, b: {
+    from: number;
+    to: number;
+}, epsMs: number): boolean;
+
+/** @deprecated Use {@link VelaStorage} — one storage contract for both shells
+ *  (`get`/`set`, each synchronous OR promise-returning, so localStorage-like and
+ *  REST/IndexedDB-like backends both fit). */
+type WorkspaceStorage = VelaStorage;
+/** An in-memory, session-lived {@link VelaStorage} — the OPT-IN alternative to the
+ *  localStorage default when persisted state must not outlive the page session. */
+declare function memoryStorageAdapter(): VelaStorage;
+
+/** The seed/mutable market state of one cell (all optional — an empty cell parks).
+ *  The SAME vocabulary as the widget's chart options: the workspace's top-level chart
+ *  options provide every cell's default ({@link seedDefaults}), `cells` overrides per
+ *  cell. `data`/`visibleRange` are boot-only (they seed the first load, never persist). */
+interface CellSeed {
+    /** Bare ticker (provider resolved by declaration order) or `EXCHANGE:`-prefixed. */
+    symbol?: string;
+    timeframe?: string;
+    priceStyle?: string;
+    bars?: number;
+    /** Offline bars for this cell — replaces the provider (boot-only). */
+    data?: OHLCV[];
+    /** Initial visible window (boot-only). */
+    visibleRange?: VisibleRangePreset | VisibleRange;
+}
+/** A destroyed cell's state, kept by the workspace pool so its slot restores later —
+ *  the per-cell entry of the SHARED state document (`src/state/document.ts`). */
+type PooledCellState = CellState;
+/** What a cell BOOTS from: a pooled state (restored slot) or an options seed — plus
+ *  the boot-only extras a pooled state never carries (offline bars, initial window). */
+type CellBoot = PooledCellState & Pick<CellSeed, 'data' | 'visibleRange'>;
+/** Chart options the workspace forwards VERBATIM to every cell's chart — the widget
+ *  vocabulary minus what the grid manages itself: `height` (the grid sizes cells),
+ *  `nativeBackend` (the WebGL budget policy, explicit value resolved upstream), the
+ *  market/view seeds (those flow through {@link CellSeed}), and `drawings`' toolbar
+ *  sub-key (see {@link cellDrawings}). */
+type CellChartDefaults = Pick<VelaOptions, 'renderer' | 'defaultLanguage' | 'currentPriceLine' | 'logScale' | 'animations' | 'glow' | 'upColor' | 'downColor' | 'drawings'>;
+/** One entry of the shared indicator picker's native catalog, per cell. */
+interface CellNativeInfo {
+    type: string;
+    title: string;
+    supported: boolean;
+    present: boolean;
+    beta?: boolean;
+}
+/** What every cell shares from the workspace. */
+interface CellDeps {
+    /** THE shared market-data feed (one registry, one cache, for every cell). */
+    feed: MarketDataFeed;
+    /** Scripting-engine factories — instantiated PER CELL (a worker engine per cell). */
+    engines: Record<string, () => ScriptingEngine>;
+    /** The workspace's top-level chart options every cell's chart starts from. */
+    chartDefaults: CellChartDefaults;
+    theme: VelaTheme;
+    live: boolean;
+    volume: boolean;
+    statusline: boolean;
+    watermark: boolean;
+    /** Geometry backend for cells under the current layout (the WebGL budget policy). */
+    nativeBackend: NativeBackend;
+    /** Where the renderer mounts its MODAL dialogs (chart/indicator settings) — the
+     *  workspace root, so dialogs center over the whole grid instead of one cell. */
+    dialogHost: HTMLElement;
+    /** The workspace-global display timezone (applied to every cell's renderer). */
+    timezone(): string;
+    /** Switch the workspace-global display timezone (a cell's time-axis menu). */
+    setTimezone(zone: string): void;
+    /** The live widget-context builder (per-cell context menus project contributed actions). */
+    context(): WidgetContext;
+    /** The shared manifest can no longer change instance sets: it resolved, or the
+     *  workspace has no `indicators` option so nothing will ever resolve. Gates the
+     *  ledger's pending fallback in `dehydrate` — once settled, a live empty set means
+     *  "the user removed everything" and persists so. */
+    manifestSettled(): boolean;
+    /** Report a pointer-down/focus in this cell (the workspace sets it active). */
+    activate(id: string): void;
+    /** The cell's market changed in place (chrome/retention refresh upstream). */
+    onMarketChanged(id: string): void;
+    /** The cell's indicator ledger changed (count/picker refresh upstream). */
+    onIndicatorsChanged(id: string): void;
+    /** Persistable per-cell state changed outside the market/indicator channels
+     *  (bars budget, watermark/titles toggles) — the workspace debounces a save. */
+    onStateDirty(): void;
+}
+declare class ChartCell {
+    readonly id: string;
+    private readonly deps;
+    /** The grid item this cell renders into (owned; removed on destroy). */
+    readonly host: HTMLElement;
+    /** This cell's unified app+drawings undo timeline (the shared Ctrl+Z routes here). */
+    readonly history: WidgetHistory;
+    /** Live manifest-indicator instances on this cell (the SAME entry may repeat). */
+    readonly instances: Array<{
+        entry: ResolvedIndicator;
+        handle: IndicatorHandle | null;
+    }>;
+    /** The native-indicator catalog with this cell's live supported/present flags. */
+    nativeCatalog: CellNativeInfo[];
+    /** Last crosshair position in this cell (the alt+H/alt+V shortcuts anchor here). */
+    lastCrossTime: number | null;
+    lastCrossPrice: number | null;
+    /** The bottombar range chip this cell is framed on (null = none). */
+    activeRangeId: string | null;
+    private inner;
+    /** The live app theme — seeded from deps, updated on `theme:changed` (the base the
+     *  plot-overlay tokens re-derive from). */
+    private appTheme;
+    private readonly statusline;
+    private readonly watermark;
+    private readonly contextMenu;
+    private readonly offMarket;
+    /** The cell's durable market state — the seed vocabulary plus the venue mirror the
+     *  persisted document carries (`provider` = the symbol's parsed prefix). */
+    private state;
+    private manifest;
+    /** A restored ledger's manifest entry NAMES, waiting for the manifest to resolve
+     *  (a pool/persisted cell can be built before the shared manifest has loaded). */
+    private pendingManifestNames;
+    /** The volume auto-add rides the cell's first candles (`load:end`); until then the
+     *  registry can't show it and the dehydrated ledger reports the INTENT instead. */
+    private volumeMayBePending;
+    /** Volume intent: the seed's ledger, else the workspace `volume` option. */
+    private readonly volumeIntent;
+    /** 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 presentNatives;
+    private rangeBars;
+    private pendingRange;
+    private watermarkOn;
+    /** Indicator titles (this cell's in-chart legend rows) shown. */
+    private indicatorTitlesOn;
+    private destroyed;
+    constructor(id: string, gridHost: HTMLElement, seed: CellBoot, deps: CellDeps);
+    /** Show/hide this cell's symbol watermark (persisted per cell). */
+    setWatermarkVisible(visible: boolean): void;
+    /** Show/hide this cell's indicator titles — the in-chart legend rows (persisted per cell). */
+    setIndicatorTitlesVisible(visible: boolean): void;
+    /** The LIVE chart of this cell — never cache it across a layout change (the cell's
+     *  identity is what endures; the chart dies with the cell). */
+    get chart(): Vela;
+    get symbol(): string;
+    get timeframe(): string;
+    get priceStyle(): string;
+    /** Manifest instances + present natives — the topbar indicator count. */
+    get indicatorCount(): number;
+    /** Switch this cell's market in place (the chart instance survives). */
+    setSymbol(symbol: string): void;
+    setTimeframe(timeframe: string): void;
+    /** Applied live (renderer feature) — no reload. */
+    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 workspace shell keeps the app theme; the cell host's tokens re-derive from
+     *  the LIVE plot surface (see {@link applyPlotOverlayTokens}). */
+    private syncPlotOverlayTokens;
+    /**
+     * Frame a bottombar range chip: switch to its timeframe, fetch the depth its window
+     * needs, and keep it framed (re-asserted once the deeper history is painted).
+     */
+    applyRange(preset: RangePreset): void;
+    /** Make this cell the active one and put keyboard focus on its chart surface. */
+    focus(): void;
+    /** Download this cell's chart as a PNG (named after its market). */
+    downloadScreenshot(): void;
+    /**
+     * Hand the cell the workspace's resolved manifest. A RESTORED ledger (pool or
+     * persisted state) re-adds its recorded entries by name — held until the manifest
+     * actually carries them. Otherwise `seedEnabled` auto-adds the manifest's `enabled`
+     * entries (fresh cells only).
+     */
+    setManifest(list: readonly ResolvedIndicator[], seedEnabled: boolean): void;
+    /** The picker's library rows: supported natives first, then the manifest. */
+    libraryRows(): Array<{
+        name: string;
+        language?: string;
+        category?: string;
+        native?: boolean;
+        nativeType?: string;
+        beta?: boolean;
+    }>;
+    /** The picker's on-chart rows: present natives first, then live instances. */
+    onChartRows(): Array<{
+        name: string;
+        language?: string;
+        native?: boolean;
+        nativeType?: string;
+    }>;
+    /** Add by picker LIBRARY index (natives precede the manifest — mirrors libraryRows). */
+    addFromLibrary(index: number): void;
+    /** Remove by picker ON-CHART index (present natives precede instances). */
+    removeFromChart(index: number): void;
+    /** Add ONE instance of a manifest entry (repeatable — duplicates are legitimate). */
+    addManifestInstance(entry: ResolvedIndicator, opts?: {
+        record?: boolean;
+    }): void;
+    private removeInstance;
+    private dropInstance;
+    /** Add a native indicator (single-instance per type — the core dedupes). */
+    addNative(type: string): void;
+    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;
+    /** Refresh the native catalog (supported/present flags) for this cell's market. */
+    refreshNativeCatalog(): void;
+    private addToChart;
+    /** Snapshot everything the pool needs to restore this slot later. The market fields
+     *  come from the LIVE config (`chart.market`) — the requested identity — so a switch
+     *  still loading when the snapshot is taken (persist-on-close) is not lost. */
+    dehydrate(): PooledCellState;
+    destroy(): void;
+}
+
+/** The extended context a workspace hands to contributed actions/attachments. */
+interface WorkspaceWidgetContext extends WidgetContext {
+    /** Every live cell (layout order) — id + LIVE chart + market snapshot. */
+    cells: ReadonlyArray<{
+        id: string;
+        chart: Vela;
+        symbol: string;
+        timeframe: string;
+    }>;
+    activeCellId: string;
+    setActiveCell(id: string): void;
+}
+
+/** One registered workspace layout. */
+interface LayoutDefinition {
+    /** Stable id (`'4'`, `'2h'`, a plugin's `'6-tall'`, …) — re-registering replaces. */
+    id: string;
+    /** Human-readable label for layout pickers. */
+    label: string;
+    /** Column track weights (`fr` units), left to right. */
+    cols: number[];
+    /** Row track weights, top to bottom. */
+    rows: number[];
+    /**
+     * Optional `grid-template-areas` rows for ASYMMETRIC layouts — one string per row,
+     * one area name per column (e.g. `['main a', 'main b']` = a tall left cell besides
+     * two stacked ones). Omitted ⇒ cells auto-flow row-major in `cells` order.
+     */
+    areas?: string[];
+    /** The layout's SLOTS, in order — pure geometry: `id` keys the slot's grid styles
+     *  and `area` binds it to a named area. A slot id is NOT a cell identity: the cell
+     *  living in slot i is decided by the workspace (its `cells` declaration order),
+     *  so two layouts sharing slot geometry need no id coordination. Built-ins use
+     *  `c1`…`cN`. */
+    cells: Array<{
+        id: string;
+        area?: string;
+    }>;
+}
+
+/** Register (or replace) a workspace layout. Pickers read the registry live. */
+declare function registerLayout(def: LayoutDefinition): void;
+declare function unregisterLayout(id: string): void;
+/** The definition behind a layout id (undefined for unknown ids). */
+declare function layoutDefinition(id: string): LayoutDefinition | undefined;
+/** Every registered layout (registration order) — drives layout pickers. */
+declare function layouts(): LayoutDefinition[];
+/** Register the built-in presets (idempotent — called by the workspace entry point). */
+declare function registerBuiltinLayouts(): void;
+/** Inline styles for the grid container + each cell — PURE (the workspace applies them). */
+declare function gridStyles(def: LayoutDefinition, trackSizes?: TrackSizes): {
+    container: Record<string, string>;
+    perCell: Record<string, Record<string, string>>;
+};
+/**
+ * The active cell after a layout change: keep it when its slot survives, else fall
+ * back to the first slot (the reducer behind `setLayout`; pure for tests).
+ */
+declare function activeAfterLayout(current: string | null, cellIds: readonly string[]): string | null;
+
+/**
+ * The workspace options: the widget's chart vocabulary + the shared shell surface + the
+ * grid's own options. Every chart option given TOP-LEVEL (symbol, timeframe, priceStyle,
+ * upColor, glow, defaultLanguage, …) is the DEFAULT of each cell — `cells` overrides it
+ * per cell with the same words. `height` is the one chart option a grid cannot honor
+ * (the layout sizes cells), so it is omitted from the type.
+ */
+interface VelaWorkspaceOptions extends Omit<VelaOptions, 'height'>, VelaShellOptions {
+    /** Initial layout — a registered id (`'1'`, `'2h'`, `'2v'`, `'4'`, `'8'`, or a
+     *  plugin-registered one) or an inline definition. Default `'4'`. */
+    layout?: string | LayoutDefinition;
+    /** Per-cell overrides of the top-level chart defaults, keyed by a FREE-FORM cell
+     *  name — the name is the cell's durable IDENTITY (persistence, `sync` groups,
+     *  `ws.cell(name)`), never its position: DECLARATION ORDER fills the layout's
+     *  slots (first declared → first slot). Fewer entries than slots ⇒ the remaining
+     *  slots boot on the defaults (auto identity); more ⇒ the extras wait in the pool
+     *  and appear when a larger layout reveals them. Purely-numeric names are rejected
+     *  (JS object keys would reorder them). Same vocabulary as the widget, reduced to
+     *  the per-cell seeds ({@link CellSeed}). */
+    cells?: Record<string, CellSeed>;
+    /** The ONE shared drawing toolbar, docked left of the grid and acting on the active
+     *  cell (per-cell in-chart bars stay hidden either way; a `drawings` object still
+     *  configures tools/persistence per cell). Default true. */
+    drawingToolbar?: boolean;
+    /** Sync links between cells: per kind, `true` = all cells, or a `{cellId: group}`
+     *  record (only same-group cells follow each other). `crosshair` mirrors the
+     *  pointer time as ghost crosshairs on the followers (also toggleable from the
+     *  layout dropdown). Default: everything off. Change at runtime via
+     *  `ws.sync.set(kind, setting)`. */
+    sync?: SyncOptions;
+    /** Above this many cells, EVERY cell uses the canvas2d backend (uniform look inside
+     *  the browser's WebGL-context budget; glow is unavailable there). Default 8; an
+     *  explicit `nativeBackend` other than `'auto'` wins over this policy. */
+    maxWebglCells?: number;
+}
+/** A cell's {@link ScriptRun}, tagged with the cell it ran in. */
+type WorkspaceScriptRun = ScriptRun & {
+    cell: string;
+};
+interface WorkspaceEventMap extends Record<string, unknown> {
+    /** The active cell changed (click/focus in a cell, or `setActiveCell`). */
+    'cell:active': {
+        id: string;
+        prev: string | null;
+    };
+    /**
+     * A script computed in ANY cell — the per-chart `script:run` relayed up with its cell
+     * identity, so one subscription covers the whole grid, cells added by a later layout
+     * change included.
+     */
+    'script:run': WorkspaceScriptRun;
+    /** The grid switched layouts (cells created/destroyed/restored around it). */
+    'layout:changed': {
+        layout: string;
+    };
+    'cell:created': {
+        id: string;
+    };
+    'cell:destroyed': {
+        id: string;
+    };
+    /** The persistable state changed (debounced ~500ms) — re-pull `getState()` if you
+     *  consume it. The signal custom persistence flows build on. */
+    'state:changed': undefined;
+}
+declare class VelaWorkspace {
+    readonly root: HTMLElement;
+    /** The shortcut system — one manager for the whole workspace, routed to the active cell. */
+    readonly keymap: KeymapManager;
+    private readonly gridEl;
+    private readonly events;
+    private readonly feed;
+    private readonly cellsById;
+    private readonly pool;
+    private readonly trackSizes;
+    private readonly splitters;
+    private readonly resizeObserver;
+    private readonly opts;
+    private def;
+    /** Cell identities by SLOT POSITION — `order[i]` lives in the layout's i-th slot.
+     *  Names come from the `cells` declaration order (then the persisted document);
+     *  slots beyond the list get auto identities. Grows, never reorders. */
+    private order;
+    private activeId;
+    private cellBackend;
+    private destroyed;
+    private readonly topbar;
+    private readonly bottombar;
+    private readonly objectTree;
+    private readonly dataWindow;
+    /** The side-panel column, shared by the whole grid. */
+    private readonly dock;
+    private readonly symbolPicker;
+    private readonly indicatorPicker;
+    private readonly tfQuick;
+    private shortcutsHelp;
+    private readonly toast;
+    private readonly glider;
+    private readonly drawToolbar;
+    /** The GLOBAL armed tool/magnet/stay (workspace policy) — re-applied to whichever cell
+     *  takes the focus; only the ACTIVE cell ever holds a non-null tool. Measure/eraser
+     *  stay transient and per-cell: they exit when the focus leaves. */
+    private globalTool;
+    private globalSnap;
+    private globalStay;
+    /** Live subscription to the ACTIVE cell's unified history (rebound on every projection). */
+    private historyUnsub;
+    /** Favorite drawing tools — a WORKSPACE preference (one star set, every cell). */
+    private favs;
+    /** Live sync configuration (mutable copy of the option). */
+    private readonly syncOpts;
+    private readonly persistKey;
+    private readonly storage;
+    private stateTimer;
+    private readonly onUnload;
+    /** Re-entrance guard around one propagation tick: followers' synchronous echoes
+     *  (their setVisibleRange re-emits viewport:changed) must not re-propagate. */
+    private syncBusy;
+    private manifest;
+    /** The shared manifest can no longer change instance sets — resolved, or no
+     *  `indicators` option so nothing ever will. Gates the cells' ledger fallback. */
+    private manifestSettled;
+    private timezone;
+    private openDialogs;
+    private alerts;
+    private alertsMenu;
+    private readonly attachmentDisposers;
+    /** The single grid-wide attribution mark — re-inked on a live theme swap. */
+    private attributionMark;
+    private readonly onRootKeydown;
+    constructor(container: HTMLElement | string, opts?: VelaWorkspaceOptions);
+    /** The cell with identity `id` (its declared name, or `c<N>` when undeclared), or
+     *  undefined when no live cell holds it. */
+    cell(id: string): ChartCell | undefined;
+    /** Every live cell, in slot order. Enumerated over `order` — the IDENTITY space —
+     *  never the layout's positional slot ids, which only coincide with it for a
+     *  workspace whose cells are undeclared. Identities past the current layout size are
+     *  pooled, not live, so they drop out here. */
+    cells(): ChartCell[];
+    /** The ACTIVE cell — the one the shared chrome reflects and acts on. */
+    get active(): ChartCell;
+    /** Shortcut for `active.chart` — the same habit as `widget.chart`. LIVE: read it at
+     *  the point of use; the durable identity to hold is the cell (or its id). */
+    get chart(): Vela;
+    setActiveCell(id: string | null): void;
+    on<K extends keyof WorkspaceEventMap>(event: K, handler: (payload: WorkspaceEventMap[K]) => void): () => void;
+    /** The context handed to contributed actions/attachments (rebuilt per invocation). */
+    context(): WorkspaceWidgetContext;
+    /** Re-project contributed topbar actions + side panels, and mount late-registered attachments. */
+    refreshActions(): void;
+    /** The sync-link control surface: `set(kind, true | {cellId: group} | false)`,
+     *  `get(kind)`, `state()`. Enabling a market/viewport link aligns the followers to
+     *  the ACTIVE cell once, so the grid starts coherent; `crosshair` mirrors the
+     *  pointer time as ghost crosshairs on the followers (also a toggle in the layout
+     *  dropdown). */
+    readonly sync: {
+        set: (kind: SyncKind, setting: SyncSetting | false | undefined) => void;
+        get: (kind: SyncKind) => SyncSetting | undefined;
+        state: () => SyncOptions;
+    };
+    /**
+     * Snapshot the COMPLETE workspace state as a versioned, serializable document:
+     * layout + splitter sizes, active cell, sync links, timezone, and — per slot, live
+     * AND dormant — the market, the renderer's cosmetic config, the user-drawings
+     * document, and the indicator ledger. This is what `persist` writes; hosts build
+     * custom flows on it (server snapshots, share links, templates).
+     */
+    getState(): WorkspaceState;
+    /**
+     * Restore a state document produced by {@link getState} (untrusted-safe: malformed
+     * fields are dropped). Replaces the WHOLE workspace state: prefs, sync links,
+     * layout, and every slot — current cells are rebuilt from the document. A layout id
+     * that is not registered keeps the current grid (register custom layouts first).
+     */
+    applyState(state: unknown): void;
+    /** Set the workspace-global display timezone — applied to EVERY cell. */
+    setTimezone(zone: string): void;
+    /**
+     * Swap the workspace theme at runtime — `'dark'`, `'light'`, or a full custom theme,
+     * applied to the shared chrome (topbar, panels, drawing toolbar) and EVERY cell.
+     * Also reached from any cell's chart settings → Canvas → Theme. The choice sticks:
+     * cells rebuilt by later layout switches reconstruct with it.
+     */
+    setTheme(theme: NonNullable<VelaWorkspaceOptions['theme']>): void;
+    get layout(): LayoutDefinition;
+    /**
+     * Switch the grid. Cells are diffed BY IDENTITY (`order` head of the next size):
+     * surviving cells keep their live charts untouched; cells past the new size
+     * dehydrate into the pool; (re)appearing positions hydrate their identity from
+     * the pool (or its seed). Crossing the WebGL budget rebuilds every cell through
+     * the pool so the backend stays uniform.
+     */
+    setLayout(layout: string | LayoutDefinition): void;
+    resize(): void;
+    destroy(): void;
+    /** Re-project the shared chrome from the ACTIVE cell. The chrome holds no state of
+     *  its own — this is a pure read of the cell, safe to call redundantly. */
+    private projectActiveCell;
+    /** Put keyboard focus back on the active cell's chart surface (after a toolbar press
+     *  stole it) so chart/drawing shortcuts keep working. */
+    private refocusActive;
+    /** Debounced dirty mark: one `state:changed` (+ one storage write in persist mode)
+     *  per burst of edits, flushed hard on unload/destroy. */
+    private markStateDirty;
+    /** Write the current state through the storage adapter now (fire-and-forget). */
+    private persistNow;
+    private resolveLayout;
+    private backendFor;
+    private currentTracks;
+    private applyTracks;
+    /** Apply the grid template (+ per-cell areas) and reposition the splitter strips.
+     *  Geometry is keyed by SLOT (`perCell[slot.id]`); the cell living there is
+     *  `order[i]` — the identity/position decoupling in one line. */
+    private applyGrid;
+    /** Create the cells the current layout wants but don't exist yet (pool-first).
+     *  A slot's CELL IDENTITY is `order[i]` (declaration order — never the slot's own
+     *  positional id); slots past the declared list mint an auto identity once. */
+    private buildCells;
+    /** Per-cell chart subscriptions (trigger ② — the chart instance is stable for the
+     *  cell's whole life, so these live and die with the cell). */
+    private wireCell;
+    private applySyncSetting;
+    /**
+     * Mirror an origin cell's pointer time onto its same-group followers as GHOST
+     * crosshairs (`renderer.setExternalCrosshair`). Leaving the origin propagates
+     * `null` (the event already carries it) and clears every ghost. No busy guard
+     * needed: an external crosshair never re-emits `onCrosshairMove` — the flow is
+     * one-way by port contract, so no echo loop can exist.
+     */
+    private propagateCrosshair;
+    /**
+     * Push an origin cell's visible range onto its same-group followers. Loop-safe two
+     * ways: the busy guard eats the followers' SYNCHRONOUS echoes (their setVisibleRange
+     * re-emits `viewport:changed` in the same tick), and the half-bar epsilon
+     * short-circuits any async residue — a follower already within half of ITS OWN bar
+     * interval is left alone, so cross-timeframe groups settle instead of oscillating.
+     */
+    private propagateViewport;
+    /**
+     * Push an origin cell's symbol/timeframe onto its same-group followers (fired from
+     * `market:changed`). Convergence comes from IDEMPOTENCE, not the guard: a follower's
+     * own (async) `market:changed` propagates back, but every peer already carries the
+     * value, so the cell setters no-op and the wave dies.
+     */
+    private propagateMarket;
+    /** Trigger ② — a cell's market changed: retention + sync always; chrome only if active. */
+    private onCellMarketChanged;
+    /** Trigger ② — a cell's indicator ledger changed: count + picker only if active. */
+    private onCellIndicatorsChanged;
+    /** Timeframe changes routed from the topbar menu / quick entry (chip state follows). */
+    private setActiveTimeframe;
+    /** The aggregated alerts bell — entries carry their cell; selecting one activates it. */
+    private openAlertsMenu;
+    /** Mount registered attachments not yet mounted on this workspace (idempotent per id). */
+    private mountAttachments;
+    /** The default shortcut set — every binding acts on the ACTIVE cell. */
+    private registerDefaultKeys;
+    /** Bare-typing router: letters → symbol search (seeded), digits → timeframe entry. */
+    private routeTyping;
+    private trackDialog;
+    /** Pool a dehydrated slot state (bounded — oldest entries drop past the cap). */
+    private poolSet;
+    /**
+     * Declare every live cell's symbol to the shared bar cache so one cell's load never
+     * evicts the others' history (multi-symbol retention). Keys are CANONICAL tickers —
+     * resolved through the registry when its indexes are ready, raw until then (refreshed
+     * again on `feed.ready()`).
+     */
+    private refreshRetention;
+}
+
+/** Even weights for `n` tracks (the double-click reset). */
+declare function evenTracks(n: number): number[];
+/**
+ * Resize the boundary between tracks `index` and `index+1` by a pixel delta — PURE.
+ * The two neighbors trade weight (their sum, and every other track, is preserved);
+ * both are clamped so neither drops under {@link MIN_TRACK_FRAC} of the total.
+ * `sizePx` is the container's content size along the axis (gaps excluded).
+ */
+declare function resizeTracks(weights: readonly number[], index: number, deltaPx: number, sizePx: number): number[];
+/**
+ * Pixel centers of the INTERNAL track boundaries (`n-1` entries) — where the divider
+ * strips sit. PURE: cumulative weights over the gap-corrected content size.
+ */
+declare function trackOffsets(weights: readonly number[], sizePx: number, gapPx: number): number[];
+
+export { type CellBoot, type CellChartDefaults, type CellNativeInfo, type CellSeed, CellState, ChartCell, type LayoutDefinition, type PooledCellState, SyncKind, SyncOptions, SyncSetting, TrackSizes, VelaWorkspace, type VelaWorkspaceOptions, type WorkspaceEventMap, type WorkspaceScriptRun, WorkspaceState, type WorkspaceStorage, type WorkspaceWidgetContext, activeAfterLayout, evenTracks, gridStyles, layoutDefinition, layouts, memoryStorageAdapter, rangesWithin, registerBuiltinLayouts, registerLayout, resizeTracks, syncTargets, trackOffsets, unregisterLayout };