@alphacharts/indicators 0.0.0-stage → 0.1.1

package/dist/types/all.d.ts

@@ -0,0 +1,3 @@
+import { ALL_STUDIES } from "./studies/all.js";
+export { ALL_STUDIES };
+export declare function registerAllStudies(): void;

package/dist/types/chart/marker-floor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The first bar index whose mark is kept, over bars `[0, n)` of `col`: marks at
+ * or after it are drawn, those before are not. 0 when the plot asks for no limit.
+ */
+export declare function markerFloor(col: ArrayLike<number>, n: number, o: {
+    last?: number;
+    within?: number;
+    text?: boolean;
+}): number;

package/dist/types/chart/studies.d.ts

@@ -0,0 +1,192 @@
+import { type Chart, type ChartPlugin, type DataChange, type PluginApi, type PluginPaneView, type Series, type SeriesType } from "@alphacharts/core";
+import { type FeedBar, type FeedBars, type FeedConfig } from "../engine/feed.js";
+import { type StudyRunner } from "../runner.js";
+import type { InputValue, Params, StudyDef } from "../types.js";
+export declare const PLUGIN_ID = "alphacharts.studies";
+type AnySeries = Series<SeriesType>;
+type SourceSeries = Series<"candles" | "bars" | "line" | "area" | "histogram">;
+export interface AddStudyOptions {
+    /** Volume series (histogram or line) for studies that need volume. */
+    volume?: Series<"histogram" | "line" | "area">;
+    /** Instance id; default `s<n>`. Layout state is keyed by it. */
+    id?: string;
+    /** Batch evaluation off the UI thread; ticks always run inline. */
+    runner?: StudyRunner;
+    /** Called once when the study is dropped or disposed (removed, source removed, layout restored over it). */
+    onDispose?: () => void;
+    /**
+     * Whether `StudiesPlugin.toJSON` saves this study (default true). A study
+     * that something else rebuilds on restore (a script, through
+     * `restoreScript`) sets it false: the plugin could not recreate it, and a
+     * layout holding it would be refused.
+     */
+    persist?: boolean;
+}
+export interface PlotStyle {
+    color?: string;
+    width?: number;
+}
+export declare class Study {
+    private readonly host;
+    readonly id: string;
+    private readonly source;
+    private readonly volume;
+    private readonly ownRunner?;
+    private readonly onDispose?;
+    readonly def: StudyDef;
+    private params;
+    private engine;
+    private outs;
+    private lines;
+    /** Background shading: one primitive per bgcolor plot, attached to the series of the pane it shades. */
+    private shades;
+    /** Outside series the host gave this study, by key. */
+    private feeds;
+    private sameScale;
+    private styles;
+    private shown;
+    private pane;
+    private scaleId;
+    private version;
+    private job;
+    /** A tick arrived while a job was pending (caught up on adoption). */
+    private dirty;
+    /** A replace/prepend arrived while a job was pending: the job's data is stale. */
+    private structural;
+    /** Set when a computation failed: the study stops following the source and says why. */
+    error: Error | null;
+    private ready_;
+    disposed: boolean;
+    /** Decimals a separate-pane study's axis and labels show when its def does not set `minMove`: two, more when the values are small. */
+    private decimals;
+    /** Whether the plugin saves this study (see `AddStudyOptions.persist`). */
+    persist: boolean;
+    inputs(): Params;
+    get visible(): boolean;
+    /** Resolves when the last requested computation has been applied to the chart. */
+    ready(): Promise<void>;
+    /**
+     * Redraw from the engine's columns after they were written from outside (a
+     * computation that arrives late, e.g. a script worker): the last bar when
+     * `onlyLast`, else every bar.
+     */
+    refresh(onlyLast?: boolean): void;
+    /** Output series, in plot order. */
+    series(): readonly AnySeries[];
+    /**
+     * Change inputs; unspecified ones keep their value, and the keys in `reset` go back to their defaults (a preset that
+     * has no value for an input the study has). Validated before anything changes. Outside series the study was given stay.
+     */
+    setInputs(partial: Readonly<Record<string, InputValue>>, reset?: readonly string[]): void;
+    setVisible(visible: boolean): void;
+    setStyle(plotKey: string, style: PlotStyle): void;
+    remove(): void;
+    /** The last computed value of each column (undefined while in warm-up), by column name. */
+    lastValues(): Record<string, number | undefined>;
+    /** Output column `name` over the source bars (a view: copy it to keep it). */
+    column(name: string): Float64Array;
+    /** Bar times of the columns. */
+    times(): Float64Array;
+    /** The study as saved: its id, definition, inputs, source series ids, visibility and styles. `StudiesPlugin.toJSON` is a list of these. */
+    state(): {
+        visible: boolean;
+        styles: Record<string, PlotStyle>;
+        volume?: string;
+        id: string;
+        study: string;
+        inputs: Record<string, InputValue>;
+        source: string;
+    };
+    /**
+     * Give the study outside series `key` (see engine/feed.ts for what a feed is and how it is joined), replacing the
+     * previous bars of that key, and compute everything again. The study keeps its own copy.
+     */
+    setFeed(key: string, bars: FeedBars, cfg: FeedConfig): void;
+    /** Keys of the outside series given so far. */
+    feedKeys(): string[];
+    /**
+     * A live bar of outside series `key` (same time as its last bar revises it, a later time appends). Only the study's
+     * last bar is evaluated again, and only when it sees a different feed bar through the join; otherwise nothing is
+     * recomputed or redrawn.
+     */
+    pushFeedBar(key: string, bar: FeedBar): void;
+    get isShown(): boolean;
+    private get ohlc();
+    private checkSource;
+    /** Whether `d` is the store of one of this study's inputs. */
+    private watches;
+    private bars;
+    private barAt;
+    /** Recompute everything from the source's bars. */
+    private recompute;
+    /** Bring an adopted engine up to the source's current last bars (ticks that arrived during the job). */
+    private catchUp;
+    private fullLoad;
+    private title;
+    private retitle;
+    private color;
+    private seriesOptions;
+    private createSeries;
+    private syncAll;
+    /** Background shades and bar colours, from the engine's columns (every bar). */
+    private syncOverlays;
+    private writeSeries;
+    /** Show enough decimals for values below 1 (three significant digits); only ever grows. A def's own `minMove` wins; an overlay reads like its source. */
+    private widen;
+    /** The output series that draws `column`, or undefined when no plot does (a column that is only an input to others). */
+    seriesOfColumn(column: string): AnySeries | undefined;
+    /** After one appended or revised bar: one point per output series. */
+    private tickSync;
+    private drawMarkers;
+}
+export declare class StudiesPlugin implements ChartPlugin {
+    readonly chart: Chart;
+    readonly runner: StudyRunner | undefined;
+    private readonly resolve;
+    readonly id = "alphacharts.studies";
+    api: PluginApi | null;
+    private readonly studies;
+    private counter;
+    /** Sources whose bars the plugin has coloured: the plugin owns their colour column while a barcolor study exists. */
+    private readonly coloured;
+    constructor(chart: Chart, runner: StudyRunner | undefined, resolve: (id: string) => StudyDef);
+    install(api: PluginApi): void;
+    uninstall(): void;
+    dataChanged(c: DataChange): void;
+    drawPane(ctx: CanvasRenderingContext2D, view: PluginPaneView): void;
+    list(): Study[];
+    get(id: string): Study | undefined;
+    /** Lowest pane index >= 1 holding no series (reuses a gap), else a new pane. */
+    freePane(): number;
+    add(def: StudyDef, inputs: Readonly<Record<string, InputValue>>, source: SourceSeries, o?: AddStudyOptions, saved?: {
+        visible?: boolean;
+        styles?: Record<string, PlotStyle>;
+    }): Study;
+    removeStudy(id: string): void;
+    /** Drop studies whose source series was removed from the chart. */
+    private reap;
+    /** Never hand out an id at or below `n` again: ids of removed studies stay retired, so an alert that still names one cannot land on a different study. */
+    reserveIds(n: number): void;
+    /** The highest `s<n>` number handed out or restored so far. */
+    idHighWater(): number;
+    private nextId;
+    toJSON(): unknown;
+    /** Throws what `fromJSON(state)` would, changing nothing: the layout is refused whole when a study cannot be rebuilt. */
+    validateState(state: unknown, ctx: {
+        seriesIds: readonly string[];
+    }): void;
+    /** Called after the chart restored its series: rebuild each study over the restored series. */
+    fromJSON(state: unknown): void;
+}
+/** Install the studies plugin on a chart (idempotent). Restoring a layout that holds studies needs this first. */
+export declare function installStudies(chart: Chart, opts?: {
+    runner?: StudyRunner;
+    resolve?: (id: string) => StudyDef;
+}): StudiesPlugin;
+/**
+ * Add a study over `source`. `study` is a definition (tree-shakable) or the id of
+ * a registered one. Throws on unknown inputs, out-of-range values or a source
+ * that lacks what the study needs.
+ */
+export declare function addStudy(chart: Chart, source: SourceSeries, study: StudyDef | string, inputs?: Readonly<Record<string, InputValue>>, opts?: AddStudyOptions): Study;
+export {};

