@pineforge/codegen-pyodide 0.10.4 → 1.0.0

package/pineforge_codegen/codegen/emit_top.py

@@ -82,8 +82,11 @@ and ``..analyzer``.
 
 from __future__ import annotations
 
+import re
+
 from ..ast_nodes import (
-    ExprStmt, FuncCall, Identifier, IfStmt, SwitchStmt, VarDecl,
+    BoolLiteral, ExprStmt, ForInStmt, ForStmt, FuncCall, Identifier, IfStmt,
+    MemberAccess, SwitchStmt, TupleAssign, TupleLiteral, VarDecl, WhileStmt,
 )
 from ..analyzer import FuncInfo
 from ..symbols import PineType, method_receiver_cpp_token
@@ -92,9 +95,13 @@ from .tables import (
     TA_CHART_PREV_CLOSE_ARG,
     DRAWING_TYPE_TO_CPP,
     PINE_TYPE_TO_CPP,
+    PINE_V6_STRATEGY_DEFAULTS,
     RUNTIME_REGISTER_SECURITY_EVAL_FN,
     RUNTIME_REGISTER_SECURITY_LOWER_TF_EVAL_FN,
 )
+from ..limits import iter_ast_nodes
+from .drawing import DRAWING_LIFETIME_CPP
+from .tv_number_format import TV_NUMBER_FORMAT_CPP
 
 
 class TopLevelEmitter:
@@ -105,8 +112,26 @@ class TopLevelEmitter:
     Mixed into ``CodeGen``; not intended to be instantiated standalone."""
 
     def _emit_includes(self, lines: list[str]) -> None:
-        lines.append('#include <pineforge/engine.hpp>')
+        roots = [self.ctx.ast] + [
+            pragma.expr_node for pragma in (self.ctx.pf_trace_pragmas or [])
+        ]
+        # Every syntax child (``iter_ast_nodes``): ``_walk_ast`` does not enter
+        # a tuple literal, so ``str.tostring`` in a request.security tuple
+        # payload left ``pine_str_tostring_tv`` undeclared.
+        self._uses_tv_number_format = any(
+            (namespace == "str" and func_name in {"format", "tostring"})
+            or (namespace is None and func_name == "tostring")
+            or (namespace == "log" and func_name in {"info", "warning", "error"}
+                and len(node.args) > 1)
+            for root in roots
+            for node, _depth in iter_ast_nodes(root)
+            if isinstance(node, FuncCall)
+            for func_name, namespace in [self._resolve_callee(node.callee)]
+        )
+        lines.append('#include <pineforge/source/pine_strategy_host.hpp>')
         lines.append('#include <pineforge/ta.hpp>')
+        if self._ta_uses_dynamic_lengths():
+            lines.append('#include <pineforge/source/pine_ta_length.hpp>')
         lines.append('#include <pineforge/math.hpp>')
         lines.append('#include <pineforge/series.hpp>')
         lines.append('#include <pineforge/na.hpp>')
@@ -119,10 +144,15 @@ class TopLevelEmitter:
         lines.append("#include <numeric>")
         lines.append("#include <string>")
         lines.append("#include <vector>")
+        if self._uses_tv_number_format:
+            lines.extend(("#include <charconv>", "#include <system_error>",
+                          "#include <stdexcept>"))
         if getattr(self, "_udt_defs", {}):
             lines.append("#include <deque>")
             lines.append("#include <functional>")
             lines.append("#include <limits>")
+            if self._udt_has_array_fields():
+                lines.append("#include <memory>")
         lines.append("#include <tuple>")
         lines.append("#include <optional>")
         lines.append("#include <type_traits>")
@@ -174,6 +204,11 @@ class TopLevelEmitter:
         # byte-identical — mirrors the matrix.hpp gating above.
         if getattr(self, "_uses_drawing", False):
             lines.append('#include <pineforge/drawing.hpp>')
+        lines.extend([
+            "#ifndef PINEFORGE_HAS_NATIVE_LOWERING_V1",
+            '#error "generated code requires pineforge-engine native lowering v1 (PINEFORGE_HAS_NATIVE_LOWERING_V1)"',
+            "#endif",
+        ])
         lines.append("")
         # Compatibility shim for the namespace-wrap refactor: unqualified
         # references to BacktestEngine / Bar / na<T>() / ta::* / etc. resolve
@@ -181,33 +216,228 @@ class TopLevelEmitter:
         # in favour of fully qualified names emitted at each call site.
         lines.append("using namespace pineforge;")
         lines.append("")
+        self._emit_ta_compat_shims(lines)
+        if getattr(self, "_uses_drawing", False):
+            lines.append(DRAWING_LIFETIME_CPP)
+        if self._uses_tv_number_format:
+            lines.append(TV_NUMBER_FORMAT_CPP)
+            lines.append("")
         # Syminfo derivation helpers (_pf_derive_main_tickerid, _pf_derive_country)
         from .helpers_syminfo import emit_syminfo_helpers
         lines.extend(emit_syminfo_helpers())
 
-    def _script_has_strategy_close(self) -> bool:
-        """True if the script's AST contains a ``strategy.close*`` call.
-
-        Scans the entire program body (including nested function /
-        method bodies) for any ``FuncCall`` whose callee resolves to
-        ``strategy.close`` or ``strategy.close_all``. Comments are
-        not considered (parser strips them). Result is independent of
-        whether the close call ever runs at backtest time — this is a
-        purely static script-shape check used by the engine's flip path
-        to choose between TV's empirical growth rule and the standard
-        Pine semantic.
-
-        Mixin contract: relies on ``self._walk_ast`` (NamingHelper) and
-        ``self._resolve_callee`` (NamingHelper); host class must
-        provide ``self.ctx.ast``."""
-        from ..ast_nodes import FuncCall  # local to avoid circular import
-        for node in self._walk_ast(self.ctx.ast):
-            if not isinstance(node, FuncCall):
-                continue
-            func_name, namespace = self._resolve_callee(node.callee)
-            if namespace == "strategy" and func_name in ("close", "close_all"):
-                return True
-        return False
+    def _emit_ta_compat_shims(self, lines: list[str]) -> None:
+        """Emit source-level adapters for TA1 arguments and anchored forms.
+
+        The adapters are selected by feature macros exported from
+        ``pineforge/ta.hpp``. This lets one generated TU compile against the
+        TA1 engine and the previous engine while keeping the Pine call-site
+        shape identical. The old branch deliberately preserves the historical
+        lowering; it is only selected when the corresponding macro is absent.
+        """
+        classes = {
+            site.class_name for site in getattr(self.ctx, "ta_call_sites", ())
+        }
+
+        if "_PFALMA" in classes:
+            lines.extend([
+                "#ifdef PF_ALMA_HAS_FLOOR",
+                "class _PFALMA {",
+                "    ta::ALMA impl_;",
+                "public:",
+                "    _PFALMA(int length, double offset, double sigma, bool floor = false)"
+                " : impl_(length, offset, sigma, floor) {}",
+                "    double compute(double src) { return impl_.compute(src); }",
+                "    double recompute(double src) { return impl_.recompute(src); }",
+                "};",
+                "#else",
+                "class _PFALMA {",
+                "    ta::ALMA impl_;",
+                "public:",
+                "    _PFALMA(int length, double offset, double sigma, bool = false)"
+                " : impl_(length, offset, sigma) {}",
+                "    double compute(double src) { return impl_.compute(src); }",
+                "    double recompute(double src) { return impl_.recompute(src); }",
+                "};",
+                "#endif",
+                "",
+            ])
+
+        if "_PFKC" in classes:
+            lines.extend([
+                "#ifdef PF_KC_HAS_USE_TRUE_RANGE",
+                "class _PFKC {",
+                "    ta::KC impl_;",
+                "public:",
+                "    _PFKC(int length, double mult, bool use_true_range = true)"
+                " : impl_(length, mult, use_true_range) {}",
+                "    ta::KCResult compute(double src, double high, double low, double close)"
+                " { bool _pf_prior = ta::ema_na_warmup_flag(); ta::ema_na_warmup_flag() = true; auto _pf_out = impl_.compute(src, high, low, close); ta::ema_na_warmup_flag() = _pf_prior; return _pf_out; }",
+                "    ta::KCResult recompute(double src, double high, double low, double close)"
+                " { bool _pf_prior = ta::ema_na_warmup_flag(); ta::ema_na_warmup_flag() = true; auto _pf_out = impl_.recompute(src, high, low, close); ta::ema_na_warmup_flag() = _pf_prior; return _pf_out; }",
+                "};",
+                "#else",
+                "class _PFKC {",
+                "    ta::KC impl_;",
+                "public:",
+                "    _PFKC(int length, double mult, bool = true) : impl_(length, mult) {}",
+                "    ta::KCResult compute(double src, double high, double low, double close)"
+                " { bool _pf_prior = ta::ema_na_warmup_flag(); ta::ema_na_warmup_flag() = true; auto _pf_out = impl_.compute(src, high, low, close); ta::ema_na_warmup_flag() = _pf_prior; return _pf_out; }",
+                "    ta::KCResult recompute(double src, double high, double low, double close)"
+                " { bool _pf_prior = ta::ema_na_warmup_flag(); ta::ema_na_warmup_flag() = true; auto _pf_out = impl_.recompute(src, high, low, close); ta::ema_na_warmup_flag() = _pf_prior; return _pf_out; }",
+                "};",
+                "#endif",
+                "",
+            ])
+
+        if "_PFKCW" in classes:
+            lines.extend([
+                "#ifdef PF_KC_HAS_USE_TRUE_RANGE",
+                "class _PFKCW {",
+                "    ta::KCW impl_;",
+                "public:",
+                "    _PFKCW(int length, double mult, bool use_true_range = true)"
+                " : impl_(length, mult, use_true_range) {}",
+                "    double compute(double src, double high, double low, double close)"
+                " { bool _pf_prior = ta::ema_na_warmup_flag(); ta::ema_na_warmup_flag() = true; auto _pf_out = impl_.compute(src, high, low, close); ta::ema_na_warmup_flag() = _pf_prior; return _pf_out; }",
+                "    double recompute(double src, double high, double low, double close)"
+                " { bool _pf_prior = ta::ema_na_warmup_flag(); ta::ema_na_warmup_flag() = true; auto _pf_out = impl_.recompute(src, high, low, close); ta::ema_na_warmup_flag() = _pf_prior; return _pf_out; }",
+                "};",
+                "#else",
+                "class _PFKCW {",
+                "    ta::KCW impl_;",
+                "public:",
+                "    _PFKCW(int length, double mult, bool = true) : impl_(length, mult) {}",
+                "    double compute(double src, double high, double low, double close)"
+                " { bool _pf_prior = ta::ema_na_warmup_flag(); ta::ema_na_warmup_flag() = true; auto _pf_out = impl_.compute(src, high, low, close); ta::ema_na_warmup_flag() = _pf_prior; return _pf_out; }",
+                "    double recompute(double src, double high, double low, double close)"
+                " { bool _pf_prior = ta::ema_na_warmup_flag(); ta::ema_na_warmup_flag() = true; auto _pf_out = impl_.recompute(src, high, low, close); ta::ema_na_warmup_flag() = _pf_prior; return _pf_out; }",
+                "};",
+                "#endif",
+                "",
+            ])
+
+        if "_PFAnchoredVWAP" in classes:
+            lines.extend([
+                "#ifdef PF_VWAP_HAS_ANCHOR_INPUT",
+                "class _PFAnchoredVWAP {",
+                "    ta::AnchoredVWAP impl_;",
+                "public:",
+                "    double compute(double src, double volume, int64_t timestamp,"
+                " const std::string& tz, const std::string& session, bool anchor) {",
+                "        (void)timestamp; (void)tz; (void)session;",
+                "        return impl_.compute(src, volume, anchor);",
+                "    }",
+                "    double recompute(double src, double volume, int64_t timestamp,"
+                " const std::string& tz, const std::string& session, bool anchor) {",
+                "        (void)timestamp; (void)tz; (void)session;",
+                "        return impl_.recompute(src, volume, anchor);",
+                "    }",
+                "};",
+                "#else",
+                "class _PFAnchoredVWAP {",
+                "    ta::VWAP impl_;",
+                "public:",
+                "    double compute(double src, double volume, int64_t timestamp,"
+                " const std::string& tz, const std::string& session, bool) {",
+                "#ifdef PF_VWAP_HAS_SESSION_ANCHOR",
+                "        return impl_.compute(src, volume, timestamp, tz, session);",
+                "#else",
+                "        (void)tz; (void)session;",
+                "        return impl_.compute(src, volume, timestamp);",
+                "#endif",
+                "    }",
+                "    double recompute(double src, double volume, int64_t timestamp,"
+                " const std::string& tz, const std::string& session, bool) {",
+                "#ifdef PF_VWAP_HAS_SESSION_ANCHOR",
+                "        return impl_.recompute(src, volume, timestamp, tz, session);",
+                "#else",
+                "        (void)tz; (void)session;",
+                "        return impl_.recompute(src, volume, timestamp);",
+                "#endif",
+                "    }",
+                "};",
+                "#endif",
+                "",
+            ])
+
+        if "_PFAnchoredVWAPBands" in classes:
+            lines.extend([
+                "#ifdef PF_VWAP_HAS_ANCHOR_INPUT",
+                "class _PFAnchoredVWAPBands {",
+                "    ta::AnchoredVWAPBands impl_;",
+                "public:",
+                "    explicit _PFAnchoredVWAPBands(double mult) : impl_(mult) {}",
+                "    ta::VWAPBandsResult compute(double src, double volume, int64_t timestamp,"
+                " const std::string& tz, const std::string& session, bool anchor) {",
+                "        (void)timestamp; (void)tz; (void)session;",
+                "        return impl_.compute(src, volume, anchor);",
+                "    }",
+                "    ta::VWAPBandsResult recompute(double src, double volume, int64_t timestamp,"
+                " const std::string& tz, const std::string& session, bool anchor) {",
+                "        (void)timestamp; (void)tz; (void)session;",
+                "        return impl_.recompute(src, volume, anchor);",
+                "    }",
+                "};",
+                "#else",
+                "class _PFAnchoredVWAPBands {",
+                "    ta::VWAP impl_;",
+                "    double mult_;",
+                "public:",
+                "    explicit _PFAnchoredVWAPBands(double mult) : mult_(mult) {}",
+                "    ta::VWAPBandsResult compute(double src, double volume, int64_t timestamp,"
+                " const std::string& tz, const std::string& session, bool) {",
+                "#ifdef PF_VWAP_HAS_SESSION_ANCHOR",
+                "        return impl_.compute_bands(src, volume, timestamp, mult_, tz, session);",
+                "#else",
+                "        (void)tz; (void)session;",
+                "        return impl_.compute_bands(src, volume, timestamp, mult_);",
+                "#endif",
+                "    }",
+                "    ta::VWAPBandsResult recompute(double src, double volume, int64_t timestamp,"
+                " const std::string& tz, const std::string& session, bool) {",
+                "#ifdef PF_VWAP_HAS_SESSION_ANCHOR",
+                "        return impl_.recompute_bands(src, volume, timestamp, mult_, tz, session);",
+                "#else",
+                "        (void)tz; (void)session;",
+                "        return impl_.recompute_bands(src, volume, timestamp, mult_);",
+                "#endif",
+                "    }",
+                "};",
+                "#endif",
+                "",
+            ])
+
+        if "_PFPivotPointLevels" in classes:
+            lines.extend([
+                "#ifdef PF_PIVOT_LEVELS_HAS_ANCHOR",
+                "class _PFPivotPointLevels {",
+                "    ta::PivotPointLevels impl_;",
+                "public:",
+                "    std::vector<double> compute(const std::string& type, bool anchor,"
+                " bool developing, double open, double high, double low, double close) {",
+                "        return impl_.compute(type, anchor, developing, open, high, low, close);",
+                "    }",
+                "    std::vector<double> recompute(const std::string& type, bool anchor,"
+                " bool developing, double open, double high, double low, double close) {",
+                "        return impl_.recompute(type, anchor, developing, open, high, low, close);",
+                "    }",
+                "};",
+                "#else",
+                "class _PFPivotPointLevels {",
+                "public:",
+                "    std::vector<double> compute(const std::string& type, bool, bool,"
+                " double, double high, double low, double close) {",
+                "        return ta::pivot_point_levels(type, high, low, close);",
+                "    }",
+                "    std::vector<double> recompute(const std::string& type, bool, bool,"
+                " double, double high, double low, double close) {",
+                "        return ta::pivot_point_levels(type, high, low, close);",
+                "    }",
+                "};",
+                "#endif",
+                "",
+            ])
 
     def _script_has_input_source(self) -> bool:
         """True if the script's AST contains an ``input.source(...)`` call.
