@pineforge/codegen-pyodide 0.8.1 → 0.10.0

package/pineforge_codegen/codegen/base.py

@@ -53,6 +53,7 @@ from .tables import (
     SKIP_VAR_TYPES,
     SYMINFO_MEMBER_MAP,
     COLOR_CONST_MAP,
+    ARRAY_NEW_CTORS,
     ARRAY_METHODS,
     MAP_METHODS,
     MATRIX_METHODS,
@@ -65,6 +66,15 @@ from .tables import (
     _merge_kwargs,
 )
 
+TA_TUPLE_RESULT_TYPES = {
+    "macd": "ta::MACDResult",
+    "supertrend": "ta::SupertrendResult",
+    "dmi": "ta::DMIResult",
+    "bb": "ta::BBResult",
+    "kc": "ta::KCResult",
+    "vwap_bands": "ta::VWAPBandsResult",
+}
+
 # (TA_IMPLICIT_COMPUTE / TA_COMPUTE_ARGS now imported from .tables above.)
 
 # (TA_IMPLICIT_COMPUTE_FULL / TA_IMPLICIT_APPEND / PINE_TYPE_TO_CPP /
@@ -181,6 +191,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._func_cs_var_remap: dict[tuple[str, int], dict[str, str]] = {}
         # Active var name remap (set during per-call-site function emission)
         self._active_var_remap: dict[str, str] = {}
+        # When True (only while lowering a TA runtime-reset length expression
+        # through the expression visitor), an input-backed variable identifier
+        # renders as an override-aware ``get_input_*()`` read instead of its
+        # class member name. The reset can run in ``evaluate_security`` BEFORE
+        # the input members are initialised, so it must not depend on their
+        # init order. See ``_lower_reset_expr_via_visitor``.
+        self._reset_input_getter_mode: bool = False
         # Set of var/series member names that belong to user functions (need cloning)
         self._func_var_members_set: set[str] = set()
         # BUG C: function-local names emitted as ``UDT*`` pointer aliases (a UDT
@@ -190,6 +207,16 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # needed: names are function-unique and the value-copy fallback ignores
         # entries for inactive functions.
         self._udt_ptr_alias_locals: set[str] = set()
+        # Names of hoisted GLOBAL-scope UDT loop-locals bound from a UDT array
+        # element (``z = arr.get(i)``) and later field-mutated. Pine array
+        # elements of a user-defined type are references, so such a local must
+        # ALIAS the element, not value-copy — the mutation has to write back
+        # into the array. These are de-hoisted from the class-member value-copy
+        # to a fresh per-iteration ``UDT& z = arr[i];`` local reference (the same
+        # form the non-hoisted function-local alias path already emits). Read-only
+        # get-locals are NOT recorded (no field mutation) and keep value-copy
+        # semantics. Populated by _register_udt_array_get_ref_locals.
+        self._udt_array_get_ref_locals: set[str] = set()
         self._precalc_loop_active: bool = False
         # Names of ``var`` members that live in a FUNCTION scope (not global).
         # These are initialized once-per-function-variant on first call (a
@@ -328,14 +355,44 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._instance_dispatch: dict[tuple[str | None, int], str] = {}
         self._fresh_instances: list[dict] = []
         self._fresh_var_members: list[tuple[str, str]] = []
+        # Fresh fixnan members for context-sensitive helper instances (nested
+        # helpers reached through >1 distinct call path). Each fresh instance
+        # gets its OWN previous-value member so two paths never share fixnan
+        # state. Populated by ``_build_func_instances``; declared in step 7.
+        self._fresh_fixnan_members: list[tuple[Any, str]] = []
         # NOTE: _build_func_instances() runs at the top of generate() (it needs
         # _all_member_names / _func_safe_name, which are populated later in __init__).
         # Build lookup: node id -> FixnanCallSite (counter-based)
         self._fixnan_counter = 0
+        # Per-call-site fixnan member remap for user functions (mirrors the TA
+        # remap): (func_name, cs_idx) -> {orig_member: cloned_member}.
+        self._func_cs_fixnan_remap: dict[tuple[str, int], dict[str, str]] = {}
+        # Active fixnan remap (set during per-call-site function emission).
+        self._active_fixnan_remap: dict[str, str] = {}
+        # node id -> original FixnanCallSite (the cs0 / source-level site).
+        self._fixnan_site_map: dict[int, Any] = {}
+        # Set of fixnan member names that belong to user functions (excluded
+        # from the site map so the active remap can dispatch per variant).
+        self._func_fixnan_members: set[str] = set()
+        # Dead fixnan site indices (owner is a dead user function). Skipped
+        # at declaration time so dead functions' fixnan state is not emitted.
+        self._dead_fixnan_indices: set[int] = set()
         self._switch_counter = 0
         self._security_inline_counter = 0
         self._random_call_counter = 0
         self._for_counter = 0
+        # Synthetic history buffers used by inline call-history and by scalar
+        # expressions passed to UDF series parameters.  They are pre-registered
+        # at generate() time so declarations precede method emission, then
+        # addressed by (source node, emitted UDF variant).  Each record is a
+        # real class-member Series and therefore joins _PFScriptState through
+        # the declaration-derived checkpoint inventory.
+        self._inline_history_members: list[dict] = []
+        self._inline_history_member_by_key: dict[tuple, str] = {}
+        # Unique lambda-local names used when an array lowering references its
+        # receiver more than once.  The binding keeps temporary-producing or
+        # side-effectful receivers single-evaluation (see TypeInferer).
+        self._array_receiver_counter = 0
         # UDT / enum (needed before _collect_known_vars for input.enum)
         self._udt_defs: dict[str, list] = {}
         self._enum_defs: dict[str, list[str]] = {}
@@ -367,9 +424,25 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # ctor-init list still folds to the Pine-default literal via _resolve_known.
         self._derived_input_expr: dict[str, str] = {}
         self._timeframe_period_vars: set[str] = set()
+        # Names of class-scope vars whose value is a bar-invariant scalar —
+        # i.e. derived only from inputs, literals, ``timeframe.*`` members,
+        # ``math.*`` over stable args, and ternaries/casts/arithmetic over
+        # any of those. Such vars are safe to embed in a TA ctor runtime
+        # reset expression (they do not depend on per-bar series). Vars
+        # referencing series / ta.* results / history subscripts / strategy
+        # state are NOT here, so a TA length fed by them is still rejected
+        # by the constructor guard.
+        self._stable_runtime_vars: set[str] = set()
+        # ``_var_names`` (var/varip persistent-state members) is needed by the
+        # stability classifier during _collect_known_vars, so pre-seed it from
+        # the analyzer's var_members before that pass runs; the canonical
+        # assignment below preserves the existing initialization order.
+        self._var_names: set[str] = set()
+        for _vn, _, _ in ctx.var_members:
+            self._var_names.add(_vn)
         self._collect_known_vars()
         # Track var names
-        self._var_names: set[str] = set()
+        self._var_names = set()
         for name, _, _ in ctx.var_members:
             self._var_names.add(name)
         # Every name bound ANYWHERE in the program (top-level, nested in
@@ -386,6 +459,87 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         for fi in ctx.func_infos:
             self._func_names.add(fi.name)
             self._func_info_map[fi.name] = fi
+        # Dead-code user functions: those that contain TA call sites but are
+        # never called anywhere in the script (no call site registered them,
+        # so func_call_site_counts reports 0). Their OWN TA ctor args still
+        # carry bare parameter names (e.g. ``dirmov_short(len) => ta.rma(ta.tr, len)``)
+        # that can never be resolved to a concrete length, and since the
+        # function never runs its TA buffers would be dead weight anyway.
+        # Track the dead TA site indices and dead function names so emission
+        # can skip both — the ctor guard no longer hard-fails on the bare
+        # param and no dangling member/function body is emitted. A function
+        # with zero call sites but NO TA state is NOT dead-by-this-rule (it
+        # may still be emitted; harmless if truly unreferenced).
+        #
+        # IMPORTANT: dead-ness of a TA site is decided by the site's
+        # ``owner_func`` (set by the analyzer), NOT by which function's
+        # ``func_ta_ranges`` slice the site happens to fall in. A function's
+        # slice can include clones of ANOTHER (live) function's sites that
+        # were minted while visiting THIS function's body (a nested call to
+        # a live callee registers the callee's cs{N} clones in the caller's
+        # TA-range slice). Keying dead-ness off the slice would drop those
+        # borrowed clones' declarations, leaving the owning callee's emitted
+        # clone body referencing undeclared members. Regression:
+        # quantbyboji-nq-hma-midday (``_ta_change_*_cs1`` / ``_ta_rma_*_cs1``
+        # minted inside dead ``adx_short``'s body but owned by live ``dirmov``).
+        self._dead_func_names: set[str] = set()
+        self._dead_ta_indices: set[int] = set()
+        for _fn in (ctx.func_ta_ranges or {}):
+            if (ctx.func_call_site_counts or {}).get(_fn, 0) > 0:
+                continue
+            # Only treat plain user functions (not UDT methods) as skippable
+            # dead code; methods are dispatched through the UDT and their
+            # call-site tracking is handled separately.
+            fi = self._func_info_map.get(_fn)
+            if fi is not None and getattr(fi, "is_udt_method", False):
+                continue
+            self._dead_func_names.add(_fn)
+        # Mark TA sites dead ONLY when their owner is a dead function. A
+        # site with ``owner_func=None`` (top-level) or whose owner is a
+        # live function survives -- even if it sits inside a dead
+        # function's TA-range slice (it's a borrowed clone).
+        for _i, _site in enumerate(ctx.ta_call_sites):
+            _owner = getattr(_site, "owner_func", None)
+            if _owner is not None and _owner in self._dead_func_names:
+                self._dead_ta_indices.add(_i)
+        # Build per-call-site fixnan remap + site map (mirrors TA remap above).
+        # Dead fixnan sites (owner is a dead function) are skipped at decl time.
+        clone_fn_names = getattr(ctx, "func_cs_fixnan_clone_names", {})
+        for _i, _fsite in enumerate(ctx.fixnan_sites):
+            _fowner = getattr(_fsite, "owner_func", None)
+            if _fowner is not None and _fowner in self._dead_func_names:
+                self._dead_fixnan_indices.add(_i)
+        # cs0 fixnan remap is identity (originals). Build originals per func.
+        func_fixnan_originals: dict[str, list[str]] = {}
+        for _fname, _idxs in (ctx.func_fixnan_indices or {}).items():
+            origs = [ctx.fixnan_sites[i].member_name for i in _idxs
+                     if i not in self._dead_fixnan_indices]
+            if origs:
+                func_fixnan_originals[_fname] = origs
+                self._func_cs_fixnan_remap[(_fname, 0)] = {m: m for m in origs}
+                self._func_fixnan_members.update(origs)
+        # cs > 0 remap uses the ``{orig}_cs{cs_idx}`` formula (or the
+        # analyzer's disambiguated name from func_cs_fixnan_clone_names).
+        for _fname, _origs in func_fixnan_originals.items():
+            _total_cs = ctx.func_call_site_counts.get(_fname, 1)
+            for _cs_idx in range(1, _total_cs):
+                _overrides = clone_fn_names.get((_fname, _cs_idx), {})
+                _remap = {}
+                for _orig in _origs:
+                    _remap[_orig] = _overrides.get(_orig, f"{_orig}_cs{_cs_idx}")
+                self._func_cs_fixnan_remap[(_fname, _cs_idx)] = _remap
+                self._func_fixnan_members.update(_remap.values())
+        # Site map: node id -> original site (cs0). Skip dead sites and
+        # function-local originals (the active remap dispatches variants).
+        for _i, _fsite in enumerate(ctx.fixnan_sites):
+            if _i in self._dead_fixnan_indices:
+                continue
+            if _fsite.node is None:
+                continue
+            if _fsite.member_name not in self._func_fixnan_members:
+                self._fixnan_site_map[id(_fsite.node)] = _fsite
+            elif id(_fsite.node) not in self._fixnan_site_map:
+                self._fixnan_site_map[id(_fsite.node)] = _fsite
         # Track strategy series vars (e.g., strategy.closedtrades[1])
         self._strategy_series_vars: set[str] = set()
         # Track global-scope non-var declarations (emitted as class members)
@@ -424,12 +578,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._security_calls: list[dict] = [self._normalize_security_call(item) for item in ctx.security_calls]
         # Current function parameter types (set during _emit_func_def)
         self._current_func_param_types: dict[str, str] = {}
+        self._current_func_param_specs: dict[str, "TypeSpec"] = {}
         # Current function params that are series (const Series<double>&)
         self._current_func_series_params: set[str] = set()
         # Locals declared in the function currently being emitted (symbol table loses them after analysis)
         self._current_func_locals: set[str] = set()
+        self._current_func_local_types: dict[str, str] = {}
         # for-in loop iterator names (must resolve member access, not enum fallback)
         self._current_loop_vars: set[str] = set()
+        self._current_loop_var_specs: dict[str, "TypeSpec"] = {}
         # Track array variables for codegen
         self._array_vars: set[str] = set()
         # Track map variables for codegen
@@ -553,6 +710,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             self._all_member_names.add(self._safe_name(name))
 
         self._register_global_aggregate_member_types()
+        self._register_udt_array_get_ref_locals()
         self._uses_matrix = self._detect_matrix_usage()
         # Drawing-objects-as-data: gate all new emission (drawing.hpp include +
         # the per-type arenas) on this flag so non-drawing strategies stay
@@ -645,7 +803,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         ctx = self.ctx
         stateful = (set(ctx.func_ta_ranges.keys())
                     | set(ctx.func_var_members.keys())
-                    | set(ctx.func_series_vars.keys()))
+                    | set(ctx.func_series_vars.keys())
+                    | set(ctx.func_fixnan_indices.keys())
+                    | set(ctx.func_security_clone_only))
         if not stateful:
             return
 
