Merge pull request #196 from LuxAlgo/dev

## [0.9.14] - 2026-05-05 - UDT & Transpiler Hardening, `request.security`, Streaming & Drawing `na`

Author: alaa-eddine

CHANGELOG.md

@@ -1,5 +1,34 @@
 # Change Log
 
+## [0.9.14] - 2026-05-05 - UDT & Transpiler Hardening, `request.security`, Streaming & Drawing `na`
+
+### Added
+
+- **`str.format_time(time, format, timezone)`**: Full string-based time formatting aligned with Pine Script (`Str.ts`, tests in `str.test.ts`).
+- **`for...of` runtime helpers**: Codegen uses **`$.iter`** / **`$.entries`** instead of brittle one-off special cases.
+- **UDT registry pre-pass**: **`preProcessUdtRegistry`** runs before analysis so **`ScopeManager`** is populated consistently (5 dedicated tests).
+
+### Fixed
+
+- **Live streaming with `eDate`**: **`runLive`** / live mode now works when an end date is provided; previously the combination was incorrectly rejected or behaved as non-live (**`PineTS.class.ts`**).
+- **`for...in` over `MemberExpression` iterables**: Destructuring in **`for...in`** when the iterable is a member expression (e.g. chained property access) is transformed correctly (**`MainTransformer`**).
+- **`request.security`**: Named arguments resolve through **`parseArgsForPineParams`** with **array/tuple-aware** `remaining_options`; secondary-context **bar alignment** improved; **`calc_bars_count`** threaded through the security pipeline.
+- **Callable drawing/table namespaces**: **`box`**, **`linefill`**, **`polyline`**, **`table`** — fixes for correct call vs instance dispatch in transpiled code.
+- **Reserved words in generated JS**: Transpiler avoids invalid identifiers when Pine names collide with JavaScript reserved words.
+- **Comma-separated typed declarations**: Multiple declarations on one line with shared type; guard tightened so **`chart.point[] a = ..., chart.point[] b = ...`** (dotted / repeated types) is split handled as separate statements instead of mis-parsing (**`parseTypedVarDeclaration`**).
+- **Contextual Pine Script keywords**: Parser treats keywords contextually so valid identifiers / constructs are not broken by overly greedy keyword rules.
+- **UDT field subscripts in call arguments**: Per-bar lookback (`seriesVar.field[1]`) inside function-call arguments is transformed correctly.
+- **UDT field-subscript & method transpiler**: Broader fixes for member access and methods on UDT instances.
+- **UDT `.new()` mixed positional + named args**: When the last argument is a plain object whose keys match UDT field names, it is stripped and applied as named fields instead of shifting positional slots (**`Core.ts` UDT constructor**).
+- **UFCS `obj.method()`**: Method names that are JS reserved words keep correct **`$M_`** naming without double **`_$N`** renames; **`Holder r = arr.get(0)`** with an explicit UDT type registers **`r`** for instance dispatch; **`.delete()`** on built-in drawing objects is not retargeted as a user method.
+- **Typed `na` for drawings**: **`box(na)`**, **`line(na)`**, **`label(na)`**, **`polyline(na)`**, **`linefill(na)`**, **`table(na)`** behave as Pine **typed `na`** / casts, not as calls that build empty drawing instances.
+- **UDT registration across function parameters**: Exiting a function that took a UDT parameter no longer clears outer-scope UDT-instance bindings — prior registrations are **snapshotted and restored** so patterns like **`var T x = T.new(...)`** plus **`foo(T x)`** still resolve **`x.foo()`** later.
+- **Plots & deleted drawings**: Deleted drawing objects are **omitted** from generated plot payloads so consumers do not see stale handles.
+- **Default colors**: Restored sensible default stroke/fill styling for **`box`** and **`polyline`** when colors are omitted.
+- **Documentation**: Various doc updates (merged with this release train).
+
+---
+
 ## [0.9.12] - 2026-04-15 - FMP Provider: `mintick`, Forex vs Crypto & Resilient `getSymbolInfo`
 
 ### Added

package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.9.13",
+    "version": "0.9.14",
     "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",

src/Context.class.ts

@@ -736,6 +736,37 @@ export class Context {
         }
     }
 
