openpinescript 0.0.0-stage → 0.1.0

package/dist/types/runtime/v1/context.d.ts

@@ -0,0 +1,1705 @@
+import { Series } from "./Series.js";
+import { MarketOrder } from "./stdlib/strategy.js";
+import type { FootprintLevel } from "./footprint.js";
+import { LanguageProfile } from "../../transpiler/common/profiles/index.js";
+export interface Trade {
+    id: string;
+    entryTime: number;
+    entryPrice: number;
+    exitTime: number;
+    exitPrice: number;
+    qty: number;
+    pnl: number;
+    direction: "long" | "short";
+    /**
+     * The bars the trade opened and closed on.
+     *
+     * A time alone cannot be aligned to a chart without searching the bar
+     * list for it, and "Avg # Bars in Trades" — a row of TradingView's
+     * performance summary — is `exitBarIndex - entryBarIndex` and nothing
+     * else. Both are recorded at the fill, where they are known for free.
+     */
+    entryBarIndex?: number;
+    exitBarIndex?: number;
+    /**
+     * The order id that OPENED the position, which TradingView's list of
+     * trades calls the trade's signal. `id` names the closing order, so
+     * without this the entry row of every trade reads "Close".
+     */
+    entryId?: string;
+    /**
+     * Favourable and adverse excursion, in currency, over the life of the
+     * trade — how far the position ran in the script's favour before it
+     * closed, and how far against.
+     *
+     *   run-up   = (highest price while open - entry price) * qty   [long]
+     *   drawdown = (entry price - lowest price while open)  * qty   [long]
+     *
+     * mirrored for a short. TradingView states the price form of both and
+     * reports them per trade; the exit price does not enter either one.
+     * Both are >= 0, and both are measured against the position's average
+     * price so a pyramided add moves them the way it moves the P&L.
+     */
+    runup?: number;
+    drawdown?: number;
+    /** Commission charged on the round turn, already deducted from `pnl`. */
+    commission?: number;
+    /**
+     * `strategy.closedtrades.exit_id` and `.exit_comment`, as TradingView
+     * names them: the exit's own id, "Close entry(s) order <entry>" for
+     * `strategy.close`, "Close position order" for `close_all` and a margin
+     * call. Absent where no version records them yet, and the accessors fall
+     * back to `id`.
+     */
+    exitId?: string;
+    exitComment?: string;
+}
+/**
+ * One row of the equity curve: what the account was worth at a bar's close.
+ *
+ * Sampled every bar rather than every fill because that is what a chart
+ * plots — TradingView's overview draws equity against time, and a curve
+ * that only moves when a trade closes is a staircase that hides the open
+ * position's swing. `openPL` is the part of `equity` that is not yet
+ * realized, which is what makes the difference visible.
+ */
+export interface EquityPoint {
+    time: number;
+    /** Realized cash plus the open position's mark-to-market. */
+    equity: number;
+    /** Unrealized P&L of the position held at this bar's close; 0 while flat. */
+    openPL: number;
+}
+/** One entry still open inside a position. See Position.entries. */
+export interface OpenEntry {
+    id: string;
+    /** Still open, and as filled. `qty_percent` exits are a share of `opened`. */
+    qty: number;
+    opened: number;
+    price: number;
+    bar: number;
+    time: number;
+    /** Entry commission not yet claimed by a closing trade. */
+    commission: number;
+    /** Identifies the trade for as long as it lives: the bar and the fill's order count. */
+    uid?: string;
+}
+export interface Position {
+    size: number;
+    avgPrice: number;
+    /**
+     * The bar the position was OPENED on, the time of that bar, and the order
+     * id that opened it.
+     *
+     * Recorded so `strategy.opentrades.entry_bar_index` and `.entry_id` have
+     * something to answer with. Undefined while flat, which is the same fact as
+     * `size === 0` and reads as `na` either way.
+     *
+     * `entryTime` is here because a host has to PLACE this position on a
+     * chart, and a bar index cannot be placed: the chart's bar list grows as
+     * older bars page in, so index 40 is a different bar after a scroll.
+     * `Trade` carries both for the same reason; leaving it off `Position`
+     * meant the still-open position could only be drawn on the last bar.
+     */
+    entryBarIndex?: number;
+    entryTime?: number;
+    entryId?: string;
+    /**
+     * Entry-side commission already paid on the position still open, so an
+     * exit can charge its own side and claim a share of this rather than
+     * recomputing a whole round turn.
+     *
+     * `commission.cash_per_order` is a flat fee PER ORDER, and it used to be
+     * charged twice per closed-trade record. Two partial exits of one entry
+     * are three orders and were billed for four; three pyramided entries
+     * closed in one go are four orders and were billed for two. The other two
+     * commission types scale with quantity, so they came out right by
+     * accident and this changes nothing for them.
+     */
+    entryCommission?: number;
+    /**
+     * The largest size this position has held since it opened: what a v6
+     * `qty_percent` exit is a percentage OF. Half of a 0.731 entry is 0.3655
+     * whether or not another exit has already sold part of it.
+     */
+    openedQty?: number;
+    /**
+     * The entries that make up the position, oldest first — what TradingView
+     * calls its open trades. Kept by every broker and READ only where the
+     * broker tracks trades (V6Broker): `strategy.close(id)` and an exit's
+     * `from_entry` act on the entries with that id, and a close records one
+     * trade per entry it consumes, at that entry's own price.
+     */
+    entries?: OpenEntry[];
+    /**
+     * The id ledger, apart from `entries` (the trades, first in first out):
+     * what each entry id still owns, and what it opened with. An exit with
+     * `from_entry` and `close(id)` draw on an id's quantity, but what they sell
+     * comes off the OLDEST trades whatever their id (TradingView's log,
+     * harness_strategy_exit_mix and harness_strategy_pyr3 phase d).
+     */
+    ledger?: Record<string, {
+        qty: number;
+        opened: number;
+    }>;
+}
+/**
+ * One line emitted by v5's `log.*` functions.
+ *
+ * Declared here rather than beside the functions in stdlib/logging.ts so the
+ * dependency runs one way: every stdlib module already imports the Context, and
+ * having the Context import a stdlib module back would close the cycle.
+ */
+export interface LogEntry {
+    readonly level: "info" | "warning" | "error";
+    readonly message: string;
+    /** The bar the line was emitted on, so a log can be aligned to a series. */
+    readonly bar: number;
+    /** The bar's timestamp, which is what the generated CSV rows are keyed by. */
+    readonly time: number;
+}
+interface PlotBase {
+    title: string;
+    color?: string;
+}
+export interface LinePlot extends PlotBase {
+    type: 'line';
+    value: number;
+    linewidth?: number;
+    style?: number;
+}
+export interface OHLCPlot extends PlotBase {
+    type: 'candle';
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}
+export interface MarkerPlot extends PlotBase {
+    type: 'shape' | 'char' | 'arrow';
+    value: number;
+    style?: string;
+}
+export interface ColorDirective extends PlotBase {
+    type: 'bgcolor' | 'barcolor';
+}
+export type PlotData = LinePlot | OHLCPlot | MarkerPlot | ColorDirective;
+/** Where in the Pine source a runtime error was raised; see `Context.locateError`. */
+export interface PineLocation {
+    line: number;
+    col: number;
+    /** The alias of the imported library the error was raised in, if it was in one. */
+    library?: string;
+    /** For an error inside a library: the call in the script that led there. */
+    caller?: {
+        line: number;
+        col: number;
+    };
+}
+export interface FillData {
+    plotId1: string;
+    plotId2: string;
+    color: string;
+    title: string;
+    /** `fill(show_last)`: draw only the last N bars. Absent when the script gave none. */
+    showLast?: number;
+    /** The gradient overload, `fill(p1, p2, top_value, bottom_value, top_color, bottom_color)`. */
+    gradient?: true;
+    /** `top_color` is drawn at the price `top_value`, `bottom_color` at `bottom_value`; this bar's. */
+    top_value?: number;
+    bottom_value?: number;
+    top_color?: string;
+    bottom_color?: string;
+}
+export interface InputDef {
+    id: string;
+    defval: any;
+    title: string;
+    type: string;
+}
+/**
+ * Script-level metadata declared by the `study()` / `strategy()` directive.
+ * `kind` drives mode-specific behavior (e.g. study mode disables the broker).
+ */
+/**
+ * The directive kinds a script can declare.
+ *
+ * `indicator` is v5's rename of `study` and nothing else — same parameters,
+ * same meaning. Both spellings are kept rather than normalised so a host
+ * reading `scriptMeta.kind` sees the keyword the author actually wrote, which
+ * is also what every diagnostic quotes back at them.
+ *
+ * `library` is v5's third kind. A library declares functions for other scripts
+ * to import and plots nothing itself, so a host must be able to tell one from
+ * an indicator before it tries to render anything.
+ */
+export type ScriptKind = 'study' | 'indicator' | 'strategy' | 'library';
+/**
+ * What a strategy starts with when `strategy()` does not say.
+ *
+ * TradingView's own figure, read off its own output: the golden strategy
+ * export passes no `initial_capital` and its `strategy.equity` reads exactly
+ * 1000000 on every bar before the first fill
+ * (conformance/v5/parity/harness_strategy.BTCUSDT.1D.log). The engine used to
+ * start at 100000, which put every equity-derived figure — `netprofit_percent`,
+ * `grossprofit_percent` — out by a factor of ten.
+ */
+export declare const DEFAULT_INITIAL_CAPITAL = 1000000;
+/**
+ * ...but only for Pine v5. Read off TradingView with a strategy that passes no
+ * `initial_capital`: v2, v3, v4 and v6 start at 100,000, v5 at 1,000,000.
+ */
+export declare function defaultInitialCapital(version: number): number;
+export interface ScriptMeta {
+    kind: ScriptKind;
+    title: string;
+    shorttitle: string;
+    overlay: boolean;
+    precision?: number;
+    pyramiding?: number;
+    calc_on_every_tick?: boolean;
+    calc_on_order_fills?: boolean;
+    currency?: string;
+    /**
+     * The rest of the `strategy()` declaration — the backtest settings a
+     * TradingView user reads off the Properties tab and changes without
+     * touching the script.
+     *
+     * Recorded whether or not the broker acts on each one, because a host
+     * cannot show a properties panel for arguments it was never told about,
+     * and a panel that invents its own defaults will disagree with the
+     * script the moment the script sets one.
+     */
+    initial_capital?: number;
+    default_qty_type?: string;
+    default_qty_value?: number;
+    commission_type?: string;
+    commission_value?: number;
+    slippage?: number;
+    margin_long?: number;
+    margin_short?: number;
+    process_orders_on_close?: boolean;
+    risk_free_rate?: number;
+    /**
+     * v6, July 2026: run once per tick of every HISTORICAL bar. Recorded for a
+     * host to display; this engine is given bars, not their ticks, so it has
+     * nothing to run per tick and computes exactly as if this were false.
+     * Present only when a v6 script declares it.
+     */
+    calc_on_every_history_tick?: boolean;
+}
+export interface Drawing {
+    id: string;
+    kind: 'line' | 'label' | 'box' | 'table' | 'polyline' | 'linefill';
+    /** The bar the drawing was created on. */
+    bar: number;
+    props: Record<string, any>;
+}
+/**
+ * One observation of a non-price series — a dividend, a quarterly figure.
+ *
+ * These are EVENTS, not bars: a value is published on one date and stands until
+ * the next, so a request reads as a step function over its samples rather than
+ * as one value per bar.
+ */
+export interface RequestSample {
+    /** UNIX ms. The value applies to this bar and every later one until the next sample. */
+    time: number;
+    value: number;
+}
+/** A higher-timeframe candle supplied for `security()` evaluation (P1). */
+export interface SecurityCandle {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    /**
+     * When the bar closes, if the host knows it. A stock's hourly and daily bars end
+     * where the SESSION ends, not on a clock boundary (the last hourly bar of a
+     * 09:30-16:00 session is 15:30-16:00); without it the end is the calendar's.
+     * `request.security` closes a bar with the chart bar that ends it, so a host
+     * with a session calendar should give this (TradingView's `time_close`).
+     */
+    closeTime?: number;
+}
+/**
+ * The stack of call ids being executed, with the joined key of every depth
+ * kept as it moves.
+ *
+ * A call site's key was rebuilt by joining the whole stack on every call,
+ * which was a tenth of a run's time. The keys are interned, so each is one
+ * string whose hash is computed once. A built-in that names a frame of its own
+ * (`ta.ts` pushes "rsi_gain" and the like) pushes through the same methods.
+ */
+declare class CallStack {
+    private ids;
+    /** `keys[i]` is the first `i + 1` ids joined with "/". */
+    readonly keys: string[];
+    private intern;
+    get length(): number;
+    /** The innermost id. */
+    get top(): string | undefined;
+    /** The whole stack joined with "/", "" when empty. */
+    get path(): string;
+    /** Returns the new path. */
+    push(id: string): string;
+    pop(): void;
+    join(sep: string): string;
+    [Symbol.iterator](): Iterator<string>;
+}
+export declare class Context {
+    protected callStack: CallStack;
+    /** What a call id says about itself, which never changes: its name and whether it is a user frame. */
+    private callIds;
+    /**
+     * Keyword arguments passed to a built-in whose signature does not name them.
+     *
+     * `<function>(<argument>)`, deduplicated. Empty is the only acceptable
+     * value: a name Pine accepts and this engine does not model is a gap, and a
+     * silently dropped argument is the worst shape one can take — the script
+     * runs, and does something other than what it says.
+     */
+    droppedArguments: Set<string>;
+    /**
+     * The series NAMESPACE of the user-function frame currently executing.
+     *
+     * Empty at script scope, and `<call id>|` inside a user function — nested
+     * one level per frame, so a function called from two places has two
+     * namespaces and a function called from inside another has one per outer
+     * frame.
+     *
+     * ── Why this exists ─────────────────────────────────────────────────────
+     *
+     * "each function call has its own instance of the series variables" is how
+     * Pine works, and this engine gave every call site ONE instance:
+     *
+     *     f() =>
+     *         var c = 0
+     *         c := c + 1
+     *         c
+     *     a = f()
+     *     b = f()
+     *
+     * yielded a = 1,3,5 and b = 2,4,6, where TradingView gives 1,2,3 for both.
+     * Both calls advanced the same counter. The same held for every function
+     * local, not just `var` ones: `t = close * 2` inside a function was one
+     * series shared by every caller, so a function's HISTORY (`t[1]`) mixed the
+     * call sites together.
+     *
+     * The emitter already qualifies a local's name by its FUNCTION, which stops
+     * two different functions from colliding. This is the other half: two calls
+     * of the SAME function are two variables too.
+     */
+    private seriesScope;
+    private seriesScopes;
+    /** Which user-function CALL is running: a fresh number per call, 0 at script scope. */
+    private frameSeq;
+    private frameSeqs;
+    private frameSeqCounter;
+    /** The series the running user call was handed as arguments: a parameter's history stays bar-indexed. */
+    private argSeries;
+    private frameArgs;
+    /** A series key in the frame that is running — the plain name at script scope. */
+    private scoped;
+    private states;
+    private committedSnapshot;
+    vars: Map<string, Series>;
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    currentBarIndex: number;
+    /**
+     * The chart's timeframe, as Pine spells it: "1", "5", "60", "D", "W", "M".
+     *
+     * Read by `period` / `interval` in stdlib/chart.ts. A script that branches
+     * on the chart timeframe (a very common pattern in session and pivot
+     * indicators) computes different numbers depending on this, so a host that
+     * runs intraday data MUST set it — the default is the daily bars this
+     * repo's sample dataset uses, not a claim about the data supplied.
+     */
+    resolution: string;
+    /** The chart's symbol, as `tickerid` / `ticker` report it. */
+    symbol: string;
+    /**
+     * The instrument's minimum price increment, read by `math.round_to_mintick`.
+     *
+     * A property of the SYMBOL, so a host that charts anything other than the
+     * sample dataset must set it. The default is the two-decimal tick of a
+     * typical equity, which is a starting point rather than a claim about the
+     * data supplied — the same stance `resolution` takes above.
+     */
+    mintick: number;
+    /**
+     * The rest of what a script can ask about its instrument — the `syminfo.*`
+     * family added at v4.
+     *
+     * ── Why these are host-declared, with stated defaults ───────────────────
+     *
+     * None of it is derivable from OHLCV bars. A CSV of prices does not say
+     * which exchange listed them, what currency they are quoted in, or which
+     * time zone the session runs in. So each is a field the host sets, and each
+     * default below is a CHOICE that a script can act on:
+     *
+     *   `syminfo.type == "crypto"` selects a different pivot window in a large
+     *   share of published indicators, and `syminfo.currency` appears directly
+     *   in position-sizing arithmetic.
+     *
+     * Left unset, a script gets the defaults — a US equity quoted in USD on a
+     * one-cent tick — which is exactly what this repo's sample dataset is. That
+     * is a starting point, not a claim about whatever data a host supplies.
+     *
+     * Two are DERIVED rather than stored, because Pine defines them in terms of
+     * the ticker id: `syminfo.prefix` and `syminfo.ticker` are the two halves
+     * of `EXCHANGE:SYMBOL`. Storing them separately would let them drift out of
+     * step with the symbol they describe.
+     */
+    currency: string;
+    basecurrency: string;
+    description: string;
+    symbolType: string;
+    symbolRoot: string;
+    timezone: string;
+    pointvalue: number;
+    sessionSpec: string;
+    mincontract: number;
+    /** True once the host supplied `mincontract`; only then are order quantities floored to it. */
+    mincontractSupplied: boolean;
+    isin: string;
+    currentContract: string | null;
+    /** The live quote, for `bid` / `ask` (v6). Not in an OHLCV bar. */
+    bid: number;
+    ask: number;
+    /**
+     * Volume at price, per bar, for `request.footprint()` (v6). Keyed by bar
+     * open time. `null` until a host supplies any — see getFootprintLevels.
+     */
+    private footprints;
+    /** Supplies footprint data: for each bar, its volume per price level. */
+    provideFootprints(bars: ReadonlyArray<{
+        time: number;
+        levels: FootprintLevel[];
+    }>): void;
+    /**
+     * This bar's levels, `null` when the host has none for it, and a refusal
+     * when the host has supplied no footprints at all — the `request.*` rule:
+     * a series this engine cannot fetch is asked for, not silently `na`.
+     */
+    getFootprintLevels(): FootprintLevel[] | null;
+    /** The source location of the one `request.footprint()` call, once seen. */
+    private footprintSite;
+    /**
+     * "Scripts can make only one request.footprint() call. Multiple calls
+     * cause a runtime error." A CALL is a place in the source: the innermost
+     * call id, which carries its location. Counting executions instead
+     * rejected one call inside a `for` loop on the first bar.
+     */
+    countFootprintRequest(): void;
+    /** Declares the current bid and ask. See `bid` in stdlib/v6_members.ts. */
+    provideQuote(quote: {
+        bid?: number;
+        ask?: number;
+    }): void;
+    /** Declares the instrument's metadata. Every field is optional. */
+    provideSymbolInfo(info: {
+        symbol?: string;
+        mintick?: number;
+        currency?: string;
+        basecurrency?: string;
+        description?: string;
+        type?: string;
+        root?: string;
+        timezone?: string;
+        pointvalue?: number;
+        session?: string;
+        mincontract?: number;
+        isin?: string;
+        current_contract?: string;
+    }): void;
+    /**
+     * How many bars the host is going to feed, and when the last one opens.
+     *
+     * ── Why the host has to say ─────────────────────────────────────────────
+     *
+     * `last_bar_index` and `last_bar_time` (v5, December 2021) are documented
+     * as "known at the beginning of the script's calculation" — on bar 1 a
+     * script can already ask how far the dataset runs, which is how the common
+     * `bar_index == last_bar_index - 1` idiom works at all.
+     *
+     * This engine streams bars: `setBar` is called one at a time and the
+     * Context has no way to know how many more are coming. Only the caller
+     * knows, so the caller declares it. `mock_run` reads it off the CSV; the
+     * session API takes it from the candle array it was handed.
+     *
+     * ── When it is not declared ─────────────────────────────────────────────
+     *
+     * The fallback is the highest bar seen SO FAR, which is correct on the last
+     * bar and an underestimate before it. That is a real divergence from
+     * TradingView rather than a hidden approximation, and it is why
+     * `provideDatasetExtent` exists: a host that can be exact should be.
+     */
+    datasetSize: number | null;
+    datasetLastTime: number | null;
+    /** Declare the extent of the run before the first bar. */
+    provideDatasetExtent(barCount: number, lastBarTime?: number): void;
+    /** Bar index of the last bar in the dataset — `last_bar_index`. */
+    get lastBarIndex(): number;
+    /**
+     * Is the script executing on the dataset's final bar — `barstate.islast`?
+     *
+     * Derived, not stored. `is_last` is written only by `applyTick`, which is
+     * the LIVE path, so on a purely historical run nothing ever set it and
+     * `barstate.islast` was false on every bar including the last one. That
+     * silently broke the commonest idiom in Pine — `if barstate.islast` is how
+     * every dashboard table, summary label and end-of-chart drawing is guarded,
+     * and all of them simply never ran.
+     *
+     * The extent is known: `runHistory` declares it before the first bar. So
+     * the answer is the comparison, with the live flag kept as an override for
+     * the realtime bar, which is last by definition however long the dataset is.
+     */
+    get onLastBar(): boolean;
+    /**
+     * How many bars at the END of the run the host marks REALTIME.
+     *
+     * ── Why the host has to say ─────────────────────────────────────────────
+     *
+     * `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". The second
+     * reading needs to be answered ON that preceding bar — one bar before the
+     * realtime flag arrives — so it cannot be inferred from `is_realtime`, which
+     * the host sets bar by bar.
+     *
+     * The same shape as `provideDatasetExtent` above, and for the same reason:
+     * only the caller knows how its run ends. Zero — no realtime bar, the whole
+     * dataset is settled history — is the default, because a host that says
+     * nothing is replaying closed bars. Every harness in this repository that
+     * models an open market (`is_realtime = is_last`) sets it to 1.
+     *
+     * Getting this wrong is silent: with a realtime bar unaccounted for, the
+     * guard fires on NO bar at all, and the twenty-nine documentation examples
+     * that draw their labels and tables under it drew nothing.
+     */
+    realtimeBars: number;
+    /** Bar index of the last bar the script may treat as settled history. */
+    get lastConfirmedHistoryIndex(): number;
+    /** Opening time of the last bar in the dataset — `last_bar_time`. */
+    get lastBarTime(): number;
+    /**
+     * The chart's background colour — what `chart.bg_color` returns.
+     *
+     * "chart.bg_color returns the color of the chart's background from the
+     *  'Chart settings/Appearance/Background' field."
+     *
+     * There is no chart here, so the host declares it. The default is
+     * TradingView's own light-theme background, `#ffffff`, which is a CHOICE
+     * and not a fact about the run — a script that draws its own dark
+     * dashboard will get black text out of `chart.fg_color` unless the host
+     * says otherwise. That is why the setter exists.
+     */
+    chartBgColor: string;
+    /** Declares the chart's background colour, for `chart.bg_color`. */
+    provideChartBackground(color: string): void;
+    /**
+     * The first and last VISIBLE bar times — `chart.left_visible_bar_time` and
+     * `chart.right_visible_bar_time`.
+     *
+     * "chart.left_visible_bar_time returns the time of the leftmost bar
+     *  currently visible on the chart."
+     *
+     * Visibility is a property of a viewport, and this engine has none: it runs
+     * every bar it is given. So the visible range defaults to the WHOLE
+     * dataset, which is what a script scanning "the bars on screen" would see
+     * if the user had zoomed all the way out.
+     *
+     * Stated rather than hidden, because it changes results: a script that
+     * counts bars between the two, or anchors a VWAP to the left edge, gets the
+     * full history here and a window on TradingView. A host that knows the
+     * viewport should declare it.
+     */
+    visibleRange: {
+        left: number;
+        right: number;
+    } | null;
+    /** Declares the visible bar range, in milliseconds. */
+    provideVisibleRange(leftTime: number, rightTime: number): void;
+    /** Opening time of the leftmost visible bar. */
+    get leftVisibleBarTime(): number;
+    /** Opening time of the rightmost visible bar. */
+    get rightVisibleBarTime(): number;
+    /**
+     * Opening time of the FIRST bar seen, or 0 before any bar.
+     *
+     * Recorded on the first `setBar` rather than derived, because the Context
+     * is fed one bar at a time and nothing else remembers where the run began.
+     */
+    firstBarTime: number;
+    /**
+     * Lines emitted by `log.info` / `log.warning` / `log.error` (v5).
+     *
+     * Kept on the Context rather than written to the console because they are
+     * OUTPUT: scripts/common/make-log-harness.ts generates harnesses whose entire
+     * result is a log line per bar, and a host has to be able to read them back
+     * to reproduce locally what TradingView's Pine Logs pane shows.
+     */
+    logs: LogEntry[];
+    /**
+     * Wall-clock time reported by `timenow`, in ms.
+     *
+     * Settable so a backtest or replay is reproducible — reading Date.now()
+     * inside the script would make two runs of the same data disagree.
+     */
+    now: number;
+    plots: Map<string, (PlotData | null)[]>;
+    fills: Map<string, (FillData | null)[]>;
+    /**
+     * v4 drawing objects — line, label, box, table — keyed by their generated id.
+     *
+     * A Map rather than an array so `line.delete(id)` is O(1) and ids stay
+     * stable, which is what a host needs to diff one bar's drawings against the
+     * next instead of re-rendering everything.
+     *
+     * These do NOT feed `plots`: a drawing is not a per-bar value, it is an
+     * object with a lifetime. Nothing in the golden-parity suite reads them —
+     * TradingView's exported chart data does not include drawings either.
+     */
+    drawings: Map<string, Drawing>;
+    private drawingCounter;
+    /** Live ids per kind, oldest first, so the cap below can evict in O(1). */
+    private drawingOrder;
+    /**
+     * How many drawings of each kind survive, and when the rest are deleted.
+     *
+     * The limit is the script's own: `max_lines_count`, `max_labels_count`,
+     * `max_boxes_count` and `max_polylines_count` on `indicator()` /
+     * `study()` / `strategy()`, each defaulting to 50 (`declareScript` applies
+     * them). Linefills are fixed at 50. Tables are absent deliberately: Pine
+     * limits them by POSITION (one per slot), not by count, so an eviction rule
+     * would be the wrong shape.
+     *
+     * ── The rule, as TradingView applies it ─────────────────────────────────
+     *
+     * It does NOT hold the count at `limit`. Drawings pile up past the limit
+     * and are then cut back in one go: when creating a drawing makes the live
+     * count of that kind exceed `limit + 5`, the oldest are deleted until the
+     * count equals `limit`. It happens at the creation itself, so it also
+     * happens in the middle of one bar's execution.
+     *
+     * Measured with conformance/v5/parity/probe_drawing_limits.pine:
+     *
+     *   limit 10, one line per bar   the count after each bar goes
+     *                                1, 2, ... 15, then 10, 11 ... 15, 10, ...
+     *   limit 10, 30 labels in one   the same sawtooth, per label.new
+     *   execution
+     *   limit 500, 1003 lines        505 remain, the newest 505
+     *     (harness_trader_club)
+     *
+     * Log: conformance/v5/parity/probe_drawing_limits.BTCUSDT.5.csv. Only
+     * limits 10 and 500 were measured; the +5 slack is assumed to be constant
+     * in between and at the default of 50.
+     *
+     * Without any cap, `label.new` on every bar of a 6,000-bar chart retains
+     * 6,000 records here while TradingView shows about 50, so a script that
+     * reads its own drawings back diverges, and memory grows without bound on
+     * exactly the scripts most likely to be long-running.
+     */
+    private drawingLimits;
+    /** Registers a drawing and returns its id, evicting the oldest past the cap. */
+    newDrawing(kind: Drawing["kind"], props: Record<string, any>): string;
+    /**
+     * v5 and v6: who goes when a kind passes `limit + 5`.
+     *
+     * Measured on TradingView (dev-docs/tv-parity/_probes/version-scope/
+     * v6-gc-order-1, -2, -3 and v5-gc-order, limit 10; golden test
+     * tests/v6/runtime/drawing_eviction_tv.test.ts):
+     *
+     *   - A drawing a `var` / `varip` variable holds RIGHT NOW is never
+     *     evicted. One held only inside an array is not protected. UDT fields,
+     *     maps and plain variables were not probed and are treated as not
+     *     protected.
+     *   - On a historical bar the oldest unprotected drawings go, whatever bar
+     *     they were drawn on, until the count is `limit`.
+     *   - On the realtime bar a pass first removes unprotected drawings from
+     *     EARLIER bars, oldest first, and stops there, even with the count
+     *     still above `limit`. Only a pass that finds no such drawing removes
+     *     the current bar's own, oldest first, down to `limit`.
+     *
+     * v4 and earlier were not probed and keep the plain oldest-first cut.
+     */
+    private evictDrawings;
+    /** Ids of drawings that a `var` / `varip` variable holds at this moment, in any frame. */
+    private varHeldDrawings;
+    /**
+     * Removes a drawing, keeping the eviction queue in step.
+     *
+     * Deleting straight out of `drawings` would leave the id in `drawingOrder`,
+     * so the next eviction would shift off a dead id, delete nothing, and let
+     * the live count sit above the cap indefinitely.
+     */
+    deleteDrawing(id: any): void;
+    /**
+     * Reads a field off a user-defined-type instance.
+     *
+     * Unwraps a Series first: a UDT instance held in a variable is wrapped by
+     * `ctx.new_var` exactly as a number is, so `p.x` reaches this with the
+     * wrapper rather than the object.
+     *
+     * A missing field, or a read through `na`, gives `na` rather than throwing.
+     * Pine's type checker catches a misspelt field at COMPILE time and this
+     * engine does not model field types, so throwing here would turn a
+     * legitimate `na` object — the state every UDT variable starts in — into a
+     * crash.
+     */
+    field(target: any, name: string): any;
+    /**
+     * Writes a field on a user-defined-type instance, and returns the value.
+     *
+     * Writing through `na` is an ERROR, unlike reading. `p.x := 1` when `p` has
+     * never been constructed cannot mean anything, and silently discarding the
+     * write would leave a script that looks like it is accumulating state and
+     * is not — the failure this engine exists to prevent.
+     */
+    /**
+     * The value a UDT field stores: a series argument's value on this bar.
+     *
+     * `Item.new(bx, bar_index, t)` with `box bx = box.new(…)` and `float t =
+     * high` hands the constructor SERIES -- the variables' wrappers -- and an
+     * object that kept the wrapper would read whatever the variable holds on
+     * the bar it is READ, not the one it was built on. A `var` array of such
+     * objects then saw every element change together: all reported the latest
+     * bar's values, and `box.delete(oldest.bx)` deleted the NEWEST box.
+     * TradingView stores the value (checked with Pine Logs:
+     * dev-docs/tv-parity/_probes/na-drawings/parity-udt-fields.pine), as `setField` already did for writes.
+     *
+     * Arrays, maps, matrices, drawings and nested objects are values that are
+     * references, so unwrapping keeps sharing them exactly as Pine does.
+     */
+    fieldValue(value: any): any;
+    setField(target: any, name: string, value: any): any;
+    /**
+     * `obj.copy()` — a SHALLOW copy, which is what Pine specifies.
+     *
+     * Shallow matters: a UDT holding an array shares that array with its copy,
+     * and a script relying on the opposite would diverge from TradingView.
+     */
+    copyObject(target: any): any;
+    /**
+     * `receiver.name(args)` where `name` is a BUILT-IN method — v5's method-call
+     * syntax for the collection and drawing namespaces.
+     *
+     * `a.push(1)` and `array.push(a, 1)` are the same call in Pine, and the
+     * emitter cannot tell them apart statically: it does not track types, so it
+     * does not know whether `a` is an array, a matrix or a map. The receiver
+     * does know, at run time, so the dispatch happens here.
+     *
+     * A matrix is the one case a value cannot answer for itself — it is an
+     * array of arrays, which is also a valid array — so `matrix.new` marks its
+     * result. See `MATRIX_TAG` in runtime/v1/stdlib/matrix.ts.
+     */
+    /**
+     * Which declaration of an overloaded user function or method a call
+     * reaches, chosen from the VALUES: the emitted dispatcher's job when the
+     * types are not written down where the call is (see
+     * V5ToJsVisitor.emitOverloadDispatcher).
+     *
+     * Candidates are `[fn, min, max, declared parameter types]`. Those whose
+     * arity fits are scored by how well each argument's own type matches the
+     * declared one — a user-defined object by its `__type`, a drawing by its
+     * `__builtin`, an array by its first element, a number as int or float —
+     * and the best wins; a tie goes to the first declared.
+     */
+    pickOverload(name: string, args: any[], candidates: Array<[Function, number, number, Array<string | null>]>): Function | null;
+    /** Calls the overload a dispatcher picked, binding keyword arguments by its own parameter names. */
+    callPicked(fn: Function, args: any[], name: string): any;
+    /** Loop signals thrown across a `switch` arm's function boundary. */
+    readonly LOOP_BREAK: Readonly<{
+        loopSignal: "break";
+    }>;
+    readonly LOOP_CONTINUE: Readonly<{
+        loopSignal: "continue";
+    }>;
+    builtinMethod(id: string, receiver: any, name: string, ...args: any[]): any;
+    /**
+     * Method names only the DRAWING namespaces answer.
+     *
+     * Derived from the registry rather than listed, so a drawing member added
+     * later is covered and a name a collection also spells — `copy`, `get`,
+     * `set` — is not. Which of `line` and `box` a name belongs to does not
+     * matter here: the call is a no-op either way.
+     */
+    private static drawingOnly;
+    private static drawingOnlyMethods;
+    /** Which built-in namespace owns this value's methods, or null. */
+    private static receiverNamespace;
+    /** Looks a drawing up, or throws — a stale id is a bug, not a no-op. */
+    /**
+     * Titles of every `enum` member this script declares, keyed by the member's
+     * own value — `"OscType.rsi"` → `"Relative Strength Index"`.
+     *
+     * ── Why a member is a STRING and not an object ──────────────────────────
+     *
+     * Because `==` has to work, and the emitter emits JavaScript `==`. A script
+     * variable holds a Series, so `x == OscType.rsi` compares a Series to the
+     * member; JavaScript coerces an object against a PRIMITIVE via `valueOf`
+     * and compares two OBJECTS by reference, so a member object would have made
+     * every such comparison false — silently, on every bar.
+     *
+     * A string carries the enum name as a prefix, which keeps the rule the
+     * manual states: "Scripts cannot compare members of different enums ... even
+     * if the fields have identical names and titles." `A.up` and `B.up` are
+     * different strings.
+     *
+     * The TITLE cannot live in the member for the same reason, so it lives here
+     * — read back by `str.tostring`, which the manual calls "the only way to
+     * retrieve its title".
+     */
+    enumTitles: Map<string, string>;
+    /** Members of each enum, in declaration order — what a dropdown lists. */
+    enumMembers: Map<string, string[]>;
+    /**
+     * Records an enum declaration and returns its member table.
+     *
+     * Called once per bar from the emitted script, and idempotent: re-recording
+     * the same titles is a no-op, and the table it returns holds the same
+     * STRINGS every time, which is what makes `==` work across bars.
+     */
+    declareEnum(name: string, titles: Record<string, string>): Record<string, string>;
+    /** The title of an enum member, or undefined when the value is not one. */
+    enumTitle(value: any): string | undefined;
+    /**
+     * Every live drawing of one kind, oldest first — `polyline.all`,
+     * `linefill.all`, `label.all`.
+     *
+     * Reads the EVICTION QUEUE rather than filtering `drawings`, so the order
+     * is the one Pine documents (creation order) and deleted ids are already
+     * gone from it.
+     */
+    drawingIds(kind: Drawing["kind"]): string[];
+    /** `na`, in the sense every drawing accessor has to answer to. */
+    private static isNa;
+    /**
+     * A stand-in drawing for an `na` id: writes are discarded, reads are `na`.
+     *
+     * ── Why an na id is not an error ────────────────────────────────────────
+     *
+     * Because TradingView's own examples depend on it, on three separate pages.
+     *
+     *   `v5-concepts-lines-and-boxes-02` declares `var line periodLine = na`
+     *   and calls `line.set_color(periodLine, finalColor)` on the first period
+     *   change — before anything has been assigned to it. Its OTHER branch is
+     *   guarded with `else if not na(periodLine)`, so the author knew the value
+     *   could be absent and did not guard the branch where it always is.
+     *
+     *   `v5-language-loops-17` fills an array with `array.new<line>(20)` — 20
+     *   `na` lines — and immediately loops `for pivotLine in pivotLines`
+     *   reading `pivotLine.get_x2()`.
+     *
+     *   `v4-essential-drawings-12` and `-14` are the published Pivot Points
+     *   indicators: three `var line ... = na` declarations and a block that
+     *   moves them before the first assignment.
+     *
+     * All four ran on TradingView, so a setter on an absent drawing does
+     * nothing and a getter on one returns `na`. Modelling that here rather than
+     * at each of the forty call sites keeps `getDrawing`'s contract — "hand me
+     * the record" — and makes a STALE id still an error, which it is.
+     *
+     * Fresh each time, so a discarded write can never be read back.
+     */
+    private static naDrawing;
+    getDrawing(id: any, fn: string): Drawing;
+    is_history: boolean;
+    is_realtime: boolean;
+    is_new: boolean;
+    /** True only during a realtime bar's closing execution (`Session.commit`); see `barstate.isconfirmed`. */
+    is_confirmed: boolean;
+    is_last: boolean;
+    position: Position;
+    /** Bar timestamp by bar index — see the note where it is written. */
+    barTimes: number[];
+    /** The bar a timestamp falls on, or NaN when no bar has carried it. */
+    barIndexOfTime(time: number): number;
+    cash: number;
+    /**
+     * Host overrides for the `strategy()` / `indicator()` declaration.
+     *
+     * TradingView's settings dialog lets a user change a strategy's starting
+     * capital or pyramiding without editing the script, and a host needs the
+     * same. They are consulted by `declareScript`, which is the only moment
+     * they can take effect: `cash` moves with the first fill, so seeding it
+     * afterwards would backdate money the broker has already spent.
+     *
+     * A key absent here means "use whatever the script declared".
+     */
+    propertyOverrides: Record<string, any>;
+    /**
+     * What the SCRIPT declared, before any host override.
+     *
+     * Kept apart so a settings panel can offer "reset to the script's value"
+     * — reading it back off the Context afterwards returns the override, which
+     * would make the reset button restore the thing it was resetting from.
+     */
+    declaredProperties: Record<string, any>;
+    /**
+     * The equity the strategy started with, for `strategy.initial_capital`.
+     *
+     * Held separately from `cash`, which moves with every fill — the two are
+     * equal only until the first trade closes, and the difference between them
+     * IS the realised profit.
+     *
+     * Set from `strategy(initial_capital = ...)` by declareScript().
+     */
+    initialCapital: number;
+    trades: Trade[];
+    orders: any[];
+    /**
+     * The equity curve, one point per CLOSED bar, for strategies only.
+     *
+     * A study never opens a position, so sampling one would append a flat
+     * line of `initial_capital` to every indicator's render model.
+     */
+    equityCurve: EquityPoint[];
+    /**
+     * Excursion of the position currently open, in currency, reset when a
+     * position is opened from flat and read when it closes. Both are >= 0.
+     *
+     * Tracked on the Context rather than on the Position because they are
+     * measured across bars and the broker only ever sees one: by the time
+     * `closeAt` runs, the high the trade reached three bars ago is gone.
+     */
+    positionRunup: number;
+    positionDrawdown: number;
+    /** The largest absolute position size held at any point in the run. */
+    maxContractsHeld: number;
+    /** Commission charged across the whole run, for the performance summary. */
+    commissionPaid: number;
+    /**
+     * The first and last close the strategy saw, for the buy & hold baseline
+     * TradingView draws against the equity curve. Recorded here because the
+     * render model is built from the Context alone and the candles are the
+     * caller's.
+     */
+    firstClose: number;
+    lastClose: number;
+    /**
+     * Market orders placed on this bar, waiting for the next bar's open.
+     *
+     * `setBar` drains it; see MarketOrder in ./stdlib/strategy.ts for why a
+     * market order does not fill on the bar that places it.
+     */
+    marketOrders: MarketOrder[];
+    /** Orders filled this run: entries and exits. See `Broker.countOrder`. */
+    filledOrderCount: number;
+    /** The closed trades' profit, summed as they close, in order: `netProfit()` reads it instead of re-adding every trade. */
+    netProfitSum: number;
+    inputDefs: InputDef[];
+    userInputs: Record<string, any>;
+    private inputCounter;
+    opsv2_na: number;
+    scriptMeta: ScriptMeta | null;
+    __sandbox: any;
+    private securityData;
+    private htfStates;
+    requestedSecurities: Set<string>;
+    /**
+     * The language profile this script runs under. Drives version-dependent
+     * runtime behaviour: banned identifiers (`bar_index` vs `n`) and the
+     * security() lookahead default.
+     *
+     * profiles/ depends only on version.ts and nothing in runtime/, so this
+     * import direction introduces no cycle.
+     */
+    readonly profile: LanguageProfile;
+    constructor(profile?: LanguageProfile);
+    private initBaseSeries;
+    /**
+     * Resets the entire execution environment for a new pass.
+     * Crucially, preserves `inputDefs` and `userInputs`.
+     */
+    reset(): void;
+    /**
+     * Records the script's `study()` / `strategy()` directive metadata.
+     * Called from transpiled code; positional args are mapped to named params
+     * in directive-declaration order, with keyword args (prefix-stripped) taking
+     * precedence. Idempotent across bars.
+     */
+    declareScript(kind: ScriptKind, positional?: any[], kwargs?: Record<string, any>): void;
+    /**
+     * @param meta the input's CONSTRAINTS and grouping — `minval`, `maxval`,
+     *        `step`, `options`, `tooltip`, `inline`, `group`, `confirm`,
+     *        `display`. Recorded on the definition so a host can render the
+     *        control, and the numeric three are ENFORCED on the value below.
+     *
+     *        They used to be accepted and thrown away, on the reasoning that a
+     *        constraint the engine does not enforce is worse than no constraint.
+     *        The reasoning was right and the conclusion was not: the answer is
+     *        to enforce it. `minval` appears on seventeen of TradingView's own
+     *        examples and `options` restricts an input to a fixed set, and a
+     *        user override outside either was being taken at face value.
+     */
+    registerInput(defval: any, title?: string, type?: string, meta?: Record<string, any>): any;
+    /** `registerInput`'s last answer for each input, by its position in the run. */
+    private inputMemo;
+    /** Clamp to `minval`/`maxval` and fall back to the default outside `options`. */
+    private static constrainInput;
+    /**
+     * SMART CALL EXECUTION
+     * Handles:
+     * 1. Registry Lookup (Values vs Functions)
+     * 2. Context Injection
+     * 3. Keyword Argument Resolution (kwargs)
+     */
+    /**
+     * How the CURRENT call was written: which parameters the caller named, and
+     * how many arguments it passed positionally.
+     *
+     * `call` flattens keyword arguments into the positional array below, which
+     * is what a JavaScript function can receive — and that flattening throws
+     * away the one thing an OVERLOADED built-in needs. `line.new` has two
+     * published signatures, the registry holds one, and which slot a value
+     * belongs to depends on whether the caller wrote it as `width = 3` or as
+     * the fifth thing in the list. See `pointTail` in stdlib/drawings.ts.
+     *
+     * Set for the duration of one call and restored afterwards, so a built-in
+     * that calls another does not read its caller's shape.
+     */
+    keywordArguments: ReadonlySet<string>;
+    /** How many arguments the caller passed before any keyword. */
+    positionalArguments: number;
+    /**
+     * Resolve a trailing keyword bundle against a parameter list.
+     *
+     * The same rule the built-in path applies, over names the emitter supplies
+     * rather than names the registry does. A gap is left `undefined` so the
+     * emitted function's own JavaScript default takes over, which is how a
+     * Pine parameter default is expressed.
+     */
+    private bindKeywordArguments;
+    /**
+     * Does `fname` have a parameter called `name` at THIS version?
+     *
+     * The stdlib is one implementation across versions, so a parameter added
+     * for v6 — `active` on every input, `text_formatting` on labels — is on
+     * the shared function. V6_ONLY_PARAMS says which those are, and below v6
+     * they are treated as absent.
+     */
+    private parameterExists;
+    /**
+     * Positional arguments, re-slotted for the signature THIS version has.
+     *
+     * The stdlib keeps one signature per function, the union of every
+     * version's, and two kinds of version difference sit in the middle of one:
+     *
+     *   below v6   a parameter v6 ADDED (V6_ONLY_PARAMS). Filled by position
+     *              it is cleared, so it does what it did before it existed:
+     *              nothing. Keyword use is refused separately, in the binding
+     *              below.
+     *   at v6      a function whose v6 order differs from the shared one —
+     *              v6 removed `transp` and `when` from the middle of several.
+     *              Positional arguments are placed BY NAME from V6_POSITIONAL:
+     *              v6 `plot(close, "p", c, 2, style, false)` means trackprice =
+     *              false, not transp. A name the shared signature lacks is
+     *              dropped and recorded, like an unknown keyword.
+     */
+    private positionalForVersion;
+    call(id: string, fn: Function, ...args: any[]): any;
+    /**
+     * Pins a runtime error to the Pine source position of the call it passed
+     * through, so the host can say WHERE the script failed.
+     *
+     * Every call id carries its position -- `array.get@L45:C12`, and
+     * `array.get@L4:C14@L` for a call inside the library imported as `L` -- so
+     * the position costs nothing until something throws: this runs only on
+     * the way out, once per frame, and the first frame an error passes through
+     * is the innermost call, which is the one that raised it. It is a property
+     * of the error rather than text in its message, which other code matches.
+     *
+     * An error inside a library is located at the library's own line, and
+     * the first frame outside it -- the call in the user's own script, the
+     * line an editor can show -- is kept as `caller`.
+     *
+     * Not covered: an error raised in script code that is not inside any call
+     * (nothing the stdlib throws is), which has no position to report.
+     */
+    private locateError;
+    /**
+     * Resolves a built-in by name straight from the registry.
+     *
+     * Pine keeps functions and variables in separate namespaces, so
+     * `sma = sma(close, 10)` is legal and common. The emitted JavaScript has no
+     * such separation: `let opsv2_sma = ...` shadows the sandbox binding, and
+     * the call inside its own initialiser saw the variable (undefined) instead
+     * of the function. The transpiler routes shadowed built-in callees here.
+     */
+    /**
+     * The stdlib entry for `name` AT THIS SCRIPT'S VERSION.
+     *
+     * `REGISTRY` is deliberately the union of every version's view, so a few
+     * names carry two meanings in it and the union's last writer decides which
+     * one survives. `float`, `bool` and `string` are the v1–v3 `input()` type
+     * CONSTANTS and v4's casting FUNCTIONS; `session` is a v1–v3 constant and a
+     * v5 namespace. Reading the union directly handed a v4 script the string
+     * "float" where it had called `float(na)` — "[Context.call] ... The
+     * provided reference is not a function".
+     *
+     * This is the preference `createStdlib` already applies to the sandbox,
+     * applied to the CALL path as well. Falling back to the union keeps a name
+     * the view does not carry resolvable: the transpiler has already decided
+     * what a script may spell, and the runtime is not the place to refuse a
+     * second time.
+     */
+    private entryFor;
+    /** `entryFor`'s answers: the registries are large and the same few names are asked for on every bar. */
+    private entries;
+    builtin(name: string): any;
+    /**
+     * `and` over operands that have ALREADY been evaluated.
+     *
+     * Pine does not short-circuit, so the emitter passes every operand as an
+     * argument and lets JavaScript's own evaluation order do the work. The
+     * body is trivial on purpose: all the meaning is in the call having
+     * happened at all. See visitAnd_expr in transpiler/v1/ToJsVisitor.ts.
+     */
+    allOf(...operands: boolean[]): boolean;
+    /** `or` over operands that have already been evaluated. See `allOf`. */
+    anyOf(...operands: boolean[]): boolean;
+    /**
+     * Per call site: the bar and pass it was last reached on, and whether it
+     * has run at all. One lookup per call where there were three.
+     */
+    private siteReach;
+    /**
+     * The call sites a script is known to reach more than once on a bar. Null
+     * (the default, and always for a forming bar) takes a rollback point at
+     * every stateful site on every bar; a set takes one only at the sites in it,
+     * and `missedRepeat` reports the first site that needed one and had none.
+     *
+     * Performance: only `Session.runHistory` sets it, for the history bars,
+     * which are never re-ticked. A live or forming bar is re-ticked and rolled
+     * back at every site, so it must keep this null: `runHistoryOnce` resets it
+     * before returning, and anything else that runs bars must not set it.
+     * Guarded by tests/v1/runtime/rollback_snapshot_work.test.ts. See
+     * docs/common/ARCHITECTURE.md ("Performance invariants").
+     */
+    repeatingSites: Set<string> | null;
+    /** The site that was reached again on a bar with no rollback point; see `repeatingSites`. */
+    missedRepeat: string | null;
+    /** Counts passes over a bar: `forgetBarProgress` starts a new one. */
+    private barPass;
+    /**
+     * Call sites that own series state, learned the first time one asks for it.
+     *
+     * A site that has run and never asked — `hl2`, `math.abs`, `array.get` —
+     * has nothing to roll back, so it is skipped entirely. Without this every
+     * stateless call took the snapshot path on every bar.
+     */
+    private statefulSites;
+    /**
+     * State keys at or beneath each call site, so a rollback does not have to
+     * scan every state in the run to find the handful it owns.
+     *
+     * A built-in may call another through `ctx.call` — `ta.stoch` delegates to
+     * `ta.highest` — and the nested state hangs below the outer site's key, so
+     * rolling the outer one back has to take the inner ones with it.
+     */
+    private stateKeysBySite;
+    /** State keys already indexed in `stateKeysBySite`. */
+    private indexedStateKeys;
+    /**
+     * Rollback points for the sites in `repeatableCalls`, taken at their first
+     * reach of the bar, and dropped by `forgetBarProgress` when the bar moves
+     * on or is re-run. The per-entry `bar` is still checked, because a host
+     * may drive the stdlib directly and never call `setBar` at all.
+     *
+     * ── One slot per BAR, not one per call ─────────────────────────────────
+     *
+     * A series function's history has one slot per bar. Reaching its call site
+     * again on the same bar OVERWRITES that bar's slot rather than appending a
+     * second one, and the value returned is the one including whatever was
+     * just written. Earlier bars keep whatever their LAST reach wrote.
+     *
+     * That one rule accounts for every loop probe TradingView has answered:
+     *
+     *   - Same arguments every reach (the loops export): each reach writes the
+     *     same value into the same slot, so all three reads agree and
+     *     `loopEma / 3` equals a plain `ta.ema(close, 10)` on all 2,475 bars.
+     *   - Different arguments (the loopargs export): each reach overwrites,
+     *     and the three reads differ. Replaying this rule against that export
+     *     reproduces TradingView on all 2,464 bars it reports, na-parity
+     *     included — where "the first reach wins", "the last reach wins" and
+     *     "each reach keeps its own history" each miss every single bar.
+     *   - Never reached at all: nothing is written, so the history does not
+     *     advance and the site goes STALE. `probe_call_inside_if` and
+     *     `probe_ternary_both_arms` both confirm that, and it is why this is
+     *     not symmetric with the two cases above.
+     *
+     * Overwriting is implemented as rollback-and-rerun, which is the same
+     * thing from the outside and does not require every stateful built-in to
+     * grow a re-entry path of its own.
+     *
+     * Which sites get one, and why not all of them, is at the call site in
+     * `call()`.
+     */
+    private barStateSnapshot;
+    /**
+     * Forgets everything scoped to ONE PASS over the current bar.
+     *
+     * Called at the top of `setBar`, which covers every bar and every re-tick
+     * of a forming one, and again from `restoreSnapshot` so that rolling back
+     * to a baseline restores this too. "One pass" includes the script's own
+     * execution-order counters, not just the broker's bookkeeping.
+     *
+     * The two order guards are the subtle half. They are NOT part of
+     * `captureSnapshot`, so a rollback restored the broker's position and its
+     * pending orders while leaving the guards saying "already done for this
+     * bar". Tick 2 then skipped both the market fills and the pending-order
+     * matching, and the script saw a position that had already been closed.
+     *
+     * `repeatableCalls` deliberately survives: which sites repeat is learned
+     * about the SCRIPT, not about the bar.
+     */
+    private forgetBarProgress;
+    /** Every state entry belonging to `key` or nested beneath it. */
+    private collectCallState;
+    /** Remembers `key`'s state so a later reach on this bar can undo its own. */
+    private snapshotCallState;
+    /** Puts `key` back as it was at the start of the bar. */
+    private restoreCallState;
+    getPersistentState<T>(initFn: () => T): T;
+    /** Declaration sites whose initialiser has already run, keyed by @L:C. */
+    private varInitialised;
+    /** Series declared `varip`, exempt from intra-bar rollback. */
+    private varipSeries;
+    /** Every series declared `var` or `varip`, by scoped name: what drawing eviction treats as a holder. */
+    private varSeries;
+    /**
+     * `var x = expr` — initialise ONCE, then persist across bars.
+     *
+     * The initialiser is passed as a thunk, not a value: `var x = expr` must not
+     * evaluate `expr` after the first bar. Passing the value would evaluate it
+     * every bar and throw the result away, which is invisible for `0.0` and
+     * quite visible for `var count = count + 1` or anything with a side effect.
+     *
+     * Persistence re-stamps the LAST value onto the current bar, read from
+     * `valueOf()` rather than `get(1)`. The two differ exactly when the variable
+     * was last written on an earlier bar than the previous one — a `var` inside
+     * a conditional block — where `get(1)` finds a hole and returns NaN while
+     * `valueOf()` returns the value that is actually still held. Pine persists
+     * the value, so `valueOf()` is the right question.
+     *
+     * Re-stamping every bar is also what makes `:=` work unchanged: it writes
+     * the current bar's slot through `new_var`, and the next bar carries that
+     * forward. No write-back path and no coupling to the assignment emitter.
+     *
+     * @param key  the declaration's @L<line>:C<col> site, so two DIFFERENT
+     *             `var` declarations do not share an initialised flag.
+     *
+     * ── `var` inside a user function ────────────────────────────────────────
+     *
+     * Every call site gets its OWN `var`, which is what Pine does — "each
+     * function call has its own instance of the series variables". Given
+     *
+     *     f() =>
+     *         var c = 0
+     *         c := c + 1
+     *         c
+     *     a = f()
+     *     b = f()
+     *
+     * both `a` and `b` count 1,2,3.
+     *
+     * This was wrong for a long time, and the note that stood here explained
+     * why keying the initialised flag on the call stack was not enough: the
+     * SERIES NAME was shared too, so per-site flags only redistributed the
+     * error. Both halves are now in place — `seriesScope` gives each frame its
+     * own namespace in `vars`, and this method scopes the flag into the same
+     * namespace — so `key` alone is the declaration SITE and the frame supplies
+     * the instance.
+     *
+     * `varipSeries` is scoped with them, so a `varip x` in one frame and a
+     * `var x` in another are no longer one series and no longer share an
+     * exemption from rollback.
+     */
+    var_def(name: string, key: string, initFn: () => any, ip?: boolean): Series;
+    /**
+     * Pine truthiness, for anything used as a CONDITION.
+     *
+     * ── Why this exists ─────────────────────────────────────────────────────
+     *
+     * `new_var` returns a Series, and in JavaScript EVERY object is truthy. So
+     * a condition stored in a variable was permanently true:
+     *
+     *     up = close > open        // a Series wrapping true/false
+     *     plot(up ? 1 : 0)         // 1 on every bar, forever
+     *
+     * Relational operators hid it — `close > open` coerces through valueOf() and
+     * works — but `?:`, `if`, `and`, `or` and `not` use ToBoolean, which does not
+     * consult valueOf(). Naming a condition and reusing it is how nearly every
+     * published script is written, so every branch in them was taken.
+     *
+     * The corpus suite could not see this: a script whose conditions are all
+     * true still runs and still plots finite numbers.
+     *
+     * ── The rule ────────────────────────────────────────────────────────────
+     *
+     * Unwrap first, then apply Pine's own conversion: `na` is false, 0 is false,
+     * any other number is true. v1–v3 coerce numbers to bool freely (`isSunday()
+     * and openPrice ? ...` is published v1), so this must accept numbers rather
+     * than demand a bool.
+     */
+    truthy(v: any): boolean;
+    /**
+     * FACTORY: Creates or Updates a Series Object.
+     */
+    new_var(name: string, val: any): Series;
+    /**
+     * `new_var` for the series behind a history reference on an expression,
+     * `(close + 0)[3]`: bar-indexed, carrying its last value over the bars the
+     * expression was not evaluated on. See `Series.updateCarry`.
+     */
+    new_anon(name: string, val: any): Series;
+    /**
+     * FACTORY (Tuple): Handles assignments like [a, b] = func()
+     */
+    new_vars(names: string[], values: any): Series[];
+    /**
+     * `for … in` — one iteration handle over an array, matrix or map.
+     *
+     * Yields `[key, value]` pairs. What those mean is the collection's business,
+     * and the manual states each one:
+     *
+     *   array   "item ... holds sequential values or references from the
+     *            specified collection_id" and index is "the index ... of the
+     *            retrieved item"
+     *   matrix  the item is a ROW array, and the index is "the row's position
+     *            within the matrix"
+     *   map     "the index contains the key, and item contains the associated
+     *            value from each key-value pair"
+     *
+     * A matrix is represented as an array of row arrays, so it needs no branch
+     * of its own here: iterating an array of rows already yields rows.
+     *
+     * ── The size rule is different for maps, so the code is too ──────────────
+     *
+     * "Scripts can modify the sizes of arrays and matrices directly within a
+     *  for…in loop's local scope. When a for…in loop changes the size of a
+     *  collection during an iteration, the loop's header uses the UPDATED size
+     *  to control subsequent iterations."
+     *
+     * That is why the array branch re-reads `.length` every step instead of
+     * capturing it once. A snapshot would run past the end of a shrunk array
+     * and stop short of a grown one.
+     *
+     * "Attempting to add or remove a map's key-value pairs while looping
+     *  through it with this structure typically causes a runtime error."
+     *
+     * So the map branch does the opposite: it takes the keys once and then
+     * REFUSES a size change, rather than silently iterating a stale key list.
+     * `arity` is how many loop variables the script wrote, which is what makes
+     * the single-variable form on a map reportable — the manual's second form
+     * is the only one maps accept.
+     */
+    forIn(collection: any, arity: number, at: string): Generator<[any, any]>;
+    /**
+     * Universal History Accessor (Called by transpiled code: [])
+     */
+    get(target: any, offset: number, id: string): number;
+    /**
+     * A user variable declared OUTSIDE the running function: not one of its own
+     * locals (their ids carry the frame's scope) and not a built-in series.
+     */
+    private isOuterUserSeries;
+    /**
+     * `v[n]` on a variable from outside the running function. TradingView keeps
+     * a history of it per CALL SITE, recorded only when that call runs
+     * (Pine Logs, dev-docs/tv-parity/_probes/fn-history): `[n]` is its value at
+     * the n-th previous call of this site, not on the n-th previous bar. Before
+     * that many calls it is na. The probe's first calls (bars 0, 0) log na, and
+     * the next ones read the value the variable had at those first calls.
+     */
+    private callSiteHistory;
+    /** The series registered under `name`, this frame's instance first. */
+    private findSeries;
+    /**
+     * Internal helper for fallback lookups
+     */
+    getSeries(name: string, offset: number): number;
+    setBar(time: number, open: number, high: number, low: number, close: number, volume: number, deferFills?: boolean): void;
+    /** Whether the script asked to be re-run after each order fill. */
+    get calcOnOrderFills(): boolean;
+    /**
+     * Set while a bar is being replayed for `calc_on_order_fills`: how far along
+     * the bar's price path (segment index plus the share of it covered) the
+     * last fill was, and the price there. Null otherwise.
+     */
+    intrabar: {
+        cursor: number;
+        price: number;
+    } | null;
+    /** The most times one bar is re-run after fills; TradingView's own limit is unknown. */
+    private static readonly MAX_FILL_RERUNS;
+    /**
+     * Runs one historical bar of a `calc_on_order_fills` strategy.
+     *
+     * Each fill, in the order it happens along the bar's path, re-runs the
+     * script on the whole bar with `var` and series state put back to the bar's
+     * start (as a realtime tick does; `varip` keeps its value), while the broker
+     * keeps what filled. A market order the re-run places fills at once at the
+     * price of the fill that triggered it, and a limit or stop order it places
+     * can fill later on the same bar. The ordinary run comes last, and its
+     * effects are what the next bar sees. Verified on TradingView's probe
+     * calc-on-fills (dev-docs/tv-parity/_probes/calc-on-fills) and the 12/26-IT
+     * strategy (ENGINE-BUGS.md section 1).
+     */
+    runBarWithFills(time: number, open: number, high: number, low: number, close: number, volume: number, exec: () => void): void;
+    /** The bar `fillMarketOrders` last ran on, so a re-tick does not refill. */
+    private _marketOrdersFilledBar;
+    /**
+     * Registers a pre-built PlotData object for the current bar.
+     * Each ui.ts function constructs the correctly-typed variant.
+     */
+    /**
+     * Strip the runtime wrapper off every field of a plot or fill record.
+     *
+     * `f = plot(...)` compiles to `ctx.new_var(...)`, so the plot id a script
+     * hands to `fill()` arrives as a `Series`, not a string — and a `Series`
+     * holds a back-reference to this Context, which holds the sandbox, which
+     * holds every stdlib function. Storing one put the entire runtime inside
+     * the render model: `structuredClone` threw, so `postMessage` threw, so
+     * every script using `fill()` failed in any host that runs the engine in a
+     * Worker or a backend — which is the architecture the integration guide
+     * documents. The values were all correct; the model just could not leave
+     * the process it was built in.
+     *
+     * The same applies to `plot(close, color = myColorVar)`, where the colour
+     * is a declared variable rather than a literal.
+     */
+    private plainPlotData;
+    registerPlot(data: PlotData): void;
+    registerFill(id1: any, id2: any, options?: {
+        color?: string;
+        title?: string;
+        [k: string]: any;
+    }): void;
+    finalizeBar(): void;
+    /**
+     * Records one equity point and advances the open position's excursion.
+     *
+     * Run at the END of a bar, after the script and the broker have both had
+     * it: an entry placed on this bar is already in `position`, and the high
+     * and low of the bar it filled on count towards its run-up, which is what
+     * TradingView reports.
+     */
+    /**
+     * Mark-to-market on the open position, at a price the caller names.
+     *
+     * One formula, three callers: the equity curve samples it at each bar's
+     * close, `strategy.equity()` answers with it, and the performance report
+     * takes it at the last close. All three had their own copy, so a change
+     * to any of them — deducting the entry commission, say — would have
+     * landed in one place and quietly disagreed with the other two.
+     *
+     * The price is a parameter rather than read from the Context because the
+     * report deliberately uses `lastClose` and the other two use `close`.
+     */
+    openProfitAt(price: number): number;
+    /**
+     * What one unit of the symbol's currency is worth in the strategy's
+     * currency (`strategy(currency = ...)`) on this bar: the latest sample of
+     * the host's `currency_rate` series at or before the bar's time. 1 when the
+     * script asked for no other currency, or the host supplied no series, so
+     * nothing converts and nothing throws.
+     *
+     * TradingView converts each closed trade at the exit bar's rate
+     * (_probes/currency-usd-1btc). Open profit converted at the current bar's
+     * rate, and sizing (percent_of_equity, cash qty) left unconverted, are
+     * unverified against TradingView.
+     */
+    accountRate(): number;
+    private sampleEquity;
+    /**
+     * Applies a real-time tick to the forming (last) bar, per the control
+     * protocol §7. The candle is an ABSOLUTE snapshot of the forming bar, not an
+     * increment. On the first tick of a bar we capture the committed baseline; on
+     * every later tick we roll back to it first, so re-evaluation never
+     * double-counts accumulating state (e.g. `cum`, EMA `prev`, broker orders).
+     *
+     * The caller runs the compiled script after this, then reads provisional
+     * output. Finalize with `commitBar()` when the bar closes.
+     */
+    /**
+     * `barstate.isnew` / `isconfirmed` follow TradingView's realtime bar states, and `Session.commit`
+     * runs the closing execution. Probed on v5 (rt-confirmed-v5) and v6 (rt-semantics-v6,
+     * rt-confirmed-v6); v1-v4 keep the older reading (isnew always true, isconfirmed = not realtime).
+     */
+    get realtimeBarStates(): boolean;
+    applyTick(time: number, open: number, high: number, low: number, close: number, volume: number): void;
+    /**
+     * Commits the forming bar permanently and advances. After this the next
+     * `applyTick` re-captures a fresh baseline for the new forming bar.
+     */
+    commitBar(): void;
+    /** A rollback point for a sub-context (see `request.security_lower_tf`): opaque to the caller. */
+    checkpoint(): unknown;
+    /** Rolls this context back to a `checkpoint()`. */
+    rollbackTo(cp: unknown): void;
+    private captureSnapshot;
+    private restoreSnapshot;
+    private secKey;
+    /** Supplies HTF candles for a (symbol, resolution); called by the session layer. */
+    provideSecurityData(symbol: string, resolution: string, candles: SecurityCandle[]): void;
+    /**
+     * Seeded pseudo-random state, one stream per seed.
+     *
+     * Held on the Context rather than in the stdlib module so that two Contexts
+     * — a backtest and a re-run of it — do not share a stream, and so that
+     * `reset()` restarts the sequence. A seeded run that changed its numbers
+     * because something else had drawn from the generator first would not be
+     * reproducible, which is the only thing a seed is for.
+     */
+    private randomStreams;
+    /**
+     * The next number in the stream for `seed`, in [0, 1).
+     *
+     * mulberry32 — small, fast, and with a period far beyond any chart. NOT
+     * TradingView's generator, which is unpublished; see `math.random`.
+     */
+    seededRandom(seed: number): number;
+    /**
+     * Timestamped samples for `request.financial` / `.dividends` / `.splits` /
+     * `.earnings` / `.quandl`, keyed by kind and by the arguments that select a
+     * series.
+     *
+     * Supplied by the host, like `securityData` above and for the same reason:
+     * this engine has no connection to TradingView, and a request it cannot
+     * answer must be refused rather than resolved to `na`.
+     */
+    private requestData;
+    /**
+     * Supplies one non-price series.
+     *
+     * `key` is what runtime/v1/stdlib/request.ts builds from the call's
+     * arguments — `"NASDAQ:AAPL|TOTAL_REVENUE|FQ"`. Samples are sorted here, so
+     * a host may provide them in any order.
+     */
+    provideRequestData(kind: string, key: string, samples: RequestSample[]): void;
+    getRequestData(kind: string, key: string): RequestSample[] | undefined;
+    /** The chart's own bars, as they arrive. The basis of a derived request. */
+    private chartBars;
+    /**
+     * The history run's whole dataset, set by `Session.runHistory`: only the TIMES
+     * of the bars after the current one are read, to tell where a session or a
+     * higher-timeframe bar ends. No price is ever taken from it.
+     */
+    chartAhead: readonly {
+        time: number;
+    }[] | null;
+    /** Derived higher-timeframe series, keyed by resolution, extended as bars arrive. */
+    private derivedSeries;
+    /** Heikin-Ashi transforms of a request's candles, keyed like `securityData`. */
+    private heikinAshi;
+    /**
+     * Does `symbol` name the chart's OWN instrument?
+     *
+     * `request.security(syminfo.tickerid, …)` is how nearly every published
+     * script asks for a higher timeframe of what it is already looking at, and
+     * `syminfo.tickerid` is the exchange-qualified spelling of the same thing
+     * `syminfo.ticker` gives bare. An empty symbol means the chart's too.
+     */
+    private isChartSymbol;
+    /**
+     * `request.security()` on the chart's own symbol, at the chart's timeframe
+     * or a higher one, answered from the chart's own bars.
+     *
+     * ── Why this is exact and not an approximation ──────────────────────────
+     *
+     * A higher-timeframe bar IS the aggregate of the chart bars inside it: it
+     * opens where the first one opened, closes where the last one closed, spans
+     * their extremes and carries their total volume. That is the relationship
+     * between the two series, not a model of it. TradingView builds its own
+     * weekly candles from the same daily feed.
+     *
+     * Before this, `request.security(syminfo.tickerid, "D", close)` on a daily
+     * chart returned `na` — the most basic call there is, silently empty on
+     * every bar, in twenty-five of TradingView's own examples.
+     *
+     * ── What is still refused ───────────────────────────────────────────────
+     *
+     * A LOWER timeframe, and any other symbol. The manual is explicit about the
+     * first: request.security() on a lower timeframe "will evaluate the
+     * expression from the LTF context", and there is no LTF context to evaluate
+     * it in — the intrabar prices are not in the data. Both keep returning `na`
+     * and recording the request, so a host that HAS the data can supply it.
+     *
+     * ── Causality ───────────────────────────────────────────────────────────
+     *
+     * Only bars the script has already seen are folded. Aggregating the whole
+     * dataset would hand the script the future: the group containing the
+     * current bar would close before its last bar had arrived. `security()`
+     * then applies its own closed-bar rule on top of a series that is already
+     * causal.
+     */
+    private deriveSecurityData;
+    /**
+     * Is this request just the chart's own series, under another name?
+     *
+     * True only for a DERIVED series at the chart's own timeframe — the same
+     * symbol, no host data, and a resolution that folds one chart bar into one
+     * requested bar. Then the requested bar and the chart bar ARE the same bar,
+     * and there is no closed-bar rule to apply: `request.security(
+     * syminfo.tickerid, timeframe.period, close)` is the current close.
+     *
+     * Host-supplied data is never this, even at a matching label. A host may
+     * hand over any series it likes under the name "D", and the conservative
+     * closed-bar rule is the right default for something this engine cannot see
+     * inside.
+     */
+    isOwnChartSeries(symbol: string, resolution: string): boolean;
+    /**
+     * Where a request's history starts: always the first bar. `calc_bars_count`
+     * ("the maximum number of recent historical bars the function can request")
+     * is accepted and has NO observable effect, which TradingView's own log
+     * shows (conformance/v5/parity/harness_security_cbc, BTCUSDT 5m, 5,464 bars):
+     * `request.security("60", bar_index, calc_bars_count = 50)` equals the same
+     * call without it on every row, and `ta.cum(1)` inside it is 6984 at chart
+     * bar 0; `security_lower_tf("1", bar_index, calc_bars_count = 200)` likewise
+     * equals the call without it. 50 and 200 limited nothing.
+     *
+     * (A data-supply fact for hosts, not a broker rule: the hourly context's
+     * history starts long before the chart's first bar, with 6,983 hourly bars
+     * ahead of it there, while the 1-minute lower-timeframe context starts at the
+     * chart's first bar.)
+     */
+    securityFirstBar(_symbol: string, _resolution: string, _calcBarsCount: any, _fname: string): number;
+    getSecurityData(symbol: string, resolution: string, lookaheadOn?: boolean): SecurityCandle[] | undefined;
+    /** Records a (symbol, resolution) the script needs but hasn't been given. */
+    requestSecurity(symbol: string, resolution: string): void;
+    /**
+     * The chart's context, for a sub-context that evaluates a requested
+     * expression; null on the chart's own. `syminfo.main_tickerid` and
+     * `timeframe.main_period` read it.
+     */
+    main: Context | null;
+    /**
+     * A context to evaluate a `request.security` expression in: the requested
+     * timeframe and symbol, and the chart's symbol facts when it is the
+     * chart's symbol — `timeframe.period` inside the request is "5" for a
+     * 5-minute request, as TradingView logs it, where a bare context said "1D".
+     */
+    securitySubContext(symbol: string, resolution: string): Context;
+    /** Stable key for the current call site (used for per-`security()` HTF state). */
+    currentCallKey(): string;
+    /** Per-call-site HTF state, exempt from live-tick snapshot/rollback. */
+    getHtfState<T>(key: string, initFn: () => T): T;
+    /**
+     * Evaluates a deferred `security()` expression for one HTF bar inside a
+     * sub-context, by rebinding the VM's global series (open/high/.../close) and
+     * `ctx` to the sub-context for the duration of the thunk. Restores on exit.
+     */
+    evalSecurityBar(sub: Context, bar: SecurityCandle, thunk: () => any, provisional?: boolean): any;
+}
+export {};