@pineforge/codegen-pyodide 0.10.0 → 0.10.2

package/pineforge_codegen/codegen/security.py

@@ -58,11 +58,13 @@ tables and types come from ``codegen/tables.py``, ``..ast_nodes``,
 
 from __future__ import annotations
 
+from dataclasses import replace
+
 from ..ast_nodes import (
     ASTNode, Assignment, BinOp, BoolLiteral, BreakStmt, ContinueStmt, ExprStmt,
     ForStmt, ForInStmt, FuncCall, FuncDef, Identifier, IfStmt, MemberAccess,
-    NumberLiteral, StringLiteral, Subscript, SwitchStmt, Ternary, TupleAssign,
-    TupleLiteral, UnaryOp, VarDecl, WhileStmt,
+    NaLiteral, NumberLiteral, StringLiteral, Subscript, SwitchStmt, Ternary,
+    TupleAssign, TupleLiteral, UnaryOp, VarDecl, WhileStmt,
 )
 from ..analyzer import (
     FuncInfo, TACallSite, TA_MULTI_CTOR, TA_NO_CTOR, TA_PERIOD_ARG,
@@ -76,6 +78,19 @@ from .tables import (
 )
 
 
+class _SecurityHelperArgumentFrame(dict):
+    """Callee bindings whose argument ASTs belong to the caller scope.
+
+    A callee may reuse a caller parameter name. Keeping the caller binding
+    stack with the argument prevents that new callee frame from capturing
+    identifiers inside its own argument expression and falsely recursing.
+    """
+
+    def __init__(self, values: dict, caller_stack: tuple[dict, ...]) -> None:
+        super().__init__(values)
+        self.caller_stack = caller_stack
+
+
 class SecurityEmitter:
     """Mixin owning ``request.security()`` lowering: evaluators, dispatch,
     rebind/binding/TA-variant machinery, and the per-call helper plan.
@@ -96,14 +111,22 @@ class SecurityEmitter:
         """
         if isinstance(tf_node, StringLiteral):
             return tf_node.value, None
+        if isinstance(tf_node, SwitchStmt):
+            # Keep diagnostics from the registration-time switch renderer
+            # visible; the broad expression fallback below intentionally
+            # catches ordinary unresolved expressions.
+            return None, self._security_tf_runtime_expr(tf_node)
         if isinstance(tf_node, Identifier):
             name = tf_node.name
             if name in self._timeframe_period_vars:
                 return None, "script_tf_"
             if (name in self._known_vars and name not in self._input_backed_vars
+                    and not self._known_var_is_lexically_shadowed(name)
                     and isinstance(self._known_vars[name], str)):
                 return self._known_vars[name], None
-            if name in self._input_backed_vars and name in self._input_var_to_call:
+            if (name in self._input_backed_vars
+                    and name in self._input_var_to_call
+                    and not self._known_var_is_lexically_shadowed(name)):
                 return None, self._visit_expr(self._input_var_to_call[name])
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
             if name in global_expr_map:
@@ -148,9 +171,82 @@ class SecurityEmitter:
         """
         if node is None:
             return None
+        if isinstance(node, SwitchStmt):
+            return self._security_tf_switch_runtime_expr(node, resolving or set())
         substituted = self._substitute_tf_input_reads(node, resolving or set())
         return self._visit_expr(substituted)
 
+    def _security_tf_switch_runtime_expr(
+        self, node: SwitchStmt, resolving: set[str]
+    ) -> str:
+        """Render a pure switch expression for evaluator registration.
+
+        Pine parses ``tf = switch timeframe.period ...`` as a ``SwitchStmt``
+        even though it is the right-hand side of a declaration.  The regular
+        expression visitor deliberately does not render statement nodes, so
+        passing that alias to ``request.security`` previously produced the
+        truthy placeholder ``/* unknown */`` in generated C++.  Registration
+        only needs the value selection, which can be represented as nested
+        conditional expressions over setup-time-safe leaves such as
+        ``script_tf_`` and direct input getters.
+
+        Only pure, single-expression arms with an explicit default are accepted
+        here.  Other shapes cannot be registered deterministically and produce
+        a clear codegen diagnostic.
+        """
+
+        def arm_value(body: list) -> str:
+            if len(body) != 1 or not isinstance(body[0], ExprStmt):
+                self._codegen_error(
+                    node,
+                    "request.security timeframe switch arms must contain one expression",
+                    hint=(
+                        "Compute multi-statement timeframe logic before the "
+                        "request.security call or rewrite it as pure switch arms."
+                    ),
+                )
+            value = self._security_tf_runtime_expr(body[0].expr, resolving)
+            if value is None:
+                self._codegen_error(
+                    node,
+                    "request.security timeframe switch arm could not be resolved at setup",
+                )
+            return value
+
+        if not node.default_body:
+            self._codegen_error(
+                node,
+                "request.security timeframe switch requires a default arm",
+                hint=(
+                    "An unmatched Pine switch yields na; add an explicit default "
+                    "timeframe so the evaluator can be registered deterministically."
+                ),
+            )
+        result = arm_value(node.default_body)
+
+        selector = None
+        if node.expr is not None:
+            selector = self._security_tf_runtime_expr(node.expr, resolving)
+            if selector is None:
+                self._codegen_error(
+                    node,
+                    "request.security timeframe switch selector could not be resolved at setup",
+                )
+
+        for case_expr, body in reversed(node.cases):
+            value = arm_value(body)
+            case = self._security_tf_runtime_expr(case_expr, resolving)
+            if case is None:
+                self._codegen_error(
+                    node,
+                    "request.security timeframe switch case could not be resolved at setup",
+                )
+            condition = (
+                f"(({selector}) == ({case}))" if selector is not None else case
+            )
+            result = f"(({condition}) ? ({value}) : ({result}))"
+        return result
+
     def _substitute_tf_input_reads(self, node, resolving: set[str]):
         """Return ``node`` with input-derived leaves rewritten to expressions
         that are valid at security-registration time (before ``on_bar()``
@@ -175,12 +271,24 @@ class SecurityEmitter:
         if isinstance(node, Identifier):
             name = node.name
             if name in self._timeframe_period_vars:
-                return MemberAccess(object=Identifier(name="timeframe"), member="period")
-            if name in self._input_backed_vars and name in self._input_var_to_call:
+                return MemberAccess(
+                    object=Identifier(name="timeframe", loc=node.loc),
+                    member="period",
+                    loc=node.loc,
+                    annotations=node.annotations,
+                )
+            if (name in self._input_backed_vars
+                    and name in self._input_var_to_call
+                    and not self._known_var_is_lexically_shadowed(name)):
                 return self._input_var_to_call[name]
             if (name in self._known_vars and name not in self._input_backed_vars
+                    and not self._known_var_is_lexically_shadowed(name)
                     and isinstance(self._known_vars[name], str)):
-                return StringLiteral(value=self._known_vars[name])
+                return StringLiteral(
+                    value=self._known_vars[name],
+                    loc=node.loc,
+                    annotations=node.annotations,
+                )
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
             if name in global_expr_map and name not in resolving:
                 return self._substitute_tf_input_reads(
@@ -192,18 +300,18 @@ class SecurityEmitter:
             fv = self._substitute_tf_input_reads(node.false_val, resolving)
             if cond is node.condition and tv is node.true_val and fv is node.false_val:
                 return node
-            return Ternary(condition=cond, true_val=tv, false_val=fv)
+            return replace(node, condition=cond, true_val=tv, false_val=fv)
         if isinstance(node, BinOp):
             left = self._substitute_tf_input_reads(node.left, resolving)
             right = self._substitute_tf_input_reads(node.right, resolving)
             if left is node.left and right is node.right:
                 return node
-            return BinOp(left=left, op=node.op, right=right)
+            return replace(node, left=left, right=right)
         if isinstance(node, UnaryOp):
             operand = self._substitute_tf_input_reads(node.operand, resolving)
             if operand is node.operand:
                 return node
-            return UnaryOp(op=node.op, operand=operand)
+            return replace(node, operand=operand)
         if isinstance(node, FuncCall):
             new_args = [self._substitute_tf_input_reads(a, resolving) for a in node.args]
             new_kwargs = {
@@ -217,13 +325,19 @@ class SecurityEmitter:
             )
             if unchanged:
                 return node
-            return FuncCall(callee=node.callee, args=new_args, kwargs=new_kwargs)
+            # Preserve the source span and annotations of the original call.
+            # Namespace/receiver resolution uses that provenance to decide
+            # whether a same-named global binding was visible at this call's
+            # source position.  Rebuilding a bare FuncCall here used to turn
+            # the span into synthetic 1:1 and could let a later ``map`` global
+            # capture this earlier built-in ``map.get(...)``.
+            return replace(node, args=new_args, kwargs=new_kwargs)
         if isinstance(node, Subscript):
             obj = self._substitute_tf_input_reads(node.object, resolving)
             idx = self._substitute_tf_input_reads(node.index, resolving)
             if obj is node.object and idx is node.index:
                 return node
-            return Subscript(object=obj, index=idx)
+            return replace(node, object=obj, index=idx)
         return node
 
     def _resolve_param_tf_from_callsites(self, func_name: str, param_name: str):
@@ -275,6 +389,9 @@ class SecurityEmitter:
                 "expr_node": item.expression,
                 "returns_tuple": item.returns_tuple,
                 "tuple_size": item.tuple_size,
+                "tuple_element_types": tuple(
+                    getattr(item, "tuple_element_types", ()) or ()
+                ),
                 "gaps_node": item.gaps,
                 "lookahead_node": item.lookahead,
                 "ta_range": item.ta_range,
@@ -291,6 +408,7 @@ class SecurityEmitter:
             "expr_node": item[2] if len(item) > 2 else None,
             "returns_tuple": item[3] if len(item) > 3 else False,
             "tuple_size": item[4] if len(item) > 4 else 0,
+            "tuple_element_types": (),
             "gaps_node": item[5] if len(item) > 5 else None,
             "lookahead_node": item[6] if len(item) > 6 else None,
             "ta_range": item[7] if len(item) > 7 else None,
@@ -371,6 +489,22 @@ class SecurityEmitter:
         name: str,
         helper_binding_stack: tuple[dict[str, ASTNode], ...] | None,
     ):
+        resolved = self._security_lookup_helper_binding_context(
+            name, helper_binding_stack
+        )
+        return resolved[0] if resolved is not None else None
+
+    def _security_lookup_helper_binding_context(
+        self,
+        name: str,
+        helper_binding_stack: tuple[dict[str, ASTNode], ...] | None,
+    ):
+        """Return ``(bound_value, lexical_stack_for_value)``.
+
+        Ordinary helper-local bindings are authored in the current stack.
+        Callee argument bindings are authored in the caller stack captured by
+        ``_SecurityHelperArgumentFrame`` and must be expanded there.
+        """
         if not helper_binding_stack:
             return None
         for frame in reversed(helper_binding_stack):
@@ -379,7 +513,12 @@ class SecurityEmitter:
             bound = frame[name]
             if isinstance(bound, Identifier) and bound.name == name:
                 continue
-            return bound
+            lexical_stack = (
+                frame.caller_stack
+                if isinstance(frame, _SecurityHelperArgumentFrame)
+                else helper_binding_stack
+            )
+            return bound, lexical_stack
         return None
 
     def _literal_int_for_security_index(self, node) -> int | None:
@@ -402,11 +541,11 @@ class SecurityEmitter:
             return None
         return None
 
-    # In PineForge batch backtests these barstate flags are compile-time
-    # constants (see support_checker / codegen.visit_expr barstate emission):
-    # every bar is historical, none realtime/last. The other flags
-    # (isfirst/isnew/isconfirmed) depend on runtime tick state, so they are
-    # deliberately absent and leave a fold "unknown".
+    # Narrow approximations used only while resolving a request.security()
+    # history index to a literal. This is not chart-scope barstate lowering:
+    # visit_expr emits runtime state for islast/islastconfirmedhistory, whereas
+    # this security-index folder currently treats them as false. Other flags
+    # (isfirst/isnew/isconfirmed) remain unknown and are deliberately absent.
     _SECURITY_CONST_BARSTATE = {
         "isrealtime": False,
         "islast": False,
@@ -422,10 +561,10 @@ class SecurityEmitter:
     ) -> bool | None:
         """Fold a boolean expression to a compile-time constant, or None.
 
-        Only reduces expressions whose non-literal leaves are the batch-constant
-        barstate flags above; anything runtime-dependent returns None. Used to
-        resolve a request.security history index expressed as
-        ``barstate.isrealtime ? 1 : 0`` and friends."""
+        Only reduces expressions whose non-literal leaves have a narrow
+        request.security history-index approximation above; anything else
+        returns None. Used to resolve a request.security history index
+        expressed as ``barstate.isrealtime ? 1 : 0`` and friends."""
         if resolving is None:
             resolving = set()
         if isinstance(node, BoolLiteral):
@@ -452,16 +591,33 @@ class SecurityEmitter:
                 return None
             return (left and right) if node.op == "and" else (left or right)
         if isinstance(node, Identifier):
-            bound = self._security_lookup_helper_binding(node.name, helper_binding_stack)
-            if bound is not None:
+            binding = None
+            if not self._security_identifier_is_global_binding(node):
+                binding = self._security_lookup_helper_binding_context(
+                    node.name, helper_binding_stack
+                )
+            if binding is not None:
+                bound, bound_stack = binding
+                if isinstance(bound, str):
+                    return None
                 return self._fold_security_const_bool(
-                    bound, helper_binding_stack, resolving
+                    bound, bound_stack, resolving
+                )
+            param_key = f"param:{id(node)}"
+            param_binding = self._security_index_param_callsite_binding(node)
+            if param_binding is not None and param_key not in resolving:
+                return self._fold_security_const_bool(
+                    param_binding, (), resolving | {param_key}
                 )
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
-            if node.name in global_expr_map and node.name not in resolving:
+            if (
+                self._security_identifier_is_global_binding(node)
+                and node.name in global_expr_map
+                and node.name not in resolving
+            ):
                 resolving.add(node.name)
                 out = self._fold_security_const_bool(
-                    global_expr_map[node.name], helper_binding_stack, resolving
+                    global_expr_map[node.name], (), resolving
                 )
                 resolving.remove(node.name)
                 return out
@@ -477,27 +633,44 @@ class SecurityEmitter:
 
         Extends ``_literal_int_for_security_index`` by also resolving the index
         through helper-parameter bindings and global aliases and constant-folding
-        a ternary whose condition is a batch-constant barstate flag (e.g.
-        ``idxHigher = barstate.isrealtime ? 1 : 0`` -> 0). A literal index short-
-        circuits on the first line, so behaviour is unchanged for every already-
-        literal index. Returns None when the index cannot be reduced to a
-        compile-time literal, so the caller keeps its existing rejection."""
+        a ternary whose condition has a security-index barstate approximation
+        (e.g. ``idxHigher = barstate.isrealtime ? 1 : 0`` -> 0). A literal index
+        short-circuits on the first line, so behaviour is unchanged for every
+        already-literal index. Returns None when the index cannot be reduced to
+        a compile-time literal, so the caller keeps its existing rejection."""
         direct = self._literal_int_for_security_index(node)
         if direct is not None:
             return direct
         if resolving is None:
             resolving = set()
         if isinstance(node, Identifier):
-            bound = self._security_lookup_helper_binding(node.name, helper_binding_stack)
-            if bound is not None:
+            binding = None
+            if not self._security_identifier_is_global_binding(node):
+                binding = self._security_lookup_helper_binding_context(
+                    node.name, helper_binding_stack
+                )
+            if binding is not None:
+                bound, bound_stack = binding
+                if isinstance(bound, str):
+                    return None
                 return self._resolve_security_index_literal(
-                    bound, helper_binding_stack, resolving
+                    bound, bound_stack, resolving
+                )
+            param_key = f"param:{id(node)}"
+            param_binding = self._security_index_param_callsite_binding(node)
+            if param_binding is not None and param_key not in resolving:
+                return self._resolve_security_index_literal(
+                    param_binding, (), resolving | {param_key}
                 )
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
-            if node.name in global_expr_map and node.name not in resolving:
+            if (
+                self._security_identifier_is_global_binding(node)
+                and node.name in global_expr_map
+                and node.name not in resolving
+            ):
                 resolving.add(node.name)
                 out = self._resolve_security_index_literal(
-                    global_expr_map[node.name], helper_binding_stack, resolving
+                    global_expr_map[node.name], (), resolving
                 )
                 resolving.remove(node.name)
                 return out
@@ -512,35 +685,395 @@ class SecurityEmitter:
             )
         return None
 
-    def _collect_security_ohlc_hist_fields(self, node) -> set[str]:
-        """Which security bar fields need HTF history (subscript index >= 1)."""
+    def _security_identifier_is_global_binding(self, node: Identifier) -> bool:
+        """Whether this exact identifier AST resolved to a global binding.
+
+        ``global_expr_map`` is keyed only by spelling.  Consulting it without
+        node provenance lets a UDF parameter, block local, or loop iterator
+        capture a same-named global input after analysis scopes have unwound.
+        """
+        scopes = getattr(self.ctx, "identifier_binding_scopes", {}) or {}
+        return scopes.get(id(node)) == "global"
+
+    def _security_index_param_callsite_binding(self, node: Identifier):
+        """Resolve one UDF parameter index from its call sites, conservatively.
+
+        A request.security evaluator is a class method, so a parameter of the
+        UDF that *contains* the request call is not otherwise in scope there.
+        Reuse the established timeframe-callsite model for the narrow offset
+        case: one call site is exact; several are accepted only for the same
+        literal or the same proven-global identifier.  Mixed bindings fail
+        closed instead of sharing one evaluator across different offsets.
+        """
+        scopes = getattr(self.ctx, "identifier_binding_scopes", {}) or {}
+        scope = scopes.get(id(node))
+        if not isinstance(scope, str) or not scope.startswith("func_"):
+            return None
+        func_name = scope[5:]
+        func_info = self._func_info_map.get(func_name)
+        if (
+            func_info is None
+            or func_info.node is None
+            or node.name not in func_info.node.params
+        ):
+            return None
+        # A parameter is only equal to its call-site argument until the UDF
+        # reassigns it.  Specializing a later ``ta.*[param]`` from the authored
+        # call argument would otherwise ignore legal ``param := ...`` writes
+        # and silently select the wrong requested-context history bar.
+        for child in self._walk_ast(func_info.node):
+            if (
+                isinstance(child, Assignment)
+                and isinstance(child.target, Identifier)
+                and child.target.name == node.name
+            ):
+                return None
+            if isinstance(child, VarDecl) and child.name == node.name:
+                return None
+            if isinstance(child, TupleAssign) and node.name in child.names:
+                return None
+            if isinstance(child, ForStmt) and child.var == node.name:
+                return None
+            if isinstance(child, ForInStmt) and (
+                child.var == node.name or node.name in (child.vars or [])
+            ):
+                return None
+        param_index = list(func_info.node.params).index(node.name)
+        bound_args = []
+        for call in self._walk_ast(self.ctx.ast):
+            if not (
+                isinstance(call, FuncCall)
+                and isinstance(call.callee, Identifier)
+                and call.callee.name == func_name
+            ):
+                continue
+            arg = call.args[param_index] if param_index < len(call.args) else None
+            if node.name in call.kwargs:
+                arg = call.kwargs[node.name]
+            if arg is None:
+                return None
+            bound_args.append(arg)
+        if not bound_args:
+            return None
+
+        first = bound_args[0]
+
+        def equivalent(left, right) -> bool:
+            if isinstance(left, NumberLiteral) and isinstance(right, NumberLiteral):
+                return left.value == right.value
+            if isinstance(left, Identifier) and isinstance(right, Identifier):
+                return (
+                    left.name == right.name
+                    and self._security_identifier_is_global_binding(left)
+                    and self._security_identifier_is_global_binding(right)
+                )
+            return left is right
+
+        if not all(equivalent(first, other) for other in bound_args[1:]):
+            return None
+        return first
+
+    def _resolve_security_immutable_input_int(
+        self,
+        node,
+        helper_binding_stack: tuple[dict[str, ASTNode], ...] | None = None,
+        resolving: set[int] | None = None,
+    ) -> tuple[FuncCall, tuple[dict[str, ASTNode], ...]] | None:
+        """Resolve an immutable security-history offset to its ``input.int``.
+
+        Pine v6 permits a bar-invariant input integer as a history offset.  A
+        request.security TA offset needs special admission because its backing
+        history advances in the requested context, not in chart context.  Keep
+        this proof deliberately narrower than arbitrary ``series int`` support:
+
+        * the leaf must be exactly ``input.int``;
+        * helper-parameter and top-level immutable alias chains are followed;
+        * ``var``/``varip`` or any globally reassigned alias is rejected; and
+        * arithmetic/ternary expressions remain unsupported for now.
+
+        Return the proven input call plus the lexical stack in which that call
+        was authored.  Rendering the original identifier under a helper's
+        stack would let a same-named helper parameter capture a global alias.
+        Crossing ``global_expr_map`` therefore resets the stack to global.
+
+        The generated ``Series`` safely returns ``na`` for insufficient depth;
+        negative runtime overrides are also lowered to ``na`` by the caller.
+        """
+        if resolving is None:
+            resolving = set()
+
+        if isinstance(node, FuncCall):
+            func_name, namespace = self._resolve_callee(node.callee)
+            if namespace == "input" and func_name == "int":
+                return node, tuple(helper_binding_stack or ())
+            return None
+
+        if not isinstance(node, Identifier) or id(node) in resolving:
+            return None
+
+        binding = None
+        if not self._security_identifier_is_global_binding(node):
+            binding = self._security_lookup_helper_binding_context(
+                node.name, helper_binding_stack
+            )
+        if binding is not None:
+            bound, bound_stack = binding
+            if isinstance(bound, str):
+                return None
+            return self._resolve_security_immutable_input_int(
+                bound,
+                bound_stack,
+                resolving | {id(node)},
+            )
+
+        param_binding = self._security_index_param_callsite_binding(node)
+        if param_binding is not None:
+            return self._resolve_security_immutable_input_int(
+                param_binding,
+                (),
+                resolving | {id(node)},
+            )
+
+        # Mutable globals have requested-context state of their own and cannot
+        # be replaced by their authored initializer without changing Pine
+        # semantics.  Reject them before following global_expr_map.
+        if node.name in getattr(self, "_global_mutable_infos", {}):
+            return None
+
+        if not self._security_identifier_is_global_binding(node):
+            return None
+
+        global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
+        if node.name not in global_expr_map:
+            return None
+        return self._resolve_security_immutable_input_int(
+            global_expr_map[node.name],
+            (),
+            resolving | {id(node)},
+        )
+
+    def _compose_security_helper_history_subscript(
+        self,
+        bound,
+        local_index,
+        source_node,
+    ) -> Subscript:
+        """Apply helper-local history to a supported bound bar series.
+
+        The security runtime currently has native requested-context history
+        storage only for direct OHLC/time bar fields.  Keep that support fence
+        explicit instead of emitting a C++ subscript on a scalar expression
+        for bindings such as ``hl2`` or ``ta.ema(...)``.
+        """
+        if isinstance(bound, Subscript):
+            if not (
+                isinstance(bound.object, Identifier)
+                and bound.object.name in SECURITY_BAR_FIELDS
+            ):
+                self._codegen_error(
+                    source_node,
+                    "request.security helper-parameter history currently requires "
+                    "a direct OHLC/time bar-series binding",
+                )
+            bound_idx = self._literal_int_for_security_index(bound.index)
+            local_idx = self._literal_int_for_security_index(local_index)
+            if bound_idx is not None and local_idx is not None:
+                combined_index = NumberLiteral(value=bound_idx + local_idx)
+            else:
+                combined_index = BinOp(
+                    left=bound.index,
+                    op="+",
+                    right=local_index,
+                )
+            return Subscript(object=bound.object, index=combined_index)
+        if isinstance(bound, Identifier) and bound.name in SECURITY_BAR_FIELDS:
+            return Subscript(object=bound, index=local_index)
+        self._codegen_error(
+            source_node,
+            "request.security helper-parameter history currently requires "
+            "a direct OHLC/time bar-series binding",
+        )
+
+    def _collect_security_ohlc_hist_fields(
+        self,
+        node,
+        helper_binding_stack: tuple[dict[str, ASTNode], ...] | None = None,
+        resolving: set[str] | None = None,
+    ) -> set[str]:
+        """Which requested-context bar fields need completed-bar history.
+
+        This is the declaration prepass for ``_build_security_expr``.  It must
+        follow the same helper-argument bindings and offset composition as the
+        emitter; otherwise ``f(close)`` plus ``src[1]`` can emit a history read
+        without declaring, pushing, or clearing its backing Series.
+        """
         out: set[str] = set()
+        if resolving is None:
+            resolving = set()
 
-        def walk(n):
-            if n is None:
+        def walk(n, bindings) -> None:
+            if n is None or isinstance(n, str):
                 return
+
+            if isinstance(n, Identifier):
+                binding = None
+                if not self._security_identifier_is_global_binding(n):
+                    binding = self._security_lookup_helper_binding_context(
+                        n.name, bindings
+                    )
+                if binding is not None:
+                    bound, bound_stack = binding
+                    if not isinstance(bound, str):
+                        key = f"bind:{id(bound)}"
+                        if key not in resolving:
+                            resolving.add(key)
+                            walk(bound, bound_stack)
+                            resolving.remove(key)
+                    return
+                mutable_info = self._global_mutable_infos.get(n.name)
+                if mutable_info is not None and n.name not in resolving:
+                    resolving.add(n.name)
+                    for stmt in getattr(mutable_info, "source_stmts", []) or []:
+                        walk(stmt, bindings)
+                    resolving.remove(n.name)
+                    return
+                global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
+                if (
+                    self._security_identifier_is_global_binding(n)
+                    and n.name in global_expr_map
+                    and n.name not in resolving
+                ):
+                    resolving.add(n.name)
+                    walk(global_expr_map[n.name], ())
+                    resolving.remove(n.name)
+                    return
+
             if isinstance(n, Subscript) and isinstance(n.object, Identifier):
+                binding = None
+                if not self._security_identifier_is_global_binding(n.object):
+                    binding = self._security_lookup_helper_binding_context(
+                        n.object.name, bindings
+                    )
+                if binding is not None:
+                    bound, bound_stack = binding
+                    if not isinstance(bound, str):
+                        local_index = n.index
+                        resolved_local_index = self._resolve_security_index_literal(
+                            n.index, bindings
+                        )
+                        if resolved_local_index is not None:
+                            local_index = NumberLiteral(
+                                value=resolved_local_index
+                            )
+                        walk(
+                            self._compose_security_helper_history_subscript(
+                                bound,
+                                local_index,
+                                n,
+                            ),
+                            bound_stack,
+                        )
+                    return
                 if n.object.name in SECURITY_BAR_FIELDS:
-                    idx = self._literal_int_for_security_index(n.index)
-                    # high[0]/time[0] uses current HTF `bar`; k>=1 reads prior
-                    # completed HTF bars from Series history (filled before push
-                    # in _eval_security_*). Dynamic indices may be >=1 at
-                    # runtime, so they need the same backing Series.
+                    idx = self._resolve_security_index_literal(n.index, bindings)
+                    # field[0] uses the current requested bar; k>=1 reads the
+                    # completed-bar Series. Dynamic indices need that Series too.
                     if idx is None or idx >= 1:
                         out.add(n.object.name)
+                    return
+                global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
+                if (
+                    self._security_identifier_is_global_binding(n.object)
+                    and n.object.name in global_expr_map
+                    and n.object.name not in resolving
+                ):
+                    resolving.add(n.object.name)
+                    walk(
+                        Subscript(
+                            object=global_expr_map[n.object.name],
+                            index=n.index,
+                        ),
+                        bindings,
+                    )
+                    resolving.remove(n.object.name)
+                    return
+
+            if isinstance(n, FuncCall) and isinstance(n.callee, Identifier):
+                func_name = n.callee.name
+                if func_name in self._func_names:
+                    call_key = f"func:{func_name}"
+                    if call_key in resolving:
+                        return
+                    resolving.add(call_key)
+                    plan = self._security_helper_call_plan(n, bindings)
+                    if plan["mode"] == "expr":
+                        walk(plan["expr"], plan["binding_stack"])
+                    else:
+                        local_series_names = set(plan.get("local_series_names", ()))
+                        active: dict[str, object] = {}
+
+                        def walk_stmt(stmt, current: dict[str, object]) -> None:
+                            local_stack = plan["binding_stack"] + (current,)
+                            if isinstance(stmt, VarDecl):
+                                if stmt.value is not None:
+                                    walk(stmt.value, local_stack)
+                                if stmt.name in local_series_names or stmt.is_var:
+                                    current[stmt.name] = self._security_series_binding(
+                                        f"{plan['func_info'].name}:{stmt.name}"
+                                    )
+                                elif stmt.value is not None:
+                                    current[stmt.name] = stmt.value
+                                return
+                            if isinstance(stmt, Assignment):
+                                if stmt.value is not None:
+                                    walk(stmt.value, local_stack)
+                                target = self._get_target_name(stmt.target)
+                                existing = current.get(target) if target is not None else None
+                                if (
+                                    target in local_series_names
+                                    or (
+                                        isinstance(existing, str)
+                                        and self._security_series_binding_target(existing)
+                                        is not None
+                                    )
+                                ):
+                                    current[target] = self._security_series_binding(
+                                        f"{plan['func_info'].name}:{target}"
+                                    )
+                                elif target is not None and stmt.value is not None:
+                                    current[target] = stmt.value
+                                return
+                            if isinstance(stmt, IfStmt):
+                                walk(stmt.condition, local_stack)
+                                body_bindings = dict(current)
+                                for child in stmt.body:
+                                    walk_stmt(child, body_bindings)
+                                else_bindings = dict(current)
+                                for child in stmt.else_body:
+                                    walk_stmt(child, else_bindings)
+
+                        for stmt in plan["body"]:
+                            walk_stmt(stmt, active)
+                        walk(
+                            plan["expr"],
+                            plan["binding_stack"] + (active,),
+                        )
+                    resolving.remove(call_key)
+                    return
+
             if isinstance(n, (list, tuple)):
-                for x in n:
-                    walk(x)
+                for child in n:
+                    walk(child, bindings)
                 return
-            for _k, v in getattr(n, "__dict__", {}).items():
-                if isinstance(v, ASTNode):
-                    walk(v)
-                elif isinstance(v, (list, tuple)):
-                    for x in v:
-                        if isinstance(x, ASTNode):
-                            walk(x)
-
-        walk(node)
+            for value in getattr(n, "__dict__", {}).values():
+                if isinstance(value, ASTNode):
+                    walk(value, bindings)
+                elif isinstance(value, (list, tuple)):
+                    for child in value:
+                        if isinstance(child, ASTNode):
+                            walk(child, bindings)
+
+        walk(node, helper_binding_stack or ())
         return out
 
     def _collect_security_ohlc_hist_fields_for_call(self, item: dict) -> set[str]:
@@ -565,10 +1098,43 @@ class SecurityEmitter:
         return SECURITY_BAR_FIELD_EXPRS.get(field, f"bar.{field}")
 
     @staticmethod
-    def _security_tuple_result_default(cpp_type: str, tuple_size: int) -> str:
-        vals = ", ".join("na<double>()" for _ in range(max(0, tuple_size)))
+    def _security_tuple_result_default(
+        cpp_type: str,
+        tuple_size: int,
+        tuple_element_types: tuple[PineType, ...] = (),
+    ) -> str:
+        is_bool_tuple = (
+            len(tuple_element_types) == tuple_size
+            and tuple_size > 0
+            and all(item == PineType.BOOL for item in tuple_element_types)
+        )
+        default_value = "false" if is_bool_tuple else "na<double>()"
+        vals = ", ".join(
+            default_value for _ in range(max(0, tuple_size))
+        )
         return f"{cpp_type}{{{vals}}}"
 
+    @staticmethod
+    def _security_helper_tuple_cpp_type(
+        tuple_size: int,
+        tuple_element_types: tuple[PineType, ...] = (),
+    ) -> str:
+        """C++ storage type for a supported helper tuple of arbitrary arity.
+
+        Numeric int/float families retain the established double-coercing
+        representation. Homogeneous bool families use real ``bool`` fields so
+        true/false semantics survive the requested-context boundary.
+        """
+        is_bool_tuple = (
+            len(tuple_element_types) == tuple_size
+            and tuple_size > 0
+            and all(item == PineType.BOOL for item in tuple_element_types)
+        )
+        element_cpp_type = "bool" if is_bool_tuple else "double"
+        return "std::tuple<" + ", ".join(
+            element_cpp_type for _ in range(max(0, tuple_size))
+        ) + ">"
+
     def _collect_security_ta_hist_indices(self, node) -> set[int]:
         """Which security TA call-site indices need HTF history (subscript index >= 1).
 
@@ -578,50 +1144,172 @@ class SecurityEmitter:
         per-site ``Series`` filled (gated on ``is_complete``) in
         ``_eval_security_N``. Mirrors ``_collect_security_ohlc_hist_fields`` for
         OHLC offsets. Offset 0 reuses the current committed value (``_secval_*``)
-        and needs no Series, so only index >= 1 registers here."""
+        and needs no Series, so only index >= 1 registers here.  A dynamic
+        index is registered conservatively; the expression emitter separately
+        admits only an immutable ``input.int`` chain and rejects everything
+        else.  This declaration prepass must expand helper/global bindings just
+        like ``_build_security_expr`` or a valid helper-wrapped offset could
+        emit a history read without storage, pushes, or reset."""
         out: set[int] = set()
         global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
+        resolving: set[str] = set()
 
-        def resolve_ta_site(obj, resolving: set[str] | None = None):
+        def resolve_ta_site(obj, bindings, seen: set[str] | None = None):
             """_get_ta_site only matches the literal ta.* FuncCall node by
-            identity; fall back through global_expr_map for an indirect
-            binding (``v = ta.ema(close, 55)`` then ``...v[1]...``), mirroring
-            the same fallback in _build_security_expr's Subscript branch."""
+            identity; fall back through helper/global bindings for an indirect
+            binding (``v = ta.ema(close, 55)`` then ``...v[1]...``)."""
             site = self._get_ta_site(obj)
             if site is not None:
                 return site
             if isinstance(obj, Identifier):
-                if resolving is None:
-                    resolving = set()
-                if obj.name in global_expr_map and obj.name not in resolving:
-                    resolving.add(obj.name)
-                    return resolve_ta_site(global_expr_map[obj.name], resolving)
+                if seen is None:
+                    seen = set()
+                if obj.name in seen:
+                    return None
+                binding = None
+                if not self._security_identifier_is_global_binding(obj):
+                    binding = self._security_lookup_helper_binding_context(
+                        obj.name, bindings
+                    )
+                if binding is not None:
+                    bound, bound_stack = binding
+                    if not isinstance(bound, str):
+                        return resolve_ta_site(
+                            bound, bound_stack, seen | {obj.name}
+                        )
+                if (
+                    self._security_identifier_is_global_binding(obj)
+                    and obj.name in global_expr_map
+                ):
+                    return resolve_ta_site(
+                        global_expr_map[obj.name],
+                        (),
+                        seen | {obj.name},
+                    )
             return None
 
-        def walk(n):
-            if n is None:
+        def walk(n, bindings) -> None:
+            if n is None or isinstance(n, str):
                 return
+
+            if isinstance(n, Identifier):
+                binding = None
+                if not self._security_identifier_is_global_binding(n):
+                    binding = self._security_lookup_helper_binding_context(
+                        n.name, bindings
+                    )
+                if binding is not None:
+                    bound, bound_stack = binding
+                    if not isinstance(bound, str):
+                        key = f"bind:{id(bound)}"
+                        if key not in resolving:
+                            resolving.add(key)
+                            walk(bound, bound_stack)
+                            resolving.remove(key)
+                    return
+                mutable_info = self._global_mutable_infos.get(n.name)
+                if mutable_info is not None and n.name not in resolving:
+                    resolving.add(n.name)
+                    for stmt in getattr(mutable_info, "source_stmts", []) or []:
+                        walk(stmt, bindings)
+                    resolving.remove(n.name)
+                    return
+                if (
+                    self._security_identifier_is_global_binding(n)
+                    and n.name in global_expr_map
+                    and n.name not in resolving
+                ):
+                    resolving.add(n.name)
+                    walk(global_expr_map[n.name], ())
+                    resolving.remove(n.name)
+                    return
+
             if isinstance(n, Subscript):
-                site = resolve_ta_site(n.object)
+                site = resolve_ta_site(n.object, bindings)
                 if site is not None:
-                    idx_lit = self._resolve_security_index_literal(n.index)
-                    if idx_lit is not None and idx_lit >= 1:
+                    idx_lit = self._resolve_security_index_literal(n.index, bindings)
+                    if idx_lit is None or idx_lit >= 1:
                         site_idx = self._ta_index_by_site_id.get(id(site))
                         if site_idx is not None:
                             out.add(site_idx)
+
+            if isinstance(n, FuncCall) and isinstance(n.callee, Identifier):
+                func_name = n.callee.name
+                if func_name in self._func_names:
+                    call_key = f"func:{func_name}"
+                    if call_key in resolving:
+                        return
+                    resolving.add(call_key)
+                    plan = self._security_helper_call_plan(n, bindings)
+                    if plan["mode"] == "expr":
+                        walk(plan["expr"], plan["binding_stack"])
+                    else:
+                        local_series_names = set(
+                            plan.get("local_series_names", ())
+                        )
+                        active: dict[str, object] = {}
+
+                        def walk_stmt(stmt, current: dict[str, object]) -> None:
+                            local_stack = plan["binding_stack"] + (current,)
+                            if isinstance(stmt, VarDecl):
+                                if stmt.value is not None:
+                                    walk(stmt.value, local_stack)
+                                if stmt.name in local_series_names or stmt.is_var:
+                                    current[stmt.name] = self._security_series_binding(
+                                        f"{plan['func_info'].name}:{stmt.name}"
+                                    )
+                                elif stmt.value is not None:
+                                    current[stmt.name] = stmt.value
+                                return
+                            if isinstance(stmt, Assignment):
+                                if stmt.value is not None:
+                                    walk(stmt.value, local_stack)
+                                target = self._get_target_name(stmt.target)
+                                existing = current.get(target) if target else None
+                                if (
+                                    target in local_series_names
+                                    or (
+                                        isinstance(existing, str)
+                                        and self._security_series_binding_target(
+                                            existing
+                                        )
+                                        is not None
+                                    )
+                                ):
+                                    current[target] = self._security_series_binding(
+                                        f"{plan['func_info'].name}:{target}"
+                                    )
+                                elif target is not None and stmt.value is not None:
+                                    current[target] = stmt.value
+                                return
+                            if isinstance(stmt, IfStmt):
+                                walk(stmt.condition, local_stack)
+                                body_bindings = dict(current)
+                                for child in stmt.body:
+                                    walk_stmt(child, body_bindings)
+                                else_bindings = dict(current)
+                                for child in stmt.else_body:
+                                    walk_stmt(child, else_bindings)
+
+                        for stmt in plan["body"]:
+                            walk_stmt(stmt, active)
+                        walk(plan["expr"], plan["binding_stack"] + (active,))
+                    resolving.remove(call_key)
+                    return
+
             if isinstance(n, (list, tuple)):
                 for x in n:
-                    walk(x)
+                    walk(x, bindings)
                 return
             for _k, v in getattr(n, "__dict__", {}).items():
                 if isinstance(v, ASTNode):
-                    walk(v)
+                    walk(v, bindings)
                 elif isinstance(v, (list, tuple)):
                     for x in v:
                         if isinstance(x, ASTNode):
-                            walk(x)
+                            walk(x, bindings)
 
-        walk(node)
+        walk(node, ())
         return out
 
     def _security_ta_hist_series_cpp(self, member_name: str) -> str:
@@ -822,6 +1510,49 @@ class SecurityEmitter:
         security_mutable_names: set[str],
         lines: list[str],
         resolving: set[str] | None = None,
+    ) -> str:
+        """Inline one linear helper against isolated lexical collection state."""
+        saved = (
+            self._current_func_collection_specs,
+            self._current_func_collection_shadows,
+            self._collection_types,
+            self._array_vars,
+            self._map_vars,
+            self._matrix_specs,
+        )
+        self._current_func_collection_specs = {}
+        self._current_func_collection_shadows = set()
+        self._collection_types = dict(self._collection_types)
+        self._array_vars = set(self._array_vars)
+        self._map_vars = set(self._map_vars)
+        self._matrix_specs = dict(self._matrix_specs)
+        try:
+            return self._emit_security_linear_helper_call_scoped(
+                sec_id,
+                plan,
+                ta_results,
+                security_mutable_names,
+                lines,
+                resolving,
+            )
+        finally:
+            (
+                self._current_func_collection_specs,
+                self._current_func_collection_shadows,
+                self._collection_types,
+                self._array_vars,
+                self._map_vars,
+                self._matrix_specs,
+            ) = saved
+
+    def _emit_security_linear_helper_call_scoped(
+        self,
+        sec_id: int,
+        plan: dict,
+        ta_results: dict,
+        security_mutable_names: set[str],
+        lines: list[str],
+        resolving: set[str] | None = None,
     ) -> str:
         if plan["mode"] != "linear":
             self._codegen_error(
@@ -839,8 +1570,18 @@ class SecurityEmitter:
             pad = "    " * indent
             runtime_stack_local = plan["binding_stack"] + (active_bindings,)
 
+            def activate_decl() -> None:
+                spec = self._callable_collection_bindings.get(id(stmt))
+                if spec is None:
+                    inferred = self._type_spec_from_expr(stmt.value)
+                    if (inferred is not None
+                            and inferred.kind in {"array", "map", "matrix"}):
+                        spec = inferred
+                self._activate_callable_collection_binding(stmt.name, spec)
+
             if isinstance(stmt, VarDecl):
-                if stmt.name in local_series_names:
+                is_persistent_var = stmt.is_var
+                if stmt.name in local_series_names or is_persistent_var:
                     binding = active_bindings.get(stmt.name)
                     if binding is None:
                         binding = self._security_series_binding(
@@ -859,13 +1600,53 @@ class SecurityEmitter:
                         lines,
                     )
                     active_bindings[stmt.name] = binding
-                    lines.append(f'{pad}if (_security_helper_series_["{series_name}"].size() == 0) {{')
-                    lines.append(f'{pad}    _security_helper_series_["{series_name}"].push({expr_cpp});')
-                    lines.append(f'{pad}}} else if (security_series_slot_is_new({sec_id})) {{')
-                    lines.append(f'{pad}    _security_helper_series_["{series_name}"].push({expr_cpp});')
-                    lines.append(f'{pad}}} else {{')
-                    lines.append(f'{pad}    _security_helper_series_["{series_name}"].update({expr_cpp});')
-                    lines.append(f'{pad}}}')
+                    if is_persistent_var:
+                        cpp_type = self._type_for_decl(stmt)
+                        if cpp_type not in {"double", "int", "bool"}:
+                            self._codegen_error(
+                                stmt,
+                                "request.security helper-local var state currently supports only int, float, and bool values",
+                                hint="Hoist collection, string, UDT, or drawing state outside request.security().",
+                            )
+                        # A Pine ``var`` initializer runs once per helper call
+                        # site in the requested context.  On a new requested
+                        # bar the prior committed value is carried forward; on
+                        # a lookahead/realtime recomputation of the current
+                        # requested bar it rolls back before the helper body is
+                        # evaluated again.  ``Series[1]`` is that rollback
+                        # value after the first bar.  The companion seed entry
+                        # preserves the once-only initializer for first-bar
+                        # recomputations without adding another generated
+                        # member/state family.
+                        seed_name = f"{series_name}@var_seed"
+                        lines.append(f'{pad}if (_security_helper_series_["{series_name}"].size() == 0) {{')
+                        lines.append(f'{pad}    _security_helper_series_["{seed_name}"].push({expr_cpp});')
+                        lines.append(
+                            f'{pad}    _security_helper_series_["{series_name}"].push('
+                            f'_security_helper_series_["{seed_name}"][0]);'
+                        )
+                        lines.append(f'{pad}}} else if (security_series_slot_is_new({sec_id})) {{')
+                        lines.append(
+                            f'{pad}    _security_helper_series_["{series_name}"].push('
+                            f'_security_helper_series_["{series_name}"][0]);'
+                        )
+                        lines.append(f'{pad}}} else {{')
+                        lines.append(
+                            f'{pad}    _security_helper_series_["{series_name}"].update('
+                            f'_security_helper_series_["{series_name}"].size() > 1 '
+                            f'? _security_helper_series_["{series_name}"][1] '
+                            f': _security_helper_series_["{seed_name}"][0]);'
+                        )
+                        lines.append(f'{pad}}}')
+                    else:
+                        lines.append(f'{pad}if (_security_helper_series_["{series_name}"].size() == 0) {{')
+                        lines.append(f'{pad}    _security_helper_series_["{series_name}"].push({expr_cpp});')
+                        lines.append(f'{pad}}} else if (security_series_slot_is_new({sec_id})) {{')
+                        lines.append(f'{pad}    _security_helper_series_["{series_name}"].push({expr_cpp});')
+                        lines.append(f'{pad}}} else {{')
+                        lines.append(f'{pad}    _security_helper_series_["{series_name}"].update({expr_cpp});')
+                        lines.append(f'{pad}}}')
+                    activate_decl()
                     return
 
                 local_name = active_bindings.get(stmt.name)
@@ -900,6 +1681,7 @@ class SecurityEmitter:
                         lines,
                     )
                     lines.append(f"{pad}{local_name} = {expr_cpp};")
+                activate_decl()
                 return
 
             if isinstance(stmt, Assignment):
@@ -956,13 +1738,69 @@ class SecurityEmitter:
                 )
                 lines.append(f"{pad}if ({cond_cpp}) {{")
                 body_bindings = dict(active_bindings)
-                for child in stmt.body:
-                    emit_stmt(child, body_bindings, indent + 1)
+                body_state = (
+                    self._current_func_collection_specs,
+                    self._current_func_collection_shadows,
+                    self._collection_types,
+                    self._array_vars,
+                    self._map_vars,
+                    self._matrix_specs,
+                )
+                self._current_func_collection_specs = dict(
+                    self._current_func_collection_specs
+                )
+                self._current_func_collection_shadows = set(
+                    self._current_func_collection_shadows
+                )
+                self._collection_types = dict(self._collection_types)
+                self._array_vars = set(self._array_vars)
+                self._map_vars = set(self._map_vars)
+                self._matrix_specs = dict(self._matrix_specs)
+                try:
+                    for child in stmt.body:
+                        emit_stmt(child, body_bindings, indent + 1)
+                finally:
+                    (
+                        self._current_func_collection_specs,
+                        self._current_func_collection_shadows,
+                        self._collection_types,
+                        self._array_vars,
+                        self._map_vars,
+                        self._matrix_specs,
+                    ) = body_state
                 if stmt.else_body:
                     lines.append(f"{pad}}} else {{")
                     else_bindings = dict(active_bindings)
-                    for child in stmt.else_body:
-                        emit_stmt(child, else_bindings, indent + 1)
+                    else_state = (
+                        self._current_func_collection_specs,
+                        self._current_func_collection_shadows,
+                        self._collection_types,
+                        self._array_vars,
+                        self._map_vars,
+                        self._matrix_specs,
+                    )
+                    self._current_func_collection_specs = dict(
+                        self._current_func_collection_specs
+                    )
+                    self._current_func_collection_shadows = set(
+                        self._current_func_collection_shadows
+                    )
+                    self._collection_types = dict(self._collection_types)
+                    self._array_vars = set(self._array_vars)
+                    self._map_vars = set(self._map_vars)
+                    self._matrix_specs = dict(self._matrix_specs)
+                    try:
+                        for child in stmt.else_body:
+                            emit_stmt(child, else_bindings, indent + 1)
+                    finally:
+                        (
+                            self._current_func_collection_specs,
+                            self._current_func_collection_shadows,
+                            self._collection_types,
+                            self._array_vars,
+                            self._map_vars,
+                            self._matrix_specs,
+                        ) = else_state
                 lines.append(f"{pad}}}")
                 return
 
@@ -998,7 +1836,7 @@ class SecurityEmitter:
 
         sig_frames = []
         for idx, frame in enumerate(helper_binding_stack):
-            if idx == 0:
+            if idx == 0 or isinstance(frame, _SecurityHelperArgumentFrame):
                 sig_frames.append(
                     tuple((name, _sig_value(node)) for name, node in sorted(frame.items()))
                 )
@@ -1051,8 +1889,14 @@ class SecurityEmitter:
                 "request.security helper calls must bind every parameter explicitly",
             )
 
-        new_frame = {param_name: bound_args[idx] for idx, param_name in enumerate(params)}
         base_stack = helper_binding_stack or ()
+        new_frame = _SecurityHelperArgumentFrame(
+            {
+                param_name: bound_args[idx]
+                for idx, param_name in enumerate(params)
+            },
+            base_stack,
+        )
         return fi, base_stack + (new_frame,)
 
     def _security_helper_call_plan(
@@ -1124,11 +1968,11 @@ class SecurityEmitter:
                     "request.security multi-statement helpers may only use local declarations, assignments, and if-branches before the final expression",
                 )
             if isinstance(stmt, VarDecl):
-                if stmt.is_var or stmt.is_varip:
+                if stmt.is_varip:
                     self._codegen_error(
                         node,
-                        "request.security does not support multi-statement helpers with helper-local var state",
-                        hint="Rewrite helper-local state as plain temporaries or hoist it outside request.security().",
+                        "request.security does not support helper-local varip state",
+                        hint="Use var for requested-context bar state; varip tick state is unavailable in batch backtests.",
                     )
             if isinstance(stmt, Assignment):
                 target_name = self._get_target_name(stmt.target)
@@ -1148,6 +1992,92 @@ class SecurityEmitter:
             "local_series_names": local_series_names,
         }
 
+    def _validate_security_persistent_var_control_flow(self, expr_node) -> None:
+        """Reject helper ``var`` state whose rollback would be conditional.
+
+        Persistent helper state is restored at its declaration before the body
+        mutates it. That is safe only when the declaration executes on every
+        requested-bar evaluation. Until rollback is hoisted to evaluator entry,
+        reject declarations reached through ``if``/``?:``/short-circuit paths,
+        including state owned by a nested helper called from such a path.
+        """
+        call_stack: set[str] = set()
+
+        def visit_expr(node, conditional: bool) -> None:
+            if node is None:
+                return
+            if isinstance(node, FuncCall) and isinstance(node.callee, Identifier):
+                name = node.callee.name
+                if name in self._func_names:
+                    if name in call_stack:
+                        return
+                    fi = self._func_info_map.get(name)
+                    if fi is not None and fi.node is not None:
+                        call_stack.add(name)
+                        for stmt in fi.node.body:
+                            visit_stmt(stmt, conditional)
+                        call_stack.remove(name)
+                    for arg in node.args:
+                        visit_expr(arg, conditional)
+                    for value in node.kwargs.values():
+                        if isinstance(value, ASTNode):
+                            visit_expr(value, conditional)
+                    return
+            if isinstance(node, Ternary):
+                visit_expr(node.condition, conditional)
+                visit_expr(node.true_val, True)
+                visit_expr(node.false_val, True)
+                return
+            if isinstance(node, BinOp) and node.op in ("and", "or"):
+                visit_expr(node.left, conditional)
+                visit_expr(node.right, True)
+                return
+            for value in getattr(node, "__dict__", {}).values():
+                if isinstance(value, ASTNode):
+                    visit_expr(value, conditional)
+                elif isinstance(value, (list, tuple)):
+                    for child in value:
+                        if isinstance(child, ASTNode):
+                            visit_expr(child, conditional)
+
+        def visit_stmt(stmt, conditional: bool) -> None:
+            if isinstance(stmt, VarDecl):
+                if stmt.is_var and conditional:
+                    self._codegen_error(
+                        stmt,
+                        "request.security helper-local var declarations inside "
+                        "conditional control flow are not supported",
+                        hint="Declare persistent requested-context state at the helper's top level.",
+                    )
+                # A persistent initializer runs only when its requested-context
+                # slot is first created.  Any nested persistent helper reached
+                # from that initializer would therefore need its rollback and
+                # mutation to remain inside the same once-only guard.  The
+                # current linear emitter hoists nested helper statements ahead
+                # of that guard, so treat the initializer as conditional and
+                # fail closed until it can preserve that execution boundary.
+                visit_expr(stmt.value, conditional or stmt.is_var)
+                return
+            if isinstance(stmt, IfStmt):
+                visit_expr(stmt.condition, conditional)
+                for child in stmt.body:
+                    visit_stmt(child, True)
+                for child in stmt.else_body:
+                    visit_stmt(child, True)
+                return
+            if isinstance(stmt, ExprStmt):
+                visit_expr(stmt.expr, conditional)
+                return
+            for value in getattr(stmt, "__dict__", {}).values():
+                if isinstance(value, ASTNode):
+                    visit_expr(value, conditional)
+                elif isinstance(value, (list, tuple)):
+                    for child in value:
+                        if isinstance(child, ASTNode):
+                            visit_expr(child, conditional)
+
+        visit_expr(expr_node, False)
+
     def _security_next_inline_name(self, sec_id: int, func_name: str, base_name: str) -> str:
         self._security_inline_counter += 1
         return (
@@ -1168,13 +2098,18 @@ class SecurityEmitter:
             resolving = set()
 
         if isinstance(expr_node, Identifier):
-            bound = self._security_lookup_helper_binding(expr_node.name, helper_binding_stack)
-            if bound is not None:
+            binding = None
+            if not self._security_identifier_is_global_binding(expr_node):
+                binding = self._security_lookup_helper_binding_context(
+                    expr_node.name, helper_binding_stack
+                )
+            if binding is not None:
+                bound, bound_stack = binding
                 return self._expr_depends_on_security_mutables(
                     bound,
                     security_mutable_names,
                     resolving,
-                    helper_binding_stack,
+                    bound_stack,
                 )
             if expr_node.name in security_mutable_names:
                 return True
@@ -1296,16 +2231,180 @@ class SecurityEmitter:
             if idx < len(all_args) and all_args[idx] is not None
         ]
 
+    def _security_ta_ctor_args_for_variant(
+        self,
+        sec_id: int,
+        site: TACallSite,
+        helper_binding_stack: tuple[dict[str, ASTNode], ...] | None,
+        fallback_args: list[str] | None = None,
+    ) -> tuple[list[str], list[bool] | None]:
+        """Resolve TA constructor args in one helper-call lexical context.
+
+        ``TACallSite.ctor_args`` is a source-string snapshot which ordinary
+        callable specialization mutates from the first call site.  A single
+        TA AST can also be reached several times while lowering one
+        ``request.security`` tuple (for example ``ema(src, 2)`` through
+        ``ema(src, 5)``).  Those requested-context variants share the AST but
+        must not share that first snapshot.  Re-lower the constructor AST
+        through the exact helper binding stack used to key the variant.
+
+        Calls outside an inlined helper retain the established string path so
+        input-backed runtime resets and direct top-level TA sites stay
+        byte-compatible.  The optional boolean list records, per argument,
+        whether the source AST is a bar-invariant scalar after resolving its
+        exact helper bindings.  Runtime-reset collection uses that provenance
+        to reuse trusted lowered C++ without allowing a mixed input + series
+        expression merely because it contains a generated ``get_input_*`` call.
+        """
+        fallback = list(
+            site.ctor_args if fallback_args is None else fallback_args
+        )
+        if not helper_binding_stack:
+            return fallback, None
+        arg_nodes = self._security_ta_ctor_arg_nodes(site)
+        if len(arg_nodes) != len(fallback):
+            return fallback, None
+        return (
+            [
+                self._build_security_expr(
+                    sec_id,
+                    arg,
+                    None,
+                    {},
+                    resolving=set(),
+                    security_mutable_names=set(),
+                    helper_binding_stack=helper_binding_stack,
+                    emitted_lines=None,
+                )
+                for arg in arg_nodes
+            ],
+            [
+                self._security_ta_ctor_arg_is_stable(
+                    arg,
+                    helper_binding_stack,
+                )
+                for arg in arg_nodes
+            ],
+        )
+
+    def _security_ta_ctor_arg_is_stable(
+        self,
+        node: ASTNode,
+        helper_binding_stack: tuple[dict[str, ASTNode], ...] | None,
+    ) -> bool:
+        """Classify one helper-bound requested-context TA constructor arg.
+
+        ``_expr_is_stable`` already owns the compiler's conservative definition
+        of a per-run scalar.  Resolve helper parameters first, preserving the
+        authored AST shape, and then delegate to that shared classifier.  This
+        prevents a later helper call such as ``ema(src, inputLen + int(close))``
+        from bypassing the ordinary TA-length guard just because an earlier
+        call through the same source TA site used a safe length.
+        """
+        import dataclasses
+
+        def resolve(
+            current,
+            stack: tuple[dict[str, ASTNode], ...] | None,
+            seen: frozenset[tuple[str, int]] = frozenset(),
+            depth: int = 0,
+        ):
+            if current is None or depth > 32:
+                return None
+            if isinstance(current, Identifier):
+                binding = None
+                if not self._security_identifier_is_global_binding(current):
+                    binding = self._security_lookup_helper_binding_context(
+                        current.name,
+                        stack,
+                    )
+                if binding is None:
+                    return current
+                bound, bound_stack = binding
+                if isinstance(bound, str):
+                    return None
+                key = (current.name, id(bound))
+                if key in seen:
+                    return None
+                return resolve(
+                    bound,
+                    bound_stack,
+                    seen | {key},
+                    depth + 1,
+                )
+            if isinstance(
+                current,
+                (NumberLiteral, StringLiteral, BoolLiteral, NaLiteral),
+            ):
+                return current
+            if isinstance(current, MemberAccess):
+                obj = resolve(current.object, stack, seen, depth + 1)
+                if obj is None:
+                    return None
+                return dataclasses.replace(current, object=obj)
+            if isinstance(current, BinOp):
+                left = resolve(current.left, stack, seen, depth + 1)
+                right = resolve(current.right, stack, seen, depth + 1)
+                if left is None or right is None:
+                    return None
+                return dataclasses.replace(current, left=left, right=right)
+            if isinstance(current, UnaryOp):
+                operand = resolve(current.operand, stack, seen, depth + 1)
+                if operand is None:
+                    return None
+                return dataclasses.replace(current, operand=operand)
+            if isinstance(current, Ternary):
+                condition = resolve(current.condition, stack, seen, depth + 1)
+                true_val = resolve(current.true_val, stack, seen, depth + 1)
+                false_val = resolve(current.false_val, stack, seen, depth + 1)
+                if condition is None or true_val is None or false_val is None:
+                    return None
+                return dataclasses.replace(
+                    current,
+                    condition=condition,
+                    true_val=true_val,
+                    false_val=false_val,
+                )
+            if isinstance(current, FuncCall):
+                args = [resolve(arg, stack, seen, depth + 1) for arg in current.args]
+                kwargs = {
+                    name: resolve(arg, stack, seen, depth + 1)
+                    for name, arg in current.kwargs.items()
+                }
+                if any(arg is None for arg in args) or any(
+                    arg is None for arg in kwargs.values()
+                ):
+                    return None
+                return dataclasses.replace(current, args=args, kwargs=kwargs)
+            # History, collections, and every other unhandled shape are not
+            # stable TA lengths.  Fail closed instead of inventing a buffer size.
+            return None
+
+        resolved = resolve(node, helper_binding_stack)
+        return resolved is not None and self._expr_is_stable(resolved)
+
     def _security_ta_ctor_depends_on_mutables(
         self,
         site: TACallSite,
         security_mutable_names: set[str],
         helper_binding_stack: tuple[dict[str, ASTNode], ...] | None = None,
     ) -> bool:
+        # A top-level ``var int L = 5`` is normally classified as mutable by
+        # request.security because persistent state is rebound per requested
+        # context.  The TA constructor does not read that mutable member when
+        # ``L`` passed the declaration-exact stable-literal admission proof:
+        # all main/requested-context buffers are sized directly from ``5``.
+        # Remove only those admitted names for this ctor-dependency query.
+        # Compute arguments and every other security mutability path retain
+        # the full set, and helper bindings still resolve transitively before
+        # checking the reduced set.
+        ctor_mutable_names = security_mutable_names.difference(
+            getattr(self, "_stable_var_ctor_literals", {})
+        )
         return any(
             self._expr_depends_on_security_mutables(
                 arg,
-                security_mutable_names,
+                ctor_mutable_names,
                 helper_binding_stack=helper_binding_stack,
             )
             for arg in self._security_ta_ctor_arg_nodes(site)
@@ -1328,8 +2427,13 @@ class SecurityEmitter:
             resolving = set()
 
         if isinstance(expr_node, Identifier):
-            bound = self._security_lookup_helper_binding(expr_node.name, helper_binding_stack)
-            if bound is not None:
+            binding = None
+            if not self._security_identifier_is_global_binding(expr_node):
+                binding = self._security_lookup_helper_binding_context(
+                    expr_node.name, helper_binding_stack
+                )
+            if binding is not None:
+                bound, bound_stack = binding
                 if isinstance(bound, str):
                     return collected
                 # Guard against a cyclic helper binding: an identifier bound to
@@ -1345,7 +2449,7 @@ class SecurityEmitter:
                 self._collect_security_ta_binding_stacks(
                     bound,
                     resolving,
-                    helper_binding_stack,
+                    bound_stack,
                     collected,
                     inline_ta_indices,
                     inline_helper,
@@ -1369,12 +2473,16 @@ class SecurityEmitter:
                 return collected
 
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
-            if expr_node.name in global_expr_map and expr_node.name not in resolving:
+            if (
+                self._security_identifier_is_global_binding(expr_node)
+                and expr_node.name in global_expr_map
+                and expr_node.name not in resolving
+            ):
                 resolving.add(expr_node.name)
                 self._collect_security_ta_binding_stacks(
                     global_expr_map[expr_node.name],
                     resolving,
-                    helper_binding_stack,
+                    (),
                     collected,
                     inline_ta_indices,
                     inline_helper,
@@ -1736,6 +2844,156 @@ class SecurityEmitter:
         )
         return out
 
+    def _security_lazy_ta_keys(
+        self,
+        sec_id: int,
+        expr_node,
+        info: dict,
+    ) -> set[tuple[int, tuple]]:
+        """``(ta_index, binding_signature)`` pairs Pine reaches only lazily.
+
+        Pine evaluates ``and``/``or`` with left-to-right short-circuit and a
+        ternary evaluates its condition plus exactly one branch. A ``ta.*``
+        call sitting in a skipped operand is **not evaluated on that bar**, so
+        its series state does not advance. The evaluator used to hoist every
+        collected site into an unconditional ``auto _secval_N = ...compute(...)``
+        prologue, which advanced every site on every HTF bar and desynchronised
+        the series against TradingView.
+
+        A site returned here is dropped from that prologue. ``_build_security_expr``
+        then falls through to its inline
+        ``(security_series_slot_is_new(N) ? m.compute(a) : m.recompute(a))``
+        form, emitted in expression position — C++'s own ``&&`` / ``||`` /
+        ``?:`` short-circuit then advances the state exactly when Pine would,
+        and the relational lowering's ``_pna_l`` / ``_pna_r`` temporaries keep
+        the evaluation order left-to-right.
+
+        Deliberately conservative — anything not provably single-reach and
+        conditional keeps the existing eager hoist, so scripts without
+        conditional security TA regenerate byte-identically:
+
+        - A site reached more than once must stay hoisted: sharing one
+          ``_secval_*`` is what keeps it to a single advance per bar, whereas
+          two inline copies would advance it twice (or zero times).
+        - Laziness does **not** propagate through a global binding. In the
+          requested context that global is its own unconditional top-level
+          statement, so it evaluates on every HTF bar wherever it is read
+          (this is what keeps chart-side ``t0``-shaped code exact).
+        - Sites with a history offset (``ta.ema(close, 55)[1]``) keep the
+          committed ``_secval_*`` their per-bar Series push reads.
+        - Securities that rebind mutable globals, and multi-statement helper
+          calls, bail entirely: both lower through statement emitters that
+          consume ``ta_results`` outside this expression.
+        """
+        if info.get("mutable_globals"):
+            return set()
+
+        occurrences: dict[tuple[int, tuple], list[bool]] = {}
+        unsafe = False
+
+        def walk(node, lazy: bool, binding_stack, resolving: set[str]) -> None:
+            nonlocal unsafe
+            if node is None or unsafe:
+                return
+
+            if isinstance(node, Identifier):
+                binding = None
+                if not self._security_identifier_is_global_binding(node):
+                    binding = self._security_lookup_helper_binding_context(
+                        node.name, binding_stack
+                    )
+                if binding is not None:
+                    bound, bound_stack = binding
+                    if isinstance(bound, str):
+                        return
+                    bind_key = f"bind:{id(bound)}"
+                    if bind_key in resolving:
+                        return
+                    resolving.add(bind_key)
+                    walk(bound, lazy, bound_stack, resolving)
+                    resolving.discard(bind_key)
+                    return
+
+                if self._global_mutable_infos.get(node.name) is not None:
+                    unsafe = True
+                    return
+
+                global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
+                if (
+                    self._security_identifier_is_global_binding(node)
+                    and node.name in global_expr_map
+                    and node.name not in resolving
+                ):
+                    resolving.add(node.name)
+                    walk(global_expr_map[node.name], False, (), resolving)
+                    resolving.remove(node.name)
+                    return
+
+            if isinstance(node, FuncCall) and isinstance(node.callee, Identifier):
+                func_name = node.callee.name
+                if func_name in self._func_names:
+                    call_key = f"func:{func_name}"
+                    if call_key in resolving:
+                        return
+                    resolving.add(call_key)
+                    plan = self._security_helper_call_plan(node, binding_stack)
+                    if plan["mode"] == "expr":
+                        walk(plan["expr"], lazy, plan["binding_stack"], resolving)
+                    else:
+                        unsafe = True
+                    resolving.discard(call_key)
+                    return
+
+            if isinstance(node, BinOp) and node.op in ("and", "or"):
+                walk(node.left, lazy, binding_stack, resolving)
+                walk(node.right, True, binding_stack, resolving)
+                return
+
+            if isinstance(node, Ternary):
+                walk(node.condition, lazy, binding_stack, resolving)
+                walk(node.true_val, True, binding_stack, resolving)
+                walk(node.false_val, True, binding_stack, resolving)
+                return
+
+            site = self._get_ta_site(node)
+            if site is not None:
+                idx = self._ta_index_by_site_id.get(id(site))
+                if idx is not None:
+                    key = (idx, self._security_binding_stack_signature(binding_stack))
+                    occurrences.setdefault(key, []).append(lazy)
+
+            for child in vars(node).values():
+                walk_value(child, lazy, binding_stack, resolving)
+
+        def walk_value(value, lazy: bool, binding_stack, resolving: set[str]) -> None:
+            if value is None or unsafe:
+                return
+            if hasattr(value, "__dict__"):
+                walk(value, lazy, binding_stack, resolving)
+                return
+            if isinstance(value, (list, tuple)):
+                for item in value:
+                    walk_value(item, lazy, binding_stack, resolving)
+                return
+            if isinstance(value, dict):
+                for item in value.values():
+                    walk_value(item, lazy, binding_stack, resolving)
+
+        walk(expr_node, False, (), set())
+        if unsafe:
+            return set()
+
+        hist_indices = set(self._security_ta_hist_idx_by_sec.get(sec_id, ()))
+        inline_helper_ta_indices = set(info.get("inline_helper_ta_indices", []))
+        return {
+            key
+            for key, reaches in occurrences.items()
+            if key[0] not in hist_indices
+            and key[0] not in inline_helper_ta_indices
+            and len(reaches) == 1
+            and reaches[0]
+        }
+
     def _emit_security_ohlc_hist_pushes(self, sec_id: int, lines: list[str]) -> None:
         """Emit the OHLC history-offset Series pushes for ``sec_id``, gated on
         ``is_complete``.
@@ -1801,6 +3059,7 @@ class SecurityEmitter:
             ta_indices = info.get("ta_indices") or []
             security_mutable_names = set(info.get("mutable_globals", []))
             inline_helper_ta_indices = set(info.get("inline_helper_ta_indices", []))
+            lazy_ta_keys = self._security_lazy_ta_keys(sec_id, expr_node, info)
 
             lines.append(f"    void _eval_security_{sec_id}(const Bar& bar, bool is_complete) {{")
 
@@ -1841,6 +3100,15 @@ class SecurityEmitter:
                     site = self.ctx.ta_call_sites[idx]
                     variants = (info.get("ta_variants") or {}).get(idx, [])
                     for variant in variants:
+                        if (idx, variant["signature"]) in lazy_ta_keys:
+                            # Pine only reaches this site through a
+                            # short-circuited operand or an untaken ternary
+                            # branch. Leave it out of the eager prologue:
+                            # _build_security_expr emits its
+                            # compute()/recompute() inline in expression
+                            # position, where C++'s &&/||/?: short-circuit
+                            # advances the series exactly on the bars Pine does.
+                            continue
                         helper_binding_stack = variant.get("binding_stack", ())
                         compute_args = self._security_ta_compute_args_for_site(
                             sec_id,
@@ -1993,11 +3261,17 @@ class SecurityEmitter:
                     "bb": "ta::BBResult",
                     "kc": "ta::KCResult",
                     "vwap_bands": "ta::VWAPBandsResult",
-                }.get(ta_name, "std::tuple<double, double>")
+                }.get(
+                    ta_name,
+                    self._security_helper_tuple_cpp_type(
+                        tuple_size,
+                        item.get("tuple_element_types", ()),
+                    ),
+                )
                 lines.append(f"            case {sec_id}:")
                 lines.append(
                     f"                _req_sec_{sec_id} = "
-                    f"{self._security_tuple_result_default(ctype, tuple_size)};"
+                    f"{self._security_tuple_result_default(ctype, tuple_size, item.get('tuple_element_types', ()))};"
                 )
                 for field in sorted(self._security_ohlc_hist_fields_by_sec.get(sec_id, ())):
                     lines.append(
@@ -2052,8 +3326,13 @@ class SecurityEmitter:
             helper_binding_stack = ()
 
         if isinstance(expr_node, Identifier):
-            bound = self._security_lookup_helper_binding(expr_node.name, helper_binding_stack)
-            if bound is not None:
+            binding = None
+            if not self._security_identifier_is_global_binding(expr_node):
+                binding = self._security_lookup_helper_binding_context(
+                    expr_node.name, helper_binding_stack
+                )
+            if binding is not None:
+                bound, bound_stack = binding
                 if isinstance(bound, str):
                     series_name = self._security_series_binding_target(bound)
                     if series_name is not None:
@@ -2066,7 +3345,7 @@ class SecurityEmitter:
                     ta_results,
                     resolving,
                     security_mutable_names,
-                    helper_binding_stack,
+                    bound_stack,
                     emitted_lines,
                 )
             bar_fields = {
@@ -2086,7 +3365,11 @@ class SecurityEmitter:
                 return state_name
 
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
-            if expr_node.name in global_expr_map and expr_node.name not in resolving:
+            if (
+                self._security_identifier_is_global_binding(expr_node)
+                and expr_node.name in global_expr_map
+                and expr_node.name not in resolving
+            ):
                 resolving.add(expr_node.name)
                 resolved = self._build_security_expr(
                     sec_id,
@@ -2095,7 +3378,7 @@ class SecurityEmitter:
                     ta_results,
                     resolving,
                     security_mutable_names,
-                    helper_binding_stack,
+                    (),
                     emitted_lines,
                 )
                 resolving.remove(expr_node.name)
@@ -2111,38 +3394,60 @@ class SecurityEmitter:
                 return resolved
 
         if isinstance(expr_node, Subscript):
-            index_cpp = self._build_security_expr(
-                sec_id,
-                expr_node.index,
-                ta_range,
-                ta_results,
-                resolving,
-                security_mutable_names,
-                helper_binding_stack,
-                emitted_lines,
-            )
             if isinstance(expr_node.object, Identifier):
-                bound = self._security_lookup_helper_binding(expr_node.object.name, helper_binding_stack)
-                if bound is not None:
+                binding = None
+                if not self._security_identifier_is_global_binding(expr_node.object):
+                    binding = self._security_lookup_helper_binding_context(
+                        expr_node.object.name, helper_binding_stack
+                    )
+                if binding is not None:
+                    bound, bound_stack = binding
                     if isinstance(bound, str):
                         series_name = self._security_series_binding_target(bound)
                         if series_name is not None:
+                            index_cpp = self._build_security_expr(
+                                sec_id,
+                                expr_node.index,
+                                ta_range,
+                                ta_results,
+                                resolving,
+                                security_mutable_names,
+                                helper_binding_stack,
+                                emitted_lines,
+                            )
                             return f'_security_helper_series_["{series_name}"][{index_cpp}]'
                         return bound
-                    obj_cpp = self._build_security_expr(
-                        sec_id,
+                    # Function parameters retain Pine's series identity. Apply
+                    # history to the supported bound bar series and compose
+                    # nested offsets before lowering. Unsupported scalar/
+                    # expression bindings fail closed in the shared helper.
+                    local_index = expr_node.index
+                    resolved_local_index = self._resolve_security_index_literal(
+                        expr_node.index, helper_binding_stack
+                    )
+                    if resolved_local_index is not None:
+                        local_index = NumberLiteral(value=resolved_local_index)
+                    composed = self._compose_security_helper_history_subscript(
                         bound,
+                        local_index,
+                        expr_node,
+                    )
+                    return self._build_security_expr(
+                        sec_id,
+                        composed,
                         ta_range,
                         ta_results,
                         resolving,
                         security_mutable_names,
-                        helper_binding_stack,
+                        bound_stack,
                         emitted_lines,
                     )
-                    return f"{obj_cpp}[{index_cpp}]"
                 if expr_node.object.name in SECURITY_BAR_FIELDS:
                     field = expr_node.object.name
-                    idx_lit = self._literal_int_for_security_index(expr_node.index)
+                    idx_lit = self._resolve_security_index_literal(
+                        expr_node.index,
+                        helper_binding_stack,
+                    )
                     if idx_lit is not None:
                         if idx_lit == 0:
                             return self._security_bar_field_expr(field)
@@ -2162,6 +3467,16 @@ class SecurityEmitter:
                     hist = self._security_ohlc_hist_series_cpp(sec_id, field)
                     cpp_t = self._security_bar_hist_type(field)
                     current = self._security_bar_field_expr(field)
+                    index_cpp = self._build_security_expr(
+                        sec_id,
+                        expr_node.index,
+                        ta_range,
+                        ta_results,
+                        resolving,
+                        security_mutable_names,
+                        helper_binding_stack,
+                        emitted_lines,
+                    )
                     return (
                         f"([&]() -> {cpp_t} {{ "
                         f"int _hidx = (int)({index_cpp}); "
@@ -2181,8 +3496,11 @@ class SecurityEmitter:
                 # helper binding, whichever the resolved expression turns out
                 # to be) instead of duplicating that dispatch here.
                 global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
-                if (expr_node.object.name in global_expr_map
-                        and expr_node.object.name not in resolving):
+                if (
+                    self._security_identifier_is_global_binding(expr_node.object)
+                    and expr_node.object.name in global_expr_map
+                    and expr_node.object.name not in resolving
+                ):
                     resolving.add(expr_node.object.name)
                     resolved = self._build_security_expr(
                         sec_id,
@@ -2203,6 +3521,16 @@ class SecurityEmitter:
                 meta = self._security_expr_hist_by_node.get((sec_id, id(expr_node)))
                 hist = meta["name"] if meta else f"_sec{sec_id}_expr_hist_missing"
                 cpp_t = meta["type"] if meta else "double"
+                index_cpp = self._build_security_expr(
+                    sec_id,
+                    expr_node.index,
+                    ta_range,
+                    ta_results,
+                    resolving,
+                    security_mutable_names,
+                    helper_binding_stack,
+                    emitted_lines,
+                )
                 inner = self._build_security_expr(
                     sec_id,
                     expr_node.object,
@@ -2234,14 +3562,72 @@ class SecurityEmitter:
                 # tick), so without a magnifier it advanced every chart bar and
                 # produced the chart-tf TA instead of the confirmed HTF value.
                 idx = self._ta_index_by_site_id.get(id(ta_site))
-                sig = self._security_binding_stack_signature(helper_binding_stack)
+                # A top-level TA site reached through a global alias owns the
+                # global variant even when the subscript index was authored
+                # in a helper.  Keep the helper stack for resolving that
+                # index, but do not use it to select the TA object's state.
+                ta_binding_stack = (
+                    ()
+                    if getattr(ta_site, "owner_func", None) is None
+                    else helper_binding_stack
+                )
+                sig = self._security_binding_stack_signature(ta_binding_stack)
                 idx_lit = self._resolve_security_index_literal(
                     expr_node.index, helper_binding_stack
                 )
                 if idx_lit is None:
+                    resolved_input = self._resolve_security_immutable_input_int(
+                        expr_node.index, helper_binding_stack
+                    )
+                    if resolved_input is None:
+                        self._codegen_error(
+                            expr_node,
+                            "request.security() TA history index must be a literal integer (e.g. ta.ema(close, 55)[1])",
+                        )
+                    input_node, input_stack = resolved_input
+                    index_cpp = self._build_security_expr(
+                        sec_id,
+                        input_node,
+                        ta_range,
+                        ta_results,
+                        resolving,
+                        security_mutable_names,
+                        input_stack,
+                        emitted_lines,
+                    )
+                    result_key = (idx, sig)
+                    if result_key not in ta_results:
+                        self._codegen_error(
+                            expr_node,
+                            "request.security multi-statement helper TA history is not supported",
+                            hint="Use a single-expression helper for TA history offsets.",
+                        )
+                    current = self._build_security_expr(
+                        sec_id,
+                        expr_node.object,
+                        ta_range,
+                        ta_results,
+                        resolving,
+                        security_mutable_names,
+                        ta_binding_stack,
+                        emitted_lines,
+                    )
+                    member_name = self._security_ta_variant_names.get(
+                        (sec_id, idx, sig),
+                        f"_sec{sec_id}_{ta_site.member_name}",
+                    )
+                    hist = self._security_ta_hist_series_cpp(member_name)
+                    return (
+                        "([&]() -> double { "
+                        f"int _hidx = (int)({index_cpp}); "
+                        "if (is_na(_hidx) || _hidx < 0) return na<double>(); "
+                        f"return (_hidx == 0) ? {current} : {hist}[_hidx - 1]; "
+                        "}())"
+                    )
+                if idx_lit < 0:
                     self._codegen_error(
                         expr_node,
-                        "request.security() TA history index must be a literal integer (e.g. ta.ema(close, 55)[1])",
+                        "request.security() TA history index must be non-negative",
                     )
                 if idx_lit == 0:
                     # Current completed-HTF-bar value: reuse the bare-TA emission.
@@ -2252,9 +3638,15 @@ class SecurityEmitter:
                         ta_results,
                         resolving,
                         security_mutable_names,
-                        helper_binding_stack,
+                        ta_binding_stack,
                         emitted_lines,
                     )
+                if (idx, sig) not in ta_results:
+                    self._codegen_error(
+                        expr_node,
+                        "request.security multi-statement helper TA history is not supported",
+                        hint="Use a single-expression helper for TA history offsets.",
+                    )
                 member_name = self._security_ta_variant_names.get(
                     (sec_id, idx, sig),
                     f"_sec{sec_id}_{ta_site.member_name}",
@@ -2300,6 +3692,28 @@ class SecurityEmitter:
             )
             return f"(({cond}) ? ({tv}) : ({fv}))"
 
+        if isinstance(expr_node, TupleLiteral):
+            # A tuple returned by a user helper must lower every element in the
+            # requested context.  Falling through to the ordinary expression
+            # visitor loses AST-valued helper parameter bindings (for example
+            # ``f(src) => [src, src + 1]``) and can emit an undeclared ``src``.
+            # Recursive lowering also composes helper locals, HTF history, and
+            # TA results for arbitrary supported tuple arity.
+            elements = [
+                self._build_security_expr(
+                    sec_id,
+                    element,
+                    ta_range,
+                    ta_results,
+                    resolving,
+                    security_mutable_names,
+                    helper_binding_stack,
+                    emitted_lines,
+                )
+                for element in expr_node.elements
+            ]
+            return f"std::make_tuple({', '.join(elements)})"
+
         if isinstance(expr_node, FuncCall) and isinstance(expr_node.callee, Identifier):
             func_name = expr_node.callee.name
             if func_name in self._func_names: