@christtrade/depth 0.12.21

package/types/interfaces/IExecutionAdapter.d.ts

@@ -0,0 +1,71 @@
+import type { PlaceOrderRequest } from '../lib/matchingEngine';
+import type { BracketAmendment, Fill, Order, Position, PositionClose, PriceTick } from '../lib/types/trading-types';
+import type { MboEvent, OhlcvBar } from './IDataAdapter';
+import type { SerialTrade } from '../lib/types';
+import type { PriceHistory } from '../lib/types';
+export interface IExecutionAdapter {
+    readonly id: string;
+    /**
+     * Called once per L3 event during playback or live streaming.
+     * The adapter decides internally whether to process it.
+     */
+    onMboEvent(event: MboEvent, ts: bigint): void;
+    /**
+     * Called every time the best bid/ask changes.
+     * The adapter uses this to check order triggers.
+     */
+    onTick(tick: PriceTick): void;
+    placeOrder(request: PlaceOrderRequest): string | Promise<string>;
+    cancelOrder(orderId: string): void | Promise<void>;
+    amendOrder(orderId: string, newPrice: number): void | Promise<void>;
+    amendBracket(amendment: BracketAmendment): void | Promise<void>;
+    closePosition(positionId: string): void | Promise<void>;
+    reversePosition?(positionId: string): void;
+    getOpenPositions(): Position[];
+    getWorkingOrders(): Order[];
+    getClosedPositions(): PositionClose[];
+    getPrice(): number;
+    /** Data pipeline hooks - called by ExecutionEngine when new data arrives. */
+    ingestCompactBuf?(buf: ArrayBuffer): void;
+    /** `barNs` is the bar period; without it the adapter must infer it from bar spacing. */
+    ingestOhlcvBars?(bars: OhlcvBar[], barNs?: bigint): void;
+    /**
+     * Bars streamed in ahead of the playhead, as an extension of what the
+     * adapter already holds. Implement it if ingestOhlcvBars replaces state
+     * rather than merging; without it, extensions fall back to ingestOhlcvBars.
+     */
+    appendOhlcvBars?(bars: OhlcvBar[], barNs?: bigint): void;
+    ingestSupplementalBars?(bars: Array<{
+        time: number;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }>): void;
+    appendSupplementalBars?(bars: Array<{
+        time: number;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }>): void;
+    ingestTicks?(trades: SerialTrade[]): void;
+    ingestPriceHistory?(history: PriceHistory[]): void;
+    /** Streamed extensions; fall back to the ingest form when not implemented. */
+    appendTicks?(trades: SerialTrade[]): void;
+    appendPriceHistory?(history: PriceHistory[]): void;
+    appendCompactBuf?(buf: ArrayBuffer): void;
+    seekTo?(tNs: bigint): void;
+    totalFeesPaid?(): number;
+    totalRealizedPnl?(): number;
+    /**
+     * Subscribe to engine output events.
+     * The ExecutionEngine calls this so adapters can push fills
+     * back to the chart without knowing about the event bus.
+     */
+    onFill?: (fill: Fill) => void;
+    onPositionUpdate?: (position: Position) => void;
+    destroy(): void;
+}

package/types/interfaces/plugins/IChartPlugin.d.ts

