@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/clock/clock.d.ts

@@ -0,0 +1,10 @@
+export interface Clock {
+    now(): number;
+}
+export declare const realClock: Clock;
+export declare function frozenClock(at?: number): Clock;
+export interface SteppedClock extends Clock {
+    advance(deltaMs: number): void;
+    set(atMs: number): void;
+}
+export declare function steppedClock(start?: number): SteppedClock;

package/dist/composition/chart-group-state.d.ts

@@ -0,0 +1,46 @@
+export type SyncYScale = "off" | "percent" | "absolute";
+export type ReferencePoint = "first-visible" | "last-bar" | number;
+export interface ChartGroupOptions {
+    /** Sync the visible x-domain across the group. */
+    readonly syncDomain: boolean;
+    readonly syncPanZoom: boolean;
+    readonly syncCrosshair: boolean;
+    readonly syncYScale: SyncYScale;
+    readonly referencePoint: ReferencePoint;
+    readonly syncSelection: boolean;
+    readonly syncTooltip: boolean;
+    /** Whether the group enables a brushable time-range selection. The
+     *  separate `<ChartGroupBrush>` component reads + writes this state. */
+    readonly brush: boolean;
+    /** Whether a `<ChartGroupNavigator>` minimap should engage. */
+    readonly navigator: boolean;
+}
+export declare const DEFAULT_CHART_GROUP_OPTIONS: ChartGroupOptions;
+/** Per-key optional input. Accepts `{ syncDomain?: boolean; ... }` shapes
+ *  produced by adapter prop spread under exactOptionalPropertyTypes - each
+ *  key may be present-with-undefined or missing. */
+export type ChartGroupOptionsInput = {
+    readonly [K in keyof ChartGroupOptions]?: ChartGroupOptions[K] | undefined;
+};
+export declare function resolveChartGroupOptions(input: ChartGroupOptionsInput | undefined): ChartGroupOptions;
+export interface TimeRange {
+    readonly start: number;
+    readonly end: number;
+}
+export interface ChartGroupState {
+    /** Last hover-position time observed in any sibling chart. */
+    readonly crosshairTime: number | null;
+    setCrosshairTime(t: number | null): void;
+    /** Last click-selection time. */
+    readonly selectedTime: number | null;
+    setSelectedTime(t: number | null): void;
+    /** Shared visible time-range when `syncDomain: true`. */
+    readonly domain: TimeRange | null;
+    setDomain(d: TimeRange | null): void;
+    /** Shared brush range. */
+    readonly brush: TimeRange | null;
+    setBrush(b: TimeRange | null): void;
+    /** Subscribe to any state change. Returns idempotent unsubscriber. */
+    subscribe(listener: () => void): () => void;
+}
+export declare function createChartGroupState(): ChartGroupState;

package/dist/composition/index.d.ts

@@ -0,0 +1 @@
+export { type Pane, type PaneRect, type ComputePaneRectsOpts, computePaneRects, } from './pane';

package/dist/composition/pane.d.ts

@@ -0,0 +1,33 @@
+/** A single pane in a vertical stack. The renderer decides what to
+ *  draw inside; this primitive only allocates pixel rects. */
+export interface Pane {
+    /** Stable id used by the renderer to look up its draw config. */
+    readonly id: string;
+    /** Semantic kind; `price` is the main candle/line area, `volume` is
+     *  the volume sub-pane, `indicator` is RSI / MACD / etc. */
+    readonly kind: "price" | "volume" | "indicator";
+    /** Fraction of the available content area this pane gets. Ratios are
+     *  normalized - they don't have to sum to 1. */
+    readonly heightRatio: number;
+}
+export interface PaneRect {
+    readonly id: string;
+    readonly kind: Pane["kind"];
+    /** Top y in CSS px (closer to outerTop). */
+    readonly top: number;
+    /** Bottom y in CSS px (closer to outerBottom). */
+    readonly bottom: number;
+    /** Height in CSS px (= bottom - top). */
+    readonly height: number;
+}
+export interface ComputePaneRectsOpts {
+    /** Top y of the available area (typically the chart's `innerTop`). */
+    readonly outerTop: number;
+    /** Bottom y of the available area (typically `innerBottom`). */
+    readonly outerBottom: number;
+    /** Panes in top-to-bottom order. */
+    readonly panes: readonly Pane[];
+    /** Height of each divider between panes, in CSS px. */
+    readonly dividerHeightPx: number;
+}
+export declare function computePaneRects(opts: ComputePaneRectsOpts): PaneRect[];

