@alphacharts/script 0.0.0-stage → 0.1.0

package/dist/types/ast.d.ts

@@ -0,0 +1,156 @@
+import type { Span } from "./diag.js";
+export type Base = "int" | "float" | "bool" | "string" | "color" | "na" | "plot" | "void" | "tuple";
+/** const: a literal; input: known when the study is built; series: varies per bar. */
+export type Qual = "const" | "input" | "series";
+export interface Ty {
+    b: Base;
+    q: Qual;
+    elems?: Ty[];
+}
+export interface Sym {
+    name: string;
+    kind: "builtin" | "input" | "simple" | "pure" | "state" | "local" | "loop" | "plot";
+    ty: Ty;
+    /** Builtin source name, input key, or slot / plot index. */
+    key?: string;
+    slot?: number;
+    /** A top-level variable kept in the exec program (var, or assigned with :=). */
+    isVar?: boolean;
+    decl?: Span;
+    /** A pure variable's domain (see `Base_.dom`). */
+    dom?: string;
+}
+interface Base_ extends Span {
+    /** Type, set by the checker. */
+    ty?: Ty;
+    /** Depends on a variable that changes while a bar is evaluated (state, locals, loop counters). */
+    st?: boolean;
+    /**
+     * Whose bars the value lives on, set by the checker: "~" a constant (no bars of its own), "@" the chart's bars (the
+     * default), or the key of the outside series whose own bars it is computed on. See check.ts, `combineDom`.
+     */
+    dom?: string;
+}
+/** `float` is how the literal was written: with a dot or an exponent (0.0, 1., 1e3) it is a float whatever its value. */
+export interface NumLit extends Base_ {
+    k: "num";
+    value: number;
+    float: boolean;
+}
+export interface StrLit extends Base_ {
+    k: "str";
+    value: string;
+}
+export interface BoolLit extends Base_ {
+    k: "bool";
+    value: boolean;
+}
+export interface ColorLit extends Base_ {
+    k: "color";
+    value: string;
+}
+export interface Ident extends Base_ {
+    k: "id";
+    name: string;
+    sym?: Sym;
+}
+export interface Unary extends Base_ {
+    k: "un";
+    op: "-" | "+" | "not";
+    x: Expr;
+}
+export interface Binary extends Base_ {
+    k: "bin";
+    op: string;
+    a: Expr;
+    b: Expr;
+}
+export interface Ternary extends Base_ {
+    k: "tern";
+    c: Expr;
+    a: Expr;
+    b: Expr;
+}
+export interface Arg {
+    name: string | null;
+    nameSpan?: Span;
+    value: Expr;
+}
+export interface Call extends Base_ {
+    k: "call";
+    callee: Expr; /** For outside(): the key of the series it reads, and whether it has a timeframe of its own (then what is computed on it runs on its own bars). */
+    feed?: string;
+    own?: boolean;
+    args: Arg[]; /** Resolved signature name, e.g. "ta.sma". */
+    fn?: string; /** Arguments in parameter order (null = omitted). */
+    bound?: (Expr | null)[];
+}
+export interface Member extends Base_ {
+    k: "mem";
+    obj: Expr;
+    name: string;
+    nameSpan: Span; /** A namespace constant's value (math.pi, color.red, plot.style_line). */
+    cv?: number | string;
+}
+export interface Index extends Base_ {
+    k: "idx";
+    x: Expr;
+    i: Expr;
+}
+export interface ArrayLit extends Base_ {
+    k: "arr";
+    items: Expr[];
+}
+export type Expr = NumLit | StrLit | BoolLit | ColorLit | Ident | Unary | Binary | Ternary | Call | Member | Index | ArrayLit;
+export type TypeName = "int" | "float" | "bool" | "string" | "color";
+export interface VarDecl extends Span {
+    k: "decl";
+    isVar: boolean;
+    type: TypeName | null;
+    name: string;
+    nameSpan: Span;
+    init: Expr;
+    sym?: Sym;
+}
+export interface TupleDecl extends Span {
+    k: "tuple";
+    names: {
+        name: string;
+        span: Span;
+    }[];
+    init: Expr;
+    syms?: Sym[];
+}
+export interface Assign extends Span {
+    k: "assign";
+    name: string;
+    nameSpan: Span;
+    op: ":=" | "+=" | "-=" | "*=" | "/=" | "%=";
+    value: Expr;
+    sym?: Sym;
+}
+export interface If extends Span {
+    k: "if";
+    cond: Expr;
+    then: Stmt[];
+    else: Stmt[] | null;
+}
+export interface For extends Span {
+    k: "for";
+    name: string;
+    nameSpan: Span;
+    lo: Expr;
+    hi: Expr;
+    by: Expr | null;
+    body: Stmt[];
+    sym?: Sym;
+}
+export interface ExprStmt extends Span {
+    k: "expr";
+    expr: Expr;
+}
+export type Stmt = VarDecl | TupleDecl | Assign | If | For | ExprStmt;
+export interface Program {
+    body: Stmt[];
+}
+export {};

