openpinescript 0.0.0-stage → 0.1.1

package/dist/types/runtime/v1/stdlib/core.d.ts

@@ -0,0 +1,162 @@
+/**
+ * runtime/v1/stdlib/core.ts
+ * Core functions for Pine Script v2 (Strict Compliance)
+ */
+export declare function na(x: any): boolean;
+export declare function nz(x: any, y?: any): any;
+export declare function iff(cond: any, t: any, f: any): any;
+/**
+ * `+` — numeric addition, or STRING CONCATENATION when either side is a string.
+ *
+ * Pine overloads `+` exactly as JavaScript does, and this used to coerce
+ * unconditionally: `"a" + "b"` came out as `NaN`, because `Number("a")` is NaN.
+ * Nothing caught it, because v1–v4 have almost no reason to build a string —
+ * `tostring` exists and is rarely used, and a plot cannot show one.
+ *
+ * v5 makes it central. Pine Logs are how this project collects golden data
+ * without a paid TradingView plan (see runtime/v1/stdlib/logging.ts), every
+ * generated harness builds its CSV row with `str.tostring(x) + "," + …`, and
+ * all seven of them logged the single string "NaN".
+ */
+export declare function safe_add(a: any, b: any): number | string;
+export declare function safe_sub(a: any, b: any): number;
+/**
+ * `a == b` and `a != b`, with both sides UNWRAPPED first.
+ *
+ * ── The bug this fixes ──────────────────────────────────────────────────────
+ *
+ * Every script variable is a Series OBJECT, and JavaScript compares two objects
+ * with `==` by REFERENCE. So
+ *
+ *     x = 1.0
+ *     y = 1.0
+ *     equal = x == y      // false
+ *
+ * Two variables holding the same number were never equal, at any version. It
+ * survived because the common shapes hide it: `x == 0` compares an object to a
+ * primitive, which coerces through `valueOf`, and `<`, `>`, `<=`, `>=` coerce
+ * unconditionally. Only `==` and `!=` between two variables reach the reference
+ * comparison, and then they are silently, permanently false.
+ *
+ * ── Why `==` and not `===` after unwrapping ─────────────────────────────────
+ *
+ * Because objects must still compare by reference once unwrapped. An ENUM
+ * member is a plain object with no `valueOf` of its own — deliberately, so that
+ * two enums with identically named and titled fields are not equal, which is
+ * the rule the manual states: "Scripts cannot compare members of different
+ * enums ... even if the fields have identical names and titles." Unwrapping
+ * leaves those objects alone, and `==` then does exactly the right thing for
+ * both cases.
+ *
+ * `na` needs no special handling: it is NaN, and NaN equals nothing including
+ * itself, which is what Pine reports for a comparison involving `na`.
+ */
+/**
+ * TradingView treats two floats as equal when they differ by at most 1e-10
+ * (absolute, at any magnitude). Measured with Pine Logs; see
+ * dev-docs/tv-parity/ENGINE-BUGS.md section 5.
+ */
+export declare const FLOAT_TOLERANCE = 1e-10;
+export declare function safe_eq(a: any, b: any): boolean;
+export declare function safe_ne(a: any, b: any): boolean;
+/**
+ * Ordering comparisons share the equality tolerance: `a < b` is "less AND not
+ * equal", `a <= b` is "less OR equal". A NaN difference fails every test, so
+ * `na` stays false throughout, as before.
+ */
+export declare function safe_lt(a: any, b: any): boolean;
+export declare function safe_gt(a: any, b: any): boolean;
+export declare function safe_le(a: any, b: any): boolean;
+export declare function safe_ge(a: any, b: any): boolean;
+export declare function tostring(x: any): string;
+export declare function abs(x: any): number;
+export declare function acos(x: any): number;
+export declare function asin(x: any): number;
+export declare function atan(x: any): number;
+export declare function ceil(x: any): number;
+export declare function cos(x: any): number;
+export declare function exp(x: any): number;
+export declare function floor(x: any): number;
+export declare function log(x: any): number;
+export declare function log10(x: any): number;
+export declare function max(...args: any[]): number;
+export declare function min(...args: any[]): number;
+export declare function pow(x: any, y: any): number;
+/**
+ * `round(x)`, and from v5 `math.round(number, precision)`.
+ *
+ * Half rounds AWAY from zero, and `precision` rounds to that many decimals as
+ * the number is WRITTEN: TradingView's log gives math.round(-2.5) = -3 and
+ * math.round(1.005, 2) = 1.01 (conformance/v6/golden/harness_v6_language).
+ * JavaScript's Math.round gives -2, and 1.005 * 100 is 100.49999999999999 in
+ * binary, so both need doing here. Shifting by exponent notation —
+ * Number("1.005e2") is exactly 100.5 — moves the decimal point in the decimal
+ * representation instead of multiplying in binary.
+ */
+export declare function round(x: any, precision?: any): number;
+export declare function sign(x: any): number;
+export declare function sin(x: any): number;
+export declare function sqrt(x: any): number;
+export declare function tan(x: any): number;
+export declare function avg(...args: any[]): number;
+export declare const red = "#FF5252";
+export declare const green = "#4CAF50";
+export declare const blue = "#2196F3";
+export declare const orange = "#FF9800";
+export declare const teal = "#009688";
+export declare const navy = "#3F51B5";
+export declare const white = "#FFFFFF";
+export declare const black = "#000000";
+export declare const gray = "#9E9E9E";
+export declare const purple = "#9C27B0";
+export declare const yellow = "#FFEB3B";
+export declare const lime = "#CDDC39";
+export declare const aqua = "#00BCD4";
+export declare const fuchsia = "#E040FB";
+export declare const olive = "#808000";
+export declare const maroon = "#800000";
+export declare const silver = "#C0C0C0";
+/**
+ * `int(x)` — explicit cast from float to int.
+ *
+ * Pine v4 added "functions for explicit type casting" (June 2019) because it
+ * has no implicit float → integer conversion. The v4 manual's own example is
+ * the reason this matters:
+ *
+ *     len = 10.0
+ *     s = sma(close, int(len))
+ *
+ * without which `sma` rejects `const float` where it wants `integer`.
+ *
+ * Truncates toward zero rather than rounding — `int(-1.7)` is `-1`, not `-2` —
+ * and propagates `na`, since a cast cannot invent a value.
+ *
+ * Source: https://www.tradingview.com/pine-script-docs/v4/language/type-system/
+ *
+ * @returns {series int} `x` truncated toward zero, or na.
+ */
+export declare function int(x: any): number;
+/**
+ * `max_bars_back(var, num)` — request a deeper history buffer for one series.
+ *
+ * ── Deliberately a no-op ────────────────────────────────────────────────────
+ *
+ * On TradingView this raises the internal lookback buffer for `var`, and exists
+ * because that buffer is capped: a script that indexes further back than the
+ * engine guessed fails with "Pine cannot determine the referencing length of
+ * series".
+ *
+ * This engine has no such cap. Lookback depth is bounded by available memory,
+ * which is one of the limits skipped on purpose — see the "Deliberate
+ * deviations" section of docs/common/CONFORMANCE.md and the table that follows it.
+ * Every buffer is therefore already at least as large as any `max_bars_back`
+ * call could ask for, and honouring the request would mean SHRINKING history
+ * to match a restriction that is not being modelled.
+ *
+ * Accepting and ignoring it is what keeps scripts that call it runnable. The
+ * alternative — leaving the name unbound — is what made four of TradingView's
+ * own documentation examples die with a ReferenceError.
+ *
+ * @returns {void}
+ */
+export declare function max_bars_back(_series: any, _num: any): void;