@@ -661,8 +821,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         def var_originals(fname: str) -> list[str]:
             return [self._safe_name(n) for n, _, _ in ctx.func_var_members.get(fname, [])]
 
+        def fixnan_originals(fname: str) -> list[str]:
+            return list(self._func_cs_fixnan_remap.get((fname, 0), {}).keys())
+
         def natural_name(fname: str, cs_idx: int) -> str:
-            return f"{self._func_safe_name(fname)}_cs{cs_idx}"
+            return f"{self._func_cpp_base_name(fname)}_cs{cs_idx}"
 
         interned: dict[tuple, dict] = {}
         worklist: list[dict] = []
@@ -670,7 +833,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         fresh_counter = 0
 
         # Seed with the natural clones the flat emission loop produces.
-        for fname in stateful:
+        for fname in sorted(stateful):
             if fname not in func_bodies:
                 continue
             total_cs = ctx.func_call_site_counts.get(fname, 0)
@@ -681,13 +844,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                         "name": natural_name(fname, k),
                         "ta_remap": self._func_cs_ta_remap.get((fname, k), {}),
                         "var_remap": self._func_cs_var_remap.get((fname, k), {}),
+                        "fixnan_remap": self._func_cs_fixnan_remap.get((fname, k), {}),
                     })
             else:
                 worklist.append({
                     "fname": fname,
-                    "name": self._func_safe_name(fname),
+                    "name": self._func_cpp_base_name(fname),
                     "ta_remap": {},
                     "var_remap": {},
+                    "fixnan_remap": {},
                 })
 
         while worklist:
@@ -699,6 +864,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if not body:
                 continue
             active_ta = inst["ta_remap"]
+            active_fixnan = inst.get("fixnan_remap", {})
             for callnode in self._iter_func_calls(body):
                 cs_info = ctx.func_call_cs_map.get(id(callnode))
                 if cs_info is None:
@@ -711,26 +877,49 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 for m in ta_originals(g_name):
                     mid = natural_ta.get(m, m)
                     composed_ta[m] = active_ta.get(mid, mid)
-                if composed_ta == natural_ta:
+                natural_fixnan = self._func_cs_fixnan_remap.get((g_name, j), {})
+                composed_fixnan = {}
+                for m in fixnan_originals(g_name):
+                    mid = natural_fixnan.get(m, m)
+                    composed_fixnan[m] = active_fixnan.get(mid, mid)
+                if composed_ta == natural_ta and composed_fixnan == natural_fixnan:
                     # Path resolves to the callee's own cs{j} clone — reuse it.
                     self._instance_dispatch[(inst["name"], id(callnode))] = \
                         natural_name(g_name, j)
                     continue
-                key = (g_name, frozenset(composed_ta.items()))
+                key = (g_name, frozenset(composed_ta.items()),
+                       frozenset(composed_fixnan.items()))
                 ginst = interned.get(key)
                 if ginst is None:
                     fresh_counter += 1
-                    inst_name = f"{self._func_safe_name(g_name)}__ni{fresh_counter}"
+                    inst_name = f"{self._func_cpp_base_name(g_name)}__ni{fresh_counter}"
                     fvar_remap: dict[str, str] = {}
                     for v in var_originals(g_name):
                         fresh_member = f"{v}__ni{fresh_counter}"
                         fvar_remap[v] = fresh_member
                         self._fresh_var_members.append((v, fresh_member))
+                    # Fresh fixnan members: each path gets its OWN previous-
+                    # value member so two call paths never share fixnan state.
+                    ffixnan_remap: dict[str, str] = {}
+                    for orig_fn_member in fixnan_originals(g_name):
+                        fresh_fn_member = f"{orig_fn_member}__ni{fresh_counter}"
+                        ffixnan_remap[orig_fn_member] = fresh_fn_member
+                        # Find the original FixnanCallSite to carry its type.
+                        orig_fn_site = None
+                        for _fs in ctx.fixnan_sites:
+                            if _fs.member_name == orig_fn_member:
+                                orig_fn_site = _fs
+                                break
+                        if orig_fn_site is not None:
+                            self._fresh_fixnan_members.append(
+                                (orig_fn_site, fresh_fn_member)
+                            )
                     ginst = {
                         "fname": g_name,
                         "name": inst_name,
                         "ta_remap": composed_ta,
                         "var_remap": fvar_remap,
+                        "fixnan_remap": ffixnan_remap,
                     }
                     interned[key] = ginst
                     self._fresh_instances.append(ginst)
@@ -854,31 +1043,33 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     spec = self._matrix_specs.get(recv_name) or TypeSpec.matrix(TypeSpec.primitive("float"))
                 self._matrix_specs[name] = spec
                 self._collection_types[name] = spec
-            elif ns == "array" and fn in (
-                "new",
-                "new_float",
-                "new_int",
-                "new_bool",
-                "new_string",
-                "from",
-            ):
+            elif ns == "array" and fn in ({"new", "from"} | set(ARRAY_NEW_CTORS)):
                 self._array_vars.add(name)
+                spec = self._type_spec_from_expr(expr) or self._array_spec_for_name(name)
+                self._collection_types[name] = spec
             elif ns == "map" and fn == "new":
                 self._map_vars.add(name)
 
-        # Also register var/varip matrix members from AST nodes so that
-        # the typed-matrix gate checks see the correct element spec.
+        # Also register var/varip aggregate members from AST nodes so that
+        # class-member declarations see the precise collection type before
+        # on_bar emits the initializer. This is required for unannotated
+        # drawing arrays such as ``var boxes = array.new_box()``.
         var_decl_map: dict[str, FuncCall] = {}
         for stmt in (self.ctx.ast.body if hasattr(self.ctx, "ast") else []):
             if isinstance(stmt, VarDecl) and isinstance(stmt.value, FuncCall):
                 var_decl_map[stmt.name] = stmt.value
         for name, _ptype, _init_str in self.ctx.var_members:
-            if name in self._matrix_specs:
-                continue
             expr = var_decl_map.get(name)
             if expr is None:
                 continue
             fn2, ns2 = self._resolve_callee(expr.callee)
+            if ns2 == "array" and fn2 in ({"new", "from"} | set(ARRAY_NEW_CTORS)):
+                self._array_vars.add(name)
+                spec2 = self._type_spec_from_expr(expr) or self._array_spec_for_name(name)
+                self._collection_types[name] = spec2
+                continue
+            if name in self._matrix_specs:
+                continue
             if ns2 == "matrix" and fn2 == "new":
                 targs2 = self._template_args_from_call(expr) if hasattr(expr, "annotations") else []
                 elem_spec2 = self._type_spec_from_hint_name(targs2[0]) if targs2 else TypeSpec.primitive("float")
@@ -901,6 +1092,68 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                         self._matrix_specs[name] = spec2
                         self._collection_types[name] = spec2
 