package/dist/types/define.d.ts

@@ -0,0 +1,46 @@
+import type { InputDef, LineStyleName, MarkerShape, PlotDef, StudyDef } from "./types.js";
+export declare const int: (key: string, def: number, min?: number, max?: number, label?: string) => InputDef;
+export declare const float: (key: string, def: number, min?: number, max?: number, step?: number, label?: string) => InputDef;
+export declare const bool: (key: string, def: boolean, label?: string) => InputDef;
+export declare const select: (key: string, def: string, options: readonly string[], label?: string) => InputDef;
+export declare const source: (def?: string, key?: string) => InputDef;
+export declare const COLORS: {
+    readonly blue: "#2962FF";
+    readonly orange: "#FF6D00";
+    readonly red: "#F23645";
+    readonly green: "#089981";
+    readonly purple: "#9C27B0";
+    readonly teal: "#00897B";
+    readonly yellow: "#FBC02D";
+    readonly pink: "#E91E63";
+    readonly gray: "#787B86";
+    readonly lime: "#8BC34A";
+    readonly cyan: "#00BCD4";
+    readonly brown: "#795548";
+};
+export declare const line: (col: string, color: string, o?: {
+    title?: string;
+    key?: string;
+    width?: number;
+    style?: LineStyleName;
+    offset?: number;
+    connect?: boolean;
+}) => PlotDef;
+export declare const hist: (col: string, color: string, colorDown?: string, o?: {
+    title?: string;
+    key?: string;
+}) => PlotDef;
+export declare const areaPlot: (col: string, color: string, o?: {
+    title?: string;
+    key?: string;
+}) => PlotDef;
+export declare const band: (key: string, upper: string, lower: string, color: string, fill: string, title?: string) => PlotDef;
+export declare const fillBetween: (key: string, a: string, b: string, color: string, title?: string) => PlotDef;
+export declare const hline: (key: string, value: number | ((p: import("./types.js").Params) => number), color?: string, style?: LineStyleName) => PlotDef;
+export declare const markers: (col: string, shape: MarkerShape, position: "value" | "above" | "below" | "sign", color: string, o?: {
+    title?: string;
+    key?: string;
+    offset?: number;
+    text?: boolean;
+}) => PlotDef;
+export declare function defineStudy(def: StudyDef): StudyDef;

