openpinescript 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,133 @@
+import type { Context } from "../context.js";
+export declare const array: {
+    new_float: (size?: any, initial_value?: any) => any[];
+    new_int: (size?: any, initial_value?: any) => any[];
+    new_bool: (size?: any, initial_value?: any) => any[];
+    new_string: (size?: any, initial_value?: any) => any[];
+    new_color: (size?: any, initial_value?: any) => any[];
+    new_line: (size?: any, initial_value?: any) => any[];
+    new_linefill: (size?: any, initial_value?: any) => any[];
+    /**
+     * The value `percentage` percent of the array's values are at or below,
+     * by nearest rank: `ceil(P/100 * N)` over the ascending values, so the
+     * answer is always one of them. The rule `ta.percentile_nearest_rank`
+     * applies to a window. `na` values are left out.
+     */
+    percentile_nearest_rank: (id: any, percentage: any) => number;
+    /**
+     * The same percentile, interpolating linearly between the two values that
+     * straddle it — the rule `ta.percentile_linear_interpolation` applies.
+     */
+    percentile_linear_interpolation: (id: any, percentage: any) => number;
+    new_label: (size?: any, initial_value?: any) => any[];
+    new_box: (size?: any, initial_value?: any) => any[];
+    new_table: (size?: any, initial_value?: any) => any[];
+    /** `array.from(v1, v2, …)` — build an array from its arguments. */
+    from: (...items: any[]) => any[];
+    get: (ctx: Context, id: any, index: any) => any;
+    set: (ctx: Context, id: any, index: any, value: any) => void;
+    size: (id: any) => number;
+    /**
+     * `array.first(id)` and `array.last(id)` — January 2023.
+     *
+     * "Returns the array's first element" / "Returns the array's last element."
+     *
+     * An EMPTY array is an error rather than `na`, which is the same rule
+     * `array.get` follows for an out-of-range index: the two are the same
+     * mistake, and answering `na` would let a script average nothing and plot
+     * it.
+     */
+    first: (id: any) => any;
+    last: (id: any) => any;
+    /**
+     * `array.binary_search(id, val)` — the index of `val`, or -1.
+     *
+     * Requires the array to be sorted ASCENDING, which is the contract of every
+     * binary search and is why the three `binary_search*` functions exist
+     * alongside `array.indexof`: on a sorted array they are the fast answer, and
+     * on an unsorted one they are a wrong one. This engine does not verify the
+     * ordering — checking it would cost the very thing the function is for.
+     */
+    binary_search: (ctx: Context, id: any, value: any, sort_field?: any) => number;
+    push: (id: any, value: any) => void;
+    pop: (id: any) => any;
+    shift: (id: any) => any;
+    unshift: (id: any, value: any) => void;
+    insert: (ctx: Context, id: any, index: any, value: any) => void;
+    remove: (ctx: Context, id: any, index: any) => any;
+    clear: (id: any) => void;
+    /**
+     * Fills a contiguous range, and RETURNS THE ARRAY.
+     *
+     * The reference gives `array.fill(id, value, index_from, index_to) → void`,
+     * and the manual's Methods page gives this example
+     *
+     *     srcArray.copy().fill(1.0, 0.0, min, val).avg()
+     *
+     * with the explanation: "We are able to call `copy()`, `fill()`, and
+     * `avg()` successively on the same line of code because the first two
+     * methods return an `array<float>` instance."
+     *
+     * The two statements disagree. The example is the one a script can depend
+     * on — it is TradingView's own published code, and returning the receiver
+     * is a strict superset of returning nothing: a caller that ignores the
+     * result cannot tell the difference. So the receiver is returned, and the
+     * conflict is recorded here rather than resolved silently.
+     */
+    fill: (id: any, value: any, index_from?: any, index_to?: any) => any[];
+    copy: (id: any) => any[];
+    slice: (id: any, index_from: any, index_to: any) => any[];
+    concat: (id1: any, id2: any) => any[];
+    reverse: (id: any) => void;
+    /**
+     * `array.sort_indices(id, order, sort_field)` — the indices that WOULD
+     * sort the array, which is left as it is. v6 (April 2026) adds
+     * `sort_field` for arrays of objects.
+     *
+     * TradingView's log (conformance/common/v5_gaps_golden.test.ts) settles the
+     * two things the reference leaves open: ascending is a STABLE sort with
+     * `na` last, and descending is exactly that order REVERSED — so `na` comes
+     * first, and equal values come out in reverse index order.
+     */
+    sort_indices: (ctx: Context, id: any, order?: any, sort_field?: any) => number[];
+    sort: (ctx: Context, id: any, order?: any, sort_field?: any) => void;
+    /**
+     * `binary_search_leftmost` / `_rightmost`. v6 (August 2026) adds
+     * `sort_field` for arrays of objects.
+     *
+     * From the reference: the index of the value when it is found; otherwise
+     * leftmost gives "the index of the next smallest element to the left of
+     * where the value would lie", rightmost the element to its right. With
+     * duplicates, each returns the occurrence its name says — and below the
+     * whole array leftmost answers 0, not -1. Both pinned by TradingView's log.
+     */
+    binary_search_leftmost: (ctx: Context, id: any, value: any, sort_field?: any) => number;
+    binary_search_rightmost: (ctx: Context, id: any, value: any, sort_field?: any) => number;
+    includes: (id: any, value: any) => boolean;
+    indexof: (id: any, value: any) => number;
+    lastindexof: (id: any, value: any) => number;
+    sum: (id: any) => number;
+    avg: (id: any) => number;
+    min: (id: any) => number;
+    max: (id: any) => number;
+    range: (id: any) => number;
+    median: (id: any) => number;
+    mode: (id: any) => number;
+    /** Sample variance (n-1), matching `variance()` elsewhere in the stdlib. */
+    variance: (id: any) => number;
+    stdev: (id: any) => number;
+    covariance: (id1: any, id2: any) => number;
+    /** `array.join(id, separator)` — v4 spells the default separator as ",". */
+    join: (id: any, separator?: any) => string;
+};
+/**
+ * `array.sort`'s direction argument.
+ *
+ * A namespace of its own in Pine rather than a string, which is why the tests
+ * spell `order.descending` and not `"desc"`. `array.sort` accepts either, since
+ * it only asks whether the value contains "desc".
+ */
+export declare const order: {
+    ascending: string;
+    descending: string;
+};

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