@@ -0,0 +1,254 @@
+/**
+ * Base contract for all DepthChart plugins. Every plugin type
+ * (drawing, chart-type, indicator, data-source, extension) extends
+ * ChartPlugin and is installed through PluginContext.
+ */
+import type { TypedEventBus, InterceptableEvent, Interceptor } from '../../core/TypedEventBus';
+import type { RenderEngine, DrawHook } from '../../core/RenderEngine';
+import type { ExecutionEngine } from '../../core/ExecutionEngine';
+import type { GlobalChartBus } from '../../core/GlobalChartBus';
+import type { LiveTransformer } from '../ICoordinateTransformer';
+import type { DataLevel, OhlcvBar, SymbolInfo, TickEvent } from '../IDataAdapter';
+import type { SerialTrade, PriceHistory } from '../../lib/types';
+import type { FootprintBar } from '../../lib/types/footprint';
+import type { BracketAmendment } from '../../lib/types/trading-types';
+import type { PlaceOrderRequest } from '../../lib/matchingEngine';
+export type PluginType = 'indicator' | 'drawing' | 'chart-type' | 'data-source' | 'extension';
+export type Permission = 'data:read' | 'data:write' | 'eventbus:emit' | 'eventbus:intercept' | 'ui:pane' | 'ui:panel' | 'ui:toolbar' | 'ui:context-menu' | 'render:overlay' | 'render:shader' | 'drawing:register' | 'chart-type:register' | 'theme:register' | 'audio' | 'network' | 'storage' | 'intercept' | 'execution:read' | 'execution:write';
+export interface ToolbarItem {
+    id: string;
+    title: string;
+    icon?: React.ReactNode;
+    onClick: () => void;
+    active?: boolean;
+    disabled?: boolean;
+}
+export interface BottomBarHandle {
+    rerender(): void;
+    destroy(): void;
+}
+export interface FloatingPanelOpts {
+    element: React.ReactNode;
+    title?: string;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    initialSize?: {
+        width: number;
+        height: number;
+    };
+    resizable?: boolean;
+    visible?: boolean;
+}
+export interface ContextMenuItem {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    separator?: boolean;
+    onClick: () => void;
+}
+export interface ThemeDef {
+    id: string;
+    name: string;
+    /** CSS variables to inject - keys are var names without the leading '--'. */
+    vars: Record<string, string>;
+}
+export type SettingSchemaType = 'number' | 'string' | 'boolean' | 'color' | 'select';
+export interface SettingSchema {
+    type: SettingSchemaType;
+    label?: string;
+    default?: unknown;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: Array<{
+        value: unknown;
+        label: string;
+    }>;
+}
+export interface PluginStorage {
+    get<T>(key: string, fallback: T): T;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+    /** Clears only this plugin's keys. */
+    clear(): void;
+}
+export type ServiceApi = Record<string, (...args: any[]) => any>;
+export interface ServiceObserver<T extends ServiceApi> {
+    onAvailable: (api: T) => void;
+    onRemoved?: () => void;
+}
+export interface PluginServices {
+    register<T extends ServiceApi>(name: string, api: T): () => void;
+    get<T extends ServiceApi>(name: string): T | null;
+    on<T extends ServiceApi>(name: string, observer: ServiceObserver<T>): () => void;
+}
+export interface PluginSchedule {
+    /** Managed repeating timer - auto-cancelled on plugin teardown. */
+    interval(ms: number, fn: () => void): () => void;
+    /** Managed one-shot timer - auto-cancelled on plugin teardown. */
+    timeout(ms: number, fn: () => void): () => void;
+    /** Managed animation-frame callback - auto-cancelled on plugin teardown. */
+    raf(fn: () => void): () => void;
+}
+export type NotifyLevel = 'info' | 'success' | 'warn' | 'error';
+export interface NotifyOptions {
+    title: string;
+    body?: string;
+    level?: NotifyLevel;
+    /** ms. Default 4000. Pass Infinity for sticky. */
+    duration?: number;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+export interface PluginStateSnapshot {
+    serialize(): unknown;
+    restore(state: unknown): void;
+}
+export interface PluginExecutionSurface {
+    placeOrder(req: PlaceOrderRequest): string | Promise<string> | undefined;
+    cancelOrder(orderId: string): void;
+    amendOrder(orderId: string, newPrice: number): void;
+    amendBracket(amendment: BracketAmendment): void;
+    closePosition(positionId: string): void;
+    reversePosition(positionId: string): void;
+    totalRealizedPnl(): number;
+    totalFeesPaid(): number;
+}
+export interface PluginLifecycle {
+    onSymbolChange(cb: (symbol: string) => void): () => void;
+    onTimeframeChange(cb: (tf: string) => void): () => void;
+    onThemeChange(cb: (theme: 'light' | 'dark') => void): () => void;
+    onFocus(cb: (id: number) => void): () => void;
+    onBlur(cb: () => void): () => void;
+}
+export interface PaneOptions {
+    heightRatio?: number;
+    minHeightRatio?: number;
+}
+export interface PluginDataSnapshot {
+    trades: SerialTrade[];
+    footprintBars: FootprintBar[];
+    priceHistory: PriceHistory[];
+    /** Always present - synthesised from footprintBars when dataLevel is l3/tick. */
+    ohlcvBars: OhlcvBar[];
+    /** Populated when dataLevel is tick or l3. */
+    ticks: TickEvent[];
+    barNs: bigint;
+    dataStart: number;
+    dataEnd: number;
+    symbolInfo: SymbolInfo | null;
+    dataLevel: DataLevel;
+}
+export interface BottomBarItem {
+    id: string;
+    render: () => React.ReactNode;
+}
+/**
+ * The surface passed to every plugin's install() method. All capabilities
+ * are gated by the plugin's declared permissions - calls without the required
+ * permission throw at runtime.
+ */
+export interface PluginContext {
+    global: GlobalChartBus;
+    eventBus: TypedEventBus;
+    renderEngine: RenderEngine;
+    executionEngine: ExecutionEngine;
+    transformer: LiveTransformer;
+    dataLevel: DataLevel;
+    horizon: () => number;
+    getData(): Readonly<PluginDataSnapshot>;
+    /**
+     * The bar still being built at the playback horizon, or `null` before any
+     * data has arrived.
+     *
+     * This is the one you want for "what is the price right now". The last entry
+     * of `getData().ohlcvBars` is the last bar that was *loaded*, which during
+     * replay is somewhere in the future and at the fetch resolution rather than
+     * the charted timeframe.
+     *
+     * A snapshot - it is copied out of the live bar, so holding onto it gives you
+     * a stale bar. Call it again.
+     */
+    openBar(): OhlcvBar | null;
+    registerPane(id: string, opts?: PaneOptions): () => void;
+    registerPanel(id: string, element: React.ReactNode, title?: string, visible?: boolean): () => void;
+    getSettings<T>(defaults: T): T;
+    saveSettings<T>(patch: Partial<T>): void;
+    addOverlay(phase: 'before-base' | 'after-base' | 'after-ui', hook: DrawHook): () => void;
+    registerToolbarItem(item: ToolbarItem): () => void;
+    registerBottomBarItem(id: string, render: () => React.ReactNode): BottomBarHandle;
+    registerContextMenuItem(item: ContextMenuItem): () => void;
+    /** See PluginDrawingToolDef in core/DrawingRegistry for the full type. */
+    registerDrawingTool(tool: {
+        id: string;
+        name: string;
+        anchorCount: number | 'dynamic';
+        render(ctx: any): void;
+        hitTest(ctx: any): boolean | string | null;
+        [key: string]: any;
+    }): () => void;
+    registerTheme(theme: ThemeDef): () => void;
+    playSound(id: string | AudioBuffer): void;
+    /**
+     * Claim symbols and serve their data yourself - a derived instrument, or a
+     * whole venue behind the user's own API key. A source is an IDataAdapter
+     * with a claim on top; see PluginDataSource in core/DataSourceRegistry.
+     */
+    registerDataSource(source: {
+        [key: string]: any;
+    }): () => void;
+    storage: PluginStorage;
+    /** Sandboxed fetch - only allowed origins declared in the plugin manifest. */
+    fetch(url: string, init?: RequestInit): Promise<Response>;
+    intercept<K extends InterceptableEvent>(event: K, interceptor: Interceptor<K>): () => void;
+    /** null when neither execution:read nor execution:write is declared. */
+    execution: PluginExecutionSurface | null;
+    services: PluginServices;
+    schedule: PluginSchedule;
+    lifecycle: PluginLifecycle;
+    notify(opts: NotifyOptions): void;
+    playback: {
+        registerState(snapshot: PluginStateSnapshot): () => void;
+    };
+}
+export interface ChartPlugin {
+    readonly id: string;
+    readonly name: string;
+    readonly version: string;
+    readonly type: PluginType;
+    readonly permissions?: Permission[];
+    /**
+     * Origins `ctx.fetch` may talk to, e.g. `['https://api.massive.com']`.
+     * Anything else throws. A plugin holding the user's API key can only send
+     * it where it declared it would.
+     */
+    readonly origins?: string[];
+    readonly category?: string;
+    /** Source code string - used by the scripted plugin system. */
+    readonly code: string;
+    /**
+     * Minimum data level this plugin requires. Defaults to 'ohlcv'.
+     * The registry skips the plugin and emits 'plugin:incompatible' if the
+     * chart's data level does not satisfy this.
+     */
+    readonly require?: DataLevel;
+    install(ctx: PluginContext): void | (() => void) | Promise<void | (() => void)>;
+    uninstall?(ctx: PluginContext): void;
+}
+export interface PluginManifest {
+    id: string;
+    name: string;
+    version: string;
+    type: PluginType;
+    script: string;
+    permissions: Permission[];
+    /** Origins `ctx.fetch` may reach. See ChartPlugin.origins. */
+    origins?: string[];
+    settings?: Record<string, SettingSchema>;
+}

package/types/interfaces/plugins/IChartTypePlugin.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Contract for plugins that register a custom chart type (e.g. a Renko,
+ * Kagi, or custom orderflow renderer). Plugins declare type: 'chart-type'
+ * and require the 'chart-type:register' permission.
+ *
+ * Computation runs in a dedicated worker (workerInit / workerUpdate), then
+ * the main thread receives the output via hydrate / appendHydrate and draws
+ * it each frame via draw().
+ */
+import type { ChartPlugin, BottomBarHandle } from './IChartPlugin';
+import type { LiveTransformer } from '../ICoordinateTransformer';
+import type { TypedEventBus } from '../../core/TypedEventBus';
+import type { ViewBounds } from '../../lib/types';
+import type { FootprintBar } from '../../lib/types/footprint';
+import type { TradePoint, PriceHistory } from '../../lib/types';
+import type { Rect } from '../../lib/types/indicator-types';
+import type { ChartSettings } from '../../lib/types/chart-settings';
+import type { StyleField } from '../../components/drawings/drawing-settings-dialog';
+export interface ChartTypeActiveContext {
+    requestRedraw(): void;
+    setCursor(cursor: string): void;
+    eventBus: TypedEventBus;
+    registerBottomBarItem(id: string, render: () => React.ReactNode): BottomBarHandle;
+}
+export interface ChartTypePointerEvent {
+    /** Data-space timestamp (nanoseconds). */
+    ts: bigint;
+    price: number;
+    x: number;
+    y: number;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    buttons: number;
+    ctx: ChartTypeActiveContext;
+}
+export interface ChartTypeKeyEvent {
+    key: string;
+    code: string;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    ctx: ChartTypeActiveContext;
+}
+export interface ChartTypeRenderContext {
+    ctx: CanvasRenderingContext2D;
+    rect: Rect;
+    view: ViewBounds;
+    transformer: LiveTransformer;
+    footprintBars: FootprintBar[];
+    trades: TradePoint[];
+    priceHistory: PriceHistory[];
+    barNs: bigint;
+    chartSettings: ChartSettings;
+    /** The hydrated computed state (whatever workerInit / appendHydrate returned). */
+    computed: unknown;
+}
+export interface ChartTypePlugin extends ChartPlugin {
+    type: 'chart-type';
+    /** Unique identifier registered with ChartTypeRegistry. */
+    chartTypeId: string;
+    /** Human-readable label shown in the chart type picker. */
+    label: string;
+    /** Icon shown in the chart type picker. */
+    icon: React.ReactNode;
+    /**
+     * Fields shown in the chart settings dialog while this chart type is
+     * active. Build them with the `StyleField` helpers exported alongside the
+     * drawing settings dialog.
+     */
+    settingsSchema?: StyleField[];
+    /** Starting value for every key in `settingsSchema`. */
+    defaultSettings?: Record<string, unknown>;
+    /**
+     * The user changed a setting. Receives the full set, not just the change.
+     * Values are persisted with the chart under `ChartSettings.pluginSettings`,
+     * keyed by `chartTypeId`, and are also on the render context as
+     * `chartSettings.pluginSettings[chartTypeId]`.
+     */
+    onSettingsChange?(settings: Record<string, unknown>): void;
+    /**
+     * Serialized pure function - runs in the chart type's dedicated worker on
+     * initial load, backward seek, or timeframe change.
+     *
+     * Signature: ({ data, barNs, params }) => State
+     *
+     * Must be pure - no imports, no closures, no side effects.
+     */
+    workerInit?: string;
+    /**
+     * Serialized pure function - runs in the worker on every horizon tick.
+     *
+     * Signature: ({ newData, data, state, barNs, horizon, params }) => { points, state }
+     *
+     * Must be pure - no imports, no closures, no side effects.
+     */
+    workerUpdate?: string;
+    /**
+     * Called on the main thread after workerInit completes.
+     * Receives the full computed state and should replace any stored output.
+     */
+    hydrate?(data: unknown, barNs: bigint): void;
+    /**
+     * Called on the main thread after workerUpdate completes.
+     * Receives the incremental output - append it, do not replace.
+     */
+    appendHydrate?(points: unknown, barNs: bigint): void;
+    /** Called every frame by RenderEngine to draw the chart type. Required. */
+    draw(context: ChartTypeRenderContext): void;
+    /** Return custom y-axis bounds, or null to use default price scaling. */
+    getAutoYBounds?(tMin: bigint, tMax: bigint, horizon: bigint): {
+        min: number;
+        max: number;
+    } | null;
+    /** Called when the user switches TO this chart type. */
+    onActivate?(ctx: ChartTypeActiveContext): void;
+    /** Called when the user switches AWAY from this chart type. */
+    onDeactivate?(): void;
+    onPointerDown?(event: ChartTypePointerEvent): boolean | void;
+    onPointerMove?(event: ChartTypePointerEvent): boolean | void;
+    onPointerUp?(event: ChartTypePointerEvent): boolean | void;
+    onKeyDown?(event: ChartTypeKeyEvent): boolean | void;
+    /** Called when the crosshair hovers over a bar. */
+    onBarHover?(ts: bigint, price: number, barNs: bigint): void;
+    /** Return a custom crosshair tooltip string, or null for the default. */
+    getTooltip?(ts: bigint, price: number): string | null;
+}

package/types/interfaces/plugins/IDataSourcePlugin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Contract for plugins that provide a custom data source (adapter factory).
+ * A data-source plugin creates an IDataAdapter on demand, enabling remote
+ * or community-built data feeds to be loaded as plugins.
+ *
+ * Requires the 'data:write' permission.
+ */
+import type { ChartPlugin } from './IChartPlugin';
+import type { IDataAdapter } from '../IDataAdapter';
+export interface DataSourcePlugin extends ChartPlugin {
+    type: 'data-source';
+    /**
+     * Factory called by the engine when the user selects a symbol served by
+     * this plugin. Return a fully initialised IDataAdapter.
+     *
+     * @param symbol  The symbol string the user requested.
+     * @param config  Arbitrary config passed from the plugin's settings schema.
+     */
+    createAdapter(symbol: string, config: unknown): IDataAdapter;
+}

package/types/interfaces/plugins/IDrawingPlugin.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Contract for plugins that register a custom drawing tool.
+ * Drawing plugins declare type: 'drawing' and require the
+ * 'drawing:register' permission. The actual tool definition
+ * is registered via ctx.registerDrawingTool(tool) inside install().
+ *
+ * For a simpler path to custom drawing tools, implement PluginDrawingToolDef
+ * directly and register it from any extension plugin - a full DrawingPlugin
+ * is only necessary when you need plugin lifecycle hooks (settings, state).
+ */
+import type { ChartPlugin } from './IChartPlugin';
+import type { Anchor } from '../../lib/types/drawing-types';
+import type { PluginDrawingRenderContext, PluginDrawingHitContext } from '../../core/DrawingRegistry';
+import type { OhlcvBar } from '../IDataAdapter';
+export interface Point {
+    x: number;
+    y: number;
+}
+export type AnchorConfig = {
+    ts: bigint;
+    price: number;
+};
+export interface DrawingPlugin extends ChartPlugin {
+    type: 'drawing';
+    /** ID of the drawing tool this plugin registers - must be globally unique. */
+    toolId: string;
+    /** SVG string or emoji shown in the drawing toolbar. */
+    icon?: string;
+    /**
+     * How many anchor clicks are needed to commit the drawing.
+     * 'dynamic' = user keeps clicking and presses Escape to finish.
+     */
+    anchorCount: number | 'dynamic';
+    /**
+     * Return initial anchor positions when the user starts placing the drawing.
+     * `start` is the first click in data space.
+     */
+    createAnchors(start: AnchorConfig): AnchorConfig[];
+    /**
+     * Full render of the committed drawing. Called every canvas frame.
+     * Receives the full PluginDrawingRenderContext including resolved pixel positions.
+     */
+    render(ctx: PluginDrawingRenderContext): void;
+    /**
+     * Live preview while the user is still placing anchors.
+     * `cursor` is the current mouse position in data space.
+     */
+    preview?(anchors: Anchor[], cursor: AnchorConfig): void;
+    /**
+     * Return true (or the anchor id that was hit) if the mouse is over this drawing.
+     * Return false for no hit.
+     */
+    hitTest(ctx: PluginDrawingHitContext): boolean | string | null;
+    /**
+     * Optionally snap an anchor to the nearest bar OHLC value during placement.
+     */
+    snap?(anchor: Anchor, bars: OhlcvBar[]): Anchor;
+    /** Serialise anchor positions to a JSON-safe value for persistence. */
+    serialize(anchors: Anchor[]): unknown;
+    /** Restore anchors from a previously serialised value. */
+    deserialize(data: unknown): Anchor[];
+}

package/types/interfaces/plugins/IIndicatorPlugin.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Contract for indicator plugins. Indicators extend ChartPlugin with
+ * type: 'indicator' and a declarative rendering model mirroring ChartTypePlugin:
+ * heavy computation runs in a worker (workerInit / workerUpdate), the main
+ * thread receives the output via hydrate / appendHydrate, and drawBase /
+ * drawUI are called every frame.
+ *
+ * Requires at minimum 'data:read' + 'render:overlay' permissions.
+ * Pane-layout indicators additionally require 'ui:pane'.
+ */
+import type { ChartPlugin } from './IChartPlugin';
+import type { LiveTransformer } from '../ICoordinateTransformer';
+import type { Rect } from '../../lib/types/indicator-types';
+/**
+ * Everything an indicator needs to draw one frame.
+ * Coordinates are in LOCAL pane space - origin is the top-left of this pane.
+ */
+export interface IndicatorRenderContext {
+    ctx: CanvasRenderingContext2D;
+    /** Pane bounding rect in local coordinates. */
+    rect: Rect;
+    /** Visible time range (nanoseconds). */
+    tMin: bigint;
+    tMax: bigint;
+    /** Pane price/value axis range. */
+    yMin: number;
+    yMax: number;
+    /** Active bar duration in nanoseconds. 0n = tick/raw mode. */
+    barNs: bigint;
+    /**
+     * Current playback horizon in nanoseconds.
+     * Never draw data beyond this timestamp - doing so leaks future data.
+     * 0n means live / full-history mode.
+     */
+    horizon: bigint;
+    transformer: LiveTransformer;
+}
+export interface IndicatorCrosshair {
+    /** Canvas pixel x. */
+    x: number;
+    /** Canvas pixel y. */
+    y: number;
+}
+export interface IndicatorPlugin extends ChartPlugin {
+    type: 'indicator';
+    /** Where the indicator renders. */
+    layout: 'overlay' | 'pane';
+    /**
+     * Pane id to render in when layout === 'pane'.
+     * If omitted, a new pane is created automatically.
+     */
+    paneId?: string;
+    /**
+     * Serialized pure function - runs in the indicator worker on initial load,
+     * backward seek, or timeframe change.
+     *
+     * Signature:
+     *   (input: { trades: SerialTrade[], ohlcv: OhlcvBar[], barNs: bigint, params?: unknown }) => State
+     *
+     * Must be pure - no imports, no closures, no side effects.
+     */
+    workerInit?: string;
+    /**
+     * Serialized pure function - runs in the worker on every horizon tick.
+     *
+     * Signature:
+     *   (input: { newTrades: SerialTrade[], state: State, barNs: bigint, horizon: bigint, params?: unknown }) => { points: Points, state: State }
+     *
+     * Must be pure - no imports, no closures, no side effects.
+     */
+    workerUpdate?: string;
+    /**
+     * Called on the main thread after workerInit completes.
+     * Receives the full computed state - replace all stored output.
+     */
+    hydrate?(data: unknown, barNs: bigint): void;
+    /**
+     * Called on the main thread after workerUpdate completes.
+     * Receives incremental output - append, do not replace.
+     */
+    appendHydrate?(points: unknown, barNs: bigint): void;
+    /**
+     * Draw the indicator lines / fills / bars.
+     * Called every frame after the base chart layer.
+     */
+    drawBase?(ctx: IndicatorRenderContext): void;
+    /**
+     * Draw crosshair-aware UI: value labels, legend markers, tooltip overlays.
+     * Called every frame when the crosshair is visible.
+     */
+    drawUI?(ctx: IndicatorRenderContext, crosshair: IndicatorCrosshair | null): void;
+    /** Return custom y-axis bounds for this pane, or null to use auto-scaling. */
+    getAutoYBounds?(tMin: bigint, tMax: bigint, horizon: bigint): {
+        min: number;
+        max: number;
+    } | null;
+}

package/types/interfaces/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export type { PluginType, Permission, ToolbarItem, BottomBarHandle, BottomBarItem, FloatingPanelOpts, ContextMenuItem, ThemeDef, SettingSchema, SettingSchemaType, PluginStorage, ServiceApi, ServiceObserver, PluginServices, PluginSchedule, NotifyLevel, NotifyOptions, PluginStateSnapshot, PluginExecutionSurface, PluginLifecycle, PaneOptions, PluginDataSnapshot, PluginContext, ChartPlugin, PluginManifest, } from './IChartPlugin';
+export type { DrawingPlugin, Point, AnchorConfig } from './IDrawingPlugin';
+export type { ChartTypePlugin, ChartTypeRenderContext, ChartTypeActiveContext, ChartTypePointerEvent, ChartTypeKeyEvent, } from './IChartTypePlugin';
+export type { DataSourcePlugin } from './IDataSourcePlugin';
+export type { IndicatorPlugin, IndicatorRenderContext, IndicatorCrosshair, } from './IIndicatorPlugin';

package/types/lib/bar-grid.d.ts

@@ -0,0 +1,6 @@
+import { type SessionMapper } from '../core/SessionMapper';
+export declare function ohlcvBucketRange(tsNs: bigint, barNs: bigint, sessionMapper?: SessionMapper | null): {
+    start: bigint;
+    end: bigint;
+};
+export declare function snapTsToBarGrid(tsNs: bigint, barNs: bigint, sessionMapper?: SessionMapper | null): bigint;

package/types/lib/book.d.ts

@@ -0,0 +1,5 @@
+import { BookState, MboEvent } from './types';
+export declare function createBook(): BookState;
+export declare function applyEvent(book: BookState, event: MboEvent): void;
+export declare function getBestBid(book: BookState): number | null;
+export declare function getBestAsk(book: BookState): number | null;

package/types/lib/clock.d.ts

@@ -0,0 +1,7 @@
+export type Clock = {
+    wallStart: number;
+    dataStart: bigint;
+    speed: number;
+};
+export declare function createClock(dataStart: bigint, speed: number): Clock;
+export declare function getCurrentDataTime(clock: Clock): bigint;