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

package/pineforge_codegen/codegen/ta.py

@@ -22,6 +22,8 @@ Sibling-mixin methods consumed via ``self``:
 
 from __future__ import annotations
 
+import copy
+import re
 from typing import TYPE_CHECKING
 
 from ..ast_nodes import (
@@ -31,7 +33,16 @@ from ..ast_nodes import (
     Ternary, TupleAssign, TupleLiteral, TypeDecl, TypeField, UnaryOp, VarDecl,
     WhileStmt,
 )
-from .tables import TA_IMPLICIT_APPEND, TA_IMPLICIT_COMPUTE_FULL
+from ..pine_spelling import blank_string_literals
+from ..symbols import PineType
+from .helpers import pine_index_int_cast
+from .tables import (
+    BAR_SERIES_PUSH,
+    TA_CHART_PREV_CLOSE,
+    TA_CHART_PREV_CLOSE_ARG,
+    TA_IMPLICIT_APPEND,
+    TA_IMPLICIT_COMPUTE_FULL,
+)
 
 if TYPE_CHECKING:
     from ..analyzer import TACallSite
@@ -95,7 +106,52 @@ class TaSiteHelper:
     # .compute() arg-string construction
     # ------------------------------------------------------------------
 
+    _TA_BOOL_COMPUTE_ARGS = {
+        "barssince": frozenset({0}),
+        "valuewhen": frozenset({0}),
+        "pivot_point_levels": frozenset({1, 2}),
+        "vwap_anchored": frozenset({1}),
+        "vwap_anchored_bands": frozenset({1}),
+    }
+
+    def _ta_compute_arg_cpp(self, ta_name: str, position: int, node) -> str:
+        """Render one TA compute argument with Pine bool truthiness."""
+        rendered = self._visit_expr(node)
+        if position in self._TA_BOOL_COMPUTE_ARGS.get(ta_name, ()):
+            return self._coerce_bool_expr(rendered, node)
+        return rendered
+
     def _ta_compute_args_for_site(self, site: "TACallSite") -> str:
+        """``_ta_compute_args_for_site_base`` plus, for a site whose length the
+        constructor cannot take, the per-call arguments of its lowering
+        (``_ta_dynamic_compute_args``)."""
+        args = self._ta_compute_args_for_site_base(site)
+        # In a user-function body emitted for one call site, the member is
+        # that call site's clone: its own constructor arguments decide.
+        site = self._ta_active_site(site)
+        plan = self._ta_dynamic_plan(site)
+        if plan is None:
+            return args
+        return self._ta_dynamic_compute_args(site, plan, args, self._visit_expr)
+
+    def _ta_active_site(self, site: "TACallSite") -> "TACallSite":
+        """The site whose member ``_ta_member_name`` resolves ``site`` to."""
+        remap = self._active_ta_remap
+        if not remap:
+            return site
+        name = remap.get(site.member_name)
+        if not name or name == site.member_name:
+            return site
+        return self._ta_site_by_member().get(name, site)
+
+    def _ta_site_by_member(self) -> dict:
+        by_member = self.__dict__.get("_ta_site_by_member_cache")
+        if by_member is None:
+            by_member = {s.member_name: s for s in self.ctx.ta_call_sites}
+            self.__dict__["_ta_site_by_member_cache"] = by_member
+        return by_member
+
+    def _ta_compute_args_for_site_base(self, site: "TACallSite") -> str:
         """Build the C++ argument string for ``<member>.compute(...)`` of a TA site.
 
         Three layered cases:
@@ -111,17 +167,55 @@ class TaSiteHelper:
           when applicable (e.g. ``vwma()`` -> ``volume`` only)."""
         ta_name = self._ta_name_from_site(site)
 
+        # TA1's new stateful wrappers need the Pine anchor after the chart
+        # clock arguments. The compatibility shims use the timestamp and
+        # symbol clock only on an older engine; the TA1 branch ignores them.
+        if site.class_name in ("_PFAnchoredVWAP", "_PFAnchoredVWAPBands"):
+            explicit = [
+                self._ta_compute_arg_cpp(ta_name, i, a)
+                for i, a in enumerate(site.compute_args)
+            ]
+            if len(explicit) < 2:
+                raise AssertionError("anchored VWAP site is missing source/anchor")
+            return (
+                f"{explicit[0]}, current_bar_.volume, current_bar_.timestamp, "
+                f"syminfo_.timezone, syminfo_.session, {explicit[1]}"
+            )
+
+        if site.class_name == "_PFPivotPointLevels":
+            explicit = [
+                self._ta_compute_arg_cpp(ta_name, i, a)
+                for i, a in enumerate(site.compute_args)
+            ]
+            if len(explicit) < 3:
+                raise AssertionError("pivot TA1 site is missing anchor arguments")
+            return (
+                f"{explicit[0]}, {explicit[1]}, {explicit[2]}, "
+                "current_bar_.open, current_bar_.high, current_bar_.low, "
+                "current_bar_.close"
+            )
+
         if ta_name in TA_IMPLICIT_COMPUTE_FULL:
             implicit = TA_IMPLICIT_COMPUTE_FULL[ta_name]
+            # issue #178: chart-context atr / tr take the previous CHART
+            # bar's close as a 4th argument (see TA_CHART_PREV_CLOSE).
+            if ta_name in TA_CHART_PREV_CLOSE:
+                implicit = f"{implicit}, {TA_CHART_PREV_CLOSE_ARG}"
             if site.compute_args:
-                explicit = ", ".join(self._visit_expr(a) for a in site.compute_args)
+                explicit = ", ".join(
+                    self._ta_compute_arg_cpp(ta_name, i, a)
+                    for i, a in enumerate(site.compute_args)
+                )
                 if ta_name in self._TA_IMPLICIT_REPLACE:
                     return explicit
                 return f"{explicit}, {implicit}" if explicit else implicit
             return implicit
 
         if site.compute_args:
-            explicit = ", ".join(self._visit_expr(a) for a in site.compute_args)
+            explicit = ", ".join(
+                self._ta_compute_arg_cpp(ta_name, i, a)
+                for i, a in enumerate(site.compute_args)
+            )
             if ta_name in TA_IMPLICIT_APPEND:
                 return f"{explicit}, {TA_IMPLICIT_APPEND[ta_name]}"
             return explicit
@@ -383,48 +477,6 @@ class TaSiteHelper:
         "ycelestine77/quantbyboji exact on main, 2026-09-04)"
     )
 
-    _LAZY_SOURCE_CLOCK_BAR_SOURCES = frozenset({
-        "open", "high", "low", "close", "volume", "hl2", "hlc3", "ohlc4", "hlcc4",
-    })
-
-    def _script_has_user_binding(self, name: str) -> bool:
-        cache = getattr(self, "_user_binding_names", None)
-        if cache is None:
-            cache = set()
-            ast = getattr(self.ctx, "ast", None)
-            for node in self._walk_ast(ast):
-                if isinstance(node, VarDecl):
-                    cache.add(node.name)
-                elif isinstance(node, TupleAssign):
-                    cache.update(node.names)
-                elif isinstance(node, ForStmt):
-                    cache.add(node.var)
-                elif isinstance(node, ForInStmt):
-                    if node.var:
-                        cache.add(node.var)
-                    cache.update(node.vars or ())
-                elif isinstance(node, FuncDef):
-                    cache.add(node.name)
-                    cache.update(node.params)
-            self._user_binding_names = cache
-        return name in cache
-
-    def _lazy_source_clock_chart_source(self, site: "TACallSite"):
-        """The unshadowed bar-builtin source node, or None.
-
-        Between two executions closer than ``length`` bars the pin does not
-        distinguish the held read from #64's eager chart ``source[length]``;
-        the eager read is kept where the source is a plain chart builtin.
-        """
-        source = site.compute_args[0] if site.compute_args else None
-        if (
-            isinstance(source, Identifier)
-            and source.name in self._LAZY_SOURCE_CLOCK_BAR_SOURCES
-            and not self._script_has_user_binding(source.name)
-        ):
-            return source
-        return None
-
     @staticmethod
     def _lazy_source_clock_length_node(node):
         kwargs = getattr(node, "kwargs", None) or {}