+    def _walk_global_scope_with_loopflag(self, stmts, in_loop):
+        """Yield ``(stmt, in_loop)`` for every statement in global scope,
+        recursing into control-flow bodies (if/for/while/switch) but NOT into
+        nested function definitions — a function-local of the same name lives in
+        a separate scope and must not be attributed to a global member. The
+        ``in_loop`` flag is True once inside any for/while loop body."""
+        for s in stmts:
+            if isinstance(s, FuncDef):
+                continue
+            yield s, in_loop
+            child_in_loop = in_loop or isinstance(s, (ForStmt, ForInStmt, WhileStmt))
+            for attr in ("body", "else_body", "default_body"):
+                child = getattr(s, attr, None)
+                if isinstance(child, list):
+                    yield from self._walk_global_scope_with_loopflag(child, child_in_loop)
+            cases = getattr(s, "cases", None)
+            if isinstance(cases, list):
+                for _case_expr, case_stmts in cases:
+                    if isinstance(case_stmts, list):
+                        yield from self._walk_global_scope_with_loopflag(case_stmts, child_in_loop)
+
+    def _register_udt_array_get_ref_locals(self) -> None:
+        """Detect global-scope UDT loop-locals that alias a UDT array element and
+        are later field-mutated (Pine array elements of a user-defined type are
+        references — ``z = arr.get(i)`` then ``z.f := v`` MUST write back into
+        ``arr``).
+
+        A non-``var`` global-scope ``UDT z = arr.get(i)`` (or ``.first`` /
+        ``.last``) nested inside a for/while loop mis-lowers to a value copy: a
+        global ``while`` loop hoists ``z`` to a class member whose in-loop init
+        becomes a value-copy assignment, and a global ``for`` loop keeps ``z`` a
+        true local but the function-local alias path (``_udt_local_alias_kind``)
+        no-ops at global scope (``_current_func_body`` is None) — both silently
+        drop the field mutation. We record exactly this shape so the (possible)
+        class member is suppressed and the in-loop VarDecl is emitted as a fresh
+        per-iteration ``UDT& z = arr[i];`` reference instead (the same alias form
+        the non-hoisted function-local path already produces). Strictly gated:
+        the RHS must be a UDT-array-element lvalue AND the name must be field-
+        mutated at global scope AND the declaration must be loop-nested. A
+        read-only get-local is never recorded, so its value-copy output is
+        unchanged. Function-local get-locals are excluded (the walker skips
+        function bodies) — those keep using the existing alias path."""
+        pairs = list(self._walk_global_scope_with_loopflag(self.ctx.ast.body, False))
+        field_mutated: set[str] = set()
+        for s, _in_loop in pairs:
+            if (isinstance(s, Assignment)
+                    and isinstance(s.target, MemberAccess)
+                    and isinstance(s.target.object, Identifier)):
+                field_mutated.add(s.target.object.name)
+        for s, in_loop in pairs:
+            if not isinstance(s, VarDecl) or s.is_var or s.is_varip:
+                continue
+            if not in_loop:
+                continue
+            if not isinstance(s.value, FuncCall):
+                continue
+            if self._is_udt_lvalue(s.value) is None:
+                continue
+            if s.name not in field_mutated:
+                continue
+            self._udt_array_get_ref_locals.add(s.name)
+
     def _extract_receiver_name(self, call_node) -> str | None:
         """Extract receiver Identifier name from m.method(...) or matrix.method(m, ...).
 
@@ -1009,9 +1262,184 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # First, find all variables that are reassigned anywhere in the AST.
         # These cannot be inlined as constants since their value changes at runtime.
         reassigned = self._find_reassigned_vars()
+        # Register never-reassigned ``var``/``varip`` scalars with a stable
+        # init FIRST — a later derived var (or a UDF body) may reference such a
+        # scalar as a stable length component, so it must be classified stable
+        # before those exprs are evaluated below.
+        self._collect_stable_var_scalars(reassigned)
         for stmt in self.ctx.ast.body:
             if isinstance(stmt, VarDecl) and stmt.name not in reassigned:
                 self._collect_known_var(stmt)
+        # A second pass handles the stable-reassigned-scalar pattern: a
+        # class-scope scalar initialized from a stable expr and reassigned
+        # ONLY inside top-level if/elif chains whose conditions and assigned
+        # values are themselves stable (inputs / timeframe.* / math.*). Such
+        # a var is a bar-invariant scalar and may feed a TA ctor length with
+        # a runtime reset that reproduces the conditional logic. Series-
+        # dependent reassignments are left untracked (rejected by the guard).
+        self._collect_reassigned_stable_scalars(reassigned)
+
+    def _collect_stable_var_scalars(self, reassigned: set[str]) -> None:
+        """Track top-level ``var``/``varip`` scalars declared exactly once (never
+        reassigned) from a stable init expression.
+
+        A ``var`` scalar's one-shot initializer runs once and the value never
+        changes across bars, so a never-reassigned ``var`` over a stable init
+        (``var int _tfSec = timeframe.in_seconds()``) is a bar-invariant scalar —
+        safe to embed in a TA ctor runtime-reset expression. Recording it in
+        ``_derived_input_expr`` + ``_stable_runtime_vars`` lets the reset path
+        expand the name and lets ``_expr_is_stable`` classify it (the
+        ``_stable_runtime_vars`` check precedes the ``_var_names`` rejection).
+
+        A ``var`` that is reassigned anywhere (``:=`` in ``reassigned``), is a
+        series var, or is initialized from a non-stable value stays untracked —
+        so a TA length fed by genuinely-mutable persistent state is still
+        rejected by the constructor guard. Names are NOT folded into
+        ``_known_vars`` (no use-site inlining): only the length-analysis path is
+        affected, and the ``var`` member still emits and initializes normally.
+        """
+        for stmt in (self.ctx.ast.body or []):
+            if not isinstance(stmt, VarDecl):
+                continue
+            if not (stmt.is_var or stmt.is_varip):
+                continue
+            if stmt.name in reassigned:
+                continue
+            if stmt.name in self.ctx.series_vars:
+                continue
+            if stmt.value is None or not self._expr_is_stable(stmt.value):
+                continue
+            expr_str = self._arith_expr_to_str(stmt.value)
+            if expr_str is None:
+                continue
+            self._derived_input_expr[stmt.name] = expr_str
+            self._stable_runtime_vars.add(stmt.name)
+            # Mark input-backed iff the init references an input, so the reset
+            # emits override-aware get_input_*() reads for it.
+            import re as _re
+            toks = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", expr_str))
+            if any(t in self._input_backed_vars for t in toks):
+                self._input_backed_vars.add(stmt.name)
+
+    def _collect_reassigned_stable_scalars(self, reassigned: set[str]) -> None:
+        """Track class-scope scalars that are reassigned but only along stable
+        if/elif paths (see ``test_stable_reassigned_class_scope_length``).
+
+        For each top-level ``v = <init>`` whose name is reassigned, build the
+        final value as a nested ternary by folding subsequent top-level
+        IfStmts / direct Assignments. If every condition and every assigned
+        RHS is stable (and renderable), record the ternary in
+        ``_derived_input_expr`` and add ``v`` to ``_stable_runtime_vars`` so
+        the TA ctor reset path can expand it. Anything non-stable (a ta.*
+        result, a bar field, a series var) leaves the var untracked, so the
+        ctor guard still rejects it loudly.
+        """
+        from ..ast_nodes import IfStmt, Assignment
+        body = self.ctx.ast.body or []
+        # Pre-resolve each reassigned var's initial VarDecl.
+        inits: dict[str, object] = {}
+        for stmt in body:
+            if (isinstance(stmt, VarDecl) and stmt.name in reassigned
+                    and not stmt.is_var and not stmt.is_varip):
+                # Only consider vars whose initial value is itself stable;
+                # an unstable init cannot become a stable scalar via later
+                # reassignment.
+                if stmt.value is not None and self._expr_is_stable(stmt.value):
+                    inits[stmt.name] = stmt.value
+        if not inits:
+            return
+
+        def _value_after(stmts, fallback: str | None) -> str | None:
+            """Fold a statement list into the final value expression for the
+            target var, given ``fallback`` as the value on entry. Returns None
+            if any condition / assignment is non-stable or unrenderable."""
+            current = fallback
+            for s in stmts or []:
+                if isinstance(s, Assignment) and isinstance(s.target, Identifier):
+                    if s.target.name != target_name:
+                        continue
+                    if s.op != ":=":
+                        return None  # compound assignment — not a stable fold
+                    if not self._expr_is_stable(s.value):
+                        return None
+                    rhs = self._arith_expr_to_str(s.value)
+                    if rhs is None:
+                        return None
+                    current = rhs
+                elif isinstance(s, IfStmt):
+                    # Only model IfStmts that actually reassign the target var;
+                    # an unrelated IfStmt (e.g. entry/exit logic with a series
+                    # condition) must NOT abort the fold — the var simply keeps
+                    # its current value through it.
+                    if not _reassigns(s, target_name):
+                        continue
+                    if not self._expr_is_stable(s.condition):
+                        return None
+                    cond = self._arith_expr_to_str(s.condition)
+                    if cond is None:
+                        return None
+                    then_val = _value_after(s.body, current)
+                    if then_val is None:
+                        return None
+                    else_val = _value_after(s.else_body, current)
+                    if else_val is None:
+                        return None
+                    current = f"({cond} ? {then_val} : {else_val})"
+                # Other statement shapes (for/while/switch/var decls of
+                # other vars) are ignored for this var's value fold; they
+                # do not reassign ``target_name`` in a way we model.
+            return current
+
+        def _reassigns(node, name: str) -> bool:
+            """True if any ``:=`` assignment to ``name`` occurs within node."""
+            from ..ast_nodes import IfStmt as _If, Assignment as _Asg
+            if isinstance(node, _Asg) and isinstance(node.target, Identifier):
+                return node.target.name == name
+            if isinstance(node, _If):
+                if any(_reassigns(c, name) for c in (node.body or [])):
+                    return True
+                if any(_reassigns(c, name) for c in (node.else_body or [])):
+                    return True
+                return False
+            for attr in ("body", "else_body", "cases", "default_body"):
+                sub = getattr(node, attr, None)
+                if isinstance(sub, list):
+                    if any(_reassigns(c, name) for c in sub):
+                        return True
+            return False
+
+        for target_name, init_node in inits.items():
+            init_str = self._arith_expr_to_str(init_node)
+            if init_str is None:
+                continue
+            final = _value_after(body, init_str)
+            if final is None:
+                continue
+            # Sanity: the fold must actually differ from the bare init,
+            # otherwise there were no stable reassignments and the var is
+            # already covered (or rejected) by the main pass.
+            if final == init_str:
+                continue
+            # Fold to a compile-time literal when possible (so the ctor-init
+            # list can use it directly); otherwise record the raw expression
+            # for the runtime reset path to expand.
+            folded = self._resolve_known(final)
+            if self._is_compile_time_value(folded):
+                try:
+                    num = float(folded)
+                    self._known_vars[target_name] = (
+                        int(num) if num == int(num) else num
+                    )
+                except ValueError:
+                    pass
+            self._derived_input_expr[target_name] = final
+            self._stable_runtime_vars.add(target_name)
+            # Mark input-backed iff the expression references an input so the
+            # override-aware get_input_*() reads are emitted on the reset path.
+            import re as _re
+            toks = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", final))
+            if any(t in self._input_backed_vars for t in toks):
+                self._input_backed_vars.add(target_name)
 
     def _find_reassigned_vars(self) -> set[str]:
         """Scan AST to find all variable names that are targets of := or compound assignment."""
@@ -1038,11 +1466,276 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             walk(stmt)
         return reassigned
 
-    def _arith_expr_to_str(self, node) -> str | None:
+    # ``math.*`` members that are pure functions over their (stable) args, or
+    # stable constants. Anything outside this set (e.g. ``math.random``) is
+    # treated as non-stable. Used by ``_expr_is_stable``.
+    _MATH_STABLE_MEMBERS: frozenset[str] = frozenset({
+        "pi", "e", "phi", "rphi",
+        "abs", "max", "min", "round", "floor", "ceil",
+        "sqrt", "log", "log10", "exp", "pow",
+        "sin", "cos", "tan", "asin", "acos", "atan", "sign",
+        "sum", "avg", "to_precision", "round_to_mintick",
+    })
+
+    # ``timeframe.*`` members that are constant for the lifetime of a run —
+    # they reflect the script's resolution, not a per-bar value.
+    _TF_STABLE_MEMBERS: frozenset[str] = frozenset({
+        "period", "main_period", "multiplier",
+        "isintraday", "isminutes", "isdaily", "isweekly",
+        "ismonthly", "isdwm", "isseconds", "in_seconds", "isticks",
+    })
+
+    # Depth ceiling for inlining nested single-expression user functions while
+    # classifying a TA length's stability. Pine forbids recursion, so any real
+    # chain is shallow; the cap is a backstop against pathological input and is
+    # enforced together with a name-stack cycle guard.
+    _UDF_INLINE_MAX_DEPTH = 16
+
+    def _get_udf_def(self, name: str):
+        """Return the top-level single-name ``FuncDef`` for ``name`` (or None).
+
+        Built lazily and cached. UDT ``MethodDef``s are intentionally excluded —
+        only a free function can appear as a bare-name TA length call.
+        """
+        cache = getattr(self, "_udf_def_cache", None)
+        if cache is None:
+            cache = {}
+            for stmt in (self.ctx.ast.body or []):
+                if isinstance(stmt, FuncDef):
+                    # Last definition wins; a name map is all the length path needs.
+                    cache[stmt.name] = stmt
+            self._udf_def_cache = cache
+        return cache.get(name)
+
+    def _inline_single_expr_udf(self, node, _udf_stack: frozenset = frozenset(),
+                                _depth: int = 0):
+        """If ``node`` is a call to a user-defined SINGLE-EXPRESSION function,
+        return its body expression with each parameter substituted by the
+        corresponding call-argument node. Returns None when the call is not such
+        a function, the arity/kwargs do not match, the body is not a single
+        expression, the body contains a shape we do not clone, or the call would
+        recurse (cycle / depth-limit).
+
+        Purely structural: it does NOT judge stability (the caller does, via
+        ``_expr_is_stable`` on the returned node). The conservative None keeps
+        the TA-ctor guard intact.
+        """
+        if not isinstance(node, FuncCall):
+            return None
+        func_name, namespace = self._resolve_callee(node.callee)
+        if namespace is not None or func_name is None:
+            return None
+        if func_name in _udf_stack or _depth >= self._UDF_INLINE_MAX_DEPTH:
+            return None
+        fdef = self._get_udf_def(func_name)
+        if fdef is None:
+            return None
+        # A body that is exactly ONE expression statement is inlinable, whether
+        # written inline after ``=>`` (``is_single_expr=True``) or as a one-line
+        # indented block (``f(x) =>`` then a single indented expr, which the
+        # parser records as ``is_single_expr=False`` with a one-ExprStmt body —
+        # the gonzowiththewind-sisyphus ``f_bars`` shape). A multi-statement
+        # body (len != 1, or a non-ExprStmt) is conservatively refused.
+        body = fdef.body
+        if not body or len(body) != 1 or not isinstance(body[0], ExprStmt):
+            return None
+        # Require a plain positional call: one arg per param, no kwargs, no
+        # default-parameter fill-in — anything else is conservatively refused.
+        if node.kwargs or len(node.args) != len(fdef.params):
+            return None
+        subst = dict(zip(fdef.params, node.args))
+        return self._subst_params(body[0].expr, subst)
+
+    def _subst_params(self, node, subst: dict):
+        """Return a copy of ``node`` with every ``Identifier`` whose name is a
+        key in ``subst`` replaced by the mapped argument node. Returns None for
+        any node outside the small arithmetic/call grammar we fold (an
+        unrecognised construct — e.g. a history ``Subscript`` — conservatively
+        aborts the inline). ``dataclasses.replace`` preserves ``loc``/
+        ``annotations`` so diagnostics still point at real source spans."""
+        import dataclasses as _dc
+        if isinstance(node, (NumberLiteral, StringLiteral, BoolLiteral, NaLiteral)):
+            return node
+        if isinstance(node, Identifier):
+            return subst.get(node.name, node)
+        if isinstance(node, MemberAccess):
+            obj = self._subst_params(node.object, subst)
+            if obj is None:
+                return None
+            return _dc.replace(node, object=obj)
+        if isinstance(node, Ternary):
+            c = self._subst_params(node.condition, subst)
+            t = self._subst_params(node.true_val, subst)
+            f = self._subst_params(node.false_val, subst)
+            if c is None or t is None or f is None:
+                return None
+            return _dc.replace(node, condition=c, true_val=t, false_val=f)
+        if isinstance(node, BinOp):
+            l = self._subst_params(node.left, subst)
+            r = self._subst_params(node.right, subst)
+            if l is None or r is None:
+                return None
+            return _dc.replace(node, left=l, right=r)
+        if isinstance(node, UnaryOp):
+            o = self._subst_params(node.operand, subst)
+            if o is None:
+                return None
+            return _dc.replace(node, operand=o)
+        if isinstance(node, FuncCall):
+            if node.kwargs:
+                return None
+            new_args = []
+            for a in node.args:
+                sa = self._subst_params(a, subst)
+                if sa is None:
+                    return None
+                new_args.append(sa)
+            return _dc.replace(node, args=new_args)
+        # Subscript (history read) and anything else: not a stable-length shape.
+        return None
+
+    def _expr_is_stable(self, node, _udf_stack: frozenset = frozenset(),
+                        _depth: int = 0) -> bool:
+        """True iff ``node``'s value is a bar-invariant scalar.
+
+        A stable expression depends only on: literals, ``input.*`` values,
+        previously-tracked stable runtime vars, known compile-time consts,
+        ``timeframe.*`` members (constant per run), ``syminfo.*`` (constant
+        per instrument), and ``math.*`` functions/consts over stable
+        sub-expressions, combined with arithmetic / comparison / logical
+        ops, ternaries, and the ``int/float/bool/string`` casts.
+
+        Returns False (i.e. "series") for any node that references a per-bar
+        value: bar fields (close/open/...), series vars, history subscripts,
+        ``ta.*`` results, strategy.* state, or any unrecognised construct.
+        The conservative False keeps the TA-ctor guard intact for genuinely
+        dynamic lengths.
+        """
+        if node is None:
+            return False
+        if isinstance(node, (NumberLiteral, StringLiteral, BoolLiteral)):
+            return True
+        if isinstance(node, NaLiteral):
+            return True
+        if isinstance(node, Identifier):
+            name = node.name
+            if name in self._known_vars:
+                return True
+            if name in self._stable_runtime_vars:
+                return True
+            if name in self._input_backed_vars:
+                return True
+            if name in self.ctx.series_vars:
+                return False
+            if name in self._var_names:
+                # var/varip persistent state — mutable across bars.
+                return False
+            if name in BAR_FIELDS or name in BAR_BUILTINS:
+                return False
+            # Unrecognised bare identifier: be conservative so we never
+            # silently allow an undeclared / dynamic length through.
+            return False
+        if isinstance(node, MemberAccess):
+            if isinstance(node.object, Identifier):
+                ns = node.object.name
+                if ns == "timeframe":
+                    return node.member in self._TF_STABLE_MEMBERS
+                if ns == "math":
+                    return node.member in self._MATH_STABLE_MEMBERS
+                if ns == "syminfo":
+                    # syminfo.* (mintick, pointvalue, tickerid, ...) is
+                    # constant for the run — safe as a stable scalar.
+                    return True
+            # bar.* / request.* / any other member access reads per-bar or
+            # dynamic state.
+            return False
+        if isinstance(node, Subscript):
+            # History read (``close[1]``) or indexed access — per-bar.
+            return False
+        if isinstance(node, Ternary):
+            return (self._expr_is_stable(node.condition, _udf_stack, _depth)
+                    and self._expr_is_stable(node.true_val, _udf_stack, _depth)
+                    and self._expr_is_stable(node.false_val, _udf_stack, _depth))
+        if isinstance(node, BinOp):
+            return (self._expr_is_stable(node.left, _udf_stack, _depth)
+                    and self._expr_is_stable(node.right, _udf_stack, _depth))
+        if isinstance(node, UnaryOp):
+            return self._expr_is_stable(node.operand, _udf_stack, _depth)
+        if isinstance(node, FuncCall):
+            func_name, namespace = self._resolve_callee(node.callee)
+            if namespace == "ta":
+                return False
+            if namespace == "math":
+                if func_name not in self._MATH_STABLE_MEMBERS:
+                    return False
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
+            if namespace == "timeframe":
+                # ``timeframe.in_seconds()`` (and any other function-form
+                # timeframe member) is a stable per-run scalar — it reflects
+                # the script's resolution, not a per-bar value.
+                if func_name not in self._TF_STABLE_MEMBERS:
+                    return False
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
+            if namespace == "input":
+                return True
+            if namespace is None and func_name in ("int", "float", "bool", "string"):
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
+            # A user-defined single-expression function is stable iff every
+            # argument is stable AND its body (with the params bound to those
+            # args) is stable — i.e. the body references only stable scalars
+            # (inputs / consts / timeframe.* / math.* / never-reassigned var
+            # scalars) and no series / strategy state / ta.* results. Inlining
+            # the body (params substituted by the arg nodes) lets the ordinary
+            # classifier decide; the name-stack + depth guard refuses recursion
+            # so a cyclic / malformed UDF is rejected, not looped forever.
+            if namespace is None and func_name is not None:
+                inlined = self._inline_single_expr_udf(node, _udf_stack, _depth)
+                if inlined is not None:
+                    if not all(self._expr_is_stable(a, _udf_stack, _depth)
+                               for a in node.args):
+                        return False
+                    return self._expr_is_stable(
+                        inlined, _udf_stack | {func_name}, _depth + 1)
+            # Any other call (multi-statement user functions, str.*, array.*,
+            # ...) — series by default; the conservative answer keeps the guard
+            # honest.
+            return False
+        return False
+
+    # AST node kinds whose serialized form is self-delimiting (a literal, a
+    # name, a member read, or a ``name(...)`` call). Non-atomic kinds (BinOp /
+    # UnaryOp / Ternary) MUST be parenthesized when they appear as an operand,
+    # otherwise re-parsing the flattened infix string silently reassociates the
+    # tree: Pine grouping ``(a - b) / (c - d)`` degrades to ``a - b / c - d``
+    # under C++ precedence. See ``_runtime_ctor_arg_for_reset`` (the string is
+    # re-parsed and lowered through the expression visitor).
+    _ATOMIC_ARITH_NODES = (NumberLiteral, Identifier, MemberAccess, FuncCall)
+
+    def _arith_operand_to_str(self, node, _udf_stack: frozenset = frozenset(),
+                              _depth: int = 0) -> str | None:
+        """Serialize ``node`` for use as an operand: parenthesize it unless its
+        serialized form is already self-delimiting, so grouping survives a
+        round-trip through the parser."""
+        s = self._arith_expr_to_str(node, _udf_stack, _depth)
+        if s is None:
+            return None
+        if isinstance(node, self._ATOMIC_ARITH_NODES):
+            return s
+        return f"({s})"
+
+    def _arith_expr_to_str(self, node, _udf_stack: frozenset = frozenset(),
+                           _depth: int = 0) -> str | None:
         """Render a numeric arithmetic-over-identifiers expression to a string