+    /**
+     * Resolve an iterable for `for x in collection` codegen.
+     * Handles PineArrayObject (unwrap to inner JS array) and plain JS arrays uniformly.
+     * Returns the value itself if it's already iterable (Map, Set, etc.).
+     *
+     * Centralizing this here means the transpiler can emit a uniform shape regardless of
+     * whether the iterable is a built-in returning a plain array (e.g. box.all) or a UDT
+     * field holding a PineArrayObject — and future collection types only need to update
+     * this helper, not the codegen.
+     */
+    iter(source: any): any {
+        if (source == null) return [];
+        // PineArrayObject wraps the underlying JS array as `.array`
+        if (Array.isArray(source.array)) return source.array;
+        return source;
+    }
+
+    /**
+     * Resolve an iterable yielding [index, value] tuples for `for [i, x] in collection`
+     * destructuring codegen. PineArrayObject's [Symbol.iterator] yields scalar values, so
+     * we must explicitly call `.entries()` on the underlying array.
+     */
+    entries(source: any): IterableIterator<[number, any]> {
+        if (source == null) return [].entries();
+        if (Array.isArray(source.array)) return source.array.entries();
+        if (Array.isArray(source)) return source.entries();
+        // Map / Set / other iterables that already yield tuples
+        if (typeof source.entries === 'function') return source.entries();
+        return [].entries();
+    }
+
     //#region [Call Stack Management] ===========================
 
     private _callStack: string[] = [];

src/namespaces/Core.ts

