@pineforge/codegen-pyodide 0.8.1 → 0.10.0

package/pineforge_codegen/codegen/visit_call.py

@@ -136,6 +136,7 @@ from ..ast_nodes import (
     FuncCall,
     Identifier,
     MemberAccess,
+    NaLiteral,
     TupleLiteral,
     StringLiteral,
 )
@@ -160,6 +161,7 @@ from .tables import (
     SKIP_VAR_TYPES,
     STR_FUNC_MAP,
     TIME_FIELD_EXPRS,
+    _math_minmax_na_expr,
     _merge_kwargs,
     _merge_kwargs_with_defaults,
     tz_time_field_lambda,
@@ -174,9 +176,21 @@ def _parse_pine_datestring_ms(text: str) -> int | None:
     "MMM DD YYYY ..." forms. A dateString without a time zone is GMT+0 per
     the Pine reference. Returns None when the string cannot be parsed.
     """
-    from datetime import datetime, timezone
+    import re
+    from datetime import datetime, timezone, timedelta
 
     txt = text.strip()
+    # Pine dateStrings may carry a trailing timezone WORD ("2024-01-01 00:00 UTC",
+    # "1 Jan 2020 09:30 GMT+2") that neither fromisoformat nor the strptime forms
+    # below can read. Peel it off and fold it into an explicit offset (UTC/GMT
+    # with an optional ±H[:MM] suffix; the bare word is +00:00).
+    tzoff = None
+    m = re.search(r"\s+(?:UTC|GMT)([+-]\d{1,2})?(?::?(\d{2}))?$", txt, re.I)
+    if m:
+        txt = txt[: m.start()].strip()
+        h = int(m.group(1) or 0)
+        mm = int(m.group(2) or 0)
+        tzoff = timezone(timedelta(hours=h, minutes=(mm if h >= 0 else -mm)))
     dt = None
     try:
         dt = datetime.fromisoformat(txt)
@@ -186,6 +200,7 @@ def _parse_pine_datestring_ms(text: str) -> int | None:
             "%d %b %Y %H:%M:%S", "%d %b %Y %H:%M", "%d %b %Y",
             "%b %d %Y %H:%M:%S %z", "%b %d %Y %H:%M %z",
             "%b %d %Y %H:%M:%S", "%b %d %Y %H:%M", "%b %d %Y",
+            "%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M", "%Y-%m-%d",
         ):
             try:
                 dt = datetime.strptime(txt, fmt)
@@ -195,7 +210,7 @@ def _parse_pine_datestring_ms(text: str) -> int | None:
     if dt is None:
         return None
     if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
+        dt = dt.replace(tzinfo=(tzoff or timezone.utc))
     return int(dt.timestamp() * 1000)
 
 
@@ -209,6 +224,63 @@ class CallVisitor:
     # Function-call dispatch
     # ------------------------------------------------------------------
 
+    def _udt_method_call_emit_name(self, fi, node: FuncCall) -> str:
+        """Resolve a UDT method call through the ordinary UDF clone graph."""
+        base = self._emit_udt_method_cpp_name(fi)
+        dispatch = self._instance_dispatch.get(
+            (self._current_instance_name, id(node))
+        )
+        if dispatch is not None:
+            return dispatch
+
+        cs_info = self.ctx.func_call_cs_map.get(id(node))
+        if self._active_call_site_idx is not None and cs_info is not None:
+            return f"{base}_cs{self._active_call_site_idx}"
+        if cs_info is not None and cs_info[0] == fi.name:
+            return f"{base}_cs{cs_info[1]}"
+        if (self._active_call_site_idx is not None
+                and self.ctx.func_call_site_counts.get(fi.name, 0) > 1):
+            return f"{base}_cs{self._active_call_site_idx}"
+        return base
+
+    def _array_init_value_expr(self, elem_spec: TypeSpec | None, value_node) -> str:
+        if isinstance(value_node, NaLiteral):
+            if elem_spec is not None and elem_spec.kind == "udt":
+                return self._default_for_spec(elem_spec)
+            cpp_type = self._type_spec_to_cpp(elem_spec)
+            if cpp_type in ("double", "int", "int64_t", "bool", "std::string"):
+                return f"na<{cpp_type}>()"
+            return self._default_for_spec(elem_spec)
+        return self._visit_expr(value_node)
+
+    def _array_method_args(
+        self, method: str, arg_nodes: list, spec: TypeSpec | None,
+    ) -> list[str]:
+        elem_spec = (
+            spec.element
+            if spec is not None and spec.kind == "array" and spec.element is not None
+            else TypeSpec.primitive("float")
+        )
+        value_arg_indexes = {
+            "set": {1},
+            "push": {0},
+            "unshift": {0},
+            "insert": {1},
+            "fill": {0},
+            "includes": {0},
+            "indexof": {0},
+            "lastindexof": {0},
+            "binary_search": {0},
+            "binary_search_leftmost": {0},
+            "binary_search_rightmost": {0},
+        }.get(method, set())
+        return [
+            self._array_init_value_expr(elem_spec, arg)
+            if idx in value_arg_indexes
+            else self._visit_expr(arg)
+            for idx, arg in enumerate(arg_nodes)
+        ]
+
     def _visit_func_call(self, node: FuncCall) -> str:
         callee = node.callee
         if isinstance(callee, MemberAccess):
@@ -217,7 +289,7 @@ class CallVisitor:
                 mk = f"{recv_spec.name}.{callee.member}"
                 fi_u = self._func_info_map.get(mk)
                 if fi_u is not None and getattr(fi_u, "is_udt_method", False):
-                    fn_cpp = self._emit_udt_method_cpp_name(fi_u)
+                    fn_cpp = self._udt_method_call_emit_name(fi_u, node)
                     recv_e = self._visit_expr(callee.object)
                     param_names = list(fi_u.node.params[1:]) if fi_u.node else []
                     # Drop the leading ``self`` slot from param_defaults so the
@@ -270,7 +342,9 @@ class CallVisitor:
                     meth = callee.member
                     raw_args = [self._visit_expr(a) for a in node.args]
                     if recv_spec is not None and recv_spec.kind == "array" and meth in ARRAY_METHODS:
-                        return self._array_method_expr(recv, meth, raw_args, recv_spec)
+                        return self._array_method_expr(
+                            recv, meth, self._array_method_args(meth, node.args, recv_spec), recv_spec
+                        )
                     if recv_spec is not None and recv_spec.kind == "map" and meth in MAP_METHODS:
                         return self._map_method_expr(recv, meth, raw_args, recv_spec)
                     args = ", ".join(raw_args)
@@ -294,7 +368,9 @@ class CallVisitor:
                         return self._map_method_expr(m, meth_raw, margs, self._map_spec_for_name(oname))
                     if oname in self._array_vars and meth_raw in ARRAY_METHODS:
                         arr = self._safe_name(oname)
-                        margs = [self._visit_expr(a) for a in node.args]
+                        margs = self._array_method_args(
+                            meth_raw, node.args, self._array_spec_for_name(oname)
+                        )
                         return self._array_method_expr(arr, meth_raw, margs, self._array_spec_for_name(oname))
                     if oname in self._matrix_specs and meth_raw in MATRIX_METHODS:
                         arr = self._safe_name(oname)
@@ -323,7 +399,7 @@ class CallVisitor:
                         mk = f"{udt_t}.{meth_raw}"
                         fi_u = self._func_info_map.get(mk)
                         if fi_u is not None and getattr(fi_u, "is_udt_method", False):
-                            fn_cpp = self._emit_udt_method_cpp_name(fi_u)
+                            fn_cpp = self._udt_method_call_emit_name(fi_u, node)
                             recv_e = self._visit_expr(obj)
                             param_names = list(fi_u.node.params[1:]) if fi_u.node else []
                             # Drop the leading ``self`` slot so param_defaults
@@ -387,11 +463,19 @@ class CallVisitor:
         if site is not None:
             compute_args = self._ta_compute_args_for_site(site)
             ta_mem = self._ta_member_name(site)
-            if getattr(self, "_precalc_loop_active", False) and getattr(site, "is_static", False):
+            uses_precalc = self._ta_site_uses_precalc(site)
+            if getattr(self, "_precalc_loop_active", False) and uses_precalc:
                 return f"_precalc_{ta_mem}[i]"
-            if getattr(site, "is_static", False):
-                return f"(_use_precalc ? _precalc_{ta_mem}[bar_index_] : (is_first_tick_ ? {ta_mem}.compute({compute_args}) : {ta_mem}.recompute({compute_args})))"
-            return f"(is_first_tick_ ? {ta_mem}.compute({compute_args}) : {ta_mem}.recompute({compute_args}))"
+            if uses_precalc:
+                return (
+                    f"(_use_precalc ? _precalc_{ta_mem}[bar_index_] : "
+                    f"(history_advances_new_bar() ? {ta_mem}.compute({compute_args}) "
+                    f": {ta_mem}.recompute({compute_args})))"
+                )
+            return (
+                f"(history_advances_new_bar() ? {ta_mem}.compute({compute_args}) "
+                f": {ta_mem}.recompute({compute_args}))"
+            )
 
         # math.* calls
         if namespace == "math":
@@ -451,18 +535,23 @@ class CallVisitor:
         # Array method syntax: arr.push(val) where namespace is the array variable name
         if namespace is not None and namespace in self._array_vars and func_name in ARRAY_METHODS:
             arr = self._safe_name(namespace)
-            args = [self._visit_expr(a) for a in node.args]
-            return self._array_method_expr(arr, func_name, args, self._array_spec_for_name(namespace))
+            spec = self._array_spec_for_name(namespace)
+            args = self._array_method_args(func_name, node.args, spec)
+            return self._array_method_expr(arr, func_name, args, spec)
 
         # Array operations — emit proper C++ vector operations
         if namespace == "array":
             if func_name in ("new", "new_float", "new_int", "new_bool", "new_string") or func_name in ARRAY_DRAWING_NEW_CTORS:
                 spec = self._type_spec_from_expr(node) or TypeSpec.array(TypeSpec.primitive("float"))
                 cpp_type = self._type_spec_to_cpp(spec)
-                init_default = self._default_for_spec(spec.element if spec.element is not None else TypeSpec.primitive("float"))
+                elem_spec = spec.element if spec.element is not None else TypeSpec.primitive("float")
+                init_default = self._default_for_spec(elem_spec)
                 if node.args:
                     size_arg = self._visit_expr(node.args[0])
-                    init_val = self._visit_expr(node.args[1]) if len(node.args) > 1 else init_default
+                    if len(node.args) > 1:
+                        init_val = self._array_init_value_expr(elem_spec, node.args[1])
+                    else:
+                        init_val = init_default
                     return f"{cpp_type}((size_t)({size_arg}), {init_val})"
                 return f"{cpp_type}()"
             if func_name == "from":
@@ -472,8 +561,8 @@ class CallVisitor:
             # Method calls: array.method(arr, args...)
             if func_name in ARRAY_METHODS and node.args:
                 arr = self._visit_expr(node.args[0])
-                rest = [self._visit_expr(a) for a in node.args[1:]]
                 spec = self._type_spec_from_expr(node.args[0])
+                rest = self._array_method_args(func_name, node.args[1:], spec)
                 return self._array_method_expr(arr, func_name, rest, spec)
             return "0"
 
@@ -665,11 +754,12 @@ class CallVisitor:
                 # mutex-guarded setenv+localtime_r block as the 2-arg
                 # form.
                 tz_arg = "syminfo_.timezone"
-            # 2-arg form — honor the tz argument. The shared
-            # ``tz_time_field_lambda`` (codegen/tables.py) also backs the
-            # bare variable forms (``hour`` etc. via BAR_BUILTINS), so the
-            # numbers agree across both forms.
-            return tz_time_field_lambda(field_expr, ts_arg, tz_arg)
+            # Route through the engine's cached pine_<field>() (session_time.hpp),
+            # same as the bare variable forms (BAR_BUILTINS) — value-identical but
+            # free of the per-call setenv+tzset churn (KI-35). field_expr is unused
+            # now (the engine applies the Pine offsets internally).
+            del field_expr
+            return f"pine_{func_name}((int64_t)({ts_arg}), {tz_arg})"
 
         # time(timeframe) or time(timeframe, session[, tz])
         if func_name == "time" and namespace is None and (node.args or node.kwargs):
@@ -699,6 +789,8 @@ class CallVisitor:
                     is_tz_first = True
                 elif isinstance(node.args[0], StringLiteral):
                     is_tz_first = True
+                elif self._infer_type(node.args[0]) == "std::string":
+                    is_tz_first = True
 
             if is_tz_first:
                 # A single string argument is the timestamp(dateString)
@@ -748,7 +840,7 @@ class CallVisitor:
                 sc = args[6] if len(args) > 6 else "0"
                 return (
                     f"[&]() -> int64_t {{ "
-                    f"std::string _tz = ({tz}); "
+                    f"std::string _tz = pineforge::normalize_timezone_for_posix(({tz})); "
                     f"int _yr = ({yr}); int _mo = ({mo}); int _dy = ({dy}); "
                     f"int _hr = ({hr}); int _min = ({mn}); int _sc = ({sc}); "
                     f"static thread_local std::string _last_tz; "
@@ -760,6 +852,7 @@ class CallVisitor:
                     f"struct tm t = {{}}; "
                     f"t.tm_year = _yr - 1900; t.tm_mon = _mo - 1; "
                     f"t.tm_mday = _dy; t.tm_hour = _hr; t.tm_min = _min; t.tm_sec = _sc; "
+                    f"t.tm_isdst = -1; "
                     f"int64_t _res; "
                     f"if (_tz.empty() || _tz == \"UTC\" || _tz == \"Etc/UTC\") {{ "
                     f"_res = (int64_t)timegm(&t) * 1000; "
@@ -840,7 +933,15 @@ class CallVisitor:
         if func_name == "float" and namespace is None and node.args:
             return f"(double)({self._visit_expr(node.args[0])})"
         if func_name == "bool" and namespace is None and node.args:
-            return f"(bool)({self._visit_expr(node.args[0])})"
+            # Pine v6 bools are two-state. Explicit bool(int/float) treats na
+            # like false, while a raw C++ cast would make NaN truthy.
+            x = self._visit_expr(node.args[0])
+            return (
+                f"[&](){{ auto _pf_v = ({x}); "
+                f"using _pf_t = std::decay_t<decltype(_pf_v)>; "
+                f"if constexpr (std::is_same_v<_pf_t, bool>) {{ return _pf_v; }} "
+                f"else {{ return is_na(_pf_v) ? false : (bool)_pf_v; }} }}()"
+            )
         if func_name == "string" and namespace is None and node.args:
             # Pine string(x) cast — same emission as str.tostring(x), with
             # string passthrough and TV-style "true"/"false" for bools
@@ -1060,17 +1161,32 @@ class CallVisitor:
 
         def _visit_arg_for_series(arg_node, arg_idx):
             """Visit a function argument, returning Series ref for series params."""
-            if arg_idx in _func_series_param_indices and isinstance(arg_node, Identifier):
-                aname = arg_node.name
-                # Bar field: pass _s_close instead of current_bar_.close
-                if aname in BAR_FIELDS or aname in BAR_SERIES_PUSH:
-                    return f"_s_{aname}"
-                # Series var: pass the Series object directly
-                if aname in self.ctx.series_vars:
-                    safe = self._safe_name(aname)
-                    if self._active_var_remap and safe in self._active_var_remap:
-                        safe = self._active_var_remap[safe]
-                    return safe
+            if arg_idx in _func_series_param_indices:
+                if isinstance(arg_node, Identifier):
+                    aname = arg_node.name
+                    # Bar field: pass _s_close instead of current_bar_.close
+                    if aname in BAR_FIELDS or aname in BAR_SERIES_PUSH:
+                        return f"_s_{aname}"
+                    # Series var: pass the Series object directly
+                    if aname in self.ctx.series_vars:
+                        safe = self._safe_name(aname)
+                        if self._active_var_remap and safe in self._active_var_remap:
+                            safe = self._active_var_remap[safe]
+                        return safe
+                expr_cpp = self._visit_expr(arg_node)
+                cpp_t = self._infer_type(arg_node)
+                if cpp_t not in ("double", "int", "bool"):
+                    cpp_t = "double"
+                member = self._inline_history_member(
+                    "series_arg", node, arg_idx=arg_idx
+                )
+                return (
+                    f"([&]() -> const Series<{cpp_t}>& {{ "
+                    f"{cpp_t} _sv = ({expr_cpp}); "
+                    f"if (history_advances_new_bar()) {member}.push(_sv); "
+                    f"else {member}.update(_sv); "
+                    f"return {member}; }}())"
+                )
             return self._visit_expr(arg_node)
 
         if node.kwargs:
@@ -1167,8 +1283,34 @@ class CallVisitor:
 
     def _visit_fixnan(self, node: FuncCall) -> str:
         """Emit fixnan with persistent state member."""
-        self._fixnan_counter += 1
-        member = f"_prev_fixnan_{self._fixnan_counter}"
+        # Variant-aware lookup keyed off the analyzer-tracked site:
+        #   * function-owned site -> dispatch through the active per-call-site
+        #     remap so each emitted variant (cs0/cs1/__ni{N}) references its
+        #     OWN previous-value member.
+        #   * top-level site (owner_func is None) -> use ``site.member_name``
+        #     directly. The declarations come from ``ctx.fixnan_sites`` keyed
+        #     by these member names, so referencing anything else (e.g. the
+        #     legacy monotonic counter) would either dangle a declaration or
+        #     silently alias another site's state. In particular, when a
+        #     function-owned fixnan is analyzed BEFORE a top-level one, the
+        #     counter would restart at 1 and collide with the function's
+        #     ``_prev_fixnan_1`` -- corrupting both. Using the site's own
+        #     member name keeps declaration and reference in lockstep.
+        #   * unmapped site (node not in the site map, e.g. a fixnan reached
+        #     only through a path the analyzer didn't register) -> fall back
+        #     to the legacy monotonic counter so emission still produces a
+        #     referenceable member.
+        site = self._fixnan_site_map.get(id(node))
+        if site is not None:
+            if site.member_name in self._func_fixnan_members:
+                member = self._active_fixnan_remap.get(
+                    site.member_name, site.member_name
+                )
+            else:
+                member = site.member_name
+        else:
+            self._fixnan_counter += 1
+            member = f"_prev_fixnan_{self._fixnan_counter}"
         x = self._visit_expr(node.args[0])
         return f"(is_na({x}) ? {member} : ({member} = {x}))"
 
@@ -1252,17 +1394,17 @@ class CallVisitor:
                 qty_val = self._visit_expr(qty_n) if qty_n else "na<double>()"
                 comment = self._visit_expr(comment_n) if comment_n is not None else '""'
                 oca_val = self._visit_expr(oca_name_n) if oca_name_n is not None else '""'
+                profit_ticks = "na<double>()"
+                loss_ticks = "na<double>()"
 
                 if profit_n and not limit_n:
-                    ticks = self._visit_expr(profit_n)
-                    limit_val = f"(position_entry_price_ + (signed_position_size() > 0 ? 1.0 : -1.0) * ({ticks}) * syminfo_mintick_)"
+                    profit_ticks = self._visit_expr(profit_n)
                 if loss_n and not stop_n:
-                    ticks = self._visit_expr(loss_n)
-                    stop_val = f"(position_entry_price_ - (signed_position_size() > 0 ? 1.0 : -1.0) * ({ticks}) * syminfo_mintick_)"
+                    loss_ticks = self._visit_expr(loss_n)
 
                 return (f"strategy_exit({exit_id}, {from_id}, {limit_val}, {stop_val}, "
                         f"{trail_pts}, {trail_off}, {trail_pr}, {qty_pct}, {comment}, "
-                        f"{qty_val}, {oca_val})")
+                        f"{qty_val}, {oca_val}, {profit_ticks}, {loss_ticks})")
             close_comment = self._visit_expr(comment_n) if comment_n is not None else '""'
             return f"strategy_close({exit_id}, {close_comment})"
 
@@ -1483,23 +1625,12 @@ class CallVisitor:
         if func_name == "avg" and len(args) > 2:
             sum_expr = " + ".join(f"(double)({a})" for a in args)
             return f"(({sum_expr}) / {len(args)}.0)"
-        if func_name == "max" and len(args) > 2:
-            result = f"std::max((double)({args[0]}), (double)({args[1]}))"
-            for a in args[2:]:
-                result = f"std::max({result}, (double)({a}))"
-            return result
-        if func_name == "min" and len(args) > 2:
-            result = f"std::min((double)({args[0]}), (double)({args[1]}))"
-            for a in args[2:]:
-                result = f"std::min({result}, (double)({a}))"
-            return result
+        if func_name in ("min", "max"):
+            return _math_minmax_na_expr(func_name, args)
         if func_name in MATH_FUNC_MAP:
             mapped = MATH_FUNC_MAP[func_name]
             if "{0}" in mapped:
                 return mapped.format(*args)
-            # std::min/std::max require same types — cast to double
-            if func_name in ("min", "max") and len(args) == 2:
-                return f"{mapped}((double)({args[0]}), (double)({args[1]}))"
             return f"{mapped}({', '.join(args)})"
         # Unknown math.* — safe fallback
         return f"0.0 /* unsupported: math.{func_name} */"

package/pineforge_codegen/codegen/visit_expr.py

@@ -166,6 +166,20 @@ _BUILTIN_NAMESPACE_NAMES: frozenset[str] = frozenset({
 })
 
 
+# KI-71: Pine relational comparisons (``==`` ``!=`` ``<`` ``>`` ``<=`` ``>=``)
+# with an ``na`` operand evaluate *falsy*. Naive C++ relationals do not honour
+# this for the engine's na sentinels, so these ops route through na-aware
+# lowering when an operand can be na (see ``_visit_binop`` / ``_operand_na_kind``).
+_RELATIONAL_OPS: frozenset[str] = frozenset({"==", "!=", "<", ">", "<=", ">="})
+
+# C++ scalar types carrying a detectable ``na`` sentinel via ``is_na``:
+# ``double`` -> NaN (IEEE), ``int``/``int64_t`` -> ``numeric_limits<T>::min()``.
+# Only these route through the na-aware relational lowering — ``is_na`` has no
+# overload for ``bool``/``std::string``/vector/UDT-value operands, and Pine's
+# na-bool is engine-indistinguishable from ``false`` (na<bool>() == false).
+_NA_SCALAR_CPP: frozenset[str] = frozenset({"int", "int64_t", "double"})
+
+
 class ExprVisitor:
     """Expression-level visitor methods shared across the codegen.
 
@@ -275,6 +289,16 @@ class ExprVisitor:
                 return str(val)
             if isinstance(val, str):
                 return f'std::string("{val}")'
+        # TA runtime-reset lowering: an input-backed var renders as its
+        # override-aware getter (not the member name), because the reset may
+        # run before the input members are initialised (evaluate_security path).
+        if (self._reset_input_getter_mode
+                and name in self._input_backed_vars
+                and name in self._input_var_to_call):
+            call_node = self._input_var_to_call[name]
+            func_name_i, namespace_i = self._resolve_callee(call_node.callee)
+            title = self._get_input_title(call_node, var_name=name)
+            return self._render_input_value(call_node, func_name_i, namespace_i, title)
         # Pine type name `color` used as a value (no variable) → int64 color constant.
         # Params handled above; symbol table does not retain function locals after analysis.
         if name == "color":
@@ -373,7 +397,12 @@ class ExprVisitor:
                 if node.member == "position_size":
                     return "signed_position_size()"
                 if node.member == "position_avg_price":
-                    return "position_entry_price_"
+                    # Pine returns `na` when the position is flat
+                    # (position_size == 0); the engine field is 0.0 when flat.
+                    # Guard so the common `na(strategy.position_avg_price)`
+                    # flat/in-position idiom is not silently defeated.
+                    return ("(signed_position_size() == 0.0 ? na<double>() "
+                            ": position_entry_price_)")
                 if node.member == "position_entry_name":
                     return "position_entry_name()"
                 # Trade counts
@@ -478,13 +507,34 @@ class ExprVisitor:
                     (node.member in TA_IMPLICIT_COMPUTE_FULL and node.member in TA_COMPUTE_ARGS and TA_COMPUTE_ARGS[node.member] == [])
                     or node.member == "vwap"
                 ):