@@ -0,0 +1,27 @@
+/**
+ * barmerge.* — how security() aligns higher-timeframe data onto chart bars.
+ *
+ * The `lookahead` argument is security()'s fifth parameter. Its DEFAULT changed
+ * between versions and that change is observable in the numbers:
+ *
+ *   v1/v2 → barmerge.lookahead_on   (the historical default)
+ *   v3+   → barmerge.lookahead_off  (flipped by the v2→v3 migration)
+ *
+ * See docs/common/VERSIONS.md §2 D3.1.
+ */
+export declare const __IS_NAMESPACE__ = true;
+/**
+ * Use data from the HTF bar the current chart bar falls INSIDE, including the
+ * part that has not happened yet. On historical bars this reveals a value
+ * before it could have been known — the classic repainting behaviour.
+ */
+export declare const lookahead_on = "barmerge.lookahead_on";
+/**
+ * Use only HTF bars that have already CLOSED. No future information, so
+ * historical results match what the script would have seen live.
+ */
+export declare const lookahead_off = "barmerge.lookahead_off";
+/** Fill gaps with the previous available value (default). */
+export declare const gaps_off = "barmerge.gaps_off";
+/** Leave gaps as na. */
+export declare const gaps_on = "barmerge.gaps_on";

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

@@ -0,0 +1,79 @@
+import { Context } from "../context.js";
+export declare const __IS_NAMESPACE__ = true;
+/**
+ * Returns true if the current bar is a historical bar.
+ * @getter
+ */
+export declare function ishistory(ctx: Context): boolean;
+/**
+ * Returns true if the current bar is a real-time bar.
+ * @getter
+ */
+export declare function isrealtime(ctx: Context): boolean;
+/**
+ * Returns true if this is the first execution on the current bar.
+ * @getter
+ */
+export declare function isnew(ctx: Context): boolean;
+/**
+ * Returns true if this is the last historically available bar.
+ * @getter
+ */
+export declare function islast(ctx: Context): boolean;
+/**
+ * Returns true on the script's FIRST bar.
+ *
+ * Derived from the bar counter rather than stored as a flag, so it cannot fall
+ * out of step with `bar_index` — they are the same fact.
+ *
+ * Present in Pine since v1 and absent here until v5 needed it: every harness
+ * generated by scripts/common/make-log-harness.ts writes its CSV header under
+ * `if barstate.isfirst`, and a missing member of an EXISTING namespace reads as
+ * `undefined` rather than erroring (the namespace-root check in the emitter
+ * deliberately does not assert registry completeness), so the header was
+ * silently never emitted.
+ *
+ * @getter
+ */
+export declare function isfirst(ctx: Context): boolean;
+/**
+ * True on every historical bar, and on a realtime bar's CLOSING update.
+ *
+ * "barstate.isconfirmed is true on all historical bars and on the last
+ *  (closing) update of a realtime bar."
+ *
+ * The bar's values will not change again once this is true, which is why it is
+ * the standard guard around anything a script must do once per bar — an alert,
+ * a log line, a queue push. Eighteen of TradingView's own examples use it, and
+ * every one of them was reading `undefined`: a missing member of an EXISTING
+ * namespace does not error, so `if barstate.isconfirmed` was silently never
+ * taken and the scripts drew nothing.
+ *
+ * TradingView runs the script ONE MORE time on a realtime bar when it closes
+ * (a rollback re-execution like a tick, on the bar's final OHLCV, with
+ * `isnew` false) and `isconfirmed` is true only there. `Session.commit` does
+ * that execution and sets `Context.is_confirmed` for it. Verified:
+ * dev-docs/tv-parity/_probes/realtime/rt-confirmed-v6/run-20261113-042353 and
+ * rt-confirmed-v5/run-20261113-043223. History is always confirmed.
+ *
+ * @getter
+ */
+export declare function isconfirmed(ctx: Context): boolean;
+/**
+ * True on the last bar the script can treat as settled history.
+ *
+ * "barstate.islastconfirmedhistory is true if the script is executing on the
+ *  dataset's last bar when the market is closed, or on the bar immediately
+ *  preceding the realtime bar if the market is open."
+ *
+ * Two readings of one idea, and which applies depends on whether a realtime bar
+ * exists at all. With no realtime bar the last bar IS the last confirmed one;
+ * with one, the bar before it is.
+ *
+ * The commonest guard in TradingView's documentation — twenty-nine examples
+ * draw their tables and labels under it, because it fires exactly once and on
+ * the rightmost settled bar.
+ *
+ * @getter
+ */
+export declare function islastconfirmedhistory(ctx: Context): boolean;

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