package/dist/types/runtime/v1/stdlib/dataset.d.ts

@@ -0,0 +1,36 @@
+/**
+ * How far the dataset runs — `last_bar_index` and `last_bar_time`.
+ *
+ * Added in Pine v5 (December 2021). The release notes are explicit about the
+ * property that makes them useful:
+ *
+ *   "Added new built-in variables that return the bar_index and time values of
+ *    the last bar in the dataset. Their VALUES ARE KNOWN AT THE BEGINNING of
+ *    the script's calculation: last_bar_index - Bar index of the last chart
+ *    bar. last_bar_time - UNIX time of the last chart bar."
+ *
+ * That guarantee is the whole point. `bar_index == last_bar_index - 1` and
+ * `last_bar_index - bar_index <= 100` are how scripts find the right-hand edge
+ * of the chart, and both are meaningless if the answer only arrives on the last
+ * bar.
+ *
+ * The Context cannot derive it — it is fed one bar at a time — so the HOST
+ * declares it up front with `provideDatasetExtent`. See the note on that method
+ * for what happens when a host does not, and why the fallback is a documented
+ * divergence rather than a silent one.
+ *
+ * Source: https://www.tradingview.com/pine-script-docs/v5/release-notes/
+ */
+import { Context } from "../context.js";
+/**
+ * Bar index of the last bar in the dataset.
+ * @getter
+ * @returns {integer} The last bar's index, known from the first bar.
+ */
+export declare function last_bar_index(ctx: Context): number;
+/**
+ * UNIX time of the last bar in the dataset, in milliseconds.
+ * @getter
+ * @returns {integer} The last bar's opening time, known from the first bar.
+ */
+export declare function last_bar_time(ctx: Context): number;