package/dist/types/engine/feed.d.ts

@@ -0,0 +1,88 @@
+import { Graph } from "./graph.js";
+export type FeedField = "open" | "high" | "low" | "close" | "volume";
+export declare const FEED_FIELDS: readonly FeedField[];
+export type FeedAlign = "same" | "closed";
+export interface FeedConfig {
+    align: FeedAlign;
+    /** Nominal length of one feed bar, ms. Used by "closed" (> 0); ignored by "same". */
+    spanMs: number;
+}
+/** Columnar bars of a feed, in the feed's own time. */
+export interface FeedBars {
+    time: Float64Array;
+    open: Float64Array;
+    high: Float64Array;
+    low: Float64Array;
+    close: Float64Array;
+    volume: Float64Array;
+}
+export interface FeedBar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+/** A feed as sent to a runner: its bars and how to join them. */
+export interface FeedData extends FeedConfig {
+    bars: FeedBars;
+}
+export type FeedChange = "appended" | "revised";
+/**
+ * A feed is a graph of its own whose bars are the other series' bars: its base columns (time, open, high, low, close,
+ * volume) are the series itself, and whatever is computed from it (a script's `ta.rsi(outside(...), 14)`) is computed
+ * on those bars, so a window of 14 is 14 of the series' bars whatever the chart's timeframe. The chart's graph reads
+ * the result through the join (`Graph.joined`). Loading or ticking the feed evaluates its graph at once.
+ */
+export declare class Feed {
+    readonly graph: Graph;
+    align: FeedAlign;
+    spanMs: number;
+    private cur;
+    get n(): number;
+    /** Replace the bars (copied) and the join. Throws, naming `what`, on bars that are not a series. */
+    load(bars: FeedBars, cfg: FeedConfig, what?: string): void;
+    /** Change how the bars are joined, keeping them. */
+    configure(cfg: FeedConfig, what?: string): void;
+    /** A live bar: the same time as the last bar replaces it, a later time appends; an earlier time throws. */
+    apply(b: FeedBar, what?: string): FeedChange;
+    /** The bars as a runner takes them (copies, length n). */
+    snapshot(): FeedBars;
+    /** Index of the feed bar the study bar at time `t` sees, or -1 when it sees none. */
+    lookup(t: number): number;
+    value(field: FeedField, i: number): number;
+}
+/** Row `field` of every bar in `feed` joined onto `times`, as a plain array: the join in one call (for tests and tools). */
+export declare function joinFeed(feed: Feed, field: FeedField, times: ArrayLike<number>): Float64Array;
+export type JoinReason = 
+/** Every chart bar sees a feed bar. */
+"complete"
+/** Some chart bars see a feed bar and some do not (holes in the feed, or the feed starts later or ends earlier). */
+ | "partial"
+/** The join finds nothing: the chart has no bars, or the feed has none. */
+ | "empty"
+/** Same-length join and the feed's bar times never equal the chart's: the two sit on different clocks (offsetMs). */
+ | "different-clock"
+/** Longer-timeframe join and no feed bar has finished by any chart bar (the feed starts after the chart ends, or is too short). */
+ | "no-finished-bar";
+export interface JoinReport {
+    align: FeedAlign;
+    chartBars: number;
+    /** Chart bars that see a feed bar. A chart bar that sees none is blank (NaN) in everything read from the feed. */
+    matched: number;
+    reason: JoinReason;
+    /**
+     * For "different-clock": how far the feed's bars sit from the chart's, in ms, in (-spanMs/2, spanMs/2]: the first feed bar's
+     * time minus the first chart bar's, modulo the bar length. NSE hourly bars open at 09:15 and MCX's at 09:00, so a chart on one
+     * reading the other gives +900000 or -900000. Otherwise null.
+     */
+    offsetMs: number | null;
+    /** One sentence a host can show where it would otherwise show "blank". */
+    message: string;
+}
+/**
+ * Why a join gives what it gives, for a host to explain a blank outside series: how many chart bars `cfg` joins to a bar of `feedTimes`
+ * and, when none, the reason. A pure function of the two time columns and the config handed to `setFeed`; it reads no value.
+ */
+export declare function describeJoin(chartTimes: ArrayLike<number>, feedTimes: ArrayLike<number>, cfg: FeedConfig): JoinReport;