-        whose token spelling matches ``_resolve_known`` / ``_runtime_ctor_arg_for_reset``
-        (e.g. ``rsiLen * 2 - 1``). Returns None for any node shape we don't fold
-        (series subscripts, ternaries, etc.) so the caller leaves the var untracked.
+        that re-parses to the SAME tree (grouping preserved via
+        ``_arith_operand_to_str``). Returns None for any node shape we don't
+        fold (series subscripts, etc.) so the caller leaves the var untracked.
+
+        ``_udf_stack``/``_depth`` guard the single-expression-UDF inlining below
+        against recursion cycles (Pine forbids recursion, but a malformed source
+        must be refused, not looped forever).
         """
         if isinstance(node, NumberLiteral):
             v = node.value
@@ -1054,23 +1747,44 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
             return f"{node.object.name}.{node.member}"
         if isinstance(node, BinOp):
-            l = self._arith_expr_to_str(node.left)
-            r = self._arith_expr_to_str(node.right)
+            l = self._arith_operand_to_str(node.left, _udf_stack, _depth)
+            r = self._arith_operand_to_str(node.right, _udf_stack, _depth)
             if l is None or r is None:
                 return None
             return f"{l} {node.op} {r}"
         if isinstance(node, UnaryOp):
-            o = self._arith_expr_to_str(node.operand)
+            o = self._arith_operand_to_str(node.operand, _udf_stack, _depth)
             if o is None:
                 return None
             return f"{node.op}{o}"
+        if isinstance(node, Ternary):
+            c = self._arith_operand_to_str(node.condition, _udf_stack, _depth)
+            t = self._arith_operand_to_str(node.true_val, _udf_stack, _depth)
+            f = self._arith_operand_to_str(node.false_val, _udf_stack, _depth)
+            if c is None or t is None or f is None:
+                return None
+            return f"{c} ? {t} : {f}"
         if isinstance(node, FuncCall):
-            callee = self._arith_expr_to_str(node.callee)
+            # A bare-name call to a single-expression user function has no C++
+            # counterpart at class scope — inline its body (params substituted
+            # by the arg expressions) so the rendered string is pure
+            # math/timeframe/input arithmetic the ctor-reset path can expand.
+            # Namespaced calls (math.*/timeframe.*/int(...)) fall through to the
+            # ordinary ``callee(args)`` rendering below. The stack/depth guard
+            # refuses a recursive UDF (returns None -> caller leaves it untracked
+            # -> the ctor guard rejects it loudly) instead of recursing forever.
+            fn, ns = self._resolve_callee(node.callee)
+            if ns is None and fn is not None and self._get_udf_def(fn) is not None:
+                inlined = self._inline_single_expr_udf(node, _udf_stack, _depth)
+                if inlined is None:
+                    return None
+                return self._arith_expr_to_str(inlined, _udf_stack | {fn}, _depth + 1)
+            callee = self._arith_expr_to_str(node.callee, _udf_stack, _depth)
             if callee is None:
                 return None
             parts = []
             for a in node.args:
-                s = self._arith_expr_to_str(a)
+                s = self._arith_expr_to_str(a, _udf_stack, _depth)
                 if s is None:
                     return None
                 parts.append(s)
@@ -1129,36 +1843,56 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if stored:
                 self._input_backed_vars.add(node.name)
                 self._input_var_to_call[node.name] = node.value
-        # Class-scope arithmetic over known/input-backed vars
-        # (``wilderLen = rsiLen * 2 - 1``, ``n = math.round(len / 2)``).
+        # Class-scope arithmetic / ternaries / casts over known, input-backed,
+        # timeframe.*, or math.* operands
+        # (``wilderLen = rsiLen * 2 - 1``, ``fastPeriod = isM5 ? ... : ...``,
+        # ``filterLen = math.max(1, int(math.round(2 / a)))``).
         # Without this branch the derived name is untracked, the TA ctor arg
         # never folds, and the runtime-reset path silently degenerates to a
-        # period of 1. We (a) fold to a literal for the ctor-init list and
-        # (b) record the raw expression so the reset path can re-expand any
-        # input-backed operand to its get_input_*() runtime read.
-        elif isinstance(node.value, (BinOp, UnaryOp, FuncCall)):
+        # period of 1. We (a) fold to a literal for the ctor-init list when
+        # possible and (b) record the raw expression so the reset path can
+        # re-expand any input-backed operand to its get_input_*() runtime read
+        # and render timeframe.* / math.* fragments to valid C++.
+        #
+        # The ``_expr_is_stable`` gate is what separates a faithful stable
+        # scalar (inputs + constants + timeframe + math) from a series-derived
+        # value: a length that depends on a ta.* result, a history subscript,
+        # or a bar field stays untracked and is therefore rejected by the TA
+        # ctor guard — preserving the guardrail for genuine dynamic lengths.
+        elif isinstance(node.value, (BinOp, UnaryOp, FuncCall, Ternary)):
             expr_str = self._arith_expr_to_str(node.value)
-            if expr_str is not None:
+            if expr_str is not None and self._expr_is_stable(node.value):
                 import re as _re
                 tokens = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", expr_str))
-                refs_known = any(t in self._known_vars for t in tokens)
                 refs_input = any(t in self._input_backed_vars for t in tokens)
                 refs_derived = any(t in self._derived_input_expr for t in tokens)
-                if refs_known or refs_input or refs_derived:
-                    folded = self._resolve_known(expr_str)
-                    if self._is_compile_time_value(folded):
-                        try:
-                            num = float(folded)
-                            self._known_vars[node.name] = (
-                                int(num) if num == int(num) else num
-                            )
-                        except ValueError:
-                            pass
-                    if refs_input or refs_derived:
-                        # Track as input-backed so use-sites are not inlined and
-                        # the runtime-reset path emits the override-aware expr.
-                        self._derived_input_expr[node.name] = expr_str
-                        self._input_backed_vars.add(node.name)
+                # The stability classifier already proved this expression is a
+                # bar-invariant scalar (inputs / constants / timeframe.* /
+                # math.* / syminfo.* only). Track it unconditionally so later
+                # stable exprs (and the TA reset path) can reference / expand
+                # it — e.g. ``pi = math.asin(1) * 2`` feeds ``beta`` feeds
+                # ``alpha`` feeds a function-local ``filterLen``.
+                folded = self._resolve_known(expr_str)
+                if self._is_compile_time_value(folded):
+                    try:
+                        num = float(folded)
+                        self._known_vars[node.name] = (
+                            int(num) if num == int(num) else num
+                        )
+                    except ValueError:
+                        pass
+                # Record the raw expression so the runtime-reset path can
+                # re-expand operands. Always record for stable derived exprs
+                # (even pure-math / pure-timeframe ones with no input) so the
+                # reset can render them.
+                self._derived_input_expr[node.name] = expr_str
+                self._stable_runtime_vars.add(node.name)
+                # Mark input-backed so use-sites are not inlined and the
+                # override-aware get_input_*() reads are emitted on the reset
+                # path. Pure-math / pure-timeframe exprs (no input) stay out
+                # of this set, which is fine — they have no override to honor.
+                if refs_input or refs_derived:
+                    self._input_backed_vars.add(node.name)
 
     # ------------------------------------------------------------------
     # Public entry point
@@ -1215,17 +1949,172 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     walk(v)
         walk(self.ctx.ast)
 
+    def _func_cpp_base_name(self, fname: str) -> str:
+        """Return the actual emitted C++ base name for a UDF or UDT method."""
+        fi = self._func_info_map.get(fname)
+        if fi is not None and getattr(fi, "is_udt_method", False):
+            return self._emit_udt_method_cpp_name(fi)
+        return self._func_safe_name(fname)
+
+    def _inline_history_contexts_for_owner(self, owner: str | None) -> list[str | None]:
+        """Return every method-emission context that owns one source AST site.
+
+        ``None`` denotes top-level/on_bar or a function emitted exactly once.
+        Stateful UDF clones and fresh nested-helper instances use the same names
+        assigned to ``_current_instance_name`` by ``_emit_func_def`` so lookup
+        while visiting a body is deterministic and cannot collapse call sites.
+        """
+        if owner is None:
+            return [None]
+        if owner in self._dead_func_names:
+            return []
+
+        total_cs = self.ctx.func_call_site_counts.get(owner, 0)
+        cloned = (
+            owner in self.ctx.func_ta_ranges
+            or owner in self.ctx.func_series_vars
+            or owner in self.ctx.func_var_members
+            or owner in self.ctx.func_security_clone_only
+        ) and total_cs > 0
+        if cloned:
+            contexts: list[str | None] = [
+                f"{self._func_cpp_base_name(owner)}_cs{idx}"
+                for idx in range(total_cs)
+            ]
+        else:
+            contexts = [None]
+
+        for inst in self._fresh_instances:
+            if inst["fname"] == owner and inst["name"] not in contexts:
+                contexts.append(inst["name"])
+        return contexts
+
+    def _prepare_inline_history_members(self) -> None:
+        """Pre-register every generated temporary-Series class member.
+
+        Member declarations and the declaration-derived rollback aggregate are
+        emitted before function/on_bar bodies.  A source-order AST pass therefore
+        reserves stable names up front.  The key includes an emitted UDF context
+        because the same body AST is rendered once per stateful call-site clone.
+        """
+        self._inline_history_members = []
+        self._inline_history_member_by_key = {}
+        counters = {"hist_call": 0, "series_arg": 0}
+
+        def walk_nodes(value):
+            """Yield AST nodes in stable field order, including tuple elements.
+
+            NamingHelper._walk_ast predates several AST containers and is
+            intentionally a best-effort utility.  Member pre-registration must
+            be exhaustive because a missed node becomes an undeclared C++
+            member, so use the dataclass field graph directly here.
+            """
+            if isinstance(value, ASTNode):
+                yield value
+                for child in vars(value).values():
+                    yield from walk_nodes(child)
+                return
+            if isinstance(value, (list, tuple)):
+                for child in value:
+                    yield from walk_nodes(child)
+                return
+            if isinstance(value, dict):
+                for child in value.values():
+                    yield from walk_nodes(child)
+                return
+            if isinstance(value, TypeField) and value.default is not None:
+                yield from walk_nodes(value.default)
+
+        owner_by_node: dict[int, str] = {}
+        for fi in self.ctx.func_infos:
+            if fi.node is None:
+                continue
+            for child in walk_nodes(fi.node):
+                owner_by_node[id(child)] = fi.name
+
+        def register(kind: str, source_key: tuple, cpp_type: str,
+                     owner: str | None) -> None:
+            if cpp_type not in ("double", "int", "bool"):
+                cpp_type = "double"
+            for context in self._inline_history_contexts_for_owner(owner):
+                key = (kind, *source_key, context)
+                if key in self._inline_history_member_by_key:
+                    continue
+                counters[kind] += 1
+                member_name = f"_{kind}_{counters[kind]}"
+                self._inline_history_member_by_key[key] = member_name
+                self._inline_history_members.append({
+                    "kind": kind,
+                    "member_name": member_name,
+                    "cpp_type": cpp_type,
+                    "context": context,
+                })
+
+        def actual_args_for(call: FuncCall, params: list[str]) -> list:
+            if call.kwargs:
+                return _merge_kwargs(call.args, call.kwargs, params, lambda arg: arg)
+            return list(call.args)
+
+        for node in walk_nodes(self.ctx.ast):
+            owner = owner_by_node.get(id(node))
+            if isinstance(node, Subscript) and isinstance(node.object, FuncCall):
+                register(
+                    "hist_call", (id(node),), self._infer_type(node.object), owner
+                )
+
+            if not isinstance(node, FuncCall):
+                continue
+            func_name, _ = self._resolve_callee(node.callee)
+            fi = self._func_info_map.get(func_name)
+            if fi is None or fi.node is None:
+                continue
+            func_sv = self.ctx.func_series_vars.get(fi.name, set())
+            series_param_indices = {
+                idx for idx, name in enumerate(fi.node.params) if name in func_sv
+            }
+            if not series_param_indices:
+                continue
+            args = actual_args_for(node, list(fi.node.params))
+            for idx, arg in enumerate(args):
+                if idx not in series_param_indices:
+                    continue
+                if isinstance(arg, Identifier):
+                    if arg.name in BAR_FIELDS or arg.name in BAR_SERIES_PUSH:
+                        continue
+                    if arg.name in self.ctx.series_vars:
+                        continue
+                register(
+                    "series_arg", (id(node), idx), self._infer_type(arg), owner
+                )
+
+    def _inline_history_member(self, kind: str, node: ASTNode,
+                               arg_idx: int | None = None) -> str:
+        source_key = (id(node),) if arg_idx is None else (id(node), arg_idx)
+        key = (kind, *source_key, self._current_instance_name)
+        member = self._inline_history_member_by_key.get(key)
+        if member is None:
+            raise AssertionError(
+                "missing pre-registered inline history member for "
+                f"{kind} at {getattr(node, 'loc', None)} in context "
+                f"{self._current_instance_name!r}"
+            )
+        return member
+
     def generate(self) -> str:
         """Generate C++ source from the AnalyzerContext."""
         # Context-sensitive instance pre-pass (needs the naming helpers populated
         # in __init__). Computes nested stateful-helper dispatch + fresh instances.
         self._build_func_instances()
+        self._prepare_inline_history_members()
         # Pre-scan for strategy series vars
         self._prescan_strategy_series()
         self._security_ohlc_hist_fields_by_sec: dict[int, set[str]] = {}
         # request.security TA call-sites read at a history offset (``ta.ema(...)[k>=1]``).
         # Maps sec_id -> set of TA call-site indices needing an HTF history Series.
         self._security_ta_hist_idx_by_sec: dict[int, set[int]] = {}
+        # request.security helper-call results read at a history offset
+        # (``myHelper()[k]``). Maps (sec_id, node-id) -> backing Series metadata.
+        self._security_expr_hist_by_node: dict[tuple[int, int], dict] = {}
 
         lines: list[str] = []
 
@@ -1290,6 +2179,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # 2. Open class
         lines.append("class GeneratedStrategy : public BacktestEngine {")
         lines.append("public:")
+        _script_state_decl_start = len(lines)
         
         # request.security state
         for item in self._security_calls:
@@ -1318,19 +2208,26 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 for field in sorted(
                     self._security_ohlc_hist_fields_by_sec.get(sec_id, ())
                 ):
+                    ctype = self._security_bar_hist_type(field)
                     lines.append(
-                        f"    Series<double> {self._security_ohlc_hist_series_cpp(sec_id, field)}{_mbb};"
+                        f"    Series<{ctype}> {self._security_ohlc_hist_series_cpp(sec_id, field)}{_mbb};"
                     )
                 self._security_ta_hist_idx_by_sec[sec_id] = (
                     self._collect_security_ta_hist_indices(expr_node)
                 )
                 for name in self._security_ta_hist_series_names(sec_id):
                     lines.append(f"    Series<double> {name}{_mbb};")
+                self._emit_security_expr_hist_members(sec_id, expr_node, lines, _mbb)
                 continue
             if returns_tuple and tuple_size and tuple_size > 0 and isinstance(expr_node, TupleLiteral):
                 hist_fields: set[str] = set()
                 for el in expr_node.elements:
                     hist_fields |= self._collect_security_ohlc_hist_fields(el)
+                for name in item.get("mutable_globals", []) or []:
+                    info = self._global_mutable_infos.get(name)
+                    if info is not None:
+                        for stmt in getattr(info, "source_stmts", []) or []:
+                            hist_fields |= self._collect_security_ohlc_hist_fields(stmt)
                 self._security_ohlc_hist_fields_by_sec[sec_id] = hist_fields
                 for i, el in enumerate(expr_node.elements):
                     ctype = self._infer_cpp_type_for_security_elem(el)
@@ -1338,20 +2235,31 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                         lines.append(f"    {ctype} _req_sec_{sec_id}_{i}{{}};")
                     else:
                         lines.append(f"    {ctype} _req_sec_{sec_id}_{i} = na<double>();")
+            elif returns_tuple and tuple_size and tuple_size > 0:
+                self._security_ohlc_hist_fields_by_sec[sec_id] = (
+                    self._collect_security_ohlc_hist_fields_for_call(item)
+                )
+                site = self._get_ta_site(expr_node)
+                ta_name = self._ta_name_from_site(site) if site is not None else ""
+                ctype = TA_TUPLE_RESULT_TYPES.get(ta_name, "std::tuple<double, double>")
+                default = self._security_tuple_result_default(ctype, tuple_size)
+                lines.append(f"    {ctype} _req_sec_{sec_id} = {default};")
             else:
-                self._security_ohlc_hist_fields_by_sec[sec_id] = self._collect_security_ohlc_hist_fields(
-                    expr_node
+                self._security_ohlc_hist_fields_by_sec[sec_id] = (
+                    self._collect_security_ohlc_hist_fields_for_call(item)
                 )
                 lines.append(f"    double _req_sec_{sec_id} = na<double>();")
             for field in sorted(self._security_ohlc_hist_fields_by_sec.get(sec_id, ())):
+                ctype = self._security_bar_hist_type(field)
                 lines.append(
-                    f"    Series<double> {self._security_ohlc_hist_series_cpp(sec_id, field)}{_mbb};"
+                    f"    Series<{ctype}> {self._security_ohlc_hist_series_cpp(sec_id, field)}{_mbb};"
                 )
             self._security_ta_hist_idx_by_sec[sec_id] = (
                 self._collect_security_ta_hist_indices(expr_node)
             )
             for name in self._security_ta_hist_series_names(sec_id):
                 lines.append(f"    Series<double> {name}{_mbb};")
+            self._emit_security_expr_hist_members(sec_id, expr_node, lines, _mbb)
 
         if self._security_calls:
             lines.append('    std::unordered_map<std::string, Series<double>> _security_helper_series_;')
@@ -1375,9 +2283,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     )
 
         # 3. TA members
-        for site in self.ctx.ta_call_sites:
+        for _ta_idx, site in enumerate(self.ctx.ta_call_sites):
+            if _ta_idx in self._dead_ta_indices:
+                continue
             lines.append(f"    {site.class_name} {site.member_name};")
-            if getattr(site, "is_static", False):
+            if self._ta_site_uses_precalc(site):
                 vtype = self._ta_return_type(site)
                 lines.append(f"    std::vector<{vtype}> _precalc_{site.member_name};")
         lines.append("    bool _use_precalc = false;")
@@ -1485,7 +2395,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 lines.append(f"    Series<{cpp_type}> {safe}{_mbb};")
 
         # 7. Fixnan members
-        for site in self.ctx.fixnan_sites:
+        for _fi_idx, site in enumerate(self.ctx.fixnan_sites):
+            if _fi_idx in self._dead_fixnan_indices:
+                continue
             cpp_type = PINE_TYPE_TO_CPP.get(site.pine_type, "double")
             lines.append(f"    {cpp_type} {site.member_name} = na<{cpp_type}>();")
 
@@ -1499,12 +2411,26 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             else:
                 lines.append(f"    Series<double> {svar}{_mbb};")
 
+        # 8a. Synthetic temporary history.  Unlike the legacy function-local
+        # static buffers, these members are value-copyable rollback state and
+        # have one identity per source site / emitted UDF variant.
+        for info in self._inline_history_members:
+            lines.append(
+                f"    Series<{info['cpp_type']}> {info['member_name']}{_mbb};"
+            )
+
         # 8b. Global-scope non-var declarations as class members
         #     (so user-defined functions can reference them)
         seen_global = set()
         for name, ptype in self.ctx.global_var_decls:
             if name in seen_global or name in self.ctx.series_vars or name in self._var_names:
                 continue
+            # De-hoisted UDT array-element alias (Pine reference semantics): the
+            # in-loop VarDecl is emitted as a fresh ``UDT& z = arr[i];`` local
+            # reference each iteration, so there is no persistent class member.
+            if name in self._udt_array_get_ref_locals:
+                seen_global.add(name)
+                continue
             seen_global.add(name)
             safe = self._safe_name(name)
             
@@ -1558,6 +2484,16 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             emitted_clones.add(fresh_safe)
             self._emit_cloned_var_decl(orig_safe, fresh_safe, _mbb, lines)
 
+        # 8c3. Fresh fixnan members for context-sensitive helper instances.
+        #      Each fresh instance gets its OWN previous-value member so two
+        #      call paths never share fixnan state (mirrors 8c2 for vars).
+        for orig_site, fresh_safe in self._fresh_fixnan_members:
+            if fresh_safe in emitted_clones:
+                continue
+            emitted_clones.add(fresh_safe)
+            cpp_type = PINE_TYPE_TO_CPP.get(orig_site.pine_type, "double")
+            lines.append(f"    {cpp_type} {fresh_safe} = na<{cpp_type}>();")
+
         # 8d. Drawing-objects-as-data arenas (gated on _uses_drawing so
         #     non-drawing strategies emit byte-identical C++). Each arena is a
         #     per-strategy member -> reset-per-run is automatic. Caps come from
@@ -1605,6 +2541,16 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         lines.append("")
 
+        # 9d. Historical execution rollback checkpoint.  Derive the member
+        # inventory from the declarations above so every future generated
+        # state category is captured automatically (or generation fails loudly
+        # if it introduces an unfamiliar declaration form).
+        _script_state_members = self._collect_script_state_members(
+            lines[_script_state_decl_start:-1]
+        )
+        self._emit_script_state_hooks(lines, _script_state_members)
+        lines.append("")
+
         # 9. Constructor with TA initializer list
         self._emit_constructor(lines)
         lines.append("")
@@ -1612,6 +2558,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # 10. User-defined functions (with per-call-site variants for functions
         #     containing TA calls OR series variables that need isolation)
         for fi in self.ctx.func_infos:
+            # Dead-code user functions (defined but never called, with TA
+            # state whose ctor args can't be sized) are skipped entirely —
+            # their bodies reference TA members we no longer emit, and the
+            # functions never run anyway.
+            if fi.name in self._dead_func_names:
+                continue
             total_cs = self.ctx.func_call_site_counts.get(fi.name, 0)
             has_ta = fi.name in self.ctx.func_ta_ranges
             has_series = fi.name in self.ctx.func_series_vars or fi.name in self.ctx.func_var_members
@@ -1762,7 +2714,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if self._is_chart_point_callee(node.callee):
                 return False
             func_name, namespace = self._resolve_callee(node.callee)
-            if func_name in SKIP_FUNC_NAMES:
+            if namespace is None and func_name in SKIP_FUNC_NAMES:
                 return True
             if namespace in SKIP_NAMESPACES:
                 return True
@@ -1810,77 +2762,335 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     # _infer_type / _infer_tuple_types live on TypeInferer — see codegen/types.py.
     # _is_compile_time_value lives on TaSiteHelper — see codegen/ta.py.
 
+    # Pine ``timeframe.<member>`` -> C++ runtime expression. Mirrors the
+    # mapping in ``visit_expr._visit_member_access`` so a stable timeframe
+    # fragment embedded in a TA ctor reset renders to the same C++ the
+    # expression visitor would emit for a direct ``timeframe.*`` read.
+    _TIMEFRAME_MEMBER_CPP: dict[str, str] = {
+        "period": "script_tf_",
+        "main_period": "main_period()",
+        "multiplier": "tf_multiplier(script_tf_)",
+        "isintraday": "tf_is_intraday(script_tf_)",
+        "isminutes": "(tf_is_intraday(script_tf_) && !tf_is_seconds(script_tf_))",
+        "isdaily": "tf_is_daily(script_tf_)",
+        "isweekly": "tf_is_weekly(script_tf_)",
+        "ismonthly": "tf_is_monthly(script_tf_)",
+        "isdwm": "(tf_is_daily(script_tf_) || tf_is_weekly(script_tf_) || tf_is_monthly(script_tf_))",
+        "isseconds": "tf_is_seconds(script_tf_)",
+        "in_seconds": "tf_to_seconds(script_tf_)",
+        "isticks": "false",
+    }
+
+    # Pine ``math.<member>`` -> C++ form. Function members map to ``std::*``;
+    # constants map to their engine-side macro / literal.
+    _MATH_MEMBER_CPP: dict[str, str] = {
+        "pi": "M_PI", "e": "M_E", "phi": "1.618033988749895",
+        "rphi": "0.6180339887498949",
+        "abs": "std::abs", "max": "std::max", "min": "std::min",
+        "round": "std::round", "floor": "std::floor", "ceil": "std::ceil",
+        "sqrt": "std::sqrt", "log": "std::log", "log10": "std::log10",
+        "exp": "std::exp", "pow": "std::pow",
+        "sin": "std::sin", "cos": "std::cos", "tan": "std::tan",
+        "asin": "std::asin", "acos": "std::acos", "atan": "std::atan",
+        "sign": "(double)([] (double _v) { return (_v>0) - (_v<0); })",
+    }
+
+    # Pine logical operators (word form) -> C++ operator, used when rendering
+    # a stable runtime expression. Matched with word boundaries.
+    _PINE_LOGICAL_OPS: dict[str, str] = {"and": "&&", "or": "||", "not": "!"}
+
+    def _render_inline_input_calls(self, expr_str: str) -> tuple[str, bool]:
+        """Render inline ``input(...)`` / ``input.<type>(...)`` calls in a TA
+        ctor-arg expression string to override-aware ``get_input_*()`` reads.
+
+        A bare input expression passed straight as a length argument
+        (``adx(input(15), input(15))``) reaches the reset path as the raw call
+        spelling ``input(15)`` because the analyzer's param-substitution has no
+        intermediate variable to record in ``_input_backed_vars``. This helper
+        finds each such call (balanced parens, ``input`` optionally followed by
+        ``.<type>``), re-parses it into a FuncCall, and renders it via the same
+        ``_render_input_value`` used for ordinary input var reads.
+
+        Returns ``(rewritten_str, found_any)``. When no inline input call is
+        present, the string is returned unchanged with ``found_any=False``.
+        """
+        import re
+        # Locate ``input`` (as a word, not a substring of get_input_int etc.)
+        # optionally followed by ``.<member>``, then a ``(`` opening a balanced
+        # argument list.
+        out = expr_str
+        found = False
+        idx = 0
+        while idx < len(out):
+            m = re.search(r"\binput\b", out[idx:])
+            if m is None:
+                break
+            start = idx + m.start()
+            # Reject a match that is part of a longer identifier
+            # (e.g. ``get_input_int``) — the \b guard above already handles
+            # alphanumerics, but be defensive.
+            if start > 0 and (out[start - 1].isalnum() or out[start - 1] == "_"):
+                idx = start + len("input")
+                continue
+            j = start + len("input")
+            # Optional ``.<member>`` for the typed form ``input.int(...)``.
+            member = None
+            if j < len(out) and out[j] == ".":
+                k = j + 1
+                nm_start = k
+                while k < len(out) and (out[k].isalnum() or out[k] == "_"):
+                    k += 1
+                if k > nm_start:
+                    member = out[nm_start:k]
+                    j = k
+            # Must be followed by ``(`` to be a call.
+            if j >= len(out) or out[j] != "(":
+                idx = j
+                continue
+            # Walk the balanced parens to extract the call substring.
+            depth = 0
+            k = j
+            while k < len(out):
+                ch = out[k]
+                if ch == "(":
+                    depth += 1
+                elif ch == ")":
+                    depth -= 1
+                    if depth == 0:
+                        k += 1
+                        break
+                k += 1
+            if depth != 0:
+                # Unbalanced — bail on this match.
+                idx = j + 1
+                continue
+            call_src = out[start:k]
+            try:
+                from ..lexer import Lexer
+                from ..parser import Parser
+                tokens = Lexer(call_src).tokenize()
+                node = Parser(tokens, source=call_src)._parse_expression()
+                if not self._is_input_call(node):
+                    idx = k
+                    continue
+                func_name_i, namespace_i = self._resolve_callee(node.callee)
+                # Inline inputs have no enclosing var; reuse the default
+                # value as a synthetic title key so distinct defaults get
+                # distinct input controls (and identical defaults collapse,
+                # which is correct since they resolve to the same value).
+                default_node = self._get_input_default(node)
+                synth_title = self._visit_expr(default_node) if default_node is not None else ""
+                title = self._get_input_title(node, var_name=None)
+                if not title:
+                    title = synth_title
+                rendered = self._render_input_value(node, func_name_i, namespace_i, title)
+            except Exception:
+                idx = k
+                continue
+            out = out[:start] + rendered + out[k:]
+            found = True
+            idx = start + len(rendered)
+        return out, found
+
     def _runtime_ctor_arg_for_reset(self, arg_str: str) -> str | None:
-        """Convert a TA ctor-arg string into its runtime C++ expression when
-        the source expression references an input-backed variable. Returns the
-        runtime expression (e.g. ``get_input_int("MACD Fast", 12)``) when the
-        ctor arg depends on an input value; returns None for pure literals or
-        expressions that do not contain any input-backed identifier, so the
-        caller can decide to skip emitting a reset for that site.
+        """Convert a TA ctor-arg string into its runtime C++ expression.
+
+        Returns the runtime expression (e.g.
+        ``get_input_int("MACD Fast", 12)`` or a ternary / math expression
+        over such reads and ``timeframe.*`` members) when the ctor arg
+        depends on a stable runtime scalar — an input-backed variable, a
+        ``timeframe.*`` member, or arithmetic / ternaries / casts over
+        those. Returns None for pure literals or expressions that contain
+        any unrecognised (potentially series) identifier, so the caller
+        (the TA ctor guard) rejects them loudly instead of silently
+        emitting period 1.
         """
         import re
         ident_re = re.compile(r"[A-Za-z_][A-Za-z_0-9]*")
 
