@pineforge/codegen-pyodide 0.10.1 → 0.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pineforge/codegen-pyodide",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "Gate-validated Pyodide payload for the PineScript v6 -> C++ transpiler: archive (run in Pyodide), unpacked source, introspected tables, and release metadata.",
   "type": "module",
   "main": "index.mjs",

package/pineforge_codegen/codegen/base.py

@@ -5,6 +5,7 @@ results from AnalyzerContext instead of walking the AST to collect info.
 """
 
 from __future__ import annotations
+import re
 
 from dataclasses import dataclass
 
@@ -309,6 +310,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # Set of var/series member names that belong to user functions (need cloning)
         self._func_var_members_set: set[str] = set()
         self._precalc_loop_active: bool = False
+        # Top-level lazy-edge TA sites hoisted to every-bar evaluation for the
+        # statement currently being lowered: FuncCall id -> local name, and
+        # Subscript id -> ``_hist_call_*`` member (see ``ta.py``).
+        self._hoisted_ta_values: dict[int, str] = {}
+        self._hoisted_hist_reads: dict[int, str] = {}
         # Names of ``var`` members that live in a callable scope (not global).
         # Their exact declaration statements own initialization; they must not
         # be initialized by the constructor or the global on_bar preamble.
@@ -514,6 +520,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # the declaration-derived checkpoint inventory.
         self._inline_history_members: list[dict] = []
         self._inline_history_member_by_key: dict[tuple, str] = {}
+        # request.security/request.security_lower_tf inline their Pine helper
+        # expressions on the requested clock instead of calling the ordinary
+        # emitted UDF methods.  The chart-clocked plain-UDF history factor must
+        # therefore exclude those source nodes and any emitted helper context
+        # reached only through them.
+        self._requested_context_inline_node_ids: set[int] = set()
+        self._requested_context_only_inline_contexts: set[
+            tuple[str, str | None]
+        ] = set()
         # Unique lambda-local names used when an array lowering references its
         # receiver more than once.  The binding keeps temporary-producing or
         # side-effectful receivers single-evaluation (see TypeInferer).
@@ -925,6 +940,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._register_global_aggregate_member_types()
         self._uses_map = self._detect_map_usage()
         self._uses_matrix = self._detect_matrix_usage()
+        self._uses_pine_time = self._detect_pine_time_usage()
+        self._uses_vwap_anchor = self._detect_vwap_usage()
         # Drawing-objects-as-data: gate all new emission (drawing.hpp include +
         # the per-type arenas) on this flag so non-drawing strategies stay
         # byte-identical. Caps come from the strategy() header max_*_count.
@@ -2101,6 +2118,45 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     return True
         return False
 
+    def _detect_pine_time_usage(self) -> bool:
+        """True if emitted C++ calls the engine's pine_time()/pine_time_close().
+
+        Gates the PF_PINE_TIME_SESSION_DAY_ARGS prelude shim (emit_top.py) so
+        scripts that never call ``time(tf[, session[, tz]])`` /
+        ``time_close(...)`` stay byte-identical. A ``var`` initializer is
+        also text-scanned, mirroring ``_detect_matrix_usage``.
+        """
+        pat = re.compile(r"(?<![\w.])time(?:_close)?\s*\(")
+        for _, _, init_str in self.ctx.var_members:
+            if init_str and pat.search(str(init_str)):
+                return True
+        for node in self._walk_ast(self.ctx.ast):
+            if isinstance(node, FuncCall) and (node.args or node.kwargs):
+                fn, ns = self._resolve_callee(node.callee)
+                if ns is None and fn in ("time", "time_close"):
+                    return True
+        return False
+
+    def _detect_vwap_usage(self) -> bool:
+        """True if emitted C++ calls ta::VWAP / ta::VWAPBands compute().
+
+        Gates the PF_VWAP_SESSION_ANCHOR_ARGS prelude shim (emit_top.py):
+        ``ta.vwap(...)`` calls, the bare ``ta.vwap`` property read, and
+        ``var`` initializers are covered.
+        """
+        for _, _, init_str in self.ctx.var_members:
+            if init_str and "ta.vwap" in str(init_str):
+                return True
+        for node in self._walk_ast(self.ctx.ast):
+            if isinstance(node, FuncCall):
+                fn, ns = self._resolve_callee(node.callee)
+                if ns == "ta" and fn == "vwap":
+                    return True
+            elif isinstance(node, MemberAccess) and node.member == "vwap":
+                if getattr(node.object, "name", None) == "ta":
+                    return True
+        return False
+
     def _detect_generic_matrix_usage(self) -> bool:
         """True if emitted C++ mentions a non-float matrix specialization."""
         float_spec = TypeSpec.primitive("float")
@@ -3173,7 +3229,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         """
         self._inline_history_members = []
         self._inline_history_member_by_key = {}
