oakscriptjs 0.8.2 → 0.9.0

package/dist/esm/script/index.js

@@ -0,0 +1,1289 @@
+/**
+ * @fileoverview PineScript-style script API — write an indicator as a flat
+ * script instead of the explicit calculate() convention.
+ *
+ * ```typescript
+ * import { indicator, input, plot, ta } from 'oakscriptjs/script';
+ *
+ * indicator('My SMA', { overlay: true });
+ * const length = input.int(20, 'Length', { minval: 1 });
+ * const src = input.source('close', 'Source');
+ * plot(ta.sma(src, length), 'SMA', { color: '#2962FF' });
+ * ```
+ *
+ * Execution model: the host calls {@link executeScript} with the script body,
+ * the bars and the current input values. Declaration calls (indicator, input.*,
+ * plot, hline, fill, alertcondition) run as the body executes and are collected
+ * into a {@link ScriptRunResult}: the declarative configs (inputConfig,
+ * plotConfig, hlineConfig, fillConfig) plus an IndicatorResult with the plot
+ * data. Re-running the body with new bars or inputs is PineScript's
+ * recalculation model.
+ *
+ * `input.*` is idempotent like PineScript: it declares the input AND returns
+ * its current value (the host-supplied override, else the default).
+ *
+ * The OHLCV builtins (open/high/low/close/volume/hl2/hlc3/ohlc4/hlcc4) are
+ * Series bound to a module-level BarData that the host swaps per run, so
+ * derived Series memoize between identical runs and recompute when the bars
+ * version bumps.
+ *
+ * One script executes at a time (module-level context) — hosts that run many
+ * scripts must serialize executions, which a Web Worker does naturally.
+ *
+ * @module script
+ */
+import { BarData, Series } from '../runtime/series.js';
+import * as taSeries from '../ta-series.js';
+import * as colorCore from '../color/index.js';
+import { fixnan as fixnanValues, isNA, nz } from '../utils/index.js';
+import * as lineCore from '../line/index.js';
+import * as labelCore from '../label/index.js';
+import * as boxCore from '../box/index.js';
+import * as linefillCore from '../linefill/index.js';
+import * as polylineCore from '../polyline/index.js';
+import * as chartPointCore from '../chartpoint/index.js';
+import * as textCore from '../text/index.js';
+import * as mathCore from '../math/index.js';
+import { resetDrawings, setDrawingLimits } from '../drawing/registry.js';
+import * as timeframeCore from '../timeframe/index.js';
+import * as timeCore from '../time/index.js';
+import * as strCore from '../str/index.js';
+import { formatMessage } from '../str/messageformat.js';
+import { TradingCalendar } from '../session/calendar.js';
+import { SessionBars, sessionFlags } from '../session/bars.js';
+import { afterCompletion, heikinAshi, mapToChart, periodsOf, resample } from '../security/resample.js';
+import { STRATEGY_CONSTANTS, STRATEGY_DEFAULTS, STRATEGY_NUMBER_VARIABLES, STRATEGY_TEXT_VARIABLES, } from '../strategy/index.js';
+/** Bars for the current run. Module-level and REUSED across runs so builtins
+ *  and every Series derived from them keep their version-keyed memoization. */
+const ctxBars = new BarData([]);
+let ctx = null;
+function collector() {
+    if (!ctx) {
+        throw new Error('oakscriptjs/script functions can only run inside executeScript() — ' +
+            'the host (chart/worker) drives script execution.');
+    }
+    return ctx;
+}
+function freshCollector(inputValues) {
+    return {
+        title: 'Untitled',
+        overlay: true,
+        inputValues,
+        inputConfig: [],
+        inputIds: new Set(),
+        defaultInputs: {},
+        plotConfig: [],
+        plots: {},
+        hlineConfig: [],
+        fills: [],
+        fillConfig: [],
+        shapeConfig: [],
+        markers: [],
+        arrowConfig: [],
+        arrows: [],
+        barColorConfig: [],
+        bgcolors: [],
+        barcolors: [],
+        alertConfig: [],
+        alerts: [],
+    };
+}
+/** Stable input id from the title ("ATR / Range Period" → "atr_range_period"). */
+function slugId(title, fallback, taken) {
+    const base = (title ?? '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '') || fallback;
+    let id = base;
+    for (let n = 2; taken.has(id); n++)
+        id = `${base}_${n}`;
+    taken.add(id);
+    return id;
+}
+let scriptOptions = {};
+/**
+ * Runs a script body against `bars` with the given input overrides and
+ * collects everything it declared. `chart` describes the bars (chart timeframe,
+ * exchange time zone, session type) for the PineScript values that depend on them. `options.strategyEngine`
+ * supplies the order engine of strategy scripts. This is the host-side entry — editor
+ * panels, workers and tests call it; scripts never do.
+ */
+export function executeScript(body, barsInput, inputs = {}, chart = {}, options = {}) {
+    ctxBars.setAll(barsInput);
+    chartCtx = { ...chart };
+    scriptOptions = options;
+    ctx = freshCollector(inputs);
+    resetDrawings();
+    try {
+        body();
+        const c = ctx;
+        return {
+            metadata: {
+                title: c.title,
+                shortTitle: c.shortTitle,
+                overlay: c.overlay,
+                precision: c.precision,
+                format: c.format,
+            },
+            inputConfig: c.inputConfig,
+            plotConfig: c.plotConfig,
+            hlineConfig: c.hlineConfig,
+            fillConfig: c.fillConfig,
+            shapeConfig: c.shapeConfig,
+            arrowConfig: c.arrowConfig,
+            barColorConfig: c.barColorConfig,
+            defaultInputs: c.defaultInputs,
+            alertConfig: c.alertConfig,
+            strategyConfig: c.strategy?.properties,
+            result: {
+                metadata: { title: c.title, shorttitle: c.shortTitle, overlay: c.overlay, precision: c.precision },
+                plots: c.plots,
+                fills: c.fills.length ? c.fills : undefined,
+                markers: c.markers.length ? c.markers : undefined,
+                arrows: c.arrows.length ? c.arrows : undefined,
+                bgcolors: c.bgcolors.length ? c.bgcolors : undefined,
+                barcolors: c.barcolors.length ? c.barcolors : undefined,
+                alerts: c.alerts.length ? c.alerts : undefined,
+            },
+        };
+    }
+    finally {
+        ctx = null;
+    }
+}
+/** PineScript `indicator()` — declares the script's metadata. */
+export function indicator(title, options = {}) {
+    const c = collector();
+    declare(c, 'indicator');
+    c.title = title;
+    c.shortTitle = options.shorttitle;
+    c.overlay = options.overlay ?? true;
+    c.precision = options.precision;
+    c.format = options.format;
+    setDrawingLimits({
+        line: options.max_lines_count,
+        label: options.max_labels_count,
+        box: options.max_boxes_count,
+        polyline: options.max_polylines_count,
+    });
+}
+function declare(c, kind) {
+    if (c.declaration) {
+        throw new Error(`${kind}(): the script already declared ${c.declaration}(); a script has one declaration.`);
+    }
+    c.declaration = kind;
+}
+/** The InputConfig fields of the common input options (unset options are left out). */
+function common(opts) {
+    const out = {};
+    if (opts.group !== undefined)
+        out.group = opts.group;
+    if (opts.inline !== undefined)
+        out.inline = opts.inline;
+    if (opts.tooltip !== undefined)
+        out.tooltip = opts.tooltip;
+    if (opts.confirm !== undefined)
+        out.confirm = opts.confirm;
+    if (opts.display !== undefined)
+        out.display = opts.display;
+    return out;
+}
+/** Declares the input in the collector and returns its current value (the
+ *  host-supplied override when present, else the default). */
+function registerInput(config, fallbackId) {
+    const c = collector();
+    const id = slugId(config.title, fallbackId, c.inputIds);
+    c.inputConfig.push({ id, ...config });
+    c.defaultInputs[id] = config.defval;
+    const value = c.inputValues[id];
+    return (value === undefined ? config.defval : value);
+}
+function registerNumeric(type, defval, title, opts = {}) {
+    const v = registerInput({ type, defval, title, min: opts.minval, max: opts.maxval, step: opts.step, ...common(opts) }, `input_${type}`);
+    return typeof v === 'number' ? v : defval;
+}
+/** PineScript `input.*` — declares an input AND returns its current value. */
+export const input = {
+    int(defval, title, opts = {}) {
+        return Math.round(registerNumeric('int', defval, title, opts));
+    },
+    float(defval, title, opts = {}) {
+        return registerNumeric('float', defval, title, opts);
+    },
+    bool(defval, title, opts = {}) {
+        return registerInput({ type: 'bool', defval, title, ...common(opts) }, 'input_bool');
+    },
+    string(defval, title, opts = {}) {
+        return registerInput({ type: 'string', defval, title, options: opts.options, ...common(opts) }, 'input_string');
+    },
+    color(defval, title, opts = {}) {
+        return registerInput({ type: 'color', defval, title, ...common(opts) }, 'input_color');
+    },
+    /** Declares a source input and returns it as a Series. */
+    source(defval = 'close', title, opts = {}) {
+        const name = registerInput({ type: 'source', defval, title, ...common(opts) }, 'input_source');
+        return sourceSeries(name);
+    },
+    /** Timeframe string ("60", "1D", "W"). As in PineScript, "" means the chart timeframe. */
+    timeframe(defval, title, opts = {}) {
+        return registerInput({ type: 'timeframe', defval, title, options: opts.options, ...common(opts) }, 'input_timeframe');
+    },
+    /** Session string ("0930-1600", "0930-1600:23456"). */
+    session(defval, title, opts = {}) {
+        return registerInput({ type: 'session', defval, title, options: opts.options, ...common(opts) }, 'input_session');
+    },
+    /** Date and time as a UNIX time in milliseconds, e.g. `input.time(timestamp('2024-01-01'), 'Start')`. */
+    time(defval, title, opts = {}) {
+        const v = registerInput({ type: 'time', defval, title, ...common(opts) }, 'input_time');
+        return typeof v === 'number' ? v : defval;
+    },
+};
+// ── OHLCV builtins ───────────────────────────────────────────────────────────
+export const open = Series.fromBars(ctxBars, 'open');
+export const high = Series.fromBars(ctxBars, 'high');
+export const low = Series.fromBars(ctxBars, 'low');
+export const close = Series.fromBars(ctxBars, 'close');
+export const volume = Series.fromBars(ctxBars, 'volume');
+export const hl2 = new Series(ctxBars, (b) => (b.high + b.low) / 2);
+export const hlc3 = new Series(ctxBars, (b) => (b.high + b.low + b.close) / 3);
+export const ohlc4 = new Series(ctxBars, (b) => (b.open + b.high + b.low + b.close) / 4);
+export const hlcc4 = new Series(ctxBars, (b) => (b.high + b.low + b.close + b.close) / 4);
+const SOURCES = { open, high, low, close, volume, hl2, hlc3, ohlc4, hlcc4 };
+function sourceSeries(name) {
+    return SOURCES[name] ?? close;
+}
+// ── Bound ta namespace ───────────────────────────────────────────────────────
+const bars = () => ctxBars.bars;
+/** A Series bound to the context bars whose values come from one pass over all bars
+ *  (cumulative indicators), recomputed when the bars version changes. */
+function barsSeries(compute) {
+    let version = -1;
+    let values = [];
+    return new Series(ctxBars, (_bar, i, data) => {
+        if (version !== ctxBars.version) {
+            values = compute(data).toArray();
+            version = ctxBars.version;
+        }
+        return values[i] ?? NaN;
+    });
+}
+/** ta.* with the chart-implicit (bars-first) functions bound to the context,
+ *  so scripts call them like PineScript: `ta.tr(true)`, `ta.atr(14)`. */
+export const ta = {
+    ...taSeries,
+    tr: (handleNa = false) => taSeries.tr(bars(), handleNa),
+    atr: (length) => taSeries.atr(bars(), length),
+    sar: (start, inc, max) => taSeries.sar(bars(), start, inc, max),
+    wpr: (length) => taSeries.wpr(bars(), length),
+    supertrend: (factor, atrLength) => taSeries.supertrend(bars(), factor, atrLength),
+    dmi: (diLength, adxSmoothing) => taSeries.dmi(bars(), diLength, adxSmoothing),
+    kc: (source, length, mult, useTrueRange) => taSeries.kc(bars(), source, length, mult, useTrueRange),
+    kcw: (source, length, mult, useTrueRange) => taSeries.kcw(bars(), source, length, mult, useTrueRange),
+    ichimoku: (conversionPeriods, basePeriods, laggingSpan2Periods, displacement) => taSeries.ichimoku(bars(), conversionPeriods, basePeriods, laggingSpan2Periods, displacement),
+    /** `ta.highest(source, length)` or `ta.highest(length)` (source = high). */
+    highest: (sourceOrLength, length) => typeof sourceOrLength === 'number' ? taSeries.highest(high, sourceOrLength) : taSeries.highest(sourceOrLength, length),
+    /** `ta.lowest(source, length)` or `ta.lowest(length)` (source = low). */
+    lowest: (sourceOrLength, length) => typeof sourceOrLength === 'number' ? taSeries.lowest(low, sourceOrLength) : taSeries.lowest(sourceOrLength, length),
+    /** `ta.highestbars(source, length)` or `ta.highestbars(length)` (source = high); offsets are 0 or negative. */
+    highestbars: (sourceOrLength, length) => typeof sourceOrLength === 'number'
+        ? taSeries.highestbars(high, sourceOrLength)
+        : taSeries.highestbars(sourceOrLength, length),
+    /** `ta.lowestbars(source, length)` or `ta.lowestbars(length)` (source = low); offsets are 0 or negative. */
+    lowestbars: (sourceOrLength, length) => typeof sourceOrLength === 'number'
+        ? taSeries.lowestbars(low, sourceOrLength)
+        : taSeries.lowestbars(sourceOrLength, length),
+    /** `ta.vwap(source, anchor?, stdev_mult?)` with the chart volume; the default anchor is a new trading
+     *  day (`timeframe.change("1D")`), which needs the chart context (timeframe, time zone, session). */
+    vwap: ((source, anchor, stdev_mult) => {
+        const a = anchor ?? changeOf('1D'); // PineScript default: timeframe.change("1D")
+        return stdev_mult === undefined ? taSeries.vwap(source, volume, a) : taSeries.vwapBands(source, volume, a, stdev_mult);
+    }),
+    /** `ta.mfi(source, length)` with the chart volume (PineScript takes 2 arguments). */
+    mfi: (source, length) => taSeries.mfi(source, length, volume),
+    /** `ta.pivothigh(source, leftbars, rightbars)` or `ta.pivothigh(leftbars, rightbars)` (source = high).
+     *  The value appears `rightbars` bars after the pivot bar, as in PineScript. */
+    pivothigh: (sourceOrLeft, leftOrRight, rightbars) => typeof sourceOrLeft === 'number'
+        ? taSeries.pivothigh(high, sourceOrLeft, leftOrRight)
+        : taSeries.pivothigh(sourceOrLeft, leftOrRight, rightbars),
+    /** `ta.pivotlow(source, leftbars, rightbars)` or `ta.pivotlow(leftbars, rightbars)` (source = low). */
+    pivotlow: (sourceOrLeft, leftOrRight, rightbars) => typeof sourceOrLeft === 'number'
+        ? taSeries.pivotlow(low, sourceOrLeft, leftOrRight)
+        : taSeries.pivotlow(sourceOrLeft, leftOrRight, rightbars),
+    // PineScript variables of the chart bars: `ta.obv`, not `ta.obv()`.
+    obv: barsSeries(taSeries.obv),
+    pvt: barsSeries(taSeries.pvt),
+    accdist: barsSeries(taSeries.accdist),
+    nvi: barsSeries(taSeries.nvi),
+    pvi: barsSeries(taSeries.pvi),
+    iii: barsSeries(taSeries.iii),
+    wad: barsSeries(taSeries.wad),
+    wvad: barsSeries(taSeries.wvad),
+};
+export function fixnan(source) {
+    return source instanceof Series ? Series.fromArray(ctxBars, fixnanValues(source.toArray())) : fixnanValues(source);
+}
+function colorWhen(cond, colorTrue, colorFalse) {
+    return cond.toArray().map((v) => (!isNA(v) && v !== 0 ? colorTrue : colorFalse));
+}
+/** color.* plus `when` — per-bar conditional colors for plot()/fill()/bgcolor()/barcolor(). */
+export const color = {
+    ...colorCore,
+    new: colorCore.new_color,
+    when: colorWhen,
+};
+/** PineScript `plot()` — declares the plot and supplies its data in one call. */
+function plotImpl(series, title, options = {}) {
+    const c = collector();
+    const id = `plot${c.plotConfig.length}`;
+    const perBar = Array.isArray(options.color) ? options.color : undefined;
+    const staticColor = typeof options.color === 'string' ? options.color : (perBar?.[perBar.length - 1] ?? '#2962FF');
+    c.plotConfig.push({
+        id,
+        title: title ?? id,
+        color: staticColor,
+        lineWidth: options.linewidth,
+        style: options.style,
+        linestyle: options.linestyle,
+        display: options.display,
+        histbase: options.histbase,
+        forceOverlay: options.force_overlay,
+    });
+    const values = series.toArray();
+    const b = bars();
+    const data = [];
+    for (let i = 0; i < b.length; i++) {
+        const value = values[i];
+        if (value === undefined || !Number.isFinite(value))
+            continue; // PineScript plots +/-Infinity as na
+        data.push(perBar ? { time: b[i].time, value, color: perBar[i] } : { time: b[i].time, value });
+    }
+    c.plots[id] = data;
+    return { id, kind: 'plot' };
+}
+/**
+ * PineScript `plot()`, with the `plot.style_*` and `plot.linestyle_*` constants:
+ * `plot(src, 'Level', { style: plot.style_stepline, linestyle: plot.linestyle_dashed })`.
+ */
+export const plot = Object.assign(plotImpl, {
+    style_line: 'line',
+    style_linebr: 'linebr',
+    style_stepline: 'stepline',
+    style_steplinebr: 'steplinebr',
+    style_stepline_diamond: 'stepline_diamond',
+    style_histogram: 'histogram',
+    style_columns: 'columns',
+    style_area: 'area',
+    style_areabr: 'areabr',
+    style_circles: 'circles',
+    style_cross: 'cross',
+    linestyle_solid: 'solid',
+    linestyle_dotted: 'dotted',
+    linestyle_dashed: 'dashed',
+});
+/** PineScript `hline()` — a static horizontal level. Default line style: dashed (PineScript). */
+function hlineImpl(price, title, options = {}) {
+    const c = collector();
+    const id = `hline${c.hlineConfig.length}`;
+    c.hlineConfig.push({
+        id,
+        price,
+        title,
+        color: options.color,
+        linestyle: options.linestyle ?? 'dashed',
+        linewidth: options.linewidth,
+    });
+    return { id, kind: 'hline' };
+}
+/** PineScript `hline()`, with the `hline.style_*` constants: `hline(0, 'Zero', { linestyle: hline.style_dotted })`. */
+export const hline = Object.assign(hlineImpl, {
+    style_solid: 'solid',
+    style_dotted: 'dotted',
+    style_dashed: 'dashed',
+});
+function perBarValues(v, n) {
+    return v instanceof Series ? v.toArray().slice(0, n) : new Array(n).fill(v);
+}
+function perBarColors(c, n) {
+    if (Array.isArray(c))
+        return Array.from({ length: n }, (_, i) => c[i] ?? null);
+    return new Array(n).fill(c ?? null);
+}
+export function fill(a, b, ...args) {
+    const c = collector();
+    const third = args[0];
+    let perBar;
+    let staticColor;
+    let title;
+    let gradient;
+    if (typeof third === 'number' || third instanceof Series) {
+        const n = ctxBars.bars.length;
+        gradient = {
+            topValue: perBarValues(third, n),
+            bottomValue: perBarValues(args[1], n),
+            topColor: perBarColors(args[2], n),
+            bottomColor: perBarColors(args[3], n),
+        };
+        title = args[4];
+    }
+    else if (third !== null && typeof third === 'object' && !Array.isArray(third)) {
+        const options = third;
+        perBar = Array.isArray(options.color) ? options.color : undefined;
+        staticColor = typeof options.color === 'string' ? options.color : undefined;
+        title = options.title;
+    }
+    else {
+        const color = third;
+        perBar = Array.isArray(color) ? color.map((x) => x ?? '') : undefined;
+        staticColor = typeof color === 'string' ? color : undefined;
+        title = args[1];
+    }
+    if (a.kind === 'hline' && b.kind === 'hline') {
+        c.fillConfig.push({
+            id: `fill${c.fillConfig.length}`,
+            plot1: a.id,
+            plot2: b.id,
+            color: staticColor,
+            colors: perBar,
+            gradient,
+            title,
+        });
+        return;
+    }
+    c.fills.push({
+        plot1: a.id,
+        plot2: b.id,
+        options: { color: staticColor, title },
+        colors: perBar,
+        gradient,
+    });
+}
+/** Shared emitter for plotshape()/plotchar(). Emits one marker per bar where
+ *  the condition is truthy (not na, not 0). */
+function emitMarkers(kind, condition, title, options) {
+    const c = collector();
+    const id = `${kind}${c.shapeConfig.filter((s) => s.kind === kind).length}`;
+    const style = kind === 'shape' ? (options.style ?? 'xcross') : 'char';
+    const char = kind === 'char' ? (options.char ?? '*') : undefined;
+    const location = options.location ?? 'abovebar';
+    c.shapeConfig.push({
+        id,
+        kind,
+        title,
+        style: kind === 'shape' ? style : undefined,
+        char,
+        location,
+        color: options.color,
+        text: options.text,
+        textcolor: options.textcolor,
+        size: options.size,
+        offset: options.offset,
+        forceOverlay: options.force_overlay,
+    });
+    const values = condition.toArray();
+    const b = bars();
+    const off = options.offset ?? 0;
+    for (let i = 0; i < b.length; i++) {
+        const v = values[i];
+        if (v === undefined || Number.isNaN(v) || v === 0)
+            continue;
+        const j = i + off;
+        if (j < 0 || j >= b.length)
+            continue;
+        c.markers.push({
+            time: b[j].time,
+            id,
+            location,
+            style,
+            char,
+            color: options.color,
+            text: options.text,
+            textcolor: options.textcolor,
+            size: options.size,
+            tooltip: options.tooltip,
+            price: location === 'absolute' ? v : undefined,
+        });
+    }
+}
+/** PineScript `plotshape()` — a marker on each bar where the condition holds. */
+export function plotshape(condition, title, options = {}) {
+    emitMarkers('shape', condition, title, options);
+}
+/** PineScript `plotchar()` — a character marker on each bar where the condition holds. */
+export function plotchar(condition, title, options = {}) {
+    emitMarkers('char', condition, title, options);
+}
+/**
+ * PineScript `plotarrow()` — an up arrow below the bar for a positive value, a down arrow above the bar for a
+ * negative value, nothing for 0 / na. The arrows go to `result.arrows` (value and color per bar), the declaration to
+ * `arrowConfig`; the renderer scales the height with the absolute value between minheight and maxheight.
+ */
+export function plotarrow(series, title, options = {}) {
+    const c = collector();
+    const id = `arrow${c.arrowConfig.length}`;
+    const pick = (col, fallback, i) => col === undefined ? fallback : typeof col === 'string' ? col : col[i];
+    const colorup = typeof options.colorup === 'string' ? options.colorup : '#00FF00';
+    const colordown = typeof options.colordown === 'string' ? options.colordown : '#FF0000';
+    c.arrowConfig.push({
+        id,
+        title,
+        colorup,
+        colordown,
+        minheight: options.minheight ?? 5,
+        maxheight: options.maxheight ?? 100,
+        offset: options.offset,
+        display: options.display,
+        forceOverlay: options.force_overlay,
+    });
+    const values = series.toArray();
+    const b = bars();
+    const off = options.offset ?? 0;
+    for (let i = 0; i < b.length; i++) {
+        const v = values[i];
+        if (v === undefined || Number.isNaN(v) || v === 0)
+            continue;
+        const j = i + off;
+        if (j < 0 || j >= b.length)
+            continue;
+        const color = v > 0 ? pick(options.colorup, '#00FF00', i) : pick(options.colordown, '#FF0000', i);
+        if (color === undefined)
+            continue; // na color: no arrow
+        c.arrows.push({ time: b[j].time, id, value: v, color });
+    }
+}
+/** Shared emitter for bgcolor()/barcolor(). A static color applies to every
+ *  bar; a per-bar array (from color.when) skips undefined entries. The offset
+ *  is baked in: the color computed at bar i lands on bar i + offset. */
+function emitBarColors(kind, colors, options) {
+    const c = collector();
+    const id = `${kind}${c.barColorConfig.filter((x) => x.kind === kind).length}`;
+    c.barColorConfig.push({ id, kind, title: options.title, offset: options.offset, forceOverlay: options.force_overlay });
+    const b = bars();
+    const off = options.offset ?? 0;
+    const target = kind === 'bgcolor' ? c.bgcolors : c.barcolors;
+    for (let i = 0; i < b.length; i++) {
+        const col = typeof colors === 'string' ? colors : colors[i];
+        if (!col)
+            continue;
+        const j = i + off;
+        if (j < 0 || j >= b.length)
+            continue;
+        target.push({ time: b[j].time, color: col });
+    }
+}
+/**
+ * PineScript `bgcolor()` — per-bar background color. `force_overlay: true` colors the main chart pane even when the
+ * script is not an overlay.
+ */
+export function bgcolor(colors, options = {}) {
+    emitBarColors('bgcolor', colors, options);
+}
+/** PineScript `barcolor()` — per-bar candle color override. */
+export function barcolor(colors, options = {}) {
+    emitBarColors('barcolor', colors, options);
+}
+/**
+ * Runs the callback once per bar, in order, and collects the returned values
+ * into a Series. This is the escape hatch for PineScript logic the vectorized
+ * model cannot express:
+ *
+ * - `var x = 0` / `x := ...` → a plain `let` variable captured by the closure
+ * - per-bar `if` / `for` / `while` → native JS statements
+ * - `src[k]` → `c.get(src, k)`; self-reference → `c.prev()`
+ *
+ * Returning a boolean collects 1/0; returning nothing collects na (NaN).
+ *
+ * ```typescript
+ * let dir = 0;                          // var dir = 0
+ * const trend = eachBar((c) => {
+ *   if (c.close > c.get(close, 1)) dir = 1;   // dir := 1
+ *   else if (c.close < c.get(close, 1)) dir = -1;
+ *   return dir;
+ * });
+ * ```
+ */
+export function eachBar(fn) {
+    collector(); // same lifecycle guard (and error message) as the declaration calls
+    const b = bars();
+    const out = new Array(b.length).fill(NaN);
+    const cache = new Map();
+    let idx = 0;
+    const ctx = {
+        get i() {
+            return idx;
+        },
+        n: b.length,
+        get time() {
+            return b[idx].time;
+        },
+        get open() {
+            return b[idx].open;
+        },
+        get high() {
+            return b[idx].high;
+        },
+        get low() {
+            return b[idx].low;
+        },
+        get close() {
+            return b[idx].close;
+        },
+        get volume() {
+            return b[idx].volume ?? NaN;
+        },
+        get(src, offset = 0) {
+            if (offset < 0)
+                throw new RangeError(`c.get(): the offset cannot be negative (${offset} would read a future bar).`);
+            let vals = cache.get(src);
+            if (!vals) {
+                vals = src.toArray();
+                cache.set(src, vals);
+            }
+            const j = idx - offset;
+            return j >= 0 && j < vals.length ? (vals[j] ?? NaN) : NaN;
+        },
+        prev(offset = 1) {
+            const j = idx - Math.max(1, offset);
+            return j >= 0 ? out[j] : NaN;
+        },
+    };
+    try {
+        for (idx = 0; idx < b.length; idx++) {
+            currentBar = idx;
+            const r = fn(ctx);
+            out[idx] = typeof r === 'number' ? r : typeof r === 'boolean' ? (r ? 1 : 0) : NaN;
+        }
+    }
+    finally {
+        currentBar = -1;
+    }
+    return Series.fromArray(ctxBars, out);
+}
+/** Bar index of the running eachBar() callback, -1 outside eachBar(). */
+let currentBar = -1;
+// ── Strategy (declaration and strategy.* API; the host supplies the order engine) ──
+/** The strategy of the current run; throws when the script did not declare strategy(). */
+function strategyRun(caller) {
+    const run = collector().strategy;
+    if (!run)
+        throw new Error(`${caller}: declare the script with strategy() first.`);
+    return run;
+}
+function strategyEngine(caller) {
+    const run = strategyRun(caller);
+    if (!run.engine) {
+        throw new Error(`${caller}: no strategy engine; pass it as executeScript(body, bars, inputs, chart, { strategyEngine }).`);
+    }
+    return run.engine;
+}
+/** The engine for an order call: order calls run inside strategy.eachBar(), at a bar close. */
+function orderEngine(caller) {
+    const engine = strategyEngine(caller);
+    if (!strategyRun(caller).inLoop)
+        throw new Error(`${caller} must be called inside strategy.eachBar().`);
+    return engine;
+}
+/** Options without na (NaN) numbers and undefined values: in PineScript an na argument means "not given". */
+function given(options) {
+    const out = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (value === undefined || (typeof value === 'number' && Number.isNaN(value)))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+/** The engine for a `strategy.*` read: the values are per bar, so they are read inside strategy.eachBar(). */
+function readEngine(caller) {
+    const engine = strategyEngine(caller);
+    if (!strategyRun(caller).inLoop)
+        throw new Error(`${caller} must be read inside strategy.eachBar().`);
+    return engine;
+}
+/** `strategy.*` variables that do not change from bar to bar, readable anywhere in the script. */
+const STRATEGY_CONSTANT_VARIABLES = new Set(['initial_capital', 'account_currency']);
+function strategyVariable(name) {
+    const caller = `strategy.${name}`;
+    const engine = STRATEGY_CONSTANT_VARIABLES.has(name) ? strategyEngine(caller) : readEngine(caller);
+    const value = engine.get(name);
+    if (value === undefined)
+        throw new Error(`strategy.${name} is not provided by the strategy engine.`);
+    return value;
+}
+function riskRule(rule) {
+    const engine = strategyEngine(`strategy.risk.${rule.rule}()`);
+    if (!engine.risk)
+        throw new Error(`strategy.risk.${rule.rule}() is not provided by the strategy engine.`);
+    engine.risk(rule);
+}
+/** PineScript `strategy()` declaration: script metadata and strategy properties. */
+function declareStrategy(title, options = {}) {
+    const c = collector();
+    declare(c, 'strategy');
+    c.title = title;
+    c.shortTitle = options.shorttitle;
+    c.overlay = options.overlay ?? false;
+    c.precision = options.precision;
+    c.format = options.format;
+    setDrawingLimits({
+        line: options.max_lines_count,
+        label: options.max_labels_count,
+        box: options.max_boxes_count,
+        polyline: options.max_polylines_count,
+    });
+    const properties = { ...STRATEGY_DEFAULTS };
+    const target = properties;
+    for (const key of [...Object.keys(STRATEGY_DEFAULTS), 'currency']) {
+        const value = options[key];
+        if (value !== undefined)
+            target[key] = value;
+    }
+    const factory = scriptOptions.strategyEngine;
+    c.strategy = {
+        properties,
+        engine: factory?.({ properties, bars: ctxBars.bars, chart: chartCtx }),
+        looped: false,
+        inLoop: false,
+    };
+}
+/**
+ * Runs the strategy logic once per bar, in order, like {@link eachBar}. On each bar the engine first
+ * fills the pending orders (`processBar`), then the callback runs at the bar close (order calls,
+ * `strategy.*` variables), then `processClose` runs. A script has one strategy.eachBar() per run.
+ * The callback's return values are collected into a Series, as with eachBar().
+ */
+function strategyEachBar(fn) {
+    const run = strategyRun('strategy.eachBar()');
+    const engine = strategyEngine('strategy.eachBar()');
+    if (run.looped)
+        throw new Error('strategy.eachBar() runs once per script run.');
+    run.looped = true;
+    return eachBar((c) => {
+        engine.processBar(c.i);
+        run.inLoop = true;
+        try {
+            return fn(c);
+        }
+        finally {
+            run.inLoop = false;
+            engine.processClose(c.i);
+        }
+    });
+}
+const strategyMembers = {
+    ...STRATEGY_CONSTANTS,
+    eachBar: strategyEachBar,
+    entry(id, direction, options = {}) {
+        orderEngine('strategy.entry()').entry(id, direction, given(options));
+    },
+    order(id, direction, options = {}) {
+        orderEngine('strategy.order()').order(id, direction, given(options));
+    },
+    exit(id, options = {}) {
+        orderEngine('strategy.exit()').exit(id, given(options));
+    },
+    close(id, options = {}) {
+        orderEngine('strategy.close()').close(id, given(options));
+    },
+    close_all(options = {}) {
+        orderEngine('strategy.close_all()').close_all(given(options));
+    },
+    cancel(id) {
+        orderEngine('strategy.cancel()').cancel(id);
+    },
+    cancel_all() {
+        orderEngine('strategy.cancel_all()').cancel_all();
+    },
+    opentrade(index) {
+        return readEngine('strategy.opentrade()').openTrade(index);
+    },
+    closedtrade(index) {
+        return readEngine('strategy.closedtrade()').closedTrade(index);
+    },
+    default_entry_qty(fill_price) {
+        const engine = readEngine('strategy.default_entry_qty()');
+        if (!engine.defaultEntryQty)
+            throw new Error('strategy.default_entry_qty() is not provided by the strategy engine.');
+        return engine.defaultEntryQty(fill_price);
+    },
+    risk: {
+        allow_entry_in: (direction) => riskRule({ rule: 'allow_entry_in', direction }),
+        max_cons_loss_days: (count, alert_message) => riskRule(given({ rule: 'max_cons_loss_days', count, alert_message })),
+        max_drawdown: (value, type, alert_message) => riskRule(given({ rule: 'max_drawdown', value, type, alert_message })),
+        max_intraday_filled_orders: (count, alert_message) => riskRule(given({ rule: 'max_intraday_filled_orders', count, alert_message })),
+        max_intraday_loss: (value, type, alert_message) => riskRule(given({ rule: 'max_intraday_loss', value, type, alert_message })),
+        max_position_size: (contracts) => riskRule({ rule: 'max_position_size', contracts }),
+    },
+};
+const variableGetters = {};
+for (const name of [...STRATEGY_NUMBER_VARIABLES, ...STRATEGY_TEXT_VARIABLES]) {
+    variableGetters[name] = { get: () => strategyVariable(name), enumerable: true };
+}
+/**
+ * PineScript `strategy`: call it to declare a strategy, and use its members as the `strategy.*` namespace.
+ * OakScriptJS does not fill orders: the host passes an engine in `executeScript(..., { strategyEngine })`,
+ * and the order calls and `strategy.*` variables are forwarded to it.
+ *
+ * ```typescript
+ * strategy('MA Cross', { initial_capital: 10000, default_qty_type: strategy.percent_of_equity, default_qty_value: 100 });
+ * const up = ta.crossover(ta.sma(close, 9), ta.sma(close, 21));
+ * strategy.eachBar((c) => {
+ *   if (c.get(up) && strategy.position_size === 0) {
+ *     strategy.entry('L', strategy.long);
+ *     strategy.exit('X', { from_entry: 'L', stop: c.close * 0.95, limit: c.close * 1.15 });
+ *   }
+ * });
+ * ```
+ */
+export const strategy = Object.defineProperties(Object.assign((title, options) => declareStrategy(title, options), strategyMembers), variableGetters);
+let chartCtx = {};
+function chartTimeframe() {
+    collector();
+    if (!chartCtx.timeframe) {
+        throw new Error('The chart timeframe is not known: pass it as executeScript(body, bars, inputs, { timeframe }).');
+    }
+    return timeframeCore.info(chartCtx.timeframe);
+}
+function exchangeTimezone() {
+    collector();
+    if (!chartCtx.timezone) {
+        throw new Error('The exchange time zone is not known: pass it as executeScript(body, bars, inputs, { timezone }).');
+    }
+    return chartCtx.timezone;
+}
+/**
+ * PineScript `timeframe.*`: the chart timeframe variables (from the chart context), and
+ * `in_seconds(timeframe?)`, `from_seconds(seconds)`.
+ */
+export const timeframe = {
+    ...timeframeCore,
+    get period() {
+        return chartTimeframe().period;
+    },
+    get main_period() {
+        return chartTimeframe().period;
+    },
+    get multiplier() {
+        return chartTimeframe().multiplier;
+    },
+    get isintraday() {
+        return chartTimeframe().isintraday;
+    },
+    get isdaily() {
+        return chartTimeframe().isdaily;
+    },
+    get isweekly() {
+        return chartTimeframe().isweekly;
+    },
+    get ismonthly() {
+        return chartTimeframe().ismonthly;
+    },
+    get isminutes() {
+        return chartTimeframe().isminutes;
+    },
+    get isseconds() {
+        return chartTimeframe().isseconds;
+    },
+    get isticks() {
+        return chartTimeframe().isticks;
+    },
+    get isdwm() {
+        return chartTimeframe().isdwm;
+    },
+    /** PineScript `timeframe.change(tf)`: 1 on bars that open a new `tf` period (0 on the first bar). */
+    change(tf) {
+        return changeOf(tf || chartTimeframe().period);
+    },
+    /** Seconds in `timeframe`; without it (or with "") the chart timeframe, as in PineScript. */
+    in_seconds(tf) {
+        return timeframeCore.in_seconds(tf === undefined || tf === '' ? chartTimeframe().period : tf);
+    },
+};
+/** A symbol property that the host passes in the chart context. */
+function symbolProperty(key) {
+    collector();
+    const value = chartCtx[key];
+    if (value === undefined) {
+        throw new Error(`syminfo.${key} is not known: pass it as executeScript(body, bars, inputs, { ${key} }).`);
+    }
+    return value;
+}
+/**
+ * PineScript `syminfo.timezone`, `syminfo.tickerid`, `syminfo.session` (session type), `syminfo.mintick`,
+ * `syminfo.pointvalue` and `syminfo.mincontract`, from the chart context.
+ */
+export const syminfo = {
+    get mintick() {
+        return symbolProperty('mintick');
+    },
+    get pointvalue() {
+        return symbolProperty('pointvalue');
+    },
+    get mincontract() {
+        return symbolProperty('mincontract');
+    },
+    get timezone() {
+        return exchangeTimezone();
+    },
+    get tickerid() {
+        collector();
+        if (!chartCtx.tickerid) {
+            throw new Error('The chart symbol is not known: pass it as executeScript(body, bars, inputs, { tickerid }).');
+        }
+        return chartCtx.tickerid;
+    },
+    get session() {
+        collector();
+        return chartCtx.sessionType ?? 'regular';
+    },
+};
+function calendar(fn) {
+    return ((time, timezone) => {
+        const tz = timezone ?? exchangeTimezone();
+        return time instanceof Series ? Series.fromArray(ctxBars, time.toArray().map((t) => fn(t, tz))) : fn(time, tz);
+    });
+}
+/** PineScript `year(time, timezone?)`; the default time zone is the exchange time zone. */
+export const year = calendar(timeCore.year);
+/** PineScript `month(time, timezone?)`; the default time zone is the exchange time zone. */
+export const month = calendar(timeCore.month);
+/** PineScript `weekofyear(time, timezone?)`; the default time zone is the exchange time zone. */
+export const weekofyear = calendar(timeCore.weekofyear);
+/** PineScript `dayofmonth(time, timezone?)`; the default time zone is the exchange time zone. */
+export const dayofmonth = calendar(timeCore.dayofmonth);
+/** PineScript `dayofweek(time, timezone?)`; the default time zone is the exchange time zone. */
+export const dayofweek = calendar(timeCore.dayofweek);
+/** PineScript `hour(time, timezone?)`; the default time zone is the exchange time zone. */
+export const hour = calendar(timeCore.hour);
+/** PineScript `minute(time, timezone?)`; the default time zone is the exchange time zone. */
+export const minute = calendar(timeCore.minute);
+/** PineScript `second(time, timezone?)`; the default time zone is the exchange time zone. */
+export const second = calendar(timeCore.second);
+export function timestamp(first, ...rest) {
+    if (typeof first === 'number') {
+        const [m, d, h, mi, s] = rest;
+        return timeCore.timestamp(exchangeTimezone(), first, m, d, h, mi, s);
+    }
+    if (rest.length === 0)
+        return timeCore.timestamp(first);
+    const [y, m, d, h, mi, s] = rest;
+    return timeCore.timestamp(first, y, m, d, h, mi, s);
+}
+/** Session test of PineScript `time(timeframe, session, timezone)`; the default time zone is the exchange time zone. */
+export function inSession(time, session, timezone) {
+    return timeCore.inSession(time, session, timezone ?? exchangeTimezone());
+}
+/** PineScript `str.*`; `format_time` and the dates of `format` use the exchange time zone by default. */
+export const str = {
+    ...strCore,
+    format_time(time, format = "yyyy-MM-dd'T'HH:mm:ssZ", timezone) {
+        return strCore.format_time(time, format, timezone ?? exchangeTimezone());
+    },
+    format(pattern, ...args) {
+        return formatMessage(pattern, args, exchangeTimezone);
+    },
+};
+// ── Session values (issue #100) ──────────────────────────────────────────────
+/** Bar time in ms (PineScript `time`). */
+function barTime(bar) {
+    return bar.time * (chartCtx.timeUnit === 'ms' ? 1 : 1000);
+}
+const toSpec = (s) => (typeof s === 'string' ? { session: s } : s);
+let sessionCache = null;
+/** Session calendars of the run (loaded bars and regular hours), built from the chart context. */
+function sessionBars() {
+    const tz = exchangeTimezone();
+    const tf = chartTimeframe().period;
+    if (!chartCtx.session) {
+        throw new Error('The session is not known: pass it as executeScript(body, bars, inputs, { session }).');
+    }
+    if (sessionCache?.ctx !== chartCtx) {
+        const loaded = toSpec(chartCtx.session);
+        const regular = chartCtx.regularSession ? toSpec(chartCtx.regularSession) : loaded;
+        sessionCache = {
+            ctx: chartCtx,
+            bars: new SessionBars(new TradingCalendar(tz, loaded), tf),
+            regular: new SessionBars(new TradingCalendar(tz, { holidays: loaded.holidays, ...regular }), tf),
+        };
+    }
+    return sessionCache;
+}
+/**
+ * Calendar for `time(tf, session, timezone)` arguments. Without session and time zone: the loaded
+ * session. As in PineScript, an explicit time zone reads the symbol session hours in that zone without
+ * corrections and holidays, and an explicit session follows PineScript's session string rules.
+ */
+function calendarFor(session, timezone) {
+    const { bars } = sessionBars();
+    if (!session && !timezone)
+        return { bars, test: false };
+    const tz = timezone ?? exchangeTimezone();
+    const spec = session ? { session } : { session: toSpec(chartCtx.session).session };
+    return { bars: new SessionBars(new TradingCalendar(tz, spec, session ? 'pine' : 'symbol'), bars.chart.period), test: true };
+}
+function perBar(fn) {
+    const times = ctxBars.bars.map(barTime);
+    return Series.fromArray(ctxBars, times.map((t, i) => fn(t, i, times)));
+}
+/** A Series that can also be called, like PineScript's `time` (variable) and `time(...)` (function). */
+function callableSeries(series, fn) {
+    Object.setPrototypeOf(fn, Series.prototype);
+    Object.assign(fn, series);
+    return fn;
+}
+function timeFunction(tf, session, timezone) {
+    collector();
+    const { bars, test } = calendarFor(session, timezone);
+    const timeframeString = tf || chartTimeframe().period;
+    return perBar((t) => (test && !bars.inside(t) ? NaN : bars.timeOf(t, timeframeString)));
+}
+function timeCloseFunction(tf, session, timezone) {
+    collector();
+    const { bars, test } = calendarFor(session, timezone);
+    const timeframeString = tf || chartTimeframe().period;
+    return perBar((t) => (test && !bars.inside(t) ? NaN : bars.closeOf(t, timeframeString)));
+}
+/**
+ * PineScript `time`: the bar open time in ms (a Series), and `time(timeframe?, session?, timezone?)`:
+ * the open time of the `timeframe` period that contains the bar, `na` outside `session`.
+ */
+export const time = callableSeries(new Series(ctxBars, (b) => barTime(b)), timeFunction);
+/**
+ * PineScript `time_close`: the bar close time in ms (a Series), and `time_close(timeframe?, session?, timezone?)`.
+ * Needs the chart timeframe and session.
+ */
+export const time_close = callableSeries(new Series(ctxBars, (_b, i) => sessionBars().bars.closeOf(barTime(ctxBars.bars[i]), chartTimeframe().period)), timeCloseFunction);
+/** PineScript `time_tradingday`: 00:00 UTC of the trading day of each bar, in ms. */
+export const time_tradingday = new Series(ctxBars, (b) => sessionBars().bars.tradingDayTime(barTime(b)));
+function changeOf(tf) {
+    const { bars } = sessionBars();
+    return perBar((t, i, times) => (i > 0 && bars.timeOf(t, tf) !== bars.timeOf(times[i - 1], tf) ? 1 : 0));
+}
+function flag(key) {
+    const { bars, regular } = sessionBars();
+    const values = sessionFlags(ctxBars.bars.map(barTime), bars, regular)[key];
+    return Series.fromArray(ctxBars, values.map((v) => (v ? 1 : 0)));
+}
+/** A 1 / 0 Series from a per-bar test on the bar index and the number of bars. */
+function barFlag(test) {
+    const n = ctxBars.bars.length;
+    return Series.fromArray(ctxBars, Array.from({ length: n }, (_, i) => (test(i, n) ? 1 : 0)));
+}
+const lastRealtime = (i, n) => i === n - 1 && chartCtx.realtime === true;
+/**
+ * PineScript `barstate.*` (1 / 0 per bar). All bars but the last are confirmed history bars. The last bar is
+ * confirmed only when the host says so (`ChartContext.lastBarConfirmed`, e.g. the closing update of a realtime
+ * bar), and is a realtime bar only when it receives live updates (`ChartContext.realtime`); without live updates
+ * it is a history bar, as in PineScript.
+ * `islastconfirmedhistory` is the last bar when it is confirmed and not realtime, else the bar before it.
+ */
+export const barstate = {
+    get isfirst() { return barFlag((i) => i === 0); },
+    get islast() { return barFlag((i, n) => i === n - 1); },
+    get isconfirmed() { return barFlag((i, n) => i < n - 1 || chartCtx.lastBarConfirmed === true); },
+    get isrealtime() { return barFlag(lastRealtime); },
+    get ishistory() { return barFlag((i, n) => !lastRealtime(i, n)); },
+    get isnew() { return barFlag((i, n) => !lastRealtime(i, n) || chartCtx.lastBarNew !== false); },
+    get islastconfirmedhistory() {
+        return barFlag((i, n) => {
+            const lastConfirmed = chartCtx.lastBarConfirmed === true && chartCtx.realtime !== true;
+            return i === (lastConfirmed ? n - 1 : n - 2);
+        });
+    },
+};
+/**
+ * PineScript `session.*` (1 / 0 per bar) and the constants `session.regular` / `session.extended`.
+ * First and last bars are per session period; market / pre / post market use the regular hours.
+ */
+export const session = {
+    regular: 'regular',
+    extended: 'extended',
+    get isfirstbar() { return flag('isfirstbar'); },
+    get islastbar() { return flag('islastbar'); },
+    get ismarket() { return flag('ismarket'); },
+    get ispremarket() { return flag('ispremarket'); },
+    get ispostmarket() { return flag('ispostmarket'); },
+    get isfirstbar_regular() { return flag('isfirstbar_regular'); },
+    get islastbar_regular() { return flag('islastbar_regular'); },
+};
+// ── request.security (issue #101) ─────────────────────────────────────────────
+/** PineScript `barmerge.*` constants of `request.security`. */
+export const barmerge = {
+    gaps_on: 'gaps_on',
+    gaps_off: 'gaps_off',
+    lookahead_on: 'lookahead_on',
+    lookahead_off: 'lookahead_off',
+};
+const HEIKIN_ASHI = 'heikinashi:';
+/** PineScript `ticker.heikinashi(symbol)` / `ticker.standard(symbol)` for the chart symbol. */
+export const ticker = {
+    heikinashi(symbol) {
+        return HEIKIN_ASHI + symbol;
+    },
+    standard(symbol) {
+        return symbol.startsWith(HEIKIN_ASHI) ? symbol.slice(HEIKIN_ASHI.length) : symbol;
+    },
+};
+function valuesOf(value, length) {
+    if (!(value instanceof Series))
+        return new Array(length).fill(Number(value));
+    if (value.bars !== ctxBars.bars) {
+        throw new Error('request.security(): the expression returned a series computed on the chart bars. ' +
+            'Compute the series inside the expression, e.g. () => ta.ema(close, 10).');
+    }
+    return value.toArray().slice();
+}
+/**
+ * PineScript `request.security` for the chart symbol (`syminfo.tickerid`, `""`, `ticker.heikinashi(...)`,
+ * `ticker.standard(...)`) and a timeframe equal to or higher than the chart's. The higher-timeframe bars are
+ * built by grouping the chart bars, and `expression` runs on them (its `ta.*` calls, tuples and `timeframe.*`
+ * see the higher timeframe). Other symbols need external data and throw; a lower timeframe throws.
+ *
+ * PineScript rules: lookahead off shows a period's value from the
+ * bar that completes it; lookahead on from its first bar; gaps on keeps only the bar where the value appears.
+ * Built bars can differ from the exchange's bars (official open / close, volume).
+ */
+function security(symbol, timeframe, expression, gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_off) {
+    collector();
+    const heikin = symbol.startsWith(HEIKIN_ASHI);
+    const base = heikin ? symbol.slice(HEIKIN_ASHI.length) : symbol;
+    if (base !== '' && base !== chartCtx.tickerid) {
+        throw new Error(`request.security: "${symbol}" is not the chart symbol; other symbols need external data.`);
+    }
+    const chart = chartTimeframe();
+    const tf = timeframeCore.info(timeframe || chart.period).period;
+    if (timeframeCore.in_seconds(tf) < timeframeCore.in_seconds(chart.period)) {
+        throw new Error(`request.security: timeframe "${tf}" is lower than the chart timeframe "${chart.period}".`);
+    }
+    const chartBars = ctxBars.bars;
+    const times = chartBars.map(barTime);
+    let htf;
+    let group;
+    let latest;
+    if (tf === chart.period) {
+        htf = chartBars;
+        group = chartBars.map((_, i) => i);
+        latest = group;
+    }
+    else {
+        const { bars: loaded, regular } = sessionBars();
+        // D / W / M periods follow the regular hours; intraday periods the loaded session
+        const calendar = timeframeCore.info(tf).isdwm ? regular : loaded;
+        const starts = times.map((t) => calendar.timeOf(t, tf));
+        const dayPeriods = times.map((t, i) => {
+            const at = loaded.calendar.locate(t);
+            const periods = at ? calendar.calendar.periods(at.date) : [];
+            return periods.length ? calendar.timeOf(periods[0][0], tf) : starts[i];
+        });
+        const reaches = times.map((t) => loaded.closeOf(t, chart.period) >= calendar.periodEnd(t, tf));
+        ({ group, latest } = periodsOf(starts, dayPeriods, reaches));
+        const unit = chartCtx.timeUnit === 'ms' ? 1 : 1000;
+        // a higher-timeframe bar ends at the bar that completes it (no value from after the completion)
+        const after = afterCompletion(group, latest);
+        const kept = (_, i) => !after[i];
+        htf = resample(chartBars.filter(kept), starts.map((s) => s / unit).filter(kept)).bars;
+    }
+    if (heikin)
+        htf = heikinAshi(htf);
+    const savedCtx = chartCtx;
+    let result;
+    let values;
+    ctxBars.setAll(htf);
+    chartCtx = { ...chartCtx, timeframe: tf };
+    try {
+        result = expression();
+        const parts = Array.isArray(result) ? result : [result];
+        values = parts.map((p) => valuesOf(p, htf.length));
+    }
+    finally {
+        ctxBars.setAll(chartBars);
+        chartCtx = savedCtx;
+    }
+    const mapped = values.map((v) => Series.fromArray(ctxBars, mapToChart(v, group, latest, lookahead === barmerge.lookahead_on, gaps === barmerge.gaps_on)));
+    return (Array.isArray(result) ? mapped : mapped[0]);
+}
+/** PineScript `request.*`: `security` for the chart symbol (issue #101). */
+export const request = { security };
+// ── Drawing objects ──────────────────────────────────────────────────────────
+// The drawing namespaces come from this bundle so that they share the registry that
+// executeScript() resets. `line.all` etc. are read like PineScript variables.
+/** PineScript `line.*`; `line.all` lists the live lines in creation order. */
+export const line = {
+    ...lineCore,
+    get all() {
+        return lineCore.all();
+    },
+};
+/** PineScript `label.*`; `label.all` lists the live labels in creation order. */
+export const label = {
+    ...labelCore,
+    get all() {
+        return labelCore.all();
+    },
+};
+/** PineScript `box.*`; `box.all` lists the live boxes in creation order. */
+export const box = {
+    ...boxCore,
+    get all() {
+        return boxCore.all();
+    },
+};
+/** PineScript `linefill.*`; `linefill.all` lists the live linefills in creation order. */
+export const linefill = {
+    ...linefillCore,
+    get all() {
+        return linefillCore.all();
+    },
+};
+/** PineScript `polyline.*`; `polyline.all` lists the live polylines in creation order. */
+export const polyline = {
+    ...polylineCore,
+    get all() {
+        return polylineCore.all();
+    },
+};
+/** PineScript `text.format_*` constants. */
+export const text = { ...textCore };
+/**
+ * PineScript `chart.point.*`. `chart.point.now(price?)` is the point of the current bar
+ * (index, time, and `price`, default the close), so it runs inside eachBar().
+ */
+export const chart = {
+    point: {
+        ...chartPointCore,
+        now(price) {
+            collector();
+            if (currentBar < 0) {
+                throw new Error('chart.point.now() needs a current bar: call it inside eachBar().');
+            }
+            const bar = ctxBars.bars[currentBar];
+            return chartPointCore.new_point(barTime(bar), currentBar, price ?? bar.close);
+        },
+    },
+};
+/** Wraps a plain value array (e.g. a side output accumulated inside eachBar)
+ *  into a Series aligned with the current bars. */
+export function seriesOf(values) {
+    collector();
+    return Series.fromArray(ctxBars, values);
+}
+/** PineScript `alertcondition()` — collected for the host's alert engine. */
+export function alertcondition(condition, title, message) {
+    const c = collector();
+    const id = `alert${c.alertConfig.length}`;
+    c.alertConfig.push({ id, title, message });
+    const last = condition.length() ? condition.last() : NaN;
+    c.alerts.push({ id, title, message, triggered: !isNA(last) && last !== 0 });
+}
+// ── Convenience re-exports ───────────────────────────────────────────────────
+export { Series, BarData, isNA as na, nz };
+export { STRATEGY_DEFAULTS } from '../strategy/index.js';
+/** PineScript `math.*`; `math.round_to_mintick(x)` uses `syminfo.mintick` of the chart context. */
+export const math = {
+    ...mathCore,
+    round_to_mintick: ((number, mintick) => {
+        const tick = mintick ?? syminfo.mintick;
+        return number instanceof Series ? mathCore.round_to_mintick(number, tick) : mathCore.round_to_mintick(number, tick);
+    }),
+};
+export * as compare from '../compare/index.js';
+//# sourceMappingURL=index.js.map