@@ -215,7 +445,7 @@ class TopLevelEmitter:
         Gates the engine's native source-series push: the runtime only
         advances ``_src_<field>_`` (paying the per-bar cost) when
         ``_src_series_active_`` is set, which the ctor does iff this returns
-        True. Same static-shape scan style as ``_script_has_strategy_close``."""
+        True. This is a history-storage requirement, not a broker policy."""
         from ..ast_nodes import FuncCall  # local to avoid circular import
         for node in self._walk_ast(self.ctx.ast):
             if not isinstance(node, FuncCall):
@@ -295,6 +525,7 @@ class TopLevelEmitter:
         """
         members: list[str] = []
         seen: set[str] = set()
+        varip_members = self._varip_state_member_names()
         for line in declaration_lines:
             name = self._script_state_member_name(line)
             if name is None:
@@ -304,9 +535,109 @@ class TopLevelEmitter:
             if name in seen:
                 raise AssertionError(f"duplicate generated script-state member: {name}")
             seen.add(name)
+            if name in varip_members:
+                continue
             members.append(name)
         return members
 
+    def _varip_state_member_names(self) -> set[str]:
+        """Generated members holding ``varip`` state, with their first-run
+        initialization latches.
+
+        A historical bar executes the script once, so ``varip`` keeps its
+        value exactly like ``var``, except that a calc_on_order_fills
+        recalculation rolls ``var`` back to the bar's committed state and
+        leaves ``varip`` alone (TradingView tapes, COOF on/off and with the
+        bar magnifier). The rollback checkpoint therefore skips these members;
+        a new run still resets them (``prepare_script_run``).
+        """
+        names: set[str] = set()
+        metadata = getattr(self.ctx, "var_member_metadata_by_node", {}) or {}
+        for node_id, meta in metadata.items():
+            decl = meta[0]
+            if not (isinstance(decl, VarDecl) and decl.is_varip):
+                continue
+            base = self._safe_name(meta[1])
+            storages = {base}
+            for remap in self._func_cs_var_remap.values():
+                if base in remap:
+                    storages.add(remap[base])
+            for instance in self._fresh_instances:
+                clone = (instance.get("var_remap") or {}).get(base)
+                if clone is not None:
+                    storages.add(clone)
+            names |= storages
+            for storage in storages:
+                flag = self._runtime_var_init_flags.get((node_id, storage))
+                if flag is not None:
+                    names.add(flag)
+        return names
+
+    def _emit_script_run_prepare(self, lines: list[str], declarations: list[str]) -> None:
+        """Reset every declared script member, then prepare this run's cache.
+
+        Unlike per-bar rollback, a new lifecycle also invalidates precalculated
+        vectors and initialization latches. Constructor arguments are taken from
+        the constructor's own plan; declaration defaults cover every other
+        member. The only nonassignable state is the UDT undo coordinator/arenas,
+        whose explicit reset retains their stable internal pointers.
+        """
+        constructor_values: dict[str, str] = {}
+        for initializer in self._script_constructor_initializers:
+            name, separator, arguments = initializer.partition("(")
+            if not separator or not arguments.endswith(")") or name in constructor_values:
+                raise AssertionError(f"unexpected generated constructor initializer: {initializer!r}")
+            constructor_values[name] = "(" + arguments
+
+        udt_state = set(getattr(self, "_udt_arena_member_names", {}).values())
+        if self._udt_defs:
+            udt_state.add(self._udt_undo_coordinator_member_name)
+
+        lines.extend([
+            "#ifndef PINEFORGE_HAS_SCRIPT_RUN_PREPARE_V1",
+            '#error "Generated lifecycle reset requires a matching PineForge engine; rebuild with script-run preparation support"',
+            "#endif",
+            "    void prepare_script_run(const Bar* bars, int n, bool allow_precalculation) override {",
+            "        _pf_script_state_checkpoint_.reset();",
+        ])
+        seen: set[str] = set()
+        for declaration in declarations:
+            name = self._script_state_member_name(declaration)
+            if name is None:
+                continue
+            if name in seen:
+                raise AssertionError(f"duplicate generated lifecycle member: {name}")
+            seen.add(name)
+            if name in udt_state:
+                lines.append(f"        this->{name}.reset_for_run();")
+                continue
+            if name in constructor_values:
+                value = f"decltype(this->{name}){constructor_values[name]}"
+            else:
+                text = declaration.strip()
+                match = re.search(r"(?<![A-Za-z_0-9])" + re.escape(name)
+                                  + r"(?=\s*(?:[=({;]))", text)
+                if match is None:
+                    raise AssertionError(f"cannot reset generated declaration: {declaration!r}")
+                suffix = text[match.end():-1].strip()
+                if not suffix:
+                    value = f"decltype(this->{name}){{}}"
+                elif suffix.startswith("=") and suffix[1:].strip():
+                    value = suffix[1:].strip()
+                elif ((suffix.startswith("(") and suffix.endswith(")"))
+                      or (suffix.startswith("{") and suffix.endswith("}"))):
+                    value = f"decltype(this->{name}){suffix}"
+                else:
+                    raise AssertionError(f"unknown generated reset initializer: {declaration!r}")
+            lines.append(f"        this->{name} = {value};")
+        if not set(constructor_values).issubset(seen) or not udt_state.issubset(seen):
+            raise AssertionError("generated lifecycle reset does not cover all constructor/UDT state")
+        if self._has_precalculated_ta():
+            lines.append("        if (allow_precalculation) precalculate(bars, n);")
+        else:
+            lines.append("        (void)bars; (void)n; (void)allow_precalculation;")
+        lines.append("    }")
+
     def _emit_handle_checkpoint_traits(self, lines: list[str]) -> None:
         """Emit recursive rollback adapters for shared-ID collection state.
 
