@pineforge/codegen-pyodide 0.9.0 → 0.10.1

package/pineforge_codegen/codegen/base.py

@@ -6,6 +6,8 @@ results from AnalyzerContext instead of walking the AST to collect info.
 
 from __future__ import annotations
 
+from dataclasses import dataclass
+
 from ..ast_nodes import (
     ASTNode, Program, StrategyDecl, VarDecl, Assignment, IfStmt, ForStmt, ForInStmt,
     WhileStmt, SwitchStmt, BreakStmt, ContinueStmt, FuncDef, ExprStmt,
@@ -23,10 +25,19 @@ from ..analyzer import (
     TA_NO_CTOR,
     TA_PERIOD_ARG,
 )
-from ..symbols import PineType, TypeSpec
+from ..symbols import PineType, TypeSpec, method_receiver_type_name
 from .. import signatures as sigs
 from ..errors import CompileError, Diagnostic, Level, Phase, SourceLocation
 
+
+@dataclass(frozen=True)
+class _StableVarCtorLiteral:
+    """Exact declaration identity admitted by the TA-length literal route."""
+
+    value: int
+    declaration_id: int
+    top_level_index: int
+
 # ---------------------------------------------------------------------------
 # Mapping tables — definitions live in ``tables.py``; re-imported here so
 # inline references inside this module (BAR_FIELDS[name], MATH_FUNC_MAP[fn],
@@ -63,6 +74,7 @@ from .tables import (
     MATRIX_SORT_ALLOWED_GENERIC_ELEMS,
     MATH_FUNC_MAP,
     STR_FUNC_MAP,
+    _MATH_SIGN_CPP_FN,
     _merge_kwargs,
 )
 
@@ -95,7 +107,7 @@ from .helpers import CPP_RESERVED, NamingHelper
 from .types import TypeInferer
 
 # TaSiteHelper owns site lookup, .compute() arg construction, and the TA
-# hoisting machinery. The runtime-reset chain (_resolve_known and friends)
+# call-site machinery. The runtime-reset chain (_resolve_known and friends)
 # stays on CodeGen for now because it relies on Python's compile-time
 # expression evaluator.
 from .ta import TaSiteHelper
@@ -154,7 +166,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
           per-function emitters used by Pine functions and UDT methods
         * ``SecurityEmitter`` -- ``request.security()`` lowering pipeline
           (evaluators, dispatch, rebind, TA variants)
-        * ``TaSiteHelper`` -- TA call-site lookup + .compute() arg construction + TA hoisting
+        * ``TaSiteHelper`` -- TA call-site lookup + .compute() arg construction
         * ``TypeInferer``  -- _type_spec_*, _infer_type, _array/_map_method_expr
         * ``InputHelper``  -- Pine ``input.*`` defaults / titles / getter dispatch
         * ``NamingHelper`` -- _safe_name / _resolve_callee / _walk_ast / ...
@@ -172,6 +184,104 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
     def __init__(self, ctx: AnalyzerContext) -> None:
         self.ctx = ctx
+        # Lexical Pine names remain in ``ctx.func_var_members``.  This overlay
+        # carries exact class-member identities only for collision-qualified
+        # ordinary FuncDefs (identity mappings for every other ordinary UDF).
+        self._func_var_storage_names: dict[str, dict[str, str]] = {
+            owner: dict(names)
+            for owner, names in getattr(
+                ctx, "func_var_storage_names", {}
+            ).items()
+        }
+        self._qualified_func_var_raw_names: set[str] = {
+            raw_name
+            for storage_names in self._func_var_storage_names.values()
+            for raw_name, storage_name in storage_names.items()
+            if storage_name != raw_name
+        }
+        self._ordinary_global_binding_names: set[str] = set(
+            getattr(ctx, "ordinary_global_binding_names", set())
+        )
+        self._ordinary_global_series_names: set[str] = set(
+            getattr(ctx, "ordinary_global_series_names", set())
+        )
+        self._nonpersistent_series_decl_names: set[str] = set(
+            getattr(ctx, "nonpersistent_series_decl_names", set())
+        )
+        self._func_nonpersistent_series_vars: dict[str, set[str]] = {
+            owner: set(names)
+            for owner, names in getattr(
+                ctx, "func_nonpersistent_series_vars", {}
+            ).items()
+        }
+        # Exact declarations that are direct children of Program.body.  A
+        # same-named declaration inside a top-level ``if``/loop is still a
+        # lexical block local; raw membership in ``_global_member_vars`` must
+        # not route that nested declaration into the hoisted class member.
+        self._ordinary_global_var_decl_nodes: set[int] = {
+            id(stmt)
+            for stmt in ctx.ast.body
+            if isinstance(stmt, VarDecl)
+            and not stmt.is_var
+            and not stmt.is_varip
+        }
+        self._direct_program_var_decl_nodes: set[int] = {
+            id(stmt)
+            for stmt in ctx.ast.body
+            if isinstance(stmt, VarDecl)
+        }
+        self._direct_program_tuple_decl_nodes: set[int] = {
+            id(stmt)
+            for stmt in ctx.ast.body
+            if isinstance(stmt, TupleAssign)
+        }
+        self._direct_program_tuple_binding_names: set[str] = {
+            name
+            for stmt in ctx.ast.body
+            if isinstance(stmt, TupleAssign)
+            for name in stmt.names
+            if name != "_"
+        }
+        self._direct_program_binding_names: set[str] = {
+            stmt.name
+            for stmt in ctx.ast.body
+            if isinstance(stmt, VarDecl)
+        }
+        self._direct_program_binding_names.update(
+            name
+            for stmt in ctx.ast.body
+            if isinstance(stmt, TupleAssign)
+            for name in stmt.names
+            if name != "_"
+        )
+        self._callable_state_raw_names: set[str] = {
+            name
+            for members in ctx.func_var_members.values()
+            for name, _ptype, _init in members
+        }
+        self._callable_state_raw_names.update(
+            name
+            for names in ctx.func_series_vars.values()
+            for name in names
+        )
+
+        def func_var_storage(owner: str, raw_name: str) -> str:
+            return self._func_var_storage_names.get(owner, {}).get(
+                raw_name, raw_name
+            )
+
+        self._func_var_storage_name = func_var_storage
+        # Security metadata collection can render runtime timeframe
+        # expressions before the rest of the constructor state is prepared.
+        # Exact persistent-member identity is immutable analyzer output, so
+        # initialize it first for every expression visitor.
+        self._persistent_var_member_names: set[str] = {
+            self._safe_name(name) for name, _, _ in ctx.var_members
+        }
+        self._series_var_member_names: set[str] = {
+            self._safe_name(name)
+            for name in getattr(ctx, "series_var_members", set())
+        }
         # Build lookup: node id -> TACallSite (only for non-function-local sites)
         self._ta_site_map: dict[int, TACallSite] = {}
         # Build per-call-site TA member name remapping for user functions
@@ -179,8 +289,6 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._func_cs_ta_remap: dict[tuple[str, int], dict[str, str]] = {}
         # Active TA name remap (set during per-call-site function emission)
         self._active_ta_remap: dict[str, str] = {}
-        # Flag: inside a per-call-site function variant (enables TA hoisting)
-        self._in_ta_func_variant: bool = False
         # Active call-site index (set during per-call-site function emission)
         self._active_call_site_idx: int | None = None
         # Set of TA member names that belong to user functions
@@ -200,32 +308,16 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         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``.
+        # Names of ``var`` members that live in a callable scope (not global).
+        # Their exact declaration statements own initialization; they must not
+        # be initialized by the constructor or the global on_bar preamble.
         self._func_local_var_names: set[str] = set()
-        for _vlist in ctx.func_var_members.values():
+        for _owner, _vlist in ctx.func_var_members.items():
             for _n, _, _ in _vlist:
-                self._func_local_var_names.add(_n)
+                self._func_local_var_names.add(
+                    self._func_var_storage_name(_owner, _n)
+                )
 
         # Build per-function var/series name lists for cloning.
         # For each function with call-site variants, collect ALL function-scoped
@@ -241,17 +333,38 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # are themselves sets (analyzer stores ``dict[str, set]``), so we must
         # iterate each value in ``sorted`` order to be hash-seed independent.
         all_func_scoped_series: list[str] = []
-        for svars in ctx.func_series_vars.values():
+        for owner, svars in ctx.func_series_vars.items():
             for sv in sorted(svars):
-                if sv not in all_func_scoped_series:
-                    all_func_scoped_series.append(sv)
+                exact = self._func_var_storage_name(owner, sv)
+                # ``func_series_vars`` also carries history-referenced
+                # parameters/plain locals. Translate only a real persistent
+                # member whose analyzer-exact identity is Series storage.
+                if (self._safe_name(exact)
+                        in self._series_var_member_names):
+                    storage = exact
+                elif (sv in self._qualified_func_var_raw_names
+                      and sv not in self._func_nonpersistent_series_vars.get(
+                          owner, set()
+                      )):
+                    # A history parameter/plain local in an unrelated UDF may
+                    # reuse the Pine spelling of owner-qualified persistent
+                    # state. It has no class-member identity to propagate into
+                    # every other function's clone map; doing so remaps an
+                    # initializer's earlier global read to a bogus ``x_csN``
+                    # Series member before the persistent local is active.
+                    continue
+                else:
+                    storage = sv
+                if storage not in all_func_scoped_series:
+                    all_func_scoped_series.append(storage)
         # Also include function-scoped var_members (same ordered-list rationale).
         # ``ctx.func_var_members`` values are lists (already insertion-ordered).
         all_func_scoped_vars: list[str] = []
-        for vlist in ctx.func_var_members.values():
+        for owner, vlist in ctx.func_var_members.items():
             for n, _, _ in vlist:
-                if n not in all_func_scoped_vars:
-                    all_func_scoped_vars.append(n)
+                exact = self._func_var_storage_name(owner, n)
+                if exact not in all_func_scoped_vars:
+                    all_func_scoped_vars.append(exact)
 
         # For each function with call-site cloning (has TA ranges or is called multiple times),
         # include ALL function-scoped series/var vars that could be used in its body.
@@ -265,13 +378,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # Include function's own vars
             if fname in ctx.func_var_members:
                 for n, _, _ in ctx.func_var_members[fname]:
-                    if n not in orig_names:
-                        orig_names.append(n)
+                    exact = self._func_var_storage_name(fname, n)
+                    if exact not in orig_names:
+                        orig_names.append(exact)
             # Include function's own series vars (set -> sorted for determinism)
             if fname in ctx.func_series_vars:
                 for sv in sorted(ctx.func_series_vars[fname]):
-                    if sv not in orig_names:
-                        orig_names.append(sv)
+                    exact = self._func_var_storage_name(fname, sv)
+                    storage = (
+                        exact
+                        if self._safe_name(exact)
+                        in self._series_var_member_names
+                        else sv
+                    )
+                    if storage not in orig_names:
+                        orig_names.append(storage)
             # Include series vars from sub-functions (they share the same class members)
             for sv in all_func_scoped_series:
                 if sv not in orig_names:
@@ -300,7 +421,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # Build TA site map and per-call-site remapping
         func_ta_originals: dict[str, list[str]] = {}  # func_name -> list of original member names
         for fname, (start, end) in ctx.func_ta_ranges.items():
-            orig_names = [ctx.ta_call_sites[i].member_name for i in range(start, end)]
+            indices = (ctx.func_ta_indices or {}).get(fname)
+            if indices is None:
+                indices = range(start, end)
+            orig_names = [ctx.ta_call_sites[i].member_name for i in indices]
             func_ta_originals[fname] = orig_names
             self._func_ta_members.update(orig_names)
             # cs0 uses originals (identity mapping)
@@ -354,7 +478,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         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]] = []
+        self._fresh_var_members: list[tuple[str, 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
@@ -381,6 +505,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._security_inline_counter = 0
         self._random_call_counter = 0
         self._for_counter = 0
+        self._tuple_assign_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
@@ -408,6 +533,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._current_input_var_name: str | None = None
         # Build known_vars for constant propagation
         self._known_vars: dict[str, int | float | bool | str] = {}
+        # Source-ordered lexical declarations can shadow a same-named direct
+        # compile-time global.  Constant folding is raw-name keyed, so every
+        # fold path must consult this COW tombstone set before substituting a
+        # global literal inside the nested lexical scope.
+        self._lexical_known_var_tombstones: set[str] = set()
         # Subset of _known_vars whose value came from an input.*() call. These
         # MUST NOT be inlined at identifier use sites because strategy_set_input()
         # can override them at runtime. Ctor-time uses (TA buffer sizing,
@@ -433,6 +563,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # 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()
+        # Narrow subset of persistent scalars that a TA constructor may fold
+        # directly: one unique top-level ``var [int] name = <int literal>``
+        # binding, never reassigned and never promoted to Series storage.
+        # Keep this separate from ``_known_vars`` so ordinary identifier use
+        # still reads the persistent member and only TA buffer sizing changes.
+        self._stable_var_ctor_literals: dict[str, _StableVarCtorLiteral] = {}
         # ``_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
@@ -440,11 +576,30 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._var_names: set[str] = set()
         for _vn, _, _ in ctx.var_members:
             self._var_names.add(_vn)
+        ordinary_global_member_names = self._ordinary_global_binding_names
+        for _vlist in ctx.func_var_members.values():
+            self._var_names.update(
+                _n
+                for _n, _, _ in _vlist
+                if _n not in ordinary_global_member_names
+            )
         self._collect_known_vars()
         # Track var names
         self._var_names = set()
         for name, _, _ in ctx.var_members:
             self._var_names.add(name)
+        # Preserve the established raw lexical allow-list even when the class
+        # member itself is owner-qualified. Declaration-site remapping resolves
+        # legal reads/writes to exact storage; this union also prevents the
+        # legacy non-var-Series loop from emitting a second raw class member.
+        # A real ordinary global with that spelling is deliberately excluded:
+        # it owns separate class state and must still be emitted.
+        for _vlist in ctx.func_var_members.values():
+            self._var_names.update(
+                _n
+                for _n, _, _ in _vlist
+                if _n not in ordinary_global_member_names
+            )
         # Every name bound ANYWHERE in the program (top-level, nested in
         # if/for/while/switch blocks, or inside function bodies). The
         # unknown-identifier guard in _visit_ident uses this as a generous
@@ -548,7 +703,33 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             self._global_member_vars.add(name)
         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 {}
+        self._global_collection_types: dict[str, TypeSpec] = dict(
+            getattr(ctx, "collection_types", {}) or {}
+        )
+        self._collection_types: dict[str, TypeSpec] = dict(
+            self._global_collection_types
+        )
+        self._func_collection_types: dict[str, dict[str, TypeSpec]] = {
+            name: dict(specs)
+            for name, specs in (
+                getattr(ctx, "func_collection_types", {}) or {}
+            ).items()
+        }
+        self._block_collection_types: dict[int, dict[str, TypeSpec | None]] = {
+            owner_id: dict(specs)
+            for owner_id, specs in (
+                getattr(ctx, "block_collection_types", {}) or {}
+            ).items()
+        }
+        self._block_collection_owners: dict[int, str] = dict(
+            getattr(ctx, "block_collection_owners", {}) or {}
+        )
+        self._callable_collection_bindings: dict[int, TypeSpec | None] = dict(
+            getattr(ctx, "callable_collection_bindings", {}) or {}
+        )
+        self._callable_collection_binding_owners: dict[int, str] = dict(
+            getattr(ctx, "callable_collection_binding_owners", {}) 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.
@@ -579,11 +760,44 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # 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"] = {}
+        # Copy-on-write lexical collection inventory for the function/method
+        # currently being emitted.  Activated by _emit_func_def and restored
+        # together with the legacy raw-name registries at function exit.
+        self._current_func_collection_specs: dict[str, "TypeSpec"] = {}
+        # Direct callable-body declarations that shadow a top-level collection.
+        # Nested declarations are activated only by their block COW overlay.
+        self._current_func_collection_shadows: set[str] = set()
+        # While emitting ``name = RHS`` for a declaration that shadows an
+        # already-active same-named collection, RHS identifiers are redirected
+        # through a pre-declaration alias. C++ brings the new name into scope
+        # inside its own initializer, so raw ``name`` would otherwise self-bind.
+        self._pending_decl_outer_alias: dict[str, str] = {}
+        self._collection_shadow_tmp_counter = 0
+        self._collection_shadow_tmp_names: set[str] = set()
         # Current function params that are series (const Series<double>&)
         self._current_func_series_params: set[str] = set()
+        # Element types parallel to ``_current_func_series_params``.  Keeping
+        # these separate from the full C++ reference spelling lets expression
+        # inference see ``src`` as its Pine scalar family inside the body.
+        self._current_func_series_param_types: dict[str, str] = {}
         # 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] = {}
+        # Source-ordered drawing-handle bindings in the currently emitted
+        # lexical block. Values are exact C++ handle types; ``None`` is a
+        # scalar/non-drawing tombstone that prevents an outer same-named handle
+        # from leaking inward. Block push/pop provides sibling isolation.
+        self._lexical_drawing_types: dict[str, str | None] = {}
+        # Source-ordered arbitrary UDT bindings.  Drawing handles have their
+        # specialized registry above, while this parallel map preserves the
+        # exact authored UDT name needed to target-type a later bare ``na``
+        # reassignment.  ``None`` is an ordinary scalar/collection tombstone;
+        # block push/pop keeps sibling declarations independent.
+        self._lexical_udt_types: dict[str, str | None] = {}
+        # Source-ordered lexical Series status.  A False tombstone prevents a
+        # scalar local from inheriting a same-spelled global entry from the
+        # legacy raw-name ``ctx.series_vars`` union.
+        self._lexical_series_bindings: dict[str, bool] = {}
         # 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"] = {}
@@ -708,9 +922,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             self._all_member_names.add(self._safe_name(name))
         for name, _, _ in ctx.var_members:
             self._all_member_names.add(self._safe_name(name))
-
         self._register_global_aggregate_member_types()
-        self._register_udt_array_get_ref_locals()
+        self._uses_map = self._detect_map_usage()
         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
@@ -742,6 +955,328 @@ 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()
 
+        # Declaration-site ``var`` metadata is prepared in ``generate()``
+        # after context-sensitive function instances have been built.  Once
+        # flags share the class-member namespace with those fresh members, so
+        # allocating the flags here would not yet have the complete collision
+        # inventory.
+
+    def _scalar_var_init_depends_on_runtime_input(self, init_ast) -> bool:
+        """Whether a nominally constant initializer depends on input state.
+
+        ``_resolve_known`` intentionally folds input defaults for constructor
+        sizing and other compile-time decisions.  A Pine ``var`` initializer,
+        however, must observe any host override installed before the first
+        bar.  Treat direct input aliases and arithmetic aliases derived from
+        them as declaration-time expressions even when their default happens
+        to fold to a C++ literal.
+        """
+        if init_ast is None:
+            return False
+        runtime_names = set(self._input_backed_vars) | set(self._derived_input_expr)
+        for node in self._walk_ast(init_ast):
+            if isinstance(node, FuncCall) and self._is_input_call(node):
+                return True
+            if isinstance(node, Identifier) and node.name in runtime_names:
+                return True
+        return False
+
+    def _is_runtime_scalar_var_initializer(
+            self, name: str, ptype, init_str: str, init_ast,
+            drawing_cpp: str | None = None,
+            is_series: bool = False) -> bool:
+        """Return True for a persistent primitive that must init in execution.
+
+        Global Series and aggregate state keep their specialized preamble
+        routes. Callable vars are selected separately by the exact-declaration
+        rule below. This predicate identifies the remaining primitive global /
+        on-bar-scope members that need declaration-site once guards.
+        """
+        if init_ast is None:
+            return False
+        if name in self._visual_drop_vars:
+            return False
+        if name in self._array_vars or name in self._map_vars \
+                or name in self._matrix_specs:
+            return False
+        if drawing_cpp is not None:
+            # A nontrivial drawing-handle initializer may depend on preceding
+            # source-order state. Default construction already represents a
+            # bare ``na``, so only real expressions need a declaration-site
+            # once guard.
+            return (
+                is_series
+                or not self._is_na_expr(init_ast)
+            )
+        if is_series and name in self.ctx.series_vars:
+            return False
+        udt_type = self._member_udt_type(name)
+        if udt_type in self._udt_defs:
+            return False
+        type_spec = self._collection_types.get(name)
+        if type_spec is not None and type_spec.kind in {
+            "array", "map", "matrix", "udt",
+        }:
+            return False
+
+        ctor_val = self._resolve_known(init_str)
+        ctor_val = self._typed_na_init(ctor_val, name, ptype)
+        return (
+            not self._is_compile_time_value(ctor_val)
+            or self._scalar_var_init_depends_on_runtime_input(init_ast)
+        )
+
+    def _prepare_runtime_scalar_var_initializers(self) -> None:
+        """Index declaration-site scalar ``var`` initialization and flags.
+
+        The analyzer supplies exact metadata for every VarDecl, including
+        sibling-block disambiguation and callable ownership. Its insertion
+        order follows source analysis and reaches declarations nested inside
+        if/switch expressions, while the ownership bit excludes function and
+        method bodies. This lets emission preserve ordinary dependency order
+        and Pine's lazy first-entry semantics for conditional declarations.
+        """
+        self._runtime_scalar_var_init_by_node: dict[int, dict] = {}
+        self._runtime_scalar_var_init_by_member: dict[str, dict] = {}
+        self._runtime_scalar_var_init_members: set[str] = set()
+        self._drawing_var_member_cpp_types: dict[str, str] = {}
+        self._drawing_var_decl_info_by_node: dict[int, dict] = {}
+        self._global_drawing_cpp_types: dict[str, str] = {}
+        # Exact direct-program UDT identity, including ``None`` tombstones for
+        # primitive globals.  The analyzer's legacy UDT registry is keyed only
+        # by raw spelling and can be overwritten by an unrelated callable
+        # local with the same name.
+        self._global_udt_types: dict[str, str | None] = {}
+        for stmt in self.ctx.ast.body:
+            if not isinstance(stmt, VarDecl):
+                continue
+            spec = (
+                self._type_spec_from_hint_name(stmt.type_hint)
+                if stmt.type_hint
+                else self._type_spec_from_expr(stmt.value)
+            )
+            self._global_udt_types[stmt.name] = (
+                spec.name
+                if spec is not None and spec.kind == "udt"
+                else None
+            )
+        # Analyzer metadata preserves the collision-safe storage identity for
+        # every persistent declaration, including chart-scope siblings that
+        # are not direct Program children. Keep primitive tombstones too: the
+        # raw-name UDT union must not swap ``state`` and ``state__blk1`` types.
+        self._member_udt_types: dict[str, str | None] = {}
+        metadata_by_node = getattr(
+            self.ctx, "var_member_metadata_by_node", {}
+        ) or {}
+        type_specs_by_node = getattr(
+            self.ctx, "var_member_type_specs_by_node", {}
+        ) or {}
+        for node_id, meta in metadata_by_node.items():
+            stmt, member_name, _ptype, _init_str, _callable = meta
+            spec = type_specs_by_node.get(node_id)
+            if spec is None and isinstance(stmt, VarDecl):
+                spec = (
+                    self._type_spec_from_hint_name(stmt.type_hint)
+                    if stmt.type_hint
+                    else self._type_spec_from_expr(stmt.value)
+                )
+            self._member_udt_types[member_name] = (
+                spec.name
+                if spec is not None and spec.kind == "udt"
+                else None
+            )
+        self._runtime_var_init_flags: dict[tuple[int, str], str] = {}
+
+        used_names = set(self._all_member_names)
+        # ``_all_member_names`` historically covers persistent ``var`` and
+        # Series members only.  Plain global declarations are class members as
+        # well, so include them before minting a generated flag; otherwise a
+        # legal user binding such as ``_pf_var_init_seeded = 1`` can collide
+        # with the flag for ``var seeded = low``.
+        used_names.update(
+            self._safe_name(name) for name, _ptype in self.ctx.global_var_decls
+        )
+        # Natural call-site clones and context-sensitive fresh instances are
+        # emitted later, but they occupy the same C++ class-member namespace as
+        # these flags. Reserve the complete callable-state inventory up front;
+        # in particular, an authored local named ``_pf_var_init_state`` also
+        # produces a legal ``_pf_var_init_state_cs1`` storage clone.
+        for remap in self._func_cs_var_remap.values():
+            used_names.update(remap.values())
+        used_names.update(
+            fresh_safe
+            for _owner, _orig_safe, fresh_safe in self._fresh_var_members
+        )
+        used_names.update(
+            remapped
+            for remap in self._func_cs_fixnan_remap.values()
+            for remapped in remap.values()
+        )
+        used_names.update(
+            fresh_safe for _site, fresh_safe in self._fresh_fixnan_members
+        )
+        # Keep function naming stable across this late preparation pass.  A
+        # flag must avoid an emitted base/clone/fresh method name rather than
+        # making ``_func_safe_name`` change after the instance graph was built.
+        for func_info in self.ctx.func_infos:
+            emitted = self._func_cpp_base_name(func_info.name)
+            used_names.add(emitted)
+            for callsite in range(
+                self.ctx.func_call_site_counts.get(func_info.name, 0)
+            ):
+                used_names.add(f"{emitted}_cs{callsite}")
+        used_names.update(inst["name"] for inst in self._fresh_instances)
+
+        def allocate_flag(base: str) -> str:
+            flag = base
+            suffix = 2
+            while flag in used_names:
+                flag = f"{base}_{suffix}"
+                suffix += 1
+            used_names.add(flag)
+            self._all_member_names.add(flag)
+            return flag
+
+        metadata_by_node = getattr(
+            self.ctx, "var_member_metadata_by_node", {}
+        ) or {}
+        type_specs_by_node = getattr(
+            self.ctx, "var_member_type_specs_by_node", {}
+        ) or {}
+        owners_by_node = getattr(
+            self.ctx, "var_member_owners_by_node", {}
+        ) or {}
+        top_level_node_ids = {id(stmt) for stmt in self.ctx.ast.body}
+        for node_id, meta in metadata_by_node.items():
+            stmt, member_name, ptype, init_str, is_callable_scoped = meta
+            if not isinstance(stmt, VarDecl) or not (stmt.is_var or stmt.is_varip):
+                continue
+            stmt_spec = type_specs_by_node.get(node_id)
+            if stmt_spec is None:
+                stmt_spec = (
+                    self._type_spec_from_hint_name(stmt.type_hint)
+                    if stmt.type_hint
+                    else self._type_spec_from_expr(stmt.value)
+                )
+            drawing_cpp = (
+                DRAWING_TYPE_TO_CPP.get(stmt_spec.name)
+                if stmt_spec is not None and stmt_spec.kind == "udt"
+                else None
+            )
+            if drawing_cpp is not None:
+                self._drawing_var_member_cpp_types[member_name] = drawing_cpp
+                self._drawing_var_decl_info_by_node[node_id] = {
+                    "node_id": node_id,
+                    "raw_name": stmt.name,
+                    "member_name": member_name,
+                    "drawing_cpp": drawing_cpp,
+                    "is_callable_scoped": is_callable_scoped,
+                    "owner": owners_by_node.get(node_id),
+                    "type_spec": stmt_spec,
+                }
+                if node_id in top_level_node_ids:
+                    self._global_drawing_cpp_types[stmt.name] = drawing_cpp
+            is_series = self._safe_name(member_name) in self._series_var_member_names
+            if node_id in self._drawing_var_decl_info_by_node:
+                self._drawing_var_decl_info_by_node[node_id]["is_series"] = is_series
+            # Every initialized callable ``var`` declaration must run at its
+            # exact statement.  Nested declarations may be unreached, while a
+            # direct declaration can depend on ordinary statements immediately
+            # before it; a function-entry preamble violates both Pine rules.
+            # Exact-node once flags also preserve independent call-site clones.
+            # A bare UDT/drawing ``na`` already has the correct default member
+            # state and needs no assignment guard.
+            callable_decl_site = (
+                is_callable_scoped
+                and stmt.value is not None
+                and not (
+                    stmt_spec is not None
+                    and stmt_spec.kind == "udt"
+                    and self._is_na_expr(stmt.value)
+                )
+            )
+            nullable_collection_selection_decl_site = (
+                stmt_spec is not None
+                and stmt_spec.kind in {"map", "matrix"}
+                and isinstance(stmt.value, (IfStmt, SwitchStmt))
+            )
+            established_decl_site = (
+                (not is_callable_scoped or drawing_cpp is not None)
+                and (
+                    nullable_collection_selection_decl_site
+                    or self._is_runtime_scalar_var_initializer(
+                        member_name, ptype, init_str, stmt.value, drawing_cpp,
+                        is_series
+                    )
+                )
+            )
+            if not callable_decl_site and not established_decl_site:
+                continue
+
+            base_flag = f"_pf_var_init_{self._safe_name(member_name)}"
+            flag = allocate_flag(base_flag)
+            self._runtime_scalar_var_init_members.add(member_name)
+            info = {
+                "member_name": member_name,
+                "node_id": node_id,
+                "owner": owners_by_node.get(node_id),
+                "is_callable_scoped": is_callable_scoped,
+                "ptype": ptype,
+                "flag": flag,
+                "drawing_cpp": drawing_cpp,
+                "type_spec": stmt_spec,
+                "is_series": is_series,
+            }
+            self._runtime_scalar_var_init_by_node[node_id] = info
+            base_storage = self._safe_name(member_name)
+            self._runtime_var_init_flags[(node_id, base_storage)] = flag
+            if is_callable_scoped:
+                owner = owners_by_node.get(node_id)
+                for (remap_owner, _cs_idx), remap in self._func_cs_var_remap.items():
+                    if remap_owner != owner or base_storage not in remap:
+                        continue
+                    storage = remap[base_storage]
+                    if storage == base_storage:
+                        continue
+                    clone_base = f"_pf_var_init_{storage}"
+                    clone_flag = allocate_flag(clone_base)
+                    self._runtime_var_init_flags[(node_id, storage)] = clone_flag
+                for inst in self._fresh_instances:
+                    if inst.get("fname") != owner:
+                        continue
+                    storage = inst.get("var_remap", {}).get(
+                        base_storage, base_storage
+                    )
+                    key = (node_id, storage)
+                    if key in self._runtime_var_init_flags:
+                        continue
+                    fresh_base = f"_pf_var_init_{storage}"
+                    self._runtime_var_init_flags[key] = allocate_flag(
+                        fresh_base
+                    )
+            if not is_callable_scoped:
+                self._runtime_scalar_var_init_by_member[member_name] = info
+
+        self._runtime_var_init_flag_used_names = used_names
+
+        # Top-level non-persistent drawing declarations are not represented in
+        # var-member metadata.  Record their exact source declaration type so
+        # functions can resolve globals without consulting the analyzer's
+        # legacy raw-name UDT registry (which later locals may overwrite).
+        for stmt in self.ctx.ast.body:
+            if not isinstance(stmt, VarDecl) or stmt.is_var or stmt.is_varip:
+                continue
+            spec = (
+                self._type_spec_from_hint_name(stmt.type_hint)
+                if stmt.type_hint
+                else self._type_spec_from_expr(stmt.value)
+            )
+            if (spec is not None and spec.kind == "udt"
+                    and spec.name in DRAWING_TYPE_TO_CPP):
+                self._global_drawing_cpp_types[stmt.name] = (
+                    DRAWING_TYPE_TO_CPP[spec.name]
+                )
+
     # ------------------------------------------------------------------
     # Context-sensitive (call-path) instance machinery
     # ------------------------------------------------------------------
@@ -815,11 +1350,69 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if node is not None and getattr(node, "body", None):
                 func_bodies.setdefault(fi.name, node.body)
 
+        # Pine forbids recursive callable execution. Most scalar-only cycles
+        # never enter this state-instance pass (and some legacy dead-branch
+        # typing probes intentionally retain them), but a cycle carrying TA,
+        # var, series, fixnan, or transitive state would otherwise mint a new
+        # fresh path instance forever. Reject exactly that stateful subgraph
+        # before expanding any members or dispatch records.
+        stateful_edges: dict[str, list[tuple[str, FuncCall]]] = {
+            name: [] for name in stateful
+        }
+        inherited_names = getattr(
+            ctx, "func_inherited_call_names", {}
+        ) or {}
+        for owner, body in func_bodies.items():
+            if owner not in stateful:
+                continue
+            for callnode in self._iter_func_calls(body):
+                cs_info = ctx.func_call_cs_map.get(id(callnode))
+                callee = (
+                    cs_info[0]
+                    if cs_info is not None
+                    else inherited_names.get(id(callnode))
+                )
+                if callee in stateful:
+                    stateful_edges[owner].append((callee, callnode))
+
+        colors: dict[str, int] = {}
+        stack: list[str] = []
+
+        def reject_stateful_cycle(name: str) -> None:
+            colors[name] = 1
+            stack.append(name)
+            for callee, callnode in stateful_edges.get(name, ()):
+                color = colors.get(callee, 0)
+                if color == 1:
+                    start = stack.index(callee)
+                    cycle = [*stack[start:], callee]
+                    self._codegen_error(
+                        callnode,
+                        "Recursive stateful callable cycle is not supported: "
+                        + " -> ".join(cycle)
+                        + ".",
+                        hint=(
+                            "Remove the recursive call; Pine user-defined "
+                            "functions cannot execute recursively."
+                        ),
+                    )
+                if color == 0:
+                    reject_stateful_cycle(callee)
+            stack.pop()
+            colors[name] = 2
+
+        for name in sorted(stateful):
+            if colors.get(name, 0) == 0:
+                reject_stateful_cycle(name)
+
         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, [])]
+            return [
+                self._safe_name(self._func_var_storage_name(fname, 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())
@@ -842,6 +1435,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     worklist.append({
                         "fname": fname,
                         "name": natural_name(fname, k),
+                        "call_site_idx": 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), {}),
@@ -850,6 +1444,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 worklist.append({
                     "fname": fname,
                     "name": self._func_cpp_base_name(fname),
+                    "call_site_idx": None,
                     "ta_remap": {},
                     "var_remap": {},
                     "fixnan_remap": {},
@@ -864,12 +1459,24 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if not body:
                 continue
             active_ta = inst["ta_remap"]
+            active_var = inst.get("var_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
+                    # Natural csN parents deliberately leave inherited nested
+                    # calls unmapped so visit_call can thread N through its
+                    # active-index fallback. A fresh context-sensitive parent
+                    # has no active index; recover only that removed edge's
+                    # exact callee identity and compose it from natural cs0.
+                    if not inst.get("fresh", False):
+                        continue
+                    g_name = ctx.func_inherited_call_names.get(id(callnode))
+                    if g_name is None:
+                        continue
+                    j = 0
+                else:
+                    g_name, j = cs_info
                 if g_name not in stateful:
                     continue
                 natural_ta = self._func_cs_ta_remap.get((g_name, j), {})
@@ -877,18 +1484,56 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 for m in ta_originals(g_name):
                     mid = natural_ta.get(m, m)
                     composed_ta[m] = active_ta.get(mid, mid)
+                g_var_originals = var_originals(g_name)
+                full_natural_var = self._func_cs_var_remap.get(
+                    (g_name, j), {}
+                )
+                natural_var = {
+                    name: full_natural_var.get(name, name)
+                    for name in g_var_originals
+                }
+                composed_var = {}
+                for m in g_var_originals:
+                    mid = natural_var.get(m, m)
+                    composed_var[m] = active_var.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:
+                owns_non_ta_state = bool(
+                    g_var_originals or fixnan_originals(g_name)
+                )
+                # Every non-cs0 enclosing variant is a distinct Pine written
+                # call path. Even a pure wrapper can reach var/fixnan state
+                # farther down the graph, so preserve the path identity here
+                # and let the fresh wrapper compose its next edge in turn.
+                path_requires_fresh_state = (
+                    inst.get("fresh", False)
+                    or inst.get("call_site_idx") not in (None, 0)
+                )
+                if (
+                    not path_requires_fresh_state
+                    and composed_ta == natural_ta
+                    and composed_var == natural_var
+                    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()))
+                path_identity = (
+                    (inst["name"], id(callnode))
+                    if owns_non_ta_state or path_requires_fresh_state
+                    else None
+                )
+                key = (
+                    g_name,
+                    frozenset(composed_ta.items()),
+                    frozenset(composed_var.items()),
+                    frozenset(composed_fixnan.items()),
+                    path_identity,
+                )
                 ginst = interned.get(key)
                 if ginst is None:
                     fresh_counter += 1
@@ -897,7 +1542,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     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))
+                        self._fresh_var_members.append((g_name, 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] = {}
@@ -917,6 +1562,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     ginst = {
                         "fname": g_name,
                         "name": inst_name,
+                        "fresh": True,
+                        "call_site_idx": None,
                         "ta_remap": composed_ta,
                         "var_remap": fvar_remap,
                         "fixnan_remap": ffixnan_remap,
@@ -926,8 +1573,107 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     worklist.append(ginst)
                 self._instance_dispatch[(inst["name"], id(callnode))] = ginst["name"]
 
+    def _callable_var_collection_spec(
+            self, name: str, owner_func: str | None = None) -> TypeSpec | None:
+        """Exact TypeSpec for a function-scoped persistent collection member.
+
+        Only declaration nodes that actually became callable-scoped persistent
+        members are eligible here.  A raw-name scan of the general callable
+        inventory can otherwise turn a global scalar member into a collection
+        merely because an unrelated helper has a same-named ordinary local.
+        Clone contexts may own state reachable through another callable, so an
+        explicit owner is preferred and the owner-less fallback remains
+        deliberately limited to a single unambiguous persistent TypeSpec.
+        """
+        safe = self._safe_name(name)
+
+        candidates_by_owner: dict[str, list[TypeSpec]] = {}
+        metadata = getattr(self.ctx, "var_member_metadata_by_node", {}) or {}
+        for node_id, meta in metadata.items():
+            _node, member_name, _ptype, _init_str, is_callable_scoped = meta
+            if (not is_callable_scoped
+                    or self._safe_name(member_name) != safe):
+                continue
+            spec = self._callable_collection_bindings.get(node_id)
+            owner = self._callable_collection_binding_owners.get(node_id)
+            if (owner is None or spec is None
+                    or spec.kind not in {"array", "map", "matrix"}):
+                continue
+            owner_candidates = candidates_by_owner.setdefault(owner, [])
+            if spec not in owner_candidates:
+                owner_candidates.append(spec)
+
+        if owner_func is not None:
+            owned = candidates_by_owner.get(owner_func, [])
+            if len(owned) == 1:
+                return owned[0]
+            # The existing clone inventory deliberately unions persistent vars
+            # from reachable helpers into an enclosing function's remap.  In
+            # that case ``owner_func`` names the clone context, not the lexical
+            # declaration owner; fall through to the unambiguous owner search.
+
+        candidates: list[TypeSpec] = []
+        for owned in candidates_by_owner.values():
+            for spec in owned:
+                if spec not in candidates:
+                    candidates.append(spec)
+        return candidates[0] if len(candidates) == 1 else None
+
+    def _callable_var_udt_spec(
+            self, name: str, owner_func: str | None = None) -> TypeSpec | None:
+        """Exact UDT TypeSpec for one callable persistent member identity.
+
+        The analyzer's legacy ``_udt_var_types`` registry is keyed by raw Pine
+        spelling, so sibling declarations such as ``state`` / ``state__blk1``
+        can overwrite each other.  Declaration metadata retains both the exact
+        collision-safe member name and lexical owner; use it for base members
+        and every written-callsite clone.
+        """
+        safe = self._safe_name(name)
+        candidates_by_owner: dict[str, list[TypeSpec]] = {}
+        metadata = getattr(self.ctx, "var_member_metadata_by_node", {}) or {}
+        specs = getattr(self.ctx, "var_member_type_specs_by_node", {}) or {}
+        owners = getattr(self.ctx, "var_member_owners_by_node", {}) or {}
+        for node_id, meta in metadata.items():
+            _node, member_name, _ptype, _init_str, is_callable_scoped = meta
+            if (not is_callable_scoped
+                    or self._safe_name(member_name) != safe):
+                continue
+            spec = specs.get(node_id)
+            owner = owners.get(node_id)
+            if (owner is None or spec is None
+                    or spec.kind != "udt"
+                    or spec.name not in self._udt_defs):
+                continue
+            owner_candidates = candidates_by_owner.setdefault(owner, [])
+            if spec not in owner_candidates:
+                owner_candidates.append(spec)
+
+        if owner_func is not None:
+            owned = candidates_by_owner.get(owner_func, [])
+            if len(owned) == 1:
+                return owned[0]
+
+        candidates: list[TypeSpec] = []
+        for owned in candidates_by_owner.values():
+            for spec in owned:
+                if spec not in candidates:
+                    candidates.append(spec)
+        return candidates[0] if len(candidates) == 1 else None
+
+    def _member_udt_type(self, name: str) -> str | None:
+        """Exact UDT type for class-member storage, with global tombstones."""
+        global_types = getattr(self, "_global_udt_types", {})
+        if name in global_types:
+            return global_types[name]
+        member_types = getattr(self, "_member_udt_types", {})
+        if name in member_types:
+            return member_types[name]
+        return self._udt_var_types.get(name)
+
     def _emit_cloned_var_decl(self, orig_safe: str, cloned_safe: str,
-                              series_suffix: str, lines: list[str]) -> None:
+                              series_suffix: str, lines: list[str],
+                              owner_func: str | None = None) -> 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
@@ -935,22 +1681,59 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         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:
+                if cpp_type == "int" and self._is_int64_builtin_init(vname):
+                    cpp_type = "int64_t"
+                collection_spec = self._callable_var_collection_spec(
+                    vname, owner_func
+                )
+                udt_spec = self._callable_var_udt_spec(vname, owner_func)
+                member_udt_type = self._member_udt_type(vname)
+                drawing_cpp = self._drawing_var_member_cpp_types.get(vname)
+                if (drawing_cpp is not None
+                        and orig_safe in self._series_var_member_names):
+                    lines.append(
+                        f"    Series<{drawing_cpp}> {cloned_safe}{series_suffix};"
+                    )
+                elif (orig_safe in self._series_var_member_names
+                        or vname in self.ctx.series_vars):
                     lines.append(f"    Series<{cpp_type}> {cloned_safe}{series_suffix};")
+                elif collection_spec is not None:
+                    lines.append(
+                        f"    {self._type_spec_to_cpp(collection_spec)} {cloned_safe};"
+                    )
                 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:
+                elif drawing_cpp is not None:
+                    lines.append(
+                        f"    {drawing_cpp} {cloned_safe} = {drawing_cpp}{{}};"
+                    )
+                elif udt_spec is not None or member_udt_type is not None:
                     # 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]
+                    udt_t = (
+                        udt_spec.name
+                        if udt_spec is not None
+                        else member_udt_type
+                    )
                     handle_cpp = DRAWING_TYPE_TO_CPP.get(udt_t, udt_t)
                     lines.append(f"    {handle_cpp} {cloned_safe} = {handle_cpp}{{}};")
+                elif vname in self._runtime_scalar_var_init_members:
+                    # Declaration-site state may remain unreached while COOF
+                    # snapshots value-copy every clone. Match the base member's
+                    # typed Pine-na default instead of leaving primitive clone
+                    # storage indeterminate (or giving it a legacy zero).
+                    pending = self._typed_na_init(
+                        "na<double>()", vname, ptype
+                    )
+                    lines.append(
+                        f"    {cpp_type} {cloned_safe} = {pending};"
+                    )
                 else:
                     lines.append(f"    {cpp_type} {cloned_safe};")
                 return
@@ -961,6 +1744,52 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         else:
             lines.append(f"    double {cloned_safe} = 0.0;")
 
+    def _binding_is_series(
+        self,
+        raw_name: str,
+        resolved_safe_name: str | None = None,
+    ) -> bool:
+        """Resolve Series-ness without conflating renamed persistent siblings.
+
+        ``ctx.series_vars`` is a legacy raw-name union.  When a persistent
+        member identity is known, its exact membership wins; otherwise keep the
+        established raw-name behavior for ordinary non-var series, bar
+        builtins, and parameters.  A call-site clone resolves to ``h_cs1`` but
+        inherits the base member ``h`` status, while a sibling rename such as
+        ``x__blk1`` is itself an exact member and therefore wins directly.
+        """
+        base_safe = self._safe_name(raw_name)
+        resolved = resolved_safe_name or base_safe
+        if raw_name in self._lexical_series_bindings:
+            return self._lexical_series_bindings[raw_name]
+        if resolved in self._persistent_var_member_names:
+            return resolved in self._series_var_member_names
+        if (raw_name in self._qualified_func_var_raw_names
+                and raw_name in self._ordinary_global_binding_names):
+            return raw_name in self._ordinary_global_series_names
+        if base_safe in self._persistent_var_member_names:
+            return base_safe in self._series_var_member_names
+        return raw_name in self.ctx.series_vars
+
+    def _known_var_is_lexically_shadowed(self, name: str) -> bool:
+        """Whether a local/parameter/loop binder hides a known global name."""
+        return name in self._lexical_known_var_tombstones
+
+    def _decl_binding_is_series(self, node_id: int, raw_name: str) -> bool:
+        """Return exact history status for one declaration binding.
+
+        A VarDecl has one name, but a TupleAssign node owns several names.  The
+        node-only legacy set therefore cannot distinguish ``[x, y]`` when only
+        one element is history-referenced.  Prefer the exact analyzer key and
+        retain the node-only fallback for older/manually-built contexts.
+        """
+        exact = getattr(self.ctx, "series_decl_bindings", set()) or set()
+        if (node_id, raw_name) in exact:
+            return True
+        if any(binding_node == node_id for binding_node, _ in exact):
+            return False
+        return node_id in getattr(self.ctx, "series_decl_nodes", set())
+
     @staticmethod
     def _int_literal_value(node: ASTNode | None) -> int | None:
         """Return the integer value of a (possibly unary-minus) NumberLiteral,
@@ -1018,6 +1847,29 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         ``global_expr_map``; without registering it here, ``m`` was emitted as a scalar
         while ``on_bar`` still assigned ``PineMatrix``.
         """
+        # A typed ``matrix<T> m = na`` or an inferred nullable selection has no
+        # constructor call for the legacy RHS scan below to recognize. Resolve
+        # declarations in source order from the authored hint/RHS, not from
+        # ``ctx.collection_types``: that raw-name table describes the analyzer's
+        # final state and can already contain an invalid later reassignment's
+        # element type. The original declaration must remain the compatibility
+        # baseline used to reject matrix<int> := matrix<float>.
+        for stmt, _in_loop in self._walk_global_scope_with_loopflag(
+            getattr(self.ctx.ast, "body", []), False
+        ):
+            if not isinstance(stmt, VarDecl):
+                continue
+            if stmt.type_hint:
+                declared_spec = self._type_spec_from_hint_name(stmt.type_hint)
+            elif isinstance(stmt.value, (Ternary, IfStmt, SwitchStmt)):
+                declared_spec = self._type_spec_from_expr(stmt.value)
+            else:
+                continue
+            if declared_spec is None or declared_spec.kind != "matrix":
+                continue
+            self._matrix_specs.setdefault(stmt.name, declared_spec)
+            self._collection_types[stmt.name] = self._matrix_specs[stmt.name]
+
         gem = getattr(self.ctx, "global_expr_map", {}) or {}
         for name, _ptype in self.ctx.global_var_decls:
             expr = gem.get(name)
@@ -1099,7 +1951,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         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):
+            if isinstance(s, (FuncDef, MethodDef)):
                 continue
             yield s, in_loop
             child_in_loop = in_loop or isinstance(s, (ForStmt, ForInStmt, WhileStmt))
@@ -1113,47 +1965,6 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     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, ...).
 
@@ -1216,8 +2027,70 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             else:
                 self._codegen_error(node, "matrix.sort requires int, bool, string, or float element type; UDT matrices cannot be sorted")
 
+    def _iter_declared_matrix_specs(self):
+        """Yield matrix TypeSpecs reachable from declared source types.
+
+        A typed ``matrix<T> x = na`` has no matrix call for a syntactic scan
+        to find. Matrix types can also be nested in UDT fields or appear only
+        at a callable boundary, so include selection must start from analyzer
+        metadata and recurse through aggregate types.
+        """
+        roots = list(self._collection_types.values())
+        roots.extend(
+            spec
+            for specs in self._func_collection_types.values()
+            for spec in specs.values()
+        )
+        roots.extend(
+            spec
+            for specs in self._block_collection_types.values()
+            for spec in specs.values()
+            if spec is not None
+        )
+        roots.extend(
+            spec
+            for fields in self._udt_field_type_specs.values()
+            for spec in fields.values()
+        )
+        for fi in self.ctx.func_infos:
+            roots.extend(
+                spec
+                for spec in (getattr(fi, "param_type_specs", []) or [])
+                if spec is not None
+            )
+            return_spec = getattr(fi, "return_type_spec", None)
+            if return_spec is not None:
+                roots.append(return_spec)
+
+        def walk(spec: TypeSpec | None, visiting_udts: frozenset[str]):
+            if spec is None:
+                return
+            if spec.kind == "matrix":
+                yield spec
+                return
+            if spec.kind == "array":
+                yield from walk(spec.element, visiting_udts)
+                return
+            if spec.kind == "map":
+                yield from walk(spec.key, visiting_udts)
+                yield from walk(spec.value, visiting_udts)
+                return
+            if spec.kind == "udt" and spec.name:
+                if spec.name in visiting_udts:
+                    return
+                nested_visiting = visiting_udts | {spec.name}
+                for field_spec in self._udt_field_type_specs.get(
+                    spec.name, {}
+                ).values():
+                    yield from walk(field_spec, nested_visiting)
+
+        for root in roots:
+            yield from walk(root, frozenset())
+
     def _detect_matrix_usage(self) -> bool:
-        """True if emitted C++ will need runtime/matrix.hpp (PineMatrix)."""
+        """True if emitted C++ will need a matrix runtime header."""
+        if next(self._iter_declared_matrix_specs(), None) is not None:
+            return True
         for _, _, init_str in self.ctx.var_members:
             if init_str and "matrix.new" in str(init_str):
                 return True
@@ -1228,6 +2101,90 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     return True
         return False
 
+    def _detect_generic_matrix_usage(self) -> bool:
+        """True if emitted C++ mentions a non-float matrix specialization."""
+        float_spec = TypeSpec.primitive("float")
+        if any(
+            spec.element != float_spec
+            for spec in self._iter_declared_matrix_specs()
+        ):
+            return True
+
+        # A standalone matrix.new<T>() expression may have no declaration
+        # TypeSpec. Read its explicit template argument directly so the
+        # generated call still receives the generic runtime declaration.
+        for node in self._walk_ast(self.ctx.ast):
+            if not isinstance(node, FuncCall):
+                continue
+            fn, ns = self._resolve_callee(node.callee)
+            if ns != "matrix" or fn != "new":
+                continue
+            targs = self._template_args_from_call(node)
+            if not targs:
+                continue
+            elem_spec = self._type_spec_from_hint_name(targs[0])
+            if elem_spec is not None and elem_spec != float_spec:
+                return True
+        return False
+
+    def _detect_map_usage(self) -> bool:
+        """True when emitted C++ needs the PineMap handle/runtime helpers.
+
+        The call scan catches constructors and built-in operations. TypeSpec
+        scans additionally catch typed ``na`` maps and map fields that never
+        execute a map call, so their declarations still receive map.hpp and
+        map-aware COOF checkpoint support.
+        """
+        def contains_map(
+            spec: TypeSpec | None, visiting_udts: frozenset[str] = frozenset()
+        ) -> bool:
+            if spec is None:
+                return False
+            if spec.kind == "map":
+                return True
+            if spec.kind in {"array", "matrix"}:
+                return contains_map(spec.element, visiting_udts)
+            if spec.kind == "udt" and spec.name:
+                if spec.name in visiting_udts:
+                    return False
+                nested_visiting = visiting_udts | {spec.name}
+                return any(
+                    contains_map(field_spec, nested_visiting)
+                    for field_spec in self._udt_field_type_specs.get(
+                        spec.name, {}
+                    ).values()
+                )
+            return False
+
+        if self._map_vars:
+            return True
+        if any(contains_map(spec) for spec in self._collection_types.values()):
+            return True
+        if any(
+            contains_map(spec)
+            for fields in self._udt_field_type_specs.values()
+            for spec in fields.values()
+        ):
+            return True
+        for specs in self._func_collection_types.values():
+            if any(contains_map(spec) for spec in specs.values()):
+                return True
+        for fi in self._func_info_map.values():
+            if any(contains_map(spec) for spec in fi.param_type_specs):
+                return True
+            if contains_map(getattr(fi, "return_type_spec", None)):
+                return True
+        for node in self._walk_ast(self.ctx.ast):
+            if isinstance(node, FuncCall):
+                _fn, namespace = self._resolve_callee(node.callee)
+                if namespace == "map":
+                    return True
+            if isinstance(node, VarDecl):
+                spec = self._type_spec_from_hint_name(node.type_hint)
+                if contains_map(spec):
+                    return True
+        return False
+
     # The type-inference helpers (_type_spec_*, _infer_type, _array_method_expr,
     # _map_method_expr, _template_args_from_call, ...) live on TypeInferer
     # — see codegen/types.py.
@@ -1262,6 +2219,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # First, find all variables that are reassigned anywhere in the AST.
         # These cannot be inlined as constants since their value changes at runtime.
         reassigned = self._find_reassigned_vars()
+        # Register never-reassigned ``var``/``varip`` scalars with a stable
+        # init FIRST — a later derived var (or a UDF body) may reference such a
+        # scalar as a stable length component, so it must be classified stable
+        # before those exprs are evaluated below.
+        self._collect_stable_var_scalars(reassigned)
         for stmt in self.ctx.ast.body:
             if isinstance(stmt, VarDecl) and stmt.name not in reassigned:
                 self._collect_known_var(stmt)
@@ -1274,6 +2236,262 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # dependent reassignments are left untracked (rejected by the guard).
         self._collect_reassigned_stable_scalars(reassigned)
 
+    def _collect_stable_var_scalars(self, reassigned: set[str]) -> None:
+        """Track top-level ``var``/``varip`` scalars declared exactly once (never
+        reassigned) from a stable init expression.
+
+        A ``var`` scalar's one-shot initializer runs once and the value never
+        changes across bars, so a never-reassigned ``var`` over a stable init
+        (``var int _tfSec = timeframe.in_seconds()``) is a bar-invariant scalar —
+        safe to embed in a TA ctor runtime-reset expression. Recording it in
+        ``_derived_input_expr`` + ``_stable_runtime_vars`` lets the reset path
+        expand the name and lets ``_expr_is_stable`` classify it (the
+        ``_stable_runtime_vars`` check precedes the ``_var_names`` rejection).
+
+        A ``var`` that is reassigned anywhere (``:=`` in ``reassigned``), is a
+        series var, or is initialized from a non-stable value stays untracked —
+        so a TA length fed by genuinely-mutable persistent state is still
+        rejected by the constructor guard. Names are NOT folded into
+        ``_known_vars`` (no use-site inlining): only the length-analysis path is
+        affected, and the ``var`` member still emits and initializes normally.
+        """
+        literal_candidates = self._admitted_stable_var_ctor_literals(reassigned)
+
+        for stmt in (self.ctx.ast.body or []):
+            if not isinstance(stmt, VarDecl):
+                continue
+            if not (stmt.is_var or stmt.is_varip):
+                continue
+            literal_record = literal_candidates.get(stmt.name)
+            if stmt.name in reassigned:
+                continue
+            if self._decl_binding_is_series(id(stmt), stmt.name):
+                continue
+            if stmt.value is None or not self._expr_is_stable(stmt.value):
+                continue
+            expr_str = self._arith_expr_to_str(stmt.value)
+            if expr_str is None:
+                continue
+            self._derived_input_expr[stmt.name] = expr_str
+            self._stable_runtime_vars.add(stmt.name)
+            if literal_record is not None:
+                self._stable_var_ctor_literals[stmt.name] = literal_record
+            # Mark input-backed iff the init references an input, so the reset
+            # emits override-aware get_input_*() reads for it.
+            import re as _re
+            toks = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", expr_str))
+            if any(t in self._input_backed_vars for t in toks):
+                self._input_backed_vars.add(stmt.name)
+
+    @staticmethod
+    def _is_direct_int_var_literal(node) -> bool:
+        """Whether ``node`` is the one literal persistent shape we admit."""
+
+        return (
+            isinstance(node, VarDecl)
+            and node.is_var
+            and not node.is_varip
+            and node.type_hint in (None, "int")
+            and isinstance(node.value, NumberLiteral)
+            and isinstance(node.value.value, int)
+            and not isinstance(node.value.value, bool)
+        )
+
+    @staticmethod
+    def _walk_candidate_surface(root):
+        """Yield every AST node reachable through compiler-owned metadata.
+
+        The regular codegen walker intentionally follows only historically
+        emitted statement/expression slots.  Literal admission is a safety
+        proof and therefore needs the larger authored surface: loop bounds and
+        iterables, enum/type defaults, function/method parameter defaults kept
+        in ``annotations``, and any future AST-bearing metadata.  ``vars()``
+        plus identity de-duplication is both exhaustive and cycle-safe.
+        """
+
+        seen: set[int] = set()
+
+        def walk(value):
+            if value is None or isinstance(
+                value, (str, bytes, int, float, bool)
+            ):
+                return
+            value_id = id(value)
+            if value_id in seen:
+                return
+            seen.add(value_id)
+
+            if isinstance(value, ASTNode):
+                yield value
+            if isinstance(value, dict):
+                for key, child in value.items():
+                    yield from walk(key)
+                    yield from walk(child)
+                return
+            if isinstance(value, (list, tuple, set, frozenset)):
+                for child in value:
+                    yield from walk(child)
+                return
+            if hasattr(value, "__dict__"):
+                for child in vars(value).values():
+                    yield from walk(child)
+
+        yield from walk(root)
+
+    def _stable_var_literal_has_earlier_use(
+        self,
+        name: str,
+        declaration_index: int,
+    ) -> bool:
+        """Whether authored code reads ``name`` before its global declaration."""
+
+        for root in (self.ctx.ast.body or [])[:declaration_index]:
+            if any(
+                isinstance(node, Identifier) and node.name == name
+                for node in self._walk_candidate_surface(root)
+            ):
+                return True
+        return False
+
+    def _candidate_surface_mentions_name(self, root, name: str) -> bool:
+        return any(
+            isinstance(node, Identifier) and node.name == name
+            for node in self._walk_candidate_surface(root)
+        )
+
+    def _stable_var_literal_has_unsupported_declaration(self) -> bool:
+        """Whether authored metadata would require cross-boundary dataflow.
+
+        Stable-var constructor folding is deliberately declaration-local.  A
+        user function, method, type, or enum introduces defaults, aliases, or
+        receiver effects that require a wider proof, so this narrow feature
+        fails closed for the whole script instead of approximating that proof.
+        """
+
+        return any(
+            isinstance(node, (FuncDef, MethodDef, TypeDecl, EnumDecl))
+            for node in self._walk_candidate_surface(self.ctx.ast)
+        )
+
+    def _stable_var_literal_has_parse_recovery(self) -> bool:
+        """Whether the parser discarded any authored source fragment.
+
+        Recovery intentionally keeps broad corpus transpilation moving, but a
+        discarded declaration can hide aliases or override a builtin method.
+        Literal admission therefore requires a lossless parse even though all
+        existing non-admission codegen paths retain their recovery behavior.
+        """
+
+        return bool(
+            (self.ctx.ast.annotations or {}).get("parse_recovery_count", 0)
+        )
+
+    def _stable_var_literal_has_unsupported_receiver_use(
+        self,
+        name: str,
+    ) -> bool:
+        """Catch primitive extension-method syntax dropped by the parser."""
+
+        roots: list[object] = [self.ctx.ast]
+        roots.extend(
+            pragma.expr_node
+            for pragma in (getattr(self.ctx, "pf_trace_pragmas", None) or [])
+            if getattr(pragma, "expr_node", None) is not None
+        )
+        for root in roots:
+            for node in self._walk_candidate_surface(root):
+                if (
+                    isinstance(node, FuncCall)
+                    and isinstance(node.callee, MemberAccess)
+                    and self._candidate_surface_mentions_name(
+                        node.callee.object, name
+                    )
+                ):
+                    return True
+        return False
+
+    def _stable_var_literal_has_history_use(self, name: str) -> bool:
+        """Whether any authored or post-analyzer expression histories ``name``."""
+
+        roots: list[object] = [self.ctx.ast]
+        roots.extend(
+            pragma.expr_node
+            for pragma in (getattr(self.ctx, "pf_trace_pragmas", None) or [])
+            if getattr(pragma, "expr_node", None) is not None
+        )
+        for root in roots:
+            for node in self._walk_candidate_surface(root):
+                if not isinstance(node, Subscript):
+                    continue
+                if any(
+                    isinstance(receiver_node, Identifier)
+                    and receiver_node.name == name
+                    for receiver_node in self._walk_candidate_surface(
+                        node.object
+                    )
+                ):
+                    return True
+        return False
+
+    def _admitted_stable_var_ctor_literals(
+        self,
+        reassigned: set[str],
+    ) -> dict[str, _StableVarCtorLiteral]:
+        """Return declaration-exact persistent literals safe for TA sizing."""
+
+        occurrences: dict[str, list[tuple[int, VarDecl]]] = {}
+        for index, stmt in enumerate(self.ctx.ast.body or []):
+            if self._is_direct_int_var_literal(stmt):
+                occurrences.setdefault(stmt.name, []).append((index, stmt))
+
+        unique = {
+            name: items[0]
+            for name, items in occurrences.items()
+            if len(items) == 1
+        }
+        if not unique:
+            return {}
+
+        candidate_names = set(unique)
+        binding_counts = {name: 0 for name in candidate_names}
+        for node in self._walk_candidate_surface(self.ctx.ast):
+            names: list[str] = []
+            if isinstance(node, VarDecl) and node.name:
+                names.append(node.name)
+            elif isinstance(node, TupleAssign):
+                names.extend(name for name in node.names if name != "_")
+            elif isinstance(node, ForStmt) and node.var:
+                names.append(node.var)
+            elif isinstance(node, ForInStmt):
+                if node.var:
+                    names.append(node.var)
+                names.extend(name for name in (node.vars or []) if name != "_")
+            if isinstance(node, (FuncDef, MethodDef)):
+                names.extend(name for name in node.params if name != "_")
+            for bound_name in names:
+                if bound_name in binding_counts:
+                    binding_counts[bound_name] += 1
+
+        admitted: dict[str, _StableVarCtorLiteral] = {}
+        for name, (index, declaration) in unique.items():
+            if (
+                name in reassigned
+                or binding_counts.get(name) != 1
+                or self._decl_binding_is_series(id(declaration), name)
+                or self._stable_var_literal_has_earlier_use(name, index)
+                or self._stable_var_literal_has_history_use(name)
+                or self._stable_var_literal_has_unsupported_declaration()
+                or self._stable_var_literal_has_parse_recovery()
+                or self._stable_var_literal_has_unsupported_receiver_use(name)
+            ):
+                continue
+            admitted[name] = _StableVarCtorLiteral(
+                value=declaration.value.value,
+                declaration_id=id(declaration),
+                top_level_index=index,
+            )
+        return admitted
+
     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``).
@@ -1438,7 +2656,117 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         "ismonthly", "isdwm", "isseconds", "in_seconds", "isticks",
     })
 