-        # Expand class-scope derived vars (``wilderLen`` -> ``(rsiLen * 2 - 1)``)
-        # to their raw RHS so the input-backed leaves become get_input_*() reads
-        # below. Recursive (bounded) to handle chains of derived vars; guards
-        # against cycles.
+        # Expand class-scope derived vars (``wilderLen`` -> ``(rsiLen * 2 - 1)``,
+        # ``fastPeriod`` -> ``(isM5 ? ... : ...)``) to their raw RHS so input
+        # leaves become get_input_*() reads below. Recursive (bounded) to
+        # handle chains of derived vars; guards against cycles.
         def _expand_derived(s: str, seen: frozenset = frozenset(), depth: int = 0) -> str:
             if depth > 32:
                 return s
-            def _rep(m: re.Match) -> str:
-                nm = m.group(0)
+            def _rep(p: re.Match) -> str:
+                nm = p.group(0)
                 if nm in self._derived_input_expr and nm not in seen:
                     inner = self._derived_input_expr[nm]
                     return "(" + _expand_derived(inner, seen | {nm}, depth + 1) + ")"
                 return nm
             return ident_re.sub(_rep, s)
 
-        arg_str = _expand_derived(arg_str)
+        expanded = _expand_derived(arg_str)
+
+        tokens = set(ident_re.findall(expanded))
+
+        # Gate: every identifier token must be renderable. If any token is an
+        # unrecognised bare identifier (not an input, not a known const, not
+        # a structural keyword / namespace prefix, not a stable tracked var
+        # that we already expanded), we conservatively refuse — that identifier
+        # would otherwise leak through as an undeclared C++ symbol, or worse,
+        # a series var that should have been rejected by the ctor guard.
+        structural = (set(self._PINE_LOGICAL_OPS)
+                      | {"timeframe", "math", "syminfo",
+                         "int", "float", "bool", "string",
+                         "true", "false", "na"})
+        member_tokens = (set(self._TIMEFRAME_MEMBER_CPP)
+                         | set(self._MATH_MEMBER_CPP))
+        renderable = (self._input_backed_vars
+                      | self._stable_runtime_vars
+                      | structural
+                      | member_tokens)
+        leftover = tokens - renderable
+        # Known compile-time consts that survived expansion (e.g. ``pi`` was
+        # NOT tracked as a Python value but its name token is a stable var
+        # already; pure numeric names are in _known_vars and covered above).
+        leftover = {t for t in leftover if t not in self._known_vars}
+        # Inline ``input(...)`` / ``input.<t>(...)`` calls (a bare input
+        # expression passed straight as a length arg, e.g.
+        # ``adx(input(15), input(15))``) are re-parsed and rendered below,
+        # after the gate. ``input`` is the only token they contribute, so
+        # allow it through the gate here.
+        leftover.discard("input")
+        if leftover:
+            return None
 
