@pineforge/codegen-pyodide 0.10.4 → 1.0.0

package/pineforge_codegen/codegen/base.py

@@ -25,10 +25,18 @@ from ..analyzer import (
     TA_MULTI_CTOR,
     TA_NO_CTOR,
     TA_PERIOD_ARG,
+    TA_LENGTH_ONLY_DEFAULT_SOURCE,
 )
 from ..symbols import PineType, TypeSpec, method_receiver_type_name
 from .. import signatures as sigs
 from ..errors import CompileError, Diagnostic, Level, Phase, SourceLocation
+from ..limits import TimeBudget, iter_ast_nodes
+from ..session_reads import emitted_session_reads
+from ..block_locals import block_declarations, decl_key
+from ..pine_spelling import (
+    blank_string_literals, input_call_spans, pine_string_literal,
+    spell_input_call, sub_identifiers,
+)
 
 
 @dataclass(frozen=True)
@@ -79,6 +87,41 @@ from .tables import (
     _merge_kwargs,
 )
 
+# A UDT field of array type. Pine arrays are references: ``T.new(a)`` holds
+# the array ``a`` itself, not a copy. The field aliases a script ``var``
+# array its record is built from (its storage lives as long as the strategy
+# and keeps its identity across bars), and owns, by move or copy, any other.
+# Copying the field shares what it holds, as Pine's shallow ``copy()`` does.
+UDT_ARRAY_FIELD_CPP = r"""
+template <typename T>
+class _PFArrayField {
+public:
+    _PFArrayField()
+        : owned_(std::make_shared<std::vector<T>>()), data_(owned_.get()) {}
+    _PFArrayField(const std::vector<T>& value)
+        : owned_(std::make_shared<std::vector<T>>(value)), data_(owned_.get()) {}
+    _PFArrayField(std::vector<T>&& value)
+        : owned_(std::make_shared<std::vector<T>>(std::move(value))),
+          data_(owned_.get()) {}
+    static _PFArrayField alias(std::vector<T>& value) {
+        return _PFArrayField(&value);
+    }
+    std::vector<T>& operator*() const { return *data_; }
+    const std::shared_ptr<std::vector<T>>& owned() const { return owned_; }
+    std::vector<T>* data() const { return data_; }
+    void rebind(std::shared_ptr<std::vector<T>> owned, std::vector<T>* data) {
+        owned_ = std::move(owned);
+        data_ = data;
+    }
+
+private:
+    explicit _PFArrayField(std::vector<T>* data) : data_(data) {}
+
+    std::shared_ptr<std::vector<T>> owned_;
+    std::vector<T>* data_ = nullptr;
+};
+"""
+
 TA_TUPLE_RESULT_TYPES = {
     "macd": "ta::MACDResult",
     "supertrend": "ta::SupertrendResult",
@@ -86,6 +129,7 @@ TA_TUPLE_RESULT_TYPES = {
     "bb": "ta::BBResult",
     "kc": "ta::KCResult",
     "vwap_bands": "ta::VWAPBandsResult",
+    "vwap_anchored_bands": "ta::VWAPBandsResult",
 }
 
 # (TA_IMPLICIT_COMPUTE / TA_COMPUTE_ARGS now imported from .tables above.)
@@ -101,7 +145,12 @@ TA_TUPLE_RESULT_TYPES = {
 
 # CPP_RESERVED + the NamingHelper mixin are pulled in from helpers.py so the
 # small naming/walk utilities can be shared with future visitor mixins.
-from .helpers import CPP_RESERVED, NamingHelper
+from .helpers import (
+    CPP_RESERVED, INLINE_HISTORY_KINDS, SESSION_FLAG_MEMBERS, NamingHelper,
+    cpp_code_only, na_preserving_int_cast, pine_truth_cast,
+)
+from .constant_fold import fold_numeric_expression
+from .session_market import SESSION_MARKET_CPP, SESSION_MARKET_MEMBER
 
 # TypeInferer mixin owns the ~15 type-spec / C++-type inference helpers
 # previously scattered across this module; see ``codegen/types.py``.
@@ -109,8 +158,7 @@ from .types import TypeInferer
 
 # TaSiteHelper owns site lookup, .compute() arg construction, and the TA
 # call-site machinery. The runtime-reset chain (_resolve_known and friends)
-# stays on CodeGen for now because it relies on Python's compile-time
-# expression evaluator.
+# stays on CodeGen for now because it shares the constructor constant folder.
 from .ta import TaSiteHelper
 
 # InputHelper owns Pine input.* analysis (defaults, titles, getter dispatch,
@@ -179,12 +227,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     _prescan_strategy_series), and the runtime-reset chain
     (_resolve_known / _is_skip_expr / _runtime_ctor_arg_for_reset /
     _collect_ta_runtime_resets / _emit_ta_runtime_reset) — kept here
-    because the chain relies on Python's compile-time expression
-    evaluator.
+    because the chain shares the constructor constant folder.
     """
 
-    def __init__(self, ctx: AnalyzerContext) -> None:
+    # True while emitting the body of a function or method inlined from a
+    # v5 library (``library_v5``): and/or evaluate both operands, a for
+    # loop's end is fixed before its first iteration, a negative array
+    # index stops the run, and an observer of v5's na bool is refused.
+    _pine_v5_body = False
+
+    def __init__(self, ctx: AnalyzerContext,
+                 budget: TimeBudget | None = None) -> None:
         self.ctx = ctx
+        self._budget = budget
+        self._budget_visit_count = 0
+        self._initialise_safe_names(ctx.ast)
         # Lexical Pine names remain in ``ctx.func_var_members``.  This overlay
         # carries exact class-member identities only for collision-qualified
         # ordinary FuncDefs (identity mappings for every other ordinary UDF).
@@ -310,11 +367,57 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # Set of var/series member names that belong to user functions (need cloning)
         self._func_var_members_set: set[str] = set()
         self._precalc_loop_active: bool = False
+        # Nonzero while the expression visitor lowers a request.security
+        # payload (``_build_security_expr``): the session helper below reads
+        # the chart's timeframe, which does not describe the security bar.
+        self._security_payload_depth: int = 0
+        # The request.security builder's context while its expression visitor
+        # fallback lowers a payload node: a user call, TA site, helper-bound
+        # name or requested-bar history the visitor reaches under that node is
+        # handed back to the builder (``_security_fallback_delegate``).
+        self._security_fallback_frame: dict | None = None
+        # Whether the evaluator being emitted lowers its payload's user calls
+        # under builtin calls, and its typed methods, on the requested bar;
+        # whether it did, and the first thing it left on the chart's terms
+        # (``_emit_security_evaluator_requested``).
+        self._security_requested_calls: bool = True
+        self._security_requested_used: bool = False
+        self._security_chart_read: tuple | None = None
+        # Evaluators that keep every earlier build's lowering, decided while
+        # a method's TA constructor arguments were lowered: sec_id -> reason.
+        self._security_chart_evaluators: dict[int, tuple] = {}
+        # request.security helper series of string values (``var string``, a
+        # string local read with history) live in their own map; the member
+        # is declared when a payload's helper holds one.
+        self._security_string_series_declared: bool = False
+        self._security_string_series: set[str] = set()
+        # Each request.security evaluator local's C++ type (a string local
+        # takes ``na<std::string>()``; the builder's ``/`` reads it).
+        self._security_local_cpp_types: dict[str, str] = {}
+        # C++ the security builder hands a synthetic name: a helper-local
+        # history index lowered in its helper's scope.
+        self._security_raw_cpp: dict[str, str] = {}
+        # Set while a request.security TA history index is lowered: an input
+        # it reads is its override-aware getter, since the evaluator can run
+        # before on_bar initializes the input members.
+        self._security_index_inputs: bool = False
+        # A source input's selected series read at a history offset in a
+        # payload (``_security_bar_history_field``): the payload-method
+        # pre-pass below reads it before generate() starts the run's own.
+        self._security_source_hist_fields: dict[tuple[str, str], tuple] = {}
+        # Set when a chart expression calls ``_pf_session_market_``; its type
+        # and member are emitted once the whole TU is lowered.
+        self._uses_session_market: bool = False
+        # session.* reads inside a request.security payload already warned.
+        self._warned_security_session_sites: set[int] = set()
         # Top-level lazy-edge TA sites hoisted to every-bar evaluation for the
         # statement currently being lowered: FuncCall id -> local name, and
         # Subscript id -> ``_hist_call_*`` member (see ``ta.py``).
         self._hoisted_ta_values: dict[int, str] = {}
         self._hoisted_hist_reads: dict[int, str] = {}
+        # ``*`` nodes a ``%`` or ``/`` reads: an int product among them is
+        # computed in 64 bits (visit_expr._lower_binop).
+        self._wide_int_products: set[int] = set()
         # Names of ``var`` members that live in a callable scope (not global).
         # Their exact declaration statements own initialization; they must not
         # be initialized by the constructor or the global on_bar preamble.
@@ -712,6 +815,29 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._fixnan_site_map[id(_fsite.node)] = _fsite
         # Track strategy series vars (e.g., strategy.closedtrades[1])
         self._strategy_series_vars: set[str] = set()
+        # session.* flags read at an offset at the top level (their per-bar
+        # Series): _prescan_session_history.
+        self._session_history_flags: set[str] = set()
+        self._session_call_flags: dict[str, set[str]] = {}
+        self._session_call_owner: dict[int, str] = {}
+        self._session_history_member_names: dict[str, str] = {}
+        # The names a rendered read may not take (the script's own first: a
+        # request.security timeframe renders here, before the prescans), and
+        # each read refused where it renders: its stand-in name, then the
+        # read (kept alive, so its id stays its own), where to report it, why,
+        # and the uncloned function it asks to clone, if any; raised or asked
+        # only if the C++ emits the stand-in (_settle_session_reads).
+        self._session_names_used: set[str] = set(self._safe_name_occupied)
+        self._refused_session_read_names: dict[tuple[int, str], str] = {}
+        self._refused_session_reads: dict[
+            str, tuple[ASTNode, ASTNode, str, str | None]] = {}
+        # The uncloned functions whose reads the emitted C++ holds: another
+        # analysis clones them (pineforge_codegen._generate).
+        self.session_functions_needing_clones: frozenset[str] = frozenset()
+        # The top-level block declarations whose type the member of their name
+        # cannot hold (``block_locals``): transpile() names each apart and
+        # runs again.
+        self.block_locals_needing_names: frozenset = frozenset()
         # Track global-scope non-var declarations (emitted as class members)
         self._global_member_vars: set[str] = set()
         for name, _ in ctx.global_var_decls:
@@ -816,6 +942,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # for-in loop iterator names (must resolve member access, not enum fallback)
         self._current_loop_vars: set[str] = set()
         self._current_loop_var_specs: dict[str, "TypeSpec"] = {}
+        # The counted loops' binders among them (``for (int i = ...)``).
+        self._current_counted_loop_vars: set[str] = set()
         # Track array variables for codegen
         self._array_vars: set[str] = set()
         # Track map variables for codegen
@@ -852,9 +980,20 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     _h = _hints[_i] if _i < len(_hints) else None
                     if _h and str(_h).replace(" ", "") in _SKIP_DECL_TYPES:
                         self._visual_drop_vars.add(_p)
+        # Build set of all member names (series vars, var members) for collision
+        # detection. It precedes the security metadata below: a timeframe
+        # computed by a user function (``tf = tfFromLabel(choice)``) renders
+        # that call through ``_func_safe_name`` at registration time.
+        self._all_member_names: set[str] = set()
+        for name in ctx.series_vars:
+            self._all_member_names.add(self._safe_name(name))
+        for name, _, _ in ctx.var_members:
+            self._all_member_names.add(self._safe_name(name))
         # Collect request.security metadata per call
         self._security_eval_info: list[dict] = []
         self._security_ta_variant_names: dict[tuple[int, int, tuple], str] = {}
+        # Reassigned globals a timeframe reads (``_security_tf_replay_prologue``).
+        self._security_tf_mutable_reads: set[str] = set()
         for item in self._security_calls:
             sec_id = item["sec_id"]
             tf_node = item["tf_node"]
@@ -865,8 +1004,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # Resolve the timeframe: a literal/const/global gives a static tf;
             # a function-parameter tf is resolved from the call sites (the
             # evaluator is a class method, so the param is not in scope there).
-            tf_str, tf_expr = self._resolve_security_tf(
-                tf_node, item.get("containing_func", ""))
+            # A lower-timeframe request has no chart-timeframe fallback.
+            self._security_tf_lower = bool(item.get("is_lower_tf_array"))
+            if item.get("dead"):
+                # A helper no top-level statement reaches: its evaluator is
+                # never read, registered on the chart timeframe.
+                tf_str, tf_expr = None, "input_tf_"
+            else:
+                tf_str, tf_expr = self._resolve_security_tf(
+                    tf_node, item.get("containing_func", ""))
 
             is_lookahead_on = False
             if lookahead_node is not None:
@@ -879,7 +1025,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     is_gaps_on = True
 
             expr_node = item["expr_node"]
-            inline_helper_ta_indices: set[int] = set()
+            inline_helper_ta_indices: set[tuple] = set()
             ta_binding_stacks = self._collect_security_ta_binding_stacks(
                 expr_node,
                 inline_ta_indices=inline_helper_ta_indices,
@@ -889,7 +1035,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             for idx in sorted(ta_indices):
                 site = self.ctx.ta_call_sites[idx]
                 binding_map = ta_binding_stacks.get(idx) or {(): ()}
-                signatures = sorted(binding_map.keys(), key=repr)
+                signatures = sorted(
+                    binding_map.keys(),
+                    key=lambda sig: self._security_variant_order_key(sig, binding_map[sig]),
+                )
                 use_base_name = len(signatures) == 1
                 variants: list[dict] = []
                 for variant_idx, signature in enumerate(signatures):
@@ -926,17 +1075,19 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "ta_indices": sorted(ta_indices),
                 "ta_binding_stacks": ta_binding_stacks,
                 "ta_variants": ta_variants,
-                "inline_helper_ta_indices": sorted(inline_helper_ta_indices),
+                # (index, signature) of each TA variant computed inline, and
+                # (index, _SECURITY_THROUGH_GLOBAL) of a global's site a
+                # multi-statement helper reads, which the prologue computes.
+                "inline_helper_ta_indices": sorted(inline_helper_ta_indices, key=repr),
                 "depends_on_mutable_globals": item.get("depends_on_mutable_globals", False),
                 "mutable_globals": list(item.get("mutable_globals", [])),
                 "is_lower_tf_array": bool(item.get("is_lower_tf_array", False)),
+                # Another symbol's feed (``_emit_foreign_security_registration``);
+                # a helper nothing reaches keeps the chart registration.
+                "foreign": bool(item.get("foreign")) and not item.get("dead"),
+                "symbol_node": item.get("symbol_node"),
+                "ignore_invalid_node": item.get("ignore_invalid_node"),
             })
-        # Build set of all member names (series vars, var members) for collision detection
-        self._all_member_names: set[str] = set()
-        for name in ctx.series_vars:
-            self._all_member_names.add(self._safe_name(name))
-        for name, _, _ in ctx.var_members:
-            self._all_member_names.add(self._safe_name(name))
         self._register_global_aggregate_member_types()
         self._uses_map = self._detect_map_usage()
         self._uses_matrix = self._detect_matrix_usage()
@@ -998,10 +1149,36 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 return True
         return False
 
+    def _series_var_init_keeps_preamble(self, init_str: str, init_ast,
+                                        top_level: bool = True) -> bool:
+        """Whether a history-read ``var``'s first value can be pushed in the
+        first-bar preamble, ahead of the script body: a top-level declaration
+        of a constant, a string literal, ``na`` or a bar field (the bar is in
+        place by then). Any other initializer reads what the body computes
+        before the declaration on the first bar -- a global (``b = close *
+        2``), a UDT field (``direction.neutral``), a call, an input's
+        override -- which the preamble read before it was assigned, or
+        spelled as raw Pine that did not compile
+        (``signal.push(direction.neutral)``); and a declaration in a block
+        initializes on the first bar that reaches it, which the preamble's
+        bar 0 is not."""
+        if not top_level:
+            return False
+        if init_ast is None:
+            return True
+        if self._scalar_var_init_depends_on_runtime_input(init_ast):
+            return False
+        if isinstance(init_ast, StringLiteral):
+            return True
+        if isinstance(init_ast, Identifier) and init_ast.name in BAR_FIELDS:
+            return True
+        return self._is_compile_time_value(self._resolve_known(init_str))
+
     def _is_runtime_scalar_var_initializer(
             self, name: str, ptype, init_str: str, init_ast,
             drawing_cpp: str | None = None,
-            is_series: bool = False) -> bool:
+            is_series: bool = False,
+            top_level: bool = True) -> bool:
         """Return True for a persistent primitive that must init in execution.
 
         Global Series and aggregate state keep their specialized preamble
@@ -1025,7 +1202,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 is_series
                 or not self._is_na_expr(init_ast)
             )