-                    # Find the matching call site
-                    for site in self.ctx.ta_call_sites:
+                    # Find the matching call site. Skip sites pruned as dead
+                    # code (their owner function is never called): a dead site's
+                    # member declaration is never emitted (see base.py
+                    # ``_dead_ta_indices`` / emit_top.py member-decl guard), so
+                    # binding a LIVE bare property read to one references an
+                    # undeclared member. Regression: nightowlxtrader-azt — a live
+                    # ``ta.vwap`` (top-level + inside request.security) resolved
+                    # to dead ``f5``'s first-in-order ``_ta_vwap_10`` and emitted
+                    # ``use of undeclared identifier '_ta_vwap_10'``. A live read
+                    # must bind to a live site.
+                    for _i, site in enumerate(self.ctx.ta_call_sites):
+                        if _i in self._dead_ta_indices:
+                            continue
                         ta_short = site.class_name.split("::")[-1].lower()
                         if site.member_name.startswith(f"_ta_{node.member}_"):
                             if node.member == "vwap":
-                                return f"(is_first_tick_ ? {site.member_name}.compute(current_bar_.close, current_bar_.volume, current_bar_.timestamp) : {site.member_name}.recompute(current_bar_.close, current_bar_.volume, current_bar_.timestamp))"
-                            return f"(is_first_tick_ ? {site.member_name}.compute({TA_IMPLICIT_COMPUTE_FULL[node.member]}) : {site.member_name}.recompute({TA_IMPLICIT_COMPUTE_FULL[node.member]}))"
+                                return (
+                                    f"(history_advances_new_bar() ? {site.member_name}.compute("
+                                    "current_bar_.close, current_bar_.volume, current_bar_.timestamp) "
+                                    f": {site.member_name}.recompute(current_bar_.close, "
+                                    "current_bar_.volume, current_bar_.timestamp))"
+                                )
+                            return (
+                                f"(history_advances_new_bar() ? {site.member_name}.compute("
+                                f"{TA_IMPLICIT_COMPUTE_FULL[node.member]}) : "
+                                f"{site.member_name}.recompute("
+                                f"{TA_IMPLICIT_COMPUTE_FULL[node.member]}))"
+                            )
                     # No registered call site for this TA property read —
                     # the old fallback emitted std::string("<name>"), a
                     # silent type mismatch. Reject loudly instead.