@@ -470,6 +801,32 @@ class TopLevelEmitter:
             "",
         ])
 
+        if self._udt_has_array_fields():
+            # A UDT array field: its binding, and the contents of an array it
+            # owns (an aliased script array is checkpointed as itself).
+            lines.extend([
+                "template <typename _PFElement>",
+                f"struct {checkpoint_traits}<_PFArrayField<_PFElement>> {{",
+                f"    using vector_traits = {checkpoint_traits}<std::vector<_PFElement>>;",
+                "    struct snapshot_type {",
+                "        std::shared_ptr<std::vector<_PFElement>> owned;",
+                "        std::vector<_PFElement>* data;",
+                "        typename vector_traits::snapshot_type contents;",
+                "    };",
+                "    static snapshot_type take(const _PFArrayField<_PFElement>& value) {",
+                "        snapshot_type snapshot{value.owned(), value.data(), {}};",
+                "        if (value.owned()) snapshot.contents = vector_traits::take(*value.owned());",
+                "        return snapshot;",
+                "    }",
+                "    static void restore(_PFArrayField<_PFElement>& value,",
+                "                        const snapshot_type& snapshot) {",
+                "        value.rebind(snapshot.owned, snapshot.data);",
+                "        if (snapshot.owned) vector_traits::restore(*snapshot.owned, snapshot.contents);",
+                "    }",
+                "};",
+                "",
+            ])
+
         # Snapshot backing records field-by-field.  A nested UDT field is only
         # a numeric handle, so the primary trait copies its ID without recursing
         # into another record.  This makes self/cyclic object graphs finite;
@@ -482,7 +839,8 @@ class TopLevelEmitter:
                 for field in fields
                 if field.name not in self._udt_omitted_fields.get(type_name, set())
             ]
-            checkpoint_fields = [field.name for field in emitted_fields]
+            checkpoint_fields = [self._safe_name(field.name)
+                                 for field in emitted_fields]
             lines.append("template <>")
             lines.append(f"struct {checkpoint_traits}<{record_type}> {{")
             lines.append("    struct snapshot_type {")
@@ -641,6 +999,10 @@ class TopLevelEmitter:
             # run and their ctor args (bare param names) can never be sized.
             if ta_idx in self._dead_ta_indices:
                 continue
+            if self._ta_dynamic_plan(site) is not None:
+                # A simple or series length is read on the bar
+                # (``_ta_dynamic_plan``): the member is default-constructed.
+                continue
             if site.ctor_args:
                 # If a ctor arg is neither a compile-time literal nor expandable
                 # to an input-backed runtime expression, the old code silently
@@ -649,10 +1011,14 @@ class TopLevelEmitter:
                 # DO expand to a runtime expr (input-backed / arithmetic-over-input,
                 # incl. function-derived lengths) are safe: the `!_ta_initialized_`
                 # reset overwrites the placeholder before the first compute.
-                for a in site.ctor_args:
+                for arg_pos, a in enumerate(site.ctor_args):
                     r = self._resolve_ta_ctor_arg(a)
+                    # An argument ``_ta_arg_takes_plan`` sends to the lowering
+                    # of ``_ta_dynamic_plan`` that it cannot spell is refused
+                    # here, as before string literals were spelled.
                     if (not self._is_compile_time_value(r)
-                            and self._runtime_ctor_arg_for_reset(a) is None):
+                            and (self._runtime_ctor_arg_for_reset(a) is None
+                                 or self._ta_arg_takes_plan(site, arg_pos, a))):
                         # A TA source reached through request.security can have
                         # several helper-bound constructor variants. Validate
                         # only variants of this exact source node before the
@@ -664,24 +1030,39 @@ class TopLevelEmitter:
                             self._collect_ta_runtime_resets(
                                 security_source_node=site.node
                             )
-                        self._codegen_error(
-                            getattr(site, "node", None),
-                            f"Unsupported TA constructor length '{a}' for "
-                            f"{site.class_name}: it is neither a compile-time "
-                            f"constant nor derived from an input, so PineForge "
-                            f"cannot size the indicator buffer.",
-                            hint=("Use a literal, an input.*() value, or "
-                                  "arithmetic over those for TA lengths."),
-                        )
+                        if self._ta_ctor_arg_is_bool(site, arg_pos):
+                            message = (
+                                f"Unsupported TA constructor flag '{a}' for "
+                                f"{site.class_name}: it is neither a compile-time "
+                                "constant nor derived from an input, so PineForge "
+                                "cannot initialize the indicator with a stable "
+                                "per-run value."
+                            )
+                            hint = ("Use a literal, an input.*() value, or "
+                                    "arithmetic over those for TA constructor "
+                                    "arguments.")
+                        else:
+                            message = (
+                                f"Unsupported TA constructor length '{a}' for "
+                                f"{site.class_name}: it is neither a compile-time "
+                                "constant nor derived from an input, so PineForge "
+                                "cannot size the indicator buffer."
+                            )
+                            hint = ("Use a literal, an input.*() value, or "
+                                    "arithmetic over those for TA lengths.")
+                        self._codegen_error(getattr(site, "node", None), message, hint=hint)
                 resolved = [self._resolve_ta_ctor_arg(a) for a in site.ctor_args]
                 # Compile-time placeholder for the init list; the runtime reset
                 # (when the arg is input-derived) overwrites it on the first bar.
                 safe_resolved = []
-                for r in resolved:
+                for arg_pos, r in enumerate(resolved):
                     if self._is_compile_time_value(r):
-                        safe_resolved.append(r)
+                        rendered = r
                     else:
-                        safe_resolved.append("1")
+                        rendered = "1"
+                    if self._ta_ctor_arg_is_bool(site, arg_pos):
+                        rendered = self._ta_ctor_bool_cpp(rendered)
+                    safe_resolved.append(rendered)
                 init_parts.append(f"{site.member_name}({', '.join(safe_resolved)})")
         # Security evaluator TA ctor args (skip for user function call expressions)
         for info in self._security_eval_info:
@@ -690,6 +1071,12 @@ class TopLevelEmitter:
                 if not site.ctor_args:
                     continue
                 for variant in variants:
+                    if self._ta_security_plan(
+                        info["sec_id"], site, variant.get("binding_stack", ())
+                    ) is not None:
+                        # Default-constructed: the length is read on the bar
+                        # (``_ta_security_plan``).
+                        continue
                     ctor_args, _ctor_arg_stability = self._security_ta_ctor_args_for_variant(
                         info["sec_id"],
                         site,
@@ -697,10 +1084,11 @@ class TopLevelEmitter:
                     )
                     resolved = [self._resolve_ta_ctor_arg(a) for a in ctor_args]
                     safe_resolved = []
-                    for r in resolved:
-                        safe_resolved.append(
-                            r if self._is_compile_time_value(r) else "1"
-                        )
+                    for arg_pos, r in enumerate(resolved):
+                        rendered = r if self._is_compile_time_value(r) else "1"
+                        if self._ta_ctor_arg_is_bool(site, arg_pos):
+                            rendered = self._ta_ctor_bool_cpp(rendered)
+                        safe_resolved.append(rendered)
                     init_parts.append(f"{variant['member_name']}({', '.join(safe_resolved)})")
 
         # Non-series var members with compile-time init (deduplicate by name)
@@ -747,18 +1135,43 @@ class TopLevelEmitter:
                 cpp_val = self._typed_na_init(cpp_val, name, ptype)
                 if self._is_compile_time_value(cpp_val):
                     init_parts.append(f"{safe}({cpp_val})")
