@pineforge/codegen-pyodide 0.10.4 → 1.0.0-rc.1

package/pineforge_codegen/codegen/tables.py

@@ -16,7 +16,33 @@ consumers should never reach for them directly.
 
 from __future__ import annotations
 
+import re
+
 from ..symbols import PineType
+from .helpers import (
+    evaluate_args_once, na_preserving_int_cast, pine_index_int_cast,
+    pine_truth_cast,
+)
+
+
+_PROVEN_INT_ARG = re.compile(
+    r"^\s*(?:(?:[-+]?\d+)|get_input_int\(.*\)|pine_(?:bar_index|year|month|dayofmonth|dayofweek|hour|minute|second|weekofyear)\(.*\))\s*$"
+)
+
+
+def _matrix_int_arg(value: str) -> str:
+    """Keep old casts for typed integer matrix indices; guard other values."""
+    if _PROVEN_INT_ARG.fullmatch(value):
+        return f"(int)({value})"
+    return pine_index_int_cast(value)
+
+
+def _pine_bool_arg(value: str) -> str:
+    """Keep literal bool spellings; guard numeric/dynamic bool arguments."""
+    stripped = value.strip()
+    if stripped in {"true", "false"}:
+        return value
+    return pine_truth_cast(value)
 
 
 # ---------------------------------------------------------------------------
@@ -75,6 +101,15 @@ def tz_time_field_lambda(field_expr: str, ts_arg: str, tz_arg: str) -> str:
     )
 
 