-        if is_series and name in self.ctx.series_vars:
+        if is_series and self._series_var_init_keeps_preamble(init_str, init_ast, top_level):
             return False
         udt_type = self._member_udt_type(name)
         if udt_type in self._udt_defs:
@@ -1041,6 +1218,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         return (
             not self._is_compile_time_value(ctor_val)
             or self._scalar_var_init_depends_on_runtime_input(init_ast)
+            # A history-read var in a block (its member may be renamed,
+            # ``k__blk1``): its history is na until the first bar that
+            # reaches it (``_series_var_init_keeps_preamble``).
+            or (is_series and not top_level)
         )
 
     def _prepare_runtime_scalar_var_initializers(self) -> None:
@@ -1166,6 +1347,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         top_level_node_ids = {id(stmt) for stmt in self.ctx.ast.body}
         for node_id, meta in metadata_by_node.items():
             stmt, member_name, ptype, init_str, is_callable_scoped = meta
+            if self._budget is not None:
+                # Each declaration rescans every declaration.
+                self._budget.check(stmt.loc, Phase.CODEGEN)
             if not isinstance(stmt, VarDecl) or not (stmt.is_var or stmt.is_varip):
                 continue
             stmt_spec = type_specs_by_node.get(node_id)
@@ -1223,7 +1407,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     nullable_collection_selection_decl_site
                     or self._is_runtime_scalar_var_initializer(
                         member_name, ptype, init_str, stmt.value, drawing_cpp,
-                        is_series
+                        is_series, node_id in top_level_node_ids
                     )
                 )
             )
@@ -1280,8 +1464,29 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # var-member metadata.  Record their exact source declaration type so
         # functions can resolve globals without consulting the analyzer's
         # legacy raw-name UDT registry (which later locals may overwrite).