package/dist/types/engine/graph.d.ts

@@ -0,0 +1,136 @@
+import { Feed, type FeedField } from "./feed.js";
+export type Ref = Col | number;
+export declare class Col {
+    v: Float64Array;
+    constructor(cap: number);
+}
+export declare class Node extends Col {
+    /** Evaluate bars [from, to). */
+    run: (from: number, to: number) => void;
+}
+export type SourceName = "open" | "high" | "low" | "close" | "hl2" | "hlc3" | "ohlc4" | "hlcc4";
+export declare const SOURCE_NAMES: readonly SourceName[];
+export declare class Graph {
+    /** Bars currently loaded. */
+    n: number;
+    private cap;
+    /** Every column (inputs, aux, nodes) in creation order: the unit of transfer between threads. */
+    readonly cols: Col[];
+    private readonly nodes;
+    readonly time: Col;
+    readonly open: Col;
+    readonly high: Col;
+    readonly low: Col;
+    readonly close: Col;
+    readonly volume: Col;
+    private readonly sources;
+    /** Outside series by key: bars given by the host, joined onto this graph's bars by `external`. */
+    readonly feeds: Map<string, Feed>;
+    constructor(cap?: number);
+    /** An auxiliary column (state a node keeps per bar). */
+    col(): Col;
+    /** Make room for `n` bars; existing values are kept. */
+    reserve(n: number): void;
+    /** Evaluate bars [from, to) on every node. `to` bars must already be loaded. */
+    run(from: number, to: number): void;
+    /** Forget all values (new data is loaded from bar 0). */
+    clear(): void;
+    /** Replace every column by transferred buffers (same builder, same order). */
+    adopt(buffers: readonly Float64Array[], n: number): void;
+    /** A node whose evaluation is `body`; the body reads other columns' `.v` when it runs. */
+    node(body: (self: Node, from: number, to: number) => void): Node;
+    /** Per-bar function of the index; it may read any column at <= i (own columns at <= i-1). */
+    calc(fn: (i: number) => number): Node;
+    /** A constant as a column-compatible value. */
+    private val;
+    src(name: SourceName): Node;
+    /** The feed `key` (created empty on first use: its bars arrive from the host, and until they do every join is absent). */
+    feed(key: string): Feed;
+    /** Field `field` of feed `key` joined onto this graph's bars (see feed.ts for the two joins). NaN where the join finds no bar. */
+    external(key: string, field: FeedField): Node;
+    /**
+     * A column of feed `key`'s own graph (its base columns by name, or anything computed on its bars) read through the
+     * join: at each bar of this graph, the value at the feed row the join finds, NaN when it finds none.
+     */
+    joined(key: string, col: Col | FeedField): Node;
+    map(x: Col, f: (x: number) => number): Node;
+    map2(x: Ref, y: Ref, f: (x: number, y: number) => number): Node;
+    add(x: Ref, y: Ref): Node;
+    sub(x: Ref, y: Ref): Node;
+    mul(x: Ref, y: Ref): Node;
+    /** x / y; a zero divisor gives NaN (absent), never Infinity. */
+    div(x: Ref, y: Ref): Node;
+    max2(x: Ref, y: Ref): Node;
+    min2(x: Ref, y: Ref): Node;
+    abs(x: Col): Node;
+    neg(x: Col): Node;
+    lag(x: Col, k: number): Node;
+    change(x: Col, k?: number): Node;
+    /** Consecutive valid (non-NaN) values of x ending at each bar. */
+    validRun(x: Col): Col;
+    /** Sum over the last p bars (NaN until p valid bars). */
+    sum(x: Col, p: number): Node;
+    sma(x: Col, p: number): Node;
+    /**
+     * Recursive smoothing y = y' + alpha (x - y'), seeded with the simple mean of
+     * the first p valid values (TA-Lib's EMA/Wilder seeding; also Pine's).
+     */
+    smooth(x: Col, p: number, alpha: number): Node;
+    ema(x: Col, p: number): Node;
+    /** Wilder's smoothing (RMA / SMMA). */
+    rma(x: Col, p: number): Node;
+    /** Linearly weighted mean, newest bar weighted p. */
+    wma(x: Col, p: number): Node;
+    /** Highest value over the last p bars. */
+    highest(x: Col, p: number): Node;
+    lowest(x: Col, p: number): Node;
+    /** Bars since the highest/lowest value in the window (0 = this bar); ties pick the most recent. */
+    highestBars(x: Col, p: number, oldest?: boolean): Node;
+    lowestBars(x: Col, p: number, oldest?: boolean): Node;
+    /** `oldest`: ties pick the oldest bar (TA-Lib's MAXINDEX/MININDEX) instead of the newest (Aroon). */
+    private extreme;
+    /**
+     * Population variance over p bars (TA-Lib VAR): mean-centred two-pass over the
+     * window, because running sums of squares lose ~1e-8 relative on price series.
+     * `sample` divides by p - 1 instead (the unbiased estimator, the one a Sharpe or volatility estimate from a sample uses): the
+     * population value scaled by p / (p - 1), undefined for p = 1.
+     */
+    variance(x: Col, p: number, sample?: boolean): Node;
+    stdev(x: Col, p: number, sample?: boolean): Node;
+    /**
+     * Least-squares line over the last p bars against x = 0..p-1 (oldest..newest).
+     * `value` is the line at the newest bar; `slope` per bar; `intercept` at the oldest bar.
+     */
+    linreg(x: Col, p: number): {
+        value: Node;
+        slope: Node;
+        intercept: Node;
+    };
+    /** A node that mirrors an aux column (so it can be returned as an output). */
+    alias(c: Col): Node;
+    /** True range: max(h-l, |h-c'|, |l-c'|); the first bar has no previous close, so is absent (TA-Lib TRANGE). */
+    tr(): Node;
+    /** True range with the first bar's range as high - low (Wilder; Pine's `ta.tr(true)`). */
+    trFirst(): Node;
+    /**
+     * Average true range as Wilder defined it: the first true range is high - low, the seed is the
+     * mean of true ranges 0..p-1 (first value at bar p-1), then Wilder's smoothing. Not TA-Lib's ATR (TA-Lib skips the first
+     * true range, so it starts one bar later and differs by a different seed).
+     */
+    atr(p: number): Node;
+    /**
+     * Bars per year, read from the bars of this graph and from nothing after the bar it is written on (a causal annualisation). Intraday bars: the median number of bars per exchange-clock day over the
+     * last {@link BPY_SESSIONS} finished days, times 252 sessions (nights and weekends add no bars). A day or longer between bars: 252 a
+     * year for daily bars that leave weekends out, otherwise calendar time (365 days over the median spacing: weekly 52.14,
+     * monthly 12.17), the median over the last {@link BPY_COARSE} bars. Constant within a day, so a finished bar's value never changes
+     * when later bars arrive or the last bar is revised; absent before the first day has finished (and, for a day or
+     * longer, before six bars). The day is cut at `offsetMin` minutes east of UTC: 0 suits every session inside one UTC day
+     * (NSE, BSE, MCX, NYSE, LSE).
+     */
+    barsPerYear(offsetMin?: number): Node;
+}
+/** Finished days whose bar counts the median is taken over (barsPerYear). */
+export declare const BPY_SESSIONS = 60;
+/** Bars the spacing and the weekend test are read from when bars are a day or longer (barsPerYear). */
+export declare const BPY_COARSE = 120;
+export declare function checkPeriod(p: number): void;