@@ -0,0 +1,81 @@
+/**
+ * Explicit type-casting functions — v4's `float(x)`, `bool(x)`, `string(x)`.
+ *
+ * SOURCING. The v4 release notes, June 2019, list "functions for explicit type
+ * casting" among that version's additions, and the manual's type-system page
+ * says why they exist: "It's sometimes necessary to cast one type to another
+ * when auto-casting rules do not suffice." It names ten of them — `int()`,
+ * `float()`, `bool()`, `color()`, `string()`, `line()`, `linefill()`,
+ * `label()`, `box()` and `table()` — and gives their second job:
+ *
+ *   "Explicit type casting is also handy when declaring variables assigned to
+ *    na", with `label myLabel = na` and `myLabel = label(na)` shown as the two
+ *   spellings of one thing.
+ *
+ * `float(na)` is by far the common case in TradingView's own examples: it is
+ * how a script says "an absent FLOAT" where the bare `na` would be untyped.
+ *
+ * ── Why this file is a NAMESPACE that nothing can spell ─────────────────────
+ *
+ * `int()` and `color()` are plain flat exports elsewhere, because nothing else
+ * in the language is called `int` or `color`. These three are: `float`, `bool`
+ * and `string` are ALSO the v1–v3 `input()` type constants —
+ * `input(1.0, type = float)` — which v4 renamed to `input.float`. One flat
+ * registry key cannot be a string at v1 and a function at v4.
+ *
+ * So they are generated under `cast.*`, which no script may write, and
+ * runtime/v1/stdlib/index.ts installs them under their flat names in v4's view
+ * ONLY. v1–v3 keep the constant; v4 and v5 get the cast; neither version can
+ * see the other's meaning. The same device that lets `session` be a v1–v3
+ * string and a v5 namespace at once.
+ *
+ * `int` is deliberately NOT here — it has no collision, it is already a flat
+ * v4-only export in ./core.ts, and moving it would change a working name for
+ * symmetry's sake.
+ */
+export declare const __IS_NAMESPACE__ = true;
+/**
+ * `float(x)` — the value as a float.
+ *
+ * `na` in, `na` out: a cast changes how a value is READ, and cannot invent one.
+ * That is what makes `float(na)` the typed absent value rather than a zero.
+ *
+ * @returns {series float} `x` as a float, or na.
+ */
+export declare function float(x: any): number;
+/**
+ * `bool(x)` — the value as a boolean.
+ *
+ * Pine's truthiness, not JavaScript's: `na` is not `false`, it stays `na`, and
+ * a script that tests `if bool(x)` on an absent value must take neither branch
+ * rather than the else. Zero IS false, and every other finite number true —
+ * which is the whole reason the manual's example exists:
+ *
+ *     if bool(randomValue)
+ *
+ * "does not raise a warning, as the `bool()` function explicitly casts".
+ *
+ * @returns {series bool} `x` as a boolean, or na.
+ */
+export declare function bool(x: any): boolean | number;
+/**
+ * `string(x)` — the value as a string.
+ *
+ * NOT `str.tostring`. That one FORMATS — it takes a format mask, renders a
+ * float to a fixed number of decimals, and turns `na` into the four characters
+ * "NaN" so a label can display them. This is a cast: it reinterprets a value
+ * that is already a string, and propagates `na` rather than spelling it out.
+ *
+ * @returns {series string} `x` as a string, or na.
+ */
+export declare function string(x: any): string | number;
+/** @returns {series line} `x` as a line id, or na. */
+export declare function line(x: any): any;
+/** @returns {series linefill} `x` as a linefill id, or na. */
+export declare function linefill(x: any): any;
+/** @returns {series label} `x` as a label id, or na. */
+export declare function label(x: any): any;
+/** @returns {series box} `x` as a box id, or na. */
+export declare function box(x: any): any;
+/** @returns {series table} `x` as a table id, or na. */
+export declare function table(x: any): any;

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