-        # Strategy params that map to engine members
-        ctor_body: list[str] = []
+        # This exact initializer plan also defines a cold generated lifecycle.
+        # Engine configuration in the constructor body is deliberately excluded.
+        self._script_constructor_initializers = tuple(init_parts)
+
+        # New engines default to an independent native constructor. Select
+        # Pine compatibility before strategy_create returns and before any
+        # host metadata setter. The adapter currently owns cap and retained-
+        # parent priority only. Cap-only engines retain their legacy priority
+        # default; older headers need neither hook. Always compile/link with
+        # matching engine headers and runtime. This is not a binary ABI bridge.
+        # This is configuration, deliberately outside script-state reset.
+        ctor_body: list[str] = [
+            "#if defined(PINEFORGE_HAS_EXPLICIT_PINE_EXECUTION_ADAPTER_V1)",
+            "        pineforge::source::PineStrategyHost::attach_pine_execution_adapter();",
+            "#elif defined(PINEFORGE_HAS_EXPLICIT_PINE_CAP_V1)",
+            "        pineforge::source::PineStrategyHost::enable_pine_intraday_cap();",
+            "#endif",
+            "        pineforge::source::PineStrategyConfig cfg{};",
+        ]
+        # Strategy params that map to the source host's config surface.
         sp = self.ctx.strategy_params
 
         if sp.get("process_orders_on_close") is True:
-            ctor_body.append("        process_orders_on_close_ = true;")
+            ctor_body.append("        cfg.process_orders_on_close = true;")
 
         if sp.get("calc_on_order_fills") is True:
-            ctor_body.append("        calc_on_order_fills_ = true;")
+            ctor_body.append("        cfg.calc_on_order_fills = true;")
 
-        if "initial_capital" in sp and isinstance(sp["initial_capital"], (int, float)):
-            ctor_body.append(f"        initial_capital_ = {float(sp['initial_capital'])};")
+        # An omitted initial_capital / default_qty_type / default_qty_value is
+        # TradingView's Pine v6 default, not the host's (see
+        # PINE_V6_STRATEGY_DEFAULTS); a declared argument is emitted as before.
+        def declared_or_v6_default(key: str):
+            return sp[key] if key in sp else PINE_V6_STRATEGY_DEFAULTS[key]
+
+        initial_capital = declared_or_v6_default("initial_capital")
+        if isinstance(initial_capital, (int, float)):
+            ctor_body.append(f"        cfg.initial_capital = {float(initial_capital)};")
 
         # default_qty_type: strategy.fixed / strategy.percent_of_equity / strategy.cash
         qty_type_map = {
@@ -766,15 +1179,18 @@ class TopLevelEmitter:
             "strategy.percent_of_equity": "QtyType::PERCENT_OF_EQUITY",
             "strategy.cash": "QtyType::CASH",
         }
-        qty_type = sp.get("default_qty_type")
+        qty_type = declared_or_v6_default("default_qty_type")
         if qty_type in qty_type_map:
-            ctor_body.append(f"        default_qty_type_ = {qty_type_map[qty_type]};")
+            ctor_body.append(
+                f"        cfg.default_qty_type = static_cast<int>({qty_type_map[qty_type]});"
+            )
 
-        if "default_qty_value" in sp and isinstance(sp["default_qty_value"], (int, float)):
-            ctor_body.append(f"        default_qty_value_ = {float(sp['default_qty_value'])};")
+        qty_value = declared_or_v6_default("default_qty_value")
+        if isinstance(qty_value, (int, float)):
+            ctor_body.append(f"        cfg.default_qty_value = {float(qty_value)};")
 
         if "pyramiding" in sp and isinstance(sp["pyramiding"], int):
-            ctor_body.append(f"        pyramiding_ = {sp['pyramiding']};")
+            ctor_body.append(f"        cfg.pyramiding = {sp['pyramiding']};")
 
         # commission_type: strategy.commission.percent / .cash_per_order / .cash_per_contract
         comm_type_map = {
@@ -784,41 +1200,35 @@ class TopLevelEmitter:
         }
         comm_type = sp.get("commission_type")
         if comm_type in comm_type_map:
-            ctor_body.append(f"        commission_type_ = {comm_type_map[comm_type]};")
+            ctor_body.append(
+                f"        cfg.commission_type = static_cast<int>({comm_type_map[comm_type]});"
+            )
 
         if "commission_value" in sp and isinstance(sp["commission_value"], (int, float)):
-            ctor_body.append(f"        commission_value_ = {float(sp['commission_value'])};")
+            ctor_body.append(f"        cfg.commission_value = {float(sp['commission_value'])};")
 
         if "slippage" in sp and isinstance(sp["slippage"], (int, float)):
-            ctor_body.append(f"        slippage_ = {int(sp['slippage'])};")
+            ctor_body.append(f"        cfg.slippage = {int(sp['slippage'])};")
 
         # margin_long / margin_short: percent of position value required as
         # equity (default 100 = 1x leverage). When required_margin exceeds
         # available equity, TV silently rejects the fill — engine mirrors
         # this in execute_market_entry's FLAT branch.
         if "margin_long" in sp and isinstance(sp["margin_long"], (int, float)):
-            ctor_body.append(f"        margin_long_ = {float(sp['margin_long'])};")
+            ctor_body.append(f"        cfg.margin_long = {float(sp['margin_long'])};")
         if "margin_short" in sp and isinstance(sp["margin_short"], (int, float)):
-            ctor_body.append(f"        margin_short_ = {float(sp['margin_short'])};")
+            ctor_body.append(f"        cfg.margin_short = {float(sp['margin_short'])};")
 
         # close_entries_rule: "FIFO" (default) or "ANY"
         if sp.get("close_entries_rule") == "ANY":
-            ctor_body.append("        close_entries_rule_any_ = true;")
-
-        # Detect ``strategy.close`` / ``strategy.close_all`` calls anywhere in
-        # the script body. The runtime uses this flag in its priced-entry flip
-        # path to reproduce TradingView's empirical
-        # ``new_size = |old| + qty`` rule (see
-        # docs/codegen-gaps/validation-tv-pyramiding-override.md). The flag
-        # is set once per compilation; it is independent of how many times
-        # the close call actually fires at runtime.
-        if self._script_has_strategy_close():
-            ctor_body.append("        script_has_strategy_close_ = true;")
+            ctor_body.append("        cfg.close_entries_rule_any = true;")
 
         # Turn on native source-series history only when the script uses
         # input.source — otherwise the engine pays nothing per bar.
         if self._script_has_input_source():
-            ctor_body.append("        _src_series_active_ = true;")
+            ctor_body.append("        cfg.src_series_active = true;")
+
+        ctor_body.append("        configure_pine_strategy(cfg);")
 
         if init_parts and ctor_body:
             lines.append(f"    explicit GeneratedStrategy() : {', '.join(init_parts)} {{")
@@ -835,43 +1245,81 @@ class TopLevelEmitter:
 
         lines.append("")
         lines.append("    void set_strategy_override(const std::string& key, const std::string& value) {")
-        lines.append('        if (key == "initial_capital") { initial_capital_ = std::stod(value); return; }')
-        lines.append('        if (key == "commission_value") { commission_value_ = std::stod(value); return; }')
-        lines.append('        if (key == "default_qty_value") { default_qty_value_ = std::stod(value); return; }')
-        lines.append('        if (key == "pyramiding") { pyramiding_ = std::stoi(value); return; }')
-        lines.append('        if (key == "slippage") { slippage_ = std::stoi(value); return; }')
-        lines.append('        if (key == "process_orders_on_close") { process_orders_on_close_ = (value == "true" || value == "1"); return; }')
-        lines.append('        if (key == "calc_on_order_fills") { calc_on_order_fills_ = (value == "true" || value == "1"); return; }')
-        lines.append('        if (key == "close_entries_rule") { close_entries_rule_any_ = (value == "ANY" || value == "any" || value == "1"); return; }')
-        lines.append('        if (key == "default_qty_type") {')
-        lines.append('            if (value == "fixed" || value == "strategy.fixed" || value == "0") default_qty_type_ = QtyType::FIXED;')
-        lines.append('            else if (value == "percent_of_equity" || value == "strategy.percent_of_equity" || value == "1") default_qty_type_ = QtyType::PERCENT_OF_EQUITY;')
-        lines.append('            else if (value == "cash" || value == "strategy.cash" || value == "2") default_qty_type_ = QtyType::CASH;')
-        lines.append("            return;")
-        lines.append("        }")
-        lines.append('        if (key == "commission_type") {')
-        lines.append('            if (value == "percent" || value == "strategy.commission.percent" || value == "0") commission_type_ = CommissionType::PERCENT;')
-        lines.append('            else if (value == "cash_per_order" || value == "strategy.commission.cash_per_order" || value == "1") commission_type_ = CommissionType::CASH_PER_ORDER;')
-        lines.append('            else if (value == "cash_per_contract" || value == "strategy.commission.cash_per_contract" || value == "2") commission_type_ = CommissionType::CASH_PER_CONTRACT;')
+        lines.append("        pineforge::source::StrategyOverrides overrides{};")
+        lines.append('        if (key == "initial_capital") {')
+        lines.append("            overrides.initial_capital = std::stod(value);")
+        lines.append('        } else if (key == "commission_value") {')
+        lines.append("            overrides.commission_value = std::stod(value);")
+        lines.append('        } else if (key == "default_qty_value") {')
+        lines.append("            overrides.default_qty_value = std::stod(value);")
+        lines.append('        } else if (key == "pyramiding") {')
+        lines.append("            overrides.pyramiding = std::stoi(value);")
+        lines.append('        } else if (key == "slippage") {')
+        lines.append("            overrides.slippage = std::stoi(value);")
+        lines.append('        } else if (key == "process_orders_on_close") {')
+        lines.append('            overrides.process_orders_on_close = (value == "true" || value == "1");')
+        lines.append('        } else if (key == "calc_on_order_fills") {')
+        lines.append('            overrides.calc_on_order_fills = (value == "true" || value == "1");')
+        lines.append('        } else if (key == "close_entries_rule") {')
+        lines.append('            overrides.close_entries_rule = (value == "ANY" || value == "any" || value == "1");')
+        lines.append('        } else if (key == "default_qty_type") {')
+        lines.append('            if (value == "fixed" || value == "strategy.fixed" || value == "0") overrides.default_qty_type = static_cast<int>(QtyType::FIXED);')
+        lines.append('            else if (value == "percent_of_equity" || value == "strategy.percent_of_equity" || value == "1") overrides.default_qty_type = static_cast<int>(QtyType::PERCENT_OF_EQUITY);')
+        lines.append('            else if (value == "cash" || value == "strategy.cash" || value == "2") overrides.default_qty_type = static_cast<int>(QtyType::CASH);')
+        lines.append("            else return;")
+        lines.append('        } else if (key == "commission_type") {')
+        lines.append('            if (value == "percent" || value == "strategy.commission.percent" || value == "0") overrides.commission_type = static_cast<int>(CommissionType::PERCENT);')
+        lines.append('            else if (value == "cash_per_order" || value == "strategy.commission.cash_per_order" || value == "1") overrides.commission_type = static_cast<int>(CommissionType::CASH_PER_ORDER);')
+        lines.append('            else if (value == "cash_per_contract" || value == "strategy.commission.cash_per_contract" || value == "2") overrides.commission_type = static_cast<int>(CommissionType::CASH_PER_CONTRACT);')
+        lines.append("            else return;")
+        lines.append("        } else {")
         lines.append("            return;")
         lines.append("        }")