+# ``alert.freq_*``: TradingView's ``const string`` values. A TradingView tape
+# spells them as order comments: "all", "once_per_bar", "once_per_bar_close".
+ALERT_FREQ_VALUES = {
+    "freq_all": "all",
+    "freq_once_per_bar": "once_per_bar",
+    "freq_once_per_bar_close": "once_per_bar_close",
+}
+
+
 BAR_BUILTINS = {
     "bar_index": "pine_bar_index()",
     "time": "current_bar_.timestamp",
@@ -113,6 +148,7 @@ BAR_SERIES_PUSH = {
     "hl2": "((current_bar_.high + current_bar_.low) / 2.0)",
     "hlc3": "((current_bar_.high + current_bar_.low + current_bar_.close) / 3.0)",
     "ohlc4": "((current_bar_.open + current_bar_.high + current_bar_.low + current_bar_.close) / 4.0)",
+    "hlcc4": "((current_bar_.high + current_bar_.low + current_bar_.close + current_bar_.close) / 4.0)",
 }
 
 # Bar identifiers that refer to the *security* (HTF) bar inside
@@ -124,6 +160,12 @@ SECURITY_BAR_FIELD_EXPRS = {
     "close": "bar.close",
     "volume": "bar.volume",
     "time": "bar.timestamp",
+    # The derived series, as the engine computes its source series of a bar;
+    # their history is the requested bar's, like ``close[1]``'s.
+    "hl2": "((bar.high + bar.low) / 2.0)",
+    "hlc3": "((bar.high + bar.low + bar.close) / 3.0)",
+    "ohlc4": "((bar.open + bar.high + bar.low + bar.close) / 4.0)",
+    "hlcc4": "((bar.high + bar.low + bar.close + bar.close) / 4.0)",
 }
 SECURITY_BAR_FIELD_TYPES = {
     "open": "double",
@@ -132,8 +174,12 @@ SECURITY_BAR_FIELD_TYPES = {
     "close": "double",
     "volume": "double",
     "time": "int64_t",
+    "time_close": "int64_t",
 }
-SECURITY_BAR_FIELDS = frozenset(SECURITY_BAR_FIELD_EXPRS)
+# ``time_close`` is the requested bar's close time, which depends on the
+# requested timeframe: the evaluator renders it (security.py
+# ``_security_bar_field_expr``) instead of a fixed ``bar.*`` read.
+SECURITY_BAR_FIELDS = frozenset(SECURITY_BAR_FIELD_EXPRS) | {"time_close"}
 
 # Backwards-compatible name for consumers that only need the OHLCV subset.
 SECURITY_OHLC_BAR_FIELDS = frozenset({"open", "high", "low", "close", "volume"})
@@ -153,6 +199,24 @@ RUNTIME_REGISTER_SECURITY_EVAL_FN = "register_security_eval"
 # higher-or-equal TF requests with a precise diagnostic.
 RUNTIME_REGISTER_SECURITY_LOWER_TF_EVAL_FN = "register_security_lower_tf_eval"
 
+# TradingView's Pine v6 ``strategy()`` defaults for the three parameters whose
+# default it changed on 2026-09-24: an omitted ``initial_capital`` is 100000,
+# an omitted ``default_qty_type`` is ``strategy.percent_of_equity``, and an
+# omitted ``default_qty_value`` is 100 whatever the quantity type (100
+# contracts under ``strategy.fixed``, 100 of the account currency under
+# ``strategy.cash``). Pine v5 kept 1000000 / ``strategy.fixed`` / 1, which are
+# still the source host's own ``PineStrategyConfig`` defaults, so the
+# constructor declares these three whenever a script omits them (the analyzer
+# admits Pine v6 only). Every other ``strategy()`` parameter the lane probed --
+# currency, commission, slippage, margin, pyramiding, process_orders_on_close,
+# close_entries_rule, use_bar_magnifier -- kept its default, which stays the
+# host's. Pinned by TradingView tapes (``tests/fixtures/strategy_defaults``).
+PINE_V6_STRATEGY_DEFAULTS = {
+    "initial_capital": 100000.0,
+    "default_qty_type": "strategy.percent_of_equity",
+    "default_qty_value": 100.0,
+}
+
 
 # ---------------------------------------------------------------------------
 # TA dispatch tables
@@ -173,7 +237,7 @@ TA_COMPUTE_ARGS = {
     "stoch": [0, 1, 2],
     "highest": [0], "lowest": [0],
     "crossover": [0, 1], "crossunder": [0, 1], "cross": [0, 1],
-    "change": [0],
+    "change": [0, 1],    # source + length (the ctor only bounds the history)
     "supertrend": [],    # supertrend gets bar data implicitly
     "dmi": [],           # dmi gets bar data implicitly
     "bb": [0],
@@ -215,8 +279,9 @@ TA_COMPUTE_ARGS = {
     "wvad": [],
     "iii": [],
     "vwap": [0],  # source explicit, volume appended
-    # 3-arg bands form: only source (arg 0) goes to compute(); anchor (arg 1) is
-    # the Pine series gate (not forwarded); stdev_mult (arg 2) went to the ctor.
+    # 3-arg bands form without an explicit anchor: source (arg 0) goes to
+    # compute(); stdev_mult (arg 2) goes to the ctor. Explicit anchors are
+    # remapped to the anchored shim by the analyzer.
     "vwap_bands": [0],
     "mode": [0], "range": [0], "dev": [0],
     "max": [0], "min": [0], "rci": [0],
@@ -282,6 +347,7 @@ TA_TUPLE_FIELDS = {
     "dmi": ["diplus", "diminus", "adx"],
     # ta.vwap 3-arg bands form → VWAPBandsResult {vwap, upper, lower}
     "vwap_bands": ["vwap", "upper", "lower"],
+    "vwap_anchored_bands": ["vwap", "upper", "lower"],
 }
 
 
@@ -306,7 +372,7 @@ PINE_TYPE_TO_CPP = {
     PineType.INT: "int", PineType.FLOAT: "double", PineType.BOOL: "bool",
     PineType.STRING: "std::string", PineType.NA: "double",
     PineType.UNKNOWN: "double", PineType.VOID: "double",
-    PineType.COLOR: "int",
+    PineType.COLOR: "int64_t",
     # Drawing-objects-as-data: the value-view handle structs (see
     # drawing.hpp). Explicit-hint decls (``var line x``), UDT-method drawing
     # params, and ``_type_for_decl`` resolve through here.
@@ -379,7 +445,13 @@ SYMINFO_MEMBER_MAP = {
     "currency": "syminfo_.currency",
     "basecurrency": "syminfo_.basecurrency",
     "type": "syminfo_.type",
-    "timezone": "syminfo_.timezone",
+    # TradingView spells a UTC exchange zone "Etc/UTC" (lab tv tapes
+    # te_syminfo_timezone on BINANCE:ETHUSDT.P 15 and BINANCE:BTCUSDT 1D:
+    # syminfo.timezone == "UTC" is false there); the engine names that zone
+    # "UTC", its SymInfo default. The Pine read spells it TradingView's way;
+    # the engine calls taking the symbol's zone keep reading syminfo_.timezone.
+    "timezone": ('(syminfo_.timezone.empty() || syminfo_.timezone == "UTC"'
+                 ' ? std::string("Etc/UTC") : syminfo_.timezone)'),
     "session": "syminfo_.session",
     "volumetype": "syminfo_.volumetype",
     "description": "syminfo_.description",
@@ -388,8 +460,11 @@ SYMINFO_MEMBER_MAP = {
     "root": 'na<std::string>()',
     "pricescale": 'na<double>()',
     "minmove": 'na<double>()',
+    # --- Run facts: the value the run declares through the syminfo
+    # metadata channel (runtime_overrides.syminfo_metadata, a lane fact),
+    # na when it declares none. ---
+    "mincontract": 'get_syminfo_metadata("mincontract")',
     # --- External-data fields: na-accept so scripts compile ---
-    "mincontract": 'na<double>()',
     "current_contract": 'na<std::string>()',
     "expiration_date": 'na<int64_t>()',
     "isin": 'na<std::string>()',
@@ -539,15 +614,14 @@ def _checked_array_index_prelude(
     )
 
 
-def _checked_array_range_prelude() -> str:
+def _checked_array_range_prelude(*, reject_inverted: bool = True) -> str:
     """Validate the half-open ``[index_from, index_to)`` range of fill/slice.
 
     Both endpoints are checked with ``allow_size`` (``index_to`` is exclusive,
     so ``size`` is a legal endpoint) and without negative normalization
     (neither function appears in the Pine v6 reference's negative-indexing
-    set). An inverted range is rejected rather than silently treated as empty:
-    ``begin()+from > begin()+to`` is undefined behaviour in the STL forms this
-    replaces, and no evidence pins TradingView's behaviour there.
+    set). TradingView treats an inverted ``fill`` range as empty, but raises
+    for an inverted ``slice`` range. The caller selects that distinction.
     """
     return (
         _checked_array_index_prelude(
@@ -556,22 +630,22 @@ def _checked_array_range_prelude() -> str:
         + _checked_array_index_prelude(
             normalize_negative=False, allow_size=True, name="index_to"
         )
-        + "if(__pf_array_index_from>__pf_array_index_to) "
-        "pine_runtime_error(std::string(\"Index range \")+"
-        "std::to_string(__pf_array_index_from)+\"..\"+"
-        "std::to_string(__pf_array_index_to)+"
-        "\" is invalid. Array size is \"+"
-        "std::to_string(__pf_array_size_index_from)); "
+        + (
+            "if(__pf_array_index_from>__pf_array_index_to) "
+            "pine_runtime_error(\"Index 'from' should be less than index 'to'.\"); "
+            if reject_inverted else ""
+        )
     )
 
 
-def _checked_array_insert(a: str, args: list[str]) -> str:
+def _checked_array_insert(a: str, args: list[str], normalize_negative: bool = True) -> str:
     """``array.insert(id, index, value)`` — index is an INSERTION point.
 
     ``index == size`` appends, so the bound is ``index <= size``; a negative
     index is end-relative, exactly as for ``get``/``set``/``remove``.
     """
-    check = _checked_array_index_prelude(allow_size=True)
+    check = _checked_array_index_prelude(allow_size=True,
+                                         normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -585,13 +659,14 @@ def _checked_array_insert(a: str, args: list[str]) -> str:
 
 def _checked_array_fill_range(a: str, args: list[str]) -> str:
     """``array.fill(id, value, index_from, index_to)`` — bounded range fill."""
-    check = _checked_array_range_prelude()
+    check = _checked_array_range_prelude(reject_inverted=False)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_array_value){ "
         "return [&](auto&& __pf_raw_index_from_value){ "
         "return [&](auto&& __pf_raw_index_to_value){ "
         f"{check}"
+        "if(__pf_array_index_from<__pf_array_index_to) "
         "std::fill(__pf_array.begin()+(size_t)__pf_array_index_from, "
         "__pf_array.begin()+(size_t)__pf_array_index_to, __pf_array_value); "
         f"}}(({args[2]})); }}(({args[1]})); }}(({args[0]})); }}(({a}))"
@@ -616,8 +691,8 @@ def checked_array_slice(a: str, args: list[str], *, result_type: str) -> str:
     )
 
 
-def _checked_array_get(a: str, args: list[str]) -> str:
-    check = _checked_array_index_prelude()
+def _checked_array_get(a: str, args: list[str], normalize_negative: bool = True) -> str:
+    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array)->decltype(auto){ "
         "return [&](auto&& __pf_raw_index_value)->decltype(auto){ "
@@ -631,8 +706,8 @@ def _checked_array_get(a: str, args: list[str]) -> str:
     )
 
 
-def _checked_array_set(a: str, args: list[str]) -> str:
-    check = _checked_array_index_prelude()
+def _checked_array_set(a: str, args: list[str], normalize_negative: bool = True) -> str:
+    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -643,8 +718,8 @@ def _checked_array_set(a: str, args: list[str]) -> str:
     )
 
 
-def _checked_array_remove(a: str, args: list[str]) -> str:
-    check = _checked_array_index_prelude()
+def _checked_array_remove(a: str, args: list[str], normalize_negative: bool = True) -> str:
+    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -709,6 +784,17 @@ def _checked_array_percentrank(a: str, args: list[str]) -> str:
     )
 
 
+# Pine v5 raises a runtime error on a negative index to these (TradingView:
+# "Index -1 is out of bounds"); v6 counts from the array's end. The v5 forms
+# lower a v5 library's body (``library_v5``).
+V5_ARRAY_INDEX_METHODS = {
+    "get": lambda a, args: _checked_array_get(a, args, normalize_negative=False),
+    "set": lambda a, args: _checked_array_set(a, args, normalize_negative=False),
+    "insert": lambda a, args: _checked_array_insert(a, args, normalize_negative=False),
+    "remove": lambda a, args: _checked_array_remove(a, args, normalize_negative=False),
+}
+
+
 # Methods called as ``array.method(arr, ...)`` or ``arr.method(...)``.
 ARRAY_METHODS = {
     "get":       _checked_array_get,
@@ -726,8 +812,8 @@ ARRAY_METHODS = {
     "fill":      lambda a, args: f"std::fill({a}.begin(), {a}.end(), {args[0]})" if len(args) == 1
                                  else _checked_array_fill_range(a, args),
     "includes":  lambda a, args: f"(std::find({a}.begin(), {a}.end(), {args[0]}) != {a}.end())",
-    "indexof":   lambda a, args: f"[&](){{ auto it=std::find({a}.begin(),{a}.end(),{args[0]}); return it!={a}.end()?(double)(it-{a}.begin()):-1.0; }}()",
-    "lastindexof": lambda a, args: f"[&](){{ for(int i=(int){a}.size()-1;i>=0;i--)if({a}[i]=={args[0]})return(double)i; return -1.0; }}()",
+    "indexof":   lambda a, args: f"[&](){{ auto __pf_it=std::find({a}.begin(),{a}.end(),{args[0]}); return __pf_it!={a}.end()?(double)(__pf_it-{a}.begin()):-1.0; }}()",
+    "lastindexof": lambda a, args: f"[&](){{ for(int __pf_i=(int){a}.size()-1;__pf_i>=0;__pf_i--)if({a}[__pf_i]=={args[0]})return(double)__pf_i; return -1.0; }}()",
     "sort":      lambda a, args: (
         f"[&](){{ if (({args[0]}) == \"descending\") std::sort({a}.begin(), {a}.end(), std::greater<>()); else std::sort({a}.begin(), {a}.end()); }}()"
         if args else f"std::sort({a}.begin(), {a}.end())"
@@ -741,37 +827,50 @@ ARRAY_METHODS = {
     "min":       lambda a, args: f"({a}.empty()?na<double>():*std::min_element({a}.begin(),{a}.end()))",
     "max":       lambda a, args: f"({a}.empty()?na<double>():*std::max_element({a}.begin(),{a}.end()))",
     "range":     lambda a, args: f"({a}.empty()?na<double>():*std::max_element({a}.begin(),{a}.end())-*std::min_element({a}.begin(),{a}.end()))",
-    "every":     lambda a, args: f"std::all_of({a}.begin(),{a}.end(),[](double v){{return v!=0.0;}})",
-    "some":      lambda a, args: f"std::any_of({a}.begin(),{a}.end(),[](double v){{return v!=0.0;}})",
+    "every":     lambda a, args: f"std::all_of({a}.begin(),{a}.end(),[](auto _pf_raw){{ using _pf_val_t=typename std::decay_t<decltype({a})>::value_type; _pf_val_t v=_pf_raw; if constexpr(std::is_same_v<_pf_val_t,bool>) return v; else return !is_na(v) && v!=0; }})",
+    "some":      lambda a, args: f"std::any_of({a}.begin(),{a}.end(),[](auto _pf_raw){{ using _pf_val_t=typename std::decay_t<decltype({a})>::value_type; _pf_val_t v=_pf_raw; if constexpr(std::is_same_v<_pf_val_t,bool>) return v; else return !is_na(v) && v!=0; }})",
     # stdev/variance honor the optional 2nd ``biased`` arg (Pine v6:
     # biased=true → population (default), false → sample / n-1).
     "stdev":     lambda a, args: (
-        f"[&](){{ if({a}.empty()) return na<double>(); double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); "
-        f"double _d=({args[0]})?(double){a}.size():((double){a}.size()-1.0); "
-        f"return _d>0?std::sqrt(s/_d):na<double>(); }}()"
+        f"[&](){{ if({a}.empty()) return na<double>(); double __pf_m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double __pf_s=0; for(auto v:{a})__pf_s+=(v-__pf_m)*(v-__pf_m); "
+        f"double __pf_d=({_pine_bool_arg(args[0])})?(double){a}.size():((double){a}.size()-1.0); "
+        f"return __pf_d>0?std::sqrt(__pf_s/__pf_d):na<double>(); }}()"
         if args else
-        f"[&](){{ if({a}.empty()) return na<double>(); double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); return std::sqrt(s/{a}.size()); }}()"
+        f"[&](){{ if({a}.empty()) return na<double>(); double __pf_m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double __pf_s=0; for(auto v:{a})__pf_s+=(v-__pf_m)*(v-__pf_m); return std::sqrt(__pf_s/{a}.size()); }}()"
     ),
     "variance":  lambda a, args: (
-        f"[&](){{ if({a}.empty()) return na<double>(); double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); "
-        f"double _d=({args[0]})?(double){a}.size():((double){a}.size()-1.0); "
-        f"return _d>0?s/_d:na<double>(); }}()"
+        f"[&](){{ if({a}.empty()) return na<double>(); double __pf_m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double __pf_s=0; for(auto v:{a})__pf_s+=(v-__pf_m)*(v-__pf_m); "
+        f"double __pf_d=({_pine_bool_arg(args[0])})?(double){a}.size():((double){a}.size()-1.0); "
+        f"return __pf_d>0?__pf_s/__pf_d:na<double>(); }}()"
         if args else
-        f"[&](){{ if({a}.empty()) return na<double>(); double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); return s/{a}.size(); }}()"
+        f"[&](){{ if({a}.empty()) return na<double>(); double __pf_m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double __pf_s=0; for(auto v:{a})__pf_s+=(v-__pf_m)*(v-__pf_m); return __pf_s/{a}.size(); }}()"
     ),
-    "median":    lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto c={a}; std::sort(c.begin(),c.end()); int n=c.size(); return n%2?c[n/2]:(c[n/2-1]+c[n/2])/2.0; }}()",
-    "mode":      lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); std::unordered_map<double,int> m; for(auto v:{a})m[v]++; double best=0; int bc=0; for(auto&[v,c]:m)if(c>bc||(c==bc&&v<best)){{bc=c;best=v;}} return best; }}()",
-    "percentile_linear_interpolation": lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto c={a}; std::sort(c.begin(),c.end()); double k=({args[0]}/100.0)*c.size()-0.5; int i=std::max(0,(int)k); double f=k-i; if(i+1>=(int)c.size()) return c.back(); return c[i]*(1-f)+c[i+1]*f; }}()",
-    "percentile_nearest_rank": lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto c={a}; std::sort(c.begin(),c.end()); int r=(int)std::ceil(({args[0]}/100.0)*c.size()); return (double)c[std::min(r-1,(int)c.size()-1)]; }}()",
+    "median":    lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto __pf_c={a}; std::sort(__pf_c.begin(),__pf_c.end()); int __pf_n=__pf_c.size(); return __pf_n%2?__pf_c[__pf_n/2]:(__pf_c[__pf_n/2-1]+__pf_c[__pf_n/2])/2.0; }}()",
+    "mode":      lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); std::unordered_map<double,int> __pf_m; for(auto v:{a})__pf_m[v]++; double __pf_best=0; int __pf_bc=0; for(auto&[v,c]:__pf_m)if(c>__pf_bc||(c==__pf_bc&&v<__pf_best)){{__pf_bc=c;__pf_best=v;}} return __pf_best; }}()",
+    "percentile_linear_interpolation": lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto __pf_c={a}; std::sort(__pf_c.begin(),__pf_c.end()); double __pf_k=({args[0]}/100.0)*__pf_c.size()-0.5; if(!std::isfinite(__pf_k)) return na<double>(); if(__pf_k>=__pf_c.size()-1.0) return (double)__pf_c.back(); int __pf_i=__pf_k<=0.0?0:(int)__pf_k; double __pf_f=__pf_k-__pf_i; return __pf_c[__pf_i]*(1-__pf_f)+__pf_c[__pf_i+1]*__pf_f; }}()",
+    "percentile_nearest_rank": lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto __pf_c={a}; std::sort(__pf_c.begin(),__pf_c.end()); double __pf_p=({args[0]}); if(is_na(__pf_p)) return (double)__pf_c.front(); double __pf_rank=std::ceil((__pf_p/100.0)*__pf_c.size()); if(!std::isfinite(__pf_rank)) return na<double>(); int __pf_r=(int)std::clamp(__pf_rank,1.0,(double)__pf_c.size()); return (double)__pf_c[__pf_r-1]; }}()",
     "percentrank": _checked_array_percentrank,