-    def _expr_is_stable(self, node) -> bool:
+    # Depth ceiling for inlining nested single-expression user functions while
+    # classifying a TA length's stability. Pine forbids recursion, so any real
+    # chain is shallow; the cap is a backstop against pathological input and is
+    # enforced together with a name-stack cycle guard.
+    _UDF_INLINE_MAX_DEPTH = 16
+
+    def _get_udf_def(self, name: str):
+        """Return the top-level single-name ``FuncDef`` for ``name`` (or None).
+
+        Built lazily and cached. UDT ``MethodDef``s are intentionally excluded —
+        only a free function can appear as a bare-name TA length call.
+        """
+        cache = getattr(self, "_udf_def_cache", None)
+        if cache is None:
+            cache = {}
+            for stmt in (self.ctx.ast.body or []):
+                if isinstance(stmt, FuncDef):
+                    # Last definition wins; a name map is all the length path needs.
+                    cache[stmt.name] = stmt
+            self._udf_def_cache = cache
+        return cache.get(name)
+
+    def _inline_single_expr_udf(self, node, _udf_stack: frozenset = frozenset(),
+                                _depth: int = 0):
+        """If ``node`` is a call to a user-defined SINGLE-EXPRESSION function,
+        return its body expression with each parameter substituted by the
+        corresponding call-argument node. Returns None when the call is not such
+        a function, the arity/kwargs do not match, the body is not a single
+        expression, the body contains a shape we do not clone, or the call would
+        recurse (cycle / depth-limit).
+
+        Purely structural: it does NOT judge stability (the caller does, via
+        ``_expr_is_stable`` on the returned node). The conservative None keeps
+        the TA-ctor guard intact.
+        """
+        if not isinstance(node, FuncCall):
+            return None
+        func_name, namespace = self._resolve_callee(node.callee)
+        if namespace is not None or func_name is None:
+            return None
+        if func_name in _udf_stack or _depth >= self._UDF_INLINE_MAX_DEPTH:
+            return None
+        fdef = self._get_udf_def(func_name)
+        if fdef is None:
+            return None
+        # A body that is exactly ONE expression statement is inlinable, whether
+        # written inline after ``=>`` (``is_single_expr=True``) or as a one-line
+        # indented block (``f(x) =>`` then a single indented expr, which the
+        # parser records as ``is_single_expr=False`` with a one-ExprStmt body —
+        # the gonzowiththewind-sisyphus ``f_bars`` shape). A multi-statement
+        # body (len != 1, or a non-ExprStmt) is conservatively refused.
+        body = fdef.body
+        if not body or len(body) != 1 or not isinstance(body[0], ExprStmt):
+            return None
+        # Require a plain positional call: one arg per param, no kwargs, no
+        # default-parameter fill-in — anything else is conservatively refused.
+        if node.kwargs or len(node.args) != len(fdef.params):
+            return None
+        subst = dict(zip(fdef.params, node.args))
+        return self._subst_params(body[0].expr, subst)
+
+    def _subst_params(self, node, subst: dict):
+        """Return a copy of ``node`` with every ``Identifier`` whose name is a
+        key in ``subst`` replaced by the mapped argument node. Returns None for
+        any node outside the small arithmetic/call grammar we fold (an
+        unrecognised construct — e.g. a history ``Subscript`` — conservatively
+        aborts the inline). ``dataclasses.replace`` preserves ``loc``/
+        ``annotations`` so diagnostics still point at real source spans."""
+        import dataclasses as _dc
+        if isinstance(node, (NumberLiteral, StringLiteral, BoolLiteral, NaLiteral)):
+            return node
+        if isinstance(node, Identifier):
+            return subst.get(node.name, node)
+        if isinstance(node, MemberAccess):
+            obj = self._subst_params(node.object, subst)
+            if obj is None:
+                return None
+            return _dc.replace(node, object=obj)
+        if isinstance(node, Ternary):
+            c = self._subst_params(node.condition, subst)
+            t = self._subst_params(node.true_val, subst)
+            f = self._subst_params(node.false_val, subst)
+            if c is None or t is None or f is None:
+                return None
+            return _dc.replace(node, condition=c, true_val=t, false_val=f)
+        if isinstance(node, BinOp):
+            l = self._subst_params(node.left, subst)
+            r = self._subst_params(node.right, subst)
+            if l is None or r is None:
+                return None
+            return _dc.replace(node, left=l, right=r)
+        if isinstance(node, UnaryOp):
+            o = self._subst_params(node.operand, subst)
+            if o is None:
+                return None
+            return _dc.replace(node, operand=o)
+        if isinstance(node, FuncCall):
+            if node.kwargs:
+                return None
+            new_args = []
+            for a in node.args:
+                sa = self._subst_params(a, subst)
+                if sa is None:
+                    return None
+                new_args.append(sa)
+            return _dc.replace(node, args=new_args)
+        # Subscript (history read) and anything else: not a stable-length shape.
+        return None
+
+    def _expr_is_stable(self, node, _udf_stack: frozenset = frozenset(),
+                        _depth: int = 0) -> bool:
         """True iff ``node``'s value is a bar-invariant scalar.
 
         A stable expression depends only on: literals, ``input.*`` values,
@@ -1462,7 +2790,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             return True
         if isinstance(node, Identifier):
             name = node.name
-            if name in self._known_vars:
+            if self._known_var_is_lexically_shadowed(name):
+                return False
+            if (name in self._known_vars
+                    and not self._known_var_is_lexically_shadowed(name)):
                 return True
             if name in self._stable_runtime_vars:
                 return True
@@ -1496,13 +2827,14 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # 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))
+            return (self._expr_is_stable(node.condition, _udf_stack, _depth)
+                    and self._expr_is_stable(node.true_val, _udf_stack, _depth)
+                    and self._expr_is_stable(node.false_val, _udf_stack, _depth))
         if isinstance(node, BinOp):
-            return self._expr_is_stable(node.left) and self._expr_is_stable(node.right)
+            return (self._expr_is_stable(node.left, _udf_stack, _depth)
+                    and self._expr_is_stable(node.right, _udf_stack, _depth))
         if isinstance(node, UnaryOp):
-            return self._expr_is_stable(node.operand)
+            return self._expr_is_stable(node.operand, _udf_stack, _depth)
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
             if namespace == "ta":
@@ -1510,20 +2842,40 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             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)
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
             if namespace == "timeframe":
                 # ``timeframe.in_seconds()`` (and any other function-form
                 # timeframe member) is a stable per-run scalar — it reflects
                 # the script's resolution, not a per-bar value.
                 if func_name not in self._TF_STABLE_MEMBERS:
                     return False
-                return all(self._expr_is_stable(a) for a in node.args)
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
             if namespace == "input":
                 return True
             if namespace is None and func_name in ("int", "float", "bool", "string"):
-                return all(self._expr_is_stable(a) for a in node.args)
-            # Any other call (user functions, str.*, array.*, ...) — series
-            # by default; the conservative answer keeps the guard honest.
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
+            # A user-defined single-expression function is stable iff every
+            # argument is stable AND its body (with the params bound to those
+            # args) is stable — i.e. the body references only stable scalars
+            # (inputs / consts / timeframe.* / math.* / never-reassigned var
+            # scalars) and no series / strategy state / ta.* results. Inlining
+            # the body (params substituted by the arg nodes) lets the ordinary
+            # classifier decide; the name-stack + depth guard refuses recursion
+            # so a cyclic / malformed UDF is rejected, not looped forever.
+            if namespace is None and func_name is not None:
+                inlined = self._inline_single_expr_udf(node, _udf_stack, _depth)
+                if inlined is not None:
+                    if not all(self._expr_is_stable(a, _udf_stack, _depth)
+                               for a in node.args):
+                        return False
+                    return self._expr_is_stable(
+                        inlined, _udf_stack | {func_name}, _depth + 1)
+            # Any other call (multi-statement user functions, str.*, array.*,
+            # ...) — series by default; the conservative answer keeps the guard
+            # honest.
             return False
         return False
 
@@ -1536,22 +2888,28 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     # re-parsed and lowered through the expression visitor).
     _ATOMIC_ARITH_NODES = (NumberLiteral, Identifier, MemberAccess, FuncCall)
 
-    def _arith_operand_to_str(self, node) -> str | None:
+    def _arith_operand_to_str(self, node, _udf_stack: frozenset = frozenset(),
+                              _depth: int = 0) -> str | None:
         """Serialize ``node`` for use as an operand: parenthesize it unless its
         serialized form is already self-delimiting, so grouping survives a
         round-trip through the parser."""
-        s = self._arith_expr_to_str(node)
+        s = self._arith_expr_to_str(node, _udf_stack, _depth)
         if s is None:
             return None
         if isinstance(node, self._ATOMIC_ARITH_NODES):
             return s
         return f"({s})"
 
-    def _arith_expr_to_str(self, node) -> str | None:
+    def _arith_expr_to_str(self, node, _udf_stack: frozenset = frozenset(),
+                           _depth: int = 0) -> str | None:
         """Render a numeric arithmetic-over-identifiers expression to a string
         that re-parses to the SAME tree (grouping preserved via
         ``_arith_operand_to_str``). Returns None for any node shape we don't
         fold (series subscripts, etc.) so the caller leaves the var untracked.