+        lines.append("        pineforge::source::PineStrategyHost::set_strategy_override(overrides);")
         lines.append("    }")
 
+        if self._uses_recorded_requests():
+            lines.extend([
+                "",
+                "#ifdef PINEFORGE_HAS_SYMBOL_SECURITY_EVAL_V1",
+                "    // request.earnings / dividends / splits / financial: the series the requests",
+                "    // manifest records under the request's key, TradingView's value on the chart",
+                "    // bar opening at this bar's time (na where it has no row). A key nobody",
+                "    // installed reads na here and sets the request's flag, which its reads",
+                "    // test to stop the run.",
+                "    double _pf_recorded(const std::string& key, bool& missing) const {",
+                "        missing = recorded_series_.count(key) == 0;",
+                "        return missing ? na<double>() : recorded_series_value(key);",
+                "    }",
+                "#else",
+                "    double _pf_recorded(const std::string&, bool& missing) const {",
+                "        missing = true;",
+                "        return na<double>();",
+                "    }",
+                "#endif",
+            ])
         if self._security_eval_info:
             lines.append("")
+            if any(info.get("foreign") for info in self._security_eval_info):
+                self._emit_foreign_security_lookups(lines)
             lines.append("    void configure_security_evaluators() override {")
             lines.append("        security_eval_states_.clear();")
+            lines.extend(self._security_tf_replay_prologue())
             for info in self._security_eval_info:
                 tf = info.get("tf")
                 tf_expr = info.get("tf_expr")
                 if tf:
                     tf_expr = f'"{tf}"'
-                elif not tf_expr:
-                    # No static tf and no resolvable runtime expression — fall
-                    # back to the chart timeframe so registration still compiles
-                    # (e.g. a request.security inside a dead-code UDF, or one
-                    # whose tf is a function param called with mixed timeframes).
+                elif tf == "" and not tf_expr:
+                    # An empty timeframe string is the chart's.
                     tf_expr = "input_tf_"
+                elif not tf_expr:
+                    # Every timeframe is resolved or refused
+                    # (``_resolve_security_tf``); none registers by default.
+                    self._codegen_error(
+                        info.get("tf_node"),
+                        "request.security timeframe was not resolved for registration",
+                    )
                 if tf_expr:
                     la = "true" if info["lookahead_on"] else "false"
                     go = "true" if info.get("gaps_on") else "false"
@@ -890,6 +1338,8 @@ class TopLevelEmitter:
                             f"        {RUNTIME_REGISTER_SECURITY_LOWER_TF_EVAL_FN}"
                             f"({sec_id}, {tf_expr}, input_tf_);"
                         )
+                    elif info.get("foreign"):
+                        self._emit_foreign_security_registration(info, tf_expr, la, go, lines)
                     else:
                         lines.append(
                             f"        {RUNTIME_REGISTER_SECURITY_EVAL_FN}"
@@ -897,6 +1347,109 @@ class TopLevelEmitter:
                             f"input_tf_, {la}, {go}{ha_arg});")
             lines.append("    }")
 