-        tokens = ident_re.findall(arg_str)
-        input_tokens = [t for t in tokens if t in self._input_backed_vars]
-        if not input_tokens:
+        # Must depend on at least one runtime component (input-backed var, a
+        # timeframe reference, or an inline input() call); otherwise it's a
+        # pure compile-time expr and no reset is needed (the ctor-init literal
+        # is correct).
+        has_input = any(t in self._input_backed_vars for t in tokens)
+        has_timeframe = "timeframe" in tokens
+        has_inline_input = "input" in tokens
+        if not (has_input or has_timeframe or has_inline_input):
             return None
 
-        # Pine math.*  → C++ std::* (must run before identifier substitution so
-        # we don't treat `math.round` etc. as a bare identifier). We wrap the
-        # whole expression in (int) below because TA ctors want integer lengths.
-        expr = arg_str
-        math_map = {
-            "math.round": "std::round",
-            "math.sqrt": "std::sqrt",
-            "math.ceil": "std::ceil",
-            "math.floor": "std::floor",
-            "math.abs": "std::abs",
-            "math.max": "std::max",
-            "math.min": "std::min",
-            "math.log": "std::log",
-            "math.exp": "std::exp",
-            "math.pow": "std::pow",
-        }
-        for pine_fn, cpp_fn in math_map.items():
-            expr = expr.replace(pine_fn, cpp_fn)
-
-        def _sub(match: re.Match) -> str:
-            name = match.group(0)
-            if name not in self._input_backed_vars:
-                return name
-            call_node = self._input_var_to_call.get(name)
-            if call_node is None:
-                return name
-            func_name_i, namespace_i = self._resolve_callee(call_node.callee)
-            title = self._get_input_title(call_node, var_name=name)
-            return self._render_input_value(call_node, func_name_i, namespace_i, title)
+        # Preferred path: re-parse the (gate-approved, grouping-faithful)
+        # expression and lower it through the SAME expression visitor the
+        # statement path uses. Operator grouping and Pine numeric typing
+        # (``/`` always yields float; ``(double)`` coercion) are then correct
+        # by construction — reused from ``_visit_binop``, not re-derived here.
+        # Falls back to the legacy token-substitution renderer below only if
+        # re-parse / lowering unexpectedly fails, so a working site is never
+        # worse off than before this change.
+        lowered = self._lower_reset_expr_via_visitor(expanded)
+        if lowered is not None:
+            return lowered
+
+        # Render inline input() calls to override-aware get_input_*() reads
+        # now that the gate has accepted the expression. Done after the gate
+        # so the rendered getter tokens (get_input_int, ...) do not have to
+        # be added to ``renderable``.
+        if has_inline_input:
+            expanded, _ = self._render_inline_input_calls(expanded)
+
+        expr = expanded
+
+        # 1) timeframe.<member> -> C++ (before ident substitution so the
+        # member names don't get caught by the identifier pass). Use a
+        # targeted regex so e.g. ``isminutes`` is not confused with
+        # ``ismonthly``.
+        def _tf_rep(p: re.Match) -> str:
+            mem = p.group(1)
+            return self._TIMEFRAME_MEMBER_CPP.get(mem, p.group(0))
+        # ``timeframe.in_seconds()`` is a function-form member in Pine (the
+        # only one in the table); its C++ form ``tf_to_seconds(script_tf_)``
+        # is already a complete call, so consume the Pine ``()`` to avoid a
+        # double-call ``tf_to_seconds(script_tf_)()``. Property-form members
+        # (``timeframe.isdaily``) never carry ``()`` so the optional group is
+        # a no-op for them.
+        expr = re.sub(r"\btimeframe\.(\w+)(?:\(\))?", _tf_rep, expr)
+
+        # 2) math.<member> -> C++ (constants + std::* functions).
+        def _math_rep(p: re.Match) -> str:
+            mem = p.group(1)
+            return self._MATH_MEMBER_CPP.get(mem, p.group(0))
+        expr = re.sub(r"\bmath\.(\w+)", _math_rep, expr)
+
+        # 3) Pine word-logical operators -> C++ operators (after timeframe/math
+        # substitution so we don't rewrite inside their C++ expansions).
+        for pine_op, cpp_op in self._PINE_LOGICAL_OPS.items():
+            expr = re.sub(rf"\b{pine_op}\b", cpp_op, expr)
+
+        # 4) Substitute input-backed vars with override-aware get_input_*()
+        # reads, and inline known compile-time consts (non-input) as literals.
+        def _sub(p: re.Match) -> str:
+            name = p.group(0)
+            if name in self._input_backed_vars:
+                call_node = self._input_var_to_call.get(name)
+                if call_node is None:
+                    return name
+                func_name_i, namespace_i = self._resolve_callee(call_node.callee)
+                title = self._get_input_title(call_node, var_name=name)
+                return self._render_input_value(call_node, func_name_i, namespace_i, title)
+            if name in self._known_vars and name not in self._input_backed_vars:
+                val = self._known_vars[name]
+                if isinstance(val, bool):
+                    return "true" if val else "false"
+                if isinstance(val, (int, float)):
+                    return str(val)
+                return f'std::string("{self._cpp_string_escape(val)}")'
+            return name
 
         rewritten = ident_re.sub(_sub, expr)