+
+        ``_udf_stack``/``_depth`` guard the single-expression-UDF inlining below
+        against recursion cycles (Pine forbids recursion, but a malformed source
+        must be refused, not looped forever).
         """
         if isinstance(node, NumberLiteral):
             v = node.value
@@ -1563,30 +2921,44 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
             return f"{node.object.name}.{node.member}"
         if isinstance(node, BinOp):
-            l = self._arith_operand_to_str(node.left)
-            r = self._arith_operand_to_str(node.right)
+            l = self._arith_operand_to_str(node.left, _udf_stack, _depth)
+            r = self._arith_operand_to_str(node.right, _udf_stack, _depth)
             if l is None or r is None:
                 return None
             return f"{l} {node.op} {r}"
         if isinstance(node, UnaryOp):
-            o = self._arith_operand_to_str(node.operand)
+            o = self._arith_operand_to_str(node.operand, _udf_stack, _depth)
             if o is None:
                 return None
             return f"{node.op}{o}"
         if isinstance(node, Ternary):
-            c = self._arith_operand_to_str(node.condition)
-            t = self._arith_operand_to_str(node.true_val)
-            f = self._arith_operand_to_str(node.false_val)
+            c = self._arith_operand_to_str(node.condition, _udf_stack, _depth)
+            t = self._arith_operand_to_str(node.true_val, _udf_stack, _depth)
+            f = self._arith_operand_to_str(node.false_val, _udf_stack, _depth)
             if c is None or t is None or f is None:
                 return None
             return f"{c} ? {t} : {f}"
         if isinstance(node, FuncCall):
-            callee = self._arith_expr_to_str(node.callee)
+            # A bare-name call to a single-expression user function has no C++
+            # counterpart at class scope — inline its body (params substituted
+            # by the arg expressions) so the rendered string is pure
+            # math/timeframe/input arithmetic the ctor-reset path can expand.
+            # Namespaced calls (math.*/timeframe.*/int(...)) fall through to the
+            # ordinary ``callee(args)`` rendering below. The stack/depth guard
+            # refuses a recursive UDF (returns None -> caller leaves it untracked
+            # -> the ctor guard rejects it loudly) instead of recursing forever.
+            fn, ns = self._resolve_callee(node.callee)
+            if ns is None and fn is not None and self._get_udf_def(fn) is not None:
+                inlined = self._inline_single_expr_udf(node, _udf_stack, _depth)
+                if inlined is None:
+                    return None
+                return self._arith_expr_to_str(inlined, _udf_stack | {fn}, _depth + 1)
+            callee = self._arith_expr_to_str(node.callee, _udf_stack, _depth)
             if callee is None:
                 return None
             parts = []
             for a in node.args:
-                s = self._arith_expr_to_str(a)
+                s = self._arith_expr_to_str(a, _udf_stack, _depth)
                 if s is None:
                     return None
                 parts.append(s)
@@ -1596,7 +2968,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     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
-        if node.name in self.ctx.series_vars:
+        if self._decl_binding_is_series(id(node), node.name):
             return
         # Don't inline var/varip variables — they're mutable state that persists
         # across bars and can be reassigned with :=
@@ -1834,29 +3206,145 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             for child in walk_nodes(fi.node):
                 owner_by_node[id(child)] = fi.name
 
+        # ``ctx.series_vars`` is a legacy raw-name union.  A raw name can bind
+        # both an exact Series declaration and an unrelated scalar declaration
+        # (sibling blocks, or a callable local shadowing a global).  Such calls
+        # may need a synthetic history bridge even though the raw name appears
+        # in that union, so reserve the bridge up front; source-order lexical
+        # state decides whether the emitted call actually uses it.
+        binding_series_states: dict[str, set[bool]] = {}
+        var_metadata = getattr(
+            self.ctx, "var_member_metadata_by_node", {}
+        ) or {}
+        for decl in walk_nodes(self.ctx.ast):
+            if isinstance(decl, VarDecl):
+                metadata = var_metadata.get(id(decl))
+                if metadata is not None:
+                    exact_member = self._safe_name(metadata[1])
+                    is_series = exact_member in self._series_var_member_names
+                else:
+                    is_series = self._decl_binding_is_series(
+                        id(decl), decl.name
+                    )
+                binding_series_states.setdefault(decl.name, set()).add(
+                    is_series
+                )
+            elif isinstance(decl, TupleAssign):
+                for name in decl.names:
+                    if name != "_":
+                        binding_series_states.setdefault(name, set()).add(
+                            self._decl_binding_is_series(id(decl), name)
+                        )
+            elif isinstance(decl, ForStmt):
+                if decl.var:
+                    binding_series_states.setdefault(decl.var, set()).add(
+                        False
+                    )
+            elif isinstance(decl, ForInStmt):
+                loop_names = (
+                    [decl.var]
+                    if decl.var
+                    else list(decl.vars or [])
+                )
+                for name in loop_names:
+                    if name and name != "_":
+                        binding_series_states.setdefault(name, set()).add(
+                            False
+                        )
+        ambiguous_series_names = {
+            name for name, states in binding_series_states.items()
+            if len(states) > 1
+        }
+
+        def register_one(
+            kind: str,
+            source_key: tuple,
+            cpp_type: str,
+            context: str | None,
+        ) -> None:
+            if cpp_type not in ("double", "int", "int64_t", "bool"):
+                cpp_type = "double"
+            key = (kind, *source_key, context)
+            if key in self._inline_history_member_by_key:
+                return
+            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 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,
-                })
+                register_one(kind, source_key, cpp_type, context)
 
-        def actual_args_for(call: FuncCall, params: list[str]) -> list:
+        def owner_cs_for_context(
+            owner: str | None, context: str | None
+        ) -> int | None:
+            if owner is None or context is None:
+                return None
+            prefix = f"{self._func_cpp_base_name(owner)}_cs"
+            if not context.startswith(prefix):
+                return None
+            suffix = context[len(prefix):]
+            return int(suffix) if suffix.isdigit() else None
+
+        def target_cs_for_context(
+            fi,
+            call: FuncCall,
+            owner: str | None,
+            context: str | None,
+        ) -> int | None:
+            owner_cs = owner_cs_for_context(owner, context)
+            cs_info = self.ctx.func_call_cs_map.get(id(call))
+            count = self.ctx.func_call_site_counts.get(fi.name, 0)
+            if owner_cs is not None and (
+                cs_info is not None or count > 1
+            ):
+                return owner_cs
+            if cs_info is not None and cs_info[0] == fi.name:
+                return cs_info[1]
+            return None
+
+        def actual_args_for(call: FuncCall, params: list[str], method_info=None) -> list:
+            if method_info is not None:
+                return list(
+                    self._bind_typed_method_args(method_info, call).args_by_param
+                )
             if call.kwargs:
                 return _merge_kwargs(call.args, call.kwargs, params, lambda arg: arg)
             return list(call.args)
 
+        def owner_lexical_specs(owner: str | None) -> dict[str, TypeSpec | None]:
+            """Recover callable parameter types after analyzer scopes exit."""
+            if owner is None:
+                return {}
+            info = self._func_info_map.get(owner)
+            if info is None or info.node is None:
+                return {}
+            specs = list(getattr(info, "param_type_specs", ()) or ())
+            lexical = {
+                name: specs[index] if index < len(specs) else None
+                for index, name in enumerate(info.node.params)
+            }
+            if (
+                getattr(info, "is_udt_method", False)
+                and info.node.params
+                and info.udt_type_name
+            ):
+                receiver_spec = specs[0] if specs else None
+                if receiver_spec is None:
+                    receiver_spec = self._type_spec_from_hint_name(
+                        info.udt_type_name
+                    )
+                lexical[info.node.params[0]] = receiver_spec
+            lexical.update(self._func_collection_types.get(owner, {}))
+            return lexical
+
         for node in walk_nodes(self.ctx.ast):
             owner = owner_by_node.get(id(node))
             if isinstance(node, Subscript) and isinstance(node.object, FuncCall):
@@ -1866,8 +3354,28 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
             if not isinstance(node, FuncCall):
                 continue
-            func_name, _ = self._resolve_callee(node.callee)
-            fi = self._func_info_map.get(func_name)
+            fi = None
+            method_call = False
+            if isinstance(node.callee, MemberAccess):
+                # Method syntax is type-directed. Resolve it before considering
+                # any same-named bare UDF, and use the AST owner's lexical
+                # parameter types: analyzer symbol scopes no longer exist in
+                # this source-order prepass.
+                receiver_spec = self._map_effect_type_spec(
+                    node.callee.object, owner_lexical_specs(owner)
+                )
+                receiver_name = method_receiver_type_name(receiver_spec)
+                if receiver_name is not None:
+                    method_key = f"{receiver_name}.{node.callee.member}"
+                    candidate = self._func_info_map.get(method_key)
+                    if (
+                        candidate is not None
+                        and getattr(candidate, "is_udt_method", False)
+                    ):
+                        fi = candidate
+                        method_call = True
+            elif isinstance(node.callee, Identifier):
+                fi = self._func_info_map.get(node.callee.name)
             if fi is None or fi.node is None:
                 continue
             func_sv = self.ctx.func_series_vars.get(fi.name, set())
@@ -1876,18 +3384,72 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             }
             if not series_param_indices:
                 continue
-            args = actual_args_for(node, list(fi.node.params))
+            if method_call:
+                args = [
+                    node.callee.object,
+                    *actual_args_for(
+                        node, list(fi.node.params[1:]), method_info=fi
+                    ),
+                ]
+            else:
+                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
-                )
+                for context in self._inline_history_contexts_for_owner(owner):
+                    target_cs = target_cs_for_context(
+                        fi, node, owner, context
+                    )
+                    expected_cpp_type = self._series_param_element_cpp_type(
+                        fi, idx, target_cs
+                    )
+                    needs_bridge = True
+                    if isinstance(arg, Identifier):
+                        if (
+                            (
+                                arg.name in BAR_FIELDS
+                                or arg.name in BAR_SERIES_PUSH
+                            )
+                            and expected_cpp_type == "double"
+                        ):
+                            needs_bridge = False
+                        owner_info = self._func_info_map.get(owner or "")
+                        owner_series_cpp_type = None
+                        if (
+                            owner_info is not None
+                            and owner_info.node is not None
+                            and arg.name in owner_info.node.params
+                            and arg.name in self.ctx.func_series_vars.get(
+                                owner_info.name, set()
+                            )
+                        ):
+                            owner_index = owner_info.node.params.index(
+                                arg.name
+                            )
+                            owner_series_cpp_type = (
+                                self._series_param_element_cpp_type(
+                                    owner_info,
+                                    owner_index,
+                                    owner_cs_for_context(owner, context),
+                                )
+                            )
+                            if owner_series_cpp_type == expected_cpp_type:
+                                needs_bridge = False
+                        if (
+                            owner_series_cpp_type is None
+                            and arg.name in self.ctx.series_vars
+                            and arg.name not in ambiguous_series_names
+                            and self._series_type_for(arg.name)
+                                == expected_cpp_type
+                        ):
+                            needs_bridge = False
+                    if needs_bridge:
+                        register_one(
+                            "series_arg",
+                            (id(node), idx),
+                            expected_cpp_type,
+                            context,
+                        )
 
     def _inline_history_member(self, kind: str, node: ASTNode,
                                arg_idx: int | None = None) -> str:
@@ -1902,12 +3464,153 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             )
         return member
 
+    @staticmethod
+    def _allocate_generated_cpp_name(preferred: str, used: set[str]) -> str:
+        """Reserve one deterministic generated C++ identifier.
+
+        Pine permits identifiers beginning with underscores, so generated
+        support names cannot rely on a magic prefix being unavailable to the
+        author.  Preserve the historical spelling when it is free and append
+        a stable suffix only for an actual collision.
+        """
+        candidate = preferred
+        suffix = 2
+        while candidate in used:
+            candidate = f"{preferred}__pf{suffix}"
+            suffix += 1
+        used.add(candidate)
+        return candidate
+
+    def _prepare_udt_generated_names(self) -> None:
+        """Allocate UDT support symbols outside every authored namespace.
+
+        Record/trait/template names live at generated-file scope, while arena
+        instances live in ``GeneratedStrategy``.  This pass runs only after
+        callable clones, declaration-site flags and inline-history members have
+        their final names.  Keep one complete class-scope inventory so adding a
+        UDT member cannot make ``_func_safe_name`` change after those prepasses,
+        then extend the file-scope inventory with the same names because an
+        unqualified class member, parameter or local can hide a generated
+        support type.  In the ordinary non-colliding case the preferred names
+        remain byte-for-byte unchanged.
+        """
+        class_used: set[str] = set(
+            getattr(self, "_runtime_var_init_flag_used_names", ())
+        )
+        class_used.update(self._all_member_names)
+        class_used.update(
+            self._safe_name(name) for name in self._all_bound_names
+        )
+        class_used.update(
+            self._safe_name(name)
+            for name, _ptype in self.ctx.global_var_decls
+        )
+        for func_info in self.ctx.func_infos:
+            node = getattr(func_info, "node", None)
+            if node is not None:
+                class_used.update(
+                    self._safe_name(name)
+                    for name in (getattr(node, "params", ()) or ())
+                )
+
+        # These generated members are not all recorded in
+        # ``_runtime_var_init_flag_used_names``.  Reserve them explicitly so
+        # the inventory remains authoritative even for scripts without a
+        # runtime scalar ``var`` initializer.
+        class_used.update(
+            remapped
+            for remap in self._func_cs_ta_remap.values()
+            for remapped in remap.values()
+        )
+        class_used.update(
+            site.member_name
+            for index, site in enumerate(self.ctx.ta_call_sites)
+            if index not in self._dead_ta_indices
+        )
+        class_used.update(
+            f"_precalc_{site.member_name}"
+            for index, site in enumerate(self.ctx.ta_call_sites)
+            if index not in self._dead_ta_indices
+            and self._ta_site_uses_precalc(site)
+        )
+        class_used.update(
+            site.member_name
+            for index, site in enumerate(self.ctx.fixnan_sites)
+            if index not in self._dead_fixnan_indices
+        )
+        class_used.update(
+            info["member_name"] for info in self._inline_history_members
+        )
+        class_used.update(
+            variant["member_name"]
+            for info in self._security_eval_info
+            for variants in (info.get("ta_variants") or {}).values()
+            for variant in variants
+        )
+        for instance in self._fresh_instances:
+            class_used.add(instance["name"])
+            for remap_name in ("ta_remap", "var_remap", "fixnan_remap"):
+                class_used.update(instance.get(remap_name, {}).values())
+
+        global_used: set[str] = set(self._udt_defs)
+        global_used.update(self._enum_defs)
+        global_used.update(
+            f"{enum_name}_{member}"
+            for enum_name, members in self._enum_defs.items()
+            for member in members
+        )
+        global_used.update(
+            f"{enum_name}_str_values"
+            for enum_name, members in self._enum_defs.items()
+            if self._enum_member_strings.get(enum_name)
+            and len(self._enum_member_strings[enum_name]) == len(members)
+        )
+        global_used.update(class_used)
+
+        self._udt_arena_template_cpp_name = self._allocate_generated_cpp_name(
+            "_PFUdtArena", global_used
+        )
+        self._udt_undo_coordinator_cpp_name = self._allocate_generated_cpp_name(
+            "_PFUdtUndoCoordinator", global_used
+        )
+        self._checkpoint_traits_cpp_name = self._allocate_generated_cpp_name(
+            "_PFCheckpointTraits", global_used
+        )
+        self._udt_record_cpp_names: dict[str, str] = {}
+        for type_name in self._udt_defs:
+            self._udt_record_cpp_names[type_name] = (
+                self._allocate_generated_cpp_name(
+                    f"_PFUdtRecord_{type_name}", global_used
+                )
+            )
+
+        member_used = set(class_used)
+        self._udt_undo_coordinator_member_name = self._allocate_generated_cpp_name(
+            "_pf_udt_undo", member_used
+        )
+        self._all_member_names.add(self._udt_undo_coordinator_member_name)
+        self._udt_arena_member_names: dict[str, str] = {}
+        for type_name in self._udt_defs:
+            preferred = f"_pf_udt_{self._safe_name(type_name)}"
+            allocated = self._allocate_generated_cpp_name(
+                preferred, member_used
+            )
+            self._udt_arena_member_names[type_name] = allocated
+            self._all_member_names.add(allocated)
+
     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()
+        # Allocate declaration-site once flags only after every natural and
+        # context-sensitive callable-state member name is known.
+        self._prepare_runtime_scalar_var_initializers()
         self._prepare_inline_history_members()
+        # UDT support names are the final generated-name category.  They must
+        # suffix around every authored/callable identifier already frozen by
+        # the passes above, never force an earlier callable to rename itself.
+        self._prepare_udt_generated_names()
         # Pre-scan for strategy series vars
         self._prescan_strategy_series()
         self._security_ohlc_hist_fields_by_sec: dict[int, set[str]] = {}
@@ -1917,6 +3620,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # 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] = {}
+        self._prepare_lazy_saturated_roc3_sites()
 
         lines: list[str] = []
 
@@ -1927,14 +3631,197 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # 1. Includes
         self._emit_includes(lines)
 
-        # 1b. UDT structs
-        # Drawing field names per struct are pre-computed in __init__ as
-        # ``self._udt_omitted_fields`` so visit_expr / visit_stmt can
-        # consult the same map. Drawing types: label, line, box, table,
-        # linefill, polyline, chart.point. These have no backtest runtime
-        # representation in PineForge — see pineforge-codegen issue #10.
-        for type_name, fields in self._udt_defs.items():
+        # 1b. User-defined object handles and backing records.
+        #
+        # Pine UDT values are object IDs: ordinary assignment aliases the same
+        # object, while ``copy()`` allocates one detached outer object and keeps
+        # nested UDT/map/matrix IDs shallow-shared. Direct array-valued fields
+        # still use std::vector value storage, so their built-in UDT copy path
+        # is rejected explicitly until arrays gain handle identity. Emit every
+        # authored type as a small nullable handle first, then its value record.
+        # The two-phase order also permits self/nested UDT fields without
+        # embedding a C++ type recursively by value.
+        for type_name in self._udt_defs:
             lines.append(f"struct {type_name} {{")
+            lines.append("    int32_t __pf_id = -1;")
+            lines.append("};")
+            lines.append(
+                f"inline bool is_na(const {type_name}& _z) "
+                "{ return _z.__pf_id < 0; }"
+            )
+            lines.append("")
+
+        if self._udt_defs:
+            lines.extend([
+                "template <typename _PFValue>",
+                f"struct {self._checkpoint_traits_cpp_name};",
+                "",
+                f"class {self._udt_undo_coordinator_cpp_name} {{",
+                "    std::vector<std::function<void()>> _pf_undo_;",
+                "    uint64_t _pf_generation_ = 0;",
+                "    bool _pf_active_ = false;",
+                "public:",
+                "    struct Snapshot { uint64_t generation; };",
+                f"    {self._udt_undo_coordinator_cpp_name}() = default;",
+                f"    {self._udt_undo_coordinator_cpp_name}(",
+                f"        const {self._udt_undo_coordinator_cpp_name}&) = delete;",
+                f"    {self._udt_undo_coordinator_cpp_name}& operator=(",
+                f"        const {self._udt_undo_coordinator_cpp_name}&) = delete;",
+                f"    {self._udt_undo_coordinator_cpp_name}(",
+                f"        {self._udt_undo_coordinator_cpp_name}&&) = delete;",
+                f"    {self._udt_undo_coordinator_cpp_name}& operator=(",
+                f"        {self._udt_undo_coordinator_cpp_name}&&) = delete;",
+                "",
+                "    Snapshot snapshot() {",
+                "        if (_pf_generation_ == std::numeric_limits<uint64_t>::max()) {",
+                '            throw std::overflow_error("UDT checkpoint generation exhausted");',
+                "        }",
+                "        ++_pf_generation_;",
+                "        _pf_undo_.clear();",
+                "        _pf_active_ = true;",
+                "        return Snapshot{_pf_generation_};",
+                "    }",
+                "    uint64_t generation() const { return _pf_generation_; }",
+                "    bool active() const { return _pf_active_; }",
+                "    bool empty() const { return _pf_undo_.empty(); }",
+                "    void record(uint64_t generation, std::function<void()> undo) {",
+                "        if (!_pf_active_ || generation != _pf_generation_) {",
+                '            throw std::runtime_error("invalid UDT undo generation");',
+                "        }",
+                "        _pf_undo_.push_back(std::move(undo));",
+                "    }",
+                "    void restore(const Snapshot& snapshot) {",
+                "        if (!_pf_active_ || snapshot.generation != _pf_generation_) {",
+                '            throw std::runtime_error("invalid UDT coordinator checkpoint token");',
+                "        }",
+                "        for (auto entry = _pf_undo_.rbegin();",
+                "                entry != _pf_undo_.rend(); ++entry) (*entry)();",
+                "        _pf_undo_.clear();",
+                "    }",
+                "};",
+                "",
+                "template <typename _PFHandle, typename _PFRecord>",
+                f"class {self._udt_arena_template_cpp_name} {{",
+                f"    using _PFRecordTraits = {self._checkpoint_traits_cpp_name}<_PFRecord>;",
+                "    using _PFRecordSnapshot = typename _PFRecordTraits::snapshot_type;",
+                "    struct _PFSlot {",
+                "        _PFRecord value;",
+                "        uint64_t logged_generation = 0;",
+                "    };",
+                "    std::deque<_PFSlot> _pf_records_;",
+                f"    {self._udt_undo_coordinator_cpp_name}* _pf_coordinator_;",
+                "    std::size_t _pf_checkpoint_size_ = 0;",
+                "    uint64_t _pf_checkpoint_generation_ = 0;",
+                "    bool _pf_checkpoint_active_ = false;",
+                "",
+                "    void capture(std::size_t index) {",
+                "        if (!_pf_checkpoint_active_) return;",
+                "        auto& slot = _pf_records_.at(index);",
+                "        if (slot.logged_generation",
+                "                == _pf_checkpoint_generation_) return;",
+                "        auto snapshot = _PFRecordTraits::take(slot.value);",
+                "        _pf_coordinator_->record(_pf_checkpoint_generation_,",
+                "            [this, index, snapshot = std::move(snapshot)]() mutable {",
+                "                auto& restore_slot = _pf_records_.at(index);",
+                "                _PFRecordTraits::restore(restore_slot.value, snapshot);",
+                "                restore_slot.logged_generation = 0;",
+                "            });",
+                "        slot.logged_generation = _pf_checkpoint_generation_;",
+                "    }",
+                "public:",
+                "    struct Snapshot {",
+                "        uint64_t generation;",
+                "        std::size_t size;",
+                "    };",
+                "",
+                f"    explicit {self._udt_arena_template_cpp_name}(",
+                f"            {self._udt_undo_coordinator_cpp_name}* coordinator)",
+                "            : _pf_coordinator_(coordinator) {",
+                "        if (!_pf_coordinator_)",
+                '            throw std::invalid_argument("UDT arena requires undo coordinator");',
+                "    }",
+                f"    {self._udt_arena_template_cpp_name}(",
+                f"        const {self._udt_arena_template_cpp_name}&) = delete;",
+                f"    {self._udt_arena_template_cpp_name}& operator=(",
+                f"        const {self._udt_arena_template_cpp_name}&) = delete;",
+                f"    {self._udt_arena_template_cpp_name}(",
+                f"        {self._udt_arena_template_cpp_name}&&) = delete;",
+                f"    {self._udt_arena_template_cpp_name}& operator=(",
+                f"        {self._udt_arena_template_cpp_name}&&) = delete;",
+                "",
+                "    _PFHandle create(_PFRecord value) {",
+                "        if (_pf_records_.size() > static_cast<std::size_t>(",
+                "                std::numeric_limits<int32_t>::max())) {",
+                '            throw std::length_error("UDT object-ID capacity exceeded");',
+                "        }",
+                "        const auto id = static_cast<int32_t>(_pf_records_.size());",
+                "        _pf_records_.push_back(_PFSlot{std::move(value), 0});",
+                "        return _PFHandle{id};",
+                "    }",
+                "    _PFHandle copy(_PFHandle value) {",
+                "        return create(static_cast<const "
+                f"{self._udt_arena_template_cpp_name}&>(*this).get(value));",
+                "    }",
+                "    _PFRecord& get(_PFHandle value) {",
+                "        if (value.__pf_id < 0",
+                "                || static_cast<std::size_t>(value.__pf_id) >= _pf_records_.size()) {",
+                '            throw std::runtime_error("UDT access on na or invalid object ID");',
+                "        }",
+                "        const auto index = static_cast<std::size_t>(value.__pf_id);",
+                "        capture(index);",
+                "        return _pf_records_[index].value;",
+                "    }",
+                "    const _PFRecord& get(_PFHandle value) const {",
+                "        if (value.__pf_id < 0",
+                "                || static_cast<std::size_t>(value.__pf_id) >= _pf_records_.size()) {",
+                '            throw std::runtime_error("UDT access on na or invalid object ID");',
+                "        }",
+                "        return _pf_records_[static_cast<std::size_t>(value.__pf_id)].value;",
+                "    }",
+                "    const _PFRecord& read(_PFHandle value) const {",
+                "        return get(value);",
+                "    }",
+                "    std::size_t size() const { return _pf_records_.size(); }",
+                "    _PFRecord& record_at(std::size_t index) {",
+                "        capture(index);",
+                "        return _pf_records_.at(index).value;",
+                "    }",
+                "    const _PFRecord& record_at(std::size_t index) const {",
+                "        return _pf_records_.at(index).value;",
+                "    }",
+                "    Snapshot snapshot() {",
+                "        if (!_pf_coordinator_->active()) {",
+                '            throw std::runtime_error("UDT coordinator checkpoint is not active");',
+                "        }",
+                "        _pf_checkpoint_generation_ = _pf_coordinator_->generation();",
+                "        _pf_checkpoint_size_ = _pf_records_.size();",
+                "        _pf_checkpoint_active_ = true;",
+                "        return Snapshot{_pf_checkpoint_generation_,",
+                "                        _pf_checkpoint_size_};",
+                "    }",
+                "    void restore(const Snapshot& snapshot) {",
+                "        if (!_pf_checkpoint_active_",
+                "                || snapshot.generation != _pf_checkpoint_generation_",
+                "                || snapshot.generation != _pf_coordinator_->generation()",
+                "                || snapshot.size != _pf_checkpoint_size_",
+                "                || _pf_records_.size() < snapshot.size",
+                "                || !_pf_coordinator_->empty()) {",
+                '            throw std::runtime_error("invalid UDT checkpoint token");',
+                "        }",
+                "        _pf_records_.resize(snapshot.size);",
+                "    }",
+                "};",
+                "",
+            ])
+
+        # Drawing field names per record are pre-computed in __init__ as
+        # ``self._udt_omitted_fields`` so visit_expr / visit_stmt can consult
+        # the same map.  Authored field defaults are evaluated by ``Type.new``
+        # at the call site; record declarations use only inert typed defaults so
+        # bar/TA expressions never leak into namespace-scope C++ initializers.
+        for type_name, fields in self._udt_defs.items():
+            record_type = self._udt_record_cpp_type(type_name)
+            lines.append(f"struct {record_type} {{")
             field_specs = self._udt_field_type_specs.get(type_name, {})
             omitted = self._udt_omitted_fields.get(type_name, set())
             for f in fields:
@@ -1942,28 +3829,16 @@ 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:
-                    default = self._default_for_spec(spec)
+                default = self._default_for_spec(spec)
                 lines.append(f"    {cpp_type} {f.name} = {default};")
-            # NA sentinel (always the last data member). A default-constructed
-            # UDT - ``var T x = na``, an array fill slot, ``T.copy()`` no-arg -
-            # is na; the ``T.new(...)`` lowering sets this false. This lets
-            # ``na(udtVar)`` lower to the ``is_na(const T&)`` overload below
-            # instead of failing because no ``is_na`` accepts a struct.
-            lines.append(f"    bool __pf_na = true;")
-            lines.append(f"    static {type_name} create() {{ return {type_name}{{}}; }}")
             lines.append("};")
-            lines.append(f"inline bool is_na(const {type_name}& _z) {{ return _z.__pf_na; }}")
             lines.append("")
 
+        if self._uses_map or self._uses_matrix or self._udt_defs:
+            self._emit_handle_checkpoint_traits(lines)
+
         # 1c. Enum constants + string tables for str.tostring(enumVar)
         for enum_name, members in self._enum_defs.items():
             for i, member in enumerate(members):
@@ -1978,15 +3853,41 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 )
             lines.append("")
 
+        # Source-shaped lazy ROC call clocks are generated support types, not
+        # script state themselves. Their per-callsite instances are declared
+        # below inside GeneratedStrategy and therefore join the automatic COOF
+        # checkpoint inventory.
+        self._emit_lazy_saturated_roc3_helper(lines)
+
         # 2. Open class
         lines.append("class GeneratedStrategy : public BacktestEngine {")
         lines.append("public:")
         _script_state_decl_start = len(lines)
+
+        # One strategy-local undo coordinator gives every UDT arena a single
+        # reverse first-touch order. This is required when records from distinct
+        # authored UDT types shallow-share the same map or matrix identity.
+        if self._udt_defs:
+            lines.append(
+                f"    {self._udt_undo_coordinator_cpp_name} "
+                f"{self._udt_undo_coordinator_member_name};"
+            )
+
+        # Per-type object stores precede every handle-bearing script member.
+        # COOF rollback therefore replays the coordinator, truncates arenas,
+        # then rebinds ordinary variables, arrays and matrices in that order.
+        for type_name in self._udt_defs:
+            lines.append(
+                f"    {self._udt_arena_cpp_type(type_name)} "
+                f"{self._udt_arena_member_name(type_name)}"
+                f"{{&{self._udt_undo_coordinator_member_name}}};"
+            )
         
         # request.security state
         for item in self._security_calls:
             sec_id = item["sec_id"]
             expr_node = item["expr_node"]
+            self._validate_security_persistent_var_control_flow(expr_node)
             returns_tuple = item.get("returns_tuple", False)
             tuple_size = item.get("tuple_size", 0)
             if item.get("is_lower_tf_array"):
@@ -2036,15 +3937,33 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     if ctype == "std::vector<double>":
                         lines.append(f"    {ctype} _req_sec_{sec_id}_{i}{{}};")
                     else:
-                        lines.append(f"    {ctype} _req_sec_{sec_id}_{i} = na<double>();")
+                        default = {
+                            "double": "na<double>()",
+                            "bool": "false",
+                            "int": "0",
+                            "std::string": 'std::string("")',
+                        }.get(ctype, self._default_for_type(ctype))
+                        lines.append(
+                            f"    {ctype} _req_sec_{sec_id}_{i} = {default};"
+                        )
             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)
+                ctype = TA_TUPLE_RESULT_TYPES.get(
+                    ta_name,
+                    self._security_helper_tuple_cpp_type(
+                        tuple_size,
+                        item.get("tuple_element_types", ()),
+                    ),
+                )
+                default = self._security_tuple_result_default(
+                    ctype,
+                    tuple_size,
+                    item.get("tuple_element_types", ()),
+                )
                 lines.append(f"    {ctype} _req_sec_{sec_id} = {default};")
             else:
                 self._security_ohlc_hist_fields_by_sec[sec_id] = (
@@ -2094,6 +4013,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 lines.append(f"    std::vector<{vtype}> _precalc_{site.member_name};")
         lines.append("    bool _use_precalc = false;")
 
+        for clock_name in self._lazy_saturated_roc3_clock_by_node.values():
+            lines.append(
+                f"    {self._lazy_saturated_roc3_type_name} {clock_name};"
+            )
+        if self._lazy_saturated_roc3_clock_by_node:
+            # Dedicated eager close[3] fallback. Its fixed four-slot capacity
+            # is independent of the user's max_bars_back directive, which may
+            # legitimately be smaller than the offset this generated route
+            # requires. It is ordinary copyable script state and therefore
+            # joins the automatic COOF checkpoint below.
+            lines.append(
+                "    Series<double> "
+                f"{self._lazy_saturated_roc3_history_name}{{4}};"
+            )
+
         # Security evaluator TA members (cloned from expression dependencies)
         # Skip for user function call expressions — their TA deps are internal to the function
         for info in self._security_eval_info:
@@ -2113,6 +4047,22 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 continue
             seen_var_members.add(name)
             safe = self._safe_name(name)
+            callable_collection_spec = (
+                None
+                if name in self._global_collection_types
+                else self._callable_var_collection_spec(name)
+            )
+            if callable_collection_spec is not None:
+                lines.append(
+                    f"    {self._type_spec_to_cpp(callable_collection_spec)} {safe};"
+                )
+                continue
+            callable_udt_spec = self._callable_var_udt_spec(name)
+            if callable_udt_spec is not None:
+                lines.append(
+                    f"    {self._type_spec_to_cpp(callable_udt_spec)} {safe};"
+                )
+                continue
             # 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.
@@ -2123,12 +4073,24 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             _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
+            exact_member_spec = self._global_collection_types.get(name)
+            exact_array_member = (
+                exact_member_spec is not None
+                and exact_member_spec.kind == "array"
+            )
+            if exact_array_member or (
+                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};")
+                array_spec = exact_member_spec or self._array_spec_for_name(name)
+                lines.append(
+                    f"    {self._type_spec_to_cpp(array_spec)} {safe};"
+                )
                 continue
             # Detect matrix vars from init expression OR from the set
             # populated by ``_register_global_aggregate_member_types``
@@ -2136,7 +4098,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # not just ``matrix.new``).
             if name in self._matrix_specs:
                 pass  # already registered upstream
-            elif "matrix.new" in str(init_str):
+            elif not _is_udt_ctor_init and "matrix.new" in str(init_str):
                 self._matrix_specs[name] = TypeSpec.matrix(TypeSpec.primitive("float"))
                 self._collection_types[name] = self._matrix_specs[name]
             if name in self._matrix_specs:
@@ -2145,9 +4107,17 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if "ta.pivot_point_levels" in str(init_str):
                 lines.append(f"    std::vector<double> {safe};")
                 continue
-            if "map.new" in str(init_str) or name in self._map_vars:
+            exact_map_member = (
+                exact_member_spec is not None
+                and exact_member_spec.kind == "map"
+            )
+            if exact_map_member or (
+                not _is_udt_ctor_init
+                and ("map.new" in str(init_str) or name in self._map_vars)
+            ):
                 self._map_vars.add(name)
-                lines.append(f"    {self._type_spec_to_cpp(self._map_spec_for_name(name))} {safe};")
+                map_spec = exact_member_spec or self._map_spec_for_name(name)
+                lines.append(f"    {self._type_spec_to_cpp(map_spec)} {safe};")
                 continue
             # Detect UDT vars. Two signals: (1) the analyzer recorded an
             # explicit UDT type annotation in ``_udt_var_types`` - this is the
@@ -2161,14 +4131,18 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # 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))
+            member_udt_type = self._member_udt_type(name)
+            _draw_cpp = (
+                self._drawing_var_member_cpp_types.get(name)
+                or DRAWING_TYPE_TO_CPP.get(member_udt_type)
+            )
             if _draw_cpp is not None:
-                if name in self.ctx.series_vars:
+                if safe in self._series_var_member_names:
                     lines.append(f"    Series<{_draw_cpp}> {safe}{_mbb};")
                 else:
                     lines.append(f"    {_draw_cpp} {safe};")
                 continue
-            udt_type = self._udt_var_types.get(name)
+            udt_type = member_udt_type
             if udt_type not in self._udt_defs:
                 udt_type = None
             if udt_type is None:
@@ -2184,14 +4158,35 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # (time/time_close/timestamp), otherwise the na sentinel narrows.
             if cpp_type == "int" and self._is_int64_builtin_init(name):
                 cpp_type = "int64_t"
-            if name in self.ctx.series_vars:
+            # Persistent declarations have collision-safe exact member names
+            # (for example ``x`` and ``x__blk1`` for sibling lexical blocks).
+            # ``ctx.series_vars`` is only the legacy raw-name union, so using it
+            # here can invert the storage types: the unreferenced sibling gets
+            # Series<T> while the exact history-referenced sibling stays a
+            # scalar.  Exact analyzer identity must win for every persistent
+            # primitive, just as it already does for drawing handles above.
+            if safe in self._series_var_member_names:
                 lines.append(f"    Series<{cpp_type}> {safe}{_mbb};")
             else:
-                lines.append(f"    {cpp_type} {safe};")
+                if name in self._runtime_scalar_var_init_members:
+                    # A conditional declaration may not execute for many bars,
+                    # while COOF rollback still value-copies every member. Give
+                    # pending runtime vars a typed Pine-na sentinel so that copy
+                    # is always defined; the declaration-site guard overwrites
+                    # it on the first actual execution.
+                    pending = self._typed_na_init("na<double>()", name, ptype)
+                    lines.append(f"    {cpp_type} {safe} = {pending};")
+                else:
+                    lines.append(f"    {cpp_type} {safe};")
 
         # 6. Non-var series vars
         for name in sorted(self.ctx.series_vars):
-            if name not in self._var_names:
+            if (name not in self._var_names
+                    or name in self._nonpersistent_series_decl_names):
+                if (name in self._qualified_func_var_raw_names
+                        and name in self._ordinary_global_binding_names
+                        and name not in self._ordinary_global_series_names):
+                    continue
                 safe = self._safe_name(name)
                 cpp_type = self._series_type_for(name)
                 lines.append(f"    Series<{cpp_type}> {safe}{_mbb};")
@@ -2200,7 +4195,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         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")
+            cpp_type = self._fixnan_site_cpp_type(site)
             lines.append(f"    {cpp_type} {site.member_name} = na<{cpp_type}>();")
 
         # 8. Strategy series (e.g., strategy.closedtrades[1])
@@ -2225,13 +4220,14 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         #     (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)
+            exact_scalar_override = (
+                name in self._qualified_func_var_raw_names
+                and name in self._ordinary_global_binding_names
+                and name not in self._ordinary_global_series_names
+            )
+            if (name in seen_global
+                    or (name in self.ctx.series_vars and not exact_scalar_override)
+                    or name in self._var_names):
                 continue
             seen_global.add(name)
             safe = self._safe_name(name)
@@ -2246,12 +4242,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "localPivots", "securityPivotPointsArray", "pivotPointsArray",
             ):
                 lines.append(f"    std::vector<double> {safe} = std::vector<double>();")
-            elif name in self._udt_var_types:
+            elif self._member_udt_type(name) is not None:
                 # Non-var global of UDT type — declare as the struct so
                 # downstream method dispatch works. Probes:
                 # 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]
+                udt_t = self._member_udt_type(name)
                 # 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)
@@ -2261,7 +4257,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     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")
+                if (
+                    name in self._direct_program_tuple_binding_names
+                    and ptype == PineType.BOOL
+                ):
+                    # request.security homogeneous-bool helper tuples carry
+                    # their exact element family in analyzer metadata. The
+                    # coarse request.security call expression itself still
+                    # reports FLOAT, so prefer that exact binding type here.
+                    cpp_type = "bool"
+                else:
+                    cpp_type = (
+                        self._infer_type(expr)
+                        if expr is not None
+                        else PINE_TYPE_TO_CPP.get(ptype, "double")
+                    )
                 default = self._default_for_type(cpp_type)
                 lines.append(f"    {cpp_type} {safe} = {default};")
 
@@ -2275,16 +4285,20 @@ 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)
-                self._emit_cloned_var_decl(orig_safe, cloned_safe, _mbb, lines)
+                self._emit_cloned_var_decl(
+                    orig_safe, cloned_safe, _mbb, lines, owner_func=fname
+                )
 
         # 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:
+        for owner_func, 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)
+            self._emit_cloned_var_decl(
+                orig_safe, fresh_safe, _mbb, lines, owner_func=owner_func
+            )
 
         # 8c3. Fresh fixnan members for context-sensitive helper instances.
         #      Each fresh instance gets its OWN previous-value member so two
@@ -2293,7 +4307,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if fresh_safe in emitted_clones:
                 continue
             emitted_clones.add(fresh_safe)
-            cpp_type = PINE_TYPE_TO_CPP.get(orig_site.pine_type, "double")
+            cpp_type = self._fixnan_site_cpp_type(orig_site)
             lines.append(f"    {cpp_type} {fresh_safe} = na<{cpp_type}>();")
 
         # 8d. Drawing-objects-as-data arenas (gated on _uses_drawing so
@@ -2311,39 +4325,59 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         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.
+        # 9a. Per-member flags for primitive runtime ``var`` / ``varip``
+        # initializers. Unlike the global aggregate/Series latch above, these
+        # live at the declaration site so prior statements are available and a
+        # conditional declaration initializes on its first actual execution.
+        emitted_runtime_flags: set[str] = set()
+        for flag in self._runtime_var_init_flags.values():
+            if flag in emitted_runtime_flags:
+                continue
+            emitted_runtime_flags.add(flag)
+            lines.append(f"    bool {flag} = false;")
+
+        # 9b. Legacy per-variant latch members are retained for generated-C++
+        # and checkpoint-shape compatibility. Callable initializers no longer
+        # consult them: every initialized declaration owns an exact-site flag.
+        # Keep their historical spelling when free, but avoid legal authored
+        # ``_fvinit_*`` members and every natural/fresh clone name.
+        used_legacy_flags = set(self._runtime_var_init_flag_used_names)
+
+        def allocate_legacy_flag(base: str) -> str:
+            flag = base
+            suffix = 2
+            while flag in used_legacy_flags:
+                flag = f"{base}_{suffix}"
+                suffix += 1
+            used_legacy_flags.add(flag)
+            return flag
+
         for fi in self.ctx.func_infos:
             if fi.name not in self.ctx.func_var_members:
                 continue
+            emitted = self._func_cpp_base_name(fi.name)
             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;")
+            variants = range(total_cs) if total_cs > 0 else (None,)
+            for cs_idx in variants:
+                suffix = f"_cs{cs_idx}" if cs_idx is not None else ""
+                flag = allocate_legacy_flag(f"_fvinit_{emitted}{suffix}")
+                lines.append(f"    bool {flag} = 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;")
+                flag = allocate_legacy_flag(f"_fvinit_{inst['name']}")
+                lines.append(f"    bool {flag} = false;")
 
-        # 9b. _ta_initialized_ flag for runtime TA re-sizing (first on_bar only).
+        # 9c. _ta_initialized_ flag for runtime TA re-sizing (first on_bar only).
         if self.ctx.ta_call_sites:
             lines.append("    bool _ta_initialized_ = false;")
 
-        # 9c. _inputs_initialized_ flag for cached global inputs.
+        # 9d. _inputs_initialized_ flag for cached global inputs.
         lines.append("    bool _inputs_initialized_ = false;")
 
         lines.append("")
 
-        # 9d. Historical execution rollback checkpoint.  Derive the member
+        # 9e. 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).
@@ -2447,8 +4481,26 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
     # _get_ta_site / _ta_member_name / _ta_name_from_site / _TA_IMPLICIT_REPLACE
     # / _ta_compute_args_for_site / _security_ta_compute_args_for_site /
-    # _if_body_has_ta / _is_result_assignment / _expr_contains_ta /
-    # _hoist_if_body live on TaSiteHelper (codegen/ta.py).
+    def _resolve_ta_ctor_arg(self, arg_str: str) -> str:
+        """Resolve one TA constructor argument without widening const folding.
+
+        ``var`` values deliberately stay out of ``_known_vars`` because normal
+        expression reads must still target persistent storage.  A uniquely
+        bound, never-reassigned top-level integer literal is nevertheless a
+        faithful static TA buffer length.  Admit only that exact bare alias;
+        arithmetic, input/timeframe expressions, shadows, and all mutable or
+        history-bearing bindings continue through the existing resolver/reset
+        guardrails unchanged.
+        """
+        resolved = self._resolve_known(arg_str)
+        if self._is_compile_time_value(resolved):
+            return resolved
+        if (
+            arg_str in self._stable_var_ctor_literals
+            and not self._known_var_is_lexically_shadowed(arg_str)
+        ):
+            return str(self._stable_var_ctor_literals[arg_str].value)
+        return resolved
 
     def _resolve_known(self, arg_str: str) -> str:
         """Resolve a string arg, replacing known var names with their values.
