@pineforge/codegen-pyodide 0.8.0 → 0.9.0

package/pineforge_codegen/codegen/base.py

@@ -39,6 +39,7 @@ from .tables import (
     BAR_FIELDS,
     BAR_BUILTINS,
     BAR_SERIES_PUSH,
+    DRAWING_TYPE_TO_CPP,
     SECURITY_OHLC_BAR_FIELDS,
     TA_RETURNS_BOOL,
     TA_IMPLICIT_COMPUTE,
@@ -52,6 +53,7 @@ from .tables import (
     SKIP_VAR_TYPES,
     SYMINFO_MEMBER_MAP,
     COLOR_CONST_MAP,
+    ARRAY_NEW_CTORS,
     ARRAY_METHODS,
     MAP_METHODS,
     MATRIX_METHODS,
@@ -64,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 /
@@ -112,12 +123,17 @@ from .visit_stmt import StmtVisitor
 from .visit_expr import ExprVisitor
 from .visit_call import CallVisitor
 
+# DrawingVisitor owns the drawing-objects-as-data dispatch (line/box/label/
+# linefill/chart.point lowering onto the per-type arenas) plus _uses_drawing
+# detection and arena-cap computation. See codegen/drawing.py.
+from .drawing import DrawingVisitor
+
 
 # ---------------------------------------------------------------------------
 # CodeGen class
 # ---------------------------------------------------------------------------
 
-class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEmitter, TaSiteHelper, TypeInferer, InputHelper, NamingHelper):
+class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEmitter, TaSiteHelper, TypeInferer, InputHelper, DrawingVisitor, NamingHelper):
     """Generate C++ from an AnalyzerContext (visitor pattern).
 
     Mixin chain (Python MRO is left-to-right; method names are
@@ -175,9 +191,41 @@ 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
+        # local initialised from a var/global UDT lvalue, mutated through, AND
+        # later rebound to a different lvalue). Member access lowers to ``->``
+        # and rebinds to ``&(...)``. Reset per function in _emit_func_def is not
+        # 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
+        # function-local static equivalent), NOT in the constructor / on_bar
+        # preamble. See ``_emit_func_var_init_block``.
+        self._func_local_var_names: set[str] = set()
+        for _vlist in ctx.func_var_members.values():
+            for _n, _, _ in _vlist:
+                self._func_local_var_names.add(_n)
 
         # Build per-function var/series name lists for cloning.
         # For each function with call-site variants, collect ALL function-scoped
@@ -260,30 +308,91 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         # Build cloned site remapping for cs > 0 (must happen before _ta_site_map
         # so cloned names are in _func_ta_members and get filtered out of the map)
+        #
+        # Default to the ``{orig}_cs{cs_idx}`` formula (matches the analyzer's clone
+        # naming), but defer to the analyzer's authoritative clone-name map for any
+        # site it had to disambiguate (a TA site reached through multiple enclosing
+        # functions would otherwise collide on the formula). Keeping the formula as
+        # the default leaves all non-colliding output byte-identical.
+        clone_names = getattr(ctx, "func_cs_ta_clone_names", {})
         for fname, orig_names in func_ta_originals.items():
             total_cs = ctx.func_call_site_counts.get(fname, 1)
             for cs_idx in range(1, total_cs):
+                overrides = clone_names.get((fname, cs_idx), {})
                 remap = {}
                 for orig_name in orig_names:
-                    remap[orig_name] = f"{orig_name}_cs{cs_idx}"
+                    remap[orig_name] = overrides.get(
+                        orig_name, f"{orig_name}_cs{cs_idx}")
                 self._func_cs_ta_remap[(fname, cs_idx)] = remap
                 self._func_ta_members.update(remap.values())
 
         for site in ctx.ta_call_sites:
             if site.node is not None:
                 if site.member_name not in self._func_ta_members:
+                    # Top-level (non-function) site: maps to itself.
                     self._ta_site_map[id(site.node)] = site
-                elif not any(site.member_name.endswith(f"_cs{i}") for i in range(1, 100)):
-                    # Original (cs0) function-local site — add to map for initial visit
+                elif id(site.node) not in self._ta_site_map:
+                    # Function-local site. Multiple clones share the SAME AST
+                    # node (clones copy ``node=orig.node``); the FIRST one in
+                    # ``ta_call_sites`` order is the canonical original (cs0)
+                    # whose ``member_name`` the per-call-site remap is keyed on.
+                    # Later clones (``_cs{i}``, ``_cs{i}_cs{j}``, ``_u{n}`` …)
+                    # must NOT overwrite it: doing so poisons the base name so
+                    # the active-remap lookup misses and every clone collapses
+                    # onto one member. Keep the original; the variant member is
+                    # resolved via ``_active_ta_remap`` at emit time.
                     self._ta_site_map[id(site.node)] = site
         self._ta_index_by_site_id: dict[int, int] = {
             id(site): i for i, site in enumerate(ctx.ta_call_sites)
         }
+        # Context-sensitive (call-path) instance machinery for nested stateful
+        # helpers. Built by ``_build_func_instances`` below. ``_current_instance_name``
+        # names the function clone whose body is currently being emitted (None at
+        # top level / non-variant bodies). ``_instance_dispatch`` maps
+        # ``(enclosing_instance_name, call_node_id) -> callee emit-name`` and is the
+        # authority for nested stateful-helper dispatch (see visit_call).
+        self._current_instance_name: str | None = None
+        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]] = {}
@@ -308,10 +417,32 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # Map input-backed var name -> its input.*() FuncCall node so we can
         # later emit a runtime get_input_*() read with the same title/default.
         self._input_var_to_call: dict[str, FuncCall] = {}
+        # Class-scope arithmetic-over-input vars (e.g. ``wilderLen = rsiLen*2-1``).
+        # Maps the derived var name -> its raw RHS expression string. When such a
+        # var feeds a TA ctor length, the runtime-reset path expands it so input
+        # overrides propagate (``(get_input_int("RSI Length",14) * 2 - 1)``); the
+        # 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
@@ -328,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)
@@ -337,6 +549,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._global_mutable_infos: dict[str, object] = getattr(ctx, "global_mutable_infos", {}) or {}
         self._udt_var_types: dict[str, str] = getattr(ctx, "udt_var_types", {}) or {}
         self._collection_types: dict[str, TypeSpec] = getattr(ctx, "collection_types", {}) or {}
+        # id(block_node) -> {raw_var_name: unique_member} for block-scoped var
+        # name collisions (see Analyzer._visit_VarDecl). Activated into
+        # ``_active_var_remap`` while emitting the owning block's statements.
+        self._block_var_renames: dict[int, dict[str, str]] = getattr(ctx, "block_var_renames", {}) or {}
         self._udt_field_type_specs: dict[str, dict[str, TypeSpec]] = getattr(ctx, "udt_field_type_specs", {}) or {}
         # Map UDT struct name -> set of field names that were dropped from the
         # emitted C++ struct because they had drawing-only types (label, line,
@@ -347,7 +563,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # rewrite or strip downstream references to those fields so the
         # generated C++ never references a member that doesn't exist on the
         # emitted struct. See: pineforge-codegen issue #10.
-        _DRAWING_TYPES_INIT = {"label", "line", "box", "table", "linefill", "polyline", "chart.point"}
+        # Drawing-objects-as-data: line/box/label/linefill/chart.point are now
+        # REAL data (un-dropped from UDT structs). Only table/polyline stay
+        # dropped (no C++ representation). See drawing-objects-as-data.md §4.2.
+        _DRAWING_TYPES_INIT = {"table", "polyline"}
         self._udt_omitted_fields: dict[str, set[str]] = {}
         for _type_name, _fields in self._udt_defs.items():
             _omitted = set()
@@ -359,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
@@ -378,6 +600,29 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._map_vars.add(_name)
             elif _spec.kind == "udt" and _spec.name:
                 self._udt_var_types.setdefault(_name, _spec.name)
+        # Table / polyline variables and params have NO C++ representation
+        # (SKIP_VAR_TYPES). A *method* call on such a receiver
+        # (``panel.cell(...)``, ``dash.merge_cells(...)``) is a visual no-op
+        # that must be dropped — but unlike the namespace form
+        # (``table.cell(...)``) the receiver is a bare var/param the
+        # namespace-based skip cannot see. Collect those names so
+        # ``_is_skip_expr`` can drop their method calls.
+        _SKIP_DECL_TYPES = set(SKIP_VAR_TYPES) | {"polyline"}
+        self._visual_drop_vars: set[str] = set()
+        for _node in self._walk_ast(self.ctx.ast):
+            if isinstance(_node, VarDecl):
+                if _node.type_hint in _SKIP_DECL_TYPES:
+                    self._visual_drop_vars.add(_node.name)
+                elif isinstance(_node.value, FuncCall):
+                    _fn, _ns = self._resolve_callee(_node.value.callee)
+                    if _fn == "new" and _ns in _SKIP_DECL_TYPES:
+                        self._visual_drop_vars.add(_node.name)
+            elif isinstance(_node, (FuncDef, MethodDef)):
+                _hints = (getattr(_node, "annotations", None) or {}).get("param_type_hints") or []
+                for _i, _p in enumerate(getattr(_node, "params", []) or []):
+                    _h = _hints[_i] if _i < len(_hints) else None
+                    if _h and str(_h).replace(" ", "") in _SKIP_DECL_TYPES:
+                        self._visual_drop_vars.add(_p)
         # Collect request.security metadata per call
         self._security_eval_info: list[dict] = []
         self._security_ta_variant_names: dict[tuple[int, int, tuple], str] = {}
@@ -388,15 +633,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             lookahead_node = item.get("lookahead_node")
             ta_range = item.get("ta_range")
 
-            tf_str = None
-            if isinstance(tf_node, StringLiteral):
-                tf_str = tf_node.value
-            elif (isinstance(tf_node, Identifier)
-                  and tf_node.name in self._known_vars
-                  and tf_node.name not in self._input_backed_vars):
-                val = self._known_vars[tf_node.name]
-                if isinstance(val, str):
-                    tf_str = val
+            # Resolve the timeframe: a literal/const/global gives a static tf;
+            # a function-parameter tf is resolved from the call sites (the
+            # evaluator is a class method, so the param is not in scope there).
+            tf_str, tf_expr = self._resolve_security_tf(
+                tf_node, item.get("containing_func", ""))
 
             is_lookahead_on = False
             if lookahead_node is not None:
@@ -447,9 +688,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             self._security_eval_info.append({
                 "sec_id": sec_id,
                 "tf": tf_str,
+                "tf_expr": tf_expr,
                 "tf_node": tf_node,
                 "gaps_on": is_gaps_on,
                 "lookahead_on": is_lookahead_on,
+                "heikinashi": bool(item.get("heikinashi", False)),
                 "ta_range": ta_range,
                 "ta_indices": sorted(ta_indices),
                 "ta_binding_stacks": ta_binding_stacks,
@@ -467,7 +710,13 @@ 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
+        # byte-identical. Caps come from the strategy() header max_*_count.
+        self._uses_drawing = self._detect_drawing_usage()
+        self._drawing_caps = self._compute_drawing_caps() if self._uses_drawing else {}
 
         # max_bars_back: the per-variable history depth the engine's Series<T>
         # ring buffer should retain. Pine exposes this two ways — the
@@ -493,6 +742,225 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # history reads off security-helper series.
         self._max_bars_back_cap: int | None = self._compute_max_bars_back_cap()
 
+    # ------------------------------------------------------------------
+    # Context-sensitive (call-path) instance machinery
+    # ------------------------------------------------------------------
+    def _iter_func_calls(self, root) -> list:
+        """Collect every ``FuncCall`` node reachable from ``root`` (a stmt list
+        or single AST node). Order-independent; used by the instance pre-pass to
+        find nested user-function calls inside a function body."""
+        out: list = []
+        seen: set[int] = set()
+        stack: list = list(root) if isinstance(root, (list, tuple)) else [root]
+        while stack:
+            node = stack.pop()
+            if node is None:
+                continue
+            if isinstance(node, (list, tuple)):
+                stack.extend(node)
+                continue
+            if isinstance(node, dict):
+                stack.extend(node.values())
+                continue
+            if not hasattr(node, "__dict__"):
+                continue
+            nid = id(node)
+            if nid in seen:
+                continue
+            seen.add(nid)
+            if isinstance(node, FuncCall):
+                out.append(node)
+            for v in vars(node).values():
+                if isinstance(v, (list, tuple, dict)) or hasattr(v, "__dict__"):
+                    stack.append(v)
+        return out
+
+    def _build_func_instances(self) -> None:
+        """Context-sensitive cloning of nested stateful helper functions.
+
+        A stateful helper ``G`` (carrying TA state and/or ``var`` members) may be
+        reached through several distinct call paths — e.g. ``leg`` called from
+        three clones of ``f_get`` (lengths 10/20/30) *and* directly. Each path is
+        a logically-distinct instance that must drive its OWN TA/var members.
+
+        The analyzer already mints the per-path members (via range-widening), but
+        the flat ``{G}_cs{idx}`` clone namespace conflates a callee's own textual
+        call sites with the enclosing function's call sites. This pre-pass walks
+        the call graph from each natural clone and, for every nested stateful
+        call, composes the enclosing clone's active remap with the callee's
+        per-call-site remap:
+
+            composed_ta[m] = R_enclosing.get(R_callee_cs[m], R_callee_cs[m])
+
+        When the composition equals the callee's natural ``cs{j}`` remap the call
+        dispatches to the existing ``{G}_cs{j}`` clone (output stays byte-identical
+        for the common single-caller case). Otherwise a fresh instance is minted,
+        bound to the path-specific members (and FRESH ``var`` members so two paths
+        never share scalar state). ``_instance_dispatch`` records the resolved
+        emit-name per ``(enclosing_instance, call_node)``; ``_fresh_instances`` /
+        ``_fresh_var_members`` carry the extra code to emit.
+        """
+        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_fixnan_indices.keys())
+                    | set(ctx.func_security_clone_only))
+        if not stateful:
+            return
+
+        func_bodies: dict[str, list] = {}
+        for fi in ctx.func_infos:
+            node = getattr(fi, "node", None)
+            if node is not None and getattr(node, "body", None):
+                func_bodies.setdefault(fi.name, node.body)
+
+        def ta_originals(fname: str) -> list[str]:
+            return list(self._func_cs_ta_remap.get((fname, 0), {}).keys())
+
+        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_cpp_base_name(fname)}_cs{cs_idx}"
+
+        interned: dict[tuple, dict] = {}
+        worklist: list[dict] = []
+        seen_walk: set[str] = set()
+        fresh_counter = 0
+
+        # Seed with the natural clones the flat emission loop produces.
+        for fname in sorted(stateful):
+            if fname not in func_bodies:
+                continue
+            total_cs = ctx.func_call_site_counts.get(fname, 0)
+            if total_cs > 0:
+                for k in range(total_cs):
+                    worklist.append({
+                        "fname": fname,
+                        "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_cpp_base_name(fname),
+                    "ta_remap": {},
+                    "var_remap": {},
+                    "fixnan_remap": {},
+                })
+
+        while worklist:
+            inst = worklist.pop()
+            if inst["name"] in seen_walk:
+                continue
+            seen_walk.add(inst["name"])
+            body = func_bodies.get(inst["fname"])
+            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:
+                    continue
+                g_name, j = cs_info
+                if g_name not in stateful:
+                    continue
+                natural_ta = self._func_cs_ta_remap.get((g_name, j), {})
+                composed_ta = {}
+                for m in ta_originals(g_name):
+                    mid = natural_ta.get(m, m)
+                    composed_ta[m] = active_ta.get(mid, mid)
+                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()),
+                       frozenset(composed_fixnan.items()))
+                ginst = interned.get(key)
+                if ginst is None:
+                    fresh_counter += 1
+                    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)
+                    worklist.append(ginst)
+                self._instance_dispatch[(inst["name"], id(callnode))] = ginst["name"]
+
+    def _emit_cloned_var_decl(self, orig_safe: str, cloned_safe: str,
+                              series_suffix: str, lines: list[str]) -> None:
+        """Declare a per-clone copy of a function-scoped ``var`` member, matching
+        the original's C++ type (series / matrix / array / map / drawing-handle /
+        UDT / scalar). Shared by the per-call-site clone loop and the fresh
+        context-sensitive instance loop."""
+        for vname, ptype, _init_str in self.ctx.var_members:
+            if self._safe_name(vname) == orig_safe:
+                cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
+                if vname in self.ctx.series_vars:
+                    lines.append(f"    Series<{cpp_type}> {cloned_safe}{series_suffix};")
+                elif vname in self._matrix_specs:
+                    lines.append(f"    {self._type_spec_to_cpp(self._matrix_specs[vname])} {cloned_safe};")
+                elif vname in self._array_vars:
+                    lines.append(f"    {self._type_spec_to_cpp(self._array_spec_for_name(vname))} {cloned_safe};")
+                elif vname in self._map_vars:
+                    lines.append(f"    {self._type_spec_to_cpp(self._map_spec_for_name(vname))} {cloned_safe};")
+                elif vname in self._udt_var_types:
+                    # Drawing handle / UDT var clone must match the original's
+                    # type (Line/Label/Box/<UDT>), not the coarse PineType
+                    # default (double) — otherwise the clone can't hold the
+                    # handle and drawing access on it reads a garbage / na id.
+                    udt_t = self._udt_var_types[vname]
+                    handle_cpp = DRAWING_TYPE_TO_CPP.get(udt_t, udt_t)
+                    lines.append(f"    {handle_cpp} {cloned_safe} = {handle_cpp}{{}};")
+                else:
+                    lines.append(f"    {cpp_type} {cloned_safe};")
+                return
+        # Non-var series var
+        if orig_safe in [self._safe_name(n) for n in self.ctx.series_vars]:
+            cpp_type = self._series_type_for(orig_safe)
+            lines.append(f"    Series<{cpp_type}> {cloned_safe}{series_suffix};")
+        else:
+            lines.append(f"    double {cloned_safe} = 0.0;")
+
     @staticmethod
     def _int_literal_value(node: ASTNode | None) -> int | None:
         """Return the integer value of a (possibly unary-minus) NumberLiteral,