-        for stmt in self.ctx.ast.body:
-            if not isinstance(stmt, VarDecl) or stmt.is_var or stmt.is_varip:
+        # A declaration in a top-level block (``if c`` / ``for``) is hoisted
+        # to the same class-member storage, so it is recorded too: its
+        # ``cond ? box.new(...) : na`` needs the handle type for the ``na``.
+        def top_level_scope_decls(stmts):
+            for stmt in stmts:
+                if isinstance(stmt, VarDecl):
+                    yield stmt
+                elif isinstance(stmt, IfStmt):
+                    yield from top_level_scope_decls(stmt.body)
+                    yield from top_level_scope_decls(stmt.else_body)
+                elif isinstance(stmt, (ForStmt, ForInStmt, WhileStmt)):
+                    yield from top_level_scope_decls(stmt.body)
+                elif isinstance(stmt, SwitchStmt):
+                    for _case, body in stmt.cases:
+                        yield from top_level_scope_decls(body)
+                    yield from top_level_scope_decls(stmt.default_body)
+
+        top_level_ids = {id(stmt) for stmt in self.ctx.ast.body}
+        for stmt in top_level_scope_decls(self.ctx.ast.body):
+            if stmt.is_var or stmt.is_varip:
+                continue
+            if (id(stmt) not in top_level_ids
+                    and stmt.name in self._global_drawing_cpp_types):
                 continue
             spec = (
                 self._type_spec_from_hint_name(stmt.type_hint)
@@ -1362,10 +1567,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             return
 
         func_bodies: dict[str, list] = {}
+        func_params: dict[str, set[str]] = {}
         for fi in ctx.func_infos:
             node = getattr(fi, "node", None)
             if node is not None and getattr(node, "body", None):
                 func_bodies.setdefault(fi.name, node.body)
+                func_params.setdefault(fi.name, set(getattr(node, "params", ()) or ()))
 
         # Pine forbids recursive callable execution. Most scalar-only cycles
         # never enter this state-instance pass (and some legacy dead-branch
@@ -1426,10 +1633,30 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             return list(self._func_cs_ta_remap.get((fname, 0), {}).keys())
 
         def var_originals(fname: str) -> list[str]:
-            return [
+            names = [
                 self._safe_name(self._func_var_storage_name(fname, n))
                 for n, _, _ in ctx.func_var_members.get(fname, [])
             ]
+            # A history-read local (``float f = 0.0`` then ``f := ... f[1]``)
+            # is persistent Series state too. Without it a fresh instance
+            # kept writing the original member, so every call path it served
+            # shared one series (cs-lev's second f_pole path fed its nine
+            # true-range filters into the price filter's ``_f``).
+            # Same storage rule as the natural csN remap of the callee's own
+            # series vars (``orig_names`` above).
+            params = func_params.get(fname, set())
+            for sv in sorted(ctx.func_series_vars.get(fname, ())):
+                if sv in params:
+                    continue  # a history-read parameter is the caller's series
+                exact = self._func_var_storage_name(fname, sv)
+                storage = self._safe_name(
+                    exact
+                    if self._safe_name(exact) in self._series_var_member_names
+                    else sv
+                )
+                if storage not in names:
+                    names.append(storage)
+            return names
 
         def fixnan_originals(fname: str) -> list[str]:
             return list(self._func_cs_fixnan_remap.get((fname, 0), {}).keys())
@@ -1581,6 +1808,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                         "name": inst_name,
                         "fresh": True,
                         "call_site_idx": None,
+                        # The written call this instance runs, for its
+                        # parameter and return types: an untyped parameter
+                        # takes the argument that call passes, as the
+                        # call's own cs{j} clone does.
+                        "type_call_site_idx": j,
                         "ta_remap": composed_ta,
                         "var_remap": fvar_remap,
                         "fixnan_remap": ffixnan_remap,
@@ -2269,10 +2501,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                         all_args.append(None)
                     all_args[i] = node.kwargs[pname]
 
-        if func_name == "highest" and len(all_args) == 1:
-            all_args = [Identifier(name="high"), all_args[0]]
-        elif func_name == "lowest" and len(all_args) == 1:
-            all_args = [Identifier(name="low"), all_args[0]]
+        # The one-arg length forms read high / low (as the analyzer's merge).
+        default_source = TA_LENGTH_ONLY_DEFAULT_SOURCE.get(func_name)
+        if default_source is not None and (
+                len(all_args) == 1 or (len(all_args) == 2 and all_args[0] is None)):
+            all_args = [Identifier(name=default_source), all_args[-1]]
 
         return all_args
 
@@ -2316,6 +2549,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         rejected by the constructor guard. Names are NOT folded into
         ``_known_vars`` (no use-site inlining): only the length-analysis path is
         affected, and the ``var`` member still emits and initializes normally.
+
+        The exception is ``var v = input.*()`` itself, which is registered like
+        the plain binding ``v = input.*()`` (``_collect_known_var``).
         """
         literal_candidates = self._admitted_stable_var_ctor_literals(reassigned)
 
@@ -2329,6 +2565,19 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 continue
             if self._decl_binding_is_series(id(stmt), stmt.name):
                 continue
+            # A never-reassigned ``var v = input.*()`` holds the input's value
+            # on every bar, as ``v = input.*()`` does, so it is registered the
+            # same way: an input-backed name read through its input call. The
+            # TA runtime reset then keys the input by
+            # ``_get_input_title(call, var_name=v)``, the key the member reads
+            # it by. Recorded below as a derived expression, the reset re-read
+            # the call's own spelling instead: an untitled input under "" and
+            # without its keyword arguments, so an override never resized the
+            # indicator.
+            if self._is_var_input_binding(stmt):
+                self._collect_known_var(stmt)
+                if stmt.name in self._input_var_to_call:
+                    continue
             if stmt.value is None or not self._expr_is_stable(stmt.value):
                 continue
             expr_str = self._arith_expr_to_str(stmt.value)
@@ -2340,9 +2589,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._stable_var_ctor_literals[stmt.name] = literal_record
             # Mark input-backed iff the init references an input, so the reset
             # emits override-aware get_input_*() reads for it.
-            import re as _re
-            toks = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", expr_str))
-            if any(t in self._input_backed_vars for t in toks):
+            if self._refs_input(expr_str):
                 self._input_backed_vars.add(stmt.name)
 
     @staticmethod
@@ -2656,7 +2903,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # Fold to a compile-time literal when possible (so the ctor-init
             # list can use it directly); otherwise record the raw expression
             # for the runtime reset path to expand.
-            folded = self._resolve_known(final)
+            folded = self._resolve_known_through_inputs(final)
             if self._is_compile_time_value(folded):
                 try:
                     num = float(folded)
@@ -2669,9 +2916,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             self._stable_runtime_vars.add(target_name)
             # Mark input-backed iff the expression references an input so the
             # override-aware get_input_*() reads are emitted on the reset path.
-            import re as _re
-            toks = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", final))
-            if any(t in self._input_backed_vars for t in toks):
+            if self._refs_input(final):
                 self._input_backed_vars.add(target_name)
 
     def _find_reassigned_vars(self) -> set[str]:
@@ -2916,6 +3161,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                            for a in node.args)
             if namespace == "input":
                 return True
+            # The generic ``input(...)`` is the leaf an inline TA length
+            # already admits (``_is_stable_inline_input``: not the source
+            # overload ``input(close)``, a constant defval); it used to fall to
+            # the user-function branch below and read as a series.
+            if namespace is None and func_name == "input":
+                return self._is_stable_inline_input(node)
             if namespace is None and func_name in ("int", "float", "bool", "string"):
                 return all(self._expr_is_stable(a, _udf_stack, _depth)
                            for a in node.args)
@@ -2948,7 +3199,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     # tree: Pine grouping ``(a - b) / (c - d)`` degrades to ``a - b / c - d``
     # under C++ precedence. See ``_runtime_ctor_arg_for_reset`` (the string is
     # re-parsed and lowered through the expression visitor).
-    _ATOMIC_ARITH_NODES = (NumberLiteral, Identifier, MemberAccess, FuncCall)
+    _ATOMIC_ARITH_NODES = (NumberLiteral, StringLiteral, Identifier, MemberAccess, FuncCall)
 
     def _arith_operand_to_str(self, node, _udf_stack: frozenset = frozenset(),
                               _depth: int = 0) -> str | None:
@@ -2973,11 +3224,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         against recursion cycles (Pine forbids recursion, but a malformed source
         must be refused, not looped forever).
         """
+        if getattr(self, "_arith_udf_memo", None) is None:
+            self._arith_udf_memo = {}
+            try:
+                return self._arith_expr_to_str(node, _udf_stack, _depth)
+            finally:
+                self._arith_udf_memo = None
         if isinstance(node, NumberLiteral):
             v = node.value
             if isinstance(v, float) and v == int(v):
                 return str(int(v))
             return str(v)
+        if isinstance(node, StringLiteral):
+            # ``len = mode == "Fast" ? 8 : 21``: a length chosen by comparing
+            # an input.string with its options.
+            return pine_string_literal(node.value)
         if isinstance(node, Identifier):
             return node.name
         if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
@@ -3009,12 +3270,27 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # ordinary ``callee(args)`` rendering below. The stack/depth guard
             # refuses a recursive UDF (returns None -> caller leaves it untracked
             # -> the ctor guard rejects it loudly) instead of recursing forever.
+            # An inline input call is spelled in full (title, keyword args):
+            # the reset re-parses it and keys the override by that title. An
+            # untitled call a declaration names carries that name as title=.
+            if self._is_stable_inline_input(node):
+                return spell_input_call(node, title=self._input_spelling_title(node))
             fn, ns = self._resolve_callee(node.callee)
             if ns is None and fn is not None and self._get_udf_def(fn) is not None:
-                inlined = self._inline_single_expr_udf(node, _udf_stack, _depth)
-                if inlined is None:
-                    return None
-                return self._arith_expr_to_str(inlined, _udf_stack | {fn}, _depth + 1)
+                # A call of the same function on the same argument nodes (a
+                # caller's inlined body calling it twice, a diamond of such
+                # helpers) is spelled once; the entry keeps the arguments
+                # alive, so their ids stay theirs until the outermost call.
+                key = (fn, _depth, _udf_stack, tuple(id(a) for a in node.args), bool(node.kwargs))
+                memo = self._arith_udf_memo
+                if key not in memo:
+                    inlined = self._inline_single_expr_udf(node, _udf_stack, _depth)
+                    memo[key] = (
+                        None if inlined is None
+                        else self._arith_expr_to_str(inlined, _udf_stack | {fn}, _depth + 1),
+                        node.args,
+                    )
+                return memo[key][0]
             callee = self._arith_expr_to_str(node.callee, _udf_stack, _depth)
             if callee is None:
                 return None
@@ -3027,14 +3303,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             return f"{callee}({', '.join(parts)})"
         return None
 
+    def _is_var_input_binding(self, node: VarDecl) -> bool:
+        """``var v = input.*()``: a ``var`` bound straight to an input call."""
+        return (node.is_var and not node.is_varip
+                and isinstance(node.value, FuncCall)
+                and self._is_input_call(node.value))
+
     def _collect_known_var(self, node: VarDecl) -> None:
         """Extract known constant value from a VarDecl."""
         # Don't inline series variables — their values change over time
         if self._decl_binding_is_series(id(node), node.name):
             return
         # Don't inline var/varip variables — they're mutable state that persists
-        # across bars and can be reassigned with :=
-        if node.is_var or node.is_varip:
+        # across bars and can be reassigned with := (callers pass never-
+        # reassigned names only, so ``var v = input.*()`` is the plain binding).
+        if (node.is_var or node.is_varip) and not self._is_var_input_binding(node):
             return
         if isinstance(node.value, NumberLiteral):
             self._known_vars[node.name] = node.value.value
@@ -3049,6 +3332,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     self._input_backed_vars.add(node.name)
                     if node.value.name in self._input_var_to_call:
                         self._input_var_to_call[node.name] = self._input_var_to_call[node.value.name]
+            # A plain alias of a derived stable scalar (``emaLen = calcEmaLen``
+            # over ``calcEmaLen = swingLen * emaRatio``) holds that scalar on
+            # every bar. Recorded as a derived expression of the name it
+            # copies, the TA runtime reset re-expands it to the inputs'
+            # getter reads; unrecorded, the reset spelled the alias's own
+            # member, which the body has not assigned yet on the first bar
+            # (0: ``ta.ema(close, emaLen)`` ran as an EMA of length 0).
+            src = node.value.name
+            if (src in self._derived_input_expr
+                    and src not in self._input_var_to_call
+                    and self._expr_is_stable(node.value)):
+                self._derived_input_expr[node.name] = src
+                self._stable_runtime_vars.add(node.name)
+                if src in self._input_backed_vars:
+                    self._input_backed_vars.add(node.name)
             if node.value.name in self._timeframe_period_vars:
                 self._timeframe_period_vars.add(node.name)
         elif (isinstance(node.value, MemberAccess)
@@ -3058,25 +3356,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             self._timeframe_period_vars.add(node.name)
         # Input calls: extract default value
         elif isinstance(node.value, FuncCall) and self._is_input_call(node.value):
-            default = self._get_input_default(node.value)
-            stored = False
-            if isinstance(default, NumberLiteral):
-                self._known_vars[node.name] = default.value
-                stored = True
-            elif isinstance(default, BoolLiteral):
-                self._known_vars[node.name] = default.value
-                stored = True
-            elif isinstance(default, StringLiteral):
-                self._known_vars[node.name] = default.value
-                stored = True
-            elif isinstance(default, MemberAccess) and isinstance(default.object, Identifier):
-                en = default.object.name
-                if en in self._enum_defs and default.member in self._enum_defs[en]:
-                    self._known_vars[node.name] = self._enum_defs[en].index(
-                        default.member
-                    )
-                    stored = True
+            stored, default = self._input_default_value(node.value)
             if stored:
+                self._known_vars[node.name] = default
                 self._input_backed_vars.add(node.name)
                 self._input_var_to_call[node.name] = node.value
         # Class-scope arithmetic / ternaries / casts over known, input-backed,
@@ -3099,8 +3381,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             expr_str = self._arith_expr_to_str(node.value)
             if expr_str is not None and self._expr_is_stable(node.value):
                 import re as _re
-                tokens = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", expr_str))
-                refs_input = any(t in self._input_backed_vars for t in tokens)
+                tokens = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*",
+                                         blank_string_literals(
+                                             self._inline_inputs_masked(expr_str))))
+                refs_input = self._refs_input(expr_str)
                 refs_derived = any(t in self._derived_input_expr for t in tokens)
                 # The stability classifier already proved this expression is a
                 # bar-invariant scalar (inputs / constants / timeframe.* /
@@ -3108,7 +3392,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 # stable exprs (and the TA reset path) can reference / expand
                 # it — e.g. ``pi = math.asin(1) * 2`` feeds ``beta`` feeds
                 # ``alpha`` feeds a function-local ``filterLen``.
-                folded = self._resolve_known(expr_str)
+                folded = self._resolve_known_through_inputs(expr_str)
                 if self._is_compile_time_value(folded):
                     try:
                         num = float(folded)
@@ -3134,25 +3418,38 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     # Public entry point
     # ------------------------------------------------------------------
 
+    def _codegen_warning(self, node: ASTNode | None, message: str,
+                         hint: str | None = None) -> None:
+        """Record a warning on ``ctx.diagnostics``, the list ``transpile_full``
+        returns beside the C++ (after the support checker's)."""
+        loc = node.loc if node is not None else None
+        if loc is None:
+            loc = SourceLocation(file=self.ctx.filename, line=1, col=1, end_col=1)
+        self.ctx.diagnostics.append(Diagnostic(
+            level=Level.WARNING, phase=Phase.CODEGEN, location=loc,
+            message=message, hint=hint))
+
     def _codegen_error(self, node: ASTNode | None, message: str, hint: str | None = None) -> None:
+        raise CompileError([self._codegen_error_diagnostic(node, message, hint)])
+
+    def _codegen_error_diagnostic(self, node: ASTNode | None, message: str,
+                                  hint: str | None = None) -> Diagnostic:
         loc = node.loc if node is not None else None
         if loc is None:
             loc = SourceLocation(file=self.ctx.filename, line=1, col=1, end_col=1)
-        raise CompileError(
-            [
-                Diagnostic(
-                    level=Level.ERROR,
-                    phase=Phase.CODEGEN,
-                    location=loc,
-                    message=message,
-                    hint=hint,
-                )
-            ]
+        return Diagnostic(
+            level=Level.ERROR,
+            phase=Phase.CODEGEN,
+            location=loc,
+            message=message,
+            hint=hint,
         )
 
     def _ta_return_type(self, site: TACallSite) -> str:
         if getattr(site, "returns_tuple", False):
-            return f"{site.class_name}Result"
+            return TA_TUPLE_RESULT_TYPES.get(
+                self._ta_name_from_site(site), f"{site.class_name}Result"
+            )
         if site.class_name in ("ta::Crossover", "ta::Crossunder", "ta::Cross"):
             return "bool"
         return "double"
@@ -3235,11 +3532,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         """
         self._inline_history_members = []
         self._inline_history_member_by_key = {}
-        counters = {
-            "hist_call": 0,
-            "series_arg": 0,
-            "udf_series_arg": 0,
-        }
+        # session.* flags a function reads at an offset (owner -> flags) and
+        # the owner of each such read: one Series per flag and emitted call
+        # site, pushed at the function's entry (emit_top.py).
+        self._session_call_flags: dict[str, set[str]] = {}
+        self._session_call_owner: dict[int, str] = {}
+        counters = {kind: 0 for kind in INLINE_HISTORY_KINDS}
+        # A per-call session Series is numbered past a script name spelled
+        # like one; the older kinds keep their numbering.
+        authored_names = set(getattr(self, "_safe_name_occupied", ()))
 
         def walk_nodes(value):
             """Yield AST nodes in stable field order, including tuple elements.
@@ -3335,6 +3636,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 return
             counters[kind] += 1
             member_name = f"_{kind}_{counters[kind]}"
+            while kind == "session_call" and member_name in authored_names:
+                counters[kind] += 1
+                member_name = f"_{kind}_{counters[kind]}"
             self._inline_history_member_by_key[key] = member_name
             self._inline_history_members.append({
                 "kind": kind,
@@ -3381,6 +3685,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 return list(
                     self._bind_typed_method_args(method_info, call).args_by_param
                 )
+            if isinstance(call.callee, Identifier):
+                defaulted = self._user_call_args_with_defaults(
+                    call.callee.name, call
+                )
+                if defaulted is not None:
+                    return defaulted
             if call.kwargs:
                 return _merge_kwargs(call.args, call.kwargs, params, lambda arg: arg)
             return list(call.args)
@@ -3436,6 +3746,20 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 id(child) for child in walk_nodes(expression)
             )
         self._requested_context_inline_node_ids = requested_node_ids
+        # The session.* reads a function body emits, outside its own
+        # request.security expressions (session_reads.py); a callable that
+        # cannot keep its call sites apart, or that this analysis did not
+        # clone, gets no per-call Series (a read it emits is refused, or asks
+        # for the clones).
+        no_call_history = (
+            set(getattr(self.ctx, "session_history_unsafe", None) or {})
+            | set(getattr(self.ctx, "session_uncloned", None) or ())
+        )
+        emitted_function_reads = {
+            id(read)
+            for fi in self.ctx.func_infos if fi.node is not None
+            for read in emitted_session_reads(fi.node, requested_node_ids)
+        }
 
         def emitted_context_for_call(
             fi,
@@ -3524,6 +3848,27 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 register(
                     "hist_call", (id(node),), self._infer_type(node.object), owner
                 )
+            elif (isinstance(node, Subscript)
+                    and self._is_session_flag(node.object)):
+                # In a function body the flag's history is the calls' of its
+                # call site: one Series per flag and emitted variant (the
+                # analyzer clones the function per call site), pushed once
+                # per call at the function's entry. A top-level read uses the
+                # flag's per-bar Series (_prescan_session_history), and one
+                # written in a request.security expression the requested
+                # clock's (security.py).
+                if owner is not None and id(node) not in requested_node_ids:
+                    self._session_call_owner[id(node)] = owner
+                    if (id(node) in emitted_function_reads
+                            and owner not in no_call_history):
+                        flag = node.object.member
+                        self._session_call_flags.setdefault(owner, set()).add(flag)
+                        register("session_call", (owner, flag), "bool", owner)
+            elif (isinstance(node, Subscript)
+                    and self._is_compound_history_object(node.object)):
+                register(
+                    "hist_call", (id(node),), self._infer_type(node.object), owner
+                )
 
             if not isinstance(node, FuncCall):
                 continue
@@ -3644,12 +3989,155 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                             context,
                         )
 
+        # A plain UDF reading a script variable (or bar_index) through history
+        # reads its call site's history of it, on the same chart clock as a
+        # history parameter: every chart-executed body owns one buffer per
+        # variable, updated when the body is entered. A body that is emitted
+        # once (never called) or only for a requested context keeps the
+        # chart's history.
+        global_reads = getattr(self.ctx, "func_global_history_reads", {}) or {}
+        for fi in self.ctx.func_infos:
+            names = global_reads.get(fi.name)
+            if not names or fi.node is None:
+                continue
+            for context in self._inline_history_contexts_for_owner(fi.name):
+                if (context is None or (fi.name, context)
+                        in self._requested_context_only_inline_contexts):
+                    continue
+                for name in names:
+                    register_one(
+                        "fn_global_hist",
+                        (id(fi.node), name),
+                        self._series_type_for(name),
+                        context,
+                    )
+
+    def _function_global_history_member(self, name: str) -> str | None:
+        """The emitted body's buffer of script variable ``name``, or None."""
+        fi = self._func_info_map.get(getattr(self, "_active_func_name", None))
+        if fi is None or fi.node is None or self._security_payload_depth:
+            return None
+        return self._inline_history_member_by_key.get(
+            ("fn_global_hist", id(fi.node), name, self._current_instance_name)
+        )
+
+    def _is_compound_history_object(self, node) -> bool:
+        """Whether ``node[k]`` is history on an operator expression or a
+        ``session.*`` flag.
+
+        ``(a > b)[1]``, ``(x - y)[2]`` and ``(c ? p : q)[1]`` read the
+        expression's value k bars ago; its C++ scalar cannot be indexed, so
+        the subscript owns a synthetic ``_hist_call_*`` Series exactly like an
+        inline call result. Numeric and bool expressions only: other families
+        keep their established lowering. A ``session.*`` flag's C++ value
+        cannot be indexed either: a request.security payload keeps its history
+        on the requested clock like an operator expression's (security.py); a
+        function body reads its call site's per-call Series
+        (``_prepare_inline_history_members``) and a top-level read the flag's
+        per-bar Series (``_prescan_session_history``).
+        """
+        if self._is_session_flag(node):
+            return True
+        return (isinstance(node, (BinOp, UnaryOp, Ternary))
+                and self._infer_type(node) in ("double", "int", "int64_t", "bool"))
+
+    @staticmethod
+    def _is_session_flag(node) -> bool:
+        """Whether ``node`` is a ``session.*`` boolean (``session.ismarket``)."""
+        return (isinstance(node, MemberAccess)
+                and isinstance(node.object, Identifier)
+                and node.object.name == "session"
+                and node.member in SESSION_FLAG_MEMBERS)
+
+    def _session_history_member(self, flag: str) -> str:
+        """The per-bar Series of a ``session.*`` flag read at the top level:
+        ``_pf_session_hist_<flag>``, suffixed past a script name spelled so."""
+        return self._session_history_member_names[flag]
+
+    def _settle_session_reads(self, cpp: str) -> None:
+        """Refuse the ``session.<flag>[k]`` reads the C++ emits with no
+        history, or, for a function this analysis did not clone
+        (``session_uncloned``), ask for its clones
+        (``session_functions_needing_clones``).
+
+        Both follow the emitted code, not the rendered reads: a call can render
+        an argument and leave it out of the C++ (``color.from_gradient``'s
+        arguments, a drawing's xloc), and a read there refuses nothing and
+        needs no clone. Such a read renders as a stand-in name
+        (``_refused_session_read``), which only that read can spell in code.
+        """
+        if not self._refused_session_reads:
+            return
+        pattern = re.compile(r"(?<![\w.])(" + "|".join(map(
+            re.escape, sorted(self._refused_session_reads, key=len, reverse=True))) + r")\b")
+        emitted = set(pattern.findall(cpp_code_only(cpp)))
+        # One error per read, the refusal rendered first (a read can be
+        # rendered on the chart and in a request.security evaluator).
+        refused: dict[tuple[int, int], Diagnostic] = {}
+        needing: set[str] = set()
+        for name, (_read, where, message, uncloned) in self._refused_session_reads.items():
+            if name not in emitted:
+                continue
+            if uncloned is not None:
+                needing.add(uncloned)
+                continue
+            diagnostic = self._codegen_error_diagnostic(where, message)
+            refused.setdefault(
+                (diagnostic.location.line, diagnostic.location.col), diagnostic)
+        if refused:
+            raise CompileError([refused[key] for key in sorted(refused)])
+        self.session_functions_needing_clones = frozenset(needing)
+
+    def _prescan_session_history(self) -> None:
+        """The ``session.*`` flags the script reads at an offset at its top
+        level, each of which gets one Series pushed on every chart bar.
+
+        TradingView reads a flag's history by bars at the top level of the
+        script, in a block and on a lazy operand as well, and by calls inside a
+        function (``tests/test_e2e_session_history.py``): function bodies
+        (``_prepare_inline_history_members``) and ``request.security`` payloads
+        (the requested clock, security.py) keep their own history instead. A
+        ``// @pf-trace`` expression is read at the top level.
+        """
+        roots = [stmt for stmt in self.ctx.ast.body
+                 if not isinstance(stmt, (FuncDef, MethodDef))]
+        roots += [pragma.expr_node for pragma in (self.ctx.pf_trace_pragmas or [])
+                  if getattr(pragma, "expr_node", None) is not None]
+        payloads: set[int] = set()
+        for root in roots:
+            for node, _depth in iter_ast_nodes(root):
+                if not isinstance(node, FuncCall):
+                    continue
+                name, namespace = self._resolve_callee(node.callee)
+                if namespace == "request" and name in ("security", "security_lower_tf"):
+                    payload = node.args[2] if len(node.args) > 2 else node.kwargs.get("expression")
+                    if payload is not None:
+                        payloads.add(id(payload))
+        flags = {read.object.member for root in roots
+                 for read in emitted_session_reads(root, payloads)}
+        used = self._session_names_used
+        self._session_history_member_names = {
+            flag: self._allocate_generated_cpp_name(f"_pf_session_hist_{flag}", used)
+            for flag in sorted(flags)
+        }
+        self._session_history_flags = flags
+
     def _inline_history_member(self, kind: str, node: ASTNode,
                                arg_idx: int | None = None) -> str:
         source_key = (id(node),) if arg_idx is None else (id(node), arg_idx)
         key = (kind, *source_key, self._current_instance_name)
         member = self._inline_history_member_by_key.get(key)
         if member is None:
+            if getattr(self, "_security_fallback_frame", None) is not None:
+                # A builtin call in a request.security payload reads history
+                # the evaluator keeps no series for (a helper call's inside a
+                # helper body the payload inlines twice): refused as the bare
+                # read is, where this used to crash the transpiler.
+                self._codegen_error(
+                    node,
+                    "request.security helper call history is only supported in "
+                    "the payload itself",
+                )
             raise AssertionError(
                 "missing pre-registered inline history member for "
                 f"{kind} at {getattr(node, 'loc', None)} in context "
@@ -3791,8 +4279,47 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             self._udt_arena_member_names[type_name] = allocated
             self._all_member_names.add(allocated)
 
+    # C++ types one member holds for every declaration of a name.
+    _SHARED_MEMBER_TYPES = frozenset({"int", "int64_t", "double", "bool"})
+
+    def _block_locals_needing_names(self) -> frozenset:
+        """The declarations in the script's top-level blocks whose type the
+        member of their name cannot hold (``block_locals``). The member has
+        the type of the name's direct top-level declaration, else of its
+        first declaration; a string, a collection or an object beside another
+        type did not compile. Numbers and bools share one member, as before."""
+        decls = [(decl, nested) for decl, nested in block_declarations(self.ctx.ast.body)
+                 if not decl.is_var and not decl.is_varip and decl.value is not None]
+        member: dict[str, str | None] = {}
+        for decl, nested in decls:
+            if not nested:
+                member.setdefault(decl.name, self._declared_cpp_type(decl))
+        needing: set = set()
+        for decl, nested in decls:
+            cpp = self._declared_cpp_type(decl)
+            first = member.setdefault(decl.name, cpp)
+            if (nested and first is not None and cpp is not None and first != cpp
+                    and not {first, cpp} <= self._SHARED_MEMBER_TYPES
+                    and decl_key(decl) is not None):
+                needing.add(decl_key(decl))
+        return frozenset(needing)
+
+    def _declared_cpp_type(self, decl: VarDecl) -> str | None:
+        """The C++ type of a declaration's value (its hint's, when typed)."""
+        if decl.type_hint:
+            spec = self._type_spec_from_hint_name(decl.type_hint)
+            return self._type_spec_to_cpp(spec) if spec is not None else None
+        try:
+            return self._infer_type(decl.value)
+        except Exception:
+            return None
+
     def generate(self) -> str:
         """Generate C++ source from the AnalyzerContext."""
+        # Every input is keyed by its title: refuse a non-constant one first,
+        # then flag inputs one override key would reach together.
+        self._check_input_titles()
+        self._check_input_keys()
         # Context-sensitive instance pre-pass (needs the naming helpers populated
         # in __init__). Computes nested stateful-helper dispatch + fresh instances.
         self._build_func_instances()
@@ -3806,14 +4333,26 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._prepare_udt_generated_names()
         # Pre-scan for strategy series vars
         self._prescan_strategy_series()
+        self._prescan_session_history()
         self._security_ohlc_hist_fields_by_sec: dict[int, set[str]] = {}
+        # A source input's selected series read at a history offset in a
+        # payload: (key, default) -> (the input call, its history field).
+        self._security_source_hist_fields: dict[tuple[str, str], tuple] = {}
         # request.security TA call-sites read at a history offset (``ta.ema(...)[k>=1]``).
         # Maps sec_id -> set of TA call-site indices needing an HTF history Series.
         self._security_ta_hist_idx_by_sec: dict[int, set[int]] = {}
         # request.security helper-call results read at a history offset
         # (``myHelper()[k]``). Maps (sec_id, node-id) -> backing Series metadata.
         self._security_expr_hist_by_node: dict[tuple[int, int], dict] = {}
+        # request.security id -> the globals its payload reads with history
+        # (``_security_global_history_value``).
+        self._security_global_hist_names: dict[int, set[str]] = {}
+        # ids of the global history reads kept in a double (``_security_emits_double``).
+        self._security_double_hist_nodes: set[int] = set()
+        # request.security ids whose payload reads the requested bar_index.
+        self._security_bar_index_secs: set[int] = set()
         self._prepare_lazy_source_clock_sites()
+        self.block_locals_needing_names = self._block_locals_needing_names()
 
         lines: list[str] = []
 
@@ -3835,11 +4374,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # The two-phase order also permits self/nested UDT fields without
         # embedding a C++ type recursively by value.
         for type_name in self._udt_defs:
-            lines.append(f"struct {type_name} {{")
+            safe_type_name = self._safe_name(type_name)
+            lines.append(f"struct {safe_type_name} {{")
             lines.append("    int32_t __pf_id = -1;")
             lines.append("};")
             lines.append(
-                f"inline bool is_na(const {type_name}& _z) "
+                f"inline bool is_na(const {safe_type_name}& _z) "
                 "{ return _z.__pf_id < 0; }"
             )
             lines.append("")
@@ -3865,6 +4405,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 f"    {self._udt_undo_coordinator_cpp_name}& operator=(",
                 f"        {self._udt_undo_coordinator_cpp_name}&&) = delete;",
                 "",
+                "    void reset_for_run() {",
+                "        _pf_undo_.clear();",
+                "        _pf_active_ = false;",
+                "        // Keep generation monotonic: an old token cannot become valid again.",
+                "    }",
+                "",
                 "    Snapshot snapshot() {",
                 "        if (_pf_generation_ == std::numeric_limits<uint64_t>::max()) {",
                 '            throw std::overflow_error("UDT checkpoint generation exhausted");',
@@ -3942,6 +4488,14 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 f"    {self._udt_arena_template_cpp_name}& operator=(",
                 f"        {self._udt_arena_template_cpp_name}&&) = delete;",
                 "",
+                "    void reset_for_run() {",
+                "        _pf_records_.clear();",
+                "        _pf_checkpoint_size_ = 0;",
+                "        _pf_checkpoint_generation_ = 0;",
+                "        _pf_checkpoint_active_ = false;",
+                "        // The arena remains attached to its original coordinator.",
+                "    }",
+                "",
                 "    _PFHandle create(_PFRecord value) {",
                 "        if (_pf_records_.size() > static_cast<std::size_t>(",
                 "                std::numeric_limits<int32_t>::max())) {",
@@ -4012,6 +4566,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # the same map.  Authored field defaults are evaluated by ``Type.new``
         # at the call site; record declarations use only inert typed defaults so
         # bar/TA expressions never leak into namespace-scope C++ initializers.
+        if self._udt_has_array_fields():
+            lines.append(UDT_ARRAY_FIELD_CPP)
         for type_name, fields in self._udt_defs.items():
             record_type = self._udt_record_cpp_type(type_name)
             lines.append(f"struct {record_type} {{")
@@ -4021,11 +4577,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 if f.name in omitted:
                     continue
                 spec = field_specs.get(f.name) or self._type_spec_from_hint_name(f.type_name)
+                array_field = self._udt_array_field_cpp(spec, type_name)
+                if array_field is not None:
+                    lines.append(f"    {array_field} {self._safe_name(f.name)} = {array_field}();")
+                    continue
                 cpp_type = self._type_spec_to_cpp(spec)
                 if cpp_type == "int":
                     cpp_type = "int64_t"
                 default = self._default_for_spec(spec)
-                lines.append(f"    {cpp_type} {f.name} = {default};")
+                lines.append(f"    {cpp_type} {self._safe_name(f.name)} = {default};")
             lines.append("};")
             lines.append("")
 
@@ -4034,15 +4594,18 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         # 1c. Enum constants + string tables for str.tostring(enumVar)
         for enum_name, members in self._enum_defs.items():
+            safe_enum_name = self._safe_name(enum_name)
             for i, member in enumerate(members):
-                lines.append(f'const int {enum_name}_{member} = {i};')
+                lines.append(
+                    f'const int {safe_enum_name}_{self._safe_name(member)} = {i};'
+                )
             strs = self._enum_member_strings.get(enum_name)
             if strs and len(strs) == len(members):
                 parts = ", ".join(
                     f'std::string("{self._cpp_string_escape(s)}")' for s in strs
                 )
                 lines.append(
-                    f"static const std::string {enum_name}_str_values[] = {{{parts}}};"
+                    f"static const std::string {safe_enum_name}_str_values[] = {{{parts}}};"
                 )
             lines.append("")
 
@@ -4051,9 +4614,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # per-callsite instances are declared below inside GeneratedStrategy
         # and therefore join the automatic COOF checkpoint inventory.
         self._emit_lazy_source_clock_helper(lines)
+        # The chart-bar session type, inserted here once the class is lowered
+        # and known to call it (codegen/session_market.py).
+        _session_market_at = len(lines)
 
         # 2. Open class
-        lines.append("class GeneratedStrategy : public BacktestEngine {")
+        lines.append("class GeneratedStrategy : public pineforge::source::PineStrategyHost {")
         lines.append("public:")
         _script_state_decl_start = len(lines)
 
@@ -4127,6 +4693,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._security_ohlc_hist_fields_by_sec[sec_id] = hist_fields
                 for i, el in enumerate(expr_node.elements):
                     ctype = self._infer_cpp_type_for_security_elem(el)
+                    if ctype == "int" and item.get("foreign"):
+                        # Another symbol's int element (its time, time_close,
+                        # bar_index) is held as a double: a millisecond
+                        # stamp overflows an int, and it reads na until the
+                        # symbol's first bar.
+                        ctype = "double"
                     if ctype == "std::vector<double>":
                         lines.append(f"    {ctype} _req_sec_{sec_id}_{i}{{}};")
                     else:
@@ -4162,7 +4734,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._security_ohlc_hist_fields_by_sec[sec_id] = (
                     self._collect_security_ohlc_hist_fields_for_call(item)
                 )
-                lines.append(f"    double _req_sec_{sec_id} = na<double>();")
+                if item.get("string_result"):
+                    lines.append(f"    std::string _req_sec_{sec_id} = na<std::string>();")
+                else:
+                    lines.append(f"    double _req_sec_{sec_id} = na<double>();")
             for field in sorted(self._security_ohlc_hist_fields_by_sec.get(sec_id, ())):
                 ctype = self._security_bar_hist_type(field)
                 lines.append(
@@ -4174,9 +4749,22 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             for name in self._security_ta_hist_series_names(sec_id):
                 lines.append(f"    Series<double> {name}{_mbb};")
             self._emit_security_expr_hist_members(sec_id, expr_node, lines, _mbb)
-
+            if item.get("foreign"):
+                # configure_security_evaluators() clears it when the site is
+                # registered: its reads stop the run while it is set.
+                lines.append(f"    bool _pf_sec_missing_{sec_id} = true;")
+
+        # A recorded request's missing-data flag, set where it is evaluated.
+        for n in range(len(self._recorded_sites())):
+            lines.append(f"    bool _pf_rec_missing_{n} = true;")
         if self._security_calls:
             lines.append('    std::unordered_map<std::string, Series<double>> _security_helper_series_;')
+            self._security_string_series_declared = self._security_needs_string_series()
+            if self._security_string_series_declared:
+                lines.append(
+                    '    std::unordered_map<std::string, Series<std::string>> '
+                    '_security_helper_series_str_;'
+                )
 
         # Security-local mutable global state for request.security
         for info in self._security_eval_info:
@@ -4200,7 +4788,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         for _ta_idx, site in enumerate(self.ctx.ta_call_sites):
             if _ta_idx in self._dead_ta_indices:
                 continue
-            lines.append(f"    {site.class_name} {site.member_name};")
+            lines.append(f"    {self._ta_member_cpp_type(site)} {site.member_name};")
             if self._ta_site_uses_precalc(site):
                 vtype = self._ta_return_type(site)
                 lines.append(f"    std::vector<{vtype}> _precalc_{site.member_name};")
@@ -4219,8 +4807,6 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             literal = info["length_literal"]
             capacity = f"{{{literal + 1}}}" if literal is not None and literal >= 1 else ""
             lines.append(f"    Series<double> {info['hist']}{capacity};")
-            if info["chart"] is not None:
-                lines.append(f"    Series<double> {info['chart']}{capacity};")
 
         # Security evaluator TA members (cloned from expression dependencies)
         # Skip for user function call expressions — their TA deps are internal to the function
@@ -4228,18 +4814,26 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             for idx, variants in (info.get("ta_variants") or {}).items():
                 site = self.ctx.ta_call_sites[idx]
                 for variant in variants:
-                    lines.append(f"    {site.class_name} {variant['member_name']};")
+                    cpp_type = self._ta_security_member_cpp_type(info["sec_id"], site, variant)
+                    lines.append(f"    {cpp_type} {variant['member_name']};")
 
         # 4. Series members for bar field history
         for field_name in sorted(self.ctx.series_bar_fields):
             lines.append(f"    Series<double> _s_{field_name}{_mbb};")
 
         # 5. var/varip members (deduplicate by name)
+        # Sections 5-6 and 8c-8c2 declare the script's var/varip and
+        # history-read variables, whose drawing handles keep a drawing from
+        # the collection; 8b's plain non-var globals do not.
+        _variable_decls_start = len(lines)
         seen_var_members: set[str] = set()
         for name, ptype, init_str in self.ctx.var_members:
             if name in seen_var_members:
                 continue
             seen_var_members.add(name)
+            if self._budget is not None:
+                # _callable_var_udt_spec scans every declaration.
+                self._budget.check(phase=Phase.CODEGEN)
             safe = self._safe_name(name)
             callable_collection_spec = (
                 None
@@ -4347,7 +4941,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                         udt_type = udt_name
                         break
             if udt_type:
-                lines.append(f"    {udt_type} {safe};")
+                lines.append(f"    {self._safe_name(udt_type)} {safe};")
                 continue
             cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
             # Promote int->int64_t when init RHS is an int64-returning builtin
@@ -4387,6 +4981,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 cpp_type = self._series_type_for(name)
                 lines.append(f"    Series<{cpp_type}> {safe}{_mbb};")
 
+        _variable_decls = lines[_variable_decls_start:]
         # 7. Fixnan members
         for _fi_idx, site in enumerate(self.ctx.fixnan_sites):
             if _fi_idx in self._dead_fixnan_indices:
@@ -4404,6 +4999,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             else:
                 lines.append(f"    Series<double> {svar}{_mbb};")
 
+        # 8. session.* flags read at an offset at the top level: one Series per
+        #    flag, pushed on every chart bar (emit_top.py).
+        for flag in sorted(self._session_history_flags):
+            lines.append(f"    Series<bool> {self._session_history_member(flag)}{_mbb};")
+
         # 8a. Synthetic temporary history.  Unlike the legacy function-local
         # static buffers, these members are value-copyable rollback state and
         # have one identity per source site / emitted UDF variant.
@@ -4450,10 +5050,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 if _draw_cpp is not None:
                     lines.append(f"    {_draw_cpp} {safe} = {_draw_cpp}{{}};")
                 else:
-                    lines.append(f"    {udt_t} {safe} = {udt_t}{{}};")
+                    udt_cpp = self._safe_name(udt_t)
+                    lines.append(f"    {udt_cpp} {safe} = {udt_cpp}{{}};")
             else:
                 expr = self.ctx.global_expr_map.get(name) if hasattr(self.ctx, "global_expr_map") else None
-                if (
+                if self._global_color_hint(name):
+                    cpp_type = "int64_t"
+                elif self._global_bool_hint(name):
+                    cpp_type = "bool"
+                elif (
                     name in self._direct_program_tuple_binding_names
                     and ptype == PineType.BOOL
                 ):
@@ -4462,15 +5067,39 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     # coarse request.security call expression itself still
                     # reports FLOAT, so prefer that exact binding type here.
                     cpp_type = "bool"
+                elif (
+                    ptype == PineType.STRING
+                    and name in self._security_tuple_binding_names()
+                ):
+                    # A string element of a request.security helper tuple.
+                    cpp_type = "std::string"
+                elif (
+                    ptype == PineType.STRING
+                    and isinstance(expr, (IfStmt, SwitchStmt))
+                ):
+                    # A string element of an if/switch selection tuple
+                    # (``[a, b] = if c ... f() else [string(na), string(na)]``):
+                    # the whole selection infers as double, which a
+                    # std::string element could not be assigned to.
+                    cpp_type = "std::string"
                 else:
                     cpp_type = (
                         self._infer_type(expr)
                         if expr is not None
                         else PINE_TYPE_TO_CPP.get(ptype, "double")
                     )
+                    # The var-member rule: a plain global an epoch reaches
+                    # (``_wide_int_provenance``) is stored in 64 bits too.
+                    if cpp_type == "int" and self._is_int64_builtin_init(name):
+                        cpp_type = "int64_t"
+                    # An int that can hold TradingView's infinity
+                    # (``_nonfinite_int_names``) keeps its double.
+                    elif cpp_type == "int" and name in self._nonfinite_int_names():
+                        cpp_type = "double"
                 default = self._default_for_type(cpp_type)
                 lines.append(f"    {cpp_type} {safe} = {default};")
 
+        _variable_decls_start = len(lines)
         # 8c. Cloned var/series members for per-call-site function variants
         #     Same pattern as TA member cloning: each call site gets its own copy
         emitted_clones: set[str] = set()
@@ -4496,6 +5125,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 orig_safe, fresh_safe, _mbb, lines, owner_func=owner_func
             )
 
+        _variable_decls = _variable_decls + lines[_variable_decls_start:]
+        self._drawing_pins = self._drawing_pin_members(_variable_decls)
+
         # 8c3. Fresh fixnan members for context-sensitive helper instances.
         #      Each fresh instance gets its OWN previous-value member so two
         #      call paths never share fixnan state (mirrors 8c2 for vars).
@@ -4508,14 +5140,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         # 8d. Drawing-objects-as-data arenas (gated on _uses_drawing so
         #     non-drawing strategies emit byte-identical C++). Each arena is a
-        #     per-strategy member -> reset-per-run is automatic. Caps come from
-        #     the strategy() header max_*_count (default 50; linefill default 50).
+        #     per-strategy member, reset by prepare_script_run. The arenas never
+        #     evict: the generated collectors apply the strategy() header's
+        #     max_*_count the way TradingView does (default 50; see
+        #     DRAWING_LIFETIME_CPP), and linefills are never collected.
         if self._uses_drawing:
-            caps = self._drawing_caps or {}
-            lines.append(f"    DrawingArena<LineRec> _pf_lines_{{{caps.get('line', 50)}}};")
-            lines.append(f"    DrawingArena<BoxRec> _pf_boxes_{{{caps.get('box', 50)}}};")
-            lines.append(f"    DrawingArena<LabelRec> _pf_labels_{{{caps.get('label', 50)}}};")
-            lines.append(f"    DrawingArena<LinefillRec> _pf_linefills_{{{caps.get('linefill', 50)}}};")
+            lines.append("    DrawingArena<LineRec> _pf_lines_{_PF_DRAWING_UNBOUNDED};")
+            lines.append("    DrawingArena<BoxRec> _pf_boxes_{_PF_DRAWING_UNBOUNDED};")
+            lines.append("    DrawingArena<LabelRec> _pf_labels_{_PF_DRAWING_UNBOUNDED};")
+            lines.append("    DrawingArena<LinefillRec> _pf_linefills_{_PF_DRAWING_UNBOUNDED};")
 
         # 9. _var_initialized flag
         if self.ctx.var_members:
@@ -4577,15 +5210,23 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # inventory from the declarations above so every future generated
         # state category is captured automatically (or generation fails loudly
         # if it introduces an unfamiliar declaration form).
+        _script_state_declarations = lines[_script_state_decl_start:-1]
         _script_state_members = self._collect_script_state_members(
-            lines[_script_state_decl_start:-1]
+            _script_state_declarations
         )
         self._emit_script_state_hooks(lines, _script_state_members)
         lines.append("")
+        # Its per-strategy cache, outside the checkpointed script state.
+        _session_market_member_at = len(lines)
 
         # 9. Constructor with TA initializer list
         self._emit_constructor(lines)
         lines.append("")
+        self._emit_script_run_prepare(lines, _script_state_declarations)
+        lines.append("")
+        if self._uses_drawing:
+            self._emit_drawing_collectors(lines)
+            lines.append("")
 
         # 10. User-defined functions (with per-call-site variants for functions
         #     containing TA calls OR series variables that need isolation)
@@ -4647,7 +5288,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # 13. extern "C" interface
         self._emit_extern_c(lines)
 
-        return "\n".join(lines)
+        if self._uses_session_market:
+            lines.insert(_session_market_member_at, SESSION_MARKET_MEMBER)
+            lines.insert(_session_market_at, SESSION_MARKET_CPP)
+
+        cpp = "\n".join(lines)
+        self._settle_session_reads(cpp)
+        return cpp
 
     # ------------------------------------------------------------------
     # Top-level emitters (_emit_includes / _emit_constructor / _emit_on_bar
@@ -4696,8 +5343,99 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             and not self._known_var_is_lexically_shadowed(arg_str)
         ):
             return str(self._stable_var_ctor_literals[arg_str].value)
+        # An inline input's placeholder is its defval, as a bound
+        # ``v = input.int(9, ...)`` contributes through ``_known_vars``; the
+        # runtime reset still sizes the indicator from the live input.
+        folded = self._fold_inline_input_defaults(arg_str)
+        if folded is not None and self._is_compile_time_value(folded):
+            return folded
         return resolved
 
+    @staticmethod
+    def _ta_ctor_arg_is_bool(site: TACallSite, position: int) -> bool:
+        """Whether a TA shim constructor slot is a Pine simple bool."""
+        return (
+            (site.class_name == "_PFALMA" and position == 3)
+            or (site.class_name in ("_PFKC", "_PFKCW") and position == 2)
+            or (site.class_name == "ta::TR" and position == 0)
+            or (site.class_name in ("ta::StdDev", "ta::Variance") and position == 1)
+        )
+
+    @staticmethod
+    def _ta_ctor_bool_cpp(value: str) -> str:
+        """Pine truthiness for a runtime TA constructor flag."""
+        if value.strip() in {"true", "false"}:
+            return value
+        return pine_truth_cast(value)
+
+    # An inline ``input.*()`` call inside a ctor-arg / derived-length spelling
+    # is one leaf of the expression. It qualifies exactly when its bound
+    # spelling ``v = <call>`` would make ``v`` input-backed
+    # (``_collect_known_var``): not a source input, and a constant defval.
+
+    def _is_stable_inline_input(self, node) -> bool:
+        return (isinstance(node, FuncCall)
+                and self._is_input_call(node)
+                and not self._is_source_input(node)
+                and self._input_default_value(node)[0])
+
+    def _inline_input_calls(self, expr: str) -> list[tuple[int, int, FuncCall]] | None:
+        """Each inline input call in ``expr`` as ``(start, end, call)``; None
+        when one is not a stable inline input or does not re-parse."""
+        from ..lexer import Lexer
+        from ..parser import Parser
+        calls = []
+        for start, end in input_call_spans(expr):
+            text = expr[start:end]
+            try:
+                node = Parser(Lexer(text).tokenize(), source=text)._parse_expression()
+            except Exception:
+                return None
+            if not self._is_stable_inline_input(node):
+                return None
+            calls.append((start, end, node))
+        return calls
+
+    def _inline_inputs_masked(self, expr: str) -> str:
+        """``expr`` with each inline input call reduced to the bare word
+        ``input``, so identifier scans never read its title string or keyword
+        names. Unchanged when one of the calls is not a stable inline input."""
+        for start, end, _call in reversed(self._inline_input_calls(expr) or ()):
+            expr = expr[:start] + "input" + expr[end:]
+        return expr
+
+    def _refs_input(self, expr: str) -> bool:
+        """Whether a stable-expression spelling reads an input: an inline
+        input call or an input-backed name."""
+        masked = self._inline_inputs_masked(expr)
+        if masked != expr:
+            return True
+        return any(t in self._input_backed_vars
+                   for t in re.findall(r"[A-Za-z_][A-Za-z_0-9]*",
+                                       blank_string_literals(expr)))
+
+    def _fold_inline_input_defaults(self, expr: str) -> str | None:
+        """``expr`` const-folded with each inline input call read as its
+        defval; None when it has none or one is not a stable inline input."""
+        calls = self._inline_input_calls(expr)
+        if not calls:
+            return None
+        for start, end, call in reversed(calls):
+            value = self._input_default_value(call)[1]
+            if isinstance(value, bool):
+                literal = "true" if value else "false"
+            elif isinstance(value, str):
+                literal = pine_string_literal(value)
+            else:
+                literal = str(value)
+            expr = expr[:start] + literal + expr[end:]
+        return self._resolve_known(expr)
+
+    def _resolve_known_through_inputs(self, expr: str) -> str:
+        """``_resolve_known``, reading each inline input call as its defval."""
+        folded = self._fold_inline_input_defaults(expr)
+        return folded if folded is not None else self._resolve_known(expr)
+
     def _resolve_known(self, arg_str: str) -> str:
         """Resolve a string arg, replacing known var names with their values.
 
@@ -4719,39 +5457,18 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # Also resolve bar field references
         if arg_str in BAR_FIELDS:
             return BAR_FIELDS[arg_str]
-        # Try to evaluate expressions by substituting known variables
+        # Fold only numeric syntax. Bind names as primitive values rather than
+        # rewriting source or exposing Python builtins/module objects to it.
         if any(c in arg_str for c in "+-*/()."):
-            try:
-                resolved = arg_str
-                # Sort by length (longest first) to avoid partial replacements
-                for name in sorted(self._known_vars, key=len, reverse=True):
-                    if self._known_var_is_lexically_shadowed(name):
-                        continue
-                    val = self._known_vars[name]
-                    if isinstance(val, (int, float)):
-                        import re
-                        resolved = re.sub(rf'\b{re.escape(name)}\b', str(val), resolved)
-                # Map Pine math functions to Python equivalents for eval
-                eval_str = resolved
-                eval_str = eval_str.replace("math.round", "round")
-                eval_str = eval_str.replace("math.sqrt", "__import__('math').sqrt")
-                eval_str = eval_str.replace("math.ceil", "__import__('math').ceil")
-                eval_str = eval_str.replace("math.floor", "__import__('math').floor")
-                eval_str = eval_str.replace("math.abs", "abs")
-                # Evaluate safely (only allow numeric operations).
-                # Acquire the builtin through indirection so this file does
-                # not contain the literal three-letter token followed by ``(``
-                # — a repository-wide security hook blocks file writes
-                # containing that pattern.
-                _expr_evaluator = getattr(__builtins__, "eval", None) or __builtins__["eval"]
-                result = _expr_evaluator(eval_str, {"__builtins__": {}},
-                              {"round": round, "abs": abs,
-                               "math": __import__("math")})
+            values = {
+                name: value for name, value in self._known_vars.items()
+                if not self._known_var_is_lexically_shadowed(name)
+            }
+            result = fold_numeric_expression(arg_str, values)
+            if result is not None:
                 if isinstance(result, float) and result == int(result):
                     return str(int(result))
                 return str(result)
-            except Exception:
-                pass
         return arg_str
 
     # _is_input_call / _is_input_call_by_name / _get_input_default /
@@ -4970,11 +5687,14 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     inner = self._derived_input_expr[nm]
                     return "(" + _expand_derived(inner, seen | {nm}, depth + 1) + ")"
                 return nm
-            return ident_re.sub(_rep, s)
+            return sub_identifiers(s, _rep)
 
         expanded = _expand_derived(arg_str)
 
-        tokens = set(ident_re.findall(expanded))
+        # An inline input call is one leaf of the expression; its title string
+        # and keyword names are not identifiers the gate below should judge.
+        tokens = set(ident_re.findall(
+            blank_string_literals(self._inline_inputs_masked(expanded))))
         if any(
             self._known_var_is_lexically_shadowed(name)
             for name in tokens
@@ -5105,7 +5825,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # integer length.
         had_math = "std::" in rewritten or bool(re.search(r"\btimeframe\b", expanded))
         if had_math:
-            return f"(int)({rewritten})"
+            return na_preserving_int_cast(rewritten)
         return rewritten
 
     def _lower_reset_expr_via_visitor(self, expanded: str) -> str | None:
@@ -5149,10 +5869,34 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # unwrapped, so simple sites stay byte-identical to the legacy output.
         if ("std::" in rendered or "(double)" in rendered
                 or "script_tf_" in rendered):
-            return f"(int)({rendered})"
+            return na_preserving_int_cast(rendered)
         return rendered
 
 
+    def _ta_run_ctor_args(self, site: TACallSite) -> tuple[list[str], bool]:
+        """The constructor arguments a chart TA site runs with, and whether any
+        is a runtime expression: an input- or timeframe-backed argument as its
+        override-aware runtime read, a compile-time one as its value, any other
+        as the placeholder ``1`` (the constructor guard refuses those first).
+        The ``_ta_initialized_`` reset and ``precalculate()`` both build the
+        site from these, so a precalculated series is sized like the live
+        indicator; built from the compile-time values instead, it kept the
+        input's default (or ``1``) under every override."""
+        args: list[str] = []
+        any_runtime = False
+        for arg_pos, a in enumerate(site.ctor_args):
+            rt = self._runtime_ctor_arg_for_reset(a)
+            if rt is not None:
+                rendered = rt
+                any_runtime = True
+            else:
+                resolved = self._resolve_ta_ctor_arg(a)
+                rendered = resolved if self._is_compile_time_value(resolved) else "1"
+            if self._ta_ctor_arg_is_bool(site, arg_pos):
+                rendered = self._ta_ctor_bool_cpp(rendered)
+            args.append(rendered)
+        return args, any_runtime
+
     def _collect_ta_runtime_resets(
         self,
         *,
@@ -5173,16 +5917,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 continue
             if not site.ctor_args:
                 continue
-            runtime_args: list[str] = []
-            any_runtime = False
-            for a in site.ctor_args:
-                rt = self._runtime_ctor_arg_for_reset(a)
-                if rt is not None:
-                    runtime_args.append(rt)
-                    any_runtime = True
-                else:
-                    resolved = self._resolve_ta_ctor_arg(a)
-                    runtime_args.append(resolved if self._is_compile_time_value(resolved) else "1")
+            if self._ta_dynamic_plan(site) is not None:
+                continue
+            runtime_args, any_runtime = self._ta_run_ctor_args(site)
             if any_runtime:
                 resets.append(
                     f"{site.member_name} = {site.class_name}({', '.join(runtime_args)});"
@@ -5223,6 +5960,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 if not ctor_site.ctor_args:
                     continue
                 for variant in variants:
+                    if self._ta_security_plan(
+                        info["sec_id"], site, variant.get("binding_stack", ())
+                    ) is not None:
+                        continue
                     ctor_args, ctor_arg_stability = self._security_ta_ctor_args_for_variant(
                         info["sec_id"],
                         site,
@@ -5251,25 +5992,24 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                             and lowered_variant
                             and not self._is_compile_time_value(resolved)
                         ):
-                            self._codegen_error(
-                                getattr(site, "node", None),
-                                f"Unsupported requested-context TA constructor "
-                                f"length '{a}' for {site.class_name}: the "
-                                "helper-bound expression is not a stable "
-                                "per-run scalar.",
-                                hint=("Use a literal, an input.*() value, "
-                                      "timeframe.* metadata, or arithmetic "
-                                      "over those for TA lengths."),
+                            arg_nodes = self._security_ta_ctor_arg_nodes(site)
+                            self._refuse_security_ta_ctor_arg(
+                                site, arg_pos, a,
+                                arg_nodes[arg_pos] if arg_pos < len(arg_nodes) else None,
+                                variant.get("binding_stack", ()),
                             )
                         if rt is not None:
-                            runtime_args.append(rt)
+                            rendered = rt
                             any_runtime = True
                         else:
-                            runtime_args.append(
+                            rendered = (
                                 resolved
                                 if self._is_compile_time_value(resolved)
                                 else "1"
                             )
+                        if self._ta_ctor_arg_is_bool(site, arg_pos):
+                            rendered = self._ta_ctor_bool_cpp(rendered)
+                        runtime_args.append(rendered)
                     if any_runtime:
                         resets.append(
                             f"{variant['member_name']} = {site.class_name}({', '.join(runtime_args)});"