@@ -2459,7 +4511,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         if arg_str == "na":
             return "na<double>()"
         # Direct variable lookup
-        if arg_str in self._known_vars:
+        if (arg_str in self._known_vars
+                and not self._known_var_is_lexically_shadowed(arg_str)):
             val = self._known_vars[arg_str]
             if isinstance(val, bool):
                 return "true" if val else "false"
@@ -2476,6 +4529,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 resolved = arg_str
                 # Sort by length (longest first) to avoid partial replacements
                 for name in sorted(self._known_vars, key=len, reverse=True):
+                    if self._known_var_is_lexically_shadowed(name):
+                        continue
                     val = self._known_vars[name]
                     if isinstance(val, (int, float)):
                         import re
@@ -2546,15 +4601,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         """
         if not isinstance(node, MemberAccess):
             return False
-        # Cheap path: receiver is a bare identifier we already track in
-        # ``_udt_var_types`` (the common case — ``m.tag``, ``s.ln``).
-        if isinstance(node.object, Identifier):
-            udt_name = self._udt_var_types.get(node.object.name)
-            if udt_name is None:
-                return False
-            return node.member in self._udt_omitted_fields.get(udt_name, ())
-        # General path: try to infer the receiver's UDT type via the same
-        # spec-resolver visit_expr uses for fallback member access.
+        # Resolve even bare identifiers through the lexical/exact TypeSpec
+        # path.  The legacy raw-name UDT registry can describe an unrelated
+        # callable local and therefore cannot safely drive field omission.
         recv_spec = self._type_spec_from_expr(node.object)
         if recv_spec is not None and recv_spec.kind == "udt" and recv_spec.name:
             return node.member in self._udt_omitted_fields.get(recv_spec.name, ())
@@ -2594,7 +4643,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         "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); })",
+        "sign": _MATH_SIGN_CPP_FN,
     }
 
     # Pine logical operators (word form) -> C++ operator, used when rendering
@@ -2719,7 +4768,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 return s
             def _rep(p: re.Match) -> str:
                 nm = p.group(0)
-                if nm in self._derived_input_expr and nm not in seen:
+                if (nm in self._derived_input_expr
+                        and nm not in seen
+                        and not self._known_var_is_lexically_shadowed(nm)):
                     inner = self._derived_input_expr[nm]
                     return "(" + _expand_derived(inner, seen | {nm}, depth + 1) + ")"
                 return nm
@@ -2728,6 +4779,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         expanded = _expand_derived(arg_str)
 
         tokens = set(ident_re.findall(expanded))
+        if any(
+            self._known_var_is_lexically_shadowed(name)
+            for name in tokens
+        ):
+            return None
 
         # Gate: every identifier token must be renderable. If any token is an
         # unrecognised bare identifier (not an input, not a known const, not
@@ -2749,7 +4805,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # 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}
+        leftover = {
+            t for t in leftover
+            if (t not in self._known_vars
+                or self._known_var_is_lexically_shadowed(t))
+        }
         # 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,
@@ -2820,6 +4880,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # reads, and inline known compile-time consts (non-input) as literals.
         def _sub(p: re.Match) -> str:
             name = p.group(0)
+            if self._known_var_is_lexically_shadowed(name):
+                return name
             if name in self._input_backed_vars:
                 call_node = self._input_var_to_call.get(name)
                 if call_node is None:
@@ -2827,7 +4889,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 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:
+            if (name in self._known_vars
+                    and name not in self._input_backed_vars
+                    and not self._known_var_is_lexically_shadowed(name)):
                 val = self._known_vars[name]
                 if isinstance(val, bool):
                     return "true" if val else "false"
@@ -2893,7 +4957,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         return rendered
 
 
-    def _collect_ta_runtime_resets(self) -> list[str]:
+    def _collect_ta_runtime_resets(
+        self,
+        *,
+        security_source_node: ASTNode | None = None,
+    ) -> list[str]:
         """Collect reassignment statements for every TA object whose ctor args
         depend on an input-backed variable. Returned strings are raw C++
         assignment statements (no enclosing block/indent). Empty list when no