@@ -575,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")
@@ -622,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, ...).
 
@@ -733,6 +1265,134 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         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_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."""
@@ -759,6 +1419,180 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             walk(stmt)
         return reassigned
 
+    # ``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",
+    })
+
+    def _expr_is_stable(self, node) -> 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)
+                    and self._expr_is_stable(node.true_val)
+                    and self._expr_is_stable(node.false_val))
+        if isinstance(node, BinOp):
+            return self._expr_is_stable(node.left) and self._expr_is_stable(node.right)
+        if isinstance(node, UnaryOp):
+            return self._expr_is_stable(node.operand)
+        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) 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) 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) for a in node.args)
+            # Any other call (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) -> 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)
+        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) -> str | None:
+        """Render a numeric arithmetic-over-identifiers expression to a string
+        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.
+        """
+        if isinstance(node, NumberLiteral):
+            v = node.value
+            if isinstance(v, float) and v == int(v):
+                return str(int(v))
+            return str(v)
+        if isinstance(node, Identifier):
+            return node.name
+        if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
+            return f"{node.object.name}.{node.member}"
+        if isinstance(node, BinOp):
+            l = self._arith_operand_to_str(node.left)
+            r = self._arith_operand_to_str(node.right)
+            if l is None or r is None:
+                return None
+            return f"{l} {node.op} {r}"
+        if isinstance(node, UnaryOp):
+            o = self._arith_operand_to_str(node.operand)
+            if o is None:
+                return None
+            return f"{node.op}{o}"
+        if isinstance(node, Ternary):
+            c = self._arith_operand_to_str(node.condition)
+            t = self._arith_operand_to_str(node.true_val)
+            f = self._arith_operand_to_str(node.false_val)
+            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)
+            if callee is None:
+                return None
+            parts = []
+            for a in node.args:
+                s = self._arith_expr_to_str(a)
+                if s is None:
+                    return None
+                parts.append(s)
+            return f"{callee}({', '.join(parts)})"
+        return None
+
     def _collect_known_var(self, node: VarDecl) -> None:
         """Extract known constant value from a VarDecl."""
         # Don't inline series variables — their values change over time
@@ -811,6 +1645,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 / 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 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 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_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)
+                # 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
@@ -867,11 +1751,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] = []
 
@@ -897,6 +1942,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     continue
                 spec = field_specs.get(f.name) or self._type_spec_from_hint_name(f.type_name)
                 cpp_type = self._type_spec_to_cpp(spec)
+                # Pine ``int`` is 64-bit (it routinely holds UNIX-ms timestamps
+                # and large bar indices); emit UDT int fields as ``int64_t`` so a
+                # field initialised from ``time``/``current_bar_.timestamp`` does
+                # not truncate / narrow-init.
+                if cpp_type == "int":
+                    cpp_type = "int64_t"
                 if f.default:
                     default = self._visit_expr(f.default)
                 else:
@@ -930,6 +1981,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:
@@ -958,14 +2010,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)
@@ -973,15 +2037,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_;')
@@ -1005,9 +2085,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;")
@@ -1031,8 +2113,20 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 continue
             seen_var_members.add(name)
             safe = self._safe_name(name)
-            # Detect array vars from init expression
-            if "array.new" in str(init_str) or "array.from" in str(init_str) or name in self._array_vars:
+            # Detect array vars from init expression. Guard the substring
+            # heuristic against a UDT constructor that merely WRAPS array.new /
+            # array.from in its arguments — e.g.
+            # ``var draw d = draw.new(array.new<line>(), array.new<line>())``
+            # must declare as ``draw``, not ``std::vector<double>``. (Drawing
+            # made this latent collision reachable.)
+            _init_str_s = str(init_str)
+            _is_udt_ctor_init = any(
+                _init_str_s.startswith(f"{u}.new") for u in self._udt_defs
+            )
+            if (not _is_udt_ctor_init) and (
+                "array.new" in _init_str_s or "array.from" in _init_str_s
+                or name in self._array_vars
+            ):
                 self._array_vars.add(name)
                 lines.append(f"    {self._type_spec_to_cpp(self._array_spec_for_name(name))} {safe};")
                 continue
@@ -1063,6 +2157,17 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # decl as ``double`` and the later ``z = SDZone{...}`` would not
             # compile (assigning SDZone to double).
             init_s = str(init_str)
+            # Drawing handle var member (L-N2): a ``var line x`` declares as the
+            # C++ handle struct (Series<Line> when also history-referenced).
+            # Drawing names are NOT in _udt_defs, so the udt branch below would
+            # self-zero them to double; handle them first.
+            _draw_cpp = DRAWING_TYPE_TO_CPP.get(self._udt_var_types.get(name))
+            if _draw_cpp is not None:
+                if name in self.ctx.series_vars:
+                    lines.append(f"    Series<{_draw_cpp}> {safe}{_mbb};")
+                else:
+                    lines.append(f"    {_draw_cpp} {safe};")
+                continue
             udt_type = self._udt_var_types.get(name)
             if udt_type not in self._udt_defs:
                 udt_type = None
@@ -1092,7 +2197,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}>();")
 
@@ -1106,12 +2213,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)
             
@@ -1131,7 +2252,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 # data/validation/udt-method-probe-19-array-of-udt-method,
                 # data/validation/udt-method-probe-20-udt-return-from-func.
                 udt_t = self._udt_var_types[name]
-                lines.append(f"    {udt_t} {safe} = {udt_t}{{}};")
+                # Drawing handle global (L-N6 / U): map line/box/label/linefill
+                # to the C++ handle struct (the default is na, id=-1).
+                _draw_cpp = DRAWING_TYPE_TO_CPP.get(udt_t)
+                if _draw_cpp is not None:
+                    lines.append(f"    {_draw_cpp} {safe} = {_draw_cpp}{{}};")
+                else:
+                    lines.append(f"    {udt_t} {safe} = {udt_t}{{}};")
             else:
                 expr = self.ctx.global_expr_map.get(name) if hasattr(self.ctx, "global_expr_map") else None
                 cpp_type = self._infer_type(expr) if expr is not None else PINE_TYPE_TO_CPP.get(ptype, "double")
@@ -1148,37 +2275,65 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 if cloned_safe in emitted_clones:
                     continue  # already declared by another function's clone
                 emitted_clones.add(cloned_safe)
-                # Determine the type by finding the original declaration
-                orig_name = orig_safe  # _safe_name was already applied
-                # Check if it's a var member (Series) or plain series
-                found = False
-                for vname, ptype, init_str in self.ctx.var_members:
-                    if self._safe_name(vname) == orig_safe:
-                        cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
-                        if vname in self.ctx.series_vars:
-                            lines.append(f"    Series<{cpp_type}> {cloned_safe}{_mbb};")
-                        elif vname in self._matrix_specs:
-                            lines.append(f"    {self._type_spec_to_cpp(self._matrix_specs[vname])} {cloned_safe};")
-                        elif vname in self._array_vars:
-                            lines.append(f"    {self._type_spec_to_cpp(self._array_spec_for_name(vname))} {cloned_safe};")
-                        elif vname in self._map_vars:
-                            lines.append(f"    {self._type_spec_to_cpp(self._map_spec_for_name(vname))} {cloned_safe};")
-                        else:
-                            lines.append(f"    {cpp_type} {cloned_safe};")
-                        found = True
-                        break
-                if not found:
-                    # Non-var series var
-                    if orig_safe in [self._safe_name(n) for n in self.ctx.series_vars]:
-                        cpp_type = self._series_type_for(orig_safe)
-                        lines.append(f"    Series<{cpp_type}> {cloned_safe}{_mbb};")
-                    else:
-                        lines.append(f"    double {cloned_safe} = 0.0;")
+                self._emit_cloned_var_decl(orig_safe, cloned_safe, _mbb, lines)
+
+        # 8c2. Fresh var members for context-sensitive helper instances (nested
+        #      helpers reached through >1 distinct call path). Each fresh instance
+        #      gets its OWN scalar/series state so two paths never collide.
+        for orig_safe, fresh_safe in self._fresh_var_members:
+            if fresh_safe in emitted_clones:
+                continue
+            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
+        #     the strategy() header max_*_count (default 50; linefill default 50).
+        if self._uses_drawing:
+            caps = self._drawing_caps or {}
+            lines.append(f"    DrawingArena<LineRec> _pf_lines_{{{caps.get('line', 50)}}};")
+            lines.append(f"    DrawingArena<BoxRec> _pf_boxes_{{{caps.get('box', 50)}}};")
+            lines.append(f"    DrawingArena<LabelRec> _pf_labels_{{{caps.get('label', 50)}}};")
+            lines.append(f"    DrawingArena<LinefillRec> _pf_linefills_{{{caps.get('linefill', 50)}}};")
 
         # 9. _var_initialized flag
         if self.ctx.var_members:
             lines.append("    bool _var_initialized = false;")
 
+        # 9a. Per-function-variant ``var`` init flags. A function-scoped
+        #     ``var`` (Pine "init once" semantics) is a function-local static:
+        #     its initializer runs on the FIRST call to that function variant
+        #     (with the first bar's values the function actually sees) and the
+        #     result persists for the strategy's lifetime. Each clone (cs0,
+        #     cs1, ...) is an independent instance with its own flag.
+        #     ``func_var_members`` is keyed by the plain Pine function name
+        #     (``fi.name``), so this matches both plain UDFs and UDT methods.
+        for fi in self.ctx.func_infos:
+            if fi.name not in self.ctx.func_var_members:
+                continue
+            total_cs = self.ctx.func_call_site_counts.get(fi.name, 0)
+            if total_cs > 0:
+                for cs_idx in range(total_cs):
+                    lines.append(f"    bool _fvinit_{self._func_safe_name(fi.name)}_cs{cs_idx} = false;")
+            else:
+                lines.append(f"    bool _fvinit_{self._func_safe_name(fi.name)} = false;")
+
+        # 9a2. ``var`` init flags for fresh context-sensitive helper instances.
+        for inst in self._fresh_instances:
+            if inst["fname"] in self.ctx.func_var_members and inst["var_remap"]:
+                lines.append(f"    bool _fvinit_{inst['name']} = false;")
+
         # 9b. _ta_initialized_ flag for runtime TA re-sizing (first on_bar only).
         if self.ctx.ta_call_sites:
             lines.append("    bool _ta_initialized_ = false;")
@@ -1188,6 +2343,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("")
@@ -1195,10 +2360,24 @@ 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
-            if (has_ta or has_series) and total_cs > 0:
+            # A function whose ONLY reason to need per-call-site cloning is a
+            # security-tf-monomorphized request.security (no TA/series state
+            # of its own — see Analyzer._check_mixed_callsite_security_tf)
+            # still needs N separate emitted bodies so self._active_call_site_idx
+            # is set while each is emitted (read by the request.security
+            # use-site lowering in visit_call.py to pick the right clone's
+            # sec_id).
+            needs_security_clone = fi.name in self.ctx.func_security_clone_only
+            if (has_ta or has_series or needs_security_clone) and total_cs > 0:
                 # Emit one variant per call site
                 for cs_idx in range(total_cs):
                     self._emit_func_def(fi, lines, call_site_idx=cs_idx)
@@ -1207,7 +2386,20 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._emit_func_def(fi, lines)
                 lines.append("")
 
+        # 10a. Fresh context-sensitive instances of nested stateful helpers
+        #      (reached through >1 distinct call path). Each is bound to its own
+        #      path-specific TA + var members; see _build_func_instances.
+        if self._fresh_instances:
+            fi_by_name = {fi.name: fi for fi in self.ctx.func_infos}
+            for inst in self._fresh_instances:
+                fi = fi_by_name.get(inst["fname"])
+                if fi is None:
+                    continue
+                self._emit_func_def(fi, lines, instance=inst)
+                lines.append("")
+
         # 11. on_bar()
+        self._current_instance_name = None
         self._emit_on_bar(lines)
         lines.append("")
 
@@ -1319,13 +2511,22 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     def _is_skip_expr(self, node) -> bool:
         """Check if an expression should be skipped (visual/unsupported)."""
         if isinstance(node, FuncCall):
+            # chart.point.* resolves to namespace "chart" (a SKIP_NAMESPACE) but
+            # is REAL data (a ChartPoint aggregate literal). Never skip it.
+            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
             if namespace in SKIP_VAR_TYPES:
                 return True
+            # Method call on a table/polyline-typed receiver var/param
+            # (``panel.cell(...)``). These types have no C++ representation, so
+            # the call is a visual no-op — drop it (mirrors the namespace form).
+            if namespace in self._visual_drop_vars:
+                return True
             # strategy.risk.* — handled in _visit_stmt, not skipped
         if isinstance(node, MemberAccess):
             if isinstance(node.object, Identifier) and node.object.name in SKIP_NAMESPACES:
@@ -1363,59 +2564,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]*")
-        tokens = ident_re.findall(arg_str)
-        input_tokens = [t for t in tokens if t in self._input_backed_vars]
-        if not input_tokens:
+
+        # 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(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)
+
+        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
 
-        # 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)
+        # 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
+
+        # 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++
@@ -1427,7 +2904,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] = []
@@ -1445,15 +2924,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)