openpinescript 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,32 @@
+/**
+ * Footprint construction for `request.footprint()` — the rows, POC, Value Area
+ * and imbalances, from the volume-per-level a host supplies.
+ *
+ * Outside stdlib/ deliberately: every export of a stdlib module is published
+ * as a Pine built-in, and this is a helper. The documented rules, and the
+ * undocumented choices made here, are listed in ./stdlib/footprint.ts.
+ */
+/** One price level as the host supplies it. */
+export interface FootprintLevel {
+    price: number;
+    buy: number;
+    sell: number;
+}
+export interface Row {
+    __builtin: "volume_row";
+    down: number;
+    up: number;
+    buy: number;
+    sell: number;
+    buyImbalance: boolean;
+    sellImbalance: boolean;
+}
+export interface Footprint {
+    __builtin: "footprint";
+    rows: Row[];
+    poc: Row;
+    vah: Row;
+    val: Row;
+}
+/** Groups levels into rows and derives the footprint, or null when empty. */
+export declare function buildFootprint(levels: readonly FootprintLevel[], rowSize: number, vaPercent: number, imbalancePercent: number): Footprint | null;

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

@@ -0,0 +1,7 @@
+import { Context } from "./context.js";
+export { Context };
+export declare function run(jsCode: string, ctx: Context, sandbox: any): any;
+export declare function compile(jsCode: string, ctx: Context, sandbox: any): () => any;
+export { Session, runScript, buildRenderModel, PROTOCOL_VERSION, ENGINE_VERSION } from "./session.js";
+export type { Compiled, SimResult, RenderSeries, RenderDelta, EngineError, InputView, Candle, ChartSettings, RunOptions } from "./session.js";
+export type { Drawing, LogEntry, PlotData, FillData, ScriptMeta, SecurityCandle, InputDef, Trade, Position } from "./context.js";

package/dist/types/runtime/v1/language-spec.d.ts

@@ -0,0 +1,12 @@
+import type { PineVersion } from "../../transpiler/common/version.js";
+export interface LanguageSpec {
+    version: PineVersion;
+    /** Reserved words this version recognises, cumulative. */
+    keywords: string[];
+    /** Every built-in name, including dotted members like `ta.sma`. */
+    builtins: string[];
+    /** The leading segment of every dotted name — `ta`, `strategy`, `color`. */
+    namespaces: string[];
+}
+/** What `version` knows. Sorted, so the output is stable to diff. */
+export declare function languageSpec(version: PineVersion): LanguageSpec;

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

@@ -0,0 +1,12 @@
+/**
+ * The open trades: one per filled entry that has not been fully closed.
+ *
+ * `strategy.opentrades` is their count and `strategy.opentrades.*(n)` index
+ * the same list, oldest first, so both read it from here. It is the broker's
+ * `position.entries`; a position with no entries recorded (one a test or a
+ * host built by hand) is a single trade described by the position itself.
+ *
+ * Lives outside ./stdlib/ because every export there becomes a Pine built-in.
+ */
+import type { Context, OpenEntry } from "./context.js";
+export declare function openTrades(ctx: Context): readonly OpenEntry[];

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

@@ -0,0 +1,18 @@
+/**
+ * runtime/v1/palette.ts
+ * Colour defaults that depend on the script's version. Lives outside stdlib/ so
+ * it is not mistaken for a function scripts can call.
+ */
+import type { Context } from "./context.js";
+/**
+ * A default that Pine documents as a colour constant (`color = color.blue`,
+ * `textcolor = color.black`), in the PALETTE OF THE SCRIPT'S OWN VERSION.
+ * every version carries its own profile palette (v4 blue #2196F3, v5/v6 blue
+ * #2962FF, v5 black #363A45, v1–v3 pure RGB), core.ts's values being only a fallback, exactly as a script's own
+ * `color.blue` resolves — see createStdlib in stdlib/index.ts.
+ *
+ * Evidence for v5: TradingView drew `label.new(x, y, "default colours", style =
+ * label.style_label_down)` with a #2962FF bubble and dark text (OpenChartingView
+ * e2e/tradingview-drawings/page2.png, targets.json "default colours").
+ */
+export declare function paletteColor(ctx: Context, name: "blue" | "black" | "white"): string;

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