@@ -0,0 +1,283 @@
+/**
+ * Chart metadata — the v1–v3 spellings.
+ *
+ * These are the identifiers a pre-v4 script uses to ask what it is running on.
+ * v4 moved them into namespaces (`timeframe.period`, `syminfo.tickerid`), which
+ * is why they are unprefixed globals here and not under one.
+ *
+ * All read from Context, so a host that runs 5-minute bars gets "5" rather than
+ * a hard-coded guess. Scripts branch on these to pick pivot windows and session
+ * boundaries, so getting them wrong changes the numbers, not just a label.
+ */
+import { Context } from "../context.js";
+/**
+ * The chart's timeframe as a string: "1", "5", "60", "D", "W", "M".
+ * v4 renamed this to `timeframe.period`.
+ * @getter
+ * @returns {string} The resolution string.
+ */
+export declare function period(ctx: Context): string;
+/**
+ * The chart's timeframe as a NUMBER of minutes, or 0 for non-intraday.
+ * Pine reports "D"/"W"/"M" as 0 here, which is why `period` exists alongside it.
+ * @getter
+ * @returns {integer} Minutes per bar, 0 for daily and above.
+ */
+export declare function interval(ctx: Context): number;
+/**
+ * Is the chart's timeframe intraday (minutes/seconds rather than days or more)?
+ * @getter
+ * @returns {bool}
+ */
+export declare function isintraday(ctx: Context): boolean;
+/**
+ * Is the chart's timeframe daily?
+ * @getter
+ * @returns {bool}
+ */
+export declare function isdaily(ctx: Context): boolean;
+/**
+ * Is the chart's timeframe weekly?
+ * @getter
+ * @returns {bool}
+ */
+export declare function isweekly(ctx: Context): boolean;
+/**
+ * Is the chart's timeframe monthly?
+ * @getter
+ * @returns {bool}
+ */
+export declare function ismonthly(ctx: Context): boolean;
+/**
+ * The chart's symbol WITHOUT its exchange prefix — "BTCUSD", not
+ * "BITSTAMP:BTCUSD". v4 renamed this to `syminfo.ticker`.
+ *
+ * Published strategies branch on it to pick per-symbol constants, so it changes
+ * results rather than just labelling them.
+ * @getter
+ * @returns {string}
+ */
+export declare function ticker(ctx: Context): string;
+export declare const timeframe: {
+    /**
+     * `timeframe.in_seconds(timeframe)` — May 2024.
+     *
+     * "The typical number of seconds in the chart's timeframe."
+     *
+     * The argument defaults to the chart's own timeframe, which is how nearly
+     * every published use spells it: `timeframe.in_seconds()` compared against
+     * `timeframe.in_seconds(higherTimeframe)` is the standard guard against
+     * requesting data finer than the chart.
+     *
+     * @getter
+     * @returns {simple int} Seconds per bar.
+     */
+    in_seconds: (ctx: Context, timeframe?: any) => number;
+    /**
+     * `timeframe.from_seconds(seconds)` — September 2023.
+     *
+     * "Converts a specified number of `seconds` into a valid timeframe string
+     *  based on our timeframe specification format."
+     *
+     * The inverse of `in_seconds`, and not a total one: 90 seconds is not a whole
+     * number of minutes, so the largest unit that divides evenly is chosen and
+     * the remainder stays in the smaller one. Under a minute the answer is
+     * seconds; a value that is not a positive number has no timeframe and gives
+     * `na` rather than a plausible "1".
+     */
+    from_seconds: (seconds: any) => string;
+    /**
+     * `timeframe.change(timeframe)` — June 2022.
+     *
+     * "Returns `true` on the first bar of a new `timeframe`, `false` otherwise."
+     *
+     * Answered by comparing which PERIOD the current bar's timestamp falls into
+     * against the previous bar's, so it fires exactly once per period however
+     * many chart bars that period contains — and is false on the very first bar
+     * of the script, which begins no period the script has seen end.
+     */
+    change: (ctx: Context, timeframe: any) => boolean;
+    /**
+     * `timeframe.isseconds` — is the chart's timeframe measured in seconds?
+     *
+     * The sixth member of the `is*` family, and the only one with no v1–v3 flat
+     * spelling, because seconds-based timeframes postdate them.
+     *
+     * @getter
+     * @returns {bool}
+     */
+    isseconds: (ctx: Context) => boolean;
+    /**
+     * `timeframe.isminutes` — is the chart's timeframe measured in minutes?
+     * A bare number is minutes in the timeframe format ("1", "60", "240").
+     * @getter
+     * @returns {bool}
+     */
+    isminutes: (ctx: Context) => boolean;
+    /**
+     * `timeframe.isdwm` — is it days, weeks or months?
+     * @getter
+     * @returns {bool}
+     */
+    isdwm: (ctx: Context) => boolean;
+    /**
+     * `timeframe.isticks` — is the chart's timeframe measured in ticks ("1T")?
+     * False on every time-based timeframe, which is every one a host charts
+     * today.
+     * @getter
+     * @returns {bool}
+     */
+    isticks: (ctx: Context) => boolean;
+};
+/** @returns {integer} */
+export declare const sunday = 1;
+/** @returns {integer} */
+export declare const monday = 2;
+/** @returns {integer} */
+export declare const tuesday = 3;
+/** @returns {integer} */
+export declare const wednesday = 4;
+/** @returns {integer} */
+export declare const thursday = 5;
+/** @returns {integer} */
+export declare const friday = 6;
+/** @returns {integer} */
+export declare const saturday = 7;
+/**
+ * `timenow` — the current UNIX time in milliseconds.
+ *
+ * Distinct from `time`, which is the timestamp of the bar being evaluated.
+ * Scripts use it to age-out signals ("only alert if the bar is recent").
+ *
+ * Reads from Context rather than calling Date.now() directly so a replay or a
+ * backtest can pin it; an unpinned wall clock would make runs irreproducible.
+ * @getter
+ * @returns {integer} UNIX timestamp in milliseconds.
+ */
+export declare function timenow(ctx: Context): number;
+/**
+ * `heikinashi(symbol)` — a symbol whose bars are Heikin-Ashi transformed.
+ *
+ * Pine models this as a TICKER TRANSFORM, not a series function: the result is
+ * passed to security(), which then evaluates its expression against smoothed
+ * candles.
+ *
+ *     ha = heikinashi(tickerid)
+ *     haClose = security(ha, period, close)
+ *
+ * Returning a marked symbol keeps that shape intact — Context.getSecurityData()
+ * recognises the marker and applies the transform when the candles are read, so
+ * the whole HTF machinery (alignment, no-lookahead, per-call-site state) is
+ * reused rather than duplicated.
+ *
+ * @returns {string} The symbol, marked for Heikin-Ashi transformation.
+ */
+export declare function heikinashi(symbol: any): string;
+/** Marker understood by Context.getSecurityData(). */
+export declare const HEIKINASHI_PREFIX = "heikinashi:";
+/** @returns {string} Never returns — Renko bricks cannot be rebuilt here. */
+export declare function renko(_symbol: any, _style?: any, _param?: any): string;
+/** @returns {string} Never returns — Line Break bars cannot be rebuilt here. */
+export declare function linebreak(_symbol: any, _lines?: any): string;
+/** @returns {string} Never returns — Kagi lines cannot be rebuilt here. */
+export declare function kagi(_symbol: any, _reversal?: any): string;
+/** @returns {string} Never returns — P&F columns cannot be rebuilt here. */
+export declare function pointfigure(_symbol: any, _source?: any, _style?: any, _param?: any, _reversal?: any): string;
+/** One coordinate on the chart. */
+interface ChartPoint {
+    index: number;
+    time: number;
+    price: number;
+}
+export declare const chart: {
+    /**
+     * `chart.point` — v5's coordinate object.
+     *
+     * Written INLINE rather than as a `const` referenced by shorthand: the
+     * registry generator walks object literals with ts-morph and does not
+     * evaluate the file, so `point,` pointing at a declaration elsewhere produced
+     * no `chart.point.*` keys at all. Same rule, and the same reason, as the
+     * "written out literally" note at the top of ./drawings.ts.
+     */
+    point: {
+        /** `chart.point.new(time, index, price)` — every field given. */
+        new: (time: any, index: any, price: any) => ChartPoint;
+        /**
+         * `chart.point.now(price)` — the CURRENT bar's index and time.
+         *
+         * The only constructor that needs the Context, and that is the whole point
+         * of it: "now" is a fact about the run, not about the arguments.
+         */
+        now: (ctx: Context, price: any) => ChartPoint;
+        /** `chart.point.from_index(index, price)` — time left `na`. */
+        from_index: (index: any, price: any) => ChartPoint;
+        /** `chart.point.from_time(time, price)` — index left `na`. */
+        from_time: (time: any, price: any) => ChartPoint;
+        /** `chart.point.copy(point)` — a new point with the same three fields. */
+        copy: (p: any) => ChartPoint;
+    };
+    /**
+     * The chart's background colour.
+     *
+     * "chart.bg_color returns the color of the chart's background from the
+     *  'Chart settings/Appearance/Background' field."
+     *
+     * Host-supplied via `Context.provideChartBackground`; see the note there for
+     * the default and why it is a choice rather than a fact.
+     * @getter
+     */
+    bg_color: (ctx: Context) => string;
+    /**
+     * A colour that contrasts well with the background.
+     *
+     * "chart.fg_color returns a color providing optimal contrast with
+     *  chart.bg_color."
+     *
+     * Black on a light background, white on a dark one, chosen by relative
+     * luminance. TradingView does not publish the exact rule, so this is the
+     * standard one rather than a reproduction of theirs — the two agree on which
+     * END of the scale to pick, which is what the promise is about, and may
+     * differ on a mid-grey background.
+     * @getter
+     */
+    fg_color: (ctx: Context) => string;
+    /**
+     * Is the chart type standard?
+     * @getter
+     */
+    is_standard: (_ctx: Context) => boolean;
+    /**
+     * The non-standard chart types. This engine draws standard candles only,
+     * so each is false — the same fact `is_standard` states from the other side.
+     * @getter
+     */
+    is_heikinashi: (_ctx: Context) => boolean;
+    /** @getter */
+    is_kagi: (_ctx: Context) => boolean;
+    /** @getter */
+    is_linebreak: (_ctx: Context) => boolean;
+    /** @getter */
+    is_pnf: (_ctx: Context) => boolean;
+    /** @getter */
+    is_range: (_ctx: Context) => boolean;
+    /** @getter */
+    is_renko: (_ctx: Context) => boolean;
+    /**
+     * Opening time of the leftmost VISIBLE bar.
+     *
+     * "chart.left_visible_bar_time returns the time of the leftmost bar
+     *  currently visible on the chart."
+     *
+     * There is no viewport here, so this is the first bar of the run unless the
+     * host declares one — see `Context.provideVisibleRange`, which also explains
+     * why that is a divergence worth stating.
+     * @getter
+     */
+    left_visible_bar_time: (ctx: Context) => number;
+    /**
+     * Opening time of the rightmost VISIBLE bar. See `left_visible_bar_time`.
+     * @getter
+     */
+    right_visible_bar_time: (ctx: Context) => number;
+};
+export {};

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

