@christtrade/depth 0.12.21

package/types/lib/matchingEngine.d.ts

@@ -0,0 +1,144 @@
+import type { UseTradingStateReturn } from '../hooks/useTradingState';
+import type { Order, Fill, Position, BracketLevel, BracketAmendment, PriceTick, OrderType, OrderSide } from './types/trading-types';
+import type { MboEvent, PriceHistory } from './types';
+import type { OhlcvBar, SymbolInfo } from '../interfaces/IDataAdapter';
+import type { SerialTrade } from './types';
+import { TypedEventBus } from '../core';
+export declare function sanitizeMetadata(meta: Record<string, unknown> | undefined, symbol: string, quantity: number, symbolInfo?: SymbolInfo | null): Record<string, unknown>;
+export interface FeeSchedule {
+    /** CME exchange fee per contract per side (e.g. NQ: $0.85). */
+    exchangeFeePerContract: number;
+    /** Broker commission per contract per side. */
+    commissionPerContract: number;
+    /** NFA regulatory fee per contract (one-way). */
+    nfaFeePerContract: number;
+    /** Clearing fee per contract. */
+    clearingFeePerContract: number;
+}
+export declare const NQ_FEE_SCHEDULE: FeeSchedule;
+export declare const MICRO_FEE_SCHEDULE: FeeSchedule;
+export declare const ZERO_FEE_SCHEDULE: FeeSchedule;
+export declare function feeScheduleFor(symbolInfo?: SymbolInfo | null): FeeSchedule;
+export interface L3EngineOptions {
+    symbolInfo?: SymbolInfo;
+    tickSize?: number;
+    fees?: FeeSchedule;
+    fillLatencyMs?: number;
+    /** 'net' = CME-style futures netting. 'hedge' = independent positions. */
+    nettingMode?: 'net' | 'hedge';
+    marketSlippageTicks?: number;
+    eventBus?: TypedEventBus;
+}
+export type FillAmbiguity = 'pessimistic' | 'optimistic';
+export interface FillSearchOptions {
+    /** When false, jumps skip fill evaluation entirely (fast navigation). */
+    enabled: boolean;
+    /**
+     * Cap on how fine the skipped span is evaluated, as a function of the jumped
+     * span (ns). Bounds the work for huge jumps (e.g. a month -> hourly bars).
+     * Returns a barNs. This is what keeps gap settlement from fetching the
+     * highest granularity over a long span.
+     */
+    maxResolution: (spanNs: bigint) => bigint;
+    /**
+     * Tie-break when a single (finest-allowed) bar's range contains conflicting
+     * triggers - e.g. both a stop-loss and a take-profit. 'pessimistic' assumes
+     * the worse (stop) side filled first. OHLC alone can't disambiguate intrabar
+     * order, so this is a policy, not ground truth.
+     */
+    ambiguity: FillAmbiguity;
+}
+export declare const DEFAULT_FILL_SEARCH: FillSearchOptions;
+export interface PlaceOrderRequest {
+    side: OrderSide;
+    type: OrderType;
+    qty: number;
+    limitPrice?: number;
+    stopPrice?: number;
+    tif?: Order['tif'];
+    bracketTp?: BracketLevel[];
+    bracketSl?: BracketLevel[];
+    symbol?: string;
+    reduceOnly?: boolean;
+    targetPositionId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface L3MatchingEngine {
+    onMboEvent: (event: MboEvent, tsNs: bigint) => void;
+    onTick: (tick: PriceTick) => void;
+    /** L3 path: ingest a compact buffer and then use seekTo to replay. */
+    ingestCompactBuf: (buf: ArrayBuffer) => void;
+    /** OHLCV path: ingest bars; seekTo advances bar by bar. Resets the replay cursor. */
+    ingestOhlcvBars: (bars: OhlcvBar[], barNs?: bigint) => void;
+    /**
+     * OHLCV path: extend the buffer forward without rewinding the replay.
+     * What a stream-append must use - see appendOhlcvBars for why.
+     */
+    appendOhlcvBars: (bars: OhlcvBar[], barNs?: bigint) => void;
+    /** OHLCV path: ingest finer-resolution bars so seekTo uses accurate mark prices within the open bar. */
+    ingestSupplementalBars?: (bars: Array<{
+        time: number;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }>) => void;
+    /** Cursor-preserving counterpart of ingestSupplementalBars. */
+    appendSupplementalBars?: (bars: Array<{
+        time: number;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }>) => void;
+    /** Tick path: ingest SerialTrades (trade-by-trade); seekTo replays each trade. */
+    ingestTicks: (trades: SerialTrade[]) => void;
+    /** L2 path: ingest pre-sampled BBO history; seekTo advances snapshot by snapshot. */
+    ingestPriceHistory: (history: PriceHistory[]) => void;
+    /** Cursor-preserving forms of the three above, for streamed extensions. */
+    appendTicks: (trades: SerialTrade[]) => void;
+    appendPriceHistory: (history: PriceHistory[]) => void;
+    appendCompactBuf: (buf: ArrayBuffer) => void;
+    seekTo: (tNs: bigint) => void;
+    getPrice: () => number;
+    placeOrder: (req: PlaceOrderRequest) => string;
+    cancelOrder: (orderId: string) => void;
+    amendOrder: (orderId: string, newPrice: number) => void;
+    syncPosition: (position: Position) => void;
+    syncOrder: (order: Order) => void;
+    /**
+     * Amend a bracket level on an open position.
+     * Accepts a full BracketAmendment (typed) keyed by stable BracketLevel.id.
+     */
+    amendBracket: (amendment: BracketAmendment) => void;
+    closePosition: (positionId: string) => void;
+    reversePosition: (positionId: string) => void;
+    totalFeesPaid: () => number;
+    totalRealizedPnl: () => number;
+    /** All orders ever placed - includes working, filled, cancelled, rejected. */
+    getOrders: () => Order[];
+    /** All fills produced by this engine. */
+    getFills: () => Fill[];
+    /** All positions that have been fully closed. */
+    getPositionHistory: () => Position[];
+    /** Configure gap-fill search (jump settlement). Merges into current config. */
+    setFillSearch: (patch: Partial<FillSearchOptions>) => void;
+    getFillSearch: () => FillSearchOptions;
+    /** Cheap gate: is there any resting order / untriggered bracket that could fill? */
+    hasPendingTriggers: () => boolean;
+    /**
+     * Replay a skipped span's bars (fetched at fillSearch.maxResolution) to apply
+     * fills the jump would otherwise have skipped. Bars must be time-ascending.
+     */
+    settleGapBars: (bars: Array<{
+        tsNs: bigint;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+    }>, ambiguity?: FillAmbiguity) => void;
+    destroy: () => void;
+}
+export declare function createL3MatchingEngine(tradingState: UseTradingStateReturn, options?: L3EngineOptions): L3MatchingEngine;

package/types/lib/notifications/tradeToast.d.ts

@@ -0,0 +1,31 @@
+import type { CloseReason, PositionSide } from '../types/trading-types';
+type Tone = 'success' | 'loss' | 'info' | 'neutral';
+export declare function notifyPositionOpened(p: {
+    side: PositionSide;
+    symbol: string;
+    qty: number;
+    entryPrice: number;
+    tickSize?: number;
+}): void;
+export declare function notifyPositionClosed(p: {
+    side: PositionSide;
+    symbol: string;
+    pnl: number;
+    rMultiple?: number;
+    reason?: CloseReason;
+    partial?: boolean;
+}): void;
+/** Generic, non-domain message - keeps ad-hoc toasts on the same design system. */
+export declare function notifyMessage(title: string, opts?: {
+    description?: string;
+    tone?: Tone;
+}): void;
+export declare function notifyBracketMoved(p: {
+    kind: 'tp' | 'sl' | 'be';
+    symbol: string;
+    price: number;
+    tickSize?: number;
+    /** True when the level was just created rather than dragged to a new price. */
+    created?: boolean;
+}): void;
+export {};

package/types/lib/pointer-lock.d.ts

@@ -0,0 +1,5 @@
+export declare const pointerLock: {
+    readonly locked: boolean;
+    lock(): void;
+    unlock(): void;
+};

package/types/lib/priceFormat.d.ts

@@ -0,0 +1,17 @@
+import type { SymbolInfo } from '../core';
+/**
+ * Format a price using the symbol's display precision (`priceFormat.precision`),
+ * falling back to 2 decimal places when the symbol info is absent. This is the
+ * single source of truth for how prices are rendered across the chart, so axis
+ * labels, pills, tooltips and trade lines all stay consistent.
+ */
+export declare function formatPrice(value: number, symbolInfo?: SymbolInfo): string;
+/** Fallback tick used when a symbol provides no price metadata at all. */
+export declare const DEFAULT_TICK_SIZE = 0.25;
+/**
+ * Resolve the instrument's minimum price increment from symbol info, preferring
+ * `priceFormat.minTick`, then the deprecated `tickSize`, and finally a sensible
+ * default. Single source of truth for tick snapping, footprint/volume-profile
+ * bucketing and tick-distance readouts so they all match the instrument.
+ */
+export declare function resolveTickSize(symbolInfo?: SymbolInfo | null): number;

package/types/lib/priceTransition.d.ts

@@ -0,0 +1,22 @@
+export declare class PriceTransition {
+    private readonly durationMs;
+    private readonly tweens;
+    private symbolKey;
+    constructor(durationMs?: number);
+    /**
+     * Forget all in-flight tweens when the symbol changes, so switching
+     * instruments never animates one price across to a wildly different one.
+     */
+    setSymbol(key: string | undefined): void;
+    /**
+     * Value to render for `key` (e.g. 'last' / 'bid' / 'ask'), easing toward
+     * `target` whenever a new target arrives. With `enabled` false (or a
+     * non-finite target) it passes the target straight through and drops any
+     * pending tween, so toggling the setting off snaps to the truth immediately.
+     */
+    value(key: string, target: number, now: number, enabled: boolean): number;
+    /** True while any tween is still in flight - caller should request another frame. */
+    isAnimating(now: number): boolean;
+    reset(): void;
+    private sample;
+}

package/types/lib/renderers/drawFootprintChart.d.ts

@@ -0,0 +1,5 @@
+import type { FootprintBar, FootprintMode } from '../types/footprint';
+import type { ViewBounds } from '../types';
+import type { ChartSettings } from '../types/chart-settings';
+import { LiveTransformer } from '../../core';
+export declare function drawFootprintChart(ctx: CanvasRenderingContext2D, bars: FootprintBar[], bounds: ViewBounds, w: number, h: number, barNs: bigint, mode: FootprintMode, tickSize: number, footprintVolume: 'none' | 'split' | 'total', chartSettings: ChartSettings, horizon: bigint, transformer: LiveTransformer): void;

package/types/lib/renderers/drawTradeLines.d.ts

@@ -0,0 +1,112 @@
+import { ChartSettings } from '../types/chart-settings';
+import { LiveTransformer, SymbolInfo } from '../../core';
+import { useTradeLines } from '../../hooks/useTradeLines';
+import { ViewBounds } from '../types';
+import { TradeLine } from '../types';
+import { Crosshair } from './renderer';
+/**
+ * Draws the full visualizer for one ghost pill being dragged.
+ *
+ * Call once per active drag - i.e. for each slot where
+ *   gs.draggingGhost === `${kind}_${index}`
+ *
+ * @param ctx        Canvas 2D context
+ * @param w          Chart width (same as drawTradeLines `w` param)
+ * @param pH         Chart height (priceAxisH)
+ * @param entryPrice The entry-line's price (used to compute distance)
+ * @param dragPrice  The current ghost price (snapped)
+ * @param kind       'tp' | 'sl'
+ * @param yOffset    Same yOffset used in drawTradeLines
+ * @param bounds     ViewBounds
+ * @param chartSettings ChartSettings
+ * @param tickSize   Optional - used to show distance in ticks
+ */
+export declare function drawGhostDragVisualizer(ctx: CanvasRenderingContext2D, w: number, pH: number, entryPrice: number, dragPrice: number, kind: 'tp' | 'sl', yOffset: number, bounds: ViewBounds, chartSettings: ChartSettings, tickSize?: number, transformer?: LiveTransformer, symbolInfo?: SymbolInfo): void;
+/**
+ * Draws all trade lines onto the UI canvas layer.
+ *
+ * Returns a hit-test map so chart.tsx can wire up mouse interactions without
+ * re-computing geometry.  See TradeLineHitMap below.
+ */
+export declare function drawTradeLines(ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement, bounds: ViewBounds, w: number, h: number, chartSettings: ChartSettings, tradeLines: TradeLine[], priceAxisH: number, yOffset: number, hoveredLineId: string | null, draggingLineId: string | null, tradeLineInteraction: ReturnType<typeof useTradeLines>, tickSize: number, transformer: LiveTransformer, rightScaleWidth: number, symbolInfo: SymbolInfo, crosshair: Crosshair): {
+    hitMap: TradeLineHitMap;
+    suspendCrosshair: boolean;
+};
+export interface GhostSlotState {
+    /**
+     * Prices for each TP ghost slot.
+     * Index matches the slot shown in the ghost pill row (tp_0, tp_1, …).
+     * undefined = user hasn't dragged this slot yet.
+     */
+    tpPrices: (number | undefined)[];
+    /**
+     * Prices for each SL ghost slot.
+     */
+    slPrices: (number | undefined)[];
+    /** e.g. "tp_0", "sl_1" - which ghost pill is currently hovered */
+    hoveredGhost?: string | null;
+    /** e.g. "tp_0", "sl_1" - which ghost pill is currently being dragged */
+    draggingGhost?: string | null;
+    draggingGhostIdx?: number | null;
+    draggingGhostType?: 'tp' | 'sl' | null;
+}
+/** Map from entry-line id -> ghost state */
+export type GhostInteractionState = Record<string, GhostSlotState>;
+export interface TradeLineHitRegion {
+    id: string;
+    /** Pixel Y of the actual price line */
+    y: number;
+    top: number;
+    bottom: number;
+    pill?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    closeBtn?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    reverseBtn?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+export interface GhostPillHitRegion {
+    lineId: string;
+    /** e.g. "tp_0", "sl_2" */
+    ghostId: string;
+    index: number;
+    kind: 'tp' | 'sl';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    currentPrice?: number;
+}
+export interface TradeLineHitMap {
+    lines: TradeLineHitRegion[];
+    pricePills: {
+        id: string | undefined;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[];
+    /** Hit regions for ghost TP/SL mini-pills */
+    ghostPills: GhostPillHitRegion[];
+}
+/**
+ * Given a mouse position, return which line (and which part of it) was hit.
+ * Call this from chart.tsx on mousemove / click instead of manual hit-testing.
+ */
+export declare function hitTestTradeLines(mx: number, my: number, hitMap: TradeLineHitMap): {
+    lineId: string | null;
+    part: 'line' | 'pill' | 'close' | 'reverse' | 'pricePill' | null;
+    ghostHit?: GhostPillHitRegion;
+};

package/types/lib/renderers/drawings-renderer.d.ts

@@ -0,0 +1,57 @@
+import { Crosshair } from './renderer';
+import type { SymbolInfo } from '../../core';
+import type { ChartPane } from '../types/indicator-types';
+import type { Drawing, DraftDrawing, HitResult, DrawingAnchorId, LongDrawing, ShortDrawing } from '../types/drawing-types';
+import { ChartSettings } from '../types/chart-settings';
+import { FootprintBar } from '../types/footprint';
+import { PriceHistory, ViewBounds } from '../types';
+import { LiveTransformer } from '../../core';
+export declare const Y_AXIS_WIDTH = 65;
+export declare const X_AXIS_HEIGHT = 30;
+/**
+ * Snap a timestamp to the nearest bar-open boundary.
+ * When barNs is 0n (tick/raw mode) the value is returned unchanged.
+ */
+export declare function snapTsToBar(ts: bigint, barNs: bigint): bigint;
+/**
+ * Geometry of a position box, in prices snapped to the instrument's tick.
+ * Shared by the renderer and the hit-test so the handles you see are the
+ * handles you grab.
+ */
+export declare function positionLevels(d: LongDrawing | ShortDrawing, tick: number): {
+    entry: number;
+    up: number;
+    down: number;
+    top: number;
+    bottom: number;
+};
+export declare function drawDrawingsLayer(canvas: HTMLCanvasElement, drawings: Drawing[], bounds: ViewBounds, panes: ChartPane[], selectedId: string | null, hoveredId: string | null, hotAnchor: DrawingAnchorId | null, draft?: DraftDrawing | null, crosshair?: Crosshair, skipId?: string | null, holdingCtrl?: boolean | null, holdingShift?: boolean | null, barNs?: bigint | null, chartSettings?: ChartSettings, footprintBars?: FootprintBar[], priceHistory?: PriceHistory[], transformer?: LiveTransformer, hidePriceScale?: boolean, hideTimeScale?: boolean, priceScaleWidth?: number, symbolInfo?: SymbolInfo, horizon?: bigint): void;
+/**
+ * Hit-test drawings against a pointer position.
+ *
+ * UNITS: everything here is CSS px - `mx`/`my` come from clientX/Y minus the
+ * canvas rect, and pane layouts are computed in CSS px (useChartLayout divides
+ * by the DPR). Pass `canvas.width / dpr`, NOT `canvas.width`: on a DPR-2 screen
+ * the bitmap is twice the CSS size, which silently doubles chartW/mainH here and
+ * puts every drawing's computed screen position at ~2x - hits stop landing.
+ * Note the sibling getDrawingLabelAnchor() takes the RAW bitmap size and divides
+ * internally; the two do not share a convention.
+ */
+export declare function hitTestDrawings(mx: number, my: number, drawings: Drawing[], bounds: ViewBounds, panes: ChartPane[], 
+/** canvas width in CSS px (canvas.width / dpr) */
+cssW: number, 
+/** canvas height in CSS px (canvas.height / dpr) */
+cssH: number, transformer: LiveTransformer, hideTimeScale: boolean, priceScaleWidth: number, symbolInfo?: SymbolInfo): HitResult;
+/** UNITS: takes the RAW bitmap size (canvas.width/height) and converts to CSS px
+ *  internally - the opposite of hitTestDrawings(), which wants CSS px already. */
+export declare function getDrawingLabelAnchor(d: Drawing, bounds: ViewBounds, panes: ChartPane[], canvasW: number, canvasH: number, transformer: LiveTransformer, hideTimeScale: boolean, priceScaleWidth: number): {
+    x: number;
+    y: number;
+};
+export declare function moveDrawingAnchorDelta(d: Drawing, anchor: DrawingAnchorId, dts: bigint, // delta ts since last frame
+dprice: number, // delta price since last frame
+curTs: bigint, // absolute cursor position (for individual anchor snap)
+curPrice: number, holdingShift: boolean): {
+    drawing: Drawing;
+    anchor: DrawingAnchorId;
+};

package/types/lib/renderers/renderer.d.ts

@@ -0,0 +1,113 @@
+import { ChartPane, Indicator, Rect } from '../types/indicator-types';
+import { BookSnapshot, PriceHistory, TradePoint } from '../types';
+import type { ChartType, TradeLine, ViewBounds } from '../types';
+import type { FootprintBar } from '../types/footprint';
+import { ChartSettings } from '../types/chart-settings';
+import { ActiveDrawingTool, DraftDrawing, Drawing, DrawingAnchorId } from '../types/drawing-types';
+import { AccountSnapshot, DataLevel, LiveTransformer, OhlcvBar, SymbolInfo } from '../../core';
+import { SessionMapper } from '../../core/SessionMapper';
+import { PriceTransition } from '../priceTransition';
+import { OrdinalModel } from '../series/japaneseCharts';
+import type { CrosshairSync } from '../types/layout-sync';
+export type CandleCache = Map<bigint, {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}>;
+export type Crosshair = {
+    x: number;
+    y: number;
+} | null;
+export declare const Y_AXIS_WIDTH = 65;
+export declare const X_AXIS_HEIGHT = 30;
+export declare const TRADE_SNAP_RADIUS = 12;
+export declare const COLORS: {
+    background: string;
+    buyLine: string;
+    sellLine: string;
+    grid: string;
+    label: string;
+    axisBg: string;
+    crosshair: string;
+    crosshairBg: string;
+    crosshairText: string;
+};
+export declare function computeRightScaleWidth(bounds: ViewBounds, symbolInfo: SymbolInfo | undefined, chartSettings: ChartSettings, hidePriceScale?: boolean, ctx?: CanvasRenderingContext2D | null): number;
+export declare function drawBaseLayer(canvas: HTMLCanvasElement, panes: ChartPane[], layouts: Record<string, Rect>, indicators: Indicator[], trades: TradePoint[], priceHistory: PriceHistory[], snapshots: BookSnapshot[], bounds: ViewBounds, footprintBars: FootprintBar[], heatmapBitmap: ImageBitmap | null, bitmapOffsetX: number, bitmapOffsetY: number, bitmapOffsetW: number, bitmapOffsetH: number, barNs: bigint, chartSettings: ChartSettings, horizon: bigint, candleCache: CandleCache | null, 
+/** Live incrementally-built open bar - overrides the cache for the current bucket. */
+openBar: {
+    ts: bigint;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+} | null, ohlcvBars: {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}[], transformer: LiveTransformer, isPluginChartType?: boolean, sessionMapper?: SessionMapper, dataLevel?: DataLevel, hidePriceScale?: boolean, hideTimeScale?: boolean, symbolInfo?: SymbolInfo, rightScaleWidth?: number): void;
+export declare function drawUILayer(canvas: HTMLCanvasElement, priceHistory: PriceHistory[], trades: TradePoint[], bounds: ViewBounds, crosshair: Crosshair, showTooltip: boolean, selectedTrade: TradePoint | null, panes: ChartPane[], layouts: Record<string, Rect>, indicators: Indicator[], hoveredDividerIdx: number, hoveringLegend: boolean, barNs: bigint, chartSettings: ChartSettings, horizon: bigint, candleCache: CandleCache | null, ohlcvBars: {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}[], openBar: OhlcvBar, tradeLines: TradeLine[], tradeLineInteraction: any, hoveredLineId?: string | null, draggingLineId?: string | null, activeTool?: ActiveDrawingTool | null, draggingAnchor?: {
+    drawingId: string;
+    anchor: DrawingAnchorId;
+} | null, holdingCtrl?: boolean | null, holdingShift?: boolean | null, footprintBars?: FootprintBar[] | null, drawings?: Drawing[] | null, draft?: DraftDrawing | null, transformer?: LiveTransformer, showShiftInfo?: boolean, shiftInfoAnchor?: {
+    ts: bigint;
+    price: number;
+    x: number;
+    y: number;
+}, shiftInfoAnchor2?: {
+    ts: bigint;
+    price: number;
+    x: number;
+    y: number;
+} | null, dataLevel?: DataLevel, accountSnapshot?: AccountSnapshot, symbolInfo?: SymbolInfo, hidePriceScale?: boolean, hideTimeScale?: boolean, rightScaleWidth?: number, priceTransition?: PriceTransition, syncCrosshair?: CrosshairSync | null): import("./drawTradeLines").TradeLineHitMap;
+export declare function applyHeatmapContrast(src: ImageBitmap, chartW: number, chartH: number, threshold: number): ImageData;
+export declare function drawHeatmap(ctx: CanvasRenderingContext2D, snapshots: BookSnapshot[], bounds: ViewBounds, chartW: number, chartH: number, contrastThreshold?: number): void;
+export declare function nearestIndex(priceHistory: PriceHistory[], target: bigint): number;
+export declare function nearestTradeIndex(trades: TradePoint[], target: bigint): number;
+export declare function findNearestTrade(clickX: number, clickY: number, trades: TradePoint[], bounds: ViewBounds, chartW: number, chartH: number, chartSettings: ChartSettings, horizon: bigint, transformer: LiveTransformer): TradePoint | null;
+export declare const snapTs: (ts: bigint, tf: bigint, sessionMapper?: SessionMapper | null) => bigint;
+export declare const snapPrice: (snappedTs: bigint, rawPrice: number, chartSettings: ChartSettings, footprintBars: FootprintBar[], priceHistory: PriceHistory[], ohlcvBars: {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}[], dataLevel: DataLevel, horizon: bigint) => number;
+export declare function drawTooltip(ctx: CanvasRenderingContext2D, mouse: {
+    x: number;
+    y: number;
+}, priceHistory: PriceHistory[], bounds: ViewBounds, w: number, h: number, transformer: LiveTransformer, symbolInfo?: SymbolInfo): void;
+/** True for the price-driven chart types that render on an ordinal (column) x-axis. */
+export declare function isOrdinalChartType(t: ChartType): boolean;
+/**
+ * Memoised ordinal model for the current chart type + data + params. Returns
+ * null for non-ordinal types. Shared by the renderer, the transformer wiring
+ * (column timestamps) and autoscale (visible price extent), so all three derive
+ * from one build.
+ */
+export declare function getOrdinalModel(chartType: ChartType, chartSettings: ChartSettings, ohlcvBars: {
+    time: number;
+    close: number;
+}[] | undefined, candleCache: CandleCache | null, trades: TradePoint[], barNs: bigint): OrdinalModel | null;
+/**
+ * Price extent of the columns currently visible under the transformer's view -
+ * used to auto-scale the y-axis for ordinal charts (whose prices live in the
+ * model, not in the time-indexed bars autoFitPriceAxis scans). Returns null when
+ * nothing is visible.
+ */
+export declare function ordinalVisiblePriceRange(model: OrdinalModel, transformer: LiveTransformer): {
+    min: number;
+    max: number;
+} | null;

package/types/lib/sampler.d.ts

@@ -0,0 +1,7 @@
+import { createL3MatchingEngine } from './matchingEngine';
+import { MboEvent, PriceHistory, TradePoint } from './types';
+export declare function isoToNs(isoString: string): bigint;
+export declare function sampleTrades(events: MboEvent[], engine: ReturnType<typeof createL3MatchingEngine>): {
+    tradePoints: TradePoint[];
+    priceHistory: PriceHistory[];
+};

package/types/lib/series/japaneseCharts.d.ts

@@ -0,0 +1,88 @@
+export type PricePoint = {
+    ts: bigint;
+    price: number;
+};
+/** One Renko brick spanning [yLow, yHigh] (a single brick-size band). */
+export type RenkoBrick = {
+    ts: bigint;
+    yLow: number;
+    yHigh: number;
+    dir: 1 | -1;
+};
+/**
+ * A Kagi line segment. Endpoints are given as Kagi *column indices* (`i1`/`i2`)
+ * - one column per turning point - so duplicate turning-point timestamps never
+ * collapse onto the same x. `yang` = thick bullish line.
+ */
+export type KagiSegment = {
+    i1: number;
+    y1: number;
+    i2: number;
+    y2: number;
+    yang: boolean;
+};
+/** Turning points + index-referenced segments for a Kagi line. */
+export type KagiResult = {
+    columns: PricePoint[];
+    segments: KagiSegment[];
+};
+/** One Three-Line-Break block from `open` to `close`. */
+export type LineBreakBox = {
+    ts: bigint;
+    open: number;
+    close: number;
+    dir: 1 | -1;
+};
+/** The three price-driven (ordinal-axis) chart kinds. */
+export type OrdinalKind = 'renko' | 'kagi' | 'line-break';
+/**
+ * Shared model consumed by the transformer (column timestamps), the renderer
+ * (draw by column index) and autoscale (price extent over an index range).
+ * `columnTs` is non-decreasing with one entry per drawn column; `pLow`/`pHigh`
+ * are the per-column price extents. The matching render data is carried too so
+ * everything derives from one build.
+ */
+export type OrdinalModel = {
+    kind: OrdinalKind;
+    columnTs: BigInt64Array;
+    pLow: Float64Array;
+    pHigh: Float64Array;
+    bricks?: RenkoBrick[];
+    boxes?: LineBreakBox[];
+    kagiSegments?: KagiSegment[];
+};
+/**
+ * A "nice" rounded number near `x` (1/2/5 x 10ⁿ) - used to derive a readable
+ * default brick size / reversal amount from the data when the user hasn't set
+ * one explicitly.
+ */
+export declare function niceNumber(x: number): number;
+/** Default brick / reversal magnitude: ~1/40 of the series' price range. */
+export declare function autoThreshold(series: PricePoint[]): number;
+/**
+ * Build Renko bricks from a close series. A brick forms in the trend direction
+ * once price advances a full `brick`; reversing direction requires two bricks
+ * of movement (the canonical Renko reversal), so the bands always tile cleanly.
+ */
+export declare function buildRenko(series: PricePoint[], brick: number): RenkoBrick[];
+/**
+ * Build a Kagi line from a close series. The line extends with the trend and
+ * jogs to a new column only when price reverses by `reversal`. Each vertical
+ * leg is split into a thin "yin" portion and a thick "yang" portion at the
+ * previous shoulder (last peak) / waist (last trough) - Kagi's defining trait.
+ */
+export declare function buildKagi(series: PricePoint[], reversal: number): KagiResult;
+/**
+ * Build Three Line Break blocks from a close series. A new block forms when
+ * price closes beyond the high/low of the last `lineCount` blocks (so a
+ * reversal needs to break `lineCount` blocks, while continuation only needs to
+ * exceed the last block).
+ */
+export declare function buildThreeLineBreak(series: PricePoint[], lineCount?: number): LineBreakBox[];
+/**
+ * Build the shared ordinal model for one of the price-driven chart kinds.
+ * Columns are emitted in render order; `columnTs` feeds the transformer and
+ * `pLow`/`pHigh` feed autoscale. Render data (bricks / boxes / kagi segments)
+ * is carried so the renderer reuses this single build.
+ */
+export declare function buildOrdinalModel(kind: OrdinalKind, series: PricePoint[], param: number): OrdinalModel;