package/dist/types/engine/kernels.d.ts

@@ -0,0 +1,9 @@
+import type { Kernels } from "@alphacharts/wasm";
+export type BatchKernels = Pick<Kernels, "sumState" | "variance" | "highest" | "lowest" | "highestBars" | "lowestBars" | "linreg">;
+/** Route eligible batch runs through `k`; null restores the JS loops. */
+export declare function setKernels(k: BatchKernels | null): void;
+export declare function kernels(): BatchKernels | null;
+/** Below this many bars the call overhead beats the win. */
+export declare const KERNEL_MIN_BARS = 4096;
+/** A kernel run needs the whole series from bar 0 and no absent values. */
+export declare function eligible(x: Float64Array, from: number, to: number): boolean;

package/dist/types/engine/study.d.ts

@@ -0,0 +1,40 @@
+import { Graph, type Col } from "./graph.js";
+import type { BarColumns, BarInput, InputValue, Params, StudyDef } from "../types.js";
+import type { FeedBar, FeedConfig, FeedBars } from "./feed.js";
+/** Validate `given` against the study's inputs and fill defaults. Throws on anything unknown or out of range. */
+export declare function resolveParams(def: StudyDef, given?: Readonly<Record<string, InputValue>>): Params;
+/** A study bound to parameters and a graph: appends, revises and batch-loads bars. */
+export declare class StudyEngine {
+    readonly def: StudyDef;
+    readonly graph: Graph;
+    readonly outputs: readonly Col[];
+    readonly params: Params;
+    constructor(def: StudyDef, params?: Readonly<Record<string, InputValue>>);
+    get length(): number;
+    /** Replace all bars and compute. */
+    load(d: BarColumns): void;
+    /**
+     * Like `load`, but evaluates in chunks of `chunk` bars and awaits `pause()`
+     * between them, so a runner can service cancel messages. Stops quietly and
+     * returns false when `cancelled()` turns true.
+     */
+    loadChunked(d: BarColumns, chunk: number, pause: () => Promise<void>, cancelled: () => boolean): Promise<boolean>;
+    /** Give the study outside series `key`: bars in their own time and how to join them (copied). Run the study again afterwards. */
+    setFeed(key: string, bars: FeedBars, cfg: FeedConfig): void;
+    /**
+     * A live bar of outside series `key`: the feed's last bar is replaced or one is appended, and what the study computed
+     * on the feed's bars follows. When the study's last bar now sees a different feed row (or the same one revised), that
+     * bar is evaluated again and `true` is returned; otherwise nothing of the study is recomputed. O(1) amortised.
+     */
+    pushFeed(key: string, bar: FeedBar): boolean;
+    /** Append a bar (time later than the last). */
+    push(b: BarInput): void;
+    /** Replace the last bar (a tick revision). */
+    reviseLast(b: BarInput): void;
+    /** Output column `k` as a view over the bars loaded (valid until the next push that grows the graph). */
+    column(k: number): Float64Array;
+    private write;
+    private requireColumns;
+}
+/** One-shot: run a study over columns and return its output columns (copies, length n). */
+export declare function runStudy(def: StudyDef, params: Readonly<Record<string, InputValue>>, d: BarColumns): Float64Array[];

