pinets 0.9.14 → 0.9.16

package/dist/types/Context.class.d.ts

@@ -66,6 +66,8 @@ export declare class Context {
     sDate: number;
     eDate: number;
     fullContext: Context;
+    viewportLeft: number | undefined;
+    viewportRight: number | undefined;
     pineTSCode: Function | String;
     inputs: Record<string, any>;
     constructor({ marketData, source, tickerId, timeframe, limit, sDate, eDate, fullContext, inputs, }: {
@@ -144,12 +146,25 @@ export declare class Context {
      */
     iter(source: any): any;
     /**
-     * Resolve an iterable yielding [index, value] tuples for `for [i, x] in collection`
+     * Resolve an iterable yielding [key, value] tuples for `for [k, v] in collection`
      * destructuring codegen. PineArrayObject's [Symbol.iterator] yields scalar values, so
-     * we must explicitly call `.entries()` on the underlying array.
+     * we must explicitly call `.entries()` on the underlying array. PineMapObject stores
+     * its data on `.map` (a JS Map) — without this branch the fallthrough returned an
+     * empty iterator and `for [k,v] in map` silently iterated 0 times.
      */
-    entries(source: any): IterableIterator<[number, any]>;
+    entries(source: any): IterableIterator<[any, any]>;
     private _callStack;
+    /**
+     * Cumulative call-path stack. Each entry is the full path from the root to
+     * the current call, formed by joining the syntactic call-site ids with '|'.
+     *
+     * Pine semantics is per-call-PATH (not per-syntactic-call-site): a function
+     * with internal `var` state, called via two distinct paths through a wrapper,
+     * must keep state independent per path. Keying lctx by the path (rather than
+     * the immediate site id) makes `$$.var.*` slots and `$$.id + '_taN'` ta
+     * callsite ids correctly path-scoped without any transpiler changes.
+     */
+    private _pathStack;
     /**
      * Pushes a call ID onto the stack
      * @param id - The call ID
@@ -160,7 +175,8 @@ export declare class Context {
      */
     popId(): void;
     /**
-     * Returns the current call ID from the top of the stack
+     * Returns the current call PATH (cumulative ids joined by '|') from the top
+     * of the stack. Used as the lctx key for the current function call.
      */
     peekId(): string;
     /**

package/dist/types/PineTS.class.d.ts

@@ -57,6 +57,56 @@ export declare class PineTS {
      * @param mode Alert firing mode
      */
     setAlertMode(mode: 'realtime' | 'all'): void;
+    private _viewportLeft;
+    private _viewportRight;
+    private _usesVisibleRange;
+    private _lastRunViewport;
+    private _lastResult;
+    private _lastPineTSCode;
+    /**
+     * Set the visible range of bars from the host (e.g. chart UI viewport).
+     * Affects `chart.left_visible_bar_time` and `chart.right_visible_bar_time`.
+     * Defaults derive from `marketData[0]/[last].openTime` if never called.
+     *
+     * The setter only stores values; it does NOT trigger a re-run. Call
+     * `update()` afterwards to apply the change. For scripts that don't
+     * reference visible-range built-ins, `update()` is a no-op.
+     *
+     * @param left  openTime of the leftmost visible bar
+     * @param right openTime of the rightmost visible bar
+     */
+    setVisibleRange(left: number, right: number): void;
+    /**
+     * Whether the loaded script references any visible-range built-in
+     * (e.g. `chart.left_visible_bar_time`). Detected statically during
+     * transpile. Consumers fanning viewport changes across many indicators
+     * should skip non-tagged instances to avoid unnecessary re-runs.
+     */
+    usesVisibleRange(): boolean;
+    /** Current viewport left (undefined if setter never called). */
+    get visibleRangeLeft(): number | undefined;
+    /** Current viewport right (undefined if setter never called). */
+    get visibleRangeRight(): number | undefined;
+    /**
+     * Smart re-run: executes `run()` only if a re-run is actually needed.
+     *
+     * - First call: behaves like `run()` (always executes).
+     * - Subsequent calls: returns the cached previous result UNLESS the script
+     *   is viewport-dependent (`usesVisibleRange()`) AND the viewport has
+     *   changed since the last cached run.
+     *
+     * The typical pattern for a chart consumer with multiple indicators:
+     *
+     *     // user pans the chart
+     *     for (const p of indicators) {
+     *         p.setVisibleRange(left, right);
+     *         await p.update(code);   // no-op for non-viewport indicators
+     *     }
+     *
+     * The pineTSCode argument is optional after the first call — the same code
+     * is reused. Pass it again only when the script source itself has changed.
+     */
+    update(pineTSCode?: Indicator | Function | String): Promise<Context>;
     constructor(source: IProvider | any[], tickerId?: string, timeframe?: string, limit?: number, sDate?: number, eDate?: number);
     setDebugSettings({ ln, debug }: {
         ln: boolean;
@@ -98,6 +148,16 @@ export declare class PineTS {
      * Run the script completely and return the final context (backward compatible behavior)
      * @private
      */
+    /**
+     * Run an already-transpiled PineTS function in this instance — no
+     * additional transpile/parse pass. Used by `request.security_lower_tf`'s
+     * slow path to execute the slice produced at primary-transpile time
+     * (a truncated body containing only the prefix up to the call). The
+     * caller is responsible for ensuring `transpiledFn` was produced by
+     * this transpiler against the same source — calling this with an
+     * arbitrary function is unsafe.
+     */
+    runPretranspiled(transpiledFn: Function, inputs?: Record<string, any>, periods?: number): Promise<Context>;
     private _runComplete;
     /**
      * Run the script with pagination, yielding results page by page
@@ -186,6 +246,21 @@ export declare class PineTS {
      * @private
      */
     private _transpileCode;
+    /**
+     * Static analysis on the transpiled function body to detect references to
+     * host-bound built-ins (currently visible-range; extensible via
+     * VIEWPORT_DEPENDENT_BUILTINS). Comments are stripped during pine2js, so
+     * scanning the post-transpile output is comment-safe.
+     *
+     * Why post-transpile (not regex on Pine source): a `chart.left_visible_bar_time`
+     * literal inside a // comment would be a false positive at the source level.
+     * After pine2js, only live code remains.
+     *
+     * Why regex (not AST visitor): `chart` is a reserved namespace in
+     * KNOWN_NAMESPACES — Pine scripts cannot shadow it with a local identifier,
+     * so a whole-word match on `chart.<prop>` is unambiguous.
+     */
+    private _detectViewportUsage;
     /**
      * Execute iterations from startIdx to endIdx, updating the context
      * @private

package/dist/types/namespaces/Core.d.ts

@@ -1,4 +1,3 @@
-import { PineTypeObject } from './PineTypeObject';
 import type { IndicatorOptions } from '../types/PineTypes';
 export declare function parseIndicatorOptions(args: any[]): Partial<IndicatorOptions>;
 /**
@@ -84,8 +83,5 @@ export declare class Core {
     int(series: any): number;
     float(series: any): number;
     string(series: any): any;
-    Type(definition: Record<string, string | [string, any]>): {
-        new: (...args: any[]) => PineTypeObject;
-        copy: (object: PineTypeObject) => PineTypeObject;
-    };
+    Type(definition: Record<string, string | [string, any]>): any;
 }

package/dist/types/namespaces/PineTypeObject.d.ts

@@ -2,7 +2,19 @@ export declare class PineTypeObject {
     private _definition;
     context: any;
     get __def__(): Record<string, string>;
-    constructor(_definition: Record<string, string>, context: any);
+    /**
+     * Back-reference to the UDT factory that produced this instance.
+     * Used by `request.security_lower_tf`'s pure-builtin fast path to
+     * detect UDTs whose field defaults are all bare price builtins
+     * (e.g. `type candle { float o = open; float h = high; … }`) — when
+     * detected, the secondary's per-LTF-bar values can be synthesised
+     * directly from the candle stream without running any user script.
+     * Optional and nullable: instances created outside `Type().new` (or
+     * for legacy / direct constructions) leave this undefined and the
+     * fast path simply doesn't engage.
+     */
+    _udt?: any;
+    constructor(_definition: Record<string, string>, context: any, _udt?: any);
     copy(): PineTypeObject;
     toString(): string;
 }

package/dist/types/namespaces/Ticker.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Pine Script `ticker.*` namespace.
+ *
+ * The methods here construct "ticker ID" strings that are passed to
+ * `request.security` / `request.security_lower_tf` to fetch data for a
+ * specific symbol — potentially with extra modifiers (session,
+ * adjustment, non-standard chart type). PineTS' data providers serve
+ * standard candles only; chart-type modifiers (Heikin-Ashi, Renko,
+ * Kagi, Line Break, Point & Figure) are silently dropped at the
+ * `request.security` boundary, since we can't render alternative
+ * bar-construction algorithms from the raw OHLCV feed.
+ *
+ * For the plain "no-modifier" cases — which cover virtually every
+ * real-world Pine script — the returned tickerid strings match
+ * TradingView's exact log output, so automation tests pass strictly.
+ * Non-default `adjustment` values trigger TV's encoded
+ * `={"adjustment":"…","symbol":"…"}` form; PineTS only emits the
+ * plain symbol there (since `request.security` doesn't honor
+ * adjustment either). Document as a known divergence.
+ */
+export declare class Ticker {
+    private context;
+    constructor(context: any);
+    /**
+     * Type B param wrapper — extract scalar from series/primitive.
+     * Used by the transpiler to wrap ticker.* arguments.
+     */
+    param(source: any, index?: number, _name?: string): any;
+    /**
+     * ticker.inherit(from_tickerid, symbol) → simple string
+     *
+     * Returns a ticker ID that uses `symbol` and inherits modifier
+     * settings (session, currency, adjustment, chart type) from
+     * `from_tickerid`. For data-fetching purposes the result is
+     * effectively `symbol` — modifiers can't be honored without a TV
+     * datafeed, and `symbol` is what `request.security` needs.
+     */
+    inherit(_from_tickerid: any, symbol: any): string;
+    /**
+     * ticker.new(prefix, ticker, session?, adjustment?, ...) → simple string
+     *
+     * Returns "prefix:ticker". Modifier arguments are accepted but
+     * ignored — see class-level note. Returns an empty string if
+     * either prefix or ticker is empty (matches TV).
+     */
+    new(prefix: any, ticker: any, _session?: any, _adjustment?: any, _backadjustment?: any, _settlement_as_close?: any): string;
+    /**
+     * ticker.modify(tickerid, session?, adjustment?, ...) → simple string
+     *
+     * Returns the tickerid unchanged — modifier args are accepted but
+     * ignored.
+     */
+    modify(tickerid: any, _session?: any, _adjustment?: any, _backadjustment?: any, _settlement_as_close?: any): string;
+    /**
+     * ticker.standard(symbol?) → simple string
+     *
+     * Returns the symbol stripped of any non-standard chart-type
+     * modifiers. Since PineTS doesn't synthesise non-standard chart
+     * types in the first place, this is effectively a pass-through
+     * (the standard form IS what our providers serve). If `symbol` is
+     * undefined, falls back to `syminfo.tickerid`.
+     */
+    standard(symbol?: any): string;
+    /**
+     * ticker.heikinashi(symbol) → simple string
+     *
+     * In TV this returns an encoded tickerid that instructs the
+     * datafeed to deliver Heikin-Ashi bars. PineTS' providers don't
+     * synthesise HA candles, so we return the plain symbol — downstream
+     * `request.security` fetches standard candles, NOT HA-transformed
+     * ones. Behavior diverges from TV when the script depends on the
+     * HA values matching TV's HA computation. Documented limitation.
+     */
+    heikinashi(symbol: any): string;
+    /**
+     * ticker.renko(symbol, style?, param?, request_wicks?, source?) → simple string
+     *
+     * Stub: returns the plain symbol. See heikinashi() note.
+     */
+    renko(symbol: any, _style?: any, _param?: any, _request_wicks?: any, _source?: any): string;
+    /**
+     * ticker.kagi(symbol, reversal) → simple string
+     *
+     * Stub: returns the plain symbol. See heikinashi() note.
+     */
+    kagi(symbol: any, _reversal?: any): string;
+    /**
+     * ticker.linebreak(symbol, number_of_lines) → simple string
+     *
+     * Stub: returns the plain symbol. See heikinashi() note.
+     */
+    linebreak(symbol: any, _number_of_lines?: any): string;
+    /**
+     * ticker.pointfigure(symbol, source, style, param, reversal) → simple string
+     *
+     * Stub: returns the plain symbol. See heikinashi() note.
+     */
+    pointfigure(symbol: any, _source?: any, _style?: any, _param?: any, _reversal?: any): string;
+    /**
+     * Coerce a runtime value to a plain string. Handles Series wrappers
+     * (used by the transpiler), `na`/null/undefined, and primitives.
+     */
+    private _coerce;
+}

package/dist/types/namespaces/silentInSecondary.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `@silentInSecondary` — method decorator.
+ *
+ * Marks a helper method as a no-op when invoked on a secondary context
+ * (i.e. the auxiliary PineTS instance that `request.security` /
+ * `request.security_lower_tf` spawns to compute the captured expression
+ * at another symbol/timeframe).
+ *
+ * Drawings, plots, alerts and similar side-effect-only operations are
+ * never observable from a secondary context — its sole job is to populate
+ * `secContext.params[expression_name]` with the value of the captured
+ * expression bar-by-bar. Silencing those operations on secondaries cuts
+ * the per-bar work substantially without changing the captured value
+ * (the only output that callers ever read).
+ *
+ * Constructor-style methods (e.g. `label.new`, `line.new`, `box.new`)
+ * return `null`; setters / mutators / deletes return `undefined`. The
+ * existing helper code is null-safe end-to-end:
+ *   - `get_*` methods already return `NaN`/`""` when the receiver is null.
+ *   - The transpiler emits method calls on UDT-typed receivers as
+ *     `obj?.method?.(...)`, so `null?.set_x1?.(...)` short-circuits.
+ *   - Built-in setters like `LineHelper.set_x1(id, x)` already guard
+ *     `if (id && !id._deleted) ...` and no-op on null.
+ *
+ * Pre-condition: target classes use the conventional
+ *   `constructor(private context: any) {}`
+ * shape, so `this.context.isSecondaryContext` is uniformly accessible.
+ * (`Core.ts` `AlertHelper`, `Plots.ts` `PlotHelper`/`HlineHelper`/
+ * `FillHelper`, and the drawing helpers all conform.)
+ */
+export declare function silentInSecondary(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;

package/dist/types/transpiler/analysis/ScopeManager.d.ts

@@ -99,6 +99,14 @@ export declare class ScopeManager {
     pushScope(type: string): void;
     popScope(): void;
     getCurrentScopeType(): string;
+    /**
+     * True when any active scope on the stack is a function scope.
+     * Different from `getCurrentScopeType() === 'fn'`, which only matches
+     * the immediate scope — code inside a nested `if`/`for`/`while` inside
+     * a function body still needs the function-scope context (e.g. for
+     * call-path-keyed param/ta-callsite ids).
+     */
+    isInsideFunctionScope(): boolean;
     getCurrentScopeCount(): number;
     addLocalSeriesVar(name: string): void;
     removeLocalSeriesVar(name: string): void;

package/dist/types/transpiler/pineToJS/lexer.d.ts

@@ -14,6 +14,14 @@ export declare class Lexer {
     tokenize(): Token[];
     handleNewline(): void;
     handleIndentation(): void;
+    /**
+     * True when the most recently emitted token (skipping NEWLINE / COMMENT
+     * — those are layout, not content) is a token that requires a right-
+     * hand-side and therefore implies the next non-blank line is a
+     * continuation, not a new block. Mirrors the set the parser's
+     * `peekOperatorEx` already crosses NEWLINE for.
+     */
+    private isContinuationFromPrevToken;
     readComment(): void;
     readString(): void;
     readColorLiteral(): void;

package/dist/types/transpiler/settings.d.ts

@@ -1,6 +1,7 @@
 export declare const KNOWN_NAMESPACES: string[];
 export declare const NAMESPACES_LIKE: string[];
 export declare const ASYNC_METHODS: string[];
+export declare const VIEWPORT_DEPENDENT_BUILTINS: string[];
 export declare const FACTORY_METHODS: string[];
 export declare const NAMESPACE_COLLISION_NAMES: Set<string>;
 export declare const JS_RESERVED_WORDS: Set<string>;

package/dist/types/transpiler/slicing/buildLtfSlices.d.ts

@@ -0,0 +1 @@
+export declare function buildLtfSlices(ast: any): Record<string, Function>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.9.14",
+    "version": "0.9.16",
     "description": "Run Pine Script anywhere. PineTS is an open-source transpiler and runtime that brings Pine Script logic to Node.js and the browser with 1:1 syntax compatibility. Reliably write, port, and run indicators or strategies on your own infrastructure.",
     "keywords": [
         "Pine Script",