@@ -0,0 +1,51 @@
+/**
+ * runtime/v1/stdlib/color.ts
+ * Implements Pine Script Color Namespace.
+ * STRATEGY: Performance. We use Hex Strings (#RRGGBBAA) directly.
+ * We do NOT create Objects.
+ */
+declare const color: {
+    /**
+     * color.new(color, transp)
+     * Adds transparency to an existing hex color.
+     * @param colorStr Hex string "#RRGGBB" or "#RRGGBBAA"
+     * @param transp Number 0 (Opaque) to 100 (Invisible)
+     */
+    new: (colorStr: any, transp: any) => string;
+    /**
+     * color.rgb(red, green, blue, transp)
+     * Creates a color from RGBA components.
+     */
+    rgb: (r: any, g: any, b: any, transp?: any) => string;
+    /**
+     * `color.from_gradient(value, bottom_value, top_value, bottom_color, top_color)`
+     *
+     * Added with `color.rgb` and `color.r/g/b/t` in the same v4 batch (May
+     * 2021): "returns color calculated from the linear gradient between
+     * bottom_color to top_color".
+     *
+     * Every OTHER member of that batch was implemented; this one was missed,
+     * and the gap was invisible because `color` IS a namespace — a missing
+     * MEMBER of a real namespace emits `opsv2_color.opsv2_from_gradient`,
+     * reads `undefined`, and only fails when the result is called. Two of
+     * TradingView's own documentation examples died that way with "The
+     * provided reference is not a function".
+     *
+     * `value` is clamped to [bottom_value, top_value] — outside the range Pine
+     * returns the endpoint colour rather than extrapolating — and RGB
+     * channels truncate while transparency is interpolated in 0-100 space and
+     * rounded (Pine Logs probe color-gradient).
+     */
+    from_gradient: (value: any, bottomValue: any, topValue: any, bottomColor: any, topColor: any) => string;
+    /**
+     * color.r / .g / .b / .t
+     * Extract components from a hex string.
+     */
+    r: (c: any) => number;
+    g: (c: any) => number;
+    b: (c: any) => number;
+    t: (c: any) => number;
+};
+export default color;
+/** v4's `color.from_gradient`: not probed on TradingView, so it keeps per-channel rounding. */
+export declare const legacyFromGradient: (value: any, bottomValue: any, topValue: any, bottomColor: any, topColor: any) => string;