package/dist/types/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./types.js";
+export { Graph, Col, Node, SOURCE_NAMES } from "./engine/graph.js";
+export type { Ref, SourceName } from "./engine/graph.js";
+export { StudyEngine, resolveParams, runStudy } from "./engine/study.js";
+export { Feed, FEED_FIELDS, describeJoin, joinFeed } from "./engine/feed.js";
+export type { FeedAlign, FeedBar, FeedBars, FeedChange, FeedConfig, FeedData, FeedField, JoinReason, JoinReport } from "./engine/feed.js";
+export { registerStudy, registerStudies, getStudy, listStudies, validateDef } from "./registry.js";
+export { defineStudy } from "./define.js";
+export { addStudy, installStudies, StudiesPlugin, Study, PLUGIN_ID } from "./chart/studies.js";
+export type { AddStudyOptions, PlotStyle } from "./chart/studies.js";
+export { markerFloor } from "./chart/marker-floor.js";
+export { InlineRunner, WorkerRunner, createRunner, serveWorker, CancelledError, CHUNK } from "./runner.js";
+export type { StudyRunner, RunRequest, RunResult, WorkerLike } from "./runner.js";
+export { enableWasm, disableWasm } from "./wasm.js";
+export { setKernels } from "./engine/kernels.js";

package/dist/types/registry.d.ts

