@christtrade/depth 0.12.21

package/types/core/WasmPluginHost.d.ts

@@ -0,0 +1,39 @@
+export interface WasmPluginExports {
+    memory: WebAssembly.Memory;
+    alloc(bytes: number): number;
+    dealloc(ptr: number, bytes: number): void;
+    init(barsPtr: number, barRows: number, tradesPtr: number, tradeRows: number, barMs: number): number;
+    update?(barsPtr: number, barRows: number, tradesPtr: number, tradeRows: number, barMs: number): number;
+    set_params?(ptr: number, bytes: number): void;
+}
+export interface WasmBar {
+    ts: bigint | number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+export interface WasmTrade {
+    ts: bigint | number;
+    price: number;
+    size: number;
+    side: string;
+}
+export declare class WasmPlugin {
+    private readonly exports;
+    private readonly pluginId;
+    constructor(exports: WasmPluginExports, pluginId: string);
+    /** Without one, every horizon tick re-runs init over the full window. */
+    get hasUpdate(): boolean;
+    /** Hands the plugin's declared params over as JSON. No-op if it takes none. */
+    setParams(params: Record<string, unknown>): void;
+    init(bars: WasmBar[], trades: WasmTrade[], barNs: bigint): Float64Array | null;
+    update(bars: WasmBar[], trades: WasmTrade[], barNs: bigint): Float64Array | null;
+    private alloc;
+    private call;
+    private readResult;
+}
+export declare function instantiateWasmPlugin(wasmUrl: string, pluginId: string): Promise<WasmPlugin>;
+/** Drops a module from the compile cache, so the next load refetches it. */
+export declare function evictWasmModule(wasmUrl: string): void;

package/types/core/index.d.ts

@@ -0,0 +1,70 @@
+export { DepthChart } from './DepthChart';
+export type { ChartOptions } from './DepthChart';
+export { useDepthChart } from '../react/useDepthChart';
+export { default as Depth } from '../ChartOuter';
+export type { DepthProps } from '../ChartOuter';
+export { ExecutionEngine } from './ExecutionEngine';
+export { DataEngine } from './DataEngine';
+export type { DataEngineConfig, ChartDataSnapshot } from './DataEngine';
+export { TypedEventBus } from './TypedEventBus';
+export type { ChartEvents } from './TypedEventBus';
+export { RenderEngine } from './RenderEngine';
+export type { DrawParams } from './RenderEngine';
+export type { IDataAdapter, DataLevel, TickEvent, OhlcvBar, L2Snapshot, MboEvent, } from '../interfaces/IDataAdapter';
+export type { IExecutionAdapter } from '../interfaces/IExecutionAdapter';
+export { LiveTransformer } from '../interfaces/ICoordinateTransformer';
+export type { ICoordinateTransformer, PriceScaleMode, TransformedDrawHook, } from '../interfaces/ICoordinateTransformer';
+export { PluginRegistry } from './PluginRegistry';
+export type { PluginIcon, InstalledPlugin } from './PluginRegistry';
+export type { PluginCatalogEntry, PluginStartupEntry, PluginStartupRecord, } from './plugin-startup';
+export type { StyleField } from '../components/drawings/drawing-settings-dialog';
+export type { PluginDrawingToolDef } from './DrawingRegistry';
+export type { PluginDataSource } from './DataSourceRegistry';
+export { ChartModel } from './ChartModel';
+export type { ChartModelInit, ChartPluginRef, ChartPaneState } from './ChartModel';
+export { DrawingStore } from './DrawingStore';
+export type { ChartPlugin, PluginType, Permission, PluginManifest, PluginContext, PluginDataSnapshot, DrawingPlugin, ChartTypePlugin, ChartTypeRenderContext, DataSourcePlugin, IndicatorPlugin, IndicatorRenderContext, } from '../interfaces/plugins';
+export { createScriptedPlugin } from './ScriptedPlugin';
+export { isCompatible, DATA_LEVEL_LABELS, incompatibleReason } from './processing/data-level';
+export { processL3Chunk, mergeL3Chunks } from './processing/l3-processor';
+export type { ProcessedL3Chunk, L3DataChunk } from './processing/l3-processor';
+export { processOhlcvChunk, processOhlcvWithSupplemental } from './processing/ohlcv-processor';
+export type { OhlcvDataChunk } from './processing/ohlcv-processor';
+export { processTickChunk } from './processing/tick-processor';
+export type { TickDataChunk } from './processing/tick-processor';
+export { processL2Chunk } from './processing/l2-processor';
+export type { L2DataChunk } from './processing/l2-processor';
+export type { DataChunk } from './processing/data-chunk';
+export { isEmptyChunk } from './processing/data-chunk';
+export type { TradePoint, PriceHistory, ViewBounds, OhlcvBarMs } from '../lib/types';
+export type { Timeframe } from '../lib/timeframes';
+export type { DrawingTool } from '../lib/types/drawing-types';
+export type { FootprintBar, FootprintOptions } from '../lib/types/footprint';
+export type { ChartSettings } from '../lib/types/chart-settings';
+export { DEFAULT_CHART_SETTINGS } from '../lib/types/chart-settings';
+export type { PlaceOrderRequest, L3EngineOptions, FeeSchedule } from '../lib/matchingEngine';
+export { createL3MatchingEngine, feeScheduleFor, MICRO_FEE_SCHEDULE, NQ_FEE_SCHEDULE, ZERO_FEE_SCHEDULE, } from '../lib/matchingEngine';
+export { SimulatedMarketAdapter, createSimulatedAdapter } from '../lib/createSimulatedAdapter';
+export { AccountManager } from './AccountManager';
+export type { AccountOptions, AccountSaveState } from './AccountManager';
+export type { ChartSaveState, LayoutDescriptor } from './DepthChart';
+export { SAVE_VERSION, stringifyChartSave, parseChartSave } from './DepthChart';
+export type { IAccountAdapter, AccountAdapterCallbacks, AccountSnapshot, } from '../interfaces/IAccountAdapter';
+export { AccountSummary } from '../components/account/AccountSummary';
+export { QuickTradingButtons } from '../components/trading/QuickTradingButtons';
+export { OrderPanel } from '../components/trading/OrderPanel';
+export type { OrderPanelProps } from '../components/trading/OrderPanel';
+export { AMOUNT_MODES, amountFromQty, contractValue, deriveTicket, levelPrice, levelTicks, moneyPerTick, priceDecimals, qtyFromAmount, roundQty, roundToTick, specForSymbol, tickSizeOf, tickValueOf, ticketFromPosition, ticksBetween, } from '../components/trading/order-math';
+export type { AmountMode, Ticket, TicketInput, TicketProblem, } from '../components/trading/order-math';
+export { isMarketOpen, nextOpenNs, prevCloseNs, clipToSession, getSessionStatus, } from './SessionUtils';
+export type { SessionWindow, SessionStatus } from './SessionUtils';
+export type { SymbolInfo, SymbolType, SymbolSearchMode, SymbolSearchRequest, SymbolSearchResponse, AdapterCapabilities, TradingSession, TradingSubsession, DayOfWeek, SessionCorrection, PriceFormat, FractionalFormat, ContractSpec, } from '../interfaces/IDataAdapter';
+/** The built-in matcher, so server-side adapters can rank like the picker does. */
+export { searchSymbolsLocally, normalizeSymbolSearchResponse } from '../lib/symbol-search';
+export { SessionMapper, createSessionMapper } from './SessionMapper';
+export type { SessionSegment } from './SessionMapper';
+export { walkBackMarketNs } from './SessionUtils';
+export { STORAGE_NAMESPACE, StorageKey, isPersistenceEnabled, setPersistenceEnabled, onPersistenceChange, onChartStorageChange, clearChartStorage, chartStorageKeys, chartStorageSize, serializeChartPreferences, restoreChartPreferences, readJSON, writeJSON, setChartStorageBackend, } from '../lib/storage';
+export type { ChartPreferences, ChartStorageBackend } from '../lib/storage';
+export { importTradingViewSettings, hasTradingViewSettings, readTradingViewChartSettings, readTradingViewFavoriteDrawings, resetTradingViewImport, } from '../lib/tradingview-import';
+export type { TradingViewImportResult } from '../lib/tradingview-import';

package/types/core/plugin-startup.d.ts

@@ -0,0 +1,33 @@
+import type { PluginType } from '../interfaces/plugins/IChartPlugin';
+/**
+ * A plugin the host has code for, whether or not it is loaded. Supplied by
+ * `chart.setPluginCatalog()`; the chart resolves ids against it when it loads
+ * startup plugins and when the plugin manager offers one.
+ */
+export interface PluginCatalogEntry {
+    id: string;
+    /** Source, in the chart's plugin scripting language. */
+    code: string;
+    name?: string;
+    type?: PluginType;
+    description?: string;
+    group?: string;
+}
+/**
+ * What should happen to a plugin when the chart opens.
+ *
+ * `autostart: false` is a tombstone, not an absence - it says the user turned
+ * this plugin off, which a save document restored from another session must not
+ * override. An id with no entry at all has no opinion attached.
+ */
+export interface PluginStartupEntry {
+    /** Install the plugin when the chart opens. */
+    autostart: boolean;
+    /** Indicators only: also put an instance on a pane. */
+    activate?: boolean;
+}
+export type PluginStartupRecord = Record<string, PluginStartupEntry>;
+export declare function ptrace(...args: unknown[]): void;
+export declare function readPluginStartup(): PluginStartupRecord;
+/** Merge a patch into one plugin's entry. `null` forgets the plugin entirely. */
+export declare function writePluginStartup(id: string, patch: Partial<PluginStartupEntry> | null): PluginStartupRecord;

package/types/core/processing/data-chunk.d.ts

@@ -0,0 +1,37 @@
+import type { OhlcvBar } from '../../interfaces/IDataAdapter';
+import type { SerialTrade } from '../../lib/types';
+import type { PriceHistory } from '../../lib/types';
+import type { FootprintBar } from '../../lib/types/footprint';
+export interface L3DataChunk {
+    kind: 'l3';
+    /** 20-byte compact encoding of all MBO events. L3-only. */
+    compactBuf: ArrayBuffer;
+    trades: SerialTrade[];
+    priceHistory: PriceHistory[];
+    footprintBars: FootprintBar[];
+    dataStart: number;
+    dataEnd: number;
+}
+export interface TickDataChunk {
+    kind: 'tick';
+    trades: SerialTrade[];
+    priceHistory: PriceHistory[];
+    footprintBars: FootprintBar[];
+    dataStart: number;
+    dataEnd: number;
+}
+export interface OhlcvDataChunk {
+    kind: 'ohlcv';
+    ohlcvBars: OhlcvBar[];
+    dataStart: number;
+    dataEnd: number;
+}
+export interface L2DataChunk {
+    kind: 'l2';
+    priceHistory: PriceHistory[];
+    dataStart: number;
+    dataEnd: number;
+}
+export type DataChunk = L3DataChunk | TickDataChunk | OhlcvDataChunk | L2DataChunk;
+export declare function isEmptyChunk(chunk: DataChunk): boolean;
+export declare function mergeChunks(a: DataChunk, b: DataChunk): DataChunk;

package/types/core/processing/data-level.d.ts

@@ -0,0 +1,13 @@
+import type { DataLevel } from '../../interfaces/IDataAdapter';
+/**
+ * Does `actual` satisfy the `required` minimum level?
+ *
+ * @example
+ * isCompatible('ohlcv', 'l3')    // true, l3 can serve ohlcv plugins
+ * isCompatible('l3', 'ohlcv')    // false, ohlcv cannot serve l3 plugins
+ */
+export declare function isCompatible(required: DataLevel, actual: DataLevel): boolean;
+/** How a data level is written for the user. Nobody outside the code says "l3". */
+export declare const DATA_LEVEL_LABELS: Record<DataLevel, string>;
+/** The one line shown when something is refused for want of richer data. */
+export declare function incompatibleReason(required: DataLevel, actual: DataLevel): string;

package/types/core/processing/l2-processor.d.ts

@@ -0,0 +1,10 @@
+import type { L2Snapshot } from '../../interfaces/IDataAdapter';
+import type { PriceHistory } from '../../lib/types';
+export interface L2DataChunk {
+    kind: 'l2';
+    priceHistory: PriceHistory[];
+    /** Unix ms timestamps */
+    dataStart: number;
+    dataEnd: number;
+}
+export declare function processL2Chunk(snapshots: L2Snapshot[], _barNs: bigint): L2DataChunk;

package/types/core/processing/l3-processor.d.ts

@@ -0,0 +1,26 @@
+import { type FootprintBar, type FootprintOptions } from '../../lib/types/footprint';
+import type { MboEvent, PriceHistory } from '../../lib/types';
+import type { SerialTrade } from '../../lib/types';
+export interface ProcessedL3Chunk {
+    kind: 'l3';
+    /** 20-byte compact encoding of all MBO events. L3-only. */
+    compactBuf: ArrayBuffer;
+    trades: SerialTrade[];
+    priceHistory: PriceHistory[];
+    footprintBars: FootprintBar[];
+    /** ISO timestamp of the first event. */
+    dataStart: number;
+    /** ISO timestamp of the last event. */
+    dataEnd: number;
+}
+export type L3DataChunk = ProcessedL3Chunk;
+/**
+ * Process a batch of L3 MboEvents into the internal representation.
+ *
+ * @param events    Raw MBO events, sorted ascending by ts_event.
+ * @param barNs     Bar size in ns for the footprint. Pass 0n to skip it.
+ * @param fpOptions Forwarded to buildFootprint().
+ */
+export declare function processL3Chunk(events: MboEvent[], barNs: bigint, fpOptions?: FootprintOptions): ProcessedL3Chunk;
+/** Merge two chunks in order, earlier one first. */
+export declare function mergeL3Chunks(a: ProcessedL3Chunk, b: ProcessedL3Chunk): ProcessedL3Chunk;

package/types/core/processing/ohlcv-processor.d.ts

@@ -0,0 +1,14 @@
+import type { OhlcvBar, SupplementalBarSet } from '../../interfaces/IDataAdapter';
+export interface OhlcvDataChunk {
+    kind: 'ohlcv';
+    ohlcvBars: OhlcvBar[];
+    /** Unix ms timestamps */
+    dataStart: number;
+    dataEnd: number;
+    supplemental?: Array<{
+        resolution: bigint;
+        bars: OhlcvBar[];
+    }>;
+}
+export declare function processOhlcvChunk(bars: OhlcvBar[], _barNs: bigint): OhlcvDataChunk;
+export declare function processOhlcvWithSupplemental(primaryBars: OhlcvBar[], _supplemental: SupplementalBarSet[], barNs: bigint): OhlcvDataChunk;

package/types/core/processing/tick-processor.d.ts

@@ -0,0 +1,14 @@
+import type { TickEvent } from '../../interfaces/IDataAdapter';
+import type { SerialTrade } from '../../lib/types';
+import type { PriceHistory } from '../../lib/types';
+import type { FootprintBar } from '../../lib/types/footprint';
+export interface TickDataChunk {
+    kind: 'tick';
+    trades: SerialTrade[];
+    priceHistory: PriceHistory[];
+    footprintBars: FootprintBar[];
+    /** Unix ms timestamps */
+    dataStart: number;
+    dataEnd: number;
+}
+export declare function processTickChunk(ticks: TickEvent[], barNs: bigint): TickDataChunk;

package/types/core/script-dsl.d.ts

@@ -0,0 +1,20 @@
+export declare const PluginType: Readonly<{
+    readonly indicator: "indicator";
+    readonly drawing: "drawing";
+    readonly chartType: "chart-type";
+    readonly dataSource: "data-source";
+    readonly extension: "extension";
+}>;
+export declare const DataLevel: Readonly<{
+    readonly mbo: "l3";
+    readonly l3: "l3";
+    readonly l2: "l2";
+    readonly ohlcv: "ohlcv";
+    readonly tick: "tick";
+}>;
+export declare const Layout: Readonly<{
+    readonly overlay: "overlay";
+    readonly pane: "pane";
+}>;
+/** The DSL globals as one bag, for splatting into an eval scope. */
+export declare const SCRIPT_DSL: Record<string, unknown>;

package/types/core/script-scope.d.ts

@@ -0,0 +1,4 @@
+/** Resolves a handler source string against a prepared script scope. */
+export type ScopedCompiler = <T extends Function>(src: string | null | undefined) => T | null;
+export declare function compileFromSrc<T extends Function>(src: string | null | undefined): T | null;
+export declare function makeScopedCompiler(script: string, extra?: Record<string, unknown>, onError?: (msg: string) => void): ScopedCompiler;

package/types/core/script.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/types/hooks/useCellBridges.d.ts

@@ -0,0 +1,36 @@
+import { DepthChart, ExecutionEngine } from '../core';
+import { TypedEventBus } from '../core/TypedEventBus';
+export declare const MAX = 8;
+export declare function useTradingBridge(symbol: string, externalEngine?: ExecutionEngine, eventBus?: TypedEventBus, chart?: DepthChart): {
+    symbol: string;
+    trading: import("./useTradingState").UseTradingStateReturn;
+    executionEngine: ExecutionEngine;
+    redrawFnRef: import("react").MutableRefObject<() => void>;
+    tradingEvents: import("react").MutableRefObject<any[]>;
+};
+export type TradingBridge = ReturnType<typeof useTradingBridge>;
+export interface CellBridges {
+    /**
+     * Indexed by cell. Cells on the same symbol get the *same* bridge object -
+     * that is the point, so don't dedupe by identity and don't assume
+     * `byCell.length` distinct engines.
+     */
+    byCell: TradingBridge[];
+    /**
+     * One entry per distinct symbol on screen.
+     *
+     * Anything fanned out to engines - data ingest, playback seeks - must walk
+     * this, not `byCell`: handing a bar stream to a shared engine once per cell
+     * showing it replays the same bars through the fill logic N times.
+     */
+    bySymbol: TradingBridge[];
+}
+export declare function useCellBridges(symbols: string[], eventBus: TypedEventBus, chart?: DepthChart, 
+/**
+ * The one ExecutionEngine every bridge registers its book with - normally
+ * `chart.executionEngine`, which is also what plugins call and what the
+ * DataEngine settles jump gaps through. Leave it out and each bridge gets a
+ * private wrapper, which is fine for a single chart but leaves those two
+ * holding an engine with no books in it.
+ */
+engine?: ExecutionEngine): CellBridges;

package/types/hooks/useChartData.d.ts

@@ -0,0 +1,153 @@
+import { type MutableRefObject, type RefObject } from 'react';
+import { type BookState } from '../lib/types';
+import { type PriceHistory, type TradePoint, type ViewBounds, type OhlcvBarMs } from '../lib/types';
+import { type FootprintBar } from '../lib/types/footprint';
+import { type CompactBuffer } from '../lib/compact-buffer';
+import { type SerialTrade } from '../lib/types';
+import { SymbolInfo } from '../interfaces/IDataAdapter';
+import { type DataLevel, type TradingSession } from '../interfaces/IDataAdapter';
+import { type LiveTransformer } from '../interfaces/ICoordinateTransformer';
+import { type DomPanelHandle } from '../lib/types';
+import { type Indicator, type ChartPane, type Rect } from '../lib/types/indicator-types';
+import { type Timeframe } from '../lib/timeframes';
+import { type ChartSettings } from '../lib/types/chart-settings';
+import { type TypedEventBus } from '../core/TypedEventBus';
+import { type RenderEngine } from '../core/RenderEngine';
+import { type SessionMapper } from '../core/SessionMapper';
+import { ohlcvBucketRange } from '../lib/bar-grid';
+import { type SessionStatus } from '../core/SessionUtils';
+export { ohlcvBucketRange };
+export declare function aggregateOhlcvBars(bars: OhlcvBarMs[], targetBarNs: bigint, sessionMapper?: SessionMapper | null): OhlcvBarMs[];
+/**
+ * Incrementally prepend newly fetched bars to an existing aggregated display array.
+ * O(new_bars) instead of O(total_bars) - only re-aggregates the new chunk.
+ * Handles the boundary bucket that might straddle the old/new data boundary.
+ */
+export declare function prependAggregatedOhlcvBars(newBars: OhlcvBarMs[], existingDisplay: OhlcvBarMs[], targetBarNs: bigint, sessionMapper?: SessionMapper | null): OhlcvBarMs[];
+export declare function autoFitPriceAxis(view: ViewBounds, priceHistory: PriceHistory[], trades: TradePoint[], bars: OhlcvBarMs[], openBar: FootprintBar | null, settings: ChartSettings, horizon: bigint, dataLevel?: DataLevel): void;
+export declare function applyHorizonScrollEasing(t: number, type: string): number;
+export interface UseChartDataParams {
+    eventBus: TypedEventBus;
+    activeTimeframeRef: MutableRefObject<Timeframe>;
+    horizonRef: MutableRefObject<bigint>;
+    chartSettingsRef: MutableRefObject<ChartSettings>;
+    sessionMapperRef: MutableRefObject<SessionMapper>;
+    resolvedSessionRef: MutableRefObject<TradingSession | null>;
+    resolvedSymbolInfoRef: MutableRefObject<SymbolInfo>;
+    viewRef: MutableRefObject<ViewBounds | null>;
+    /** Auto-computed right price-axis width (css px). */
+    priceScaleWidthRef: MutableRefObject<number>;
+    panesRef: MutableRefObject<ChartPane[]>;
+    indicatorsRef: MutableRefObject<Indicator[]>;
+    transformer: LiveTransformer;
+    renderEngineRef: MutableRefObject<RenderEngine | null>;
+    isYAxisAutoRef: MutableRefObject<boolean>;
+    isDragging: MutableRefObject<boolean>;
+    dragMode: MutableRefObject<string>;
+    layoutsCacheRef: MutableRefObject<Record<string, Rect>>;
+    baseCanvasRef: RefObject<HTMLCanvasElement>;
+    selectedDrawingIdRef: MutableRefObject<string | null>;
+    pushDrawParamsRef: MutableRefObject<() => void>;
+    autofitIndicatorPanesRef: MutableRefObject<() => void>;
+    updateSettingsBarPosRef: MutableRefObject<(id: string | null) => void>;
+    resetViewRef: MutableRefObject<() => void>;
+    syncPixelLayoutsRef: MutableRefObject<(panes?: ChartPane[]) => void>;
+    doBaseRedrawRef: MutableRefObject<() => void>;
+    setIndicators: (inds: Indicator[]) => void;
+    setPanes: (updater: ((prev: ChartPane[]) => ChartPane[]) | ChartPane[]) => void;
+    getPanel: () => DomPanelHandle | null;
+    onDataBoundsChange?: (start: bigint, end: bigint) => void;
+    onHorizonUpdate: (h: bigint) => void;
+    cellSymbol: string;
+    /** Which cell this is, for events that are this pane's own business. */
+    cellId: number;
+    managed?: boolean;
+    externalDomPanelRef?: MutableRefObject<DomPanelHandle | null>;
+    hidePriceScale: boolean;
+    hideTimeScale: boolean;
+    /** The loaded symbol serves a different data level than the last one did. */
+    onDataLevelChangeRef: MutableRefObject<() => void>;
+}
+export interface ChartDataResult {
+    compactBufRef: MutableRefObject<CompactBuffer>;
+    allTradesRef: MutableRefObject<TradePoint[]>;
+    tradesRef: MutableRefObject<TradePoint[]>;
+    priceHistoryRef: MutableRefObject<PriceHistory[]>;
+    allPriceHistoryRef: MutableRefObject<PriceHistory[]>;
+    footprintBarsRef: MutableRefObject<FootprintBar[]>;
+    ohlcvBarsRef: MutableRefObject<{
+        barNs: bigint;
+        bars: OhlcvBarMs[];
+        display: OhlcvBarMs[];
+    }>;
+    previewBarsRef: MutableRefObject<OhlcvBarMs[]>;
+    openBarRef: MutableRefObject<FootprintBar | null>;
+    openBarTsRef: MutableRefObject<bigint>;
+    openBarTradeCountRef: MutableRefObject<number>;
+    phCursorRef: MutableRefObject<number>;
+    playheadIdxRef: MutableRefObject<number>;
+    replayedUpToRef: MutableRefObject<number>;
+    dataLevelRef: MutableRefObject<DataLevel | null>;
+    datasetStartRef: MutableRefObject<bigint>;
+    datasetEndRef: MutableRefObject<bigint>;
+    prevSessionStatusRef: MutableRefObject<SessionStatus | null>;
+    candleCacheRef: MutableRefObject<Map<bigint, {
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+        delta: number;
+    }> | null>;
+    supplementalBarsRef: MutableRefObject<any>;
+    serialisedTradesBufRef: MutableRefObject<ArrayBuffer | null>;
+    serialisedPhBufRef: MutableRefObject<ArrayBuffer | null>;
+    serialisedOhlcvBufRef: MutableRefObject<ArrayBuffer | null>;
+    fpRebuildSeqRef: MutableRefObject<number>;
+    rawBitmapRef: MutableRefObject<ImageBitmap | null>;
+    heatmapBitmapRef: MutableRefObject<ImageBitmap | null>;
+    heatmapBitmapOffsetsRef: MutableRefObject<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null>;
+    cacheBoundsRef: MutableRefObject<ViewBounds | null>;
+    liveBookRef: MutableRefObject<BookState>;
+    prevHorizonBarRef: MutableRefObject<bigint>;
+    lastBarAdvanceTimeRef: MutableRefObject<number>;
+    horizonScrollAnimRef: MutableRefObject<any>;
+    workerRef: MutableRefObject<Worker | null>;
+    dataWorkerRef: MutableRefObject<Worker | null>;
+    indicatorWorkerRef: MutableRefObject<Worker | null>;
+    workerReadyRef: MutableRefObject<boolean>;
+    workerRequestIdRef: MutableRefObject<number>;
+    _internalDomPanelRef: MutableRefObject<DomPanelHandle | null>;
+    seekHorizon: (horizon: bigint, triggerResample?: boolean, hotPath?: boolean, 
+    /** Explicit navigation: bring the view along instead of leaving it behind. */
+    recenter?: boolean) => void;
+    applyHorizon: (horizon: bigint, triggerResample?: boolean, hotPath?: boolean) => void;
+    scheduleResample: () => void;
+    runIndicatorWorker: (trades: SerialTrade[], barNs: bigint) => void;
+    getTradesUpToHorizon: (horizon: bigint) => TradePoint[];
+    requestFootprintRebuild: () => void;
+    syncOhlcvOpenBar: (horizon: bigint) => void;
+    rebuildCandleCache: (trades: TradePoint[], barNs: bigint) => void;
+    rebuildContrastBitmap: (contrast: number) => void;
+    foldEventsIntoOpenBar: (prevIdx: number, newIdx: number, barNs: bigint, horizon: bigint) => boolean;
+    mergeOpenBar: () => void;
+    resetPlayhead: (idx: number) => void;
+    fpSettingsFromRef: () => {
+        imbalanceRatio: number;
+        stackMinCount: number;
+        diagRatio: number;
+        absorptionMult: number;
+        absorptionDeltaFrac: number;
+    };
+    cancelAndRestartWorker: () => void;
+    runHorizonAdvance: (horizon: bigint) => void;
+    updatePriceHistoryToRawIdx: (rawIdx: number) => void;
+    findPriceHistoryIdx: (horizon: bigint) => number;
+    loadData: () => void;
+}
+export declare function useChartData(p: UseChartDataParams): ChartDataResult;

package/types/hooks/useChartHandlers.d.ts

@@ -0,0 +1,94 @@
+import { type MutableRefObject, type RefObject } from 'react';
+import { type Drawing } from '../lib/types/drawing-types';
+import { type ChartPane, type Indicator, type Rect } from '../lib/types/indicator-types';
+import { type ViewBounds, type TradeLine, type TradePoint, type PriceHistory, type OhlcvBarMs } from '../lib/types';
+import { type Timeframe } from '../lib/timeframes';
+import { type RenderEngine } from '../core/RenderEngine';
+import { type LiveTransformer } from '../interfaces/ICoordinateTransformer';
+import { type DataLevel } from '../interfaces/IDataAdapter';
+import { type CompactBuffer } from '../lib/compact-buffer';
+import { type ChartSettings } from '../lib/types/chart-settings';
+import { type SessionMapper } from '../core/SessionMapper';
+import { type FootprintBar } from '../lib/types/footprint';
+import { type SerialTrade } from '../lib/types';
+export interface UseChartHandlersParams {
+    drawingsRef: MutableRefObject<Drawing[]>;
+    drawingsCanvasRef: RefObject<HTMLCanvasElement>;
+    viewRef: MutableRefObject<ViewBounds | null>;
+    selectedDrawingIdRef: MutableRefObject<string | null>;
+    indicatorsRef: MutableRefObject<Indicator[]>;
+    panesRef: MutableRefObject<ChartPane[]>;
+    ohlcvBarsRef: MutableRefObject<{
+        barNs: bigint;
+        bars: OhlcvBarMs[];
+        display: OhlcvBarMs[];
+    }>;
+    sessionMapperRef: MutableRefObject<SessionMapper>;
+    activeTimeframeRef: MutableRefObject<Timeframe>;
+    horizonRef: MutableRefObject<bigint>;
+    phCursorRef: MutableRefObject<number>;
+    candleCacheRef: MutableRefObject<Map<bigint, any> | null>;
+    tradesRef: MutableRefObject<TradePoint[]>;
+    openBarRef: MutableRefObject<FootprintBar | null>;
+    openBarTsRef: MutableRefObject<bigint>;
+    openBarTradeCountRef: MutableRefObject<number>;
+    compactBufRef: MutableRefObject<CompactBuffer>;
+    isYAxisAutoRef: MutableRefObject<boolean>;
+    priceHistoryRef: MutableRefObject<PriceHistory[]>;
+    dataLevelRef: MutableRefObject<DataLevel | null>;
+    previewBarsRef: MutableRefObject<OhlcvBarMs[]>;
+    chartSettingsRef: MutableRefObject<ChartSettings>;
+    tradeLinesRef: MutableRefObject<TradeLine[]>;
+    hoveringLegend: MutableRefObject<boolean>;
+    renderEngineRef: MutableRefObject<RenderEngine | null>;
+    transformer: LiveTransformer;
+    maximizedPaneId: string | null;
+    setIndicators: (inds: Indicator[]) => void;
+    setPanes: (updater: ChartPane[] | ((prev: ChartPane[]) => ChartPane[])) => void;
+    setSelectedDrawingId: (id: string | null) => void;
+    setSettingsBarPos: (pos: {
+        x: number;
+        y: number;
+    } | null) => void;
+    setIndicatorSettingsId: (id: string | null) => void;
+    setActiveTimeframe: (tf: Timeframe) => void;
+    setMaximizedPaneId: (updater: string | null | ((prev: string | null) => string | null)) => void;
+    pushDrawParams: () => void;
+    updateSettingsBarPos: (id: string | null) => void;
+    recomputeLayouts: () => void;
+    scheduleResample: () => void;
+    runIndicatorWorker: (trades: SerialTrade[], barNs: bigint) => void;
+    getTradesUpToHorizon: (horizon: bigint) => TradePoint[];
+    getLayouts: () => Record<string, Rect>;
+    rebuildCandleCache: (trades: TradePoint[], barNs: bigint) => void;
+    syncOhlcvOpenBar: (horizon: bigint) => void;
+    updatePriceHistoryToRawIdx: (rawIdx: number) => void;
+    findPriceHistoryIdx: (horizon: bigint) => number;
+    resetXAxis: () => void;
+    resetYAxis: () => void;
+    autofitIndicatorPanes: () => void;
+    hideTimeScale: boolean;
+    priceScaleWidthRef: MutableRefObject<number>;
+}
+export interface UseChartHandlersResult {
+    handleUpdateDrawing: (id: string, patch: Partial<Drawing>) => void;
+    handleDeleteDrawing: (id: string) => void;
+    handleDeleteDrawings: () => void;
+    handleDuplicateDrawing: (id: string) => void;
+    handleToggleIndicator: (indicatorId: string) => void;
+    handleRemoveIndicator: (indicatorId: string) => void;
+    handleOpenIndicatorSettings: (indicatorId: string) => void;
+    handleRemoveIndicators: () => void;
+    handleMoveUp: (paneId: string) => void;
+    handleMoveDown: (paneId: string) => void;
+    handleRemovePane: (paneId: string) => void;
+    handleExpand: (paneId: string) => void;
+    handleCollapse: (paneId: string) => void;
+    handleMaximize: (paneId: string) => void;
+    handleEnter: () => void;
+    handleLeave: () => void;
+    handleTimeframeChange: (tf: Timeframe) => void;
+    handleAddIndicator: (defId: string) => void;
+    handleAddTradeLine: (opts: TradeLine) => void;
+}
+export declare function useChartHandlers(p: UseChartHandlersParams): UseChartHandlersResult;