@@ -724,11 +774,95 @@ class ExprVisitor:
                 return f'std::string("{node.member}")'
         return f"{obj}.{node.member}"
 
+    def _operand_na_kind(self, node, cpp_type: str) -> str | None:
+        """Classify a relational operand by the ``na`` sentinel it can carry.
+
+        Returns:
+
+        * ``"int"``   — an ``int``/``int64_t`` expression that can hold the
+          ``INT_MIN`` sentinel. Because that sentinel is a *finite* very-negative
+          integer (not NaN), naive C++ diverges from Pine's falsy-on-na rule for
+          EVERY relational — ordered (``<`` ``>`` ``<=`` ``>=``) and equality
+          (``==`` ``!=``) alike.
+        * ``"float"`` — a ``double`` expression that can hold NaN. IEEE already
+          yields ``false`` for ``==`` ``<`` ``>`` ``<=`` ``>=`` against NaN
+          (matching Pine's falsy), so the ONLY diverging float cell is ``!=``
+          (IEEE ``NaN != x`` is true; Pine is falsy).
+        * ``None``     — provably not na (numeric/bool literal, inlined
+          compile-time constant) or a non-scalar type with no ``is_na`` overload;
+          the naive emission is already correct.
+        """
+        if cpp_type not in _NA_SCALAR_CPP:
+            return None
+        # Literals are never na.
+        if isinstance(node, (NumberLiteral, BoolLiteral)):
+            return None
+        # A bare ``na`` lowers to ``na<double>()`` — a real NaN, i.e. it IS na.
+        if self._is_na_expr(node):
+            return "float"
+        # Inlined compile-time constants (non-input known vars) never hold na.
+        if (isinstance(node, Identifier)
+                and node.name in self._known_vars
+                and node.name not in self._input_backed_vars):
+            return None
+        return "int" if cpp_type in ("int", "int64_t") else "float"
+
+    def _emit_na_relational(self, op: str, left: str, right: str) -> str:
+        """Emit an na-aware relational: ``false`` when either operand is ``na``.
+
+        Mirrors the ``nz()`` lambda idiom (``visit_call``): each operand is
+        hoisted to a temporary so a stateful operand expression is evaluated
+        exactly once (no double-step), then compared only when neither side is
+        na. ``is_na`` resolves via the emitted ``using namespace pineforge;``
+        (``double`` -> ``isnan``; integral -> ``== numeric_limits<T>::min()``).
+        """
+        return (f"([&]{{ auto _pna_l = ({left}); auto _pna_r = ({right}); "
+                f"return !is_na(_pna_l) && !is_na(_pna_r) && "
+                f"(_pna_l {op} _pna_r); }}())")
+
+    def _lower_relational(self, op: str, left_node, right_node,
+                          left_cpp: str, right_cpp: str) -> str:
+        """Lower a Pine relational to C++, applying KI-71 na-aware wrapping.
+
+        Shared by ``_visit_binop`` and the ``request.security`` expression
+        builder so EVERY relational emission site honours Pine's falsy-on-na
+        rule. Wraps only the diverging cells: any na-capable *integer* operand
+        (the INT_MIN sentinel poisons all six operators) or a ``!=`` with an
+        na-capable *float* operand (the sole IEEE-diverging float cell). Pure
+        ``double`` ``==`` ``<`` ``>`` ``<=`` ``>=`` keep the naive emission —
+        IEEE is already falsy-on-NaN there, so wrapping would be a pure no-op.
+        Non-relational ``op`` (or non-scalar operands with no ``is_na``) fall
+        through to the naive ``(left op right)`` form unchanged.
+        """
+        if op in _RELATIONAL_OPS:
+            lt = self._infer_type(left_node)
+            rt = self._infer_type(right_node)
+            if lt in _NA_SCALAR_CPP and rt in _NA_SCALAR_CPP:
+                lk = self._operand_na_kind(left_node, lt)
+                rk = self._operand_na_kind(right_node, rt)
+                int_na = "int" in (lk, rk)
+                float_na = "float" in (lk, rk)
+                if int_na or (op == "!=" and float_na):
+                    return self._emit_na_relational(op, left_cpp, right_cpp)
+        return f"({left_cpp} {op} {right_cpp})"
+
     def _visit_binop(self, node: BinOp) -> str:
         left = self._visit_expr(node.left)
         right = self._visit_expr(node.right)
         cpp_ops = {"and": "&&", "or": "||"}
         op = cpp_ops.get(node.op, node.op)