@@ -81,7 +81,13 @@ export class NAHelper {
     }
 
     any(series: any) {
+        // Pine Script function defaults like `param = na` get transpiled to JS
+        // `param = na`, where `na` is this NAHelper instance. When the caller
+        // omits the argument, the parameter ends up holding the helper itself
+        // — which must be recognised as NA, not as a regular object.
+        if (series instanceof NAHelper) return true;
         const val = Series.from(series).get(0);
+        if (val instanceof NAHelper) return true;
         // null/undefined are always na
         if (val === null || val === undefined) return true;
         // For numbers, check NaN (Pine Script na for numeric types)
@@ -191,7 +197,15 @@ export class Core {
         return _options;
     }
     indicator(...args) {
-        const options = parseIndicatorOptions(args);
+        // The transpiler wraps every positional arg with `$.param(...)`, which
+        // promotes booleans / numbers to a `Series` instance (strings and
+        // objects pass through as-is). Multi-signature matching in
+        // `parseArgsForPineParams` then fails the `boolean` / `number` type
+        // checks because a Series is neither — so `overlay=true`,
+        // `precision=N`, etc. silently drop back to defaults. Unwrap any
+        // Series here to expose the underlying scalar.
+        const unwrapped = args.map(a => a instanceof Series ? a.get(0) : a);
+        const options = parseIndicatorOptions(unwrapped);
 
         const defaults = {
             title: '',
@@ -494,23 +508,28 @@ export class Core {
                 // Map positional args to field names, applying defaults for missing args
                 const mappedArgs: Record<string, any> = {};
 
-                // Detect named args object: if the first (and only) argument is a plain
-                // object whose keys match field names, treat it as named arguments.
-                // This handles the Pine pattern: MyType.new(field1 = val1, field2 = val2)
-                // which the transpiler converts to: MyType.new({ field1: val1, field2: val2 })
+                // Detect a trailing named-args object. The transpiler turns
+                //   MyType.new(p1, p2, named1 = v1, named2 = v2)
+                // into
+                //   MyType.new(p1, p2, { named1: v1, named2: v2 })
+                // The named-args object is always the LAST positional, so check
+                // args[args.length - 1] — not args[0]. Pure-named calls (length 1)
+                // and mixed positional+named calls are both handled by this rule.
                 let namedArgs: Record<string, any> | null = null;
-                if (
-                    args.length === 1 &&
-                    args[0] &&
-                    typeof args[0] === 'object' &&
-                    !(args[0] instanceof Series) &&
-                    !Array.isArray(args[0]) &&
-                    !(args[0] instanceof PineTypeObject)
-                ) {
-                    const keys = Object.keys(args[0]);
-                    if (keys.length > 0 && keys.some((k) => definitionKeys.includes(k))) {
-                        namedArgs = args[0];
-                        args = []; // Clear positional args
+                if (args.length > 0) {
+                    const last = args[args.length - 1];
+                    if (
+                        last &&
+                        typeof last === 'object' &&
+                        !(last instanceof Series) &&
+                        !Array.isArray(last) &&
+                        !(last instanceof PineTypeObject)
+                    ) {
+                        const keys = Object.keys(last);
+                        if (keys.length > 0 && keys.some((k) => definitionKeys.includes(k))) {
+                            namedArgs = last;
+                            args = args.slice(0, -1);
+                        }
                     }
                 }
 

src/namespaces/Str.ts

@@ -3,6 +3,14 @@
 import { Series } from '../Series';
 import { Context } from '..';
 import { PineArrayObject, PineArrayType } from './array/PineArrayObject';
+import { getDatePartsInTimezone } from './Time';
+
+const MONTH_SHORT = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const MONTH_LONG = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+const DAY_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const DAY_LONG = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+const pad = (n: number, len: number) => String(n).padStart(len, '0');
 
 export class Str {
     constructor(private context: Context) {}
@@ -133,6 +141,109 @@ export class Str {
         return String(source).substring(begin_pos, end_pos);
     }
 
+    /**
+     * Format a UNIX millisecond timestamp using Java SimpleDateFormat-style tokens
+     * (yyyy, MM, dd, HH, mm, ss, EEE, EEEE, MMM, MMMM, a, h, S, Z, etc.).
+     * Text inside single quotes is treated as a literal; '' produces a literal '.
+     */
+    format_time(time: any, format: string = "yyyy-MM-dd'T'HH:mm:ssZ", timezone?: string) {
+        if (time === null || time === undefined || (typeof time === 'number' && isNaN(time))) {
+            return 'NaN';
+        }
+        const ts = Number(time);
+        const tz = timezone || this.context.pine?.syminfo?.timezone || 'UTC';
+        const parts = getDatePartsInTimezone(ts, tz);
+
+        // Compute timezone offset (for Z token) by comparing tz-local recomposed UTC ms to actual ts
+        const tzAsUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+        const offsetMin = Math.round((tzAsUtc - ts) / 60000);
+
+        // Day of year (in target tz)
+        const startOfYearUtc = Date.UTC(parts.year, 0, 1);
+        const dayOfYear = Math.floor((tzAsUtc - startOfYearUtc) / 86400000) + 1;
+
+        const hour12 = parts.hour % 12 === 0 ? 12 : parts.hour % 12;
+
+        let result = '';
+        let i = 0;
+        while (i < format.length) {
+            const ch = format[i];
+
+            // Single-quoted literal
+            if (ch === "'") {
+                if (format[i + 1] === "'") { result += "'"; i += 2; continue; }
+                const end = format.indexOf("'", i + 1);
+                if (end === -1) { result += format.substring(i + 1); break; }
+                result += format.substring(i + 1, end);
+                i = end + 1;
+                continue;
+            }
+
+            // Pattern token: count consecutive same-letter chars
+            if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
+                let count = 1;
+                while (format[i + count] === ch) count++;
+                i += count;
+
+                switch (ch) {
+                    case 'y':
+                        result += count === 2 ? pad(parts.year % 100, 2) : count >= 4 ? pad(parts.year, 4) : String(parts.year);
+                        break;
+                    case 'M':
+                        if (count >= 4) result += MONTH_LONG[parts.month - 1];
+                        else if (count === 3) result += MONTH_SHORT[parts.month - 1];
+                        else if (count === 2) result += pad(parts.month, 2);
+                        else result += String(parts.month);
+                        break;
+                    case 'd':
+                        result += count === 2 ? pad(parts.day, 2) : String(parts.day);
+                        break;
+                    case 'D':
+                        result += count >= 3 ? pad(dayOfYear, 3) : count === 2 ? pad(dayOfYear, 2) : String(dayOfYear);
+                        break;
+                    case 'E':
+                        result += count >= 4 ? DAY_LONG[parts.dayOfWeek] : DAY_SHORT[parts.dayOfWeek];
+                        break;
+                    case 'a':
+                        result += parts.hour < 12 ? 'AM' : 'PM';
+                        break;
+                    case 'h':
+                        result += count === 2 ? pad(hour12, 2) : String(hour12);
+                        break;
+                    case 'H':
+                        result += count === 2 ? pad(parts.hour, 2) : String(parts.hour);
+                        break;
+                    case 'm':
+                        result += count === 2 ? pad(parts.minute, 2) : String(parts.minute);
+                        break;
+                    case 's':
+                        result += count === 2 ? pad(parts.second, 2) : String(parts.second);
+                        break;
+                    case 'S': {
+                        const ms = ts - Math.floor(ts / 1000) * 1000;
+                        result += pad(ms, 3).substring(0, count);
+                        break;
+                    }
+                    case 'Z': {
+                        const sign = offsetMin >= 0 ? '+' : '-';
+                        const absMin = Math.abs(offsetMin);
+                        result += `${sign}${pad(Math.floor(absMin / 60), 2)}${pad(absMin % 60, 2)}`;
+                        break;
+                    }
+                    default:
+                        // Unknown letter token — leave as-is
+                        result += ch.repeat(count);
+                }
+                continue;
+            }
+
+            // Literal char
+            result += ch;
+            i++;
+        }
+        return result;
+    }
+
     format(message: string, ...args: any[]) {
         // Handle both simple {0} and extended {0,number,#.##} patterns
         return message.replace(/\{(\d+)(?:,number,([^}]+))?\}/g, (match, index, fmt) => {

src/namespaces/box/BoxHelper.ts

@@ -45,7 +45,7 @@ export class BoxHelper {
     public syncToPlot() {
         this._ensurePlotsEntry();
         const time = this.context.marketData[0]?.openTime || 0;
-        const allPlotData = this._boxes.map(bx => bx.toPlotData());
+        const allPlotData = this._boxes.filter(bx => !bx._deleted).map(bx => bx.toPlotData());
 
         // Split force_overlay objects into a separate overlay plot (renders on main chart pane)
         const regular = allPlotData.filter((b: any) => !b.force_overlay);
@@ -91,13 +91,15 @@ export class BoxHelper {
     }
 
     /**
-     * Resolve a color value, preserving NaN (na) so renderers can detect "no color".
-     * The regular `_resolve(val) || fallback` pattern treats NaN as falsy and replaces
-     * it with the default, losing the explicit `border_color = na` intent.
+     * Resolve a color value, preserving na markers so renderers can detect "no color".
+     * Pine emits na either as NaN (from `bgcolor = na`) or as null (from
+     * `bgcolor = color(na)` — `color(na)` returns null per PineColor.any). Both
+     * must survive — replacing them with a default would force renderers to paint
+     * a visible color where the script asked for none.
      */
     private _resolveColor(val: any, fallback: string): any {
         const resolved = this._resolve(val);
-        // NaN means `na` in Pine Script — preserve it so renderers can detect it
+        if (resolved === null || resolved === undefined) return resolved;
         if (typeof resolved === 'number' && isNaN(resolved)) return NaN;
         return resolved || fallback;
     }
@@ -202,7 +204,25 @@ export class BoxHelper {
         );
     }
 
-    any(...args: any[]): BoxObject {
+    any(...args: any[]): BoxObject | null {
+        // Pine `box(arg)` is a type cast / typed-na, NOT a constructor:
+        //   box bx = box(na)         → typed-na (na(bx) is true)
+        //   box bx = box(some_box)   → no-op cast (bx === some_box)
+        // The constructor is `box.new(...)`. Multi-arg calls fall through to
+        // .new() to preserve any incidental usage.
+        if (args.length === 1) {
+            const arg = args[0];
+            if (arg === null || arg === undefined) return null;
+            if (arg instanceof NAHelper) return null;
+            if (typeof arg === 'number' && isNaN(arg)) return null;
+            if (arg instanceof BoxObject) return arg;
+            if (arg instanceof Series) {
+                const v = arg.get(0);
+                if (v === null || v === undefined || (typeof v === 'number' && isNaN(v))) return null;
+                if (v instanceof BoxObject) return v;
+            }
+            return null;
+        }
         return this.new(...args);
     }
 

src/namespaces/label/LabelHelper.ts

@@ -44,7 +44,7 @@ export class LabelHelper {
     public syncToPlot() {
         this._ensurePlotsEntry();
         const time = this.context.marketData[0]?.openTime || 0;
-        const allPlotData = this._labels.map(lbl => lbl.toPlotData());
+        const allPlotData = this._labels.filter(lbl => !lbl._deleted).map(lbl => lbl.toPlotData());
 
         // Split force_overlay objects into a separate overlay plot (renders on main chart pane)
         const regular = allPlotData.filter((l: any) => !l.force_overlay);
@@ -184,7 +184,21 @@ export class LabelHelper {
     }
 
     // label() direct call — mapped via NAMESPACES_LIKE → label.any()
-    any(...args: any[]): LabelObject {
+    // Pine `label(arg)` is a type cast / typed-na, NOT a constructor.
+    any(...args: any[]): LabelObject | null {
+        if (args.length === 1) {
+            const arg = args[0];
+            if (arg === null || arg === undefined) return null;
+            if (arg instanceof NAHelper) return null;
+            if (typeof arg === 'number' && isNaN(arg)) return null;
+            if (arg instanceof LabelObject) return arg;
+            if (arg instanceof Series) {
+                const v = arg.get(0);
+                if (v === null || v === undefined || (typeof v === 'number' && isNaN(v))) return null;
+                if (v instanceof LabelObject) return v;
+            }
+            return null;
+        }
         return this.new(...args);
     }