TA library

Every workspace ships src/sdk/ta.ts: the whole kScript (legacy) TA catalog as stateful classes, one class per builtin, 52 in all. Each class folds one bar per update() call, keeps its own window, and mirrors the engine's arithmetic, warm-up, and missing-value rules bar for bar, so a port from kScript reads the same numbers it read before. This page is the catalog: every class with its constructor, its update() arguments, its fields, the builtin it replaces, and the one convention you need to know about it. The function pages (Moving averages, Oscillators, Trend indicators, Special indicators, Volume indicators, Series functions, Utility functions) go deeper on each group with compiled examples.

How every class works

• Allocate in the constructor, never in update(), so per-bar memory stays flat.
• update(...) folds one bar and returns the current value, NaN until the class is warm (a few classes report a partial window from bar 0 instead; the tables say which).
• Multi-output classes fill fields. update() returns the primary line and the other lines sit in public fields you read after the call.
• reset() restores the just-constructed state. The host replays the forming bar through reset() on every tick.
• Periods are i32, params are f64. Construct in init() from a param (new Sma(i32(p_period()))), keep the object in a module-level let, update it once per bar in state(), and call .reset() on it from your reset(). A period below 1 is clamped to 1 (except Donchian, which uses the period as given, like the engine).

The shipped classes

Averages and smoothing

Statistics and series math

Oscillators and momentum

Ranges and bands

Trend systems

Events and conditions

Zscore carries the engine's zScore builtin. Cross folds three builtins into one return value: test > 0, < 0, or != 0.

A composite over the shipped classes: a Macd read through its three fields, a Cross gate over the line and its signal, and an Rsi, with a hand-written sheet beside the source (the metadata-first shape; the code-first shape declares the same params, one input, and four outputs at the top of the file):

{
  "id": "momentum-kit",
  "abi_version": "wrun-1",
  "warmup_bars": 1,
  "params": [
    { "name": "fast", "default": 12, "min": 1, "max": 200 },
    { "name": "slow", "default": 26, "min": 2, "max": 400 },
    { "name": "signal", "default": 9, "min": 1, "max": 200 },
    { "name": "rsi_len", "default": 14, "min": 2, "max": 200 }
  ],
  "inputSources": { "close": { "source": "ohlcv", "field": "close" } },
  "inputs": [{ "index": 0, "name": "close" }],
  "outputs": [
    { "index": 0, "name": "macd", "plot": "line", "panel": "lower" },
    { "index": 1, "name": "signal", "plot": "line", "panel": "lower" },
    { "index": 2, "name": "rsi", "plot": "line", "panel": "lower" },
    { "index": 3, "name": "crossed", "plot": "" }
  ]
}

import { in_close } from "./gen/inputs";
import { emitRow, out_crossed, out_macd, out_rsi, out_signal } from "./gen/outputs";
import { p_fast, p_rsi_len, p_signal, p_slow } from "./gen/params";
import { Cross, Macd, Rsi } from "./sdk/ta";

let macd = new Macd(12, 26, 9);
let rsi = new Rsi(14);
let cross = new Cross();
let strength: f64 = NaN;
let crossed: f64 = 0.0;

export function init(): void {
  macd = new Macd(i32(p_fast()), i32(p_slow()), i32(p_signal()));
  rsi = new Rsi(i32(p_rsi_len()));
  cross = new Cross();
}

export function state(): i32 {
  const close = in_close();
  macd.update(close);
  strength = rsi.update(close);
  crossed = f64(cross.update(macd.macd, macd.signal));
  return isNaN(macd.signal) || isNaN(strength) ? 0 : 1;
}

export function finalize(): void {
  out_macd(macd.macd);
  out_signal(macd.signal);
  out_rsi(strength);
  out_crossed(crossed);
  emitRow();
}

export function reset(): void {
  macd.reset();
  rsi.reset();
  cross.reset();
  strength = NaN;
  crossed = 0.0;
}

The catalog: every builtin and its class

Every name from the kScript catalog and the class or expression that carries it. Every class ships in src/sdk/ta.ts; the page column is where the group is explained with compiled examples.

Moving averages and smoothing

Oscillators and momentum

Trend and volatility

Volume

Statistics

Bars and events

The order book and volume profile scans (bidSum, askSum, the footprint accessors) are not classes: they are loops over a celled input on the Orderbook functions and Volume profile pages.

Conventions (read this once)

These rules hold across the library and explain nearly every edge case. Each one is the engine's own rule, carried over rather than tidied up.

Warm-up is NaN, with the engine's exceptions. A windowed class returns NaN until it has a full window and never fabricates an early value. The classes whose builtin reports a partial window from bar 0 do the same: Sum, Donchian, Ichimoku, Cum (bar 0 is x), Obv (bar 0 is 0), and Stochastic (0 before its window fills). Decide per row whether to abstain (return 0 from state()) or to write the NaN and let the chart draw nothing on that bar (Execution model).