@@ -2917,7 +4985,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     runtime_args.append(rt)
                     any_runtime = True
                 else:
-                    resolved = self._resolve_known(a)
+                    resolved = self._resolve_ta_ctor_arg(a)
                     runtime_args.append(resolved if self._is_compile_time_value(resolved) else "1")
             if any_runtime:
                 resets.append(
@@ -2942,6 +5010,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             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 (
+                    security_source_node is not None
+                    and site.node is not security_source_node
+                ):
+                    continue
                 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))
@@ -2953,18 +5026,55 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                                 ctor_site = cand
                 if not ctor_site.ctor_args:
                     continue
-                runtime_args = []
-                any_runtime = False
-                for a in ctor_site.ctor_args:
-                    rt = self._runtime_ctor_arg_for_reset(a)
-                    if rt is not None:
-                        runtime_args.append(rt)
-                        any_runtime = True
-                    else:
-                        resolved = self._resolve_known(a)
-                        runtime_args.append(resolved if self._is_compile_time_value(resolved) else "1")
-                if any_runtime:
-                    for variant in variants:
+                for variant in variants:
+                    ctor_args, ctor_arg_stability = self._security_ta_ctor_args_for_variant(
+                        info["sec_id"],
+                        site,
+                        variant.get("binding_stack", ()),
+                        fallback_args=ctor_site.ctor_args,
+                    )
+                    runtime_args = []
+                    any_runtime = False
+                    for arg_pos, a in enumerate(ctor_args):
+                        rt = self._runtime_ctor_arg_for_reset(a)
+                        resolved = self._resolve_ta_ctor_arg(a)
+                        lowered_variant = ctor_arg_stability is not None
+                        stable_variant_arg = (
+                            lowered_variant and ctor_arg_stability[arg_pos]
+                        )
+                        if (
+                            rt is None
+                            and stable_variant_arg
+                            and not self._is_compile_time_value(resolved)
+                        ):
+                            # This is trusted C++ from _build_security_expr and
+                            # its fully helper-bound AST passed _expr_is_stable.
+                            rt = a
+                        if (
+                            rt is None
+                            and lowered_variant
+                            and not self._is_compile_time_value(resolved)
+                        ):
+                            self._codegen_error(
+                                getattr(site, "node", None),
+                                f"Unsupported requested-context TA constructor "
+                                f"length '{a}' for {site.class_name}: the "
+                                "helper-bound expression is not a stable "
+                                "per-run scalar.",
+                                hint=("Use a literal, an input.*() value, "
+                                      "timeframe.* metadata, or arithmetic "
+                                      "over those for TA lengths."),
+                            )
+                        if rt is not None:
+                            runtime_args.append(rt)
+                            any_runtime = True
+                        else:
+                            runtime_args.append(
+                                resolved
+                                if self._is_compile_time_value(resolved)
+                                else "1"
+                            )
+                    if any_runtime:
                         resets.append(
                             f"{variant['member_name']} = {site.class_name}({', '.join(runtime_args)});"
                         )