@@ -0,0 +1,482 @@
+import type { PineVersion } from "../../transpiler/common/version.js";
+import type { Context as Ctx, ScriptMeta, SecurityCandle, Drawing, LogEntry, Position, EquityPoint } from "./context.js";
+export declare const PROTOCOL_VERSION = 1;
+export declare const ENGINE_VERSION: "v2";
+export interface EngineError {
+    phase: "parse" | "transpile" | "runtime";
+    /**
+     * The Pine source line and column, 1-based line and 0-based column as the
+     * compile errors report them. For a runtime error, where the call that
+     * raised it is; absent when the error was raised outside any call.
+     */
+    line?: number;
+    col?: number;
+    /**
+     * Set when a runtime error was raised inside an imported library: its
+     * alias, and the library's own line and column. `line` and `col` then
+     * name the call in the user's script that led there.
+     */
+    library?: {
+        alias: string;
+        line: number;
+        col: number;
+    };
+    message: string;
+    /** For a runtime error from `runHistory`: the bar (0-based index) it was raised on. */
+    bar?: number;
+    /** The parser's own text, when `message` was rewritten to say what is wrong. */
+    detail?: string;
+    severity: "error" | "warning";
+}
+export interface InputView {
+    id: string;
+    title: string;
+    type: string;
+    default: any;
+    current: any;
+    overridden: boolean;
+    /**
+     * The rest of what `input()` was told, so a host can build the control the
+     * script asked for rather than guessing one from the type.
+     *
+     * `input.int(14, "Length", minval = 2, maxval = 50)` is a bounded spinner;
+     * `input.string(s, options = [...])` is a dropdown and nothing else will
+     * do. The engine has always recorded these — it clamps `minval` and falls
+     * back outside `options` — and simply did not pass them on, so every host
+     * rendered a bare text box and learnt the bounds by having its value
+     * silently changed underneath it.
+     */
+    minval?: number;
+    maxval?: number;
+    step?: number;
+    options?: any[];
+    tooltip?: string;
+    /** `group` and `inline` lay the dialog out; they carry no value. */
+    group?: string;
+    inline?: string;
+    confirm?: boolean;
+}
+/** A `strategy()` / `indicator()` argument a host may override. */
+export interface PropertyView {
+    key: string;
+    title: string;
+    type: "float" | "integer" | "string";
+    current: number | string;
+    declared: number | string;
+    /** The only values a string property accepts, for a dropdown. */
+    options?: string[];
+    /** A unit to show beside the control — "%", "ticks", "contracts". */
+    unit?: string;
+    minval?: number;
+    /** Which block of TradingView's properties tab the row belongs to. */
+    group?: string;
+}
+export interface Compiled {
+    protocolVersion: number;
+    engineVersion: typeof ENGINE_VERSION;
+    meta: ScriptMeta | null;
+    inputs: InputView[];
+    /** Declaration arguments a host may override; empty for a study. */
+    properties: PropertyView[];
+    errors: EngineError[];
+}
+type SeriesType = "line" | "candle" | "marker" | "arrow" | "bgcolor" | "barcolor";
+/**
+ * One drawable point. `color` is present only where the script set a DIFFERENT
+ * colour on that bar than the series default — `plot(close, color = close >
+ * open ? green : red)` is ordinary Pine, and a per-series colour cannot express
+ * it. A host that ignores the field still draws the right shape in the series
+ * colour; one that reads it draws what TradingView draws.
+ */
+export type RenderPoint = {
+    value: number;
+    color?: string;
+} | {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    color?: string;
+} | {
+    color: string;
+} | null;
+export interface RenderSeries {
+    id: string;
+    title: string;
+    type: SeriesType;
+    pane: "main" | "sub";
+    timeframe?: string;
+    color?: string;
+    style?: string | number;
+    linewidth?: number;
+    /**
+     * Where a marker sits: `abovebar`, `belowbar`, `top`, `bottom` or
+     * `absolute` — `plotshape`'s own `location` argument. Absent for every
+     * other series type. Without it a host cannot place a shape, because the
+     * `value` of `plotshape(close > open)` is 1, not a price.
+     */
+    location?: string;
+    /** `plotshape`/`plotchar` text, and its size, when the script set them. */
+    text?: string;
+    size?: string;
+    /**
+     * Colour of a marker's text. `plotshape`/`plotchar` `textcolor`, or
+     * TradingView's default `color.blue` in the script's own palette when the
+     * script gave none (TradingView drew plotshape text with no textcolor in
+     * #2962FF on v5; OpenChartingView e2e/tradingview-drawings/page3.png).
+     * Present on marker series only.
+     */
+    textcolor?: string;
+    /**
+     * The `offset` the script gave `plot`/`plotshape`/`plotchar`, in bars
+     * (negative = left). Present only when it is non-zero.
+     *
+     * INFORMATIONAL: `data` is already shifted. The value computed on bar `n`
+     * sits at index `n + offset`, so a negative offset leaves the last
+     * |offset| entries null and a positive one extends `data` past the last
+     * bar. A host draws `data[i]` at bar `i` and must not shift it again.
+     */
+    offset?: number;
+    data: RenderPoint[];
+}
+export interface SimResult {
+    protocolVersion: number;
+    engineVersion: typeof ENGINE_VERSION;
+    meta: ScriptMeta | null;
+    barsProcessed: number;
+    series: RenderSeries[];
+    fills: Array<{
+        plotId1: string;
+        plotId2: string;
+        color: string;
+        title: string;
+        /**
+         * The fill's colour BAR BY BAR, present only when the script gave it
+         * more than one.
+         *
+         * `fill(a, b, color = spanA > spanB ? green : red)` is how every
+         * Ichimoku cloud is written, and a fill carrying one colour cannot
+         * express it — the model reported whichever colour happened to come
+         * first and the cloud drew in that one colour for the whole chart.
+         * `null` at a bar means the fill is not drawn there.
+         */
+        colors?: Array<string | null>;
+        /**
+         * `fill(show_last = N)`: the fill covers only the last N bars. Already
+         * applied to `colors`, where every earlier bar is `null`; present for
+         * a host that wants the number.
+         */
+        showLast?: number;
+        /**
+         * The gradient overload, `fill(a, b, top_value, bottom_value, top_color,
+         * bottom_color)`: a vertical gradient between the two plots, `top_color`
+         * at the price `top_value` and `bottom_color` at `bottom_value`, each
+         * bar's own. The arrays are per bar, `null` where the fill is not
+         * drawn. `color` means nothing on a gradient fill.
+         */
+        gradient?: true;
+        topValues?: Array<number | null>;
+        bottomValues?: Array<number | null>;
+        topColors?: Array<string | null>;
+        bottomColors?: Array<string | null>;
+    }>;
+    trades: any[];
+    /**
+     * The position still OPEN at the last bar, which `trades` by definition
+     * does not contain — it holds closed trades only. A strategy that is in
+     * the market when the data ends has an entry a host should still draw.
+     * `size` is 0 while flat.
+     */
+    position: Position;
+    summary: {
+        netProfit: number;
+        closedTrades: number;
+        winRate: number;
+    } | null;
+    /**
+     * The full performance report, split all / long / short — the rows of
+     * TradingView's performance summary tab. Null for a study.
+     */
+    performance: Performance | null;
+    /**
+     * Account value at every bar's close, which is what the overview tab
+     * plots. Empty for a study.
+     */
+    equity: EquityPoint[];
+    /**
+     * Every `line`, `box`, `label`, `table`, `polyline` and `linefill` the
+     * script created, in creation order, with the bar each was created on.
+     *
+     * A host draws these itself — they are objects with coordinates, not a
+     * series with one value per bar, so they cannot be expressed as a
+     * `RenderSeries`. `props` carries the drawing's own fields verbatim
+     * (`x1`/`y1`/`x2`/`y2` for a line, `text`/`style`/`color` for a label).
+     */
+    drawings: Drawing[];
+    /**
+     * Everything the script wrote with `log.info` / `log.warning` /
+     * `log.error`, each tagged with the bar and timestamp it was emitted on so
+     * a host can align it to the chart.
+     */
+    logs: LogEntry[];
+    alerts: any[];
+    errors: EngineError[];
+    /**
+     * Arguments the script passed that this engine does not implement, and so
+     * ignored, as `"function(parameter)"` -- `"fill(display)"`. Empty when the
+     * run honoured everything it was given. A host can say so beside a result
+     * that differs from TradingView's.
+     */
+    droppedArguments: string[];
+    /**
+     * Things the host got wrong or left unsaid that change what the script
+     * computed, in words a person can act on. Empty when there are none.
+     * Today: the chart's timeframe and symbol were never set (`Session.setChart`),
+     * and a `request.security` / `security_lower_tf` for data the host never
+     * supplied (`Session.provideData`), one note per symbol and timeframe.
+     */
+    warnings: string[];
+}
+export interface RenderDelta {
+    barIndex: number;
+    time: number;
+    provisional: true;
+    series: Array<{
+        id: string;
+        value?: number;
+        ohlc?: [number, number, number, number];
+        color?: string;
+    }>;
+}
+export interface Candle {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+/** Options for `Session.runHistory`. */
+export interface RunOptions {
+    /**
+     * Called as the run advances: `done` bars of `total` have been processed.
+     * Roughly every 1% of the bars, and once more at the end. A callback that
+     * throws is ignored: a host's progress display cannot fail the run. With
+     * no callback the run does nothing extra.
+     */
+    onProgress?: (done: number, total: number) => void;
+}
+/**
+ * One column of TradingView's performance summary, which reports every figure
+ * three times: over all trades, over the long ones and over the short ones.
+ *
+ * Where TradingView publishes a definition this follows it:
+ *
+ *   Profit factor   gross profit / gross loss
+ *   Max drawdown    the largest peak-to-trough decline
+ *   % profitable    winning trades / total closed trades
+ *   Sharpe          (MR - RFR) / SD, MR the mean return over a monthly
+ *                   trading period and RFR the `risk_free_rate` argument,
+ *                   2% a year by default
+ *
+ * Sortino is the same ratio against downside deviation alone, which is the
+ * only part of it TradingView states. A column's run-up and drawdown are
+ * measured on the cumulative P&L of that column's trades, so the long column
+ * answers "how deep did the long side go" rather than restating the whole
+ * account's worst moment three times.
+ */
+export interface PerformanceStats {
+    netProfit: number;
+    netProfitPercent: number;
+    grossProfit: number;
+    grossLoss: number;
+    maxRunup: number;
+    maxDrawdown: number;
+    maxRunupPercent: number;
+    maxDrawdownPercent: number;
+    profitFactor: number;
+    commissionPaid: number;
+    closedTrades: number;
+    winningTrades: number;
+    losingTrades: number;
+    evenTrades: number;
+    percentProfitable: number;
+    avgTrade: number;
+    avgWinningTrade: number;
+    avgLosingTrade: number;
+    ratioAvgWinAvgLoss: number;
+    largestWinningTrade: number;
+    largestLosingTrade: number;
+    avgBarsInTrades: number;
+    avgBarsInWinningTrades: number;
+    avgBarsInLosingTrades: number;
+}
+export interface Performance {
+    all: PerformanceStats;
+    long: PerformanceStats;
+    short: PerformanceStats;
+    /** Figures that belong to the account rather than to a side of it. */
+    initialCapital: number;
+    openPL: number;
+    openTrades: number;
+    maxContractsHeld: number;
+    buyHoldReturn: number;
+    buyHoldReturnPercent: number;
+    sharpeRatio: number;
+    sortinoRatio: number;
+}
+/**
+ * Sharpe and Sortino over the equity curve.
+ *
+ * TradingView states the ratio as `(MR - RFR) / SD` with MR "the average
+ * return for a monthly trading period", so the curve is reduced to one
+ * return per calendar month before anything is averaged. `risk_free_rate` is
+ * an ANNUAL percentage — 2 by default — so a month's share of it is
+ * `rate / 100 / 12`.
+ *
+ * Sortino replaces SD with the DOWNSIDE deviation — the same sum of squares,
+ * but counting only the shortfall below zero, and still divided by every
+ * month rather than by the losing ones. Fewer than two months of data leaves
+ * both undefined rather than zero: a single return has no deviation to
+ * divide by, and reporting 0 there would read as "no risk".
+ *
+ * Exported for its own tests. Reaching it through a strategy means finding a
+ * fixture whose months are a mix of winners and losers, and the two divisors
+ * agree exactly when they are not — so a test driven that way can pass with
+ * either formula in place.
+ */
+export declare function riskRatios(curve: EquityPoint[], annualRatePercent: number): {
+    sharpeRatio: number;
+    sortinoRatio: number;
+};
+export declare function buildRenderModel(ctx: Ctx): Omit<SimResult, "protocolVersion" | "engineVersion" | "errors" | "warnings">;
+/**
+ * What the host knows about the chart the script is running on, and the engine
+ * cannot learn from OHLCV bars: its timeframe and the symbol's facts.
+ *
+ * `timeframe` is Pine's own spelling — "1", "5", "60", "240", "D", "W", "M",
+ * "12M", "1S" — NOT a charting library's ("5m", "1H"). Everything else is
+ * optional and falls back to the engine's defaults (see Context.provideSymbolInfo).
+ */
+export interface ChartSettings {
+    symbol: string;
+    timeframe: string;
+    mintick?: number;
+    type?: string;
+    currency?: string;
+    basecurrency?: string;
+    description?: string;
+    /** The exchange's IANA zone; `time(tf, session)` evaluates sessions in it. */
+    timezone?: string;
+    pointvalue?: number;
+    session?: string;
+    mincontract?: number;
+    root?: string;
+}
+/** Message carried by `SimResult.warnings` when the host never called `setChart`. */
+export declare const CHART_NOT_SET_WARNING = "chart not set: timeframe defaults to D and symbol to SYMBOL \u2014 call Session.setChart";
+export declare class Session {
+    private js;
+    private meta;
+    private inputValues;
+    private propertyValues;
+    private securities;
+    private ctx;
+    private exec;
+    private profile;
+    /** Pine Script version detected in the last compile(). */
+    pineVersion: PineVersion;
+    private chart;
+    /**
+     * Tell the engine which chart it is running on: the timeframe and the
+     * symbol's facts. A host MUST call this — none of it can be derived from
+     * bars, and scripts branch on it (`timeframe.period`, `syminfo.type`,
+     * session windows in the exchange's `timezone`). It applies to the compile
+     * dry run and every `runHistory`; call it again to change the chart.
+     * Throws on a timeframe that is not in Pine's format.
+     */
+    setChart(chart: ChartSettings): void;
+    /**
+     * Transpile + validate; a 1-bar dry run on a throwaway context discovers inputs + metadata.
+     *
+     * `opts.libraries`: sources for the libraries the script imports, keyed by
+     * `user/name/version` (see `requiredLibraries` for finding which). An
+     * import with no source is a compile error naming the library.
+     */
+    compile(source: string, opts?: {
+        libraries?: Readonly<Record<string, string>>;
+    }): Compiled;
+    setInputs(values: Record<string, any>): void;
+    /**
+     * Override `strategy()` declaration arguments — starting capital,
+     * pyramiding — the way TradingView's properties panel does.
+     *
+     * Unlike `setInputs`, this cannot be applied to a run already in progress:
+     * `cash` moves with the first fill, so it is seeded when the script
+     * declares itself and never afterwards. The next `runHistory` picks it up.
+     */
+    setProperties(values: Record<string, any>): void;
+    private currencyRates;
+    /**
+     * Supplies the daily conversion rate from one currency to another (what
+     * `request.currency_rate(from, to)` answers), as `{ time, value }` samples
+     * where `time` is the start of the day in ms. A strategy whose
+     * `strategy(currency = to)` differs from `syminfo.currency` (= `from`)
+     * books its closed trades at the rate in effect at the exit bar.
+     */
+    provideCurrencyRate(from: string, to: string, samples: Array<{
+        time: number;
+        value: number;
+    }>): void;
+    provideData(symbol: string, resolution: string, candles: SecurityCandle[]): void;
+    /**
+     * Full historical pass; returns the render model. Builds a FRESH context so
+     * the sandbox's series references always match (ctx.reset() would re-create
+     * the base series and orphan the sandbox bindings).
+     */
+    runHistory(candles: Candle[], opts?: RunOptions): SimResult;
+    /** One pass of `runHistory`; null when it must start over (see there). */
+    private runHistoryOnce;
+    /** The forming bar's latest tick, replayed by `commit()` when no final candle is given. */
+    private lastTick;
+    /** Live tick on the forming bar (P3). Honors calc_on_every_tick. */
+    tick(candle: Candle): RenderDelta;
+    /**
+     * Close the forming bar. TradingView runs the script one more time as the bar
+     * closes: a rollback re-execution on the bar's FINAL candle with
+     * `barstate.isconfirmed` true and `isnew` false (rt-confirmed-v6/v5 probes).
+     * `finalCandle` is that final OHLCV; without it the last tick's values are used
+     * (a bar that never ticked gets no closing execution). A strategy with
+     * calc_on_every_tick off executes only here, so this is its first execution
+     * (`isnew` true) as well as its confirmed one.
+     */
+    commit(finalCandle?: Candle): {
+        barIndex: number;
+    };
+    private deltaForFormingBar;
+}
+/**
+ * `let` declarations in the emitted JS as `var`, and nothing else.
+ *
+ * A scanner, not a regex: string literals, comments and template literals
+ * (including code inside `${…}`) are tracked, and only a whole identifier
+ * `let` in code is rewritten -- not `$let`, not `x.let`, not the "let it be"
+ * in a script's or an inlined library's string.
+ */
+export declare function letToVar(js: string): string;
+/** One-shot convenience: compile + runHistory. */
+export declare function runScript(source: string, opts?: {
+    candles: Candle[];
+    inputs?: Record<string, any>;
+    properties?: Record<string, any>;
+    securities?: Array<{
+        symbol: string;
+        resolution: string;
+        candles: SecurityCandle[];
+    }>;
+    /** Library sources by import path, as for `Session.compile`. */
+    libraries?: Readonly<Record<string, string>>;
+    /** The chart, as for `Session.setChart`. Without it the result carries a warning. */
+    chart?: ChartSettings;
+}): SimResult;
+export {};

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

@@ -0,0 +1,31 @@
+/**
+ * Where one trading session ends and the next begins.
+ *
+ * Lives outside `stdlib/` deliberately: everything in that directory is scanned
+ * by scripts/common/generate-metadata.ts and anything taking a `ctx` first
+ * parameter becomes a BUILT-IN. `opensDay` is a shared helper, not a name any
+ * Pine script may call, so it cannot live there.
+ *
+ * Two built-ins need the same answer and must not drift apart:
+ *
+ *   - `session.isfirstbar` / `session.islastbar`
+ *   - `ta.vwap`, which restarts its accumulation every session
+ *
+ * ── Day boundaries ──────────────────────────────────────────────────────────
+ *
+ * "the day's session" is a calendar day in the EXCHANGE's timezone, and this
+ * engine has no timezone. It compares UTC dates, matching ./stdlib/time.ts,
+ * whose header states the same convention and the same remedy: a host that
+ * supplies bar timestamps already shifted to the exchange timezone gets
+ * agreement.
+ *
+ * This models a 24-hour session, which is right for crypto and wrong for an
+ * equity whose session opens at 09:30 — there, an intraday VWAP would restart
+ * at midnight instead of at the open. On DAILY and higher timeframes the
+ * question does not arise: every bar falls on its own calendar day, so every
+ * bar opens a session, and that falls out of the date comparison rather than
+ * being special-cased.
+ */
+import { Context } from "./context.js";
+/** Is this bar on a different calendar day from the one before it? */
+export declare function opensDay(ctx: Context): boolean;

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

@@ -0,0 +1,19 @@
+/**
+ * Copies a built-in's persistent state for the per-bar rollback point.
+ *
+ * Every stateful call site is snapshotted on every bar (see `call` in
+ * ./context.ts), and a state is usually a rolling buffer: `ta.sma` keeps up to
+ * 5,000 values. `structuredClone` of that, once per site per bar, was most of
+ * the run on a 110,000-bar chart (70% for a script with a few moving averages).
+ *
+ * States are plain data, so a plain copy does the same job: objects of
+ * primitives, arrays of primitives, and those nested. Anything else — a Map, a
+ * class instance, a function (which `structuredClone` refuses, and the caller
+ * reports), a value reachable twice (whose sharing `structuredClone` keeps) —
+ * hands the WHOLE value to `structuredClone`, so what it copies, and what it
+ * throws on, is unchanged.
+ *
+ * Not in stdlib/, where every export becomes a Pine built-in.
+ */
+/** What `structuredClone(v)` returns, faster for plain data. */
+export declare function cloneState<T>(v: T): T;

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

@@ -0,0 +1,31 @@
+/**
+ * The `alert.*` constants.
+ *
+ * ── Why they are not in ui.ts beside alert() ────────────────────────────────
+ *
+ * Pine spells `alert` as BOTH a function and a namespace — `alert(msg, freq)`
+ * and `alert.freq_all`. The registry generator takes a namespace from the NAME
+ * of an exported object, and one module cannot export both a function and an
+ * object called `alert`.
+ *
+ * So the pair is split across two files, exactly as `input` already is:
+ * ./input.ts holds `input()` and ./inputs.ts holds the `input` object. The
+ * merge in ./index.ts then hangs these members off the function object, which
+ * is what makes `alert.freq_all` resolvable at the same time as `alert(…)`.
+ *
+ * ── What the values mean ────────────────────────────────────────────────────
+ *
+ * They select how often ONE alert() call may re-fire within a single realtime
+ * bar. They are recorded on the alert rather than enforced — see the note on
+ * alert() in ./ui.ts for why that depends on a tick feed the host supplies.
+ *
+ * Source: https://www.tradingview.com/pine-script-docs/v4/essential/alerts/
+ */
+export declare const alert: {
+    /** Only the first call per realtime bar triggers. TradingView's default. */
+    freq_once_per_bar: string;
+    /** Triggers only when the realtime bar closes. */
+    freq_once_per_bar_close: string;
+    /** Every call during the realtime bar triggers. */
+    freq_all: string;
+};