Windows are strict; accumulators poison. A class that recomputes over its window (Sma, Wma, Alma, Linreg, Median, Percentile, Variance, Stdev, Correlation, Bb, Highest, Lowest, and the rest of the window family) yields NaN while any value inside the window is not finite and heals as soon as it leaves. A class that carries a running accumulator (Ema, Rma, Atr, Rsi, Macd, Adx, Cum, Psar, Supertrend's ATR) restarts its seed when a non-finite value arrives before the seed completes, and turns NaN for good when one arrives after, because the engine never reseeds. Sum and Zscore skip NaN bars instead. Run a sparse source through Fixnan or an isNaN guard before an accumulator.

Column defaults are yours to honor. kScript read the high for highest, highestbars, and pivothigh, and the low for their counterparts; the classes take one value per bar, so pass in_high() or in_low() to match, or the close to match highest(source=d.close).

Classes compose. update() takes any f64, including another class's output (rsi.update(sma.update(close))) and any series derived from a celled input. Warm-up propagates through the composition because NaN propagates through arithmetic.

Values carry; events do not. A missing scalar carries the latest eligible value forward by default (the missing policy on the source decides), so math keeps working. Events are stricter: Cross.update() returns 0 on any bar where either side is NaN, BarsSince and ValueWhen read a condition you computed (finite and not 0), so stale data cannot fabricate a signal.

Rma is Wilder, and it is the engine's Wilder. Rsi, Atr, Keltner, and Supertrend share the same accumulator, so a port that composed them in kScript reads the same numbers here.

reset() restores everything. The host replays the forming bar through reset() on every tick; a class or a module-level variable it forgets is a stale value the replayed bar reads.

Multi-output indicators

A kScript builtin that returned several streams is a class with several fields. There are no tuple outputs and nothing indexes into an array: update() returns the primary line, and you read the other fields after the call and write each to its own output (Named streams).

Fields feed a band declaration or a box the same way outputs do: write bb.upper and bb.lower to two outputs and declare a box between their handles (Drawing objects).

Over microstructure

Every windowed class also runs over order-flow series, which is where the library stops being a price-only kit. A celled volume_profile input delivers each bar's [low, high, buy, sell] tuples; sum the buy and sell columns into a per-bar delta and the delta is just an f64 any class can fold: an Rsi over it is delta-RSI, a running sum is cumulative volume delta. Declaring the celled input switches the derived sheet to the second runtime contract, and the numeric classes compute exactly as before.

import { input, line, lower, ohlcv, output, param, volume_profile } from "./sdk/declare";
import { in_close, in_profile_capacity, in_profile_cells, in_profile_read } from "./gen/inputs";
import { emitRow, out_cvd, out_delta, out_delta_rsi } from "./gen/outputs";
import { p_period } from "./gen/params";
import { Rsi } from "./sdk/ta";

param("period", 14, { min: 2, max: 200, description: "RSI window over the per-bar delta" });
input("close", ohlcv.close);
input("profile", volume_profile.cells, { max_cells: 512 });
output("delta", line, lower, { color: "#94a3b8", width: 1, description: "Buy minus sell volume across the bar's profile" });
output("delta_rsi", line, lower, { color: "#7c3aed", width: 2, description: "RSI of the per-bar delta" });
output("cvd", line, lower, { color: "#22d3ee", width: 2, description: "Cumulative volume delta" });

const cells = new StaticArray<f64>(in_profile_capacity);
let rsi = new Rsi(14);
let delta: f64 = NaN;
let deltaRsi: f64 = NaN;
let cvd: f64 = 0.0;

export function init(): void {
  rsi = new Rsi(i32(p_period()));
}

export function state(): i32 {
  in_close();
  const n = in_profile_cells();
  if (n < 0) return 0; // this bar carries no block
  delta = 0.0;
  if (n > 0) {
    in_profile_read(i32(changetype<usize>(cells)));
    for (let i = 0; i + 3 < n; i += 4) delta += cells[i + 2] - cells[i + 3];
  }
  cvd += delta;
  deltaRsi = rsi.update(delta);
  return 1;
}

export function finalize(): void {
  out_delta(delta);
  out_delta_rsi(deltaRsi);
  out_cvd(cvd);
  emitRow();
}

export function reset(): void {
  rsi.reset();
  delta = NaN;
  deltaRsi = NaN;
  cvd = 0.0;
}

The Volume profile page has every accessor the kScript footprint functions offered as a scan over the same tuples; the Orderbook functions page does the same over book levels for a book-imbalance average.

Accuracy as a contract

Every class is checked bit-exact against the kScript engine. The reference is kScript engine 3.0.85 run over a 690-bar 1h BTCUSDT window; each class is compiled through the real build and executed through the real runtime over the same bars, and every output is compared per bar: a maximum absolute deviation of 0 and identical NaN placement (a bar that is NaN in the engine is NaN here, and only that bar). The conventions on this page are written down so that comparison holds, and a change that drifts a class from the engine's numbers fails the build.

Two honest exceptions.

• Ichimoku.chikou is the current close. The engine computes the lagging span by reading close[i + displacement], a bar in the future of bar i, and only falls back to the current close on the last displacement bars of the series. A class that sees one bar at a time cannot read ahead, so the field carries the current close on every bar; it matches the engine on those last bars only. The other four fields match bar for bar.
• Vwap anchors beyond "", "day", and a numeric millisecond width are ported but unproven on that window. The "week", "month", "quarter", and "year" boundaries follow the engine's UTC calendar arithmetic, but the 690-bar window does not exercise a deep-history quarter or year, and the engine's session-calendar bucketing and RTH session filter (venues with a trading-session calendar) are not mirrored, since a per-bar class never sees a session calendar.

Everything else in the catalog, warm-up bars included, reads the same numbers a kScript script read. From kScript has the loop for comparing a full port against its original on one market.