package/dist/types/runtime/v1/stdlib/display.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `display.*` — where a plot's values are shown.
+ *
+ * "controls the locations where plot values appear, which include the script
+ *  pane, status line, price scale, and Data Window. The default is
+ *  display.all."
+ *
+ * ── Why these are powers of two ─────────────────────────────────────────────
+ *
+ * Because the manual says the constants compose with ARITHMETIC:
+ *
+ *   "supports addition and subtraction of display.* options, e.g.,
+ *    display.all - display.pane hides the pane visuals but displays the plot's
+ *    numeric results everywhere else, while
+ *    display.status_line + display.data_window displays results only in those
+ *    two locations."
+ *
+ * A set of disjoint bits is the only encoding under which both of those work
+ * with the ordinary `+` and `-` a script writes: `all - pane` clears exactly
+ * one location, and `status_line + data_window` names exactly two. Sequential
+ * integers (1, 2, 3, 4) would make `all - pane` land on some other location
+ * entirely, silently.
+ *
+ * `all` is therefore the sum of the four, not a magic number.
+ *
+ * ── What this engine does with them ─────────────────────────────────────────
+ *
+ * Carries them. There is no pane, status line, price scale or Data Window
+ * here, so `display` changes nothing about the values a plot produces — which
+ * is the whole of what this engine computes. A script that hides a plot with
+ * `display.none` still gets its series in the output, and that is a difference
+ * in presentation rather than in arithmetic.
+ *
+ * v5-only: the registry split in ./index.ts keeps the namespace out of the
+ * v1–v4 views.
+ */
+export declare const display: {
+    /** Shown nowhere. The plot is still calculated. */
+    none: number;
+    /** The Data Window. */
+    data_window: number;
+    /** The script's pane — the visible line, histogram or shape. */
+    pane: number;
+    /** The price scale on the right-hand edge. */
+    price_scale: number;
+    /** The status line above the chart. */
+    status_line: number;
+    /** Every location at once — the default. The sum of the four above. */
+    all: number;
+};

package/dist/types/runtime/v1/stdlib/drawings.d.ts