+    def _emit_foreign_security_lookups(self, lines: list[str]) -> None:
+        """The run-time lookups of another symbol's request (lane XSYM-E):
+        whether its symbol string is the chart's, and whether its data is
+        installed (``strategy_set_symbol_feed`` / ``_facts``). An engine
+        without the symbol-keyed registration has neither."""
+        lines.extend([
+            "#ifdef PINEFORGE_HAS_SYMBOL_SECURITY_EVAL_V1",
+            "    // A request of another symbol reads the chart when its symbol string is the",
+            "    // chart's: the one the requests manifest resolves it to, else the chart's",
+            "    // ticker id or ticker (syminfo.ticker reads the chart).",
+            "    bool _pf_symbol_is_chart(const std::string& symbol) const {",
+            "        const auto facts = symbol_facts_.find(symbol);",
+            "        if (facts != symbol_facts_.end() && !facts->second.canonical.empty())",
+            "            return facts->second.canonical == syminfo_.tickerid;",
+            "        return symbol == syminfo_.tickerid || symbol == syminfo_.ticker;",
+            "    }",
+            "    // Otherwise it reads the feed installed for (symbol, timeframe), in the",
+            "    // engine's timeframe spelling (\"D\" is \"1D\"), holding the named",
+            "    // column it reads (a footprint's), or the symbol's facts say it is",
+            "    // invalid (na under ignore_invalid_symbol, a stopped run without it).",
+            "    bool _pf_symbol_data_installed(const std::string& symbol,",
+            "                                   const std::string& timeframe,",
+            "                                   const char* column = nullptr) const {",
+            "        const auto facts = symbol_facts_.find(symbol);",
+            "        if (facts != symbol_facts_.end() && facts->second.valid && !*facts->second.valid)",
+            "            return true;",
+            "        std::string tf = timeframe.empty() ? script_tf_ : timeframe;",
+            "        if (tf.size() == 1 && (tf[0] == 'D' || tf[0] == 'W' || tf[0] == 'M' || tf[0] == 'S'))",
+            "            tf = \"1\" + tf;",
+            "        for (const auto& feed : symbol_feeds_) {",
+            "            if (feed.instrument != symbol || feed.tf != tf) continue;",
+            "            if (column == nullptr) return true;",
+            "            for (const auto& named : feed.columns) {",
+            "                if (named.name == column) return true;",
+            "            }",
+            "        }",
+            "        return false;",
+            "    }",
+            "    // Its payload seeds ta.ema as TradingView does in the requested context:",
+            "    // na until `length` values, then their mean (EmaSeeding::SimpleAverage).",
+            "    struct _PFForeignEmaSeeding {",
+            "        bool prior_ = ta::ema_na_warmup_flag();",
+            "        _PFForeignEmaSeeding() { ta::ema_na_warmup_flag() = true; }",
+            "        ~_PFForeignEmaSeeding() { ta::ema_na_warmup_flag() = prior_; }",
+            "        _PFForeignEmaSeeding(const _PFForeignEmaSeeding&) = delete;",
+            "        _PFForeignEmaSeeding& operator=(const _PFForeignEmaSeeding&) = delete;",
+            "    };",
+        ])
+        if any(self._security_footprint_column(info["sec_id"]) for info in self._security_eval_info):
+            lines.extend([
+                "    // A footprint's delta: the named column of the requested bar.",
+                "    double _pf_symbol_column(int sec_id, const char* name) const {",
+                "        return security_column_value(sec_id, name);",
+                "    }",
+                "#else",
+                "    double _pf_symbol_column(int, const char*) const { return na<double>(); }",
+            ])
+        lines.append("#endif")
+
+    def _emit_foreign_security_registration(
+            self, info: dict, tf_expr: str, la: str, go: str, lines: list[str]) -> None:
+        """Register a request of another symbol by its symbol string as the
+        run computes it before the first bar: on the chart when the string
+        is the chart's, on the symbol's installed feed otherwise, and not at
+        all without one -- its reads then stop the run
+        (``_pf_sec_missing_N``), never reading the chart instead."""
+        sec_id = info["sec_id"]
+        symbol = self._security_tf_runtime_expr(info["symbol_node"])
+        column = self._security_footprint_column(sec_id)
+        column = f', "{column}"' if column else ""
+        ignore_node = info.get("ignore_invalid_node")
+        if ignore_node is None:
+            ignore = "false"
+        elif isinstance(ignore_node, BoolLiteral):
+            ignore = "true" if ignore_node.value else "false"
+        else:
+            ignore = f"static_cast<bool>({self._security_tf_runtime_expr(ignore_node)})"
+        # A footprint is read from a feed's column, which the chart's bars do
+        # not carry: its site reads a feed even for the chart's own symbol.
+        chart = [] if column else [
+            "            if (_pf_symbol_is_chart(_pf_symbol)) {",
+            f"                {RUNTIME_REGISTER_SECURITY_EVAL_FN}({sec_id}, {tf_expr}, input_tf_, {la}, {go});",
+            f"                _pf_sec_missing_{sec_id} = false;",
+        ]
+        feed = f"if (_pf_symbol_data_installed(_pf_symbol, {tf_expr}{column})) {{"
+        lines.extend([
+            "#ifdef PINEFORGE_HAS_SYMBOL_SECURITY_EVAL_V1",
+            "        {",
+            f"            const std::string _pf_symbol = {symbol};",
+            *chart,
+            ("            } else " if chart else "            ") + feed,
+            f"                {RUNTIME_REGISTER_SECURITY_EVAL_FN}({sec_id}, _pf_symbol, {tf_expr}, "
+            f"input_tf_, {la}, {go}, {ignore});",
+            f"                _pf_sec_missing_{sec_id} = false;",
+            "            } else {",
+            f"                _pf_sec_missing_{sec_id} = true;",
+            "            }",
+            "        }",
+            "#else",
+            f"        _pf_sec_missing_{sec_id} = true;",
+            "#endif",
+        ])
+
     # Map strategy series member name to push expression
     _STRAT_SERIES_PUSH = {
         "position_size": "signed_position_size()",
@@ -931,7 +1484,7 @@ class TopLevelEmitter:
         self._lexical_udt_types = {}
         self._lexical_series_bindings = {}
         self._lexical_known_var_tombstones = set()
-        lines.append("    void on_bar(const Bar& bar) override {")
+        lines.append("    void on_source_bar(const Bar& bar) override {")
 
         # A GeneratedStrategy handle may execute multiple batch runs or
         # streaming lifecycles. BacktestEngine resets broker/base state, but
@@ -949,8 +1502,6 @@ class TopLevelEmitter:
             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("        }")
             for info in self._lazy_source_clock_by_node.values():
                 lines.append(f"        {info['clock']}.begin_bar(bar_index_);")
@@ -960,13 +1511,6 @@ class TopLevelEmitter:
                     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
@@ -986,10 +1530,12 @@ class TopLevelEmitter:
         # 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.
+        # scalar actual.  A plain UDF's history of a script variable
+        # (``fn_global_hist``) is on the same clock.  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":
+            if info["kind"] not in ("udf_series_arg", "fn_global_hist"):
                 continue
             member = info["member_name"]
             lines.append(
@@ -1009,17 +1555,18 @@ class TopLevelEmitter:
         #     members (base.py section 6) but — unlike user series vars (pushed at
         #     their assignment) and bar fields (pushed above) — have no push site,
         #     so ``[n]`` would read an unfed buffer (the na sentinel) on every bar.
-        #     Push each from its scalar lowering. A builtin whose lowering is a
-        #     self-referential call (e.g. ``time_close`` -> ``time_close()``) is
-        #     skipped — the call would resolve to the shadowing Series member.
+        #     Push each from its scalar lowering. ``time_close``'s Series
+        #     member is escaped (``_time_close_``) so its ``time_close()``
+        #     lowering still calls the host; a lowering that would call its
+        #     own member is skipped.
         from .tables import BAR_BUILTINS
         for _bname in sorted(self.ctx.series_vars):
             if _bname in self._var_names:
                 continue
             _bexpr = BAR_BUILTINS.get(_bname)
-            if _bexpr is None or _bexpr.strip().startswith(f"{_bname}("):
-                continue
             _bsafe = self._safe_name(_bname)
+            if _bexpr is None or _bexpr.strip().startswith(f"{_bsafe}("):
+                continue
             self._emit_history_series_write(lines, "        ", _bsafe, _bexpr)
 
         # a2. Push strategy series
@@ -1028,6 +1575,53 @@ class TopLevelEmitter:
             push_expr = self._STRAT_SERIES_PUSH.get(member, "0")
             self._emit_history_series_write(lines, "        ", svar, push_expr)
 
+        # a3. Push the session.* flags the top level reads at an offset: its
+        #     history is the chart bars', whether or not the read runs on this
+        #     bar (TradingView's tapes: tests/test_e2e_session_history.py).
+        for flag in sorted(self._session_history_flags):
+            value = self._visit_expr(MemberAccess(object=Identifier(name="session"),
+                                                  member=flag))
+            self._emit_history_series_write(
+                lines, "        ", self._session_history_member(flag), value)
+
+        # b0. Evaluate static global inputs once, BEFORE the first-bar ``var``
+        #     latch below: a ``var`` array / matrix / map / UDT initializer
+        #     reads input members (``array.new_bool(gridLines, false)``); built
+        #     first, it read their zero and sized an empty array. TradingView
+        #     requires constant input defaults, so the inputs read nothing the
+        #     latch builds.
+        static_vars = []
+        for stmt in self.ctx.ast.body:
+            if isinstance(stmt, VarDecl):
+                is_input = isinstance(stmt.value, FuncCall) and self._is_input_call(stmt.value)
+                if is_input:
+                    func_name_i, namespace_i = self._resolve_callee(stmt.value.callee)
+                    is_static_global_input = (
+                        stmt.name in self._global_member_vars
+                        and not self._is_source_input(stmt.value)
+                        and stmt.name not in self._array_vars
+                        and stmt.name not in getattr(self, "_matrix_specs", {})
+                        and stmt.name not in getattr(self, "_map_vars", {})
+                        and not stmt.is_var
+                        and not stmt.is_varip
+                    )
+                    if is_static_global_input:
+                        safe = self._safe_name(stmt.name)
+                        default = self._get_input_default(stmt.value)
+                        default_cpp = self._visit_expr(default) if default is not None else "0"
+                        title = self._get_input_title(stmt.value, var_name=stmt.name)
+                        getter = self._input_getter_for_call(stmt.value, func_name_i, namespace_i)
+                        default_cpp = self._coerce_string_input_default(getter, default_cpp)
+                        cpp_val = f'{getter}({self._input_key_literal(title)}, {default_cpp})'
+                        static_vars.append(f"{safe} = {cpp_val};")
+
+        if static_vars:
+            lines.append("        if (!_inputs_initialized_) {")
+            for var_expr in static_vars:
+                lines.append(f"            {var_expr}")
+            lines.append("            _inputs_initialized_ = true;")
+            lines.append("        }")
+
         # b. Var init / carry-forward
         if self.ctx.var_members:
             lines.append("        if (!_var_initialized) {")
@@ -1106,6 +1700,13 @@ class TopLevelEmitter:
                             break
                     continue
                 if name in self._runtime_scalar_var_init_members:
+                    if runtime_info is not None and runtime_info.get("is_series"):
+                        # A history-read var whose initializer reads what the
+                        # body computes (``_series_var_init_keeps_preamble``):
+                        # the first bar's slot holds its na until the
+                        # declaration replaces it (``_visit_var_decl``).
+                        na_cpp = self._typed_na_init("na<double>()", name, ptype)
+                        lines.append(f"            {safe}.push({na_cpp});")
                     continue
                 # Persistent authored UDT variables initialize from their full
                 # source RHS, not only from ``Type.new``.  In particular,
@@ -1196,39 +1797,6 @@ class TopLevelEmitter:
         # c. Push non-var series (they start fresh each bar with a push)
         # (actual push happens in visit_VarDecl when the decl is visited)
 
-        # c3. Evaluate static global inputs and variables once
-        static_vars = []
-        for stmt in self.ctx.ast.body:
-            if isinstance(stmt, VarDecl):
-                is_input = isinstance(stmt.value, FuncCall) and self._is_input_call(stmt.value)
-                if is_input:
-                    func_name_i, namespace_i = self._resolve_callee(stmt.value.callee)
-                    is_static_global_input = (
-                        stmt.name in self._global_member_vars
-                        and not self._is_source_input(stmt.value)
-                        and stmt.name not in self._array_vars
-                        and stmt.name not in getattr(self, "_matrix_specs", {})
-                        and stmt.name not in getattr(self, "_map_vars", {})
-                        and not stmt.is_var
-                        and not stmt.is_varip
-                    )
-                    if is_static_global_input:
-                        safe = self._safe_name(stmt.name)
-                        default = self._get_input_default(stmt.value)
-                        default_cpp = self._visit_expr(default) if default is not None else "0"
-                        title = self._get_input_title(stmt.value, var_name=stmt.name)
-                        getter = self._input_type_to_getter(func_name_i, namespace_i)
-                        default_cpp = self._coerce_string_input_default(getter, default_cpp)
-                        cpp_val = f'{getter}("{title}", {default_cpp})'
-                        static_vars.append(f"{safe} = {cpp_val};")
-
-        if static_vars:
-            lines.append("        if (!_inputs_initialized_) {")
-            for var_expr in static_vars:
-                lines.append(f"            {var_expr}")
-            lines.append("            _inputs_initialized_ = true;")
-            lines.append("        }")
-
         # c2. First-bar TA resize: rebuild any TA object whose ctor args come
         # from input-backed variables so strategy_set_input() actually changes
         # the circular-buffer sizes. Emits nothing when no TA site depends on
@@ -1237,9 +1805,11 @@ class TopLevelEmitter:
 
         # 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``).
+        #    evaluated every bar BEFORE the statement, and so is a pure user
+        #    call read at an offset there (TV rules, see ``ta.py``).
         for stmt in self.ctx.ast.body:
             self._emit_lazy_edge_ta_hoists(stmt, lines, indent=2)
+            self._emit_lazy_call_history_hoists(stmt, lines, indent=2)
             try:
                 self._visit_stmt(stmt, lines, indent=2)
             finally:
@@ -1380,9 +1950,37 @@ class TopLevelEmitter:
         lines.append("        if (!s) return;")
         lines.append("        static_cast<GeneratedStrategy*>(s)->set_magnifier_volume_weighted(on != 0);")
         lines.append("    }")
+        if self._declares_bar_magnifier():
+            # TradingView runs a script that declares use_bar_magnifier = true
+            # on its bar magnifier; the host reads this export to run it on
+            # intrabars with the magnifier on (the run parameters are the
+            # host's: bar_magnifier, a finer input_tf and its feed).
+            lines.append("    int strategy_declares_bar_magnifier(void) {")
+            lines.append("        return 1;")
+            lines.append("    }")
         lines.append("}")
         lines.append("")
 
+    def _declares_bar_magnifier(self) -> bool:
+        """``strategy(use_bar_magnifier = true)``. The argument is a const
+        bool; one that is not a literal cannot be read here, so the TU does
+        not declare the magnifier and the codegen warns."""
+        from ..ast_nodes import BoolLiteral, StrategyDecl
+        for node in self._walk_ast(self.ctx.ast):
+            if not isinstance(node, StrategyDecl):
+                continue
+            value = node.kwargs.get("use_bar_magnifier")
+            if value is None or isinstance(value, BoolLiteral):
+                return value is not None and value.value is True
+            self._codegen_warning(
+                value,
+                "strategy(use_bar_magnifier=...) is not a literal bool: the "
+                "generated strategy does not declare the bar magnifier, so a host "
+                "runs it without one.",
+                hint="Write use_bar_magnifier = true or false.")
+            return False
+        return False
+
     def _emit_udt_method_cpp_name(self, fi: FuncInfo) -> str:
         """Stable C++ identifier for a typed instance method."""
         receiver_spec = (
@@ -1399,6 +1997,22 @@ class TopLevelEmitter:
 
     def _emit_func_def(self, fi: FuncInfo, lines: list[str], call_site_idx: int | None = None,
                        instance: dict | None = None) -> None:
+        """Emit a user-defined function as a class method, under v5's rules
+        when it was inlined from a v5 library (``library_v5``)."""
+        node = fi.node
+        previous = self._pine_v5_body
+        self._pine_v5_body = (
+            node is not None
+            and (getattr(node, "annotations", None) or {}).get("pine_version") == 5
+        )
+        try:
+            self._emit_func_def_body(fi, lines, call_site_idx, instance)
+        finally:
+            self._pine_v5_body = previous
+
+    def _emit_func_def_body(self, fi: FuncInfo, lines: list[str],
+                            call_site_idx: int | None = None,
+                            instance: dict | None = None) -> None:
         """Emit a user-defined function as a class method.
 
         If call_site_idx is not None, emit a per-call-site variant with
@@ -1412,6 +2026,12 @@ class TopLevelEmitter:
         node = fi.node
         if node is None:
             return
+        # The written call whose argument types type this emission: the
+        # variant's own, or the one a fresh nested instance runs.
+        type_call_site_idx = (
+            call_site_idx if call_site_idx is not None
+            else (instance or {}).get("type_call_site_idx")
+        )
 
         # Collection registries historically used raw variable names for the
         # whole translation unit.  Emit each callable against copy-on-write
@@ -1465,9 +2085,9 @@ class TopLevelEmitter:
         )
         variant_param_types = (
             getattr(self.ctx, "func_callsite_param_types", {}).get(
-                (fi.name, call_site_idx), ()
+                (fi.name, type_call_site_idx), ()
             )
-            if call_site_idx is not None
+            if type_call_site_idx is not None
             else ()
         )
         for i, p in enumerate(node.params):
@@ -1576,7 +2196,7 @@ class TopLevelEmitter:
                     PineType.FLOAT: "double",
                     PineType.BOOL: "bool",
                     PineType.STRING: "std::string",
-                    PineType.COLOR: "int",
+                    PineType.COLOR: "int64_t",
                 }[variant_pt]
             elif i < len(getattr(fi, "param_type_specs", [])) and fi.param_type_specs[i] is not None:
                 # Precise per-param TypeSpec (declared hint or call-site inference):
@@ -1585,7 +2205,8 @@ class TopLevelEmitter:
                 # a string -> ``std::string``. User UDT field mutation propagates
                 # through the arena even though the handle parameter is by value.
                 spec = fi.param_type_specs[i]
-                cpp_t = self._type_spec_to_cpp(spec)
+                cpp_t = self._wide_declared_int_param(
+                    fi, i, self._type_spec_to_cpp(spec))
                 if spec.kind == "udt":
                     self._udt_param_udt[p] = spec.name
                     self._udt_param_udt[self._safe_name(p)] = spec.name
@@ -1600,7 +2221,8 @@ class TopLevelEmitter:
                         cpp_t = f"{cpp_t}&"
             elif i < len(fi.param_types):
                 pt = fi.param_types[i]
-                cpp_t = PINE_TYPE_TO_CPP.get(pt, "double")
+                cpp_t = self._wide_declared_int_param(
+                    fi, i, PINE_TYPE_TO_CPP.get(pt, "double"))
             else:
                 cpp_t = "double"
             param_strs.append(f"{cpp_t} {self._safe_name(p)}")
@@ -1614,14 +2236,27 @@ class TopLevelEmitter:
         # without it the function would be emitted as returning ``double`` and
         # clang errors with "no viable conversion from T to double". Probe:
         # data/validation/udt-method-probe-20-udt-return-from-func.
-        if fi.returns_tuple:
+        return_udt_name = getattr(fi, "udt_return_type", None)
+        return_udt = bool(return_udt_name and return_udt_name in self._udt_defs)
+        request_struct = self._security_helper_request_struct(node)
+        if request_struct is not None:
+            # A helper whose value is a request of a TA tuple
+            # (``request.security(..., ta.macd(...))``) returns the request's
+            # stored result struct, which ``[m, s, h] = htf()`` decomposes.
+            ret_type = request_struct
+        elif fi.returns_tuple:
             # Infer actual tuple element types from function body's last expression
             tuple_types_list = self._infer_tuple_types(node, fi.tuple_element_count)
             ret_type = f"std::tuple<{', '.join(tuple_types_list)}>"
-        elif getattr(fi, "udt_return_type", None):
+        elif return_udt_name:
             # A function returning a drawing handle must emit the C++ handle
             # struct (Line/Box/Label/Linefill), not the unknown lowercase name.
-            ret_type = DRAWING_TYPE_TO_CPP.get(fi.udt_return_type, fi.udt_return_type)
+            ret_type = DRAWING_TYPE_TO_CPP.get(
+                return_udt_name,
+                self._safe_name(return_udt_name)
+                if return_udt
+                else return_udt_name,
+            )
         elif self._func_int_return_uses_wide_history(
             fi, call_site_idx=call_site_idx
         ):
@@ -1629,14 +2264,14 @@ class TopLevelEmitter:
             # values and their na sentinel cannot narrow at the return edge.
             ret_type = "int64_t"
         elif (
-            call_site_idx is not None
+            type_call_site_idx is not None
             and self._callsite_callable_return_pine_type(
-                fi, call_site_idx
+                fi, type_call_site_idx
             ) != PineType.UNKNOWN
         ):
             ret_type = PINE_TYPE_TO_CPP.get(
                 self._callsite_callable_return_pine_type(
-                    fi, call_site_idx
+                    fi, type_call_site_idx
                 ),
                 "double",
             )
@@ -1646,13 +2281,16 @@ class TopLevelEmitter:
             ret_type = self._type_spec_to_cpp(fi.return_type_spec)
         else:
             ret_type = PINE_TYPE_TO_CPP.get(fi.return_type, "double")
-        rhs_return_cpp_type = (
-            ret_type
-            if (self._is_nullable_collection_cpp_type(ret_type)
-                or ret_type in DRAWING_TYPE_TO_CPP.values()
-                or ret_type in self._udt_defs)
-            else None
-        )
+        if return_udt:
+            # Keep the authored UDT spelling here for target typing; the
+            # expression visitor converts it to the escaped C++ handle name
+            # at the point it emits ``T{}``.
+            rhs_return_cpp_type = return_udt_name
+        elif (self._is_nullable_collection_cpp_type(ret_type)
+              or ret_type in DRAWING_TYPE_TO_CPP.values()):
+            rhs_return_cpp_type = ret_type
+        else:
+            rhs_return_cpp_type = None
 
         # For per-call-site variants, suffix the function name and activate TA + var remapping
         func_name = (
@@ -1749,22 +2387,45 @@ class TopLevelEmitter:
         self._current_func_locals |= self._collect_binding_names(node.body)
 
         lines.append(f"    {ret_type} {func_name}({', '.join(param_strs)}) {{")
+        self._emit_function_global_history_updates(fi, lines)
+
+        # A session.* flag the body reads at an offset: its history is this
+        # call site's calls, so push the flag once per call, before a lazy
+        # operand or a block can skip the read (TradingView's function tape,
+        # tests/test_e2e_session_history.py).
+        for flag in sorted(self._session_call_flags.get(fi.name, ())):
+            member = self._inline_history_member_by_key.get(
+                ("session_call", fi.name, flag, self._current_instance_name))
+            if member is not None:
+                value = self._visit_expr(MemberAccess(object=Identifier(name="session"),
+                                                      member=flag))
+                self._emit_history_series_write(lines, "        ", member, value)
 
         emitted_return = False
+        # A pure call read at an offset below a lazy edge runs once per call
+        # of this function, before its statement (``ta.py``).
+        hoisted: list[int] = []
         if node.is_single_expr and node.body:
+            hoisted = self._emit_lazy_call_history_hoists(node.body[0], lines, indent=2)
             expr = node.body[0].expr if isinstance(node.body[0], ExprStmt) else None
             if expr and self._call_is_void(expr):
                 # void setter as the sole body expr — emit as statement, fall
                 # through to the default return.
                 self._visit_stmt(node.body[0], lines, indent=2)
             elif expr:
-                lines.append(
-                    "        return "
-                    f"{self._visit_rhs_value(expr, target_cpp_type=rhs_return_cpp_type)};"
+                ret_cpp = self._coerce_int_slot(
+                    self._visit_rhs_value(
+                        expr, target_cpp_type=rhs_return_cpp_type
+                    ),
+                    expr,
+                    self._int_slot_cpp_type(None, ret_type),
                 )
+                lines.append(f"        return {ret_cpp};")
                 emitted_return = True
         else:
             for i, s in enumerate(node.body):
+                self._clear_lazy_call_history_hoists(hoisted)
+                hoisted = self._emit_lazy_call_history_hoists(s, lines, indent=2)
                 if i == len(node.body) - 1 and isinstance(s, ExprStmt):
                     # A void drawing setter / delete / visual-noop, or a dropped
                     # table/polyline method call (``panel.cell(...)``), used as
@@ -1775,10 +2436,14 @@ class TopLevelEmitter:
                     if self._call_is_void(s.expr) or self._is_skip_expr(s.expr):
                         self._visit_stmt(s, lines, indent=2)
                     else:
-                        lines.append(
-                            "        return "
-                            f"{self._visit_rhs_value(s.expr, target_cpp_type=rhs_return_cpp_type)};"
+                        ret_cpp = self._coerce_int_slot(
+                            self._visit_rhs_value(
+                                s.expr, target_cpp_type=rhs_return_cpp_type
+                            ),
+                            s.expr,
+                            self._int_slot_cpp_type(None, ret_type),
                         )
+                        lines.append(f"        return {ret_cpp};")
                         emitted_return = True
                 elif i == len(node.body) - 1 and isinstance(s, (SwitchStmt, IfStmt)):
                     # Switch/if as last statement = return expression in PineScript
@@ -1787,31 +2452,92 @@ class TopLevelEmitter:
                     # default (``Label _func_ret = Label{};``) — falling through
                     # to ``_default_for_type`` would emit ``0.0`` and clang would
                     # reject ``Label _func_ret = 0.0;``.
-                    if ret_type in self._udt_defs or ret_type in DRAWING_TYPE_TO_CPP.values():
+                    if return_udt or ret_type in DRAWING_TYPE_TO_CPP.values():
                         default_ret = f"{ret_type}{{}}"
+                    elif fi.returns_tuple:
+                        default_ret = self._tuple_default_expr(tuple_types_list)
                     else:
                         default_ret = self._default_for_type(ret_type)
                     lines.append(f"        {ret_type} _func_ret = {default_ret};")
-                    self._visit_if_switch_expr(
+                    self._visit_selection_value(
                         s,
                         "_func_ret",
                         lines,
                         indent=2,
-                        target_cpp_type=rhs_return_cpp_type,
+                        target_cpp_type=(
+                            rhs_return_cpp_type
+                            if rhs_return_cpp_type is not None
+                            else self._int_slot_cpp_type(None, ret_type)
+                        ),
+                        slot_cpp_type=None if fi.returns_tuple else ret_type,
                     )
-                    lines.append(f"        return _func_ret;")
+                    lines.append("        return _func_ret;")
+                    emitted_return = True
+                elif (i == len(node.body) - 1 and isinstance(s, TupleAssign)
+                        and fi.returns_tuple and "_" not in s.names):
+                    # ``[p, q] = pair(v)`` last returns the declared tuple.
+                    self._visit_stmt(s, lines, indent=2)
+                    declared = TupleLiteral(
+                        elements=[Identifier(name=name) for name in s.names]
+                    )
+                    declared.loc = s.loc
+                    for element in declared.elements:
+                        element.loc = s.loc
+                    lines.append(
+                        f"        return {self._visit_rhs_value(declared, target_cpp_type=rhs_return_cpp_type)};"
+                    )
+                    emitted_return = True
+                elif (i == len(node.body) - 1
+                        and self._statement_value_node(s) is not None
+                        and self._tail_value_fits(s, ret_type)):
+                    # ``_f := expr`` / ``y += v`` / ``b = a * 3`` last: the
+                    # function returns the value the statement leaves. It
+                    # used to fall through to the default return, so
+                    # cs-lev-tradleware's Gaussian filter was always 0.0.
+                    self._visit_stmt(s, lines, indent=2)
+                    value = self._statement_value_node(s)
+                    ret_cpp = self._coerce_int_slot(
+                        self._visit_rhs_value(
+                            value, target_cpp_type=rhs_return_cpp_type
+                        ),
+                        value,
+                        self._int_slot_cpp_type(None, ret_type),
+                    )
+                    lines.append(f"        return {ret_cpp};")
+                    emitted_return = True
+                elif (i == len(node.body) - 1
+                        and isinstance(s, (ForStmt, ForInStmt, WhileStmt))
+                        and not fi.returns_tuple
+                        and self._loop_value_cpp_type(s, ret_type) is not None):
+                    # A loop last: its body's last value on the last iteration
+                    # that reached it, na when none did.
+                    lines.append(
+                        f"        {ret_type} _func_ret = {self._na_value_for_type(ret_type)};"
+                    )
+                    self._emit_loop_with_assign(
+                        s,
+                        "_func_ret",
+                        lines,
+                        indent=2,
+                        target_cpp_type=ret_type,
+                        reset=False,
+                    )
+                    lines.append("        return _func_ret;")
                     emitted_return = True
                 else:
                     self._visit_stmt(s, lines, indent=2)
+        self._clear_lazy_call_history_hoists(hoisted)
 
         # Always emit a default return if no explicit return was emitted,
         # to avoid non-void function without return value.
         if not emitted_return:
-            if fi.returns_tuple:
+            if request_struct is not None:
+                lines.append(f"        return {request_struct}{{}};")
+            elif fi.returns_tuple:
                 default_vals = ", ".join(["0.0"] * fi.tuple_element_count)
                 lines.append(f"        return std::make_tuple({default_vals});")
             else:
-                if ret_type in self._udt_defs or ret_type in DRAWING_TYPE_TO_CPP.values():
+                if return_udt or ret_type in DRAWING_TYPE_TO_CPP.values():
                     default_ret = f"{ret_type}{{}}"
                 else:
                     default_ret = self._default_for_type(ret_type)
@@ -1844,13 +2570,42 @@ class TopLevelEmitter:
         self._active_call_site_idx = None
         self._current_instance_name = None
 
-    def _emit_precalculate_and_run(self, lines: list[str]) -> None:
-        has_static_ta = any(
+    def _emit_function_global_history_updates(
+            self, fi: FuncInfo, lines: list[str]) -> None:
+        """Record, on entry, each script variable the body reads through history.
+
+        The on_bar preamble has already advanced the call site's buffer by one
+        chart slot, holding the previous value; this call replaces that slot
+        with the value the call sees, so ``x[k]`` reads the site's latest call
+        at or before ``k`` bars ago (``na`` before its first call).
+        """
+        names = self.ctx.func_global_history_reads.get(fi.name, ())
+        first_read = {}
+        for owner, name, subscript in self.ctx.func_global_history_nodes.values():
+            if owner == fi.name:
+                first_read.setdefault(name, subscript.object)
+        cpp_types = {
+            info["member_name"]: info["cpp_type"]
+            for info in self._inline_history_members
+        }
+        for name in names:
+            member = self._function_global_history_member(name)
+            if member is None:
+                continue
+            value = self._series_bridge_value_expr(
+                self._visit_expr(first_read[name]), cpp_types[member]
+            )
+            lines.append(f"        {member}.update({value});")
+
+    def _has_precalculated_ta(self) -> bool:
+        return any(
             self._ta_site_uses_precalc(site)
             for _ti, site in enumerate(self.ctx.ta_call_sites)
             if _ti not in self._dead_ta_indices
         )
-        if not has_static_ta:
+
+    def _emit_precalculate_and_run(self, lines: list[str]) -> None:
+        if not self._has_precalculated_ta():
             return
 
         replayed_source_series: list[str] = []
@@ -1877,17 +2632,15 @@ class TopLevelEmitter:
             if self._ta_site_uses_precalc(site):
                 lines.append(f"        _precalc_{site.member_name}.resize(n);")
 
-        # Reset indicators to clean slate
+        # Reset indicators to clean slate, built with the arguments this run
+        # uses (an input override resizes the precalculated series too).
         lines.append("")
         for _ti, site in enumerate(self.ctx.ta_call_sites):
             if _ti in self._dead_ta_indices:
                 continue
             if self._ta_site_uses_precalc(site):
-                resolved = [self._resolve_ta_ctor_arg(a) for a in site.ctor_args]
-                safe_resolved = []
-                for r in resolved:
-                    safe_resolved.append(r if self._is_compile_time_value(r) else "1")
-                lines.append(f"        {site.member_name} = {site.class_name}({', '.join(safe_resolved)});")
+                run_args, _any_runtime = self._ta_run_ctor_args(site)
+                lines.append(f"        {site.member_name} = {site.class_name}({', '.join(run_args)});")
 
         # Clear series
         lines.append("")
@@ -1963,7 +2716,7 @@ class TopLevelEmitter:
             default = self._get_input_default(stmt.value)
             base = self._source_defval_to_base_series(default)
             title = self._get_input_title(stmt.value, var_name=stmt.name)
-            cpp_val = f'get_input_source("{title}", {base})[0]'
+            cpp_val = f'get_input_source({self._input_key_literal(title)}, {base})[0]'
             # A source var subscripted elsewhere in the script (e.g. ``src[1]``)
             # is declared ``Series<double>``, not a scalar double, mirroring
             # the normal per-bar path's ``{safe}.push({cpp_val})`` (see
@@ -2003,11 +2756,8 @@ class TopLevelEmitter:
             if _ti in self._dead_ta_indices:
                 continue
             if self._ta_site_uses_precalc(site):
-                resolved = [self._resolve_ta_ctor_arg(a) for a in site.ctor_args]
-                safe_resolved = []
-                for r in resolved:
-                    safe_resolved.append(r if self._is_compile_time_value(r) else "1")
-                lines.append(f"        {site.member_name} = {site.class_name}({', '.join(safe_resolved)});")
+                run_args, _any_runtime = self._ta_run_ctor_args(site)
+                lines.append(f"        {site.member_name} = {site.class_name}({', '.join(run_args)});")
 
         for field_name in sorted(self.ctx.series_bar_fields):
             lines.append(f"        _s_{field_name}.clear();")
@@ -2024,23 +2774,6 @@ class TopLevelEmitter:
         lines.append("    }")
         lines.append("")
 
-        # Overridden run methods
-        lines.append("    void run(const Bar* bars, int n) {")
-        lines.append("        precalculate(bars, n);")
-        lines.append("        BacktestEngine::run(bars, n);")
-        lines.append("    }")
-        lines.append("")
-        lines.append("    void run(const Bar* input_bars, int n_input,")
-        lines.append("             const std::string& input_tf,")
-        lines.append("             const std::string& script_tf,")
-        lines.append("             bool bar_magnifier = false,")
-        lines.append("             int magnifier_samples = 4,")
-        lines.append("             MagnifierDistribution magnifier_dist = MagnifierDistribution::ENDPOINTS) {")
-        lines.append("        bool needs_dynamic = bar_magnifier || !input_tf.empty() || !script_tf.empty();")
-        lines.append("        if (needs_dynamic) {")
-        lines.append("            _use_precalc = false;")
-        lines.append("        } else {")
-        lines.append("            precalculate(input_bars, n_input);")
-        lines.append("        }")
-        lines.append("        BacktestEngine::run(input_bars, n_input, input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist);")
-        lines.append("    }")
+        # All run overloads are inherited. The base-owned lifecycle hook resets
+        # generated state before preparing this run's cache, including calls
+        # entered through stream_begin rather than the generated C wrappers.