@pineforge/codegen-pyodide 0.10.4 → 1.0.0-rc.1

package/pineforge_codegen/codegen/types.py

@@ -33,18 +33,35 @@ tables it needs come from ``codegen/tables.py``.
 
 from __future__ import annotations
 
+import contextlib
+import re
+
 from ..ast_nodes import (
-    ASTNode, Assignment, BinOp, BoolLiteral, ExprStmt, FuncCall, FuncDef, Identifier, IfStmt,
-    MemberAccess, NaLiteral, NumberLiteral, StringLiteral, SwitchStmt,
-    Subscript, Ternary, TupleLiteral, UnaryOp, VarDecl,
+    ASTNode, Assignment, BinOp, BoolLiteral, ColorLiteral, ExprStmt, FuncCall, FuncDef,
+    Identifier, IfStmt,
+    MemberAccess, MethodDef, NaLiteral, NumberLiteral, StringLiteral, SwitchStmt,
+    Subscript, Ternary, TupleAssign, TupleLiteral, UnaryOp, VarDecl,
 )
+from ..errors import Phase
+from ..external_requests import UNPINNED_ANNOTATION
+from ..limits import iter_ast_nodes
 from ..symbols import PineType, TypeSpec, method_receiver_type_name
+from .helpers import (
+    NA_PRESERVING_INT_TYPES,
+    evaluate_args_once,
+    na_preserving_int_cast,
+    pine_truth_cast,
+)
 from .. import signatures as sigs
 from .tables import (
+    ALERT_FREQ_VALUES,
+    ARRAY_ARGS_READ_REPEATEDLY,
     ARRAY_DRAWING_NEW_CTORS,
     ARRAY_METHODS,
+    V5_ARRAY_INDEX_METHODS,
     BAR_BUILTINS,
     BAR_FIELDS,
+    COLOR_CONST_MAP,
     DRAWING_NS,
     DRAWING_TYPE_TO_CPP,
     MATRIX_RETURNING_METHODS,
@@ -71,6 +88,18 @@ COLLECTION_MUTATING_METHODS = frozenset({
 })
 
 
+# Binary operators whose emitted C++ result is a ``bool``, never a number.
+# Pine's ``and``/``or`` lower to ``&&``/``||`` and the relational operators go
+# through the na-aware comparison lambda, which returns ``bool``.
+_BOOL_RESULT_BINOPS = frozenset({
+    "==", "!=", "<", ">", "<=", ">=", "and", "or", "&&", "||",
+})
+
+
+# Array methods whose result is a new array (a vector of doubles, as their
+# ``ARRAY_METHODS`` templates emit it).
+ARRAY_RESULT_METHODS = frozenset({"abs", "standardize", "sort_indices"})
+
 class TypeInferer:
     """Type-spec / C++-type inference helpers shared across visitor mixins.
 
@@ -137,14 +166,15 @@ class TypeInferer:
         if spec.kind == "primitive":
             return {"float": "double", "int": "int", "int64": "int64_t",
                     "bool": "bool", "string": "std::string",
-                    "color": "int"}.get(spec.name or "float", "double")
+                    "color": "int64_t"}.get(spec.name or "float", "double")
         if spec.kind == "udt" and spec.name:
             # Drawing handle structs (P1): map BEFORE the _udt_defs check so
             # array<line> -> std::vector<Line> and scalar line -> Line instead
             # of the old collapse to double / unknown-type-name.
             if spec.name in DRAWING_TYPE_TO_CPP:
                 return DRAWING_TYPE_TO_CPP[spec.name]
-            return spec.name if spec.name in self._udt_defs else "double"
+            return (self._safe_name(spec.name)
+                    if spec.name in self._udt_defs else "double")
         if spec.kind == "array":
             return f"std::vector<{self._type_spec_to_cpp(spec.element)}>"
         if spec.kind == "map":
@@ -172,7 +202,7 @@ class TypeInferer:
         """Generated arena specialization for one user-defined object type."""
         return (
             f"{getattr(self, '_udt_arena_template_cpp_name', '_PFUdtArena')}<"
-            f"{type_name}, "
+            f"{self._safe_name(type_name)}, "
             f"{self._udt_record_cpp_type(type_name)}>"
         )
 
@@ -182,6 +212,227 @@ class TypeInferer:
             self, "_checkpoint_traits_cpp_name", "_PFCheckpointTraits"
         )
 
+    def _udt_array_field_cpp(self, spec: TypeSpec | None,
+                             type_name: str | None = None) -> str | None:
+        """The record type of an array field of the UDT ``type_name``
+        (``_PFArrayField<T>``, base.UDT_ARRAY_FIELD_CPP) when the type is
+        bar-local (``_udt_bar_local_types``), else None: its field stays the
+        ``std::vector<T>`` copy every earlier build stored."""
+        if spec is None or spec.kind != "array" or spec.element is None:
+            return None
+        if type_name not in self._udt_bar_local_types():
+            return None
+        return f"_PFArrayField<{self._type_spec_to_cpp(spec.element)}>"
+
+    def _udt_has_array_fields(self) -> bool:
+        """Whether any emitted UDT record holds a ``_PFArrayField``."""
+        return any(
+            self._udt_array_field_cpp(spec, type_name) is not None
+            for type_name, specs in self._udt_field_type_specs.items()
+            if type_name in self._udt_defs
+            for name, spec in specs.items()
+            if name not in self._udt_omitted_fields.get(type_name, set())
+        )
+
+    def _udt_array_field_target(self, node) -> str | None:
+        """The ``_PFArrayField<T>`` type of the UDT field ``node`` reads, when
+        it is one, else None."""
+        if not isinstance(node, MemberAccess) or self._is_omitted_udt_field(node):
+            return None
+        owner_spec = self._type_spec_from_expr(node.object)
+        if (owner_spec is None or owner_spec.kind != "udt"
+                or owner_spec.name not in self._udt_defs):
+            return None
+        return self._udt_array_field_cpp(
+            self._udt_field_type_specs.get(owner_spec.name, {}).get(node.member),
+            owner_spec.name)
+
+    # Builtin namespaces whose calls never return a user object.
+    _NO_USER_OBJECT_NAMESPACES = frozenset({
+        "ta", "math", "str", "color", "input", "timeframe", "syminfo",
+        "strategy", "table", "line", "label", "box", "linefill", "polyline",
+        "chart", "session", "ticker", "log", "runtime", "alert",
+    })
+
+    _PRIMITIVE_RESULTS = frozenset({
+        PineType.INT, PineType.FLOAT, PineType.BOOL, PineType.STRING,
+        PineType.COLOR,
+    })
+
+    def _may_hold_user_object(self, expr, seen: frozenset = frozenset()) -> bool:
+        """Whether ``expr`` can evaluate to a user-defined object: not a
+        literal, an operator's result, a builtin that returns a primitive or
+        a drawing, or a user function whose result is one of those (its UDT
+        or drawing result, a primitive result type, else what its last
+        expression can hold: ``pick(o) => o`` can return an object)."""
+        if expr is None or isinstance(expr, (
+                NumberLiteral, StringLiteral, BoolLiteral, ColorLiteral,
+                NaLiteral, UnaryOp, BinOp)):
+            return False
+        if isinstance(expr, FuncCall):
+            func_name, namespace = self._resolve_callee(expr.callee)
+            if namespace is None and func_name in self._func_info_map:
+                info = self._func_info_map[func_name]
+                returned = getattr(info, "udt_return_type", None)
+                if returned is not None:
+                    return returned in self._udt_defs
+                if getattr(info, "return_type", None) in self._PRIMITIVE_RESULTS:
+                    return False
+                body = getattr(getattr(info, "node", None), "body", None) or ()
+                if not body or func_name in seen:
+                    return True
+                terminal = body[-1]
+                if isinstance(terminal, ExprStmt):
+                    terminal = terminal.expr
+                return self._may_hold_user_object(terminal, seen | {func_name})
+            return namespace not in self._NO_USER_OBJECT_NAMESPACES
+        if isinstance(expr, Ternary):
+            return (self._may_hold_user_object(expr.true_val, seen)
+                    or self._may_hold_user_object(expr.false_val, seen))
+        return True
+
+    def _udt_bar_local_types(self) -> set[str]:
+        """User types none of whose objects outlives the bar that creates it.
+
+        TradingView keeps a ``var`` array's value per bar: an object kept from
+        an earlier bar reads the array as it was then, while one built this
+        bar holds the array itself (lab tv pf-cgs2-udt-array-fields: a push
+        through ``h.xs`` reaches ``a``; a record kept from the first bar reads
+        one element forever). An object nothing keeps past its bar can alias
+        the array it is built from, which is exact and copies nothing; any
+        other object keeps the copy every earlier build stored. A type escapes
+        its bar when a ``var`` / ``varip`` declaration can hold one, a
+        collection's element type or another type's field is it, a history
+        read reads one, or a ``var`` declaration of a type this cannot tell
+        exists. Cached."""
+        cached = getattr(self, "_udt_bar_local_cache", None)
+        if cached is not None:
+            return cached
+        types = set(self._udt_defs)
+        self._udt_bar_local_cache = set()
+        escaping: set[str] = set()
+
+        def udt_of_hint(hint) -> set[str]:
+            if not hint:
+                return set()
+            return {name for name in types
+                    if re.search(rf"(?<![A-Za-z0-9_.]){re.escape(name)}(?![A-Za-z0-9_])",
+                                 str(hint))}
+
+        def udt_of_spec(spec) -> set[str]:
+            found = set()
+            pending = [spec]
+            while pending:
+                current = pending.pop()
+                if current is None:
+                    continue
+                if current.kind == "udt" and current.name in types:
+                    found.add(current.name)
+                pending.extend((current.element, current.key, current.value))
+            return found
+
+        for type_name, fields in self._udt_defs.items():
+            for field in fields or ():
+                escaping |= udt_of_hint(getattr(field, "type_name", None))
+        ast = getattr(self.ctx, "ast", None)
+        for node in self._walk_ast(ast):
+            if isinstance(node, VarDecl):
+                hint = str(node.type_hint or "")
+                if any(mark in hint for mark in ("<", "[")):
+                    # A collection of objects keeps them past their bar.
+                    escaping |= udt_of_hint(hint)
+                if not (node.is_var or node.is_varip):
+                    continue
+                if hint:
+                    escaping |= udt_of_hint(hint)
+                    continue
+                try:
+                    spec = self._type_spec_from_expr(node.value)
+                except Exception as exc:  # an unresolvable value may hold any type
+                    if getattr(exc, "limit", False):
+                        raise
+                    spec = None
+                if spec is None and isinstance(node.value, FuncCall):
+                    func_name, namespace = self._resolve_callee(node.value.callee)
+                    info = (self._func_info_map.get(func_name)
+                            if namespace is None else None)
+                    returned = getattr(info, "udt_return_type", None)
+                    if returned in types:
+                        escaping.add(returned)
+                        continue
+                if spec is None and self._may_hold_user_object(node.value):
+                    return self._udt_bar_local_cache
+                escaping |= udt_of_spec(spec)
+            elif isinstance(node, FuncCall):
+                func_name, namespace = self._resolve_callee(node.callee)
+                if namespace in ("array", "map", "matrix") or func_name in (
+                        "push", "unshift", "insert", "set", "fill", "put"):
+                    for template in self._template_args_from_call(node) or ():
+                        escaping |= udt_of_hint(template)
+                    for arg in [*node.args, *node.kwargs.values()]:
+                        try:
+                            escaping |= udt_of_spec(self._type_spec_from_expr(arg))
+                        except Exception as exc:
+                            if getattr(exc, "limit", False):
+                                raise
+                            continue
+            elif isinstance(node, Subscript):
+                try:
+                    escaping |= udt_of_spec(self._type_spec_from_expr(node.object))
+                except Exception as exc:
+                    if getattr(exc, "limit", False):
+                        raise
+                    continue
+        self._udt_bar_local_cache = types - escaping
+        return self._udt_bar_local_cache
+
+    def _stable_var_array_names(self) -> set[str]:
+        """Top-level ``var`` arrays no statement rebinds (``:=``): one array
+        object for the whole run, whose member storage keeps that identity,
+        so a UDT field can alias it. Cached."""
+        cached = getattr(self, "_stable_var_array_cache", None)
+        if cached is not None:
+            return cached
+        ast = getattr(self.ctx, "ast", None)
+        top_level_vars = {
+            stmt.name for stmt in getattr(ast, "body", None) or ()
+            if isinstance(stmt, VarDecl) and stmt.is_var and not stmt.is_varip
+        }
+        declarations: dict[str, int] = {}
+        rebound: set[str] = set()
+        for node in self._walk_ast(ast):
+            if isinstance(node, VarDecl):
+                declarations[node.name] = declarations.get(node.name, 0) + 1
+            elif (isinstance(node, Assignment)
+                    and isinstance(node.target, Identifier)):
+                rebound.add(node.target.name)
+        names = set()
+        for name in top_level_vars:
+            # Declared once in the whole program, so no local shadows it.
+            if declarations.get(name) != 1 or name in rebound:
+                continue
+            spec = self._collection_spec_for_name_raw(name)
+            if spec is not None and spec.kind == "array":
+                names.add(name)
+        self._stable_var_array_cache = names
+        return names
+
+    def _udt_array_field_value(self, field_cpp: str, value_node, value_cpp: str) -> str:
+        """The ``_PFArrayField<T>`` a UDT array field takes from ``value_node``:
+        an alias of a stable script ``var`` array (``_stable_var_array_names``)
+        read at the script's level of names, else the value itself, moved or
+        copied in (the snapshot every earlier build stored)."""
+        name = value_node.name if isinstance(value_node, Identifier) else None
+        if (name is not None
+                and name in self._stable_var_array_names()
+                and name not in (getattr(self, "_current_func_param_types", {}) or {})
+                and name not in (getattr(self, "_current_func_local_types", {}) or {})
+                and name not in (getattr(self, "_current_func_locals", ()) or ())
+                and name not in (getattr(self, "_current_loop_vars", ()) or ())
+                and not self._known_var_is_lexically_shadowed(name)):
+            return f"{field_cpp}::alias({value_cpp})"
+        return f"{field_cpp}({value_cpp})"
+
     def _udt_direct_array_fields(self, type_name: str) -> tuple[str, ...]:
         """Direct array-valued fields whose UDT copy semantics are unsupported.
 
@@ -261,7 +512,7 @@ class TypeInferer:
             # (Line{} = na handle), NOT the lowercase Pine name (line{}).
             if spec.name in DRAWING_TYPE_TO_CPP:
                 return f"{DRAWING_TYPE_TO_CPP[spec.name]}{{}}"
-            return f"{spec.name}{{}}"
+            return f"{self._safe_name(spec.name)}{{}}"
         cpp_type = self._type_spec_to_cpp(spec)
         if cpp_type.startswith("std::vector") or cpp_type.startswith("PineMap"):
             return f"{cpp_type}()"
@@ -294,8 +545,14 @@ class TypeInferer:
     def _int_fits_int32(value: int) -> bool:
         return -(1 << 31) <= value < (1 << 31)
 
-    def _pure_int_literal_value(self, node) -> int | None:
-        """Exact value of an expression built only from int literals and
+    @staticmethod
+    def _int_fits_int64(value: int) -> bool:
+        return -(1 << 63) <= value < (1 << 63)
+
+    def _pure_int_literal_value(self, node, names: bool = True,
+                                global_scope: bool = False) -> int | None:
+        """Exact value of an expression built only from int literals, the
+        int constants ``_visit_ident`` inlines as literals (``names``), and
         ``+ - *`` / unary minus, else ``None``.
 
         Pine ``int`` is 64-bit: ``90 * 24 * 60 * 60 * 1000`` (three months in
@@ -303,21 +560,30 @@ class TypeInferer:
         literal arithmetic the same product overflows (wraps to -813 934 592),
         so a ``(time - t0) > threeMonths`` expiry fires on every bar (round 8
         family U: latibonit15 execution-signals-confluence, six lanes; lab tv
-        u-lati-levels-nq15 vs the engine, 2026-09-05). Folding the literal
-        subtree in Python keeps the exact value; the caller emits it as a
+        u-lati-levels-nq15 vs the engine, 2026-09-05). ``400 * MS`` over
+        ``const int MS = 7200000`` is 2 880 000 000 too (lab tv
+        pf-cgs-int64-const, 2026-09-28): the constant is emitted as its
+        literal, so the product was the same C++ ``int`` overflow. Folding
+        the subtree in Python keeps the exact value; the caller emits it as a
         64-bit literal only when it does not fit ``int32`` so every in-range
-        expression is byte-identical to before.
+        expression is byte-identical to before. ``global_scope`` reads names
+        as the script's top level binds them, whatever is being emitted.
         """
         if isinstance(node, NumberLiteral):
             return node.value if isinstance(node.value, int) and not isinstance(node.value, bool) else None
+        if isinstance(node, Identifier):
+            if not names:
+                return None
+            return (self._global_int_constant(node.name) if global_scope
+                    else self._inlined_int_constant(node))
         if isinstance(node, UnaryOp) and node.op == "-":
-            inner = self._pure_int_literal_value(node.operand)
+            inner = self._pure_int_literal_value(node.operand, names, global_scope)
             return -inner if inner is not None else None
         if isinstance(node, BinOp) and node.op in ("+", "-", "*"):
-            left = self._pure_int_literal_value(node.left)
+            left = self._pure_int_literal_value(node.left, names, global_scope)
             if left is None:
                 return None
-            right = self._pure_int_literal_value(node.right)
+            right = self._pure_int_literal_value(node.right, names, global_scope)
             if right is None:
                 return None
             if node.op == "+":
@@ -327,10 +593,528 @@ class TypeInferer:
             return left * right
         return None
 
-    def _literal_overflows_int32(self, node) -> bool:
-        value = self._pure_int_literal_value(node)
+    def _inlined_int_constant(self, node: Identifier) -> int | None:
+        """The int a name is emitted as when ``_visit_ident`` inlines it as a
+        literal (a never-reassigned constant: ``const int MS = 7200000``,
+        ``int step = 2 * 60 * 60 * 1000``), else None. Every read that
+        ``_visit_expr`` / ``_visit_ident`` renders otherwise is None: a
+        dropped no-data request, a ``request.security`` fallback frame, a
+        parameter, a bar field or built-in, an input, and a local that
+        shadows the constant."""
+        if node.annotations and UNPINNED_ANNOTATION in node.annotations:
+            return None
+        if getattr(self, "_security_fallback_frame", None) is not None:
+            return None
+        name = node.name
+        if name == "na" or name in getattr(self, "_pending_decl_outer_alias", {}):
+            return None
+        if (name in getattr(self, "_current_func_series_params", ())
+                or name in getattr(self, "_current_func_param_types", ())
+                or name in BAR_FIELDS or name in BAR_BUILTINS):
+            return None
+        known = getattr(self, "_known_vars", {})
+        if (name not in known
+                or name in getattr(self, "_input_backed_vars", ())
+                or self._known_var_is_lexically_shadowed(name)):
+            return None
+        value = known[name]
+        if isinstance(value, bool) or not isinstance(value, int):
+            return None
+        return value
+
+    def _global_int_constant(self, name: str) -> int | None:
+        """The int constant a top-level name is inlined as (``_known_vars``,
+        not an input, a bar field or a built-in), read at the top level."""
+        if name == "na" or name in BAR_FIELDS or name in BAR_BUILTINS:
+            return None
+        known = getattr(self, "_known_vars", {})
+        if name not in known or name in getattr(self, "_input_backed_vars", ()):
+            return None
+        value = known[name]
+        if isinstance(value, bool) or not isinstance(value, int):
+            return None
+        return value
+
+    def _literal_overflows_int32(self, node, names: bool = False) -> bool:
+        value = self._pure_int_literal_value(node, names)
         return value is not None and not self._int_fits_int32(value)
 
+    def _literal_wide_global(self, name: str, decl=None) -> bool:
+        """Whether the top-level declaration of ``name`` gives it an int
+        constant past int32 -- a literal (``g = 3000000000``) or constant
+        arithmetic (``var int e = 300 * MS``): its slot is ``int64_t``,
+        reassigned or not. Only that slot: the width is not a provenance
+        that travels by spelling through copies, parameters, arrays and
+        helper state (``_wide_int_provenance``), whose consumers keep their
+        types; a callable's or a block's declaration keeps its type too, and
+        so does a callable's local or parameter of that name where it is in
+        scope. With ``decl``, only when ``decl`` is that declaration."""
+        widths = getattr(self, "_top_level_constant_widths", None)
+        if widths is None:
+            widths = self._top_level_constant_widths = {}
+            ast = getattr(self.ctx, "ast", None)
+            for stmt in getattr(ast, "body", None) or ():
+                if (isinstance(stmt, VarDecl) and stmt.value is not None
+                        and stmt.name not in widths):
+                    value = self._pure_int_literal_value(stmt.value, global_scope=True)
+                    widths[stmt.name] = (
+                        stmt, value is not None and not self._int_fits_int32(value))
+        top = widths.get(name)
+        if top is None or not top[1]:
+            return False
+        if decl is not None:
+            return decl is top[0]
+        return not (
+            self._known_var_is_lexically_shadowed(name)
+            or name in getattr(self, "_current_func_param_types", ())
+            or name in getattr(self, "_current_func_series_params", ())
+            or name in getattr(self, "_current_func_locals", ())
+            or name in getattr(self, "_current_func_local_types", {})
+        )
+
+    # C++ text of an ``int`` expression built from decimal literals only.
+    _INT_LITERAL_CPP = re.compile(r"[\s()0-9+\-*]+")
+
+    @classmethod
+    def _int32_literal_cpp_value(cls, cpp: str) -> int | None:
+        """Exact value of C++ text built from decimal literals, ``+ - *`` and
+        parentheses that C++ evaluates in ``int`` (every literal and every
+        partial result fits int32), else None."""
+        if not cls._INT_LITERAL_CPP.fullmatch(cpp or ""):
+            return None
+        import ast as _ast
+        try:
+            tree = _ast.parse(cpp.strip(), mode="eval")
+        except SyntaxError:
+            return None
+
+        def value(node):
+            if isinstance(node, _ast.Constant) and type(node.value) is int:
+                result = node.value
+            elif isinstance(node, _ast.UnaryOp) and isinstance(node.op, (_ast.USub, _ast.UAdd)):
+                inner = value(node.operand)
+                if inner is None:
+                    return None
+                result = -inner if isinstance(node.op, _ast.USub) else inner
+            elif isinstance(node, _ast.BinOp) and isinstance(
+                    node.op, (_ast.Add, _ast.Sub, _ast.Mult)):
+                left, right = value(node.left), value(node.right)
+                if left is None or right is None:
+                    return None
+                result = (left + right if isinstance(node.op, _ast.Add)
+                          else left - right if isinstance(node.op, _ast.Sub)
+                          else left * right)
+            else:
+                return None
+            return result if cls._int_fits_int32(result) else None
+
+        return value(tree.body)
+
+    def _fold_int32_overflow_cpp(self, op: str, left_cpp: str, right_cpp: str) -> str | None:
+        """``left op right`` as a 64-bit literal when both sides are C++
+        ``int`` literal arithmetic whose exact result leaves int32 (Pine's
+        ``int`` is 64-bit; C++ would overflow), else None. The emitted text
+        is what decides: a name inlined as its literal, a global expanded
+        into its declaration or a helper parameter bound to a literal all
+        read as literals here."""
+        if op not in ("+", "-", "*"):
+            return None
+        left = self._int32_literal_cpp_value(left_cpp)
+        if left is None:
+            return None
+        right = self._int32_literal_cpp_value(right_cpp)
+        if right is None:
+            return None
+        result = left + right if op == "+" else left - right if op == "-" else left * right
+        if self._int_fits_int32(result):
+            return None
+        return f"static_cast<int64_t>({result}LL)"
+
+    # A runtime integer the C++ holds in 32 bits (bar_index, a counter, a loop
+    # binder, an input without a declared range) is taken to stay within 2**24
+    # (16 777 216: more bars than thirty years of one-minute data).
+    _RUNTIME_INT_BOUND = 1 << 24
+
+    def _int_arith_leaves_int32(self, node, owner_info=None) -> bool:
+        """Whether ``node`` is an integer ``+ - *`` the C++ would compute in
+        32-bit ``int`` arithmetic -- both operands are 32-bit integers
+        (``_narrow_int_bound``) -- while its magnitude can leave int32.
+
+        Pine's ``int`` is 64-bit: ``days * 86400000`` over ``days =
+        input.int(30)`` is 2592000000 on TradingView, and ``bar_index *
+        7200000`` passes int32 at bar 299 (lab tv pf-cgs2-int64-products).
+        Such a node is computed in 64 bits (``_visit_binop``) and its value
+        is wide wherever it is stored (``_expr_returns_wide_int``). A node
+        whose magnitude fits int32 keeps its spelling."""
+        if not (isinstance(node, BinOp) and node.op in ("+", "-", "*")):
+            return False
+        bound = self._int_arith_bound(node, owner_info)
+        return bound is not None and bound > (1 << 31) - 1
+
+    def _int_arith_bound(self, node: BinOp, owner_info=None) -> int | None:
+        """The bound on ``|value|`` of a ``+ - *`` over two 32-bit integer
+        operands, uncapped; None when an operand is not one."""
+        left = self._narrow_int_bound(node.left, owner_info)
+        if left is None:
+            return None
+        right = self._narrow_int_bound(node.right, owner_info)
+        if right is None:
+            return None
+        return left * right if node.op == "*" else left + right
+
+    def _narrow_int_bound(self, node, owner_info=None) -> int | None:
+        """A bound on ``|value|`` of an integer expression the C++ holds in a
+        32-bit ``int``, else None (a double, a 64-bit integer, or a shape this
+        does not know). Literals and inlined constants are exact, an
+        ``input.int`` is its declared range (its default and 2**24 without
+        one), and any other runtime integer is ``_RUNTIME_INT_BOUND``."""
+        if isinstance(node, NumberLiteral):
+            value = node.value
+            if type(value) is int and self._int_fits_int32(value):
+                return abs(value)
+            return None
+        if isinstance(node, UnaryOp):
+            if node.op != "-":
+                return None
+            return self._narrow_int_bound(node.operand, owner_info)
+        if isinstance(node, BinOp):
+            if node.op not in ("+", "-", "*"):
+                return None
+            bound = self._int_arith_bound(node, owner_info)
+            # A node past int32 is computed in 64 bits: no longer 32-bit.
+            return bound if bound is not None and bound <= (1 << 31) - 1 else None
+        if isinstance(node, Ternary):
+            arms = [self._narrow_int_bound(arm, owner_info)
+                    for arm in (node.true_val, node.false_val)]
+            return None if None in arms else max(arms)
+        if isinstance(node, Identifier):
+            return self._narrow_int_name_bound(node.name, owner_info)
+        return None
+
+    @contextlib.contextmanager
+    def _int_width_scan(self, epoch_only: bool | None = None):
+        """The scope of a whole-script width cache computation: names resolve
+        against the scanned code's owner, not the callable being emitted
+        (``_narrow_int_name_info``); ``epoch_only`` sets the epoch-only mode
+        (``_wide_int_array_names``) for its duration."""
+        self._int_width_scan_depth = getattr(self, "_int_width_scan_depth", 0) + 1
+        saved = getattr(self, "_wide_int_epoch_only", False)
+        if epoch_only is not None:
+            self._wide_int_epoch_only = epoch_only
+        try:
+            yield
+        finally:
+            self._int_width_scan_depth -= 1
+            self._wide_int_epoch_only = saved
+
+    def _narrow_int_name_bound(self, name: str, owner_info=None) -> int | None:
+        """``_narrow_int_bound`` of a bare name (``_narrow_int_name_info``)."""
+        info = self._narrow_int_name_info(name, owner_info)
+        return info[0] if info is not None else None
+
+    def _narrow_int_name_info(self, name: str,
+                              owner_info=None) -> tuple[int, bool] | None:
+        """``(bound, may_be_na)`` of a bare name the C++ holds in a 32-bit
+        ``int``: a parameter or local of the callable being emitted (or
+        ``owner_info``'s), a counted loop's binder, an inlined int constant,
+        an input, ``bar_index`` / ``last_bar_index``, or a script variable
+        whose slot is a C++ ``int``; None for any other name. A parameter, a
+        local and a script variable can hold ``na``; a binder, a constant, an
+        input and the bar index cannot.
+
+        While a width cache is computed (``_int_width_scan``) the callable
+        being emitted is not the one the scanned code belongs to, so only
+        ``owner_info`` resolves a callable's names."""
+        runtime = self._RUNTIME_INT_BOUND
+        # ``owner_info`` names the callable the name belongs to: resolve it
+        # there, whichever callable is being emitted.
+        emitting = (getattr(self, "_int_width_scan_depth", 0) == 0
+                    and owner_info is None)
+        owner_node = getattr(owner_info, "node", None)
+        param_types = (getattr(self, "_current_func_param_types", {}) or {}
+                       if emitting else {})
+        if name in param_types or (emitting and name in (
+                getattr(self, "_current_func_series_params", ()) or ())):
+            return (runtime, True) if param_types.get(name) == "int" else None
+        if owner_node is not None and name in owner_node.params:
+            index = owner_node.params.index(name)
+            if (getattr(owner_info, "is_udt_method", False) and index == 0) \
+                    or name in self.ctx.func_series_vars.get(owner_info.name, set()) \
+                    or (owner_info.name, index) in self._wide_int_provenance()[1]:
+                return None
+            declared = list(getattr(self.ctx, "func_declared_param_type_specs",
+                                    {}).get(owner_info.name, ()))
+            spec = declared[index] if index < len(declared) else None
+            if spec is None:
+                specs = list(getattr(owner_info, "param_type_specs", ()) or ())
+                spec = specs[index] if index < len(specs) else None
+            if (spec is not None and spec.kind == "primitive"
+                    and spec.name == "int"):
+                return runtime, True
+            if (spec is None and self._func_param_int_cpp_type(
+                    owner_info, index, None) == "int"):
+                # An untyped parameter whose calls carry no TypeSpec
+                # (``toMs(year(time))``) is the emitter's ``int`` still.
+                return runtime, True
+            return None
+        if emitting and name in (
+                getattr(self, "_current_counted_loop_vars", ()) or ()):
+            # A counted loop's binder is ``for (int i = ...)``.
+            return runtime, False
+        if emitting and name in (getattr(self, "_current_loop_vars", ()) or ()):
+            # A ``for ... in`` binder: an element, a map entry or an index,
+            # 32-bit only when its spec says ``int`` (a float element is a
+            # double), and an element can be na.
+            spec = (getattr(self, "_current_loop_var_specs", {}) or {}).get(name)
+            if (spec is not None and spec.kind == "primitive"
+                    and spec.name == "int"):
+                return runtime, True
+            return None
+        local_types = (getattr(self, "_current_func_local_types", {}) or {}
+                       if emitting else {})
+        if name in local_types or (emitting and name in (
+                getattr(self, "_current_func_locals", ()) or ())):
+            return (runtime, True) if local_types.get(name) == "int" else None
+        if owner_node is not None:
+            hints = {str(child.type_hint or "") for child in
+                     self._walk_ast_list(owner_node.body)
+                     if isinstance(child, VarDecl) and child.name == name}
+            if hints:
+                # A local of ``owner_info`` read outside its emission (its
+                # result type is decided before its locals are registered):
+                # a declared ``int`` is 32-bit, anything else unknown.
+                return (runtime, True) if hints == {"int"} else None
+        if name in BAR_FIELDS:
+            return None
+        if name in ("bar_index", "last_bar_index"):
+            return runtime, False
+        if name in BAR_BUILTINS or name in self._INTEGRAL_BUILTINS:
+            return None
+        if owner_node is None and self._known_var_is_lexically_shadowed(name):
+            # A block's local of that spelling: its type is not the global's.
+            return None
+        known = getattr(self, "_known_vars", {})
+        if name in getattr(self, "_input_backed_vars", ()):
+            bound = self._input_int_bound(name)
+            return (bound, False) if bound is not None else None
+        if name in known:
+            value = known[name]
+            if type(value) is int and self._int_fits_int32(value):
+                return abs(value), False
+            return None
+        if name in self._wide_int_provenance()[0]:
+            return None
+        if (getattr(self, "_int_width_scan_depth", 0) == 0
+                and self._literal_wide_global(name)):
+            # A top-level int constant past int32 initializes an int64_t
+            # slot (CGINT5a), reassigned or not: where it is emitted it is no
+            # 32-bit operand. A width scan keeps it one: it cannot tell the
+            # block local that may shadow it there (``int g = bar_index``),
+            # and a product it reads is 64-bit either way.
+            return None
+        return ((runtime, True)
+                if self._slot_scalar_cpp_type(name) == "int" else None)
+
+    def _int_operand_may_be_na(self, node, owner_info=None) -> bool:
+        """Whether a 32-bit int operand ``_narrow_int_bound`` accepts can be
+        ``na``: a leaf that is a parameter, a local or a script variable
+        (``_narrow_int_name_info``). Literals, inlined constants, inputs, a
+        counted loop's binder and the bar index cannot."""
+        if isinstance(node, NumberLiteral):
+            return False
+        if isinstance(node, UnaryOp):
+            return self._int_operand_may_be_na(node.operand, owner_info)
+        if isinstance(node, BinOp):
+            return (self._int_operand_may_be_na(node.left, owner_info)
+                    or self._int_operand_may_be_na(node.right, owner_info))
+        if isinstance(node, Ternary):
+            return (self._int_operand_may_be_na(node.true_val, owner_info)
+                    or self._int_operand_may_be_na(node.false_val, owner_info))
+        if isinstance(node, Identifier):
+            info = self._narrow_int_name_info(node.name, owner_info)
+            return info is None or info[1]
+        return True
+
+    def _na_aware_wide_is_double(self, node) -> bool:
+        """Whether ``node`` is a 64-bit ``+ - *`` (``_int_arith_leaves_int32``)
+        over an operand that can be na, which ``_wide_int_arith_cpp`` emits
+        as a double."""
+        return (isinstance(node, BinOp) and self._int_arith_leaves_int32(node)
+                and self._int_operand_may_be_na(node))
+
+    def _holds_na_aware_wide_double(self, expr) -> bool:
+        """Whether ``expr`` holds such a double-valued product: an integer
+        store of it narrows na-preserving (quirk 9), not implicitly."""
+        return expr is not None and any(
+            isinstance(sub, BinOp) and self._na_aware_wide_is_double(sub)
+            for sub, _depth in iter_ast_nodes(expr))
+
+    def _wide_int_arith_cpp(self, node, left: str, right: str, lower) -> str:
+        """The C++ of an integer ``+ - *`` computed in 64 bits
+        (``_int_arith_leaves_int32``): ``lower`` over the left operand cast to
+        ``int64_t``. An operand that can be ``na`` makes the value ``na``, as
+        Pine's arithmetic does: the widening ``static_cast`` reads the
+        sentinel ``na<int>()`` as the number -2147483648 (quirk 9). That form
+        is a ``double`` (``_emitted_value_is_double``): the slot such a value
+        lands in is a double as often as an ``int64_t`` (a global holding
+        integer arithmetic is declared from ``_infer_type``), and a double
+        keeps ``na`` where ``na<int64_t>()`` reads -9.2e18; an integer slot
+        narrows it na-preserving (every integer store of one does: arrays,
+        map and matrix values, parameters). A double is exact up to 2**53, a
+        product past it rounds."""
+        if not self._int_operand_may_be_na(node):
+            return lower(f"static_cast<int64_t>({left})", right)
+        return (f"[&]() -> double {{ auto _pf_wide_l = ({left}); "
+                f"auto _pf_wide_r = ({right}); "
+                f"return (is_na(_pf_wide_l) || is_na(_pf_wide_r)) "
+                f"? na<double>() : static_cast<double>("
+                f"{lower('static_cast<int64_t>(_pf_wide_l)', '_pf_wide_r')}); }}()")
+
+    def _input_int_bound(self, name: str) -> int | None:
+        """A bound on an int input's value: its declared range when it has
+        both ends, else its default and ``_RUNTIME_INT_BOUND`` (an override
+        can take any value). None for an input that is not an int."""
+        call = getattr(self, "_input_var_to_call", {}).get(name)
+        default = getattr(self, "_known_vars", {}).get(name)
+        if call is None or type(default) is not int:
+            return None
+        func_name, namespace = self._resolve_callee(call.callee)
+        if not ((namespace == "input" and func_name == "int")
+                or (namespace is None and func_name == "input")):
+            return None
+        ends = []
+        for index, key in ((2, "minval"), (3, "maxval")):
+            node = (call.args[index] if namespace == "input"
+                    and len(call.args) > index else call.kwargs.get(key))
+            # An input is a top-level declaration: a named bound reads the
+            # top-level constant, whichever callable is being emitted.
+            value = (self._pure_int_literal_value(node, global_scope=True)
+                     if node is not None else None)
+            if value is not None:
+                ends.append(abs(value))
+        if len(ends) == 2:
+            return max(abs(default), *ends)
+        return max(abs(default), self._RUNTIME_INT_BOUND, *ends)
+
+    def _holds_wide_int_constant(self, expr) -> bool:
+        """Whether ``expr`` is, or selects, an int constant past int32
+        (``3000000000``, ``c ? 0 : 400 * 7200000``): the slot holding its
+        value -- a tuple element, a function's or method's result -- is
+        ``int64_t``. Only that slot: the width does not travel through the
+        spelling-keyed provenance (``_wide_int_provenance``)."""
+        if isinstance(expr, ExprStmt):
+            expr = expr.expr
+        if isinstance(expr, NumberLiteral):
+            return (type(expr.value) is int
+                    and not self._int_fits_int32(expr.value))
+        if isinstance(expr, (BinOp, UnaryOp)):
+            return self._literal_overflows_int32(expr)
+        if isinstance(expr, Ternary):
+            return (self._holds_wide_int_constant(expr.true_val)
+                    or self._holds_wide_int_constant(expr.false_val))
+        return False
+
+    def _widen_int_slot(self, cpp_type: str, expr, owner_info=None) -> str:
+        """``int64_t`` for an ``int`` slot ``expr`` gives a 64-bit value."""
+        if cpp_type == "int" and (
+                self._holds_wide_int_constant(expr)
+                or self._expr_returns_wide_int(expr, owner_info, set(), None)):
+            return "int64_t"
+        return cpp_type
+
+    def _udt_receiver_type_name(self, receiver, owner_info=None) -> str | None:
+        """The user type of a field read's receiver: a method's own receiver
+        parameter by its declared type, anything else by its TypeSpec."""
+        owner_node = getattr(owner_info, "node", None)
+        if (getattr(owner_info, "is_udt_method", False)
+                and owner_node is not None and owner_node.params
+                and isinstance(receiver, Identifier)
+                and receiver.name == owner_node.params[0]):
+            specs = list(getattr(owner_info, "param_type_specs", ()) or ())
+            return (method_receiver_type_name(specs[0] if specs else None)
+                    or getattr(owner_info, "udt_type_name", None))
+        try:
+            spec = self._type_spec_from_expr(receiver)
+        except Exception as exc:  # an unresolvable receiver holds no wide field
+            if getattr(exc, "limit", False):
+                raise
+            return None
+        if spec is not None and spec.kind == "udt":
+            return spec.name
+        return None
+
+    def _wide_udt_int_fields(self) -> set[tuple[str, str]]:
+        """``(type, field)`` of the UDT ``int`` fields holding a 64-bit value:
+        a default or a write (``T.new(...)``, ``obj.field := v``) that is a
+        constant past int32 or a wide value (``_expr_returns_wide_int``).
+        The field is ``int64_t`` storage already; its reads carry the width
+        (``method big(U this) => this.v * 2`` over ``int v = 3000000000``
+        is 6000000000 on TradingView). Iterated to a fixpoint and cached."""
+        cached = getattr(self, "_wide_udt_int_field_cache", None)
+        if cached is not None:
+            return cached
+        fields: set[tuple[str, str]] = set()
+        self._wide_udt_int_field_cache = fields
+        udt_defs = getattr(self, "_udt_defs", {}) or {}
+        int_fields = {
+            (type_name, field.name): index
+            for type_name, decl_fields in udt_defs.items()
+            for index, field in enumerate(decl_fields or ())
+            if getattr(field, "type_name", "") == "int"
+        }
+        if not int_fields:
+            return fields
+        writes: list = []
+        for (type_name, name), index in int_fields.items():
+            default = udt_defs[type_name][index].default
+            if default is not None:
+                writes.append(((type_name, name), default, None))
+
+        def collect(node, owner) -> None:
+            if (isinstance(node, FuncCall)
+                    and isinstance(node.callee, MemberAccess)
+                    and isinstance(node.callee.object, Identifier)
+                    and node.callee.member == "new"
+                    and node.callee.object.name in udt_defs):
+                type_name = node.callee.object.name
+                names = [f.name for f in udt_defs[type_name] or ()]
+                bound = list(zip(names, node.args))
+                bound += [(key, value) for key, value in node.kwargs.items()
+                          if key in names]
+                for name, value in bound:
+                    if (type_name, name) in int_fields:
+                        writes.append(((type_name, name), value, owner))
+            elif (isinstance(node, Assignment)
+                    and isinstance(node.target, MemberAccess)):
+                type_name = self._udt_receiver_type_name(
+                    node.target.object, owner)
+                if (type_name, node.target.member) in int_fields:
+                    writes.append(((type_name, node.target.member),
+                                   node.value, owner))
+
+        for info in getattr(self.ctx, "func_infos", ()):
+            node = getattr(info, "node", None)
+            if node is not None:
+                for child in self._walk_ast_list(node.body):
+                    collect(child, info)
+        ast = getattr(self.ctx, "ast", None)
+        for stmt in getattr(ast, "body", None) or ():
+            if isinstance(stmt, (FuncDef, MethodDef)):
+                continue
+            for child in self._walk_ast(stmt):
+                collect(child, None)
+        changed = True
+        with self._int_width_scan(epoch_only=False):
+            while changed:
+                changed = False
+                for key, value, owner in writes:
+                    if key not in fields and (
+                            self._holds_wide_int_constant(value)
+                            or self._expr_returns_wide_int(value, owner, set(), None)):
+                        fields.add(key)
+                        changed = True
+        return fields
+
     def _array_receiver_and_value(self, call):
         """``(receiver_name, value_node)`` of an element-writing array call in
         either form (``array.push(a, v)`` / ``a.push(v)``), else ``None``."""
@@ -364,7 +1148,15 @@ class TypeInferer:
         ``set`` / ``insert`` / ``fill``, or is built by ``array.new_int`` /
         ``array.new<int>`` / ``array.from`` from one. Their element type is
         ``int64_t`` (TypeSpec primitive ``int64``): Pine's ``int`` holds the
-        epoch, ``std::vector<int>`` truncates it. Cached on the instance."""
+        epoch, ``std::vector<int>`` truncates it. Cached on the instance.
+
+        Only an epoch widens an array (the scan runs in the epoch-only mode):
+        a declared ``array<int>`` parameter, result or field stays
+        ``std::vector<int>``, which a widened argument does not bind to, so a
+        value that is wide only by 64-bit arithmetic or a constant past int32
+        (``bars.push(bar_index * 1000)``) keeps the array's C++ ``int``, is
+        narrowed na-preserving where it is stored and warns
+        (``_array_init_value_expr``)."""
         cached = getattr(self, "_wide_int_array_cache", None)
         if cached is not None:
             return cached
@@ -415,16 +1207,17 @@ class TypeInferer:
                     names.add(target)
 
         ast = getattr(self.ctx, "ast", None)
-        for _round in range(8):
-            before = len(names)
-            if ast is not None:
-                scan(self._walk_ast(ast), None)
-            for info in getattr(self.ctx, "func_infos", ()):
-                node = getattr(info, "node", None)
-                if node is not None:
-                    scan(self._walk_ast_list(node.body), info)
-            if len(names) == before:
-                break
+        with self._int_width_scan(epoch_only=True):
+            for _round in range(8):
+                before = len(names)
+                if ast is not None:
+                    scan(self._walk_ast(ast), None)
+                for info in getattr(self.ctx, "func_infos", ()):
+                    node = getattr(info, "node", None)
+                    if node is not None:
+                        scan(self._walk_ast_list(node.body), info)
+                if len(names) == before:
+                    break
         return names
 
     def _widen_array_spec_for_name(self, name, spec):
@@ -592,6 +1385,11 @@ class TypeInferer:
                         return TypeSpec.primitive("int64")
                     return TypeSpec.primitive("int")
             return None
+        if self._is_color_value(node):
+            # A color is a packed-ARGB ``int64_t``: ``array.from(color.red,
+            # color.new(c, 50))`` is ``std::vector<int64_t>``, which a
+            # ``double`` vector cannot be braced from.
+            return TypeSpec.primitive("color")
         spec = self._type_spec_from_expr(node)
         if spec is not None:
             return spec
@@ -611,6 +1409,40 @@ class TypeInferer:
                     return TypeSpec.primitive(primitive_name)
         return None
 
+    def _is_color_value(self, node, _depth: int = 0) -> bool:
+        """Whether ``node`` is a color value: a literal, a ``color.*``
+        constant, a ``color.new`` / ``rgb`` / ``from_gradient`` call, a
+        conditional selecting one, or a script variable declared ``color`` or
+        bound to one (``c1 = color.new(...)``, which the analyzer types
+        float)."""
+        if _depth > 16 or node is None:
+            return False
+        if isinstance(node, ColorLiteral):
+            return True
+        if isinstance(node, MemberAccess):
+            return (isinstance(node.object, Identifier)
+                    and node.object.name == "color"
+                    and node.member in COLOR_CONST_MAP)
+        if isinstance(node, FuncCall):
+            func_name, namespace = self._resolve_callee(node.callee)
+            return namespace == "color" and func_name in (
+                "new", "rgb", "from_gradient")
+        if isinstance(node, Ternary):
+            return (self._is_color_value(node.true_val, _depth + 1)
+                    or self._is_color_value(node.false_val, _depth + 1))
+        if isinstance(node, Identifier):
+            if self._slot_scalar_cpp_type(node.name) != "int64_t":
+                return False
+            sym = self._variable_symbol(node.name)
+            if sym is not None and sym.pine_type == PineType.COLOR:
+                return True
+            if (node.name in getattr(self, "_current_func_local_types", {})
+                    or node.name in getattr(self, "_current_func_param_types", {})):
+                return False
+            value = getattr(self.ctx, "global_expr_map", {}).get(node.name)
+            return self._is_color_value(value, _depth + 1)
+        return False
+
     @staticmethod
     def _selection_terminal_expr(body: list[ASTNode] | None) -> ASTNode | None:
         """Return one if/switch branch's value expression, if present."""
@@ -650,6 +1482,13 @@ class TypeInferer:
 
         Returns ``None`` when the node's type cannot be narrowed beyond
         the runtime default (most callers fall back to ``double``)."""
+        budget = getattr(self, "_budget", None)
+        if budget is not None:
+            # A method chain re-infers each receiver more than once, so this
+            # recursion can outgrow the visitor checkpoints.
+            self._budget_visit_count += 1
+            if self._budget_visit_count % 128 == 0:
+                budget.check(getattr(node, "loc", None), Phase.CODEGEN)
         if isinstance(node, NumberLiteral):
             return TypeSpec.primitive("float" if isinstance(node.value, float) else "int")
         if isinstance(node, BoolLiteral):
@@ -929,6 +1768,23 @@ class TypeInferer:
                 receiver_spec = self._type_spec_from_expr(receiver_node)
                 if receiver_spec is not None and receiver_spec.kind == "matrix":
                     return receiver_spec
+            # ``matrix.row(m, i)`` / ``matrix.col`` / ``matrix.eigenvalues``
+            # return arrays, as their method forms below do; an untyped
+            # ``r = matrix.row(m, 0)`` was declared a double.
+            if namespace == "matrix" and func_name in ("row", "col", "eigenvalues"):
+                receiver_node = node.args[0] if node.args else node.kwargs.get("id")
+                receiver_spec = self._type_spec_from_expr(receiver_node)
+                if receiver_spec is not None and receiver_spec.kind == "matrix":
+                    if func_name == "eigenvalues":
+                        return TypeSpec.array(TypeSpec.primitive("float"))
+                    return TypeSpec.array(receiver_spec.element)
+            # array.abs / standardize / sort_indices build a new array, which
+            # their templates (``ARRAY_METHODS``) emit as a vector of doubles.
+            if namespace == "array" and func_name in ARRAY_RESULT_METHODS:
+                receiver_node = node.args[0] if node.args else node.kwargs.get("id")
+                receiver_spec = self._type_spec_from_expr(receiver_node)
+                if receiver_spec is not None and receiver_spec.kind == "array":
+                    return TypeSpec.array(TypeSpec.primitive("float"))
             if namespace == "map" and func_name == "new":
                 key = self._type_spec_from_hint_name(targs[0]) if len(targs) > 0 else TypeSpec.primitive("string")
                 val = self._type_spec_from_hint_name(targs[1]) if len(targs) > 1 else TypeSpec.primitive("float")
@@ -967,6 +1823,8 @@ class TypeInferer:
                         return recv_spec.element
                     if member_name in ("copy", "slice"):
                         return recv_spec
+                    if member_name in ARRAY_RESULT_METHODS:
+                        return TypeSpec.array(TypeSpec.primitive("float"))
                 if recv_spec is not None and recv_spec.kind == "map":
                     if member_name in ("put", "get", "remove"):
                         return recv_spec.value
@@ -1124,7 +1982,8 @@ class TypeInferer:
         )
 
     def _array_method_expr(
-        self, array_expr: str, method: str, args: list[str], spec: TypeSpec | None = None,
+        self, array_expr: str, method: str, args: list[str],
+        spec: TypeSpec | None = None, node: ASTNode | None = None,
     ) -> str:
         """Lower ``arr.method(...)`` to its C++ form, validating numeric requirements."""
         spec = spec or TypeSpec.array(TypeSpec.primitive("float"))
@@ -1133,14 +1992,33 @@ class TypeInferer:
         if method == "copy":
             lower_receiver = lambda recv: f"{arr_cpp_type}({recv})"
         elif method == "slice":
+            # TradingView aliases primitive source elements bidirectionally.
+            # Our std::vector lowering owns a copy; a true view needs a
+            # lifetime-safe collection representation across all array lanes.
+            # Keep the compiling lowering and surface the measured divergence.
+            warned = getattr(self, "_slice_alias_warned_nodes", set())
+            if node is None or id(node) not in warned:
+                self._codegen_warning(
+                    node,
+                    "array.slice returns a copy in PineForge; TradingView slices "
+                    "share source elements, so writes through either array can diverge.",
+                    hint="Avoid mutating a slice or its source while the slice is used.",
+                )
+                if node is not None:
+                    warned.add(id(node))
+                    self._slice_alias_warned_nodes = warned
             # Bounds-checked in the shared helper; the element type stays
             # caller-supplied so the typed lane keeps its own vector type.
             lower_receiver = lambda recv: checked_array_slice(
                 recv, args, result_type=arr_cpp_type
             )
         elif method == "join" and elem_cpp == "std::string":
-            sep = args[0] if args else 'std::string(",")'
-            lower_receiver = lambda recv: f"[&](){{ std::string r; for(size_t i=0;i<{recv}.size();i++){{ if(i>0)r+={sep}; r+={recv}[i]; }} return r; }}()"
+            join_args = list(args) or ['std::string(",")']
+            lower_receiver = lambda recv: evaluate_args_once(
+                join_args, ARRAY_ARGS_READ_REPEATEDLY["join"],
+                lambda a: f"[&](){{ std::string __pf_r; for(size_t __pf_i=0;__pf_i<{recv}.size();__pf_i++){{ if(__pf_i>0)__pf_r+={a[0]}; __pf_r+={recv}[__pf_i]; }} return __pf_r; }}()",
+                "_pf_array_a",
+            )
         else:
             numeric_only = {
                 "sum", "avg", "min", "max", "range", "stdev", "variance", "median",
@@ -1191,8 +2069,15 @@ class TypeInferer:
                 arg_bindings.append((token, args[arg_index]))
             self._array_arg_counter = counter
 
+            table = (V5_ARRAY_INDEX_METHODS
+                     if self._pine_v5_body and method in V5_ARRAY_INDEX_METHODS
+                     else ARRAY_METHODS)
+
             def lower_receiver(recv: str) -> str:
-                lowered = ARRAY_METHODS[method](recv, bound_args)
+                lowered = evaluate_args_once(
+                    bound_args, ARRAY_ARGS_READ_REPEATEDLY.get(method, ()),
+                    lambda a: table[method](recv, a), "_pf_array_a",
+                )
                 for token, original in reversed(arg_bindings):
                     lowered = (
                         f"[&](){{ auto {token}=({original}); "
@@ -1258,7 +2143,7 @@ class TypeInferer:
                 owner,
                 set(),
                 getattr(self, "_active_call_site_idx", None),
-            ) or self._is_int64_builtin_init(node.name):
+            ) or self._is_int64_builtin_init(node.name, node):
                 return "int64_t"
             return cpp_type
 
@@ -1319,13 +2204,76 @@ class TypeInferer:
         # int64_t buffer: epoch-ms overflow int32 and the na sentinel would be
         # misdetected. ``_is_int64_builtin_init`` only matches user vars whose
         # init RHS is such a builtin, so also match the builtin name directly.
-        if name in INT64_BUILTINS or self._is_int64_builtin_init(name):
+        if name in INT64_BUILTINS:
+            return "int64_t"
+        sym = self._variable_symbol(name)
+        # A float or bool an epoch reaches keeps its type: the analyzer types
+        # every request.security value float (a double holds an epoch
+        # exactly), and a name is keyed by spelling across scopes.
+        if self._is_int64_builtin_init(name) and (
+            sym is None
+            or sym.pine_type not in (PineType.FLOAT, PineType.BOOL, PineType.STRING)
+        ):
+            # So does a function's local, which the global scope does not
+            # hold: ``float x = time`` is a float series (``x - x[1]`` is na
+            # on the first bar, not a difference with the integer sentinel).
+            local = self._callable_series_local_symbol(name) if sym is None else None
+            if local is not None and local.pine_type == PineType.FLOAT:
+                return "double"
             return "int64_t"
-        sym = self.ctx.symbols.resolve(name)
         if sym is not None:
             return PINE_TYPE_TO_CPP.get(sym.pine_type, "double")
         return "double"
 
+    def _variable_symbol(self, name: str):
+        """The symbol the variable ``name`` resolves to.
+
+        The symbol table keeps one name per scope, and a user function is
+        defined in the global scope under its name, typed by what it
+        returns. A function-local variable of the same spelling -- the
+        ``float f`` series of another function beside ``f(x) =>
+        str.tostring(x)`` -- resolved there once the analyzer had left its
+        scope. Inside a function the variable is that function's own
+        symbol; outside one, a series is the symbol of the function that
+        keeps it (``func_series_vars``).
+        """
+        sym = self.ctx.symbols.resolve(name)
+        if name not in getattr(self, "_func_names", ()):
+            return sym
+        active = getattr(self, "_active_func_name", None)
+        if active:
+            scope_names = {f"func_{active}"}
+        else:
+            scope_names = {
+                f"func_{owner}"
+                for owner, names in getattr(self.ctx, "func_series_vars", {}).items()
+                if name in names
+            }
+        for scope in self.ctx.symbols.all_scopes:
+            if scope.name in scope_names and name in scope.symbols:
+                return scope.symbols[name]
+        return sym
+
+    def _callable_series_local_symbol(self, name: str):
+        """The symbol of the function-local series ``name``: the one every
+        function or method keeping it as a series (``func_series_vars``)
+        declares in its scope, else None when they disagree or none does."""
+        scope_names = {
+            # A method ``Type.name`` scopes its body as ``method_Type_name``.
+            f"method_{owner.replace('.', '_', 1)}" if "." in owner
+            else f"func_{owner}"
+            for owner, names in getattr(self.ctx, "func_series_vars", {}).items()
+            if name in names
+        }
+        found = [
+            scope.symbols[name]
+            for scope in self.ctx.symbols.all_scopes
+            if scope.name in scope_names and name in scope.symbols
+        ]
+        if not found or any(s.pine_type != found[0].pine_type for s in found):
+            return None
+        return found[0]
+
     def _series_param_element_cpp_type(
         self,
         func_info,
@@ -1364,7 +2312,7 @@ class TypeInferer:
             if spec.name == "bool":
                 return "bool"
             if spec.name == "color":
-                return "int"
+                return "int64_t"
             if spec.name == "float":
                 return "double"
 
@@ -1382,7 +2330,7 @@ class TypeInferer:
             if pine_type == PineType.BOOL:
                 return "bool"
             if pine_type == PineType.COLOR:
-                return "int"
+                return "int64_t"
             if pine_type == PineType.FLOAT:
                 return "double"
 
@@ -1394,7 +2342,7 @@ class TypeInferer:
             if spec.name == "bool":
                 return "bool"
             if spec.name == "color":
-                return "int"
+                return "int64_t"
             if spec.name == "float":
                 return "double"
         param_types = list(getattr(func_info, "param_types", ()) or ())
@@ -1404,7 +2352,7 @@ class TypeInferer:
         if pine_type == PineType.BOOL:
             return "bool"
         if pine_type == PineType.COLOR:
-            return "int"
+            return "int64_t"
         return "double"
 
     def _callsite_callable_return_pine_type(
@@ -1464,10 +2412,17 @@ class TypeInferer:
         terminal = node.body[-1]
         if isinstance(terminal, ExprStmt):
             terminal = terminal.expr
+        if (not getattr(self, "_wide_int_epoch_only", False)
+                and self._holds_wide_int_constant(terminal)):
+            return True
         return self._expr_returns_wide_int(
             terminal, func_info, seen, call_site_idx
         )
 
+    _NON_INTEGER_BINOPS = frozenset({
+        "/", "==", "!=", "<", ">", "<=", ">=", "and", "or",
+    })
+
     def _expr_returns_wide_int(
         self,
         expr,
@@ -1489,7 +2444,12 @@ class TypeInferer:
             node = getattr(owner_info, "node", None)
             if node is not None:
                 if expr.name in node.params:
-                    return False
+                    # A parameter is wide when a written call feeds it a wide
+                    # value (``_wide_int_provenance``).
+                    return (
+                        getattr(owner_info, "name", ""),
+                        node.params.index(expr.name),
+                    ) in self._wide_int_provenance()[1]
                 local_key = (
                     f"{getattr(owner_info, 'name', '')}:local:{expr.name}"
                 )
@@ -1521,15 +2481,32 @@ class TypeInferer:
                             call_site_idx,
                         ):
                             return True
-            return self._expr_is_int64_builtin(expr)
+            # A name some declaration or reassignment makes wide carries the
+            # epoch wherever it is read (``_wide_int_provenance``).
+            return (self._expr_is_int64_builtin(expr)
+                    or expr.name in self._wide_int_provenance()[0])
         if self._expr_is_int64_builtin(expr):
             return True
         if isinstance(expr, (BinOp, UnaryOp)) and self._literal_overflows_int32(expr):
             # ``90 * 24 * 60 * 60 * 1000``: an int-literal product beyond
             # int32 is a 64-bit value in Pine (``_pure_int_literal_value``).
             return True
+        epoch_only = getattr(self, "_wide_int_epoch_only", False)
+        if isinstance(expr, MemberAccess):
+            if epoch_only:
+                return False
+            # A UDT ``int`` field is ``int64_t`` storage; a read of one some
+            # write fills with a wide value keeps it (``_wide_udt_int_fields``).
+            type_name = self._udt_receiver_type_name(expr.object, owner_info)
+            return (type_name, expr.member) in self._wide_udt_int_fields()
         if isinstance(expr, FuncCall):
             func_name, namespace = self._resolve_callee(expr.callee)
+            if namespace == "request" and func_name == "security":
+                # The requested bar's value of the payload keeps its
+                # provenance: ``request.security(t, "60", time)`` is an epoch.
+                return self._expr_returns_wide_int(
+                    self._security_payload_node(expr), owner_info, seen, call_site_idx
+                )
             if func_name in self._WIDE_ARRAY_ELEMENT_READS:
                 # An element read off a wide int array (``array.get(times, i)``
                 # / ``times.get(i)``) carries the epoch: the destination must
@@ -1607,6 +2584,13 @@ class TypeInferer:
                 )
             )
         if isinstance(expr, BinOp):
+            if expr.op in self._NON_INTEGER_BINOPS:
+                # Pine v6 ``/`` is a float and a comparison a bool: no
+                # integer slot holds them, whatever the operands carry.
+                return False
+            if not epoch_only and self._int_arith_leaves_int32(expr, owner_info):
+                # ``days * 86400000``: computed in 64 bits (``_visit_binop``).
+                return True
             return (
                 self._expr_returns_wide_int(
                     expr.left, owner_info, seen, call_site_idx
@@ -1616,6 +2600,8 @@ class TypeInferer:
                 )
             )
         if isinstance(expr, UnaryOp):
+            if expr.op == "not":
+                return False
             return self._expr_returns_wide_int(
                 expr.operand, owner_info, seen, call_site_idx
             )
@@ -1697,44 +2683,164 @@ class TypeInferer:
             return "int64_t"
         return cpp_type
 
-    def _int64_reassign_targets(self) -> set[str]:
-        """Names of vars that are reassigned (``:=``/``=``) anywhere in the AST
-        with an RHS that is a top-level int64-returning builtin. Cached on the
-        instance. Pine ``int`` collapses these to 32-bit, but the runtime stores
-        the epoch in 64 bits, so the member must be promoted to ``int64_t``."""
-        cached = getattr(self, "_int64_reassign_cache", None)
+    def _wide_int_provenance(self) -> tuple[set[str], set[tuple[str, int]]]:
+        """Names, and integer callable parameters, that carry an epoch.
+
+        A name is wide when its declaration or any ``:=``/``=`` gives it a
+        value ``_expr_returns_wide_int`` traces to a wide source; an integer
+        parameter (declared ``int``, or untyped) is wide when a written call
+        passes it one. A wide name or parameter is itself a wide source, so
+        the width travels through copies: ``int sel = switch k => E2`` over
+        ``const int E2 = timestamp(...)``, ``copy := first`` over
+        ``first := time``, and ``f(int t)`` called as ``f(time)``. Pine
+        ``int`` keeps the whole epoch in each (lab tv pf-krunerr-int64-probe1,
+        2026-09-26: 1743468300000 where 32-bit slots read -288422176); the
+        runtime stores it, and the na sentinel, in 64 bits, so each slot is
+        ``int64_t``. Iterated to a fixpoint and cached. Names are keyed by
+        spelling across scopes, as the reassignment scan before this one was:
+        a same-spelled narrow name widens with a wide one, which only drops a
+        narrowing.
+        """
+        # The epoch-only mode (``_wide_int_array_names``) keeps its own sets.
+        cache_attr = ("_wide_int_epoch_provenance_cache"
+                      if getattr(self, "_wide_int_epoch_only", False)
+                      else "_wide_int_provenance_cache")
+        cached = getattr(self, cache_attr, None)
         if cached is not None:
             return cached
-        targets: set[str] = set()
-        # Callable locals need their lexical owner so a reassignment through a
-        # wrapper/method returning wide history is recognized as well as a
-        # direct ``time[1]`` RHS.
+        names: set[str] = set()
+        params: set[tuple[str, int]] = set()
+        # Published before the scan: a lookup made while the fixpoint runs
+        # reads the sets as they grow instead of starting a second scan.
+        setattr(self, cache_attr, (names, params))
+        bindings: list = []
+        calls: list = []
+
+        def collect(node, owner) -> None:
+            if isinstance(node, VarDecl) and node.value is not None:
+                bindings.append((node.name, node.value, owner))
+            elif (isinstance(node, Assignment)
+                    and isinstance(node.target, Identifier)):
+                bindings.append((node.target.name, node.value, owner))
+            elif isinstance(node, TupleAssign):
+                # ``[t0, t1] = request.security(sym, tf, f())``: each name is
+                # bound to the element its tuple evaluates.
+                for index, name in enumerate(node.names):
+                    element = (
+                        self._tuple_element_value(node.value, index, owner)
+                        if name and name != "_" else None
+                    )
+                    if element is not None:
+                        bindings.append((name, *element))
+            elif (isinstance(node, FuncCall)
+                    and isinstance(node.callee, Identifier)
+                    and node.callee.name in self._func_info_map):
+                calls.append((node, owner))
+
+        # Callable bodies resolve their locals and parameters against their
+        # lexical owner; everything outside them is global.
         for info in getattr(self.ctx, "func_infos", ()):
             node = getattr(info, "node", None)
             if node is None:
                 continue
             for child in self._walk_ast_list(node.body):
-                if (
-                    isinstance(child, Assignment)
-                    and isinstance(child.target, Identifier)
-                    and self._expr_returns_wide_int(
-                        child.value, info, set(), None
-                    )
-                ):
-                    targets.add(child.target.name)
+                collect(child, info)
         ast = getattr(self.ctx, "ast", None)
-        if ast is not None:
-            for node in self._walk_ast(ast):
-                if (isinstance(node, Assignment)
-                        and isinstance(node.target, Identifier)
-                        and self._expr_returns_wide_int(
-                            node.value, None, set(), None
-                        )):
-                    targets.add(node.target.name)
-        self._int64_reassign_cache = targets
-        return targets
-
-    def _is_int64_builtin_init(self, name: str) -> bool:
+        for stmt in getattr(ast, "body", None) or ():
+            if isinstance(stmt, (FuncDef, MethodDef)):
+                continue
+            for child in self._walk_ast(stmt):
+                collect(child, None)
+
+        changed = True
+        with self._int_width_scan():
+            while changed:
+                changed = False
+                for name, value, owner in bindings:
+                    if name not in names and self._expr_returns_wide_int(
+                            value, owner, set(), None):
+                        names.add(name)
+                        changed = True
+                for call, owner in calls:
+                    callee = self._func_info_map[call.callee.name]
+                    callee_params = list(getattr(callee.node, "params", ()) or ())
+                    bound = list(enumerate(call.args))
+                    bound += [
+                        (callee_params.index(key), arg)
+                        for key, arg in call.kwargs.items()
+                        if key in callee_params
+                    ]
+                    for index, arg in bound:
+                        key = (callee.name, index)
+                        if (key not in params
+                                and self._param_is_integer_scalar(callee, index)
+                                and self._expr_returns_wide_int(
+                                    arg, owner, set(), None)):
+                            params.add(key)
+                            changed = True
+        return names, params
+
+    @staticmethod
+    def _security_payload_node(call: FuncCall):
+        """The expression argument of a ``request.security`` call."""
+        if len(call.args) > 2:
+            return call.args[2]
+        return call.kwargs.get("expression")
+
+    def _tuple_element_value(self, value, index: int, owner, depth: int = 0):
+        """``(expression, lexical owner)`` element ``index`` of a tuple value
+        evaluates: a tuple literal's element, through a ``request.security``
+        payload and a user function's final tuple; None otherwise."""
+        if depth > 32:
+            return None
+        if isinstance(value, TupleLiteral):
+            if index < len(value.elements):
+                return value.elements[index], owner
+            return None
+        if not isinstance(value, FuncCall):
+            return None
+        func_name, namespace = self._resolve_callee(value.callee)
+        if namespace == "request" and func_name == "security":
+            return self._tuple_element_value(
+                self._security_payload_node(value), index, owner, depth + 1)
+        info = self._func_info_map.get(func_name) if namespace is None else None
+        node = getattr(info, "node", None)
+        if node is None or not node.body:
+            return None
+        terminal = node.body[-1]
+        if isinstance(terminal, ExprStmt):
+            terminal = terminal.expr
+        return self._tuple_element_value(terminal, index, info, depth + 1)
+
+    def _param_is_integer_scalar(self, fi, index: int) -> bool:
+        """Whether parameter ``index`` of ``fi`` is a scalar integer slot:
+        declared ``int`` or untyped, not a history parameter (those are
+        ``Series<int64_t>`` already) and not a method receiver."""
+        node = getattr(fi, "node", None)
+        if node is None or index >= len(node.params or ()):
+            return False
+        if getattr(fi, "is_udt_method", False) and index == 0:
+            return False
+        if node.params[index] in self.ctx.func_series_vars.get(fi.name, set()):
+            return False
+        declared = list(
+            getattr(self.ctx, "func_declared_param_type_specs", {}).get(
+                fi.name, ()
+            )
+        )
+        spec = declared[index] if index < len(declared) else None
+        if spec is None:
+            return True
+        return spec.kind == "primitive" and spec.name == "int"
+
+    def _wide_declared_int_param(self, fi, index: int, cpp_type: str) -> str:
+        """``int64_t`` for a declared ``int`` parameter a call feeds an epoch
+        (``_wide_int_provenance``), else ``cpp_type`` unchanged."""
+        if cpp_type == "int" and (fi.name, index) in self._wide_int_provenance()[1]:
+            return "int64_t"
+        return cpp_type
+
+    def _is_int64_builtin_init(self, name: str, decl=None) -> bool:
         """True if ``name``'s initializer OR any ``:=``/``=`` reassignment has an
         RHS that is a top-level int64-returning builtin (``time``, ``time_close``,
         ``timenow``, ``timestamp``, ``time_tradingday``). The Pine type system
@@ -1742,7 +2848,9 @@ class TypeInferer:
         (and the full epoch-ms value, which overflows int32) in 64 bits, so
         storing into ``int`` silently corrupts both the value and na detection.
         A reassignment like ``var int entryTime = na`` then ``entryTime := time``
-        must promote even though the *initializer* alone is ``na``.
+        must promote even though the *initializer* alone is ``na``, and so
+        must every name a copy of such a value reaches
+        (``_wide_int_provenance``).
         """
         expr = (
             self.ctx.global_expr_map.get(name)
@@ -1750,7 +2858,565 @@ class TypeInferer:
         )
         if self._expr_is_int64_builtin(expr):
             return True
-        return name in self._int64_reassign_targets()
+        # A script-level int constant past int32 (``_literal_wide_global``;
+        # ``decl`` restricts it to that declaration).
+        if self._literal_wide_global(name, decl):
+            return True
+        return name in self._wide_int_provenance()[0]
+
+    # ------------------------------------------------------------------
+    # na-preserving double -> int narrowing
+    # ------------------------------------------------------------------
+
+    # Pine functions whose declared return type is ``int`` but whose C++
+    # lowering is a ``double``-valued expression, so the Pine-facing type is
+    # not enough to decide whether a narrowing happens.
+    _DOUBLE_EMITTING_INT_CALLS = {
+        ("math", "round"), ("math", "floor"), ("math", "ceil"),
+    }
+
+    # Built-ins whose lowering is an integer-valued engine expression, in
+    # either the bare-variable or the call form: ``pine_bar_index()`` and the
+    # ``pine_<field>()`` calendar helpers return ``int``, the epoch-ms readings
+    # return ``int64_t``. ``_infer_type`` reports ``double`` for all of them
+    # (they are ``BAR_BUILTINS``), which would wrap an already-integral value.
+    _INTEGRAL_BUILTINS = frozenset({
+        "bar_index", "last_bar_index",
+        "year", "month", "dayofmonth", "dayofweek",
+        "hour", "minute", "second", "weekofyear",
+        "time", "timenow", "time_close", "last_bar_time", "time_tradingday",
+    })
+
+    # ``strategy.closedtrades`` / ``strategy.opentrades`` read the trade-book
+    # sizes, emitted as ``((int)trades_.size())``.
+    _INTEGRAL_STRATEGY_MEMBERS = frozenset({"closedtrades", "opentrades"})
+
+    # Only an integer literal is width-independent. An integer ``na`` value,
+    # input read, or prior guarded cast can still lose its sentinel when it
+    # crosses into the other integer width, so those must be checked again.
+    _INTEGRAL_CPP_TEXT = re.compile(
+        r"^\s*(?:\(\s*)*[-+]?(?:0[xX][0-9a-fA-F]+|\d+)(?:LL|ULL|L|U)?"
+        r"(?:\s*\))*\s*$"
+    )
+
+    def _emitted_value_is_double(self, node) -> bool:
+        """True when the C++ expression emitted for ``node`` has type ``double``.
+
+        This is deliberately *not* ``_infer_type(node) == "double"``.
+        ``_infer_type`` answers "what type does this slot hold", which for
+        ``math.round(x)`` is Pine's ``int`` even though the emission is
+        ``std::round(x)``, a ``double`` — and which falls back to ``double``
+        for any shape it cannot resolve, including integer arithmetic. Only
+        this function's answer decides whether a value reaching an integer
+        slot needs the na-preserving cast.
+        """
+        if node is None:
+            return False
+        if isinstance(node, NumberLiteral):
+            return isinstance(node.value, float)
+        if isinstance(node, (BoolLiteral, StringLiteral, ColorLiteral)):
+            # A colour literal lowers to a packed-ARGB ``int64_t`` literal.
+            return False
+        if isinstance(node, Subscript) and isinstance(node.object, Identifier):
+            # A history read keeps the series' element type.
+            base = node.object.name
+            if base in self._INTEGRAL_BUILTINS:
+                return False
+            if base in self.ctx.series_vars or base in self.ctx.series_bar_fields:
+                return self._series_type_for(base) == "double"
+        if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
+            # color.* lowers to a packed-ARGB integer constant; session.*
+            # lowers to a ``pine_session_*`` predicate (bool).
+            if node.object.name in ("color", "session"):
+                return False
+            if (node.object.name == "strategy"
+                    and node.member in self._INTEGRAL_STRATEGY_MEMBERS):
+                return False
+        if isinstance(node, NaLiteral):
+            return True
+        if isinstance(node, UnaryOp):
+            if node.op in ("not", "!"):
+                return False
+            return self._emitted_value_is_double(node.operand)
+        if isinstance(node, BinOp):
+            if node.op in _BOOL_RESULT_BINOPS:
+                return False
+            if node.op in ("/", "%"):
+                # Both lower through an explicit double form
+                # (``(double)a / (double)b`` / ``std::fmod``).
+                return True
+            if self._na_aware_wide_is_double(node):
+                # ``_wide_int_arith_cpp``'s na-aware form.
+                return True
+            return (self._emitted_value_is_double(node.left)
+                    or self._emitted_value_is_double(node.right))
+        if isinstance(node, Ternary):
+            # C++ gives a mixed int/double conditional the common type
+            # ``double``, so one double arm narrows the whole expression.
+            return (self._emitted_value_is_double(node.true_val)
+                    or self._emitted_value_is_double(node.false_val))
+        if isinstance(node, Identifier):
+            name = node.name
+            if name in getattr(self, "_current_loop_vars", set()):
+                # A counted-loop binder is emitted as ``for (int i = ...)``,
+                # whatever ``_infer_type`` reports for the Pine binding.
+                return False
+            if (name in self._INTEGRAL_BUILTINS
+                    and name not in self._current_func_param_types
+                    and name not in self._known_vars):
+                return False
+            # Builtins, constants and parameters are resolved precisely by
+            # ``_infer_type``; a user variable's *storage* is what the read
+            # emits, and that can be a double where the Pine type is an int
+            # (a hoisted global is declared from its initializer).
+            if not (name in BAR_FIELDS or name in BAR_BUILTINS
+                    or name in self._known_vars
+                    or name in getattr(
+                        self, "_current_func_series_param_types", {})
+                    or name in self._current_func_param_types):
+                declared = self._slot_scalar_cpp_type(name)
+                if declared is not None:
+                    return declared == "double"
+        if isinstance(node, FuncCall):
+            func_name, namespace = self._resolve_callee(node.callee)
+            if (namespace, func_name) in self._DOUBLE_EMITTING_INT_CALLS:
+                # The 2-arg precision overload is a float in Pine as well and
+                # falls through to the generic check.
+                return len(node.args) + len(node.kwargs or {}) == 1
+            if namespace is None and func_name in ("int", "bool"):
+                # Already spelled as an explicit, na-preserving cast.
+                return False
+            if namespace is None and func_name == "nz" and node.args:
+                # ``nz(x)`` / ``nz(x, y)`` keep the replaced value's type.
+                return self._emitted_value_is_double(node.args[0])
+            if namespace == "timeframe" and func_name == "in_seconds":
+                return False
+            if namespace == "session":
+                return False
+            if namespace is None and func_name in self._INTEGRAL_BUILTINS:
+                # ``year(t)`` / ``hour(t, tz)`` lower to the same integer
+                # ``pine_<field>()`` helpers as their bare-variable forms.
+                return False
+            if namespace == "color":
+                # Every color.* lowering is an integer (packed ARGB, or a
+                # channel read).
+                return False
+            if namespace == "ta":
+                # Every ta.* call site lowers to a ta:: class
+                # ``compute()``/``recompute()``, which returns a double even
+                # where Pine's type is an int (``ta.highestbars``,
+                # ``ta.barssince``, ...).
+                return func_name not in TA_RETURNS_BOOL
+        return self._infer_type(node) == "double"
+
+    def _slot_scalar_cpp_type(self, name: str) -> str | None:
+        """The C++ type of the storage a write to the scalar ``name`` lands in.
+
+        Reads the declaration sites in the order the emitter itself uses:
+        ``var`` member, function-local, parameter, then hoisted global member.
+        Unlike ``_na_reassign_cpp_type`` the global case mirrors
+        ``base.generate``'s member layout (``_infer_type`` of the initializer)
+        rather than the analyzer's ``PineType``: the two disagree for
+        e.g. ``x = math.round(...)``, and the declaration is the real storage.
+        """
+        for vname, ptype, _init in self.ctx.var_members:
+            if vname == name:
+                return PINE_TYPE_TO_CPP.get(ptype, "double")
+        local = getattr(self, "_current_func_local_types", {}).get(name)
+        if local is not None:
+            return local
+        param = getattr(self, "_current_func_param_types", {}).get(name)
+        if param is not None:
+            return param
+        for gname, gptype in self.ctx.global_var_decls:
+            if gname != name:
+                continue
+            if self._global_color_hint(name):
+                return "int64_t"
+            if self._global_bool_hint(name):
+                return "bool"
+            if (name in getattr(self, "_direct_program_tuple_binding_names", ())
+                    and gptype == PineType.BOOL):
+                return "bool"
+            if (gptype == PineType.STRING
+                    and name in self._security_tuple_binding_names()):
+                return "std::string"
+            if name in self._nonfinite_int_names():
+                return "double"
+            expr = getattr(self.ctx, "global_expr_map", {}).get(name)
+            if expr is not None:
+                return self._infer_type(expr)
+            return PINE_TYPE_TO_CPP.get(gptype, "double")
+        return None
+
+    # ------------------------------------------------------------------
+    # A Pine int TradingView holds as +-Infinity
+    # ------------------------------------------------------------------
+
+    _NONFINITE_INT_READ_OPS = frozenset({"<", ">", "<=", ">=", "==", "!="})
+    NONFINITE_INT_ORDERING_OPS = frozenset({"<", ">", "<=", ">="})
+
+    def _nonfinite_int_names(self) -> frozenset[str]:
+        """Plain global ``int`` names stored as ``double`` to keep an infinity.
+
+        ``math.floor(100 / 0)`` is +Infinity in TradingView, even in an ``int``
+        variable: ``>``/``>=`` against any number hold and ``<``/``<=`` do not,
+        while ``na()`` reads it as na, ``==``/``!=`` are false, ``str.tostring``
+        prints NaN and ``strategy.entry(qty = ...)`` trades the default quantity
+        (lab tv tailc-a-na-compare, tailc-a-divzero-readout,
+        tailc-a-qty-nonfinite2; R5 lane TAIL-C). A C++ ``int`` narrows it to
+        ``na<int>()``, which orders as na. So a name is stored as the ``double``
+        its value already is when every binding of it -- a global declaration
+        or ``:=`` -- is a one-argument ``math.floor``/``math.ceil``/
+        ``math.round``, some read of it is an ordering comparison's operand --
+        the one read whose answer an infinity changes -- and every read of it
+        is an operand of a comparison, the argument of ``na``/``nz``/
+        ``str.tostring`` or the quantity of ``strategy.entry``/
+        ``strategy.order``. Its reads keep the int's old answers
+        (``_nonfinite_int_read``): an infinity reads na, except as the operand
+        of an ordering comparison, which reads it as the number.
+        """
+        cached = getattr(self, "_nonfinite_int_names_cache", None)
+        if cached is not None:
+            return cached
+        self._nonfinite_int_names_cache = frozenset()
+        ast = getattr(self.ctx, "ast", None)
+        if ast is None:
+            return self._nonfinite_int_names_cache
+        # Read off the program and the analyzer alone, so every pass of the
+        # emitter, the first included, gets the same answer.
+        candidates = {
+            name for name, _ptype in self.ctx.global_var_decls
+            if name not in self.ctx.series_vars
+        }
+        if not candidates:
+            return self._nonfinite_int_names_cache
+        bound: set[str] = set()
+        rejected: set[str] = set()
+        ordered: set[str] = set()
+
+        def floor_call(value) -> bool:
+            if not isinstance(value, FuncCall) or value.kwargs or len(value.args) != 1:
+                return False
+            func_name, namespace = self._resolve_callee(value.callee)
+            return (namespace, func_name) in self._DOUBLE_EMITTING_INT_CALLS
+
+        def allowed_read(parent, slot: str, index: int) -> bool:
+            if isinstance(parent, BinOp):
+                return parent.op in self._NONFINITE_INT_READ_OPS
+            if not isinstance(parent, FuncCall):
+                return False
+            func_name, namespace = self._resolve_callee(parent.callee)
+            if slot == "args" and index == 0 and (
+                    (namespace is None and func_name in ("na", "nz"))
+                    or (namespace, func_name) == ("str", "tostring")):
+                return True
+            return (namespace == "strategy" and func_name in ("entry", "order")
+                    and (slot == "kwargs:qty" or (slot == "args" and index == 2)))
+
+        def children(node):
+            for slot, value in vars(node).items():
+                if isinstance(value, ASTNode):
+                    yield slot, 0, value
+                elif isinstance(value, dict):
+                    for key, item in value.items():
+                        if isinstance(item, ASTNode):
+                            yield f"{slot}:{key}", 0, item
+                elif isinstance(value, (list, tuple)):
+                    for index, item in enumerate(value):
+                        if isinstance(item, ASTNode):
+                            yield slot, index, item
+                        elif isinstance(item, (list, tuple)):
+                            for inner in item:
+                                if isinstance(inner, ASTNode):
+                                    yield slot, index, inner
+                                elif isinstance(inner, list):
+                                    for leaf in inner:
+                                        if isinstance(leaf, ASTNode):
+                                            yield slot, index, leaf
+
+        pending = [(ast, False)]
+        while pending:
+            node, in_callable = pending.pop()
+            if isinstance(node, (FuncDef, MethodDef)):
+                # A parameter or a local of that spelling would read through
+                # the global's rule.
+                rejected.update(set(getattr(node, "params", None) or ()) & candidates)
+                in_callable = True
+            if isinstance(node, VarDecl) and node.name in candidates:
+                if (in_callable or node.is_var or node.is_varip
+                        or node.type_hint not in (None, "int")
+                        or not floor_call(node.value)):
+                    rejected.add(node.name)
+                bound.add(node.name)
+            elif isinstance(node, TupleAssign):
+                rejected.update(set(node.names) & candidates)
+            elif (isinstance(node, Assignment) and isinstance(node.target, Identifier)
+                    and node.target.name in candidates):
+                if node.op != ":=" or not floor_call(node.value):
+                    rejected.add(node.target.name)
+                bound.add(node.target.name)
+            for slot, index, child in children(node):
+                if isinstance(child, Identifier) and child.name in candidates:
+                    binding_target = (isinstance(node, Assignment) and slot == "target")
+                    if not binding_target and not allowed_read(node, slot, index):
+                        rejected.add(child.name)
+                    if (isinstance(node, BinOp)
+                            and node.op in self.NONFINITE_INT_ORDERING_OPS):
+                        ordered.add(child.name)
+                pending.append((child, in_callable))
+        self._nonfinite_int_names_cache = frozenset((bound & ordered) - rejected)
+        return self._nonfinite_int_names_cache
+
+    def _global_color_hint(self, name: str) -> bool:
+        """A top-level ``color`` declaration must keep its 64-bit na sentinel."""
+        return any(
+            isinstance(stmt, VarDecl)
+            and stmt.name == name
+            and stmt.type_hint == "color"
+            for stmt in self.ctx.ast.body
+        )
+
+    def _global_bool_hint(self, name: str) -> bool:
+        """A top-level declared bool keeps its type when initialized by na."""
+        return any(
+            isinstance(stmt, VarDecl)
+            and stmt.name == name
+            and stmt.type_hint == "bool"
+            for stmt in self.ctx.ast.body
+        )
+
+    def _int_slot_cpp_type(self, name: str | None,
+                           declared: str | None = None) -> str | None:
+        """``"int"``/``"int64_t"`` when a write to this slot narrows, else ``None``.
+
+        ``declared`` short-circuits the lookup for an emitter that already
+        knows the storage type it is about to spell (a local declaration).
+        """
+        if declared is not None:
+            resolved = declared
+        elif name is None:
+            return None
+        else:
+            resolved = self._slot_scalar_cpp_type(name)
+            if (resolved == "int" and name is not None
+                    and self._is_int64_builtin_init(name)):
+                resolved = "int64_t"
+        return resolved if resolved in (*NA_PRESERVING_INT_TYPES, "bool") else None
+
+    def _func_param_int_cpp_type(self, fi, index: int,
+                                 call_site_idx: int | None) -> str | None:
+        """``"int"``/``"int64_t"`` when parameter ``index`` of ``fi`` is an integer.
+
+        Mirrors the parameter-type branches of ``emit_top._emit_func_def`` in
+        the same order, keeping only the outcomes that are integers: a value
+        crossing into one of those parameters narrows, and Pine's ``color`` is
+        one of them (the engine packs a color as an integer). History
+        parameters become ``const Series<T>&`` and are not a narrowing slot.
+        """
+        node = getattr(fi, "node", None)
+        if node is None or index >= len(node.params or ()):
+            return None
+        param = node.params[index]
+        if getattr(fi, "is_udt_method", False) and index == 0:
+            return None
+        if fi.name == "isInSession" and index < 2:
+            return None
+        if param in self.ctx.func_series_vars.get(fi.name, set()):
+            return None
+        declared = list(
+            getattr(self.ctx, "func_declared_param_type_specs", {}).get(
+                fi.name, ()
+            )
+        )
+        variant = (
+            getattr(self.ctx, "func_callsite_param_types", {}).get(
+                (fi.name, call_site_idx), ()
+            )
+            if call_site_idx is not None
+            else ()
+        )
+        if (index >= len(declared) or declared[index] is None) and index < len(variant):
+            return {
+                PineType.INT: "int64_t",
+                PineType.COLOR: "int64_t",
+            }.get(variant[index])
+        specs = getattr(fi, "param_type_specs", []) or []
+        if index < len(specs) and specs[index] is not None:
+            cpp_t = self._wide_declared_int_param(
+                fi, index, self._type_spec_to_cpp(specs[index]))
+            return cpp_t if cpp_t in NA_PRESERVING_INT_TYPES else None
+        if index < len(fi.param_types):
+            cpp_t = self._wide_declared_int_param(
+                fi, index, PINE_TYPE_TO_CPP.get(fi.param_types[index], "double"))
+            return cpp_t if cpp_t in NA_PRESERVING_INT_TYPES else None
+        return None
+
+    def _func_param_is_bool(self, fi, index: int,
+                            call_site_idx: int | None = None) -> bool:
+        """Whether one emitted user-function parameter is Pine ``bool``."""
+        node = getattr(fi, "node", None)
+        if node is None or index >= len(node.params or ()):
+            return False
+        declared = list(
+            getattr(self.ctx, "func_declared_param_type_specs", {}).get(
+                fi.name, ()
+            )
+        )
+        if index < len(declared) and declared[index] is not None:
+            spec = declared[index]
+            return spec.kind == "primitive" and spec.name == "bool"
+        variant = (
+            getattr(self.ctx, "func_callsite_param_types", {}).get(
+                (fi.name, call_site_idx), ()
+            )
+            if call_site_idx is not None
+            else ()
+        )
+        if index < len(variant):
+            return variant[index] == PineType.BOOL
+        specs = getattr(fi, "param_type_specs", []) or []
+        if index < len(specs) and specs[index] is not None:
+            spec = specs[index]
+            return spec.kind == "primitive" and spec.name == "bool"
+        return index < len(fi.param_types) and fi.param_types[index] == PineType.BOOL
+
+    def _udt_field_int_cpp_type(self, target_node) -> str | None:
+        """Integer C++ type of a UDT field write target, else ``None``.
+
+        Mirrors the record layout in ``base.generate``, which widens a Pine
+        ``int`` field to ``int64_t`` so epoch values and the na sentinel fit.
+        """
+        if not isinstance(target_node, MemberAccess):
+            return None
+        owner = self._type_spec_from_expr(target_node.object)
+        if owner is None or owner.kind != "udt" or not owner.name:
+            return None
+        spec = (self._udt_field_type_specs.get(owner.name) or {}).get(
+            target_node.member
+        )
+        if spec is None:
+            return None
+        cpp_type = self._type_spec_to_cpp(spec)
+        if cpp_type == "int":
+            cpp_type = "int64_t"
+        return cpp_type if cpp_type in (*NA_PRESERVING_INT_TYPES, "bool") else None
+
+    def _coerce_int_slot(self, cpp_val: str, node, target_cpp_type: str | None,
+                         *, value_is_double: bool | None = None) -> str:
+        """Route a value into an ``int``/``int64_t`` slot without losing ``na``.
+
+        A double NaN cannot be narrowed implicitly, and an integer na
+        sentinel cannot cross into the other integer width without losing
+        its sentinel. Same-width integral slots keep their established C++
+        spelling; width changes check the original source value first.
+        ``value_is_double`` overrides the AST judgement for emitters that
+        build their own expression text.
+        """
+        if target_cpp_type == "bool":
+            return self._coerce_bool_expr(cpp_val, node)
+        if target_cpp_type not in NA_PRESERVING_INT_TYPES:
+            return cpp_val
+        if cpp_val in {"na<double>()", "na<int>()", "na<int64_t>()"}:
+            # A bare na needs no round trip through the source width.
+            return f"na<{target_cpp_type}>()"
+        if self._INTEGRAL_CPP_TEXT.match(cpp_val):
+            return cpp_val
+        if ((target_cpp_type == "int" and cpp_val.startswith("get_input_int("))
+                or (target_cpp_type == "int64_t"
+                    and cpp_val.startswith("get_input_int64("))):
+            # Engine ABI declarations return exactly these widths, and their
+            # integer na sentinel already matches the destination slot.
+            return cpp_val
+        if value_is_double is None:
+            value_is_double = self._emitted_value_is_double(node)
+        if value_is_double:
+            return na_preserving_int_cast(cpp_val, target_cpp_type)
+        if node is None:
+            return cpp_val
+        source_cpp_type = self._infer_type(node)
+        if (isinstance(node, Identifier)
+                and self._is_int64_builtin_init(node.name)):
+            source_cpp_type = "int64_t"
+        if (source_cpp_type in NA_PRESERVING_INT_TYPES
+                and source_cpp_type != target_cpp_type):
+            return na_preserving_int_cast(cpp_val, target_cpp_type)
+        return cpp_val
+
+    def _coerce_int_slot_with_cast(
+        self, cpp_val: str, node, target_cpp_type: str
+    ) -> str:
+        """Preserve an explicit integral cast when no Na conversion is needed.
+
+        A few public textual contracts intentionally show the destination cast
+        (drawing ABI coordinates and security history offsets).  Keep that
+        spelling for values already proven integral; double-valued expressions
+        still take `_coerce_int_slot`'s na-preserving lambda.
+        """
+        rendered = self._coerce_int_slot(cpp_val, node, target_cpp_type)
+        if (rendered == cpp_val
+                and (self._INTEGRAL_CPP_TEXT.match(cpp_val)
+                     or not self._emitted_value_is_double(node))):
+            return f"({target_cpp_type})({cpp_val})"
+        return rendered
+
+    def _coerce_bool_expr(self, cpp_val: str, node=None) -> str:
+        """Lower a Pine scalar used in a boolean context.
+
+        Pine treats ``na`` as false when a numeric expression is consumed by
+        ``if``, a ternary, ``and``/``or``, or a boolean parameter.  A C++
+        conversion does not: NaN and the integer ``na`` sentinel are both
+        truthy.  Keep compile-time literals and expressions already typed as
+        ``bool`` byte-identical; every other numeric scalar goes through the
+        one single-evaluation runtime helper.
+
+        The helper deliberately does not reject an unresolved shape.  The
+        analyzer has already admitted the expression, and preserving its
+        existing lowering with a warning is preferable to introducing a new
+        refusal for a population script.
+        """
+        # Text-only helper paths (notably security registration) do not carry
+        # an AST node from which to prove the scalar type.  Keep their
+        # established spelling; the typed chart/security visitors pass the
+        # original node and take the exact path below.
+        if node is None:
+            return cpp_val
+        if cpp_val.strip() in {"true", "false", "na<bool>()"}:
+            return cpp_val
+        if cpp_val.strip() in {
+            "is_first_tick()", "is_last_tick_", "barstate_islast_",
+            "tf_change(prev_bar_timestamp_, current_bar_.timestamp)",
+        }:
+            return cpp_val
+        if isinstance(node, FuncCall):
+            func_name, namespace = self._resolve_callee(node.callee)
+            if namespace == "timeframe" and func_name == "change":
+                return cpp_val
+            if namespace == "session":
+                return cpp_val
+        if (isinstance(node, MemberAccess)
+                and isinstance(node.object, Identifier)
+                and node.object.name in {
+                    "barstate", "chart", "session", "timeframe"
+                }
+                and self._infer_type(node) == "bool"):
+            return cpp_val
+        inferred = self._infer_type(node)
+        if inferred == "bool":
+            return cpp_val
+        if inferred not in {"double", "int", "int64_t"}:
+            # Non-numeric values cannot carry Pine's numeric na sentinel. The
+            # ordinary C++ conversion is the established fallback for handles
+            # and other engine values.
+            return cpp_val
+        if isinstance(node, (NumberLiteral, BoolLiteral, ColorLiteral)):
+            return cpp_val
+        if (isinstance(node, Identifier)
+                and node.name in self._known_vars
+                and node.name not in self._input_backed_vars
+                and not self._known_var_is_lexically_shadowed(node.name)):
+            return cpp_val
+        return pine_truth_cast(cpp_val)
 
     def _na_reassign_cpp_type(self, name: str) -> str | None:
         """Declared scalar C++ type of a ``:=`` reassignment target ``name``, so a
@@ -1794,7 +3460,11 @@ class TypeInferer:
         if cpp_type is None:
             for gname, gptype in self.ctx.global_var_decls:
                 if gname == name:
-                    cpp_type = PINE_TYPE_TO_CPP.get(gptype, "double")
+                    cpp_type = (
+                        "int64_t" if self._global_color_hint(name)
+                        else "bool" if self._global_bool_hint(name)
+                        else PINE_TYPE_TO_CPP.get(gptype, "double")
+                    )
                     break
         if cpp_type is None:
             return None
@@ -1935,6 +3605,12 @@ class TypeInferer:
         and ternaries / if / switch expressions. Returns the string
         ``"double"`` as the safe fallback when no narrower type can be
         determined."""
+        if isinstance(node, Subscript) and isinstance(node.object, Identifier):
+            name = node.object.name
+            if name in self.ctx.series_vars:
+                return self._series_type_for(name)
+            if name in self.ctx.series_bar_fields:
+                return "double"
         if isinstance(node, Subscript) and isinstance(node.object, FuncCall):
             # A callable-result history read keeps the callable's scalar
             # family. Collection subscripts follow separate element-type paths.
@@ -1943,6 +3619,8 @@ class TypeInferer:
             return "double" if isinstance(node.value, float) else "int"
         if isinstance(node, BoolLiteral):
             return "bool"
+        if isinstance(node, ColorLiteral):
+            return "int64_t"
         if isinstance(node, StringLiteral):
             return "std::string"
         if isinstance(node, NaLiteral):
@@ -1973,7 +3651,7 @@ class TypeInferer:
                 return self._current_func_local_types[node.name]
             if node.name in getattr(self, "_current_loop_vars", set()):
                 return "double"
-            sym = self.ctx.symbols.resolve(node.name)
+            sym = self._variable_symbol(node.name)
             if sym is not None and getattr(sym, "type_spec", None) is not None:
                 return self._type_spec_to_cpp(sym.type_spec)
             if sym is not None and sym.pine_type != PineType.UNKNOWN:
@@ -1981,6 +3659,11 @@ class TypeInferer:
             return "double"
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
+            if namespace == "color":
+                return "int64_t" if func_name in {"new", "rgb", "from_gradient"} else "int"
+            if (namespace == "request" and func_name == "security"
+                    and self._security_call_returns_string(node)):
+                return "std::string"
             # Nested trade-accessor calls bypass the flat namespace signature
             # table.  Their textual metadata accessors return std::string from
             # the runtime, so hintless locals must not use the double fallback.
@@ -2005,7 +3688,9 @@ class TypeInferer:
                 return "int64_t"
             if func_name == "na":
                 return "bool"
-            if namespace == "input" or (namespace is None and func_name == "input"):
+            if namespace is None and func_name == "input":
+                return self._generic_input_cpp_type(node)
+            if namespace == "input":
                 if func_name in ("string", "timeframe", "session", "symbol", "text_area"):
                     return "std::string"
                 if func_name == "bool":
@@ -2102,18 +3787,30 @@ class TypeInferer:
             return "bool"
         if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
             ename = node.object.name
+            if ename == "color":
+                return "int64_t"
             if ename in self._enum_defs and node.member in self._enum_defs[ename]:
                 return "int"
             # format.* constants emit std::string literals (consumed by
             # pine_str_tostring); bare reads must declare std::string.
             if ename == "format":
                 return "std::string"
+            if ename == "alert" and node.member in ALERT_FREQ_VALUES:
+                return "std::string"
             if ename == "timeframe":
                 if node.member in ("period", "main_period"):
                     return "std::string"
                 if node.member == "multiplier":
                     return "int"
                 return "bool"
+            # chart.is_* are Pine bools (the emitter lowers them to C++
+            # ``true``/``false``): str.tostring(chart.is_standard) reads "true"
+            # on TradingView (lab tv pf-krunerr-env-facts, 2026-09-26), not the
+            # numeric "1".
+            if ename == "chart" and node.member in (
+                    "is_standard", "is_heikinashi", "is_kagi", "is_linebreak",
+                    "is_pnf", "is_range", "is_renko"):
+                return "bool"
             # syminfo.* type inference: look up in SYMINFO_MEMBER_MAP
             # and derive C++ type from the expression (na<T>() or function call).
             if ename == "syminfo":
@@ -2193,6 +3890,16 @@ class TypeInferer:
                         local_types[stmt.name] = self._type_spec_to_cpp(spec)
                         continue
                 local_types[stmt.name] = self._infer_type(stmt.value)
+            elif (isinstance(stmt, TupleAssign)
+                    and isinstance(stmt.value, (IfStmt, SwitchStmt))):
+                for name, cpp_t in zip(
+                    stmt.names,
+                    self._infer_selection_tuple_types(
+                        stmt.value, len(stmt.names), local_types
+                    ),
+                ):
+                    if name != "_":
+                        local_types[name] = cpp_t
 
         last_stmt = func_node.body[-1]
         expr = None
@@ -2200,12 +3907,109 @@ class TypeInferer:
             expr = last_stmt.expr
         elif isinstance(last_stmt, TupleLiteral):
             expr = last_stmt
+        request = last_stmt.expr if isinstance(last_stmt, ExprStmt) else last_stmt
+        if (isinstance(request, FuncCall)
+                and self._resolve_callee(request.callee) == ("security", "request")):
+            # A helper returning a request's tuple returns it as the value
+            # read stores it (``_req_sec_N`` or its per-element members).
+            item = self._security_call_for_request(request)
+            if item is not None and item.get("returns_tuple"):
+                payload = item["expr_node"]
+                if isinstance(payload, TupleLiteral):
+                    return ["double" if item.get("foreign") and cpp_t == "int" else cpp_t
+                            for cpp_t in map(self._infer_cpp_type_for_security_elem,
+                                             payload.elements)]
+                return self._security_tuple_element_cpp_types(
+                    count, item.get("tuple_element_types", ()))
         if expr is not None:
+            owner_info = next(
+                (info for info in self._func_info_map.values()
+                 if getattr(info, "node", None) is func_node), None)
             result: list[str] = []
             for e in expr.elements:
                 if isinstance(e, Identifier) and e.name in local_types:
-                    result.append(local_types[e.name])
+                    cpp_t = local_types[e.name]
                 else:
-                    result.append(self._infer_type(e))
+                    cpp_t = self._infer_type(e)
+                result.append(self._widen_int_slot(cpp_t, e, owner_info))
             return result
+        if isinstance(last_stmt, (IfStmt, SwitchStmt)):
+            return self._infer_selection_tuple_types(
+                last_stmt, count, local_types
+            )
+        if (isinstance(last_stmt, TupleAssign)
+                and isinstance(last_stmt.value, FuncCall)
+                and isinstance(last_stmt.value.callee, Identifier)):
+            # ``[p, q] = pair(v)`` last: the names are the callee's elements.
+            callee = self._func_info_map.get(last_stmt.value.callee.name)
+            callee_node = getattr(callee, "node", None)
+            if isinstance(callee_node, FuncDef) and callee_node is not func_node:
+                return self._infer_tuple_types(callee_node, count)
         return ["double"] * count
+
+    def _infer_selection_tuple_types(
+        self, node, count: int, local_types: dict[str, str] | None = None,
+    ) -> list[str]:
+        """C++ element types of a tuple-valued if/switch.
+
+        Each arm ends in a ``[a, b]`` literal, a tuple-returning user
+        function call or a nested selection (the analyzer's
+        ``_selection_tuple_shape``). Arms agreeing on a position keep that
+        type; numeric arms that differ widen to ``double``; any other
+        disagreement keeps the first arm's type.
+        """
+        local_types = local_types or {}
+        if isinstance(node, IfStmt):
+            arms = [node.body] + ([node.else_body] if node.else_body else [])
+        elif isinstance(node, SwitchStmt):
+            arms = [body for _case, body in node.cases]
+            if node.default_body:
+                arms.append(node.default_body)
+        else:
+            return ["double"] * count
+        per_arm: list[list[str]] = []
+        for body in arms:
+            if not body:
+                continue
+            terminal = body[-1]
+            expr = terminal.expr if isinstance(terminal, ExprStmt) else terminal
+            if isinstance(expr, TupleLiteral) and len(expr.elements) == count:
+                per_arm.append([
+                    local_types[e.name]
+                    if isinstance(e, Identifier) and e.name in local_types
+                    else self._infer_type(e)
+                    for e in expr.elements
+                ])
+            elif isinstance(expr, FuncCall) and isinstance(expr.callee, Identifier):
+                fi = self._func_info_map.get(expr.callee.name)
+                if (fi is not None and fi.node is not None
+                        and getattr(fi, "returns_tuple", False)
+                        and fi.tuple_element_count == count):
+                    per_arm.append(self._infer_tuple_types(fi.node, count))
+            elif isinstance(expr, (IfStmt, SwitchStmt)):
+                per_arm.append(
+                    self._infer_selection_tuple_types(expr, count, local_types)
+                )
+        if not per_arm:
+            return ["double"] * count
+        result: list[str] = []
+        for position in range(count):
+            found = [types[position] for types in per_arm]
+            if len(set(found)) == 1:
+                result.append(found[0])
+            elif set(found) <= {"double", "int", "int64_t"}:
+                result.append("double")
+            else:
+                result.append(found[0])
+        return result
+
+    def _tuple_default_expr(self, types: list[str]) -> str:
+        """``std::tuple<...>`` of na elements: a tuple selection no arm of
+        which runs yields na in every position."""
+        values = [
+            f"na<{cpp_t}>()"
+            if cpp_t in ("double", "int", "int64_t", "bool", "std::string")
+            else self._default_for_type(cpp_t)
+            for cpp_t in types
+        ]
+        return f"std::tuple<{', '.join(types)}>({', '.join(values)})"