@@ -0,0 +1,7 @@
+import type { StudyDef } from "./types.js";
+export declare function registerStudy(def: StudyDef): void;
+export declare function registerStudies(defs: readonly StudyDef[]): void;
+export declare function getStudy(id: string): StudyDef;
+export declare function listStudies(): StudyDef[];
+/** Catch an inconsistent definition when it is registered, not when it is drawn. */
+export declare function validateDef(def: StudyDef): void;

package/dist/types/runner.d.ts

@@ -0,0 +1,91 @@
+import type { FeedBar, FeedData } from "./engine/feed.js";
+import type { BarColumns, InputValue, StudyDef } from "./types.js";
+export declare const CHUNK: number;
+export interface RunRequest {
+    studyId: string;
+    params: Readonly<Record<string, InputValue>>;
+    /** Transferred to the runner when it is a worker: do not use afterwards. */
+    bars: BarColumns;
+    /** Outside series by key, each a copy the runner may keep or transfer. Only a runner that can run a study that reads them (a script) uses them. */
+    feeds?: Record<string, FeedData>;
+}
+export interface RunResult {
+    n: number;
+    /** All graph columns (inputs, state, outputs), in registration order. */
+    buffers: Float64Array[];
+}
+export declare class CancelledError extends Error {
+    constructor();
+}
+export interface StudyRunner {
+    /** Whether this runner can evaluate `def` (a worker only knows built-ins). */
+    canRun(def: StudyDef): boolean;
+    /** Rejects with CancelledError when `cancel(handle)` is called first. */
+    run(def: StudyDef, req: RunRequest): {
+        promise: Promise<RunResult>;
+        cancel(): void;
+    };
+    /**
+     * A live bar of outside series `key` for a study this runner holds state for; the runner answers through the channel
+     * its ticks use. Optional: a runner that keeps no per-study state (every batch starts afresh) does not have it.
+     */
+    feedBar?(def: StudyDef, key: string, bar: FeedBar): void;
+    dispose(): void;
+}
+/** Main-thread fallback: same chunked evaluation, same cancellation. */
+export declare class InlineRunner implements StudyRunner {
+    canRun(): boolean;
+    run(def: StudyDef, req: RunRequest): {
+        promise: Promise<RunResult>;
+        cancel: () => undefined;
+    };
+    dispose(): void;
+}
+export interface WorkerLike {
+    postMessage(msg: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: "message", fn: (e: {
+        data: unknown;
+    }) => void): void;
+    addEventListener(type: "error", fn: (e: {
+        message?: string;
+    }) => void): void;
+    terminate(): void;
+}
+type WorkerReply = {
+    type: "result";
+    id: number;
+    n: number;
+    buffers: Float64Array[];
+} | {
+    type: "cancelled";
+    id: number;
+} | {
+    type: "error";
+    id: number;
+    message: string;
+};
+/** Runs built-in studies in a Web Worker. `isBuiltin` says which ids the worker knows. */
+export declare class WorkerRunner implements StudyRunner {
+    private readonly worker;
+    private readonly isBuiltin;
+    private nextId;
+    /** Set once the worker has failed: later runs reject at once instead of waiting on a dead worker. */
+    private dead;
+    private readonly pending;
+    constructor(worker: WorkerLike, isBuiltin: (def: StudyDef) => boolean);
+    canRun(def: StudyDef): boolean;
+    run(def: StudyDef, req: RunRequest): {
+        promise: Promise<RunResult>;
+        cancel: () => void;
+    };
+    dispose(): void;
+}
+/** Worker-side message handler: wire it to `self.onmessage` (see worker.ts). */
+export declare function serveWorker(post: (msg: WorkerReply, transfer?: Transferable[]) => void, find: (id: string) => StudyDef | undefined): (data: unknown) => void;
+/**
+ * A worker runner on the worker `factory` creates, otherwise (no factory, or the worker would not start) the inline fallback.
+ * The package never guesses where its worker lives: the host's bundler spells the URL out,
+ * `() => new Worker(new URL("@alphacharts/indicators/worker", import.meta.url), { type: "module" })`.
+ */
+export declare function createRunner(builtinIds: ReadonlySet<string>, factory?: () => WorkerLike): StudyRunner;
+export {};

package/dist/types/studies/all.d.ts

@@ -0,0 +1,2 @@
+import type { StudyDef } from "../types.js";
+export declare const ALL_STUDIES: readonly StudyDef[];

package/dist/types/studies/cycle.d.ts

@@ -0,0 +1,7 @@
+export declare const htDcPeriod: import("../types.js").StudyDef;
+export declare const htDcPhase: import("../types.js").StudyDef;
+export declare const htPhasor: import("../types.js").StudyDef;
+export declare const htSine: import("../types.js").StudyDef;
+export declare const htTrendline: import("../types.js").StudyDef;
+export declare const htTrendMode: import("../types.js").StudyDef;
+export declare const mama: import("../types.js").StudyDef;