package/dist/domain/concat.d.ts

@@ -0,0 +1,18 @@
+import { CandleSeries, LineSeries } from './series';
+/** Concatenate two ingested `CandleSeries` (history first, visible
+ *  second). Re-runs ingestion on the combined typed arrays so the
+ *  result is validated as a single monotonic series (catches
+ *  history that overlaps the visible window via duplicate / out-of-
+ *  order timestamps).
+ *
+ *  When the history series is empty, returns the visible unchanged
+ *  (zero-allocation fast path). */
+export declare function concatCandleSeries(history: CandleSeries, visible: CandleSeries): CandleSeries;
+/** Concatenate two ingested `LineSeries`. Same contract as
+ *  `concatCandleSeries`. */
+export declare function concatLineSeries(history: LineSeries, visible: LineSeries): LineSeries;
+/** Slice the leading `n` values off a typed-array indicator output.
+ *  Zero-copy via `subarray()`. Used to drop the warmup-history
+ *  portion of an indicator result so the remainder aligns with the
+ *  visible data window. */
+export declare function sliceLeading(values: Float64Array, n: number): Float64Array;

package/dist/domain/drawings.d.ts

@@ -0,0 +1,44 @@
+export type DrawingType = "trend-line" | "horizontal-line" | "vertical-line" | "rectangle" | "ellipse" | "arrow" | "text" | "fib-retracement" | "fib-extension" | "pitchfork" | "channel" | "brush";
+export interface Anchor {
+    /** Time in ms since the epoch. */
+    t: number;
+    /** Price (in the chart's price scale). */
+    y: number;
+}
+export interface DrawingStyle {
+    /** Stroke / fill base color (resolved CSS string OR `'auto'` to use
+     *  the active palette's `drawings.stroke` slot). */
+    color?: string | "auto";
+    lineWidth?: number;
+    lineStyle?: "solid" | "dashed" | "dotted";
+    fillOpacity?: number;
+    /** Trend-line + arrow only - bool toggles arrowhead at the second
+     *  anchor. */
+    arrowhead?: boolean;
+    /** Text-drawing only. */
+    text?: string;
+    fontSize?: number;
+}
+export interface Drawing {
+    readonly id: string;
+    readonly type: DrawingType;
+    /** Anchors in data coordinates. Cardinality varies by type:
+     *  - 1: horizontal-line (y), vertical-line (t)
+     *  - 2: trend-line, rectangle, ellipse, arrow, text (single anchor
+     *       point + style.text), fib-retracement, fib-extension, brush
+     *  - 3: pitchfork, channel
+     *  Validation is host-side at construction; the chart trusts the
+     *  cardinality for the type it sees. */
+    readonly anchors: readonly Anchor[];
+    readonly style: DrawingStyle;
+    /** Optional metadata for host bookkeeping; not used by the chart. */
+    readonly meta?: Record<string, unknown>;
+}
+/** Anchor count required for each drawing type. The chart's drawing
+ *  pipeline asserts that `drawing.anchors.length >= ANCHOR_COUNTS[type]`. */
+export declare const ANCHOR_COUNTS: Record<DrawingType, number>;
+/** Standard fib retracement levels. */
+export declare const FIB_RETRACEMENT_LEVELS: readonly [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
+/** Standard fib extension levels. */
+export declare const FIB_EXTENSION_LEVELS: readonly [1, 1.272, 1.414, 1.618, 2, 2.618];
+export declare function isValidDrawing(d: Drawing): boolean;

package/dist/domain/heikin-ashi.d.ts

@@ -0,0 +1,9 @@
+import { CandleSeries } from './series';
+export interface HeikinAshiArrays {
+    readonly opens: Float64Array;
+    readonly highs: Float64Array;
+    readonly lows: Float64Array;
+    readonly closes: Float64Array;
+}
+export declare function computeHeikinAshi(opens: Float64Array, highs: Float64Array, lows: Float64Array, closes: Float64Array): HeikinAshiArrays;
+export declare function computeHeikinAshiCached(series: CandleSeries): HeikinAshiArrays;

package/dist/domain/index.d.ts

@@ -0,0 +1,7 @@
+export { LineSeries, CandleSeries } from './series';
+export { ingestLineSeries, ingestCandleSeries, type IngestOptions, } from './ingestion';
+export { type LinePoint, type LineSeriesInput, type Candle, type CandleSeriesInput, type BinaryCandleSeriesInput, DataValidationError, } from './values';
+export { type LiveState, type LiveStateInput, deriveLiveState, } from './live-state';
+export { concatCandleSeries, concatLineSeries, sliceLeading } from './concat';
+export { type Drawing, type DrawingType, type DrawingStyle, type Anchor, ANCHOR_COUNTS, FIB_RETRACEMENT_LEVELS, FIB_EXTENSION_LEVELS, isValidDrawing, } from './drawings';
+export { type SignalMarker, type SignalSide, type OrderMarker, type OrderSide, type PositionMarker, type EventMarker, type EventKind, } from './markers';

package/dist/domain/ingestion.d.ts

@@ -0,0 +1,7 @@
+import { CandleSeries, LineSeries } from './series';
+import { CandleSeriesInput, LineSeriesInput } from './values';
+export interface IngestOptions {
+    strict?: boolean;
+}
+export declare function ingestLineSeries(input: LineSeriesInput, opts?: IngestOptions): LineSeries;
+export declare function ingestCandleSeries(input: CandleSeriesInput, opts?: IngestOptions): CandleSeries;

package/dist/domain/live-state.d.ts

@@ -0,0 +1,12 @@
+export type LiveState = "live" | "stale" | "disconnected";
+export interface LiveStateInput {
+    /** Explicit override from host. When set, wins over auto-detection. */
+    readonly connectionState?: LiveState | undefined;
+    /** ms timestamp of the last successful tick. Undefined → no signal. */
+    readonly liveSince?: number | undefined;
+    /** ms; 0 disables auto-detection. */
+    readonly staleThreshold: number;
+    /** ms; clock used for the freshness comparison. Pure → injectable. */
+    readonly now: number;
+}
+export declare function deriveLiveState(input: LiveStateInput): LiveState;

package/dist/domain/markers.d.ts

@@ -0,0 +1,38 @@
+export type SignalSide = "buy" | "sell";
+export interface SignalMarker {
+    /** Time in ms (matches a candle's t). */
+    t: number;
+    side: SignalSide;
+    /** [0, 1] confidence - drives the marker size scale. */
+    confidence?: number;
+    /** Optional override for the chart's `signalTooltip` data. */
+    meta?: Record<string, unknown>;
+}
+export type OrderSide = "buy" | "sell";
+export interface OrderMarker {
+    /** Bar t the order lives at (typically the most-recent bar). */
+    t: number;
+    side: OrderSide;
+    entryPrice: number;
+    stopLossPrice?: number;
+    takeProfitPrice?: number;
+    meta?: Record<string, unknown>;
+}
+export interface PositionMarker {
+    t: number;
+    side: "long" | "short";
+    entryPrice: number;
+    /** Quantity in shares / lots - used by P&L pill calculations. */
+    qty: number;
+    meta?: Record<string, unknown>;
+}
+export type EventKind = "earnings" | "dividend" | "split" | "news";
+export interface EventMarker {
+    t: number;
+    kind: EventKind;
+    /** Short label (1-2 chars) for the glyph mode. */
+    glyph?: string;
+    /** Full title for the banner mode. */
+    title?: string;
+    meta?: Record<string, unknown>;
+}

package/dist/domain/series.d.ts

@@ -0,0 +1,22 @@
+export declare class LineSeries {
+    #private;
+    readonly times: Float64Array;
+    readonly values: Float64Array;
+    readonly length: number;
+    constructor(times: Float64Array, values: Float64Array);
+    get revisionId(): number;
+    bumpRevision(): number;
+}
+export declare class CandleSeries {
+    #private;
+    readonly times: Float64Array;
+    readonly opens: Float64Array;
+    readonly highs: Float64Array;
+    readonly lows: Float64Array;
+    readonly closes: Float64Array;
+    readonly volumes: Float64Array | null;
+    readonly length: number;
+    constructor(times: Float64Array, opens: Float64Array, highs: Float64Array, lows: Float64Array, closes: Float64Array, volumes: Float64Array | null);
+    get revisionId(): number;
+    bumpRevision(): number;
+}

package/dist/domain/values.d.ts

@@ -0,0 +1,32 @@
+export interface LinePoint {
+    t: number;
+    value: number;
+}
+export type LineSeriesInput = {
+    points: readonly LinePoint[];
+} | {
+    times: Float64Array;
+    values: Float64Array;
+};
+export interface Candle {
+    t: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    v?: number;
+}
+export interface BinaryCandleSeriesInput {
+    times: Float64Array;
+    opens: Float64Array;
+    highs: Float64Array;
+    lows: Float64Array;
+    closes: Float64Array;
+    volumes?: Float64Array;
+}
+export type CandleSeriesInput = {
+    candles: readonly Candle[];
+} | BinaryCandleSeriesInput;
+export declare class DataValidationError extends Error {
+    readonly name = "DataValidationError";
+}

package/dist/engine/aggregation.d.ts

@@ -0,0 +1,15 @@
+/** SoA result of `aggregateMinutes`. Typed-array views into engine
+ *  linear memory - consumer either uses in-frame or copies via
+ *  `copyOutF64` (per `./views.ts`) before the next engine call. */
+export interface AggregatedSeries {
+    readonly times: Float64Array;
+    readonly opens: Float64Array;
+    readonly highs: Float64Array;
+    readonly lows: Float64Array;
+    readonly closes: Float64Array;
+    readonly volumes: Float64Array;
+    readonly length: number;
+}
+/** Roll up an OHLCV series from `baseTfMinutes` to `targetTfMinutes`.
+ *  Throws if the target isn't a positive integer multiple of the base. */
+export declare function aggregateMinutes(times: Float64Array, opens: Float64Array, highs: Float64Array, lows: Float64Array, closes: Float64Array, volumes: Float64Array, baseTfMinutes: number, targetTfMinutes: number): Promise<AggregatedSeries>;

package/dist/engine/downsampling.d.ts

@@ -0,0 +1,3 @@
+export declare function lttb(xs: Float64Array, ys: Float64Array, target: number): Promise<Float64Array>;
+export declare function douglasPeucker(xs: Float64Array, ys: Float64Array, epsilon: number): Promise<Uint8Array>;
+export declare function cullByX(xs: Float64Array, x0: number, x1: number): Promise<[number, number]>;

package/dist/engine/events.d.ts

@@ -0,0 +1,14 @@
+export declare const AggregationEventKind: {
+    readonly NoEvent: 0;
+    readonly MutateLast: 1;
+    readonly AppendNew: 2;
+};
+export type AggregationEventKindValue = (typeof AggregationEventKind)[keyof typeof AggregationEventKind];
+export interface AggregationEvent {
+    kind: AggregationEventKindValue;
+    bucketStartMs: number;
+    index: number;
+}
+export declare function createAggregationEventScratch(): AggregationEvent;
+export declare function isMutateLast(e: AggregationEvent): boolean;
+export declare function isAppendNew(e: AggregationEvent): boolean;

package/dist/engine/index.d.ts

@@ -0,0 +1,13 @@
+export { loadEngine, getEnginePing, EngineLoadError } from './module';
+export { parseEngineVersion, isEngineCompatible, ENGINE_COMPATIBILITY, EngineVersionParseError, EngineVersionMismatchError, type EngineVersion, } from './version';
+export { AggregationEventKind, createAggregationEventScratch, isMutateLast, isAppendNew, type AggregationEvent, type AggregationEventKindValue, } from './events';
+export { copyOutF64, copyOutU32, type TypedView, } from './views';
+export { createMarket, type MarketHandle, type MarketKind, } from './markets';
+export { timeAxisWallClock, timeAxisSessionOrdinal, type AxisTick, type TimeAxisHandle, } from './time-axis';
+export { createQuadtree, type QuadtreeHandle, type NearestHit, type RangeHit, } from './quadtree';
+export { sma, ema, wma, rsi, macd, bollinger, atr, stochastic, vwap, IndicatorComputeService, type IndicatorSpecKey, type BollingerOutput, type MacdOutput, type StochasticOutput, } from './indicators';
+export { lttb, douglasPeucker, cullByX, } from './downsampling';
+export { createStreamingEngine, type StreamingEngineHandle, } from './streaming';
+export { createEngineSession, type EngineSession, type CreateEngineSessionOptions, } from './session';
+export { maCrossSignal, rsiSignal, stochasticSignal, macdSignal, bollingerSignal, vwapSignal, confluence, type Signal, type SignalDirection, SIGNAL_BULLISH, SIGNAL_BEARISH, SIGNAL_NEUTRAL, INDICATOR_SMA, INDICATOR_EMA, INDICATOR_WMA, INDICATOR_RSI, INDICATOR_MACD, INDICATOR_BOLLINGER, INDICATOR_ATR, INDICATOR_STOCHASTIC, INDICATOR_VWAP, } from './signals';
+export { aggregateMinutes, type AggregatedSeries, } from './aggregation';

package/dist/engine/indicators.d.ts

@@ -0,0 +1,37 @@
+export interface BollingerOutput {
+    upper: Float64Array;
+    middle: Float64Array;
+    lower: Float64Array;
+}
+export interface MacdOutput {
+    macd: Float64Array;
+    signal: Float64Array;
+    histogram: Float64Array;
+}
+export interface StochasticOutput {
+    k: Float64Array;
+    d: Float64Array;
+}
+export declare function sma(closes: Float64Array, period: number): Promise<Float64Array>;
+export declare function ema(closes: Float64Array, period: number): Promise<Float64Array>;
+export declare function wma(closes: Float64Array, period: number): Promise<Float64Array>;
+export declare function rsi(closes: Float64Array, period: number): Promise<Float64Array>;
+export declare function macd(closes: Float64Array, fast: number, slow: number, signal: number): Promise<MacdOutput>;
+export declare function bollinger(closes: Float64Array, period: number, multiplier: number): Promise<BollingerOutput>;
+export declare function atr(highs: Float64Array, lows: Float64Array, closes: Float64Array, period: number): Promise<Float64Array>;
+export declare function stochastic(highs: Float64Array, lows: Float64Array, closes: Float64Array, fastK: number, slowK: number, slowD: number, fast: boolean): Promise<StochasticOutput>;
+export declare function vwap(highs: Float64Array, lows: Float64Array, closes: Float64Array, volumes: Float64Array, sessionStarts: Uint32Array): Promise<Float64Array>;
+export interface IndicatorSpecKey {
+    hash: number;
+    revisionId: number;
+}
+export declare class IndicatorComputeService<T> {
+    readonly capacity: number;
+    private readonly entries;
+    constructor(capacity?: number);
+    private indexOf;
+    get(key: IndicatorSpecKey): T | undefined;
+    set(key: IndicatorSpecKey, value: T): void;
+    clear(): void;
+    get size(): number;
+}

package/dist/engine/markets.d.ts

@@ -0,0 +1,8 @@
+export type MarketKind = "equity" | "dst-equity" | "crypto-24-7";
+export interface MarketHandle {
+    kind: MarketKind;
+    inner: import('@abdullahjaswal/tickyr-charts-wasm').Market;
+    free(): void;
+    [Symbol.dispose](): void;
+}
+export declare function createMarket(kind: MarketKind): Promise<MarketHandle>;

package/dist/engine/module.d.ts

@@ -0,0 +1,8 @@
+type EngineModule = typeof import("@abdullahjaswal/tickyr-charts-wasm");
+export declare class EngineLoadError extends Error {
+    readonly name = "EngineLoadError";
+}
+export declare function loadEngine(): Promise<EngineModule>;
+export declare function getEnginePing(): string | null;
+export declare function resetEngineModuleForTests(): void;
+export {};

package/dist/engine/quadtree.d.ts

@@ -0,0 +1,18 @@
+export interface NearestHit {
+    id: number;
+    x: number;
+    y: number;
+}
+export interface RangeHit {
+    id: number;
+    x: number;
+    y: number;
+}
+export interface QuadtreeHandle {
+    readonly length: number;
+    nearest(x: number, y: number): NearestHit | null;
+    rangeQuery(minX: number, minY: number, maxX: number, maxY: number): RangeHit[];
+    free(): void;
+    [Symbol.dispose](): void;
+}
+export declare function createQuadtree(xyInterleaved: Float64Array, ids: Uint32Array): Promise<QuadtreeHandle>;

package/dist/engine/session.d.ts

@@ -0,0 +1,11 @@
+import { MarketHandle, MarketKind } from './markets';
+export interface EngineSession {
+    readonly disposed: boolean;
+    readonly market: MarketHandle;
+    dispose(): void;
+    [Symbol.dispose](): void;
+}
+export interface CreateEngineSessionOptions {
+    marketKind: MarketKind;
+}
+export declare function createEngineSession(opts: CreateEngineSessionOptions): Promise<EngineSession>;

package/dist/engine/signals.d.ts

@@ -0,0 +1,52 @@
+/** Direction code mirrors `DirectionJs` from the engine. */
+export type SignalDirection = 0 | 1 | 2;
+export declare const SIGNAL_BULLISH: SignalDirection;
+export declare const SIGNAL_BEARISH: SignalDirection;
+export declare const SIGNAL_NEUTRAL: SignalDirection;
+export interface Signal {
+    /** 0 = Bullish, 1 = Bearish, 2 = Neutral. */
+    readonly direction: SignalDirection;
+    /** `[0, 1]` - magnitude of the verdict. */
+    readonly strength: number;
+    /** `[0, 1]` - interpreter's confidence; 0 means warm-up / NaN. */
+    readonly confidence: number;
+}
+/** Indicator codes mirror engine's IndicatorId.code mapping. Used as
+ *  the `indicator_codes` payload of `confluence`. */
+export declare const INDICATOR_SMA = 0;
+export declare const INDICATOR_EMA = 1;
+export declare const INDICATOR_WMA = 2;
+export declare const INDICATOR_RSI = 3;
+export declare const INDICATOR_MACD = 4;
+export declare const INDICATOR_BOLLINGER = 5;
+export declare const INDICATOR_ATR = 6;
+export declare const INDICATOR_STOCHASTIC = 7;
+export declare const INDICATOR_VWAP = 8;
+/** Moving-average crossover. Bullish when close crosses MA from below
+ *  AND momentum confirms; bearish on the inverse. **NOT FINANCIAL ADVICE.** */
+export declare function maCrossSignal(closeAt: number, closePrev: number, maAt: number, maPrev: number): Promise<Signal>;
+/** RSI signal. Oversold → Bullish, overbought → Bearish, in-band →
+ *  Neutral. **NOT FINANCIAL ADVICE.** */
+export declare function rsiSignal(rsiAt: number, oversold: number, overbought: number): Promise<Signal>;
+/** Stochastic signal. Same oversold/overbought logic on the K line.
+ *  **NOT FINANCIAL ADVICE.** */
+export declare function stochasticSignal(kAt: number, oversold: number, overbought: number): Promise<Signal>;
+/** MACD signal. Histogram sign + slope (Appel 2005). **NOT FINANCIAL ADVICE.** */
+export declare function macdSignal(histAt: number, histPrev: number): Promise<Signal>;
+/** Bollinger Bands signal - mean-reversion convention. Close near or
+ *  past upper band ⇒ Bearish; close near or past lower band ⇒ Bullish;
+ *  inside ⇒ Neutral. **NOT FINANCIAL ADVICE.** */
+export declare function bollingerSignal(close: number, upper: number, lower: number): Promise<Signal>;
+/** VWAP signal - close above VWAP ⇒ Bullish, below ⇒ Bearish, equal ⇒
+ *  Neutral. **NOT FINANCIAL ADVICE.** */
+export declare function vwapSignal(close: number, vwapAt: number): Promise<Signal>;
+/** Confluence - combine N indicator signals into one via weighted vote.
+ *  All input arrays are parallel + row-major.
+ *
+ *  - `indicatorCodes` - one of the `INDICATOR_*` constants per signal.
+ *  - `directionCodes` - Bullish (0) / Bearish (1) / Neutral (2).
+ *  - `strengths`, `confidences` - `[0, 1]` per signal.
+ *  - `weightCodes`, `weightValues` - indicator → weight, sorted parallel.
+ *
+ *  Throws on length mismatch. **NOT FINANCIAL ADVICE.** */
+export declare function confluence(indicatorCodes: Uint8Array, directionCodes: Uint8Array, strengths: Float64Array, confidences: Float64Array, weightCodes: Uint8Array, weightValues: Float64Array): Promise<Signal>;

package/dist/engine/streaming.d.ts

@@ -0,0 +1,20 @@
+import { MarketHandle } from './markets';
+import { AggregationEvent } from './events';
+export interface StreamingEngineHandle {
+    readonly length: number;
+    pushTick(tsMs: number, priceRaw: number, volumeRaw: number, out: AggregationEvent): void;
+    reset(): void;
+    setAnomalyPolicy(maxRelativePriceJump: number, rejectZeroVolumeTrade: boolean, clockSkewToleranceMs: number, maxGapMs: number): void;
+    setAuditCallback(callback: ((...args: unknown[]) => void) | null): void;
+    setTelemetryCallback(callback: ((...args: unknown[]) => void) | null): void;
+    free(): void;
+    [Symbol.dispose](): void;
+}
+export declare function createStreamingEngine(opts: {
+    timeframeMinutes: number;
+    capacity: number;
+    market: MarketHandle;
+    minPriceRaw: number;
+    maxPriceRaw: number;
+    maxVolumeRaw: number;
+}): Promise<StreamingEngineHandle>;

package/dist/engine/time-axis.d.ts

@@ -0,0 +1,16 @@
+import { MarketHandle } from './markets';
+export interface AxisTick {
+    atMs: number;
+    kind: number;
+    label: string;
+}
+export interface TimeAxisHandle {
+    position(tMs: number): number;
+    inversePosition(p: number): number;
+    ticks(viewportPxWidth: number): AxisTick[];
+    visibleSpanMs(): number;
+    free(): void;
+    [Symbol.dispose](): void;
+}
+export declare function timeAxisWallClock(startMs: number, endMs: number): Promise<TimeAxisHandle>;
+export declare function timeAxisSessionOrdinal(startMs: number, endMs: number, market: MarketHandle): Promise<TimeAxisHandle>;

package/dist/engine/version.d.ts

@@ -0,0 +1,16 @@
+export type EngineVersion = `${number}.${number}.${number}`;
+export declare const ENGINE_COMPATIBILITY: {
+    readonly major: 0;
+    readonly minorMin: 1;
+    readonly minorMax: number;
+};
+export declare function parseEngineVersion(pingToken: string): EngineVersion;
+export declare function isEngineCompatible(version: EngineVersion): boolean;
+export declare class EngineVersionParseError extends Error {
+    readonly name = "EngineVersionParseError";
+    constructor(token: string);
+}
+export declare class EngineVersionMismatchError extends Error {
+    readonly name = "EngineVersionMismatchError";
+    constructor(actual: string);
+}

package/dist/engine/views.d.ts

@@ -0,0 +1,3 @@
+export type TypedView<T extends ArrayBufferView> = T;
+export declare function copyOutF64(view: Float64Array): Float64Array;
+export declare function copyOutU32(view: Uint32Array): Uint32Array;