package/dist/types/builtins.d.ts

@@ -0,0 +1,67 @@
+import type { InputDef, StudyDef } from "@alphacharts/indicators";
+import type { Ty } from "./ast.js";
+export declare const FLOAT_S: Ty;
+export declare const INT_S: Ty;
+export declare const BOOL_S: Ty;
+export declare const t: (b: Ty["b"], q?: Ty["q"]) => Ty;
+export declare const tuple: (elems: Ty[]) => Ty;
+/** The fields of an outside series a script can read. */
+export declare const OUTSIDE_FIELDS: readonly ["open", "high", "low", "close", "volume"];
+export declare const NAMESPACES: ReadonlySet<string>;
+/** Series available everywhere. `needs` is what the study must be given. */
+export declare const BUILTIN_SERIES: Readonly<Record<string, {
+    ty: Ty;
+    needs: "value" | "ohlc" | "ohlcv";
+}>>;
+export declare const COLORS: Readonly<Record<string, string>>;
+/** Constants reachable as `namespace.name`. */
+export declare const MEMBER_CONSTS: Readonly<Record<string, {
+    ty: Ty;
+    value: number | string;
+}>>;
+export declare const ENUMS: {
+    plotStyle: string[];
+    lineStyle: string[];
+    shape: string[];
+    location: string[];
+};
+/**
+ * series: a numeric (or bool) series, any qualifier. num/int/bool/string/color: simple values (const or input).
+ * `enum`: one of a set, written as the namespace constant. strlist: an array literal of string literals.
+ */
+export type PKind = "series" | "num" | "int" | "bool" | "string" | "color" | "enum" | "strlist" | "plot" | "any";
+export interface Param {
+    name: string;
+    kind: PKind;
+    opt?: boolean;
+    /** For "enum". */
+    oneOf?: readonly string[];
+    /** For "int"/"num": bounds checked when the argument is a literal; checked again at build otherwise. */
+    min?: number;
+    max?: number;
+    /** For generic study inputs: the input this parameter feeds. */
+    input?: InputDef;
+}
+export interface Sig {
+    /** Fully qualified name: "ta.sma", "nz". */
+    name: string;
+    params: Param[];
+    ret: Ty;
+    /** What the study must be given for this call to work. */
+    needs?: "value" | "ohlc" | "ohlcv";
+    /** Kind of lowering. */
+    op: "scalar" | "kernel" | "study" | "special";
+    /** Scalar math: elementwise. */
+    fn?: (...a: number[]) => number;
+    /** Generic study: the definition and the order of its non-source inputs. */
+    study?: StudyDef;
+}
+export declare const SIGS: Map<string, Sig>;
+export declare const TA_TR: Ty;
+export declare const studyFnName: (id: string) => string;
+/** Names the editor can offer: every callable, every constant, the series and the keywords. */
+export declare function completionNames(): {
+    label: string;
+    kind: "function" | "constant" | "variable" | "keyword" | "namespace";
+    detail?: string;
+}[];

package/dist/types/check.d.ts