-    "abs":       lambda a, args: f"[&](){{ std::vector<double> r; for(auto v:{a})r.push_back(std::abs(v)); return r; }}()",
-    "join":      lambda a, args: "[&](){{ std::string r; for(size_t i=0;i<{arr}.size();i++){{ if(i>0)r+={sep}; r+=std::to_string({arr}[i]); }} return r; }}()".format(arr=a, sep=args[0] if args else 'std::string(",")'),
-    "standardize": lambda a, args: f"[&](){{ double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); s=std::sqrt(s/{a}.size()); std::vector<double> r; for(auto v:{a})r.push_back(s==0?1.0:(v-m)/s); return r; }}()",
-    "covariance": lambda a, args: f"[&](){{ auto&&b=({args[0]}); int n=std::min({a}.size(),b.size()); if(n<=0) return na<double>(); double ma=0,mb=0; for(int i=0;i<n;i++){{ma+={a}[i];mb+=b[i];}} ma/=n;mb/=n; double c=0; for(int i=0;i<n;i++)c+=({a}[i]-ma)*(b[i]-mb); return c/n; }}()",
-    "binary_search": lambda a, args: f"[&](){{ auto it=std::lower_bound({a}.begin(),{a}.end(),{args[0]}); return (it!={a}.end()&&*it=={args[0]})?(double)(it-{a}.begin()):-1.0; }}()",
-    "binary_search_leftmost": lambda a, args: f"[&](){{ auto it=std::lower_bound({a}.begin(),{a}.end(),{args[0]}); return (it!={a}.end()&&*it=={args[0]})?(double)(it-{a}.begin()):(double)(it-{a}.begin()-1); }}()",
-    "binary_search_rightmost": lambda a, args: f"[&](){{ auto it=std::upper_bound({a}.begin(),{a}.end(),{args[0]}); return (it!={a}.begin()&&*(it-1)=={args[0]})?(double)(it-{a}.begin()-1):(double)(it-{a}.begin()); }}()",
-    "sort_indices": lambda a, args: f"[&](){{ std::vector<double> idx({a}.size()); std::iota(idx.begin(),idx.end(),0); std::sort(idx.begin(),idx.end(),[&](int i,int j){{return {a}[i]<{a}[j];}}); return idx; }}()",
+    "abs":       lambda a, args: f"[&](){{ std::vector<double> __pf_r; for(auto v:{a})__pf_r.push_back(std::abs(v)); return __pf_r; }}()",
+    "join":      lambda a, args: "[&](){{ std::string __pf_r; for(size_t __pf_i=0;__pf_i<{arr}.size();__pf_i++){{ if(__pf_i>0)__pf_r+={sep}; __pf_r+=std::to_string({arr}[__pf_i]); }} return __pf_r; }}()".format(arr=a, sep=args[0] if args else 'std::string(",")'),
+    "standardize": lambda a, args: f"[&](){{ double __pf_m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double __pf_s=0; for(auto v:{a})__pf_s+=(v-__pf_m)*(v-__pf_m); __pf_s=std::sqrt(__pf_s/{a}.size()); std::vector<double> __pf_r; for(auto v:{a})__pf_r.push_back(__pf_s==0?1.0:(v-__pf_m)/__pf_s); return __pf_r; }}()",
+    "covariance": lambda a, args: f"[&](){{ auto&&__pf_b=({args[0]}); int __pf_n=std::min({a}.size(),__pf_b.size()); if(__pf_n<=0) return na<double>(); double __pf_ma=0,__pf_mb=0; for(int __pf_i=0;__pf_i<__pf_n;__pf_i++){{__pf_ma+={a}[__pf_i];__pf_mb+=__pf_b[__pf_i];}} __pf_ma/=__pf_n;__pf_mb/=__pf_n; double __pf_c=0; for(int __pf_i=0;__pf_i<__pf_n;__pf_i++)__pf_c+=({a}[__pf_i]-__pf_ma)*(__pf_b[__pf_i]-__pf_mb); return __pf_c/__pf_n; }}()",
+    "binary_search": lambda a, args: f"[&](){{ auto __pf_it=std::lower_bound({a}.begin(),{a}.end(),{args[0]}); return (__pf_it!={a}.end()&&*__pf_it=={args[0]})?(double)(__pf_it-{a}.begin()):-1.0; }}()",
+    "binary_search_leftmost": lambda a, args: f"[&](){{ auto __pf_it=std::lower_bound({a}.begin(),{a}.end(),{args[0]}); return (__pf_it!={a}.end()&&*__pf_it=={args[0]})?(double)(__pf_it-{a}.begin()):(double)(__pf_it-{a}.begin()-1); }}()",
+    "binary_search_rightmost": lambda a, args: f"[&](){{ auto __pf_it=std::upper_bound({a}.begin(),{a}.end(),{args[0]}); return (__pf_it!={a}.begin()&&*(__pf_it-1)=={args[0]})?(double)(__pf_it-{a}.begin()-1):(double)(__pf_it-{a}.begin()); }}()",
+    "sort_indices": lambda a, args: f"[&](){{ std::vector<double> __pf_idx({a}.size()); std::iota(__pf_idx.begin(),__pf_idx.end(),0); std::sort(__pf_idx.begin(),__pf_idx.end(),[&](int __pf_i,int __pf_j){{return {a}[__pf_i]<{a}[__pf_j];}}); return __pf_idx; }}()",
+}
+
+# The ARRAY_METHODS arguments (receiver excluded) a template reads more than
+# once, or once per loop iteration: evaluate_args_once binds each that is not
+# a plain read. The typed string ``join`` lowering reads its separator the
+# same way.
+ARRAY_ARGS_READ_REPEATEDLY = {
+    "lastindexof": (0,),
+    "binary_search": (0,),
+    "binary_search_leftmost": (0,),
+    "binary_search_rightmost": (0,),
+    "join": (0,),
+    "concat": (0,),
 }
 
 # Pine parameter order for the checked-index subset. Keeping the receiver