+        if node.op == "+":
+            lt = self._infer_type(node.left)
+            rt = self._infer_type(node.right)
+            if lt == "std::string" or rt == "std::string":
+                def _as_string(rendered, inferred):
+                    if inferred == "std::string":
+                        return rendered
+                    if inferred == "bool":
+                        return f'(({rendered}) ? std::string("true") : std::string("false"))'
+                    return f"std::to_string({rendered})"
+
+                return f"({_as_string(left, lt)} + {_as_string(right, rt)})"
         # PineScript % works on floats — use std::fmod in C++
         if node.op == "%":
             return f"std::fmod((double)({left}), (double)({right}))"
@@ -738,7 +872,7 @@ class ExprVisitor:
         # Ref: https://www.tradingview.com/pine-script-docs/concepts/operators/
         if node.op == "/":
             return f"((double)({left}) / (double)({right}))"
-        return f"({left} {op} {right})"
+        return self._lower_relational(op, node.left, node.right, left, right)
 
     def _visit_unaryop(self, node: UnaryOp) -> str:
         operand = self._visit_expr(node.operand)
@@ -784,26 +918,26 @@ class ExprVisitor:
         # ``ta.highest(high, 10)[1]`` or ``f()[2]``. In Pine the call yields a
         # series, so ``[k]`` reads its value k bars ago — but the call lowers to
         # a freshly-computed C++ scalar, and ``scalar[k]`` is not subscriptable.