@@ -0,0 +1,78 @@
+import type { Arg, Expr, Program, Stmt, Sym } from "./ast.js";
+import type { Reporter, Span } from "./diag.js";
+import { type Dependency } from "./feeds.js";
+export type ColorRef = {
+    value: string;
+} | {
+    input: string;
+};
+export interface InputSpec {
+    key: string;
+    kind: "int" | "float" | "bool" | "string" | "source" | "color";
+    label: string;
+    default: number | boolean | string;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: string[];
+    span: Span;
+}
+export interface PlotSpec {
+    kind: "line" | "histogram" | "area" | "hline" | "fill" | "markers" | "barcolor" | "bgcolor";
+    key: string;
+    title: string;
+    color: ColorRef;
+    /** A line coloured per bar: `color` where `cond` is false or absent, this colour where it is true. */
+    colorWhen?: {
+        cond: Expr;
+        color: string;
+    };
+    colorDown?: string;
+    width?: number;
+    lineStyle?: string;
+    offset?: number;
+    /** A bar shift written as an expression known when the study is built (`-right`): an int input or a literal combination of them. Wins over `offset`. */
+    offsetExpr?: Expr;
+    /** Series plotted (line/histogram/area/markers), the price of an hline, or the condition of a barcolor / bgcolor. */
+    expr?: Expr;
+    /** fill: indexes into the plots. */
+    a?: number;
+    b?: number;
+    /** hline: a fill draws between it and another plot, so its level is also a column (constant on every bar). */
+    column?: boolean;
+    shape?: string;
+    position?: string;
+    /** plotshape: only the most recent `last` marked bars keep their mark. */
+    last?: number;
+    /** plotshape: only marks on the final `within` bars are kept. */
+    within?: number;
+    span: Span;
+}
+export interface Plan {
+    title: string;
+    overlay: boolean;
+    /** Which price axis the script's series use. */
+    scale: "left" | "right";
+    /** Every `outside(...)` call, once per distinct (symbol, field, timeframe), in order of first use. */
+    dependencies: Dependency[];
+    inputs: InputSpec[];
+    plots: PlotSpec[];
+    body: Stmt[];
+    needs: "value" | "ohlc" | "ohlcv";
+    /** Frame size of the per-bar program. */
+    slots: number;
+    /** Top-level variables kept in columns by the per-bar program, in declaration order. */
+    stateVars: Sym[];
+}
+/** Domains: a value lives on the chart's bars ("@"), on an outside series' own bars (its key), or on none (a constant, "~"). */
+export declare const CHART_DOM = "@";
+export declare const CONST_DOM = "~";
+/**
+ * The domain of an operation on operands of these domains: constants take the other's; operands of one outside series
+ * stay on its bars (so a window of 14 is 14 of its bars); anything else is on the chart's bars, each outside operand
+ * meeting them through the join first.
+ */
+export declare function combineDom(...doms: string[]): string;
+export declare function withTransparency(hex: string, transp: number): string;
+export declare function check(prog: Program, rep: Reporter, limits?: Readonly<import("./limits.js").Limits>): Plan;
+export type { Arg };

package/dist/types/codegen.d.ts

@@ -0,0 +1,14 @@
+import type { StudyDef } from "@alphacharts/indicators";
+import type { Plan } from "./check.js";
+import { type Limits } from "./limits.js";
+export interface ColorInput {
+    key: string;
+    label: string;
+    default: string;
+    plotKeys: string[];
+}
+export interface Compiled {
+    def: StudyDef;
+    colorInputs: ColorInput[];
+}
+export declare function generate(plan: Plan, source: string, limits?: Limits): Compiled;

package/dist/types/compile.d.ts