@@ -494,16 +546,9 @@ class TaSiteHelper:
         clocks: dict[int, dict] = {}
         routed = self._lazy_edge_ta_hoist_plan()["source_clock"]
         for index, (node_id, info) in enumerate(routed.items(), start=1):
-            chart_source = self._lazy_source_clock_chart_source(info["site"])
             clocks[node_id] = {
                 "clock": allocate(f"_pf_lazy_src_clock_{index}", reserved_members),
                 "hist": allocate(f"_pf_lazy_src_hist_{index}", reserved_members),
-                "chart": (
-                    allocate(f"_pf_lazy_src_chart_{index}", reserved_members)
-                    if chart_source is not None
-                    else None
-                ),
-                "chart_source": chart_source,
                 "site": info["site"],
                 "node": info["node"],
                 "length_literal": info["length_literal"],
@@ -516,22 +561,22 @@ class TaSiteHelper:
         source = self._visit_expr(site.compute_args[0])
         length_node = self._lazy_source_clock_length_node(node)
         literal = self._lazy_source_clock_length_literal(length_node)
-        chart = info["chart"]
         if literal is not None:
             length_expr = str(literal)
             held = f"{info['hist']}[{literal - 1}]" if literal >= 1 else "na<double>()"
-            eager = f"{chart}[{literal}]" if chart is not None else held
         else:
-            length_expr = f"(int)({self._visit_expr(length_node)})"
+            length_raw = self._visit_expr(length_node)
+            length_expr = self._coerce_int_slot(
+                length_raw, length_node, "int"
+            )
+            if (length_expr == length_raw
+                    and not self._emitted_value_is_double(length_node)):
+                length_expr = pine_index_int_cast(length_raw)
             held = (
                 f"(({length_expr}) >= 1 ? {info['hist']}[({length_expr}) - 1] "
                 f": na<double>())"
             )
-            eager = f"{chart}[{length_expr}]" if chart is not None else held
-        previous = (
-            f"{info['clock']}.previous_source({held}, {eager}, {length_expr}, "
-            f"bar_index_)"
-        )
+        previous = f"{info['clock']}.previous_source({held}, {length_expr})"
         method = "roc" if self._ta_name_from_site(site) == "roc" else "change"
         return f"{info['clock']}.{method}({source}, {previous})"
 
@@ -549,10 +594,8 @@ class TaSiteHelper:
                 "// history is na before the first execution. The paired hist Series",
                 "// holds `bar_base_source` (the value committed by earlier bars) once",
                 "// per chart bar, so `hist[length - 1]` is the source at the most",
-                "// recent execution at or before bar-length. Between two executions",
-                "// closer than `length` bars the tapes do not distinguish that read",
-                "// from the eager chart `source[length]`, so the #64 eager read is",
-                "// kept there for chart-builtin sources.",
+                "// recent execution at or before bar-length, also when the previous",
+                "// execution is closer than `length` bars.",
                 f"struct {type_name} {{",
                 "    double committed_source = na<double>();",
                 "    int committed_bar = -1;",
@@ -578,12 +621,11 @@ class TaSiteHelper:
                 "        }",
                 "    }",
                 "",
-                "    double previous_source(double held, double eager, int length,",
-                "                           int bar) const {",
+                "    double previous_source(double held, int length) const {",
                 "        if (bar_base_bar < 0 || length < 1) {",
                 "            return na<double>();",
                 "        }",
-                "        return bar - bar_base_bar >= length ? held : eager;",
+                "        return held;",
                 "    }",
                 "",
                 "    double change(double source, double previous) {",
@@ -642,6 +684,10 @@ class TaSiteHelper:
         and request.security sites retain their existing behavior."""
         if not getattr(site, "is_static", False):
             return False
+        if self._ta_dynamic_plan(site) is not None:
+            # The length is read on the bar (its first execution, or every
+            # call); precalculate() has no such value.
+            return False
         node = getattr(site, "node", None)
         plan = self._lazy_edge_ta_hoist_plan()
         if node is not None and (
@@ -858,29 +904,78 @@ class TaSiteHelper:
                 return
             # Literals, identifiers and anything else are leaves.
 
-        def roots(stmt) -> list:
-            if isinstance(stmt, VarDecl):
-                if stmt.is_var or stmt.is_varip:
-                    return []
-                return [stmt.value]
-            if isinstance(stmt, Assignment):
-                return [stmt.target, stmt.value]
-            if isinstance(stmt, TupleAssign):
-                return [stmt.value]
-            if isinstance(stmt, ExprStmt):
-                return [stmt.expr]
-            if isinstance(stmt, IfStmt):
-                return [stmt.condition]
-            return []
-
         ast = getattr(self.ctx, "ast", None)
         for stmt in getattr(ast, "body", ()) or ():
             units: list[dict] = []
-            for root in roots(stmt):
+            for root in self._lazy_edge_statement_roots(stmt):
                 scan(root, False, units)
             if units:
                 by_stmt[id(stmt)] = units
 
+        # A change / mom / roc call in a top-level if block -- an else-if's
+        # and a nested if's too -- runs only on the bars its block runs, and
+        # reads its own held source history as a lazy operand's call does:
+        # TradingView's tape of te_lazy_if_source reads ta.roc(close, 3) on
+        # its tenth bar from the close its third bar held, where the
+        # executions' own ring is still short (and the stateful ROC oracles
+        # pf-probe-quant-stateful-roc-* read their reached ROC so). Loop and
+        # switch bodies, a var initializer and a call read with history keep
+        # their lowering.
+        def block_sites(node, history_read: bool = False) -> None:
+            if node is None or isinstance(node, (str, int, float, bool)):
+                return
+            if isinstance(node, (list, tuple)):
+                for child in node:
+                    block_sites(child)
+                return
+            if not isinstance(node, ASTNode) or isinstance(
+                    node, (FuncDef, MethodDef, ForStmt, ForInStmt, WhileStmt, SwitchStmt)):
+                return
+            if isinstance(node, VarDecl) and (node.is_var or node.is_varip):
+                return
+            if isinstance(node, Subscript):
+                block_sites(node.object, history_read=True)
+                block_sites(node.index)
+                return
+            if isinstance(node, FuncCall):
+                callee = node.callee
+                is_security = (
+                    isinstance(callee, MemberAccess)
+                    and isinstance(callee.object, Identifier)
+                    and callee.object.name == "request"
+                    and callee.member in ("security", "security_lower_tf")
+                )
+                site = None if history_read else self._get_ta_site(node)
+                if (site is not None
+                        and self._ta_name_from_site(site) in self.LAZY_SOURCE_CLOCK_TA
+                        and self._lazy_source_clock_eligible(site)):
+                    source_clock.setdefault(id(node), {
+                        "node": node,
+                        "site": site,
+                        "length_literal": self._lazy_source_clock_length_literal(
+                            self._lazy_source_clock_length_node(node)
+                        ),
+                    })
+                for idx, arg in enumerate(getattr(node, "args", ()) or ()):
+                    if not (is_security and idx == 2):
+                        block_sites(arg)
+                for key, value in (getattr(node, "kwargs", None) or {}).items():
+                    if not (is_security and key == "expression"):
+                        block_sites(value)
+                return
+            for key, value in vars(node).items():
+                if key not in ("loc", "annotations"):
+                    block_sites(value)
+
+        for stmt in getattr(ast, "body", ()) or ():
+            blocks = [stmt] if isinstance(stmt, IfStmt) else [
+                value for value in (getattr(stmt, "value", None),)
+                if isinstance(stmt, (VarDecl, Assignment)) and isinstance(value, IfStmt)
+            ]
+            for block in blocks:
+                block_sites(block.body)
+                block_sites(block.else_body)
+
         plan = {
             "by_stmt": by_stmt,
             "call_nodes": call_nodes,
@@ -925,6 +1020,214 @@ class TaSiteHelper:
         self._hoisted_ta_values.clear()
         self._hoisted_hist_reads.clear()
 
+    @staticmethod
+    def _lazy_edge_statement_roots(stmt) -> list:
+        """The expressions of one statement a scope runs on every execution:
+        a ``VarDecl`` value (not a ``var``/``varip`` initializer), an
+        ``Assignment``'s target and value, a ``TupleAssign`` value, an
+        ``ExprStmt`` and an ``IfStmt``'s head condition."""
+        if isinstance(stmt, VarDecl):
+            if stmt.is_var or stmt.is_varip:
+                return []
+            return [stmt.value]
+        if isinstance(stmt, Assignment):
+            return [stmt.target, stmt.value]
+        if isinstance(stmt, TupleAssign):
+            return [stmt.value]
+        if isinstance(stmt, ExprStmt):
+            return [stmt.expr]
+        if isinstance(stmt, IfStmt):
+            return [stmt.condition]
+        return []
+
+    # ------------------------------------------------------------------
+    # A pure user call's history below a lazy edge
+    # ------------------------------------------------------------------
+    #
+    # TradingView rule, pinned 2026-09-29 with ``lab tv`` on BINANCE:BTCUSDT
+    # 15 (``tests/fixtures/lazy_call_history``): ``f(...)[k]`` on a user
+    # function's call in the lazily evaluated right operand of ``and``/``or``
+    # or in a ternary's arm reads the call's value k executions of its scope
+    # ago -- k bars at the top level, k calls inside a function -- on all 95
+    # every-third-bar reads of each shape, in a function and at the top level:
+    # the call runs on every execution of its scope, and the lazy edge gates
+    # only the read. So ``isNew(s) => inS(s) and not inS(s)[1]`` is true on
+    # the first bar of every session. The call-local history the Subscript
+    # lowering keeps otherwise (pushed only where the operand runs) reads the
+    # previous time the operand ran: ``[1]`` three bars back on the tape's
+    # reads, and ``isNew`` true once in a whole run.
+    #
+    # Only a call whose value cannot depend on when it runs is hoisted: a
+    # user function whose body is one expression of its parameters, bar
+    # fields, literals, ``timeframe.*``/``syminfo.*`` facts, operators, and
+    # ``na``/``nz``/``time``/``time_close`` or such functions (the tape's
+    # shapes), called positionally with arguments of literals, names and
+    # operators. A stateful or side-effecting callee, a read in an ``if`` or
+    # loop body, a read not below a lazy edge, one in the arguments of an
+    # every-bar ``ta.*`` hoist (already pushed on every bar) and one in a
+    # statement the lowering drops keep their lowering.
+
+    _LAZY_CALL_HISTORY_BUILTINS = frozenset({"na", "nz", "time", "time_close"})
+    _LAZY_CALL_HISTORY_NAMESPACES = frozenset({"timeframe", "syminfo"})
+
+    def _lazy_call_history_pure_expr(self, expr, params: set[str] | None) -> bool:
+        """Whether ``expr`` reads only literals, names and fixed facts through
+        operators -- and, when ``params`` is given (a function body), bar
+        fields, parameters and the calls ``_lazy_call_history_pure_call``
+        admits instead of arbitrary names."""
+        stack = [expr]
+        while stack:
+            n = stack.pop()
+            if isinstance(n, (NumberLiteral, BoolLiteral, StringLiteral, NaLiteral,
+                              ColorLiteral)):
+                continue
+            if isinstance(n, Identifier):
+                if (params is None or n.name in params or n.name in BAR_SERIES_PUSH
+                        or n.name in ("bar_index", "time")):
+                    continue
+                return False
+            if isinstance(n, MemberAccess):
+                if (isinstance(n.object, Identifier)
+                        and n.object.name in self._LAZY_CALL_HISTORY_NAMESPACES):
+                    continue
+                return False
+            if isinstance(n, BinOp):
+                stack.extend((n.left, n.right))
+            elif isinstance(n, UnaryOp):
+                stack.append(n.operand)
+            elif isinstance(n, Ternary):
+                stack.extend((n.condition, n.true_val, n.false_val))
+            elif (params is not None and isinstance(n, FuncCall)
+                    and isinstance(n.callee, Identifier) and not n.kwargs
+                    and (n.callee.name in self._LAZY_CALL_HISTORY_BUILTINS
+                         or self._lazy_call_history_pure_call(n))):
+                stack.extend(n.args)
+            else:
+                return False
+        return True
+
+    def _lazy_call_history_pure_call(self, call) -> bool:
+        """A positional call of the one user function of its name whose body
+        is a single ``_lazy_call_history_pure_expr`` of its parameters. A body
+        reached again through its own calls is not pure."""
+        if not isinstance(call, FuncCall) or not isinstance(call.callee, Identifier):
+            return False
+        name = call.callee.name
+        overloads = [fi for fi in self.ctx.func_infos if fi.name == name]
+        if call.kwargs or len(overloads) != 1 or overloads[0].node is None:
+            return False
+        node = overloads[0].node
+        if len(call.args) != len(node.params):
+            return False
+        cache = getattr(self, "_lazy_call_history_pure_cache", None)
+        if cache is None:
+            cache = self._lazy_call_history_pure_cache = {}
+        if id(node) not in cache:
+            cache[id(node)] = False
+            body = getattr(node, "body", None) or []
+            cache[id(node)] = (
+                len(body) == 1 and isinstance(body[0], ExprStmt)
+                and self._lazy_call_history_pure_expr(body[0].expr, set(node.params))
+            )
+        return cache[id(node)]
+
+    def _lazy_call_history_units(self, stmt) -> list:
+        """The ``pure_call(...)[k]`` reads below a lazy edge of ``stmt``'s
+        roots (``_lazy_edge_statement_roots``), in evaluation order, whose
+        arguments are ``_lazy_call_history_pure_expr``. A
+        ``request.security*`` payload, which its own evaluator runs, is not
+        walked."""
+        cache = getattr(self, "_lazy_call_history_units_cache", None)
+        if cache is None:
+            cache = self._lazy_call_history_units_cache = {}
+        if id(stmt) in cache:
+            return cache[id(stmt)]
+        units: list = []
+        # A statement the lowering drops (plot, bgcolor, ...) reads nothing.
+        if isinstance(stmt, ExprStmt) and self._is_skip_expr(stmt.expr):
+            cache[id(stmt)] = units
+            return units
+        hoisted_ta = self._lazy_edge_hoisted_ta_call_nodes()
+
+        def scan(expr, under_lazy: bool) -> None:
+            if expr is None:
+                return
+            if isinstance(expr, Subscript):
+                call = expr.object
+                if (under_lazy and self._lazy_call_history_pure_call(call)
+                        and all(self._lazy_call_history_pure_expr(arg, None)
+                                for arg in call.args)):
+                    units.append(expr)
+                    return
+                scan(expr.object, under_lazy)
+                scan(expr.index, under_lazy)
+            elif isinstance(expr, FuncCall):
+                # An every-bar ta.* hoist evaluates its arguments on every
+                # bar, so a read inside one already pushes on every bar.
+                if id(expr) in hoisted_ta:
+                    return
+                callee = expr.callee
+                is_security = (
+                    isinstance(callee, MemberAccess)
+                    and isinstance(callee.object, Identifier)
+                    and callee.object.name == "request"
+                    and callee.member in ("security", "security_lower_tf")
+                )
+                scan(callee, under_lazy)
+                for idx, arg in enumerate(getattr(expr, "args", ()) or ()):
+                    if not (is_security and idx == 2):
+                        scan(arg, under_lazy)
+                for key, value in (getattr(expr, "kwargs", None) or {}).items():
+                    if not (is_security and key == "expression"):
+                        scan(value, under_lazy)
+            elif isinstance(expr, BinOp):
+                scan(expr.left, under_lazy)
+                scan(expr.right, under_lazy or expr.op in ("and", "or"))
+            elif isinstance(expr, Ternary):
+                scan(expr.condition, under_lazy)
+                scan(expr.true_val, True)
+                scan(expr.false_val, True)
+            elif isinstance(expr, UnaryOp):
+                scan(expr.operand, under_lazy)
+            elif isinstance(expr, MemberAccess):
+                scan(expr.object, under_lazy)
+            elif isinstance(expr, TupleLiteral):
+                for element in expr.elements:
+                    scan(element, under_lazy)
+            elif isinstance(expr, IfStmt):
+                scan(expr.condition, under_lazy)
+            elif isinstance(expr, SwitchStmt):
+                scan(expr.expr, under_lazy)
+
+        for root in self._lazy_edge_statement_roots(stmt):
+            scan(root, False)
+        cache[id(stmt)] = units
+        return units
+
+    def _emit_lazy_call_history_hoists(self, stmt, lines: list[str], indent: int) -> list[int]:
+        """Push each ``_lazy_call_history_units`` read's call once, before
+        ``stmt``, and make the read return its Series. Returns the reads to
+        hand ``_clear_lazy_call_history_hoists`` once ``stmt`` is lowered."""
+        units = self._lazy_call_history_units(stmt)
+        if not units:
+            return []
+        pad = "    " * indent
+        lines.append(
+            f"{pad}// Pine v6 lazy operand: a call read at an offset runs on every "
+            "execution, only the read is gated."
+        )
+        hoisted = []
+        for read in units:
+            member = self._inline_history_member("hist_call", read)
+            self._emit_history_series_write(lines, pad, member, self._visit_expr(read.object))
+            self._hoisted_hist_reads[id(read)] = member
+            hoisted.append(id(read))
+        return hoisted
+
+    def _clear_lazy_call_history_hoists(self, hoisted: list[int]) -> None:
+        for key in hoisted:
+            self._hoisted_hist_reads.pop(key, None)
+
     def _security_ta_compute_args_for_site(
         self,
         sec_id: int,
@@ -933,6 +1236,38 @@ class TaSiteHelper:
         security_mutable_names: set[str] | None = None,
         helper_binding_stack: tuple[dict, ...] | None = None,
         emitted_lines: list[str] | None = None,
+    ) -> str:
+        """``_security_ta_compute_args_for_site_base`` plus the per-call
+        arguments of a copy whose length the constructor cannot take
+        (``_ta_security_plan``), a series argument rendered in the requested
+        context."""
+        args = self._security_ta_compute_args_for_site_base(
+            sec_id, site, ta_results, security_mutable_names,
+            helper_binding_stack, emitted_lines,
+        )
+        plan = self._ta_security_plan(sec_id, site, helper_binding_stack)
+        if plan is None:
+            return args
+        return self._ta_dynamic_compute_args(
+            site,
+            plan,
+            args,
+            lambda node: self._build_security_expr(
+                sec_id, node, None, ta_results,
+                security_mutable_names=security_mutable_names,
+                helper_binding_stack=helper_binding_stack,
+                emitted_lines=emitted_lines,
+            ),
+        )
+
+    def _security_ta_compute_args_for_site_base(
+        self,
+        sec_id: int,
+        site: "TACallSite",
+        ta_results: dict[int, str],
+        security_mutable_names: set[str] | None = None,
+        helper_binding_stack: tuple[dict, ...] | None = None,
+        emitted_lines: list[str] | None = None,
     ) -> str:
         """Same as ``_ta_compute_args_for_site`` but inside an ``evaluate_security`` body.
 
@@ -942,20 +1277,87 @@ class TaSiteHelper:
         mutable globals get rebound to the security-context shadows."""
         ta_name = self._ta_name_from_site(site)
 
-        if ta_name in TA_IMPLICIT_COMPUTE_FULL:
-            implicit = TA_IMPLICIT_COMPUTE_FULL[ta_name].replace("current_bar_.", "bar.")
-            if site.compute_args:
-                explicit = ", ".join(
+        if site.class_name in ("_PFAnchoredVWAP", "_PFAnchoredVWAPBands"):
+            explicit = [
+                self._coerce_bool_expr(
                     self._build_security_expr(
-                        sec_id,
-                        a,
-                        None,
-                        ta_results,
+                        sec_id, a, None, ta_results,
                         security_mutable_names=security_mutable_names,
                         helper_binding_stack=helper_binding_stack,
                         emitted_lines=emitted_lines,
+                    ),
+                    a,
+                ) if i in self._TA_BOOL_COMPUTE_ARGS.get(ta_name, ()) else
+                self._build_security_expr(
+                    sec_id, a, None, ta_results,
+                    security_mutable_names=security_mutable_names,
+                    helper_binding_stack=helper_binding_stack,
+                    emitted_lines=emitted_lines,
+                )
+                for i, a in enumerate(site.compute_args)
+            ]
+            if len(explicit) < 2:
+                raise AssertionError("anchored VWAP security site is missing source/anchor")
+            return (
+                f"{explicit[0]}, bar.volume, bar.timestamp, syminfo_.timezone, "
+                f"syminfo_.session, {explicit[1]}"
+            )
+
+        if site.class_name == "_PFPivotPointLevels":
+            explicit = [
+                self._coerce_bool_expr(
+                    self._build_security_expr(
+                        sec_id, a, None, ta_results,
+                        security_mutable_names=security_mutable_names,
+                        helper_binding_stack=helper_binding_stack,
+                        emitted_lines=emitted_lines,
+                    ),
+                    a,
+                ) if i in self._TA_BOOL_COMPUTE_ARGS.get(ta_name, ()) else
+                self._build_security_expr(
+                    sec_id, a, None, ta_results,
+                    security_mutable_names=security_mutable_names,
+                    helper_binding_stack=helper_binding_stack,
+                    emitted_lines=emitted_lines,
+                )
+                for i, a in enumerate(site.compute_args)
+            ]
+            if len(explicit) < 3:
+                raise AssertionError("pivot security site is missing anchor arguments")
+            return (
+                f"{explicit[0]}, {explicit[1]}, {explicit[2]}, bar.open, bar.high, "
+                "bar.low, bar.close"
+            )
+
+        if ta_name in TA_IMPLICIT_COMPUTE_FULL:
+            implicit = TA_IMPLICIT_COMPUTE_FULL[ta_name].replace("current_bar_.", "bar.")
+            if site.compute_args:
+                explicit = ", ".join(
+                    (
+                        self._coerce_bool_expr(
+                            self._build_security_expr(
+                                sec_id,
+                                a,
+                                None,
+                                ta_results,
+                                security_mutable_names=security_mutable_names,
+                                helper_binding_stack=helper_binding_stack,
+                                emitted_lines=emitted_lines,
+                            ),
+                            a,
+                        )
+                        if i in self._TA_BOOL_COMPUTE_ARGS.get(ta_name, ())
+                        else self._build_security_expr(
+                            sec_id,
+                            a,
+                            None,
+                            ta_results,
+                            security_mutable_names=security_mutable_names,
+                            helper_binding_stack=helper_binding_stack,
+                            emitted_lines=emitted_lines,
+                        )
                     )
-                    for a in site.compute_args
+                    for i, a in enumerate(site.compute_args)
                 )
                 if ta_name in self._TA_IMPLICIT_REPLACE:
                     return explicit
@@ -964,16 +1366,31 @@ class TaSiteHelper:
 
         if site.compute_args:
             explicit = ", ".join(
-                self._build_security_expr(
-                    sec_id,
-                    a,
-                    None,
-                    ta_results,
-                    security_mutable_names=security_mutable_names,
-                    helper_binding_stack=helper_binding_stack,
-                    emitted_lines=emitted_lines,
+                (
+                    self._coerce_bool_expr(
+                        self._build_security_expr(
+                            sec_id,
+                            a,
+                            None,
+                            ta_results,
+                            security_mutable_names=security_mutable_names,
+                            helper_binding_stack=helper_binding_stack,
+                            emitted_lines=emitted_lines,
+                        ),
+                        a,
+                    )
+                    if i in self._TA_BOOL_COMPUTE_ARGS.get(ta_name, ())
+                    else self._build_security_expr(
+                        sec_id,
+                        a,
+                        None,
+                        ta_results,
+                        security_mutable_names=security_mutable_names,
+                        helper_binding_stack=helper_binding_stack,
+                        emitted_lines=emitted_lines,
+                    )
                 )
-                for a in site.compute_args
+                for i, a in enumerate(site.compute_args)
             )
             if ta_name in TA_IMPLICIT_APPEND:
                 implicit = TA_IMPLICIT_APPEND[ta_name].replace("current_bar_.", "bar.")
@@ -985,6 +1402,686 @@ class TaSiteHelper:
 
         return ""
 
+    # ------------------------------------------------------------------
+    # Lengths the constructor cannot take (K-TA-DYNLEN)
+    # ------------------------------------------------------------------
+    #
+    # A ``ta.*`` constructor argument that is neither a compile-time value nor
+    # a runtime-resettable input/timeframe expression used to be refused. Its
+    # Pine qualifier decides TradingView's answer (lab tv, K-TA-DYNLEN
+    # 2026-09-26; the engine header pineforge/source/pine_ta_length.hpp states
+    # every rule with its tape):
+    #
+    # * simple (fixed for the run -- a syminfo preset, str.* over one):
+    #   TradingView answers exactly the constant-length call
+    #   (the ring of a sparse ta.lowest included). Lowered onto
+    #   ``pineforge::source::FirstCallBound<class>``, built from the call's
+    #   first execution; a length goes through ``simple_ta_length`` (0, a
+    #   negative length or na stops the run, as TradingView does).
+    # * series, for ta.highest / ta.lowest / ta.highestbars / ta.lowestbars:
+    #   re-windowed on every call -- ``pineforge::source::Series*``, the length
+    #   passed per call.
+    # * ta.supertrend: the factor (series or simple) of the first execution is
+    #   the run's -- ``pineforge::source::PineSupertrend``.
+    #
+    # TradingView refuses a series length for ta.rma / ema / rsi / atr / dmi /
+    # macd / kc / hma / tsi / rci and supertrend's atrPeriod at compile time,
+    # so those only ever carry a simple one here. A series length for the
+    # other window functions (ta.sma, ta.wma, ...) keeps the refusal.
+    # Constant- and input-length sites never reach this path: their C++ is
+    # unchanged. An input.string choice of a length (``mode == "A" ? 5 : 10``)
+    # is an input length since CG-SECURITY-2 spells string literals; the other
+    # arguments those literals bring to the constructor stay here
+    # (``_ta_arg_takes_plan``).
+
+    _TA_SERIES_EXTREME_CLASSES = {
+        "highest": "pineforge::source::SeriesHighest",
+        "lowest": "pineforge::source::SeriesLowest",
+        "highestbars": "pineforge::source::SeriesHighestBars",
+        "lowestbars": "pineforge::source::SeriesLowestBars",
+    }
+    # Pure str.* functions of simple arguments (a simple result).
+    _SIMPLE_STR_FUNCS = frozenset({
+        "upper", "lower", "contains", "startswith", "endswith", "length",
+        "pos", "substring", "replace", "replace_all", "trim", "repeat",
+        "tonumber", "tostring",
+    })
+
+    def _ta_site_function(self, site: "TACallSite") -> str:
+        """The Pine ``ta.<name>`` of a site (a clone keeps its template's node)."""
+        node = getattr(site, "node", None)
+        if isinstance(node, FuncCall):
+            func_name, namespace = self._resolve_callee(node.callee)
+            if namespace == "ta" and func_name:
+                return func_name
+        return self._ta_name_from_site(site)
+
+    def _ta_dynamic_plan(self, site: "TACallSite") -> dict | None:
+        """The lowering of a site with a constructor argument the constructor
+        cannot take, or None (the ordinary constructor / runtime-reset path).
+        ``kind`` is ``first_call`` / ``series_extreme`` / ``supertrend``, or
+        ``refused`` (the constructor guard reports it)."""
+        cache = self.__dict__.setdefault("_ta_dynamic_plan_cache", {})
+        key = id(site)
+        if key not in cache:
+            cache[key] = self._build_ta_dynamic_plan(site)
+        plan = cache[key]
+        if plan is None or plan["kind"] == "refused":
+            return None
+        return plan
+
+    def _ta_dynamic_refusal(self, site: "TACallSite") -> dict | None:
+        """The refused plan of a site, when it has one."""
+        self._ta_dynamic_plan(site)
+        plan = self.__dict__.get("_ta_dynamic_plan_cache", {}).get(id(site))
+        if plan is not None and plan["kind"] == "refused":
+            return plan
+        return None
+
+    # A string literal in a length's spelling, and the names a length may read
+    # beside input-backed ones and still be a choice between inputs' options.
+    _TA_STRING_LITERAL = re.compile(r'"(?:[^"\\]|\\.)*"|\'(?:[^\'\\]|\\.)*\'')
+    _TA_INPUT_CHOICE_NAMES = frozenset({
+        "and", "or", "not", "true", "false", "na", "int", "float", "bool",
+        "string", "input", "math",
+    })
+
+    def _ta_length_literal_facts(self, arg: str, inline: bool = True) -> tuple[bool, bool]:
+        """Whether the constructor argument ``arg`` reaches the constructor
+        only because string literals are spelled -- a derived name whose value
+        holds a literal (it went untracked), or, when ``inline``, a literal
+        naming something written in ``arg`` itself (the reset path's
+        identifier scans read it as a name) -- and whether it then reads
+        anything beside inputs, literals and ``math.*``.
+
+        CG-SECURITY-2 spells those literals so that a length chosen by
+        comparing an ``input.string`` with its options is input-derived and
+        keeps its constructor. Any other argument they bring to the
+        constructor -- a ``syminfo.*`` or ``timeframe.*`` comparison,
+        ``str.*`` over one -- stays with this module's lowering, as before
+        (the reset path reads ``timeframe.*`` on the chart's timeframe in a
+        request.security copy, where TradingView reads the requested one)."""
+        newly = False
+        names: set[str] = set()
+        pending, seen = [(arg, inline)], set()
+        while pending:
+            raw, literal_counts = pending.pop()
+            text = self._inline_inputs_masked(raw)
+            if literal_counts and any(re.search(r"[A-Za-z_]", lit[1:-1])
+                                      for lit in self._TA_STRING_LITERAL.findall(text)):
+                newly = True
+            for name in re.findall(r"[A-Za-z_][A-Za-z_0-9]*", blank_string_literals(text)):
+                derived = self._derived_input_expr.get(name)
+                if derived is None or self._known_var_is_lexically_shadowed(name):
+                    names.add(name)
+                elif name not in seen:
+                    seen.add(name)
+                    if self._TA_STRING_LITERAL.search(self._inline_inputs_masked(derived)):
+                        newly = True
+                    pending.append((derived, True))
+        if not newly:
+            return False, False
+        allowed = (self._TA_INPUT_CHOICE_NAMES | self._input_backed_vars
+                   | set(self._MATH_MEMBER_CPP))
+        outside = {
+            name for name in names - allowed
+            if name not in self._known_vars or self._known_var_is_lexically_shadowed(name)
+        }
+        return True, bool(outside)
+
+    def _ta_arg_takes_plan(self, site: "TACallSite", position: int, arg: str,
+                           inline: bool = True) -> bool:
+        """A constructor argument the constructor path takes only because
+        string literals are spelled, that this module lowers instead
+        (``_ta_length_literal_facts``): anything beside an input.string
+        choice, and an input.string choice of a parameter that is not known
+        to be an int -- a float, or one ``_ta_ctor_param`` does not know (a
+        VWAP band multiplier, ``math.sum``'s length) -- since the runtime
+        reset casts its expression to a length."""
+        newly, outside = self._ta_length_literal_facts(arg, inline)
+        if not newly:
+            return False
+        if outside:
+            return True
+        param = self._ta_ctor_param(site, position)
+        return param is None or param.pine_type != PineType.INT
+
+    def _ta_bound_arg_takes_plan(self, site: "TACallSite", position: int, node) -> bool:
+        """``_ta_arg_takes_plan`` of a helper-bound argument's AST. A literal
+        written in the helper call itself always reached the constructor
+        (its AST is stable); only a derived name's counts."""
+        spelled = self._arith_expr_to_str(node) if node is not None else None
+        return spelled is not None and self._ta_arg_takes_plan(site, position, spelled, inline=False)
+
+    def _build_ta_dynamic_plan(self, site: "TACallSite") -> dict | None:
+        if not site.ctor_args:
+            return None
+        refused = [
+            pos for pos, arg in enumerate(site.ctor_args)
+            if not self._is_compile_time_value(self._resolve_ta_ctor_arg(arg))
+            and (self._runtime_ctor_arg_for_reset(arg) is None
+                 or self._ta_arg_takes_plan(site, pos, arg))
+        ]
+        if not refused:
+            return None
+        nodes = list(getattr(site, "ctor_nodes", None) or [])
+        if len(nodes) != len(site.ctor_args):
+            return {"kind": "refused", "refused": refused}
+        # A call outside every callable is spelled from its own nodes, whose
+        # identifiers carry the analyzer's scope. A callable's constructor
+        # arguments are its call site's spelling substituted into the body.
+        own_nodes = site.owner_func is None
+        simple = {
+            pos: (self._simple_ta_arg_cpp_node(nodes[pos], scoped=True)
+                  if own_nodes else self._simple_ta_arg_cpp(site.ctor_args[pos]))
+            for pos in refused
+        }
+        return self._ta_plan_for(site, refused, simple)
+
+    def _ta_plan_for(self, site: "TACallSite", refused: list, simple: dict) -> dict:
+        """The plan of a site whose ``refused`` constructor arguments have the
+        context-free C++ ``simple`` (None: series)."""
+        family = self._ta_site_function(site)
+        if family in self._TA_SERIES_EXTREME_CLASSES:
+            kind = "first_call" if simple[refused[0]] is not None else "series_extreme"
+        elif family == "supertrend":
+            kind = "supertrend"
+        elif all(simple[pos] is not None for pos in refused):
+            kind = "first_call"
+        else:
+            return {"kind": "refused", "refused": refused}
+        return {"kind": kind, "refused": refused, "simple": simple, "family": family}
+
+    def _ta_security_plan(self, sec_id: int, site: "TACallSite",
+                          helper_binding_stack=None) -> dict | None:
+        """The lowering of the request.security copy of ``site`` that
+        ``sec_id`` evaluates through ``helper_binding_stack`` (the variant
+        key), or None (the constructor / runtime-reset path, whose guards
+        report a length they cannot take). A copy reached through a helper
+        call is planned from the arguments that call binds; a copy of a
+        callable's request.security cloned per call site, from that call
+        site's clone of the TA site."""
+        stack = tuple(helper_binding_stack or ())
+        key = (sec_id, id(site), self._security_binding_stack_signature(stack))
+        cache = self.__dict__.setdefault("_ta_security_plan_cache", {})
+        if key not in cache:
+            cache[key] = self._build_ta_security_plan(sec_id, site, stack)
+        return cache[key]
+
+    def _build_ta_security_plan(self, sec_id: int, site: "TACallSite",
+                                stack: tuple) -> dict | None:
+        if not stack:
+            ctor_site = self._security_ta_ctor_site(sec_id, site)
+            plan = self._ta_dynamic_plan(ctor_site)
+            if (plan is None and ctor_site is not site
+                    and self._ta_dynamic_plan(site) is not None):
+                # The constructor path sizes every copy from the first call
+                # site's arguments, which are not this call site's: build
+                # the constant-length class from this call site's.
+                plan = {"kind": "first_call", "refused": [], "simple": {},
+                        "family": self._ta_site_function(ctor_site)}
+            if plan is None:
+                # An input.string choice keeps the constructor, which sizes a
+                # callable's one evaluator from its first call site's
+                # arguments: refuse call sites passing different ones, as the
+                # lowering above does (``_ta_length_literal_facts``).
+                dead = getattr(self, "_dead_ta_indices", set())
+                if any(
+                    self._ta_length_literal_facts(arg)[0]
+                    for index, other in enumerate(self.ctx.ta_call_sites)
+                    if other.node is site.node and index not in dead
+                    for arg in other.ctor_args
+                ):
+                    self._refuse_shared_security_ta_lengths(sec_id, site)
+                return None
+            self._refuse_shared_security_ta_lengths(sec_id, site)
+            return {**plan, "site": ctor_site, "sec_id": sec_id}
+        if not site.ctor_args:
+            return None
+        nodes = self._security_ta_ctor_arg_nodes(site)
+        ctor_args, stability = self._security_ta_ctor_args_for_variant(sec_id, site, stack)
+        if stability is None or len(nodes) != len(ctor_args):
+            if self._ta_dynamic_plan(site) is not None:
+                self._codegen_error(
+                    site.node,
+                    f"Unsupported requested-context TA constructor for "
+                    f"{site.class_name}: PineForge cannot bind the helper "
+                    "call's arguments to its constructor arguments.",
+                    hint="Call the ta.* function directly inside request.security().",
+                )
+            return None
+        bound = [self._security_helper_bound_ast(node, stack) for node in nodes]
+        # The positions the runtime-reset path would refuse
+        # (``_collect_ta_runtime_resets``); none -> that path, unchanged.
+        # ``ctor_args`` are rendered C++ here: the bound argument's Pine
+        # spelling decides ``_ta_bound_arg_takes_plan``.
+        refused = [
+            pos for pos, arg in enumerate(ctor_args)
+            if not self._is_compile_time_value(self._resolve_ta_ctor_arg(arg))
+            and ((self._runtime_ctor_arg_for_reset(arg) is None and not stability[pos])
+                 or self._ta_bound_arg_takes_plan(site, pos, bound[pos]))
+        ]
+        if not refused:
+            return None
+        bound_simple = {
+            pos: self._simple_ta_arg_cpp_node(node, scoped=True)
+            for pos, node in enumerate(bound) if node is not None
+        }
+        plan = self._ta_plan_for(
+            site, refused, {pos: bound_simple.get(pos) for pos in refused})
+        if plan["kind"] == "refused":
+            forced = [pos for pos in plan["refused"]
+                      if stability[pos] or self._runtime_ctor_arg_for_reset(ctor_args[pos]) is not None]
+            if forced:
+                # An argument the constructor path takes only because string
+                # literals are spelled (``_ta_bound_arg_takes_plan``) that this
+                # lowering cannot spell either: refused, as before.
+                pos = forced[0]
+                self._refuse_security_ta_ctor_arg(site, pos, ctor_args[pos], nodes[pos], stack)
+            return None
+        return {**plan, "site": site, "sec_id": sec_id, "bound_simple": bound_simple}
+
+    def _refuse_security_ta_ctor_arg(self, site: "TACallSite", pos: int, cpp: str,
+                                     node, stack) -> None:
+        """Refuse a requested-context TA constructor argument the evaluator
+        cannot size the object from, naming it. One that reads a helper's
+        ``var`` (or a local an if arm or a history read makes a value of each
+        requested bar) is named in Pine, with the local."""
+        shown, reason = cpp, ""
+        state = self._security_helper_state_reads(node, stack) if node is not None else []
+        if state:
+            shown = self._arith_expr_to_str(node) or cpp
+            reason = (
+                f": it reads {', '.join(repr(name) for name in state)}, a helper "
+                "local holding a value of each requested bar, and PineForge takes "
+                "such a length only for ta.highest, ta.lowest, ta.highestbars and "
+                "ta.lowestbars"
+            )
+        self._codegen_error(
+            site.node,
+            f"Unsupported requested-context TA constructor "
+            f"{'flag' if self._ta_ctor_arg_is_bool(site, pos) else 'length'} "
+            f"'{shown}' for {site.class_name}: the "
+            f"helper-bound expression is not a stable per-run scalar{reason}.",
+            hint=("Use a literal, an input.*() value, timeframe.* metadata, "
+                  "or arithmetic over those for TA lengths."),
+        )
+
+    def _security_call_item(self, sec_id: int) -> dict:
+        for item in self._security_calls:
+            if item["sec_id"] == sec_id:
+                return item
+        return {}
+
+    def _security_ta_ctor_site(self, sec_id: int, site: "TACallSite") -> "TACallSite":
+        """The site whose constructor arguments the ``sec_id`` copy of
+        ``site`` takes: a callable's request.security cloned per call site
+        uses that call site's clone (``_collect_ta_runtime_resets`` does the
+        same)."""
+        item = self._security_call_item(sec_id)
+        containing = item.get("containing_func") or ""
+        cs_idx = item.get("callsite_idx")
+        if containing and cs_idx is not None:
+            remap = self._func_cs_ta_remap.get((containing, cs_idx)) or {}
+            name = remap.get(site.member_name)
+            if name and name != site.member_name:
+                return self._ta_site_by_member().get(name, site)
+        return site
+
+    def _refuse_shared_security_ta_lengths(self, sec_id: int, site: "TACallSite") -> None:
+        """A callable's request.security that is not cloned per call site is
+        one evaluator for every call: it can only take a length all the
+        calls spell the same."""
+        item = self._security_call_item(sec_id)
+        containing = item.get("containing_func") or ""
+        if not containing or item.get("callsite_idx") is not None:
+            return
+        dead = getattr(self, "_dead_ta_indices", set())
+        spellings = sorted({
+            ", ".join(other.ctor_args)
+            for index, other in enumerate(self.ctx.ta_call_sites)
+            if other.node is site.node and index not in dead
+        })
+        if len(spellings) > 1:
+            self._codegen_error(
+                site.node,
+                f"Unsupported TA constructor length for {site.class_name} "
+                f"inside request.security in '{containing}': its call sites "
+                f"pass different lengths ({' / '.join(spellings)}), and one "
+                "requested-context evaluator serves them all.",
+                hint=("Call request.security() at each call site, or pass "
+                      "the same length from every call."),
+            )
+
+    _TF_EXPR_ATOM = re.compile(r'"[^"\\]*"|\w+')
+
+    def _ta_payload_cpp(self, cpp: str, sec_id: int) -> str:
+        """``cpp`` (a length rendered for the chart) evaluated in the
+        request.security context ``sec_id``: ``timeframe.*`` reads that
+        context's timeframe, as ``_build_security_timeframe_member`` lowers
+        it for the rest of the payload."""
+        if "script_tf_" not in cpp:
+            return cpp
+        tf = self._security_timeframe_expr(sec_id)
+        if not self._TF_EXPR_ATOM.fullmatch(tf):
+            tf = f"({tf})"
+        # String literals are left alone.
+        parts = re.split(r'("(?:\\.|[^"\\])*")', cpp)
+        return "".join(
+            part if index % 2 else re.sub(r"\bscript_tf_\b", lambda _m: tf, part)
+            for index, part in enumerate(parts)
+        )
+
+    def _ta_plan_cpp_type(self, site: "TACallSite", plan: dict | None) -> str:
+        if plan is None:
+            return site.class_name
+        if plan["kind"] == "series_extreme":
+            return self._TA_SERIES_EXTREME_CLASSES[plan["family"]]
+        if plan["kind"] == "supertrend":
+            return "pineforge::source::PineSupertrend"
+        return f"pineforge::source::FirstCallBound<{site.class_name}>"
+
+    def _ta_member_cpp_type(self, site: "TACallSite") -> str:
+        """The C++ type a site's member is declared with."""
+        return self._ta_plan_cpp_type(site, self._ta_dynamic_plan(site))
+
+    def _ta_security_member_cpp_type(self, sec_id: int, site: "TACallSite",
+                                     variant: dict) -> str:
+        """The C++ type of one request.security copy of a site."""
+        return self._ta_plan_cpp_type(
+            site, self._ta_security_plan(sec_id, site, variant.get("binding_stack", ())))
+
+    def _ta_uses_dynamic_lengths(self) -> bool:
+        """Whether any live site or request.security copy takes the lowering
+        above (the TU then includes its engine header)."""
+        dead = getattr(self, "_dead_ta_indices", set())
+        if any(
+            self._ta_dynamic_plan(site) is not None
+            for index, site in enumerate(self.ctx.ta_call_sites)
+            if index not in dead
+        ):
+            return True
+        return any(
+            self._ta_security_plan(
+                info["sec_id"], self.ctx.ta_call_sites[idx],
+                variant.get("binding_stack", ())) is not None
+            for info in self._security_eval_info
+            for idx, variants in (info.get("ta_variants") or {}).items()
+            for variant in variants
+        )
+
+    def _ta_ctor_param(self, site: "TACallSite", position: int):
+        """The signature parameter a constructor argument binds (Param or None)."""
+        from ..analyzer.tables import TA_MULTI_CTOR, TA_PERIOD_ARG
+        from ..signatures import TA_FUNCTIONS
+        family = self._ta_site_function(site)
+        if family in TA_MULTI_CTOR:
+            indices = list(TA_MULTI_CTOR[family])
+            if family in ("pivothigh", "pivotlow") and len(site.ctor_args) == 2:
+                indices = [1, 2]
+        elif family in TA_PERIOD_ARG:
+            indices = [TA_PERIOD_ARG[family]]
+        else:
+            return None
+        func = TA_FUNCTIONS.get(family)
+        if func is None or position >= len(indices):
+            return None
+        widest = max(func.signatures, key=lambda sig: len(sig.params))
+        index = indices[position]
+        if index >= len(widest.params):
+            return None
+        return widest.params[index]
+
+    def _ta_dynamic_ctor_arg(self, site: "TACallSite", plan: dict, position: int,
+                             render_node) -> str:
+        """One constructor argument of a lowered site: a compile-time value, a
+        runtime-reset expression, a context-free simple expression, or (a
+        series argument) the call site's own rendering. A request.security
+        copy reached through a helper call takes the argument that call
+        binds (``ctor_args`` holds the first call site's); any request.security
+        copy reads ``timeframe.*`` in its requested context."""
+        if "bound_simple" in plan:
+            value = plan["bound_simple"].get(position)
+        elif position in plan.get("refused", ()):
+            # A refused position takes its context-free spelling, else (a
+            # series one) the call site's rendering: never the reset path's
+            # reading, which one ``_ta_arg_takes_plan`` sends here would
+            # have cast to an int length, on the chart's timeframe, at the
+            # end of the bar.
+            value = plan["simple"].get(position)
+        else:
+            arg = site.ctor_args[position]
+            # The live input first: a compile-time resolution of an input-backed
+            # argument is only its default (the constructor's placeholder).
+            value = self._runtime_ctor_arg_for_reset(arg)
+            if value is None:
+                resolved = self._resolve_ta_ctor_arg(arg)
+                if self._is_compile_time_value(resolved):
+                    value = resolved
+            if value is None:
+                value = plan["simple"].get(position)
+        if value is None:
+            value = render_node(site.ctor_nodes[position])
+        elif plan.get("sec_id") is not None:
+            value = self._ta_payload_cpp(value, plan["sec_id"])
+        if self._ta_ctor_arg_is_bool(site, position):
+            value = self._ta_ctor_bool_cpp(value)
+        return value
+
+    def _ta_dynamic_compute_args(self, site: "TACallSite", plan: dict, base_args: str,
+                                 render_node) -> str:
+        """The ``compute()`` / ``recompute()`` arguments of a lowered site."""
+        kind = plan["kind"]
+        site = plan.get("site", site)
+        if kind == "series_extreme":
+            length = self._ta_dynamic_ctor_arg(site, plan, 0, render_node)
+            return f"{base_args}, pineforge::source::ta_number({length})"
+        if kind == "supertrend":
+            factor = self._ta_dynamic_ctor_arg(site, plan, 0, render_node)
+            period = self._ta_dynamic_ctor_arg(site, plan, 1, render_node)
+            dynamic = (f"pineforge::source::ta_number({factor}), "
+                       f"pineforge::source::ta_number({period})")
+            return f"{dynamic}, {base_args}" if base_args else dynamic
+        family = plan["family"]
+        ctor = []
+        for position in range(len(site.ctor_args)):
+            value = self._ta_dynamic_ctor_arg(site, plan, position, render_node)
+            param = self._ta_ctor_param(site, position)
+            if (position in plan["refused"] and param is not None
+                    and param.pine_type == PineType.INT
+                    and not self._ta_ctor_arg_is_bool(site, position)):
+                value = (f'pineforge::source::simple_ta_length({value}, '
+                         f'"{family}", "{param.name}")')
+            ctor.append(value)
+        make = f"[&]() {{ return {site.class_name}({', '.join(ctor)}); }}"
+        return f"{make}, {base_args}" if base_args else make
+
+    def _simple_ta_top_level_decls(self) -> dict:
+        """Top-level plain declarations read as simple values: declared once,
+        never reassigned, not ``var``/``varip``, not declared ``series``."""
+        cached = self.__dict__.get("_simple_ta_decls_cache")
+        if cached is not None:
+            return cached
+        reassigned = self._find_reassigned_vars()
+        counts: dict[str, int] = {}
+        decls: dict[str, VarDecl] = {}
+        for stmt in self.ctx.ast.body or []:
+            if isinstance(stmt, VarDecl):
+                counts[stmt.name] = counts.get(stmt.name, 0) + 1
+                decls[stmt.name] = stmt
+            elif isinstance(stmt, TupleAssign):
+                for name in getattr(stmt, "names", []) or []:
+                    counts[name] = counts.get(name, 0) + 2
+        result = {
+            name: decl for name, decl in decls.items()
+            if counts.get(name) == 1 and name not in reassigned
+            and not decl.is_var and not decl.is_varip and decl.value is not None
+            and (decl.annotations or {}).get("qualifier") != "series"
+        }
+        self.__dict__["_simple_ta_decls_cache"] = result
+        return result
+
+    def _ta_locally_declared_names(self) -> frozenset:
+        """Every name a block, loop or callable declares: a parameter, a loop
+        variable, a local."""
+        cached = self.__dict__.get("_ta_local_names_cache")
+        if cached is not None:
+            return cached
+        top_level = {id(stmt) for stmt in self.ctx.ast.body or []}
+        names: set[str] = set()
+        for node in self._walk_ast(self.ctx.ast):
+            if isinstance(node, (FuncDef, MethodDef)):
+                names.update(p for p in node.params if isinstance(p, str))
+            elif isinstance(node, VarDecl) and id(node) not in top_level:
+                names.add(node.name)
+            elif isinstance(node, TupleAssign) and id(node) not in top_level:
+                names.update(name for name in node.names if name)
+            elif isinstance(node, ForStmt) and node.var:
+                names.add(node.var)
+            elif isinstance(node, ForInStmt):
+                if node.var:
+                    names.add(node.var)
+                names.update(name for name in node.vars or [] if name)
+        result = frozenset(names)
+        self.__dict__["_ta_local_names_cache"] = result
+        return result
+
+    def _ta_identifier_reads_top_level(self, node: Identifier, scoped: bool) -> bool:
+        """Whether ``node`` reads the top-level binding of its name. A node of
+        the analysed program (``scoped``) answers from the scope the analyzer
+        resolved it in; a spelling re-parsed from ``ctor_args`` has none, so
+        its name must be one no block, loop or callable declares."""
+        if scoped:
+            scopes = getattr(self.ctx, "identifier_binding_scopes", {}) or {}
+            return scopes.get(id(node)) == "global"
+        return node.name not in self._ta_locally_declared_names()
+
+    def _simple_ta_arg_ast(self, node, seen: frozenset = frozenset(), depth: int = 0,
+                           scoped: bool = False):
+        """A context-free copy of ``node`` whose leaves are literals, inputs,
+        ``syminfo.*`` / ``timeframe.*`` metadata and ``math`` constants
+        combined by operators, ternaries, casts and pure ``math.*`` /
+        ``str.*`` calls, top-level simple declarations expanded in place --
+        a Pine simple value. None when any part may vary by bar, or when an
+        identifier may be bound by a block, loop or callable rather than the
+        top-level declaration (``_ta_identifier_reads_top_level``)."""
+        if node is None or depth > 64:
+            return None
+        if isinstance(node, (NumberLiteral, StringLiteral, BoolLiteral, NaLiteral)):
+            return copy.deepcopy(node)
+        if isinstance(node, Identifier):
+            name = node.name
+            if self._known_var_is_lexically_shadowed(name):
+                return None
+            if not self._ta_identifier_reads_top_level(node, scoped):
+                return None
+            # A derived name tracked only since string literals are spelled
+            # (``_ta_length_literal_facts``) is expanded from its declaration,
+            # as before, not read from the chart's member.
+            literal_derived = (name in self._derived_input_expr
+                               and self._ta_length_literal_facts(name, inline=False)[0])
+            if not literal_derived and (name in self._input_backed_vars
+                                        or name in self._known_vars):
+                return copy.deepcopy(node)
+            decl = self._simple_ta_top_level_decls().get(name)
+            if decl is None or name in seen:
+                return None
+            # The declaration's own nodes carry the analyzer's scope.
+            return self._simple_ta_arg_ast(decl.value, seen | {name}, depth + 1, True)
+        if isinstance(node, MemberAccess):
+            if not isinstance(node.object, Identifier):
+                return None
+            namespace = node.object.name
+            if (namespace == "syminfo"
+                    or (namespace == "timeframe" and node.member in self._TF_STABLE_MEMBERS)
+                    or (namespace == "math" and node.member in self._MATH_STABLE_MEMBERS)):
+                return copy.deepcopy(node)
+            return None
+        if isinstance(node, BinOp):
+            left = self._simple_ta_arg_ast(node.left, seen, depth + 1, scoped)
+            right = self._simple_ta_arg_ast(node.right, seen, depth + 1, scoped)
+            if left is None or right is None:
+                return None
+            out = copy.copy(node)
+            out.left, out.right = left, right
+            return out
+        if isinstance(node, UnaryOp):
+            operand = self._simple_ta_arg_ast(node.operand, seen, depth + 1, scoped)
+            if operand is None:
+                return None
+            out = copy.copy(node)
+            out.operand = operand
+            return out
+        if isinstance(node, Ternary):
+            parts = [self._simple_ta_arg_ast(child, seen, depth + 1, scoped)
+                     for child in (node.condition, node.true_val, node.false_val)]
+            if any(part is None for part in parts):
+                return None
+            out = copy.copy(node)
+            out.condition, out.true_val, out.false_val = parts
+            return out
+        if isinstance(node, FuncCall):
+            func_name, namespace = self._resolve_callee(node.callee)
+            if namespace == "input" or (namespace is None and func_name == "input"):
+                return copy.deepcopy(node) if self._is_stable_inline_input(node) else None
+            pure = (
+                (namespace == "str" and func_name in self._SIMPLE_STR_FUNCS)
+                or (namespace == "math" and func_name in self._MATH_STABLE_MEMBERS)
+                or (namespace == "timeframe" and func_name in self._TF_STABLE_MEMBERS)
+                or (namespace is None and func_name in ("int", "float", "bool", "string"))
+            )
+            if not pure:
+                return None
+            args = [self._simple_ta_arg_ast(arg, seen, depth + 1, scoped) for arg in node.args]
+            kwargs = {key: self._simple_ta_arg_ast(value, seen, depth + 1, scoped)
+                      for key, value in (node.kwargs or {}).items()}
+            if any(arg is None for arg in args) or any(v is None for v in kwargs.values()):
+                return None
+            out = copy.copy(node)
+            out.callee = copy.deepcopy(node.callee)
+            out.args = args
+            out.kwargs = kwargs
+            return out
+        return None
+
+    def _simple_ta_arg_cpp_node(self, node, scoped: bool = False) -> str | None:
+        """``_simple_ta_arg_cpp`` of an AST node (not cached); ``scoped`` when
+        the node belongs to the analysed program
+        (``_ta_identifier_reads_top_level``)."""
+        expanded = self._simple_ta_arg_ast(node, scoped=scoped) if node is not None else None
+        if expanded is None:
+            return None
+        previous = self._reset_input_getter_mode
+        self._reset_input_getter_mode = True
+        try:
+            rendered = self._visit_expr(expanded)
+        except Exception:
+            rendered = None
+        finally:
+            self._reset_input_getter_mode = previous
+        if rendered and "/* " not in rendered:
+            return f"({rendered})"
+        return None
+
+    def _simple_ta_arg_cpp(self, arg_str: str) -> str | None:
+        """The context-free C++ of a simple constructor argument spelled
+        ``arg_str`` (inputs read through their override-aware getters, so it
+        evaluates the same in ``on_bar`` and in ``evaluate_security`` before
+        either initialised anything), or None when the argument is series.
+        The spelling carries no scope: the answer depends on the text alone."""
+        cache = self.__dict__.setdefault("_simple_ta_arg_cache", {})
+        if arg_str in cache:
+            return cache[arg_str]
+        try:
+            from ..lexer import Lexer
+            from ..parser import Parser
+            node = Parser(Lexer(arg_str).tokenize(), source=arg_str)._parse_expression()
+        except Exception:
+            node = None
+        result = self._simple_ta_arg_cpp_node(node)
+        cache[arg_str] = result
+        return result
+
     # ------------------------------------------------------------------
     # Compile-time-value predicate (paired with the runtime-reset chain
     # that still lives on CodeGen because it uses Python's expression