@@ -0,0 +1,407 @@
+/**
+ * Pine Script drawing objects — `line`, `label`, `box`, `table`.
+ *
+ * `line` and `label` arrived June 2019, `box` and `table` in May 2021, all
+ * under v4 (see the v4 release notes). The registry split in ./index.ts keeps
+ * the whole set out of the v1–v3 view, so a v3 script naming `label.new` is
+ * refused there rather than by a check here.
+ *
+ * ── WHAT THIS DOES AND DOES NOT DO ──────────────────────────────────────────
+ *
+ * A drawing is recorded on the Context with an id and its properties, and the
+ * setters mutate that record. It is NOT rendered, and it does not participate
+ * in `plots` — a drawing is an object with a lifetime, not a per-bar value, and
+ * TradingView's exported chart data does not contain drawings either. So
+ * nothing here can affect the golden-parity numbers.
+ *
+ * The point is that a script which draws RUNS. A large fraction of published v4
+ * indicators label their signals, and before this they died on the first
+ * `label.new` — which said nothing about whether their arithmetic was right.
+ *
+ * Getters return what was set. `line.get_price(id, x)` is the one that computes
+ * rather than recalls, because it is the only one a script reads back into its
+ * own maths.
+ */
+import { Context } from "../context.js";
+export declare const line: {
+    /**
+     * `line.new(x1, y1, x2, y2, …)` and `line.new(first_point, second_point, …)`
+     * — see the note above `isChartPoint` for how the two are told apart, and
+     * why nothing here carries a parameter default.
+     */
+    new: (ctx: Context, x1: any, y1: any, x2: any, y2: any, xloc?: any, extend?: any, color?: any, style?: any, width?: any) => string;
+    set_x1: (ctx: Context, id: any, x: any) => void;
+    set_y1: (ctx: Context, id: any, y: any) => void;
+    set_x2: (ctx: Context, id: any, x: any) => void;
+    set_y2: (ctx: Context, id: any, y: any) => void;
+    set_width: (ctx: Context, id: any, width: any) => void;
+    /**
+     * `line.set_xloc(id, x1, x2, xloc)` — both x coordinates AND what they
+     * mean, in one call, because changing `xloc` alone would reinterpret bar
+     * indices as timestamps or the reverse.
+     *
+     * This took `(id, xloc)`, so the documented four-argument call put `x1`
+     * into `xloc` and left the line where it was. TradingView's log settles
+     * it — conformance/common/v5_gaps_golden.test.ts — and the signature is the
+     * same at every version that has lines.
+     */
+    set_xloc: (ctx: Context, id: any, x1: any, x2: any, xloc: any) => void;
+    set_extend: (ctx: Context, id: any, extend: any) => void;
+    set_color: (ctx: Context, id: any, color: any) => void;
+    set_style: (ctx: Context, id: any, style: any) => void;
+    get_x1: (ctx: Context, id: any) => any;
+    get_y1: (ctx: Context, id: any) => any;
+    get_x2: (ctx: Context, id: any) => any;
+    get_y2: (ctx: Context, id: any) => any;
+    /** Both endpoints at once — one call in Pine, so one call here. */
+    set_xy1: (ctx: Context, id: any, x: any, y: any) => void;
+    set_xy2: (ctx: Context, id: any, x: any, y: any) => void;
+    /**
+     * `line.set_first_point(id, point)` / `set_second_point` — the `chart.point`
+     * spellings of `set_xy1` / `set_xy2`, October 2023.
+     *
+     * A point carries BOTH x coordinates, and which one applies is the line's
+     * own `xloc` — so the drawing decides, not the point. That is the whole
+     * reason these exist beside the xy pair: a script that works in
+     * `chart.point`s should not have to unpack one to move a line.
+     */
+    set_first_point: (ctx: Context, id: any, point: any) => void;
+    set_second_point: (ctx: Context, id: any, point: any) => void;
+    /**
+     * The price the line takes at bar `x`, by linear interpolation through its
+     * two endpoints — extrapolated beyond them, which is what makes the
+     * trendline-projection idiom work.
+     *
+     * Vertical lines have no single price, so they are `na` rather than ±∞.
+     */
+    get_price: (ctx: Context, id: any, x: any) => any;
+    delete: (ctx: Context, id: any) => void;
+    /**
+     * `line.all` — every live line, oldest first.
+     *
+     * A Pine ARRAY, so `array.size(line.all)` and `line.all.size()` both work, and
+     * so does iterating it to delete the oldest. `polyline.all` and
+     * `linefill.all` are the same thing; these three were simply missing, and a
+     * missing member of a real namespace read as `undefined` — which made
+     * `array.size(label.all)` a call on nothing.
+     *
+     * @getter
+     */
+    all: (ctx: Context) => string[];
+    copy: (ctx: Context, id: any) => string;
+    style_solid: string;
+    style_dotted: string;
+    style_dashed: string;
+    style_arrow_left: string;
+    style_arrow_right: string;
+    style_arrow_both: string;
+};
+export declare const label: {
+    /**
+     * `label.new(x, y, text, …)` and `label.new(point, text, …)`.
+     *
+     * The point form replaces ONE coordinate pair with one point, so the tail
+     * shifts by one rather than two. `text_font_family` is v5: three of
+     * TradingView's own examples pass it — `label.new(…, text_font_family =
+     * font.family_monospace)` — and an argument the signature does not name is
+     * dropped without a word, so a monospaced label came out proportional and
+     * nothing said so.
+     */
+    new: (ctx: Context, x: any, y: any, text?: any, xloc?: any, yloc?: any, color?: any, style?: any, textcolor?: any, size?: any, textalign?: any, tooltip?: any, text_font_family?: any, force_overlay?: any, text_formatting?: any) => string;
+    set_x: (ctx: Context, id: any, x: any) => void;
+    set_y: (ctx: Context, id: any, y: any) => void;
+    set_text: (ctx: Context, id: any, text: any) => void;
+    /**
+     * `label.set_xloc(id, x, xloc)` — the reference's signature. The same
+     * defect `line.set_xloc` had: this took `(id, xloc)`. Fixed from the
+     * reference rather than from a log, as the line's twin.
+     */
+    set_xloc: (ctx: Context, id: any, x: any, xloc: any) => void;
+    set_yloc: (ctx: Context, id: any, yloc: any) => void;
+    set_color: (ctx: Context, id: any, color: any) => void;
+    set_style: (ctx: Context, id: any, style: any) => void;
+    set_textcolor: (ctx: Context, id: any, textcolor: any) => void;
+    set_size: (ctx: Context, id: any, size: any) => void;
+    /** v6. See `formatting` above for the value. */
+    set_text_font_family: (ctx: Context, id: any, text_font_family: any) => void;
+    set_text_formatting: (ctx: Context, id: any, text_formatting: any) => void;
+    set_textalign: (ctx: Context, id: any, textalign: any) => void;
+    set_tooltip: (ctx: Context, id: any, tooltip: any) => void;
+    get_x: (ctx: Context, id: any) => any;
+    get_y: (ctx: Context, id: any) => any;
+    get_text: (ctx: Context, id: any) => any;
+    /** `label.set_point(id, point)` — `set_xy` from a `chart.point`. */
+    set_point: (ctx: Context, id: any, point: any) => void;
+    set_xy: (ctx: Context, id: any, x: any, y: any) => void;
+    delete: (ctx: Context, id: any) => void;
+    /**
+     * `label.all` — every live label, oldest first.
+     *
+     * A Pine ARRAY, so `array.size(label.all)` and `label.all.size()` both work, and
+     * so does iterating it to delete the oldest. `polyline.all` and
+     * `linefill.all` are the same thing; these three were simply missing, and a
+     * missing member of a real namespace read as `undefined` — which made
+     * `array.size(label.all)` a call on nothing.
+     *
+     * @getter
+     */
+    all: (ctx: Context) => string[];
+    copy: (ctx: Context, id: any) => string;
+    style_none: string;
+    style_xcross: string;
+    style_cross: string;
+    style_triangleup: string;
+    style_triangledown: string;
+    style_flag: string;
+    style_circle: string;
+    style_arrowup: string;
+    style_arrowdown: string;
+    style_label_up: string;
+    style_label_down: string;
+    style_label_left: string;
+    style_label_right: string;
+    style_label_lower_left: string;
+    style_label_lower_right: string;
+    style_label_upper_left: string;
+    style_label_upper_right: string;
+    style_label_center: string;
+    /** Text drawn with an outline and no bubble — v5, 2024. */
+    style_text_outline: string;
+    style_square: string;
+    style_diamond: string;
+};
+export declare const box: {
+    /**
+     * `box.new(left, top, right, bottom, …)` and
+     * `box.new(top_left, bottom_right, …)`.
+     *
+     * A box's corners are (left, top) and (right, bottom), so `top_left`
+     * supplies left/top and `bottom_right` supplies right/bottom.
+     *
+     * `xloc` decides whether `left`/`right` are BAR INDICES or TIMES, and it
+     * sits between `extend` and `bgcolor` in the published signature. It was
+     * absent, so `box.new(…, xloc = xloc.bar_time)` had its coordinates read as
+     * bar indices — a box drawn at bar 1,700,000,000.
+     *
+     * The text defaults are the manual's: "size.auto (default)", "Its default
+     * is color.black", "text.align_center (default)" for both alignments, "The
+     * default is text.wrap_none", and `font.family_default`. Spelled as the
+     * VALUES those constants carry, so a script that passes the constant and a
+     * script that leaves it out record the same thing.
+     */
+    new: (ctx: Context, left: any, top: any, right: any, bottom: any, border_color?: any, border_width?: any, border_style?: any, extend?: any, xloc?: any, bgcolor?: any, text?: any, text_size?: any, text_color?: any, text_halign?: any, text_valign?: any, text_wrap?: any, text_font_family?: any, force_overlay?: any, text_formatting?: any) => string;
+    set_left: (ctx: Context, id: any, left: any) => void;
+    set_top: (ctx: Context, id: any, top: any) => void;
+    set_right: (ctx: Context, id: any, right: any) => void;
+    set_bottom: (ctx: Context, id: any, bottom: any) => void;
+    set_border_width: (ctx: Context, id: any, width: any) => void;
+    set_border_color: (ctx: Context, id: any, color: any) => void;
+    set_border_style: (ctx: Context, id: any, style: any) => void;
+    set_extend: (ctx: Context, id: any, extend: any) => void;
+    set_bgcolor: (ctx: Context, id: any, bgcolor: any) => void;
+    /**
+     * v6, March 2025: "Sets the left and right border coordinates of a box
+     * and whether they are bar indices or UNIX timestamps. It works like the
+     * set_xloc() functions for lines and labels" — so the shape TradingView
+     * documents for `line.set_xloc`, `(id, x1, x2, xloc)`, with a box's
+     * horizontal coordinates being `left` and `right`.
+     *
+     */
+    set_xloc: (ctx: Context, id: any, left: any, right: any, xloc: any) => void;
+    /**
+     * A box holds TEXT, and the seven setters that write it.
+     *
+     * "box.set_text(), box.set_text_size(), box.set_text_color(),
+     *  box.set_text_halign(), box.set_text_valign(), box.set_text_wrap(), and
+     *  box.set_text_font_family() update the id box's text-related properties",
+     * and `box.new` takes the same seven as `text, text_size, text_color,
+     * text_halign, text_valign, text_wrap, text_font_family`.
+     *
+     * The whole family was missing, so `myBox.set_text(…)` — which
+     * TradingView's own lines-and-boxes example calls — died with "'box' has no
+     * method 'set_text'".
+     */
+    set_text: (ctx: Context, id: any, text: any) => void;
+    set_text_size: (ctx: Context, id: any, text_size: any) => void;
+    /** v6. */
+    set_text_formatting: (ctx: Context, id: any, text_formatting: any) => void;
+    set_text_color: (ctx: Context, id: any, text_color: any) => void;
+    set_text_halign: (ctx: Context, id: any, text_halign: any) => void;
+    set_text_valign: (ctx: Context, id: any, text_valign: any) => void;
+    set_text_wrap: (ctx: Context, id: any, text_wrap: any) => void;
+    set_text_font_family: (ctx: Context, id: any, text_font_family: any) => void;
+    get_left: (ctx: Context, id: any) => any;
+    get_top: (ctx: Context, id: any) => any;
+    get_right: (ctx: Context, id: any) => any;
+    get_bottom: (ctx: Context, id: any) => any;
+    set_lefttop: (ctx: Context, id: any, left: any, top: any) => void;
+    /** The `chart.point` spellings of the two corner setters. */
+    set_top_left_point: (ctx: Context, id: any, point: any) => void;
+    set_bottom_right_point: (ctx: Context, id: any, point: any) => void;
+    set_rightbottom: (ctx: Context, id: any, right: any, bottom: any) => void;
+    delete: (ctx: Context, id: any) => void;
+    /**
+     * `box.all` — every live box, oldest first.
+     *
+     * A Pine ARRAY, so `array.size(box.all)` and `box.all.size()` both work, and
+     * so does iterating it to delete the oldest. `polyline.all` and
+     * `linefill.all` are the same thing; these three were simply missing, and a
+     * missing member of a real namespace read as `undefined` — which made
+     * `array.size(label.all)` a call on nothing.
+     *
+     * @getter
+     */
+    all: (ctx: Context) => string[];
+    copy: (ctx: Context, id: any) => string;
+    style_solid: string;
+    style_dotted: string;
+    style_dashed: string;
+};
+export declare const table: {
+    new: (ctx: Context, position: any, columns: any, rows: any, bgcolor?: any, frame_color?: any, frame_width?: any, border_color?: any, border_width?: any) => string;
+    cell: (ctx: Context, table_id: any, column: any, row: any, text?: any, width?: any, height?: any, text_color?: any, text_halign?: any, text_valign?: any, text_size?: any, bgcolor?: any, tooltip?: any, text_font_family?: any, text_formatting?: any) => void;
+    /**
+     * `table.cell_set_*` — change ONE property of an existing cell.
+     *
+     * The prefix is `cell_set_`, not `set_cell_`. The distinction is the
+     * table's own naming rule: `table.set_*` changes the TABLE (`set_position`,
+     * `set_bgcolor`) and `table.cell_set_*` changes a CELL. Eight of
+     * TradingView's own examples call `table.cell_set_text`, and the misspelled
+     * `set_cell_text` this engine had was reachable by nothing.
+     *
+     * A cell that has not been written yet is created empty rather than
+     * ignored, which is what lets a script lay out a table with `table.cell`
+     * and then update one field of it per bar.
+     */
+    /**
+     * The typeface and the tooltip of one cell.
+     *
+     * `table.cell_set_text_font_family` is not on the manual's Tables page, and
+     * TradingView's `v5-concepts-time-20` calls it anyway —
+     * `displayTable.cell_set_text_font_family(colID, rowID, font.family_monospace)`
+     * — which is the same standard of evidence the `fixnan` and `transp=`
+     * decisions rest on: a published example is the language.
+     */
+    cell_set_text_font_family: (ctx: Context, table_id: any, column: any, row: any, family: any) => void;
+    cell_set_tooltip: (ctx: Context, table_id: any, column: any, row: any, tooltip: any) => void;
+    cell_set_text: (ctx: Context, table_id: any, column: any, row: any, text: any) => void;
+    cell_set_bgcolor: (ctx: Context, table_id: any, column: any, row: any, bgcolor: any) => void;
+    cell_set_text_color: (ctx: Context, table_id: any, column: any, row: any, text_color: any) => void;
+    cell_set_text_size: (ctx: Context, table_id: any, column: any, row: any, text_size: any) => void;
+    cell_set_text_halign: (ctx: Context, table_id: any, column: any, row: any, text_halign: any) => void;
+    cell_set_text_valign: (ctx: Context, table_id: any, column: any, row: any, text_valign: any) => void;
+    /** v6. */
+    cell_set_text_formatting: (ctx: Context, table_id: any, column: any, row: any, text_formatting: any) => void;
+    cell_set_width: (ctx: Context, table_id: any, column: any, row: any, width: any) => void;
+    cell_set_height: (ctx: Context, table_id: any, column: any, row: any, height: any) => void;
+    /**
+     * `table.merge_cells(table_id, start_column, start_row, end_column, end_row)`.
+     *
+     * Recorded rather than rendered: nothing here draws a table, so a merge is
+     * a fact about the cell range that a host renderer would honour. The
+     * top-left cell of the range carries it, which is where its text lives.
+     */
+    merge_cells: (ctx: Context, table_id: any, start_column: any, start_row: any, end_column: any, end_row: any) => void;
+    set_position: (ctx: Context, id: any, position: any) => void;
+    set_bgcolor: (ctx: Context, id: any, bgcolor: any) => void;
+    set_border_color: (ctx: Context, id: any, border_color: any) => void;
+    set_border_width: (ctx: Context, id: any, border_width: any) => void;
+    set_frame_color: (ctx: Context, id: any, frame_color: any) => void;
+    set_frame_width: (ctx: Context, id: any, frame_width: any) => void;
+    /** Every table the script has made and not deleted, oldest first. @getter */
+    all: (ctx: Context) => string[];
+    clear: (ctx: Context, id: any) => void;
+    delete: (ctx: Context, id: any) => void;
+};
+/** `xloc` — whether an x coordinate is a bar index or a UNIX time. */
+export declare const xloc: {
+    bar_index: string;
+    bar_time: string;
+};
+/** `yloc` — whether a y coordinate is a price or is pinned to the bar. */
+export declare const yloc: {
+    price: string;
+    abovebar: string;
+    belowbar: string;
+};
+/** `extend` — how far a line or box runs past its endpoints. */
+export declare const extend: {
+    none: string;
+    right: string;
+    left: string;
+    both: string;
+};
+/** `position` — where a table sits on the chart. */
+export declare const position: {
+    top_left: string;
+    top_center: string;
+    top_right: string;
+    middle_left: string;
+    middle_center: string;
+    middle_right: string;
+    bottom_left: string;
+    bottom_center: string;
+    bottom_right: string;
+};
+/** `text.align_*` — v4 spells these on the `text` namespace. */
+export declare const text: {
+    align_left: string;
+    align_center: string;
+    align_right: string;
+    align_top: string;
+    align_bottom: string;
+    /**
+     * `text.wrap_*` — a BOX's text wrapping, and v5 only.
+     *
+     * "If its value is text.wrap_auto, the box wraps the text to ensure it does
+     *  not span past its vertical borders. It also clips the wrapped text when
+     *  it extends past the bottom. If the value is text.wrap_none, the box
+     *  displays the text on a single line that can extend beyond its borders.
+     *  The default is text.wrap_none."
+     *
+     * Gated by name in V5_ONLY_NAMES: `text` itself is a v4 namespace, and box
+     * text arrived long after it.
+     */
+    wrap_auto: string;
+    wrap_none: string;
+    /**
+     * `text.format_*` — v6 (November 2024): "whether displayed text is bold,
+     * italic, or both". Both is the SUM of the two, which is why these are bit
+     * flags rather than names: `text.format_bold + text.format_italic` is how a
+     * script asks for it, and 1 + 2 = 3 is unambiguous where "bold" + "italic"
+     * would not be. Gated by name in V6_ONLY_NAMES.
+     */
+    format_none: number;
+    format_bold: number;
+    format_italic: number;
+};
+export declare const polyline: {
+    new: (ctx: Context, points: any, curved?: any, closed?: any, xloc?: any, line_color?: any, fill_color?: any, line_style?: any, line_width?: any, force_overlay?: any) => string;
+    delete: (ctx: Context, id: any) => void;
+    /**
+     * Every polyline currently on the chart, oldest first.
+     * @getter
+     */
+    all: (ctx: Context) => string[];
+};
+export declare const linefill: {
+    /**
+     * A linefill on an `na` line is `na` and creates nothing.
+     *
+     * Logged on TradingView with `line nl = na; linefill.new(nl, nl, color.red)`:
+     * `linefill.all.size()` is 0 before and after
+     * (conformance/v5/parity/probe_drawing_limits.BTCUSDT.5.csv, `LF|0|0`).
+     * The case where only ONE line is `na` was not logged; it is INFERRED from
+     * that, since a fill is the space between two lines and has none with one.
+     */
+    new: (ctx: Context, line1: any, line2: any, color: any) => string | number;
+    set_color: (ctx: Context, id: any, color: any) => void;
+    get_line1: (ctx: Context, id: any) => any;
+    get_line2: (ctx: Context, id: any) => any;
+    delete: (ctx: Context, id: any) => void;
+    /**
+     * Every linefill currently on the chart, oldest first.
+     * @getter
+     */
+    all: (ctx: Context) => string[];
+};

package/dist/types/runtime/v1/stdlib/errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The `runtime.*` namespace — v5's script-authored failure path.
+ *
+ * One member: `runtime.error(message)`, which halts the script with the
+ * author's own message. It exists so a script can refuse to produce numbers it
+ * knows are wrong — the same stance this engine takes everywhere else — rather
+ * than plotting `na` and leaving the reader to guess why.
+ */
+import { Context } from "../context.js";
+/**
+ * Thrown by `runtime.error`. A distinct class so a host can tell an intentional
+ * script-level halt from an engine defect: the first is the script working as
+ * written, the second is a bug here.
+ */
+export declare class PineRuntimeError extends Error {
+    readonly bar: number;
+    constructor(message: string, bar: number);
+}
+export declare const runtime: {
+    error: (ctx: Context, message: any) => never;
+};