@@ -0,0 +1,52 @@
+import type { StudyDef } from "@alphacharts/indicators";
+import { type Diagnostic } from "./diag.js";
+import { type InputSpec, type Plan, type PlotSpec } from "./check.js";
+import type { Expr, Stmt } from "./ast.js";
+import { type ColorInput } from "./codegen.js";
+import type { Dependency } from "./feeds.js";
+import { type Limits } from "./limits.js";
+/** One output statement of the script. `expr` is the series plotted (plot, plotshape) or the price of an hline; fill has none. */
+export interface PlotView {
+    kind: PlotSpec["kind"];
+    title: string;
+    expr: Expr | null;
+}
+/**
+ * What the script means, read off the checked syntax tree (nothing is executed). Read-only: the tree is shared with the
+ * compiled study, do not change it. Names are resolved: an `id` node's `sym` is the declaration it refers to (same object for every use
+ * and every assignment of one variable), `ty` is every expression's type, `call.fn` the resolved function name ("ta.sma").
+ */
+export interface ScriptPlan {
+    overlay: boolean;
+    /** The price axis the script's series use. */
+    scale: "left" | "right";
+    /**
+     * The outside series the script reads, one entry per distinct `outside(symbol, field, timeframe)` call, found by
+     * reading the program (nothing is run). `symbol` / `timeframe` are null for "this chart's". The host loads them and
+     * gives them to the script (`feedsOf(plan.dependencies)` groups them by series).
+     */
+    dependencies: readonly Dependency[];
+    /** The most the script reads: "value" (close/time only), "ohlc", or "ohlcv" when it reads volume (the `volume` series or a study that does). */
+    needs: Plan["needs"];
+    plots: readonly PlotView[];
+    /** Top-level statements, in order. */
+    body: readonly Stmt[];
+}
+export interface CompileOk {
+    ok: true;
+    study: StudyDef;
+    /** Inputs the study schema has no type for (input.color): applied as plot colours. */
+    colorInputs: ColorInput[];
+    inputs: InputSpec[];
+    title: string;
+    /** Warnings only. */
+    diagnostics: Diagnostic[];
+    source: string;
+    plan: ScriptPlan;
+}
+export interface CompileFailed {
+    ok: false;
+    diagnostics: Diagnostic[];
+}
+export type CompileResult = CompileOk | CompileFailed;
+export declare function compile(source: string, limits?: Limits): CompileResult;

package/dist/types/diag.d.ts

@@ -0,0 +1,45 @@
+export interface Diagnostic {
+    severity: "error" | "warning";
+    message: string;
+    /** 1-based. */
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+    /** Character offsets into the source, `to` exclusive. */
+    from: number;
+    to: number;
+}
+export interface Span {
+    from: number;
+    to: number;
+}
+/** Converts offsets to line:column for one source text. */
+export declare class LineMap {
+    readonly text: string;
+    private readonly starts;
+    constructor(text: string);
+    at(offset: number): {
+        line: number;
+        column: number;
+    };
+}
+/** Collects diagnostics; stops accepting errors after `max` (the last one says so). */
+export declare class Reporter {
+    private readonly max;
+    readonly list: Diagnostic[];
+    private readonly map;
+    private errors;
+    constructor(text: string, max?: number);
+    get errorCount(): number;
+    error(message: string, span: Span): void;
+    warn(message: string, span: Span): void;
+    private add;
+}
+/** Thrown for failures found while building or running a script, with the range of the offending code. */
+export declare class ScriptError extends Error {
+    readonly span: Span | null;
+    readonly kind: "build" | "runtime" | "budget";
+    constructor(message: string, span?: Span | null, kind?: "build" | "runtime" | "budget");
+}
+export declare function formatDiagnostic(d: Diagnostic): string;

package/dist/types/editor/index.d.ts

@@ -0,0 +1,23 @@
+import { type Completion } from "@codemirror/autocomplete";
+import { StreamLanguage } from "@codemirror/language";
+import type { Diagnostic } from "../diag.js";
+export interface ScriptEditorAdapter {
+    mount(el: HTMLElement, opts: {
+        value: string;
+        onChange(v: string): void;
+        onRun(v: string): void;
+        diagnostics: Diagnostic[];
+    }): {
+        setDiagnostics(d: Diagnostic[]): void;
+        destroy(): void;
+    };
+}
+interface LState {
+}
+export declare const scriptLanguage: StreamLanguage<LState>;
+/** Names declared in the text (variables, inputs, loop counters): `name =`, `var name =`, `float name =`, `for i =`, `[a, b] =`. */
+export declare function declaredNames(text: string): string[];
+/** Completion options for the word before the cursor (exported for tests). */
+export declare function completionsFor(text: string, word: string): Completion[];
+export declare function createScriptEditorAdapter(): ScriptEditorAdapter;
+export type { Diagnostic };