-        # Materialize the result into a self-contained history buffer: a static
+        # Materialize the result into a checkpoint-owned class-member
         # ``Series<T>`` that pushes (new bar) / updates (intrabar) the value
         # exactly once per evaluation — same semantics as every other series in
         # the strategy — and read ``[k]`` off it. The inner call is emitted once
-        # so its own stateful indicator is not double-stepped, and the buffer
-        # clears itself on run-start (``is_first_tick_ && bar_index_ == 0``) so a
-        # reused strategy handle (parameter sweep) does not leak prior-run history.
+        # so its own stateful indicator is not double-stepped.  The deterministic
+        # member identity includes the emitted UDF variant; separate Pine call
+        # sites never share history, and on_bar clears every synthetic member at
+        # run-start even when this particular expression is conditional.
         if isinstance(node.object, FuncCall):
             inner = self._visit_expr(node.object)
             cpp_t = self._infer_type(node.object)
             if cpp_t not in ("double", "int", "bool"):
                 cpp_t = "double"
+            member = self._inline_history_member("hist_call", node)
             return (
                 f"([&]() -> {cpp_t} {{ "
-                f"static thread_local Series<{cpp_t}> _hist_call; "
-                f"if (is_first_tick_ && bar_index_ == 0) _hist_call.clear(); "
                 f"{cpp_t} _hv = ({inner}); "
-                f"if (is_first_tick_) _hist_call.push(_hv); "
-                f"else _hist_call.update(_hv); "
-                f"return _hist_call[(int)({idx})]; }}())"
+                f"if (history_advances_new_bar()) {member}.push(_hv); "
+                f"else {member}.update(_hv); "
+                f"return {member}[(int)({idx})]; }}())"
             )
         obj = self._visit_expr(node.object)
         # If subscripting a non-series variable (e.g., function parameter),