-        counters = {"hist_call": 0, "series_arg": 0}
+        counters = {
+            "hist_call": 0,
+            "series_arg": 0,
+            "udf_series_arg": 0,
+        }
 
         def walk_nodes(value):
             """Yield AST nodes in stable field order, including tuple elements.
@@ -3345,6 +3405,113 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             lexical.update(self._func_collection_types.get(owner, {}))
             return lexical
 
+        def plain_udf_info(call: FuncCall):
+            if not isinstance(call.callee, Identifier):
+                return None
+            candidate = self._func_info_map.get(call.callee.name)
+            if (
+                candidate is None
+                or candidate.node is None
+                or getattr(candidate, "is_udt_method", False)
+            ):
+                return None
+            return candidate
+
+        # Requested-context UDF expressions are lowered independently by
+        # security.py.  Classify their otherwise-emitted helper variants so
+        # this chart-clocked factor neither allocates unused buffers for them
+        # nor changes the legacy bodies that remain in generated C++.
+        requested_node_ids: set[int] = set()
+        for security_call in self._security_calls:
+            expression = security_call.get("expr_node")
+            if expression is None:
+                continue
+            requested_node_ids.update(
+                id(child) for child in walk_nodes(expression)
+            )
+        self._requested_context_inline_node_ids = requested_node_ids
+
+        def emitted_context_for_call(
+            fi,
+            call: FuncCall,
+            owner: str | None,
+            owner_context: str | None,
+        ) -> str | None:
+            dispatch = self._instance_dispatch.get(
+                (owner_context, id(call))
+            )
+            if dispatch is not None:
+                return dispatch
+            target_cs = target_cs_for_context(
+                fi, call, owner, owner_context
+            )
+            if target_cs is not None:
+                return f"{self._func_cpp_base_name(fi.name)}_cs{target_cs}"
+            return None
+
+        requested_roots: set[tuple[str, str | None]] = set()
+        chart_roots: set[tuple[str, str | None]] = set()
+        context_edges: dict[
+            tuple[str, str | None], set[tuple[str, str | None]]
+        ] = {}
+        for call in (
+            candidate
+            for candidate in walk_nodes(self.ctx.ast)
+            if isinstance(candidate, FuncCall)
+        ):
+            fi = plain_udf_info(call)
+            if fi is None:
+                continue
+            owner = owner_by_node.get(id(call))
+            if id(call) in requested_node_ids:
+                owner_contexts = (
+                    [None]
+                    if owner is None
+                    else self._inline_history_contexts_for_owner(owner)
+                )
+                for owner_context in owner_contexts:
+                    requested_roots.add((
+                        fi.name,
+                        emitted_context_for_call(
+                            fi, call, owner, owner_context
+                        ),
+                    ))
+                continue
+            if owner is None:
+                target = (
+                    fi.name,
+                    emitted_context_for_call(fi, call, None, None),
+                )
+                chart_roots.add(target)
+                continue
+            for owner_context in self._inline_history_contexts_for_owner(owner):
+                source = (owner, owner_context)
+                target = (
+                    fi.name,
+                    emitted_context_for_call(
+                        fi, call, owner, owner_context
+                    ),
+                )
+                context_edges.setdefault(source, set()).add(target)
+
+        def reachable(
+            roots: set[tuple[str, str | None]],
+        ) -> set[tuple[str, str | None]]:
+            found = set(roots)
+            pending = list(roots)
+            while pending:
+                source = pending.pop()
+                for target in context_edges.get(source, ()):
+                    if target in found:
+                        continue
+                    found.add(target)
+                    pending.append(target)
+            return found
+
+        self._requested_context_only_inline_contexts = (
+            reachable(requested_roots) - reachable(chart_roots)
+        )
+
         for node in walk_nodes(self.ctx.ast):
             owner = owner_by_node.get(id(node))
             if isinstance(node, Subscript) and isinstance(node.object, FuncCall):
@@ -3403,6 +3570,26 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     expected_cpp_type = self._series_param_element_cpp_type(
                         fi, idx, target_cs
                     )
+                    # Pine gives each plain-UDF written call its own
+                    # chart-aligned parameter history.  Even an exact Series
+                    # actual therefore needs a call-site-owned buffer: skipped
+                    # evaluations hold the last value in that bar's slot
+                    # instead of exposing the caller's independently changing
+                    # history.  Typed methods retain their established direct
+                    # binding/bridge behavior below.
+                    chart_execution_context = (
+                        id(node) not in requested_node_ids
+                        and (owner, context)
+                        not in self._requested_context_only_inline_contexts
+                    )
+                    if not method_call and chart_execution_context:
+                        register_one(
+                            "udf_series_arg",
+                            (id(node), idx),
+                            expected_cpp_type,
+                            context,
+                        )
+                        continue
                     needs_bridge = True
                     if isinstance(arg, Identifier):
                         if (
@@ -3620,7 +3807,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # request.security helper-call results read at a history offset
         # (``myHelper()[k]``). Maps (sec_id, node-id) -> backing Series metadata.
         self._security_expr_hist_by_node: dict[tuple[int, int], dict] = {}
-        self._prepare_lazy_saturated_roc3_sites()
+        self._prepare_lazy_source_clock_sites()
 
         lines: list[str] = []
 
@@ -3853,11 +4040,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 )
             lines.append("")
 
-        # Source-shaped lazy ROC call clocks are generated support types, not
-        # script state themselves. Their per-callsite instances are declared
-        # below inside GeneratedStrategy and therefore join the automatic COOF
-        # checkpoint inventory.
-        self._emit_lazy_saturated_roc3_helper(lines)
+        # Hold-last source clocks (change/mom/roc below a top-level lazy edge)
+        # are generated support types, not script state themselves. Their
+        # per-callsite instances are declared below inside GeneratedStrategy
+        # and therefore join the automatic COOF checkpoint inventory.
+        self._emit_lazy_source_clock_helper(lines)
 
         # 2. Open class
         lines.append("class GeneratedStrategy : public BacktestEngine {")
@@ -4013,20 +4200,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 lines.append(f"    std::vector<{vtype}> _precalc_{site.member_name};")
         lines.append("    bool _use_precalc = false;")
 
-        for clock_name in self._lazy_saturated_roc3_clock_by_node.values():
-            lines.append(
-                f"    {self._lazy_saturated_roc3_type_name} {clock_name};"
-            )
-        if self._lazy_saturated_roc3_clock_by_node:
-            # Dedicated eager close[3] fallback. Its fixed four-slot capacity
-            # is independent of the user's max_bars_back directive, which may
-            # legitimately be smaller than the offset this generated route
-            # requires. It is ordinary copyable script state and therefore
-            # joins the automatic COOF checkpoint below.
+        for info in self._lazy_source_clock_by_node.values():
             lines.append(
-                "    Series<double> "
-                f"{self._lazy_saturated_roc3_history_name}{{4}};"
+                f"    {self._lazy_source_clock_type_name} {info['clock']};"
             )
+            # Held-source history on the chart clock. A literal length sizes
+            # it exactly (independent of the user's max_bars_back directive,
+            # which may legitimately be smaller than this generated route
+            # needs); a runtime length uses the Series default capacity. Both
+            # are ordinary copyable script state and join the automatic COOF
+            # checkpoint below.
+            literal = info["length_literal"]
+            capacity = f"{{{literal + 1}}}" if literal is not None and literal >= 1 else ""
+            lines.append(f"    Series<double> {info['hist']}{capacity};")
+            if info["chart"] is not None:
+                lines.append(f"    Series<double> {info['chart']}{capacity};")
 
         # Security evaluator TA members (cloned from expression dependencies)
         # Skip for user function call expressions — their TA deps are internal to the function

package/pineforge_codegen/codegen/emit_top.py

@@ -136,6 +136,28 @@ class TopLevelEmitter:
         lines.append('#include <pineforge/log.hpp>')
         lines.append('#include <pineforge/str_utils.hpp>')
         lines.append('#include <pineforge/session_time.hpp>')
+        # Feature-guarded argument tails (lab experiment cells build the
+        # candidate codegen against the BASE engine too): the symbol clock
+        # (syminfo tz + session) reaches time()/time_close() and ta.vwap only
+        # when the engine header advertises the overloads; otherwise the
+        # macros expand to nothing and the calls collapse to the legacy
+        # 5-arg pine_time / 3-arg VWAP::compute shapes (session filter in
+        # UTC, UTC-day VWAP anchor — the honest "factor absent" behaviour).
+        # Gated on the pre-scans so scripts without such calls stay
+        # byte-identical. The expansion carries no extra parentheses so the
+        # preprocessed call is byte-identical to the plain 7-arg form.
+        if getattr(self, "_uses_pine_time", False):
+            lines.append("#ifdef PF_PINE_TIME_HAS_SESSION_DAY")
+            lines.append("#define PF_PINE_TIME_SESSION_DAY_ARGS(tz, sess) , tz, sess")
+            lines.append("#else")
+            lines.append("#define PF_PINE_TIME_SESSION_DAY_ARGS(tz, sess)")
+            lines.append("#endif")
+        if getattr(self, "_uses_vwap_anchor", False):
+            lines.append("#ifdef PF_VWAP_HAS_SESSION_ANCHOR")
+            lines.append("#define PF_VWAP_SESSION_ANCHOR_ARGS(tz, sess) , tz, sess")
+            lines.append("#else")
+            lines.append("#define PF_VWAP_SESSION_ANCHOR_ARGS(tz, sess)")
+            lines.append("#endif")
         if self._uses_matrix:
             # Unconditional include when matrix API is used — do not gate on
             # __has_include(<Eigen/Dense>) (can differ between runtime build and this TU).
@@ -912,28 +934,38 @@ class TopLevelEmitter:
 
         # A GeneratedStrategy handle may execute multiple batch runs or
         # streaming lifecycles. BacktestEngine resets broker/base state, but
-        # generated members survive. Reset source-shaped lazy ROC clocks and
-        # their forced eager-fallback close history at the first genuine slot
-        # of each lifecycle. This lives in on_bar rather than a generated run
-        # wrapper because stream_begin() enters the base run path directly.
-        # COOF post-close recalculations have history_advances_new_bar()==false
-        # and therefore preserve the current committed clock/base.
-        if self._lazy_saturated_roc3_clock_by_node:
+        # generated members survive. Reset the hold-last source clocks
+        # (change/mom/roc below a top-level lazy edge) and their held-source
+        # Series at the first genuine slot of each lifecycle, then freeze this
+        # bar's base and record it once per chart bar. This lives in on_bar
+        # rather than a generated run wrapper because stream_begin() enters the
+        # base run path directly. COOF post-close recalculations have
+        # history_advances_new_bar()==false and therefore keep the same base.
+        if self._lazy_source_clock_by_node:
             lines.append(
                 "        if (history_advances_new_bar() && bar_index_ == 0) {"
             )
-            for clock_name in self._lazy_saturated_roc3_clock_by_node.values():
-                lines.append(f"            {clock_name}.reset();")
-            lines.append(
-                f"            {self._lazy_saturated_roc3_history_name}.clear();"
-            )
+            for info in self._lazy_source_clock_by_node.values():
+                lines.append(f"            {info['clock']}.reset();")
+                lines.append(f"            {info['hist']}.clear();")
+                if info["chart"] is not None:
+                    lines.append(f"            {info['chart']}.clear();")
             lines.append("        }")
-            self._emit_history_series_write(
-                lines,
-                "        ",
-                self._lazy_saturated_roc3_history_name,
-                "current_bar_.close",
-            )
+            for info in self._lazy_source_clock_by_node.values():
+                lines.append(f"        {info['clock']}.begin_bar(bar_index_);")
+                self._emit_history_series_write(
+                    lines,
+                    "        ",
+                    info["hist"],
+                    f"{info['clock']}.bar_base_source",
+                )
+                if info["chart"] is not None:
+                    self._emit_history_series_write(
+                        lines,
+                        "        ",
+                        info["chart"],
+                        self._visit_expr(info["chart_source"]),
+                    )
 
         # reset_run_state() owns engine/broker state, while these generated
         # Series members belong to the strategy object. Clear all of them on
@@ -949,6 +981,21 @@ class TopLevelEmitter:
                 f"{info['member_name']}.clear();"
             )
 
+        # A history-reading plain-UDF parameter advances on the chart clock,
+        # even when lazy control flow skips its written call on this bar.  Seed
+        # the new slot with the prior current value (``na`` before first reach);
+        # an executed call later in the bar updates this same slot with its
+        # scalar actual.  Typed-method ``series_arg`` bridges intentionally keep
+        # their existing execution-clock behavior.
+        for info in self._inline_history_members:
+            if info["kind"] != "udf_series_arg":
+                continue
+            member = info["member_name"]
+            lines.append(
+                f"        if (history_advances_new_bar()) "
+                f"{member}.push({member}.current());"
+            )
+
         # a. Push bar field series (with bar magnifier support)
         for field_name in sorted(self.ctx.series_bar_fields):
             push_expr = BAR_SERIES_PUSH.get(field_name, f"current_bar_.{field_name}")
@@ -1181,9 +1228,15 @@ class TopLevelEmitter:
         # an input (the default-sized construction already matches Pine).
         self._emit_ta_runtime_reset(lines, indent=2)
 
-        # d. Visit each statement
+        # d. Visit each statement. A stateful ``ta.*`` site below a lazy
+        #    ``and``/``or`` RHS or ternary arm of a top-level statement is
+        #    evaluated every bar BEFORE the statement (TV rule, see ``ta.py``).
         for stmt in self.ctx.ast.body:
-            self._visit_stmt(stmt, lines, indent=2)
+            self._emit_lazy_edge_ta_hoists(stmt, lines, indent=2)
+            try:
+                self._visit_stmt(stmt, lines, indent=2)
+            finally:
+                self._clear_lazy_edge_ta_hoists()
 
         # e. ``// @pf-trace`` pragma block — emitted last so trace values
         #    reflect every assignment / strategy call made earlier in the

package/pineforge_codegen/codegen/security.py

@@ -2844,6 +2844,156 @@ class SecurityEmitter:
         )
         return out
 
+    def _security_lazy_ta_keys(
+        self,
+        sec_id: int,
+        expr_node,
+        info: dict,
+    ) -> set[tuple[int, tuple]]:
+        """``(ta_index, binding_signature)`` pairs Pine reaches only lazily.
+
+        Pine evaluates ``and``/``or`` with left-to-right short-circuit and a
+        ternary evaluates its condition plus exactly one branch. A ``ta.*``
+        call sitting in a skipped operand is **not evaluated on that bar**, so
+        its series state does not advance. The evaluator used to hoist every
+        collected site into an unconditional ``auto _secval_N = ...compute(...)``
+        prologue, which advanced every site on every HTF bar and desynchronised
+        the series against TradingView.
+
+        A site returned here is dropped from that prologue. ``_build_security_expr``
+        then falls through to its inline
+        ``(security_series_slot_is_new(N) ? m.compute(a) : m.recompute(a))``
+        form, emitted in expression position — C++'s own ``&&`` / ``||`` /
+        ``?:`` short-circuit then advances the state exactly when Pine would,
+        and the relational lowering's ``_pna_l`` / ``_pna_r`` temporaries keep
+        the evaluation order left-to-right.
+
+        Deliberately conservative — anything not provably single-reach and
+        conditional keeps the existing eager hoist, so scripts without
+        conditional security TA regenerate byte-identically:
+
+        - A site reached more than once must stay hoisted: sharing one
+          ``_secval_*`` is what keeps it to a single advance per bar, whereas
+          two inline copies would advance it twice (or zero times).
+        - Laziness does **not** propagate through a global binding. In the
+          requested context that global is its own unconditional top-level
+          statement, so it evaluates on every HTF bar wherever it is read
+          (this is what keeps chart-side ``t0``-shaped code exact).
+        - Sites with a history offset (``ta.ema(close, 55)[1]``) keep the
+          committed ``_secval_*`` their per-bar Series push reads.
+        - Securities that rebind mutable globals, and multi-statement helper
+          calls, bail entirely: both lower through statement emitters that
+          consume ``ta_results`` outside this expression.
+        """
+        if info.get("mutable_globals"):
+            return set()
+
+        occurrences: dict[tuple[int, tuple], list[bool]] = {}
+        unsafe = False
+
+        def walk(node, lazy: bool, binding_stack, resolving: set[str]) -> None:
+            nonlocal unsafe
+            if node is None or unsafe:
+                return
+
+            if isinstance(node, Identifier):
+                binding = None
+                if not self._security_identifier_is_global_binding(node):
+                    binding = self._security_lookup_helper_binding_context(
+                        node.name, binding_stack
+                    )
+                if binding is not None:
+                    bound, bound_stack = binding
+                    if isinstance(bound, str):
+                        return
+                    bind_key = f"bind:{id(bound)}"
+                    if bind_key in resolving:
+                        return
+                    resolving.add(bind_key)
+                    walk(bound, lazy, bound_stack, resolving)
+                    resolving.discard(bind_key)
+                    return
+
+                if self._global_mutable_infos.get(node.name) is not None:
+                    unsafe = True
+                    return
+
+                global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
+                if (
+                    self._security_identifier_is_global_binding(node)
+                    and node.name in global_expr_map
+                    and node.name not in resolving
+                ):
+                    resolving.add(node.name)
+                    walk(global_expr_map[node.name], False, (), resolving)
+                    resolving.remove(node.name)
+                    return
+
+            if isinstance(node, FuncCall) and isinstance(node.callee, Identifier):
+                func_name = node.callee.name
+                if func_name in self._func_names:
+                    call_key = f"func:{func_name}"
+                    if call_key in resolving:
+                        return
+                    resolving.add(call_key)
+                    plan = self._security_helper_call_plan(node, binding_stack)
+                    if plan["mode"] == "expr":
+                        walk(plan["expr"], lazy, plan["binding_stack"], resolving)
+                    else:
+                        unsafe = True
+                    resolving.discard(call_key)
+                    return
+
+            if isinstance(node, BinOp) and node.op in ("and", "or"):
+                walk(node.left, lazy, binding_stack, resolving)
+                walk(node.right, True, binding_stack, resolving)
+                return
+
+            if isinstance(node, Ternary):
+                walk(node.condition, lazy, binding_stack, resolving)
+                walk(node.true_val, True, binding_stack, resolving)
+                walk(node.false_val, True, binding_stack, resolving)
+                return
+
+            site = self._get_ta_site(node)
+            if site is not None:
+                idx = self._ta_index_by_site_id.get(id(site))
+                if idx is not None:
+                    key = (idx, self._security_binding_stack_signature(binding_stack))
+                    occurrences.setdefault(key, []).append(lazy)
+
+            for child in vars(node).values():
+                walk_value(child, lazy, binding_stack, resolving)
+
+        def walk_value(value, lazy: bool, binding_stack, resolving: set[str]) -> None:
+            if value is None or unsafe:
+                return
+            if hasattr(value, "__dict__"):
+                walk(value, lazy, binding_stack, resolving)
+                return
+            if isinstance(value, (list, tuple)):
+                for item in value:
+                    walk_value(item, lazy, binding_stack, resolving)
+                return
+            if isinstance(value, dict):
+                for item in value.values():
+                    walk_value(item, lazy, binding_stack, resolving)
+
+        walk(expr_node, False, (), set())
+        if unsafe:
+            return set()
+
+        hist_indices = set(self._security_ta_hist_idx_by_sec.get(sec_id, ()))
+        inline_helper_ta_indices = set(info.get("inline_helper_ta_indices", []))
+        return {
+            key
+            for key, reaches in occurrences.items()
+            if key[0] not in hist_indices
+            and key[0] not in inline_helper_ta_indices
+            and len(reaches) == 1
+            and reaches[0]
+        }
+
     def _emit_security_ohlc_hist_pushes(self, sec_id: int, lines: list[str]) -> None:
         """Emit the OHLC history-offset Series pushes for ``sec_id``, gated on
         ``is_complete``.
@@ -2909,6 +3059,7 @@ class SecurityEmitter:
             ta_indices = info.get("ta_indices") or []
             security_mutable_names = set(info.get("mutable_globals", []))
             inline_helper_ta_indices = set(info.get("inline_helper_ta_indices", []))
+            lazy_ta_keys = self._security_lazy_ta_keys(sec_id, expr_node, info)
 
             lines.append(f"    void _eval_security_{sec_id}(const Bar& bar, bool is_complete) {{")
 
@@ -2949,6 +3100,15 @@ class SecurityEmitter:
                     site = self.ctx.ta_call_sites[idx]
                     variants = (info.get("ta_variants") or {}).get(idx, [])
                     for variant in variants:
+                        if (idx, variant["signature"]) in lazy_ta_keys:
+                            # Pine only reaches this site through a
+                            # short-circuited operand or an untaken ternary
+                            # branch. Leave it out of the eager prologue:
+                            # _build_security_expr emits its
+                            # compute()/recompute() inline in expression
+                            # position, where C++'s &&/||/?: short-circuit
+                            # advances the series exactly on the bars Pine does.
+                            continue
                         helper_binding_stack = variant.get("binding_stack", ())
                         compute_args = self._security_ta_compute_args_for_site(
                             sec_id,