package/dist/types/feeds.d.ts

@@ -0,0 +1,33 @@
+import type { FeedAlign, FeedField } from "@alphacharts/indicators";
+export { describeJoin } from "@alphacharts/indicators";
+export type { FeedField, JoinReason, JoinReport } from "@alphacharts/indicators";
+/** One `outside(symbol, field, timeframe)` call: `symbol` / `timeframe` are null when the script left them out (this chart's). */
+export interface Dependency {
+    symbol: string | null;
+    field: FeedField;
+    timeframe: string | null;
+}
+/** One outside series the host must load: a distinct (symbol, timeframe), carrying every field the script reads from it. */
+export interface FeedRef {
+    /** Pass to `handle.setSeries` / `handle.pushSeries`. */
+    key: string;
+    symbol: string | null;
+    timeframe: string | null;
+    fields: FeedField[];
+}
+/** Length in ms of a timeframe like "5m", "1h", "1d", "1w", or null when it is not written that way. */
+export declare function parseTimeframe(tf: string): number | null;
+/** The key of an outside series: symbol and timeframe, either empty for "this chart's". Symbols are opaque, so the separator is an unprintable one. */
+export declare function feedKey(symbol: string | null, timeframe: string | null): string;
+/** The distinct outside series a script reads, in order of first use, each with its fields. */
+export declare function feedsOf(deps: readonly Dependency[]): FeedRef[];
+/**
+ * How an outside series on `timeframe` (null: the chart's own) joins a chart whose bars last `intervalMs`:
+ * the same length joins on exact time ("same"); a longer one joins on the bar that has finished ("closed", its
+ * length is the nominal bar length); a shorter one is refused, since it would have to be aggregated and a
+ * silent choice of how would be a number nobody asked for.
+ */
+export declare function alignFor(timeframe: string | null, intervalMs: number): {
+    align: FeedAlign;
+    spanMs: number;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+export { compile } from "./compile.js";
+export type { CompileResult, CompileOk, CompileFailed, ScriptPlan, PlotView } from "./compile.js";
+export type { Expr, Stmt, Sym, Ty, Call, Ident, NumLit, VarDecl, TupleDecl, Assign, If, For, ExprStmt, Arg } from "./ast.js";
+export type { Diagnostic } from "./diag.js";
+export { formatDiagnostic, ScriptError } from "./diag.js";
+export type { ColorInput } from "./codegen.js";
+export type { InputSpec } from "./check.js";
+export { alignFor, describeJoin, feedKey, feedsOf, parseTimeframe } from "./feeds.js";
+export type { Dependency, FeedField, FeedRef, JoinReason, JoinReport } from "./feeds.js";
+export { DEFAULT_LIMITS } from "./limits.js";
+export type { Limits } from "./limits.js";
+export { runScript, restoreScript, ScriptDiagnosticsError } from "./run.js";
+export type { ScriptHandle, SavedScript, RunScriptOptions } from "./run.js";
+export { ScriptRunner } from "./runner.js";
+export { lockdown, serveScripts, BLOCKED_GLOBALS } from "./sandbox.js";
+export { createScriptRunAdapter } from "./ui-adapter.js";
+export type { ScriptRunAdapter } from "./ui-adapter.js";

package/dist/types/lexer.d.ts

@@ -0,0 +1,14 @@
+import type { Reporter } from "./diag.js";
+export type TokKind = "num" | "str" | "color" | "ident" | "kw" | "op" | "newline" | "indent" | "dedent" | "eof";
+export interface Token {
+    kind: TokKind;
+    /** Text for ident/kw/op; decoded value for str; digits for num; "#rrggbb[aa]" for color. */
+    text: string;
+    value?: number;
+    from: number;
+    to: number;
+}
+export declare const KEYWORDS: ReadonlySet<string>;
+/** Words that belong to other languages (or to features this one leaves out): refused with a pointer. */
+export declare const RESERVED: Readonly<Record<string, string>>;
+export declare function lex(src: string, rep: Reporter): Token[];

package/dist/types/limits.d.ts

@@ -0,0 +1,25 @@
+export interface Limits {
+    /** Largest period / length a ta.* call or history offset may use. Matches the indicators' own maximum. */
+    maxPeriod: number;
+    /** Iterations of one `for` statement execution. */
+    maxLoopIterations: number;
+    /** Loop iterations in the evaluation of one bar (the count restarts every bar, so it does not depend on the history length). */
+    maxSteps: number;
+    /** Columns of the compiled graph (every named series, ta.* result and intermediate). */
+    maxColumns: number;
+    /** Bytes a script may hold: columns x bars x 8, counted three times (the worker keeps a copy, and a column grows by half when a bar is appended). */
+    maxBytes: number;
+    /** Bars a script runs over. */
+    maxBars: number;
+    /** Nodes of the syntax tree / source length: refuses pathological inputs before they are parsed. */
+    maxSourceChars: number;
+    /** Distinct outside series (symbol and timeframe pairs) a script may read. Each is held twice (worker and page), in six columns of its own length. */
+    maxFeeds: number;
+    /** Wall-clock budget of one batch in the worker before it is terminated, milliseconds. */
+    batchMs: number;
+    /** Wall-clock budget of one tick, milliseconds. */
+    tickMs: number;
+}
+export declare const DEFAULT_LIMITS: Readonly<Limits>;
+/** Largest history offset `x[n]`. */
+export declare const MAX_HISTORY = 1000000;

package/dist/types/parser.d.ts

@@ -0,0 +1,3 @@
+import type { Reporter } from "./diag.js";
+import type { Program } from "./ast.js";
+export declare function parse(src: string, rep: Reporter): Program;

package/dist/types/run.d.ts

@@ -0,0 +1,69 @@
+import { type Study } from "@alphacharts/indicators";
+import type { Chart, Series, SeriesType } from "@alphacharts/core";
+import { type CompileOk } from "./compile.js";
+import { type FeedRef } from "./feeds.js";
+import { type Diagnostic } from "./diag.js";
+import { ScriptRunner } from "./runner.js";
+import type { Limits } from "./limits.js";
+import type { FeedBar, FeedBars, InputValue, WorkerLike } from "@alphacharts/indicators";
+type SourceSeries = Series<"candles" | "bars" | "line" | "area" | "histogram">;
+type VolumeSeries = Series<"histogram" | "line" | "area">;
+export declare class ScriptDiagnosticsError extends Error {
+    readonly diagnostics: Diagnostic[];
+    constructor(diagnostics: Diagnostic[]);
+}
+export interface RunScriptOptions {
+    volume?: VolumeSeries;
+    /** Share one runner (one worker) between scripts. Default: a private one that `remove()` disposes. */
+    runner?: ScriptRunner;
+    /** Creates the worker, from the host's bundler (`new Worker(new URL("@alphacharts/script/worker", import.meta.url), { type: "module" })`). Required unless `runner` is given: the package never guesses where its worker lives. */
+    workerFactory?: () => WorkerLike;
+    limits?: Partial<Limits>;
+    /**
+     * Length of one bar of the source series, ms. Required when the script reads outside series (`compile().plan.dependencies`):
+     * it decides whether each joins on exact time (same length) or on the bar that has finished (longer).
+     */
+    intervalMs?: number;
+    id?: string;
+    /** Called when the script fails at run time (budget, runtime error, worker failure). */
+    onError?: (d: Diagnostic) => void;
+}
+export interface ScriptHandle {
+    readonly study: Study;
+    readonly compiled: CompileOk;
+    /** The outside series the script reads (what to load and pass to `setSeries`), empty for a script that reads none. */
+    readonly feeds: readonly FeedRef[];
+    /**
+     * Give the script the bars of outside series `key` (one of `feeds[i].key`), in that series' own time (UTC ms, strictly
+     * increasing), replacing what it had, and compute again. The script keeps its own copy.
+     */
+    setSeries(key: string, bars: FeedBars): void;
+    /**
+     * A live bar of outside series `key`: the same time as its last bar revises it, a later time appends. Only the chart's
+     * last bar is evaluated again, and only when it sees a different bar of that series; otherwise nothing is computed or
+     * redrawn. Does nothing until `setSeries` has given the series.
+     */
+    pushSeries(key: string, bar: FeedBar): void;
+    /** Last run-time failure, if any. */
+    error: Diagnostic | null;
+    /**
+     * Change inputs: those in `partial` take their value, the others keep theirs, and the keys in `reset` go back to the
+     * script's defaults (colour inputs included). Outside series the script was given stay.
+     */
+    setInputs(partial: Readonly<Record<string, InputValue>>, reset?: readonly string[]): void;
+    remove(): void;
+    ready(): Promise<void>;
+    toJSON(): SavedScript;
+}
+export interface SavedScript {
+    version: 1;
+    source: string;
+    inputs: Record<string, InputValue>;
+    series: string;
+    volume?: string;
+    visible: boolean;
+}
+export declare function runScript(chart: Chart, source: SourceSeries, text: string, inputs: Readonly<Record<string, InputValue>>, opts: RunScriptOptions): ScriptHandle;
+/** Recreate a saved script (SavedScript from `toJSON`) on a chart that holds its series. */
+export declare function restoreScript(chart: Chart, saved: SavedScript, opts: RunScriptOptions): ScriptHandle;
+export type { SeriesType };

package/dist/types/runner.d.ts

@@ -0,0 +1,54 @@
+import { type BarInput, type FeedBar, type RunRequest, type RunResult, type StudyDef, type StudyRunner, type WorkerLike } from "@alphacharts/indicators";
+import { ScriptError } from "./diag.js";
+import { type Limits } from "./limits.js";
+export interface ScriptInfo {
+    sid: number;
+    source: string;
+}
+export interface TickListener {
+    values(index: number, values: Float64Array): void;
+    error(e: ScriptError): void;
+}
+export declare class ScriptRunner implements StudyRunner {
+    private readonly factory;
+    private worker;
+    private nextId;
+    private nextSid;
+    private readonly infos;
+    private readonly pending;
+    private readonly listeners;
+    private tickTimers;
+    /** Instances whose computed state died with a terminated worker: their bars are not sent until a new batch result. */
+    private readonly dead;
+    private limits;
+    private disposed;
+    constructor(factory: () => WorkerLike, limits?: Partial<Limits>);
+    /** Change budgets for later requests. */
+    setLimits(l: Partial<Limits>): void;
+    /** Bind a (mirror) definition to a script instance. Returns the instance id. */
+    attach(def: StudyDef, source: string, listener: TickListener): number;
+    detach(sid: number): void;
+    canRun(def: StudyDef): boolean;
+    private ensure;
+    private post;
+    run(def: StudyDef, req: RunRequest): {
+        promise: Promise<RunResult>;
+        cancel: () => void;
+    };
+    /** Send one bar of a tick (append or revision) to the script instance. */
+    sendBar(sid: number, index: number, bar: BarInput): void;
+    /** Send one live bar of an outside series to the script instance; it answers with the chart's last bar's values, or `idle` when nothing it sees changed. */
+    feedBar(def: StudyDef, key: string, bar: FeedBar): void;
+    private arm;
+    private clearTick;
+    private settle;
+    private onMessage;
+    private timeout;
+    /**
+     * Kill the worker. Every instance lost its computed state with it: each one is told, and stops
+     * sending bars until it is run again (a new batch, e.g. after an input change).
+     */
+    private terminateWorker;
+    private fail;
+    dispose(): void;
+}

package/dist/types/sandbox-worker.d.ts

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