-        # Pine auto-converts floats to ints for TA lengths; C++ does not, so
-        # wrap the whole expression in an explicit int cast when any math.*
-        # function appears (they return doubles).
-        if any(m in arg_str for m in math_map):
+
+        # 5) Pine auto-converts floats to ints for TA lengths; C++ does not.
+        # If any math.* function appears (returns double) OR a timeframe.*
+        # boolean is part of a ternary whose branches are doubles, wrap the
+        # whole expression in an explicit int cast so the TA ctor gets an
+        # integer length.
+        had_math = "std::" in rewritten or bool(re.search(r"\btimeframe\b", expanded))
+        if had_math:
             return f"(int)({rewritten})"
         return rewritten
 
+    def _lower_reset_expr_via_visitor(self, expanded: str) -> str | None:
+        """Re-parse a gate-approved, fully-expanded TA-length expression and
+        lower it through the SAME expression visitor the statement path uses,
+        so operator grouping and Pine numeric typing are preserved identically
+        (Pine ``/`` always yields float; ``math.*`` returns double; branches are
+        parenthesized). Reuses ``_visit_binop`` etc.; nothing is re-typed here.
+
+        Input-backed variables render as override-aware ``get_input_*()`` reads
+        (not member refs) via ``_reset_input_getter_mode`` — the reset can run
+        in ``evaluate_security`` before the input members are initialised, so it
+        must not depend on their init order. Inline ``input(...)`` calls and
+        ``math.*`` / ``timeframe.*`` members lower through the visitor's own
+        handlers (same C++ the statement path would emit).
+
+        Returns None if re-parse / lowering fails, so the caller falls back to
+        the legacy token-substitution renderer (never worse than before)."""
+        try:
+            from ..lexer import Lexer
+            from ..parser import Parser
+            tokens = Lexer(expanded).tokenize()
+            node = Parser(tokens, source=expanded)._parse_expression()
+        except Exception:
+            return None
+        prev = self._reset_input_getter_mode
+        self._reset_input_getter_mode = True
+        try:
+            rendered = self._visit_expr(node)
+        except Exception:
+            return None
+        finally:
+            self._reset_input_getter_mode = prev
+        if not rendered or "/* " in rendered:
+            # Unknown/unhandled node leaked a placeholder — defer to legacy.
+            return None
+        # A TA length must be int. Truncate when the lowered form is
+        # float-typed (a ``std::*`` call, a ``(double)`` division coercion, or a
+        # ``timeframe.*`` helper — all timeframe helpers reference script_tf_).
+        # A bare int / identifier length carries none of these and is left
+        # unwrapped, so simple sites stay byte-identical to the legacy output.
+        if ("std::" in rendered or "(double)" in rendered
+                or "script_tf_" in rendered):
+            return f"(int)({rendered})"
+        return rendered
+
+
     def _collect_ta_runtime_resets(self) -> list[str]:
         """Collect reassignment statements for every TA object whose ctor args
         depend on an input-backed variable. Returned strings are raw C++
@@ -1892,7 +3102,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         resets: list[str] = []
 
         # Main-context TA objects
-        for site in self.ctx.ta_call_sites:
+        for _ta_idx, site in enumerate(self.ctx.ta_call_sites):
+            if _ta_idx in self._dead_ta_indices:
+                continue
             if not site.ctor_args:
                 continue
             runtime_args: list[str] = []
@@ -1910,15 +3122,38 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     f"{site.member_name} = {site.class_name}({', '.join(runtime_args)});"
                 )
 
-        # Security-context TA copies (same ctor args as their main-context site)
+        # Security-context TA copies. Normally these share the ctor args of
+        # their main-context site, but a request.security nested in a helper
+        # called at several sites is cloned per call site (distinct sec_id +
+        # callsite_idx) while the shared TA site's ``ctor_args`` were resolved
+        # ONCE (against the first call site). Every clone would then size its
+        # indicator from call site 0's argument (e.g. four EMAs all pinned to
+        # crossFastLen instead of the per-site fast/slow lengths). Resolve each
+        # sec's ctor args against ITS call site by reusing the per-call-site
+        # function-clone TA remap (identity for cs0 / non-clones, so all other
+        # output stays byte-identical).
+        sec_call_by_id = {it["sec_id"]: it for it in self._security_calls}
+        ta_site_by_member = {s.member_name: s for s in self.ctx.ta_call_sites}
         for info in self._security_eval_info:
+            sec_item = sec_call_by_id.get(info["sec_id"])
+            sec_containing = (sec_item or {}).get("containing_func") or ""
+            sec_cs_idx = (sec_item or {}).get("callsite_idx")
             for idx, variants in (info.get("ta_variants") or {}).items():
                 site = self.ctx.ta_call_sites[idx]
-                if not site.ctor_args:
+                ctor_site = site
+                if sec_containing and sec_cs_idx is not None:
+                    remap = self._func_cs_ta_remap.get((sec_containing, sec_cs_idx))
+                    if remap:
+                        cloned_name = remap.get(site.member_name)
+                        if cloned_name and cloned_name != site.member_name:
+                            cand = ta_site_by_member.get(cloned_name)
+                            if cand is not None:
+                                ctor_site = cand
+                if not ctor_site.ctor_args:
                     continue
                 runtime_args = []
                 any_runtime = False
-                for a in site.ctor_args:
+                for a in ctor_site.ctor_args:
                     rt = self._runtime_ctor_arg_for_reset(a)
                     if rt is not None:
                         runtime_args.append(rt)