@@ -830,7 +929,7 @@ def _matrix_add_row(m: str, args: list) -> str:
     if len(args) == 1:
         return f"{m}.add_row((int)({m}.rows()), {args[0]})"
     if len(args) == 2:
-        return f"{m}.add_row((int)({args[0]}), {args[1]})"
+        return f"{m}.add_row({_matrix_int_arg(args[0])}, {args[1]})"
     raise IndexError("matrix.add_row")
 
 
@@ -839,7 +938,7 @@ def _matrix_add_col(m: str, args: list) -> str:
     if len(args) == 1:
         return f"{m}.add_col((int)({m}.columns()), {args[0]})"
     if len(args) == 2:
-        return f"{m}.add_col((int)({args[0]}), {args[1]})"
+        return f"{m}.add_col({_matrix_int_arg(args[0])}, {args[1]})"
     raise IndexError("matrix.add_col")
 
 
@@ -897,28 +996,28 @@ MATRIX_NUMERIC_ONLY: frozenset[str] = frozenset({
 MATRIX_SORT_ALLOWED_GENERIC_ELEMS: frozenset[str] = frozenset({"int", "bool", "string"})
 
 MATRIX_METHODS = {
-    "get":       lambda m, args: f"{m}.get((int)({args[0]}), (int)({args[1]}))",
-    "set":       lambda m, args: f"{m}.set((int)({args[0]}), (int)({args[1]}), {args[2]})",
+    "get":       lambda m, args: f"{m}.get({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
+    "set":       lambda m, args: f"{m}.set({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])}, {args[2]})",
     "fill":      lambda m, args: f"{m}.fill({args[0]})",
-    "row":       lambda m, args: f"{m}.row((int)({args[0]}))",
-    "col":       lambda m, args: f"{m}.col((int)({args[0]}))",
+    "row":       lambda m, args: f"{m}.row({_matrix_int_arg(args[0])})",
+    "col":       lambda m, args: f"{m}.col({_matrix_int_arg(args[0])})",
     "rows":      lambda m, args: f"(int){m}.rows()",
     "columns":   lambda m, args: f"(int){m}.columns()",
     "add_row":   _matrix_add_row,
     "add_col":   _matrix_add_col,
     # ``remove_row`` is void in C++; Pine may assign the result, so we wrap
     # it in a lambda that returns a sentinel double after the side effect.
-    "remove_row": lambda m, args: f"[&](){{ {m}.remove_row((int)({args[0]})); return 0.0; }}()",
-    "remove_col":lambda m, args: f"[&](){{ {m}.remove_col((int)({args[0]})); return 0.0; }}()",
-    "swap_rows": lambda m, args: f"{m}.swap_rows((int)({args[0]}), (int)({args[1]}))",
-    "swap_columns": lambda m, args: f"{m}.swap_columns((int)({args[0]}), (int)({args[1]}))",
+    "remove_row": lambda m, args: f"[&](){{ {m}.remove_row({_matrix_int_arg(args[0])}); return 0.0; }}()",
+    "remove_col":lambda m, args: f"[&](){{ {m}.remove_col({_matrix_int_arg(args[0])}); return 0.0; }}()",
+    "swap_rows": lambda m, args: f"{m}.swap_rows({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
+    "swap_columns": lambda m, args: f"{m}.swap_columns({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
     "copy":      lambda m, args: f"{m}.copy()",
-    "submatrix": lambda m, args: f"{m}.submatrix((int)({args[0]}), (int)({args[1]}), (int)({args[2]}), (int)({args[3]}))",
-    "reshape":   lambda m, args: f"{m}.reshape((int)({args[0]}), (int)({args[1]}))",
+    "submatrix": lambda m, args: f"{m}.submatrix({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])}, {_matrix_int_arg(args[2])}, {_matrix_int_arg(args[3])})",
+    "reshape":   lambda m, args: f"{m}.reshape({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
     "reverse":   lambda m, args: f"{m}.reverse()",
     "transpose": lambda m, args: f"{m}.transpose()",
-    "sort":      lambda m, args: f"{m}.sort((int)({args[0]}), {args[1]} != \"descending\")" if len(args)>1 else f"{m}.sort((int)({args[0]}))",
-    "concat":    lambda m, args: f"{m}.concat({args[0]}, (bool)({args[1]}))" if len(args)>1 else f"{m}.concat({args[0]}, true)",
+    "sort":      lambda m, args: f"{m}.sort({_matrix_int_arg(args[0])}, {args[1]} != \"descending\")" if len(args)>1 else f"{m}.sort({_matrix_int_arg(args[0])})",
+    "concat":    lambda m, args: f"{m}.concat({args[0]}, {pine_truth_cast(args[1])})" if len(args)>1 else f"{m}.concat({args[0]}, true)",
     "avg":       lambda m, args: f"{m}.avg()",
     "min":       lambda m, args: f"{m}.min()",
     "max":       lambda m, args: f"{m}.max()",
@@ -926,7 +1025,7 @@ MATRIX_METHODS = {
     "sum":       lambda m, args: f"{m}.sum()",
     "diff":      lambda m, args: f"{m}.diff({args[0]})",
     "mult":      lambda m, args: f"{m}.mult({args[0]})",
-    "pow":       lambda m, args: f"{m}.pow((int)({args[0]}))",
+    "pow":       lambda m, args: f"{m}.pow({_matrix_int_arg(args[0])})",
     "det":       lambda m, args: f"{m}.det()",
     "inv":       lambda m, args: f"{m}.inv()",
     "pinv":      lambda m, args: f"{m}.pinv()",
@@ -980,6 +1079,17 @@ def _math_minmax_na_expr(func_name: str, args: list[str]) -> str:
     )
 
 
+def _math_round_digits_expr(args: list[str]) -> str:
+    """``math.round(number, precision)``: the template reads the precision
+    twice, so one that is more than a plain read is evaluated once."""
+    return evaluate_args_once(
+        args, (1,),
+        lambda a: (f"(std::round({a[0]} * std::pow(10.0, {a[1]})) / "
+                   f"std::pow(10.0, {a[1]}))"),
+        "_pf_round_a",
+    )
+
+
 # Pine ``math.sign`` returns a float, propagates numeric ``na``, and must not
 # evaluate its argument more than once.  Keep the callable separate from the
 # call template because the stable-runtime TA reset fallback also substitutes
@@ -1015,18 +1125,30 @@ STR_FUNC_MAP = {
     "contains":    lambda args: f"({args[0]}.find({args[1]}) != std::string::npos)",
     "startswith":  lambda args: f"({args[0]}.substr(0, {args[1]}.length()) == {args[1]})",
     "endswith":    lambda args: f"({args[0]}.length() >= {args[1]}.length() && {args[0]}.compare({args[0]}.length() - {args[1]}.length(), {args[1]}.length(), {args[1]}) == 0)",
-    "pos":         lambda args: f"[&](){{ auto p={args[0]}.find({args[1]}); return p!=std::string::npos?(int)p:-1; }}()",
+    "pos":         lambda args: f"[&](){{ auto __pf_p={args[0]}.find({args[1]}); return __pf_p!=std::string::npos?(int)__pf_p:-1; }}()",
     "substring":   None,  # handled separately (2 vs 3 args)
-    "replace_all": lambda args: f"[&](){{ std::string s={args[0]}; size_t p=0; while((p=s.find({args[1]},p))!=std::string::npos){{ s.replace(p,{args[1]}.length(),{args[2]}); p+={args[2]}.length(); }} return s; }}()",
+    "replace_all": lambda args: f"[&](){{ std::string __pf_s={args[0]}; size_t __pf_p=0; while((__pf_p=__pf_s.find({args[1]},__pf_p))!=std::string::npos){{ __pf_s.replace(__pf_p,{args[1]}.length(),{args[2]}); __pf_p+={args[2]}.length(); }} return __pf_s; }}()",
     "replace":     None,  # handled separately (3 vs 4 args)
-    "lower":       lambda args: f"[&](){{ std::string s={args[0]}; std::transform(s.begin(),s.end(),s.begin(),::tolower); return s; }}()",
-    "upper":       lambda args: f"[&](){{ std::string s={args[0]}; std::transform(s.begin(),s.end(),s.begin(),::toupper); return s; }}()",
-    "trim":        lambda args: f'[&](){{ std::string s={args[0]}; s.erase(0,s.find_first_not_of(" \\t\\n\\r")); s.erase(s.find_last_not_of(" \\t\\n\\r")+1); return s; }}()',
-    "repeat":      lambda args: f"[&](){{ std::string r; for(int i=0;i<(int)({args[1]});i++) r+={args[0]}; return r; }}()",
+    "lower":       lambda args: f"[&](){{ std::string __pf_s={args[0]}; std::transform(__pf_s.begin(),__pf_s.end(),__pf_s.begin(),::tolower); return __pf_s; }}()",
+    "upper":       lambda args: f"[&](){{ std::string __pf_s={args[0]}; std::transform(__pf_s.begin(),__pf_s.end(),__pf_s.begin(),::toupper); return __pf_s; }}()",
+    "trim":        lambda args: f'[&](){{ std::string __pf_s={args[0]}; __pf_s.erase(0,__pf_s.find_first_not_of(" \\t\\n\\r")); __pf_s.erase(__pf_s.find_last_not_of(" \\t\\n\\r")+1); return __pf_s; }}()',
+    "repeat":      lambda args: (
+        f"[&](){{ std::string __pf_r; for(int __pf_i=0;__pf_i<{na_preserving_int_cast(args[1])};__pf_i++) __pf_r+={args[0]}; return __pf_r; }}()"
+        if len(args) < 3 else
+        f"[&](){{ std::string __pf_r; for(int __pf_i=0;__pf_i<{na_preserving_int_cast(args[1])};__pf_i++){{ if(__pf_i>0) __pf_r+={args[2]}; __pf_r+={args[0]}; }} return __pf_r; }}()"
+    ),
     "match":       lambda args: f'pine_str_match({args[0]}, {args[1]})',
     "split":       lambda args: f'pine_str_split({args[0]}, {args[1]})',
     "format":      None,  # handled separately
 }
+# The STR_FUNC_MAP arguments a template reads more than once, or once per
+# loop iteration: evaluate_args_once binds each that is not a plain read.
+STR_ARGS_READ_REPEATEDLY = {
+    "startswith": (1,),
+    "endswith": (0, 1),
+    "replace_all": (1, 2),
+    "repeat": (0, 1, 2),
+}
 
 
 # ---------------------------------------------------------------------------