@pineforge/codegen-pyodide 0.10.0 → 0.10.2

package/pineforge_codegen/codegen/emit_top.py

@@ -59,7 +59,6 @@ State written by ``_emit_func_def`` (the per-function emit context):
 - ``self._current_func_locals`` (``set[str]``).
 - ``self._active_ta_remap`` (``dict[str, str]``).
 - ``self._active_var_remap`` (``dict[str, str]``).
-- ``self._in_ta_func_variant`` (``bool``).
 - ``self._active_call_site_idx`` (``int | None``).
 
 Sibling-mixin methods consumed via ``self``:
@@ -87,7 +86,7 @@ from ..ast_nodes import (
     ExprStmt, FuncCall, Identifier, IfStmt, SwitchStmt, VarDecl,
 )
 from ..analyzer import FuncInfo
-from ..symbols import TypeSpec
+from ..symbols import PineType, method_receiver_cpp_token
 from .tables import (
     BAR_SERIES_PUSH,
     DRAWING_TYPE_TO_CPP,
@@ -110,6 +109,8 @@ class TopLevelEmitter:
         lines.append('#include <pineforge/math.hpp>')
         lines.append('#include <pineforge/series.hpp>')
         lines.append('#include <pineforge/na.hpp>')
+        if getattr(self, "_uses_map", False):
+            lines.append('#include <pineforge/map.hpp>')
         lines.append("#include <cstdint>")
         lines.append("#include <cmath>")
         lines.append("#include <algorithm>")
@@ -117,9 +118,16 @@ class TopLevelEmitter:
         lines.append("#include <numeric>")
         lines.append("#include <string>")
         lines.append("#include <vector>")
+        if getattr(self, "_udt_defs", {}):
+            lines.append("#include <deque>")
+            lines.append("#include <functional>")
+            lines.append("#include <limits>")
         lines.append("#include <tuple>")
         lines.append("#include <optional>")
         lines.append("#include <type_traits>")
+        if getattr(self, "_udt_defs", {}):
+            lines.append("#include <stdexcept>")
+            lines.append("#include <utility>")
         lines.append("#include <memory>")
         lines.append("#include <mutex>")
         lines.append("#include <unordered_map>")
@@ -136,8 +144,7 @@ class TopLevelEmitter:
             # is present in the TU. Float matrices route through PineMatrix in
             # matrix.hpp; pulling in the generic header otherwise is a wasted
             # include.
-            float_spec = TypeSpec.primitive("float")
-            if any(spec.element != float_spec for spec in self._matrix_specs.values()):
+            if self._detect_generic_matrix_usage():
                 lines.append('#include <pineforge/generic_matrix.hpp>')
         # Drawing-objects-as-data runtime (line/box/label/linefill arenas +
         # ChartPoint). Gated on _uses_drawing so non-drawing strategies stay
@@ -277,26 +284,272 @@ class TopLevelEmitter:
             members.append(name)
         return members
 
+    def _emit_handle_checkpoint_traits(self, lines: list[str]) -> None:
+        """Emit recursive rollback adapters for shared-ID collection state.
+
+        This support block is emitted for scripts using a shared-ID map/matrix
+        or an authored UDT arena. The primary trait retains the historical
+        value-copy checkpoint for ordinary runtime state; specialized map,
+        matrix, vector, UDT-record, and arena traits snapshot their owned state
+        without recursively following nested UDT handle graphs.
+        """
+        checkpoint_traits = self._checkpoint_traits_cpp_type()
+        lines.extend([
+            "template <typename _PFValue>",
+            f"struct {checkpoint_traits} {{",
+            "    using snapshot_type = _PFValue;",
+            "    static snapshot_type take(const _PFValue& value) { return value; }",
+            "    static void restore(_PFValue& value, const snapshot_type& snapshot) {",
+            "        value = snapshot;",
+            "    }",
+            "};",
+            "",
+        ])
+
+        if getattr(self, "_udt_defs", {}):
+            coordinator_type = self._udt_undo_coordinator_cpp_name
+            lines.extend([
+                "template <>",
+                f"struct {checkpoint_traits}<{coordinator_type}> {{",
+                f"    using coordinator_type = {coordinator_type};",
+                "    using snapshot_type = typename coordinator_type::Snapshot;",
+                "    static snapshot_type take(coordinator_type& value) {",
+                "        return value.snapshot();",
+                "    }",
+                "    static void restore(coordinator_type& value,",
+                "                        const snapshot_type& snapshot) {",
+                "        value.restore(snapshot);",
+                "    }",
+                "};",
+                "",
+            ])
+
+        if getattr(self, "_uses_map", False):
+            lines.extend([
+            "template <typename _PFKey, typename _PFValue>",
+            f"struct {checkpoint_traits}<PineMap<_PFKey, _PFValue>> {{",
+            "    using map_type = PineMap<_PFKey, _PFValue>;",
+            "    static_assert(map_type::snapshot_supported,",
+            '                  "generated map checkpoints require primitive map values");',
+            "    using snapshot_type = std::optional<typename map_type::Snapshot>;",
+            "    static snapshot_type take(const map_type& value) {",
+            "        if (value.is_na()) return std::nullopt;",
+            "        return value.snapshot();",
+            "    }",
+            "    static void restore(map_type& value, const snapshot_type& snapshot) {",
+            "        if (!snapshot) {",
+            "            value = map_type{};",
+            "            return;",
+            "        }",
+            "        value.restore(*snapshot);",
+            "    }",
+            "};",
+            "",
+            ])
+
+        if getattr(self, "_uses_matrix", False):
+            lines.extend([
+                "template <>",
+                f"struct {checkpoint_traits}<PineMatrix> {{",
+                "    using matrix_type = PineMatrix;",
+                "    using snapshot_type = std::optional<typename matrix_type::Snapshot>;",
+                "    static snapshot_type take(const matrix_type& value) {",
+                "        if (value.is_na()) return std::nullopt;",
+                "        return value.snapshot();",
+                "    }",
+                "    static void restore(matrix_type& value, const snapshot_type& snapshot) {",
+                "        if (!snapshot) {",
+                "            value = matrix_type{};",
+                "            return;",
+                "        }",
+                "        value.restore(*snapshot);",
+                "    }",
+                "};",
+                "",
+            ])
+
+            if self._detect_generic_matrix_usage():
+                lines.extend([
+                    "template <typename _PFElement>",
+                    f"struct {checkpoint_traits}<PineGenericMatrix<_PFElement>> {{",
+                    "    using matrix_type = PineGenericMatrix<_PFElement>;",
+                    f"    using element_traits = {checkpoint_traits}<_PFElement>;",
+                    "    using element_snapshot = typename element_traits::snapshot_type;",
+                    "    struct active_snapshot {",
+                    "        typename matrix_type::Snapshot outer;",
+                    "        int rows;",
+                    "        int columns;",
+                    "        std::vector<element_snapshot> elements;",
+                    "    };",
+                    "    using snapshot_type = std::optional<active_snapshot>;",
+                    "    static snapshot_type take(const matrix_type& value) {",
+                    "        if (value.is_na()) return std::nullopt;",
+                    "        active_snapshot snapshot{value.snapshot(), value.rows(),",
+                    "                                 value.columns(), {}};",
+                    "        snapshot.elements.reserve(",
+                    "            static_cast<std::size_t>(snapshot.rows) *",
+                    "            static_cast<std::size_t>(snapshot.columns));",
+                    "        for (int row = 0; row < snapshot.rows; ++row) {",
+                    "            for (int column = 0; column < snapshot.columns; ++column) {",
+                    "                snapshot.elements.push_back(",
+                    "                    element_traits::take(value.get(row, column)));",
+                    "            }",
+                    "        }",
+                    "        return snapshot;",
+                    "    }",
+                    "    static void restore(matrix_type& value, const snapshot_type& snapshot) {",
+                    "        if (!snapshot) {",
+                    "            value = matrix_type{};",
+                    "            return;",
+                    "        }",
+                    "        value.restore(snapshot->outer);",
+                    "        std::size_t index = 0;",
+                    "        for (int row = 0; row < snapshot->rows; ++row) {",
+                    "            for (int column = 0; column < snapshot->columns; ++column) {",
+                    "                _PFElement element = value.get(row, column);",
+                    "                element_traits::restore(element, snapshot->elements[index++]);",
+                    "                value.set(row, column, element);",
+                    "            }",
+                    "        }",
+                    "    }",
+                    "};",
+                    "",
+                ])
+
+        lines.extend([
+            "template <typename _PFElement, typename _PFAllocator>",
+            f"struct {checkpoint_traits}<std::vector<_PFElement, _PFAllocator>> {{",
+            f"    using element_traits = {checkpoint_traits}<_PFElement>;",
+            "    using element_snapshot = typename element_traits::snapshot_type;",
+            "    using snapshot_type = std::vector<element_snapshot>;",
+            "    static snapshot_type take(",
+            "            const std::vector<_PFElement, _PFAllocator>& value) {",
+            "        snapshot_type snapshot;",
+            "        snapshot.reserve(value.size());",
+            "        for (std::size_t index = 0; index < value.size(); ++index) {",
+            "            const _PFElement element = value[index];",
+            "            snapshot.push_back(element_traits::take(element));",
+            "        }",
+            "        return snapshot;",
+            "    }",
+            "    static void restore(",
+            "            std::vector<_PFElement, _PFAllocator>& value,",
+            "            const snapshot_type& snapshot) {",
+            "        value.clear();",
+            "        value.reserve(snapshot.size());",
+            "        for (const auto& element_snapshot_value : snapshot) {",
+            "            _PFElement element{};",
+            "            element_traits::restore(element, element_snapshot_value);",
+            "            value.push_back(element);",
+            "        }",
+            "    }",
+            "};",
+            "",
+        ])
+
+        # 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;
+        # each arena snapshots every owned record exactly once. Shared-ID map
+        # and matrix fields still enter their specialized recursive traits.
+        for type_name, fields in self._udt_defs.items():
+            record_type = self._udt_record_cpp_type(type_name)
+            emitted_fields = [
+                field
+                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]
+            lines.append("template <>")
+            lines.append(f"struct {checkpoint_traits}<{record_type}> {{")
+            lines.append("    struct snapshot_type {")
+            for index, field_name in enumerate(checkpoint_fields):
+                lines.append(
+                    f"        {checkpoint_traits}<"
+                    f"decltype({record_type}::{field_name})>::snapshot_type "
+                    f"_pf_field_{index};"
+                )
+            lines.append("    };")
+            lines.append(
+                f"    static snapshot_type take(const {record_type}& value) {{"
+            )
+            lines.append("        return snapshot_type{")
+            for field_name in checkpoint_fields:
+                lines.append(
+                    f"            {checkpoint_traits}<"
+                    f"decltype({record_type}::{field_name})>::take(value.{field_name}),"
+                )
+            lines.append("        };")
+            lines.append("    }")
+            lines.append(
+                f"    static void restore({record_type}& value, "
+                "const snapshot_type& snapshot) {"
+            )
+            for index, field_name in enumerate(checkpoint_fields):
+                lines.append(
+                    f"        {checkpoint_traits}<"
+                    f"decltype({record_type}::{field_name})>::restore("
+                    f"value.{field_name}, snapshot._pf_field_{index});"
+                )
+            lines.append("    }")
+            lines.append("};")
+            lines.append("")
+
+            arena_type = self._udt_arena_cpp_type(type_name)
+            lines.append("template <>")
+            lines.append(f"struct {checkpoint_traits}<{arena_type}> {{")
+            lines.append(
+                f"    using arena_type = {arena_type};"
+            )
+            lines.append(
+                "    using snapshot_type = typename arena_type::Snapshot;"
+            )
+            lines.append("    static snapshot_type take(arena_type& value) {")
+            lines.append("        return value.snapshot();")
+            lines.append("    }")
+            lines.append(
+                "    static void restore(arena_type& value, const snapshot_type& snapshot) {"
+            )
+            lines.append("        value.restore(snapshot);")
+            lines.append("    }")
+            lines.append("};")
+            lines.append("")
+
     def _emit_script_state_hooks(self, lines: list[str], members: list[str]) -> None:
         """Emit the engine's Pine rollback checkpoint hook implementation.
 
-        The checkpoint owns value copies of all generated mutable state.  Every
-        runtime container used by generated code (Series, std::vector/map,
-        PineMatrix/generic matrices, UDTs and drawing arenas) has value
-        semantics, so copying recursively preserves data without retaining
-        pointers into live state.  Drawing handles themselves are stable ids;
-        their arenas are captured in the same checkpoint.
+        The checkpoint owns detached snapshots of all generated mutable state.
+        Shared-ID maps and matrices retain their original backing identity so
+        rollback updates every alias. Generated UDT arenas snapshot each owned
+        record once; nested UDT/map/matrix fields therefore restore through
+        their numeric/shared IDs without recursively walking object graphs.
+        Vectors snapshot their elements, including UDT handle values. Drawing
+        handles themselves are stable ids and their arenas are captured in the
+        same checkpoint.
 
         The static assertions deliberately turn any future non-copyable member
         into a compile failure instead of a nominal, shallow rollback.  Engine
         broker/order state lives in the base class and is intentionally absent:
         fills must survive while Pine script variables roll back.
         """
+        checkpoint_traits = self._checkpoint_traits_cpp_type()
+        handle_aware = bool(
+            getattr(self, "_uses_map", False)
+            or getattr(self, "_uses_matrix", False)
+            or getattr(self, "_udt_defs", {})
+        )
         lines.append("    struct _PFScriptState {")
         for idx, name in enumerate(members):
-            lines.append(
-                f"        decltype(GeneratedStrategy::{name}) _pf_value_{idx};"
-            )
+            if handle_aware:
+                lines.append(
+                    f"        {checkpoint_traits}<"
+                    f"decltype(GeneratedStrategy::{name})>::snapshot_type "
+                    f"_pf_value_{idx};"
+                )
+            else:
+                lines.append(
+                    f"        decltype(GeneratedStrategy::{name}) _pf_value_{idx};"
+                )
         lines.append("    };")
         lines.append(
             "    static_assert(std::is_copy_constructible_v<_PFScriptState>, "
@@ -311,16 +564,29 @@ class TopLevelEmitter:
         lines.append("    void snapshot_script_state() override {")
         lines.append("        _pf_script_state_checkpoint_.emplace(_PFScriptState{")
         for name in members:
-            lines.append(f"            {name},")
+            if handle_aware:
+                lines.append(
+                    f"            {checkpoint_traits}<"
+                    f"decltype(GeneratedStrategy::{name})>::take({name}),"
+                )
+            else:
+                lines.append(f"            {name},")
         lines.append("        });")
         lines.append("    }")
         lines.append("")
         lines.append("    void restore_script_state() override {")
         lines.append("        if (!_pf_script_state_checkpoint_) return;")
         for idx, name in enumerate(members):
-            lines.append(
-                f"        this->{name} = _pf_script_state_checkpoint_->_pf_value_{idx};"
-            )
+            if handle_aware:
+                lines.append(
+                    f"        {checkpoint_traits}<"
+                    f"decltype(GeneratedStrategy::{name})>::restore("
+                    f"this->{name}, _pf_script_state_checkpoint_->_pf_value_{idx});"
+                )
+            else:
+                lines.append(
+                    f"        this->{name} = _pf_script_state_checkpoint_->_pf_value_{idx};"
+                )
         lines.append("    }")
         lines.append("")
         lines.append("    void commit_script_state() override {")
@@ -361,9 +627,20 @@ class TopLevelEmitter:
                 # incl. function-derived lengths) are safe: the `!_ta_initialized_`
                 # reset overwrites the placeholder before the first compute.
                 for a in site.ctor_args:
-                    r = self._resolve_known(a)
+                    r = self._resolve_ta_ctor_arg(a)
                     if (not self._is_compile_time_value(r)
                             and self._runtime_ctor_arg_for_reset(a) is None):
+                        # A TA source reached through request.security can have
+                        # several helper-bound constructor variants. Validate
+                        # only variants of this exact source node before the
+                        # ordinary guard fires, so an unstable requested-context
+                        # expression keeps its provenance-specific diagnostic
+                        # without allowing a later, unrelated security error to
+                        # reorder an earlier ordinary error.
+                        if self._security_eval_info and site.node is not None:
+                            self._collect_ta_runtime_resets(
+                                security_source_node=site.node
+                            )
                         self._codegen_error(
                             getattr(site, "node", None),
                             f"Unsupported TA constructor length '{a}' for "
@@ -373,7 +650,7 @@ class TopLevelEmitter:
                             hint=("Use a literal, an input.*() value, or "
                                   "arithmetic over those for TA lengths."),
                         )
-                resolved = [self._resolve_known(a) for a in site.ctor_args]
+                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 = []
@@ -389,11 +666,18 @@ class TopLevelEmitter:
                 site = self.ctx.ta_call_sites[idx]
                 if not site.ctor_args:
                     continue
-                resolved = [self._resolve_known(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")
                 for variant in variants:
+                    ctor_args, _ctor_arg_stability = self._security_ta_ctor_args_for_variant(
+                        info["sec_id"],
+                        site,
+                        variant.get("binding_stack", ()),
+                    )
+                    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"
+                        )
                     init_parts.append(f"{variant['member_name']}({', '.join(safe_resolved)})")
 
         # Non-series var members with compile-time init (deduplicate by name)
@@ -403,27 +687,39 @@ class TopLevelEmitter:
                 continue
             seen_ctor_vars.add(name)
             safe = self._safe_name(name)
-            if name in self._array_vars or name in self._map_vars:
+            if (name in self._array_vars
+                    or name in self._map_vars
+                    or name in self._matrix_specs):
+                # Collection members are initialized in the first-bar block.
+                # A matrix declared as ``var matrix<T> x = na`` has no
+                # constructor call to replay there and its default constructor
+                # is already the correctly typed null ID.  Letting the generic
+                # scalar path add ``x(na<double>())`` is ill-typed.
                 continue
-            # Function-scoped ``var`` members are initialized once-per-variant
-            # on first call (see _emit_func_var_init_block); exclude them from
-            # the constructor so they are not double-initialized and so their
-            # (possibly bar-dependent) initializer is lowered in the function's
-            # own scope (with its active var remap for clones).
+            # Callable-scoped ``var`` members initialize at their exact source
+            # declarations; exclude them from the constructor so source order,
+            # first reach, and the active clone remap remain authoritative.
             if name in getattr(self, "_func_local_var_names", ()):
                 continue
+            # Runtime primitive initializers execute at their Pine declaration
+            # site under a per-member once flag.  This preserves source-order
+            # dependencies and first-entry semantics for conditional blocks.
+            if name in self._runtime_scalar_var_init_members:
+                continue
             # UDT-typed var members (``var SDZone z = na``) default-construct to
             # na via the struct's in-class ``__pf_na = true``; a ctor init like
             # ``z(na<double>())`` would not type-match the struct member.
-            if name in self._udt_var_types and self._udt_var_types[name] in self._udt_defs:
+            member_udt_type = self._member_udt_type(name)
+            if member_udt_type in self._udt_defs:
                 continue
             # Drawing handle var member (L-N3): ``var line x`` / ``var box b``
             # default-construct to {-1} (na). A ``b(na<double>())`` ctor init
             # would not type-match the handle struct — skip it (the in-class
             # member default is the once-only persistent na init).
-            if name in self._udt_var_types and self._udt_var_types[name] in DRAWING_TYPE_TO_CPP:
+            if (name in self._drawing_var_member_cpp_types
+                    or member_udt_type in DRAWING_TYPE_TO_CPP):
                 continue
-            if name not in self.ctx.series_vars:
+            if safe not in self._series_var_member_names:
                 cpp_val = self._resolve_known(init_expr)
                 cpp_val = self._typed_na_init(cpp_val, name, ptype)
                 if self._is_compile_time_value(cpp_val):
@@ -608,8 +904,37 @@ class TopLevelEmitter:
         lines.append(f"{pad}else {member}.update({value});")
 
     def _emit_on_bar(self, lines: list[str]) -> None:
+        self._lexical_drawing_types = {}
+        self._lexical_udt_types = {}
+        self._lexical_series_bindings = {}
+        self._lexical_known_var_tombstones = set()
         lines.append("    void on_bar(const Bar& bar) override {")
 
+        # A GeneratedStrategy handle may execute multiple batch runs or
+        # streaming lifecycles. BacktestEngine resets broker/base state, but
+        # generated members survive. Reset source-shaped lazy ROC clocks and
+        # their forced eager-fallback close history at the first genuine slot
+        # of each lifecycle. This lives in on_bar rather than a generated run
+        # wrapper because stream_begin() enters the base run path directly.
+        # COOF post-close recalculations have history_advances_new_bar()==false
+        # and therefore preserve the current committed clock/base.
+        if self._lazy_saturated_roc3_clock_by_node:
+            lines.append(
+                "        if (history_advances_new_bar() && bar_index_ == 0) {"
+            )
+            for clock_name in self._lazy_saturated_roc3_clock_by_node.values():
+                lines.append(f"            {clock_name}.reset();")
+            lines.append(
+                f"            {self._lazy_saturated_roc3_history_name}.clear();"
+            )
+            lines.append("        }")
+            self._emit_history_series_write(
+                lines,
+                "        ",
+                self._lazy_saturated_roc3_history_name,
+                "current_bar_.close",
+            )
+
         # reset_run_state() owns engine/broker state, while these generated
         # Series members belong to the strategy object. Clear all of them on
         # the first genuine history slot of bar zero, unconditionally: a site
@@ -624,6 +949,21 @@ class TopLevelEmitter:
                 f"{info['member_name']}.clear();"
             )
 
+        # A history-reading plain-UDF parameter advances on the chart clock,
+        # even when lazy control flow skips its written call on this bar.  Seed
+        # the new slot with the prior current value (``na`` before first reach);
+        # an executed call later in the bar updates this same slot with its
+        # scalar actual.  Typed-method ``series_arg`` bridges intentionally keep
+        # their existing execution-clock behavior.
+        for info in self._inline_history_members:
+            if info["kind"] != "udf_series_arg":
+                continue
+            member = info["member_name"]
+            lines.append(
+                f"        if (history_advances_new_bar()) "
+                f"{member}.push({member}.current());"
+            )
+
         # a. Push bar field series (with bar magnifier support)
         for field_name in sorted(self.ctx.series_bar_fields):
             push_expr = BAR_SERIES_PUSH.get(field_name, f"current_bar_.{field_name}")
@@ -659,11 +999,36 @@ class TopLevelEmitter:
         if self.ctx.var_members:
             lines.append("        if (!_var_initialized) {")
             for name, ptype, init_expr in self.ctx.var_members:
-                # Function-scoped ``var`` members are init'd once-per-variant
-                # on first call (see _emit_func_var_init_block), not here.
+                # Callable-scoped ``var`` members initialize at their exact
+                # declaration statements, not in the global on_bar preamble.
                 if name in getattr(self, "_func_local_var_names", ()):
                     continue
                 safe = self._safe_name(name)
+                runtime_info = self._runtime_scalar_var_init_by_member.get(name)
+                if (runtime_info is not None
+                        and runtime_info.get("drawing_cpp") is not None):
+                    if runtime_info.get("is_series"):
+                        self._emit_history_series_write(
+                            lines,
+                            "            ",
+                            safe,
+                            f"{runtime_info['drawing_cpp']}{{}}",
+                        )
+                    continue
+                # Declaration-site initialization owns nullable collection
+                # members carrying runtime metadata. A persistent map/matrix
+                # if/switch initializer must not also enter the legacy
+                # first-bar aggregate preamble (which cannot lower a block
+                # expression and formerly emitted ``/* unknown */`` for maps).
+                # Keep primitive and ternary paths on their established order.
+                runtime_spec = (
+                    runtime_info.get("type_spec")
+                    if runtime_info is not None
+                    else None
+                )
+                if (runtime_spec is not None
+                        and runtime_spec.kind in {"map", "matrix"}):
+                    continue
                 if name in self._array_vars:
                     for stmt in self.ctx.ast.body:
                         if isinstance(stmt, VarDecl) and stmt.name == name:
@@ -672,39 +1037,55 @@ class TopLevelEmitter:
                             break
                     continue
                 if name in self._matrix_specs:
-                    # Matrix vars: initialize with matrix.new expression
+                    # Matrix vars are nullable ID handles. Initialize from the
+                    # authored RHS in declaration order, not only from a
+                    # matrix.new(...) call: ``var matrix<int> alias = source``
+                    # must copy source's ID once, while a later local rebind
+                    # remains independent.
                     for stmt in self.ctx.ast.body:
-                        if isinstance(stmt, VarDecl) and stmt.name == name and isinstance(stmt.value, FuncCall):
-                            cpp_val = self._visit_expr(stmt.value)
+                        if isinstance(stmt, VarDecl) and stmt.name == name:
+                            cpp_val = self._visit_rhs_value(
+                                stmt.value,
+                                name,
+                                target_cpp_type=self._type_spec_to_cpp(
+                                    self._matrix_specs[name]
+                                ),
+                            )
                             lines.append(f"            {safe} = {cpp_val};")
                             break
                     continue
                 if name in self._map_vars:
                     for stmt in self.ctx.ast.body:
                         if isinstance(stmt, VarDecl) and stmt.name == name:
-                            cpp_val = self._visit_expr(stmt.value)
+                            cpp_val = self._visit_rhs_value(
+                                stmt.value,
+                                name,
+                                target_cpp_type=self._type_spec_to_cpp(
+                                    self._map_spec_for_name(name)
+                                ),
+                            )
                             lines.append(f"            {safe} = {cpp_val};")
                             break
                     continue
-                # UDT vars: init with constructor expression
-                init_s = str(init_expr)
-                is_udt_init = False
-                for udt_name in self._udt_defs:
-                    if init_s.startswith(f"{udt_name}.new"):
-                        # Find the actual AST node to generate the init expression
-                        for stmt in self.ctx.ast.body:
-                            if isinstance(stmt, VarDecl) and stmt.name == name and isinstance(stmt.value, FuncCall):
-                                cpp_val = self._visit_expr(stmt.value)
-                                lines.append(f"            {safe} = {cpp_val};")
-                                is_udt_init = True
-                                break
-                        if not is_udt_init:
-                            lines.append(f"            {safe} = {udt_name}{{}};")
-                            is_udt_init = True
-                        break
-                if is_udt_init:
+                if name in self._runtime_scalar_var_init_members:
                     continue
-                if name in self.ctx.series_vars:
+                # Persistent authored UDT variables initialize from their full
+                # source RHS, not only from ``Type.new``.  In particular,
+                # ``var Item alias = original`` must copy the numeric handle
+                # once and therefore alias the same arena record.
+                udt_name = self._member_udt_type(name)
+                if udt_name in self._udt_defs:
+                    for stmt in self.ctx.ast.body:
+                        if isinstance(stmt, VarDecl) and stmt.name == name:
+                            cpp_val = self._visit_rhs_value(
+                                stmt.value,
+                                name,
+                                target_cpp_type=udt_name,
+                            )
+                            lines.append(f"            {safe} = {cpp_val};")
+                            break
+                    continue
+                if self._binding_is_series(name, safe):
                     cpp_val = self._resolve_known(init_expr)
                     cpp_val = self._typed_na_init(cpp_val, name, ptype)
                     lines.append(f"            {safe}.push({cpp_val});")
@@ -722,9 +1103,26 @@ class TopLevelEmitter:
             lines.append("        } else {")
             for name, _, _ in self.ctx.var_members:
                 safe = self._safe_name(name)
+                runtime_info = self._runtime_scalar_var_init_by_member.get(name)
+                if (runtime_info is not None
+                        and runtime_info.get("drawing_cpp") is not None):
+                    if runtime_info.get("is_series"):
+                        lines.append(f"            if ({runtime_info['flag']}) {{")
+                        self._emit_history_series_write(
+                            lines, "                ", safe, f"{safe}[0]"
+                        )
+                        lines.append("            } else {")
+                        self._emit_history_series_write(
+                            lines,
+                            "                ",
+                            safe,
+                            f"{runtime_info['drawing_cpp']}{{}}",
+                        )
+                        lines.append("            }")
+                    continue
                 if name in self._array_vars:
                     continue
-                if name in self.ctx.series_vars:
+                if self._binding_is_series(name, safe):
                     self._emit_history_series_write(
                         lines, "            ", safe, f"{safe}[0]"
                     )
@@ -740,6 +1138,20 @@ class TopLevelEmitter:
                                 self._emit_history_series_write(
                                     lines, "            ", cloned, f"{cloned}[0]"
                                 )
+                    # Context-sensitive nested helper instances own fresh
+                    # Series members outside the flat cs remap table.  Advance
+                    # each exact fresh member once per bar as well; otherwise a
+                    # valid ``fresh[1]`` history read never moves past slot 0.
+                    for _owner, orig_safe, fresh_safe in self._fresh_var_members:
+                        if orig_safe != safe or fresh_safe in carry_emitted:
+                            continue
+                        carry_emitted.add(fresh_safe)
+                        self._emit_history_series_write(
+                            lines,
+                            "            ",
+                            fresh_safe,
+                            f"{fresh_safe}[0]",
+                        )
             lines.append("        }")
 
         # c. Push non-var series (they start fresh each bar with a push)
@@ -927,10 +1339,18 @@ class TopLevelEmitter:
         lines.append("")
 
     def _emit_udt_method_cpp_name(self, fi: FuncInfo) -> str:
-        """Stable C++ identifier for a UDT instance method (``_udt_Type_method``)."""
-        udt = fi.udt_type_name or ""
+        """Stable C++ identifier for a typed instance method."""
+        receiver_spec = (
+            fi.param_type_specs[0]
+            if getattr(fi, "param_type_specs", None)
+            else None
+        )
+        receiver = method_receiver_cpp_token(
+            receiver_spec,
+            fi.udt_type_name,
+        )
         base = fi.node.name if fi.node else ""
-        return self._func_safe_name(f"_udt_{udt}_{base}")
+        return self._func_safe_name(f"_udt_{receiver}_{base}")
 
     def _emit_func_def(self, fi: FuncInfo, lines: list[str], call_site_idx: int | None = None,
                        instance: dict | None = None) -> None:
@@ -948,51 +1368,191 @@ class TopLevelEmitter:
         if node is None:
             return
 
-        is_udt = bool(getattr(fi, "is_udt_method", False)) and fi.udt_type_name
+        # Collection registries historically used raw variable names for the
+        # whole translation unit.  Emit each callable against copy-on-write
+        # registries overlaid with its analyzer-captured lexical TypeSpecs, then
+        # restore the top-level state.  This keeps legacy readers working while
+        # preventing local declarations/method dispatch from contaminating a
+        # sibling UDF, UDT method, clone, or on_bar.
+        prev_func_collection_specs = self._current_func_collection_specs
+        prev_func_collection_shadows = self._current_func_collection_shadows
+        prev_collection_types = self._collection_types
+        prev_array_vars = self._array_vars
+        prev_map_vars = self._map_vars
+        prev_matrix_specs = self._matrix_specs
+        # Start from top-level state only. Callable locals become visible at
+        # their declaration statement (after its RHS), not at function entry:
+        # preloading the analyzer's final inventory would make a later local
+        # shadow an earlier read of a same-named global collection.
+        self._current_func_collection_specs = {}
+        self._current_func_collection_shadows = set()
+        self._collection_types = dict(prev_collection_types)
+        self._array_vars = set(prev_array_vars)
+        self._map_vars = set(prev_map_vars)
+        self._matrix_specs = dict(prev_matrix_specs)
+
+        is_method = (
+            bool(getattr(fi, "is_udt_method", False))
+            and fi.udt_type_name
+        )
 
         # Determine param types and set context for type inference inside body
         param_strs = []
         self._current_func_param_types = {}
         self._current_func_param_specs = {}
+        param_hints = (getattr(node, "annotations", None) or {}).get(
+            "param_type_hints", []
+        )
+        self._current_func_declared_param_names = {
+            alias
+            for i, param in enumerate(node.params)
+            if i < len(param_hints) and param_hints[i]
+            for alias in (param, self._safe_name(param))
+        }
         self._current_func_series_params = set()
+        self._current_func_series_param_types = {}
         self._udt_param_udt = {}
         func_sv = self.ctx.func_series_vars.get(fi.name, set())
+        declared_param_specs = list(
+            getattr(self.ctx, "func_declared_param_type_specs", {}).get(
+                fi.name, ()
+            )
+        )
+        variant_param_types = (
+            getattr(self.ctx, "func_callsite_param_types", {}).get(
+                (fi.name, call_site_idx), ()
+            )
+            if call_site_idx is not None
+            else ()
+        )
         for i, p in enumerate(node.params):
             spec = None
-            if is_udt and i == 0 and fi.udt_type_name:
-                # A method receiver whose type is a drawing primitive
-                # (egoigor's ``method slope(line ln)``) must emit ``Line&`` not
-                # the unknown ``line&``. Register _udt_param_udt so the body's
-                # getters dispatch through the §4.3 drawing path (L.6d / U.5).
-                recv_cpp = DRAWING_TYPE_TO_CPP.get(fi.udt_type_name, fi.udt_type_name)
-                cpp_t = f"{recv_cpp}&"
-                safe_p = self._safe_name(p)
-                self._udt_param_udt[safe_p] = fi.udt_type_name
-                self._udt_param_udt[p] = fi.udt_type_name
+            receiver_spec = None
+            if is_method and i == 0:
+                recv_spec = (
+                    fi.param_type_specs[i]
+                    if i < len(fi.param_type_specs)
+                    else None
+                )
+                receiver_spec = recv_spec
+
+            if (
+                receiver_spec is not None
+                and receiver_spec.kind == "primitive"
+                and p in func_sv
+            ):
+                # A primitive receiver used with history is a Series boundary,
+                # just like an ordinary history-bearing UDF parameter.
+                elem_cpp_t = self._series_param_element_cpp_type(
+                    fi, i, call_site_idx
+                )
+                cpp_t = f"const Series<{elem_cpp_t}>&"
+                spec = receiver_spec
+                self._current_func_series_params.add(p)
+                self._current_func_series_param_types[p] = elem_cpp_t
+                self._current_func_series_param_types[
+                    self._safe_name(p)
+                ] = elem_cpp_t
+            elif is_method and i == 0 and fi.udt_type_name:
+                # Receiver pass modes follow Pine's value/ID families. A user
+                # UDT is itself a numeric object-ID handle, so pass it by value:
+                # field mutation dereferences the same arena record while
+                # ``self := other`` remains a local handle rebind.
+                recv_spec = receiver_spec
+                if recv_spec is None:
+                    recv_spec = self._type_spec_from_hint_name(
+                        fi.udt_type_name
+                    )
+                spec = recv_spec
+                if recv_spec is not None:
+                    cpp_t = self._type_spec_to_cpp(recv_spec)
+                    if (
+                        recv_spec.kind in {"array", "matrix"}
+                        or (
+                            recv_spec.kind == "udt"
+                            and recv_spec.name not in self._udt_defs
+                        )
+                    ):
+                        cpp_t = f"{cpp_t}&"
+                    if recv_spec.kind == "udt" and recv_spec.name:
+                        safe_p = self._safe_name(p)
+                        self._udt_param_udt[safe_p] = recv_spec.name
+                        self._udt_param_udt[p] = recv_spec.name
+                else:
+                    # Compatibility for synthetic/legacy method records that
+                    # carry only the old receiver-name field.
+                    recv_cpp = DRAWING_TYPE_TO_CPP.get(
+                        fi.udt_type_name, fi.udt_type_name
+                    )
+                    cpp_t = (
+                        recv_cpp
+                        if fi.udt_type_name in self._udt_defs
+                        else f"{recv_cpp}&"
+                    )
+                    safe_p = self._safe_name(p)
+                    self._udt_param_udt[safe_p] = fi.udt_type_name
+                    self._udt_param_udt[p] = fi.udt_type_name
             elif fi.name == "isInSession" and i < 2:
                 cpp_t = "std::string"
             elif p in func_sv:
-                # This param uses history access (e.g. src[1]) — pass as Series
-                cpp_t = "const Series<double>&"
+                # This param uses history access (e.g. src[1]) — preserve its
+                # Pine scalar family instead of hard-coding Series<double>.
+                elem_cpp_t = self._series_param_element_cpp_type(
+                    fi, i, call_site_idx
+                )
+                cpp_t = f"const Series<{elem_cpp_t}>&"
                 self._current_func_series_params.add(p)
+                self._current_func_series_param_types[p] = elem_cpp_t
+                self._current_func_series_param_types[
+                    self._safe_name(p)
+                ] = elem_cpp_t
+                if (
+                    i < len(getattr(fi, "param_type_specs", []))
+                    and fi.param_type_specs[i] is not None
+                ):
+                    spec = fi.param_type_specs[i]
+            elif (
+                i >= len(declared_param_specs)
+                or declared_param_specs[i] is None
+            ) and i < len(variant_param_types) and variant_param_types[i] in {
+                PineType.INT,
+                PineType.FLOAT,
+                PineType.BOOL,
+                PineType.STRING,
+                PineType.COLOR,
+            }:
+                # Non-history untyped parameters are polymorphic too. A pure
+                # wrapper around a stateful helper is cloned per written call,
+                # so its scalar boundary must use that clone's actual family
+                # instead of the first call's shared FuncInfo inference.
+                variant_pt = variant_param_types[i]
+                cpp_t = {
+                    PineType.INT: "int64_t",
+                    PineType.FLOAT: "double",
+                    PineType.BOOL: "bool",
+                    PineType.STRING: "std::string",
+                    PineType.COLOR: "int",
+                }[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):
-                # ``pivot hi`` -> ``pivot&``, ``line ln`` -> ``Line&``, an untyped
-                # ``s`` used as a string -> ``std::string``. UDT / collection
-                # params pass by reference (Pine UDTs/arrays are reference types,
-                # so mutations propagate and member access compiles).
+                # ``pivot hi`` -> ``pivot`` numeric handle, ``line ln`` keeps its
+                # established drawing-handle route, and an untyped ``s`` used as
+                # 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)
                 if spec.kind == "udt":
                     self._udt_param_udt[p] = spec.name
                     self._udt_param_udt[self._safe_name(p)] = spec.name
-                    cpp_t = f"{cpp_t}&"
+                    if spec.name not in self._udt_defs:
+                        cpp_t = f"{cpp_t}&"
                 elif spec.kind in ("array", "map"):
                     elem = spec.element if spec.kind == "array" else spec.value
                     if elem is not None and elem.kind == "udt":
                         self._udt_param_udt[p] = elem.name
                         self._udt_param_udt[self._safe_name(p)] = elem.name
-                    cpp_t = f"{cpp_t}&"
+                    if spec.kind == "array":
+                        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")
@@ -1017,16 +1577,44 @@ class TopLevelEmitter:
             # 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)
+        elif self._func_int_return_uses_wide_history(
+            fi, call_site_idx=call_site_idx
+        ):
+            # The history parameter is represented as int64_t so timestamp
+            # values and their na sentinel cannot narrow at the return edge.
+            ret_type = "int64_t"
+        elif (
+            call_site_idx is not None
+            and self._callsite_callable_return_pine_type(
+                fi, call_site_idx
+            ) != PineType.UNKNOWN
+        ):
+            ret_type = PINE_TYPE_TO_CPP.get(
+                self._callsite_callable_return_pine_type(
+                    fi, call_site_idx
+                ),
+                "double",
+            )
         elif getattr(fi, "return_type_spec", None) is not None:
-            # Array-returning function (``f() => array.from(...)``) — emit the
-            # vector type from the inferred element TypeSpec.
+            # Exact return TypeSpec (collections plus narrowly cached primitive
+            # terminal reads) takes precedence over the coarse PineType slot.
             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
+        )
 
         # For per-call-site variants, suffix the function name and activate TA + var remapping
-        func_name = self._emit_udt_method_cpp_name(fi) if is_udt else self._func_safe_name(fi.name)
-        var_init_flag: str | None = None
+        func_name = (
+            self._emit_udt_method_cpp_name(fi)
+            if is_method
+            else self._func_safe_name(fi.name)
+        )
         if instance is not None:
             # Fresh context-sensitive instance: name + composed remaps come from
             # the instance record. No textual cs index (dispatch is via the
@@ -1035,10 +1623,8 @@ class TopLevelEmitter:
             self._active_ta_remap = instance["ta_remap"]
             self._active_var_remap = instance["var_remap"]
             self._active_fixnan_remap = instance.get("fixnan_remap", {})
-            self._in_ta_func_variant = True
             self._active_call_site_idx = None
             self._current_instance_name = instance["name"]
-            var_init_flag = f"_fvinit_{instance['name']}"
         elif call_site_idx is not None:
             func_name = f"{func_name}_cs{call_site_idx}"
             remap = self._func_cs_ta_remap.get((fi.name, call_site_idx), {})
@@ -1046,7 +1632,6 @@ class TopLevelEmitter:
             var_remap = self._func_cs_var_remap.get((fi.name, call_site_idx), {})
             self._active_var_remap = var_remap
             self._active_fixnan_remap = self._func_cs_fixnan_remap.get((fi.name, call_site_idx), {})
-            self._in_ta_func_variant = True
             self._active_call_site_idx = call_site_idx
             # Use the actual emitted name. Plain UDFs are unchanged; UDT
             # methods carry their `_udt_Type_method` prefix. This identity is
@@ -1057,26 +1642,62 @@ class TopLevelEmitter:
             self._active_ta_remap = {}
             self._active_var_remap = {}
             self._active_fixnan_remap = {}
-            self._in_ta_func_variant = False
             self._active_call_site_idx = None
             self._current_instance_name = None
 
         prev_func_locals = self._current_func_locals
         prev_func_local_types = self._current_func_local_types
+        prev_lexical_drawing_types = self._lexical_drawing_types
+        prev_lexical_udt_types = self._lexical_udt_types
+        prev_lexical_series_bindings = self._lexical_series_bindings
+        prev_known_var_tombstones = self._lexical_known_var_tombstones
         prev_func_body = getattr(self, "_current_func_body", None)
         prev_func_name = getattr(self, "_active_func_name", None)
-        # The function body is the lexical scope used by the UDT-alias analysis
-        # (BUG C): a local initialised from a var/global UDT lvalue and later
-        # mutated through must alias, not value-copy.
         self._current_func_body = node.body
         self._active_func_name = fi.name
-        # Pointer-aliased UDT locals are function-scoped: a name like ``p_ivot``
-        # may be a rebinding pointer alias in one function and a ``pivot&``
-        # parameter in another, so reset per function to avoid cross-contamination.
-        prev_ptr_alias = self._udt_ptr_alias_locals
-        self._udt_ptr_alias_locals = set()
         self._current_func_locals = {n for n, _, _ in self.ctx.func_var_members.get(fi.name, [])}
         self._current_func_local_types = {}
+        self._lexical_drawing_types = {
+            param: DRAWING_TYPE_TO_CPP[drawing_name]
+            for param in node.params
+            for drawing_name in (
+                (
+                    self._current_func_param_specs[param].name
+                    if (param in self._current_func_param_specs
+                        and self._current_func_param_specs[param].kind == "udt")
+                    else self._udt_param_udt.get(param)
+                ),
+            )
+            if (drawing_name in DRAWING_TYPE_TO_CPP
+                and self._current_func_param_types.get(
+                    param, ""
+                ).removesuffix("&").removesuffix("*")
+                == DRAWING_TYPE_TO_CPP[drawing_name])
+        }
+        self._lexical_udt_types = {
+            param: (
+                spec.name
+                if spec is not None
+                and spec.kind == "udt"
+                and spec.name in self._udt_defs
+                else (
+                    self._udt_param_udt.get(param)
+                    if (self._udt_param_udt.get(param) in self._udt_defs
+                        and self._current_func_param_types.get(
+                            param, ""
+                        ).removesuffix("&").removesuffix("*")
+                        == self._udt_param_udt.get(param))
+                    else None
+                )
+            )
+            for param in node.params
+            for spec in (self._current_func_param_specs.get(param),)
+        }
+        self._lexical_series_bindings = {
+            param: param in self._current_func_series_params
+            for param in node.params
+        }
+        self._lexical_known_var_tombstones = set(node.params)
         # Plain (non-persistent) scalar locals are emitted inline and live in
         # no other set; collect them so the unknown-identifier guard in
         # _visit_ident does not mistake them for undeclared symbols.
@@ -1084,12 +1705,6 @@ class TopLevelEmitter:
 
         lines.append(f"    {ret_type} {func_name}({', '.join(param_strs)}) {{")
 
-        # Function-scoped ``var`` one-shot initializer: Pine ``var`` inside a
-        # function is a function-local static — its initializer runs exactly
-        # once, on the first call to THIS variant, with the first bar's values
-        # the function actually sees. Each clone (cs0/cs1/…) is independent.
-        self._emit_func_var_init_block(fi, call_site_idx, lines, flag_override=var_init_flag)
-
         emitted_return = False
         if node.is_single_expr and node.body:
             expr = node.body[0].expr if isinstance(node.body[0], ExprStmt) else None
@@ -1098,7 +1713,10 @@ class TopLevelEmitter:
                 # through to the default return.
                 self._visit_stmt(node.body[0], lines, indent=2)
             elif expr:
-                lines.append(f"        return {self._visit_expr(expr)};")
+                lines.append(
+                    "        return "
+                    f"{self._visit_rhs_value(expr, target_cpp_type=rhs_return_cpp_type)};"
+                )
                 emitted_return = True
         else:
             for i, s in enumerate(node.body):
@@ -1112,7 +1730,10 @@ 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(f"        return {self._visit_expr(s.expr)};")
+                        lines.append(
+                            "        return "
+                            f"{self._visit_rhs_value(s.expr, target_cpp_type=rhs_return_cpp_type)};"
+                        )
                         emitted_return = True
                 elif i == len(node.body) - 1 and isinstance(s, (SwitchStmt, IfStmt)):
                     # Switch/if as last statement = return expression in PineScript
@@ -1126,7 +1747,13 @@ class TopLevelEmitter:
                     else:
                         default_ret = self._default_for_type(ret_type)
                     lines.append(f"        {ret_type} _func_ret = {default_ret};")
-                    self._visit_if_switch_expr(s, "_func_ret", lines, indent=2)
+                    self._visit_if_switch_expr(
+                        s,
+                        "_func_ret",
+                        lines,
+                        indent=2,
+                        target_cpp_type=rhs_return_cpp_type,
+                    )
                     lines.append(f"        return _func_ret;")
                     emitted_return = True
                 else:
@@ -1148,87 +1775,30 @@ class TopLevelEmitter:
         lines.append("    }")
         self._current_func_param_types = {}
         self._current_func_param_specs = {}
+        self._current_func_declared_param_names = set()
         self._current_func_series_params = set()
+        self._current_func_series_param_types = {}
         self._udt_param_udt = {}
         self._current_func_locals = prev_func_locals
         self._current_func_local_types = prev_func_local_types
+        self._lexical_drawing_types = prev_lexical_drawing_types
+        self._lexical_udt_types = prev_lexical_udt_types
+        self._lexical_series_bindings = prev_lexical_series_bindings
+        self._lexical_known_var_tombstones = prev_known_var_tombstones
         self._current_func_body = prev_func_body
         self._active_func_name = prev_func_name
-        self._udt_ptr_alias_locals = prev_ptr_alias
+        self._current_func_collection_specs = prev_func_collection_specs
+        self._current_func_collection_shadows = prev_func_collection_shadows
+        self._collection_types = prev_collection_types
+        self._array_vars = prev_array_vars
+        self._map_vars = prev_map_vars
+        self._matrix_specs = prev_matrix_specs
         self._active_ta_remap = {}
         self._active_var_remap = {}
         self._active_fixnan_remap = {}
-        self._in_ta_func_variant = False
         self._active_call_site_idx = None
         self._current_instance_name = None
 
-    def _func_var_init_flag_name(self, fname: str, call_site_idx: int | None) -> str:
-        suffix = f"_cs{call_site_idx}" if call_site_idx is not None else ""
-        return f"_fvinit_{self._func_safe_name(fname)}{suffix}"
-
-    def _emit_func_var_init_block(self, fi: FuncInfo, call_site_idx: int | None,
-                                  lines: list[str], flag_override: str | None = None) -> None:
-        """Emit the one-shot initializer block for a function's ``var`` members.
-
-        Pine ``var`` declared inside a function is a function-local static:
-        the initializer runs exactly once on the FIRST call to this variant
-        (using the first bar's values the function actually sees) and the
-        result persists for the strategy's lifetime. Each per-call-site clone
-        is an independent instance with its own flag and its own set of
-        (remapped) members.
-
-        This closes the gap where a function-scoped ``var line x = line.new(...)``
-        (or any non-compile-time initializer — drawing handles, UDT ctors,
-        arrays, runtime expressions) was declared as a default-constructed
-        class member but its initializer was dropped, leaving the member ``na``
-        / uninitialised and causing "drawing access on na handle" at runtime.
-        """
-        members = self.ctx.func_var_members.get(fi.name)
-        if not members:
-            return
-        flag = flag_override or self._func_var_init_flag_name(fi.name, call_site_idx)
-        # ``_active_var_remap`` is already set for this variant by the caller,
-        # so lowering each init expression here correctly resolves references
-        # to sibling var members (which are themselves remapped for clones).
-        init_lines: list[str] = []
-        for name, ptype, _init_str in members:
-            init_ast = self.ctx.var_member_init_exprs.get(name)
-            safe = self._safe_name(name)
-            target = self._active_var_remap.get(safe, safe)
-            if name in self.ctx.series_vars:
-                if init_ast is None:
-                    continue
-                init_cpp = self._visit_expr(init_ast)
-                init_cpp = self._typed_na_init(init_cpp, name, ptype)
-                init_lines.append(f"        {target}.push({init_cpp});")
-                continue
-            if init_ast is None:
-                # No initializer to lower (e.g. bare ``var box b``); leave the
-                # member at its default-constructed value.
-                continue
-            # Skip a plain ``na`` initializer for drawing handles / UDTs whose
-            # default-constructed member is already the na sentinel; assigning
-            # ``na<double>()`` would not type-match the handle / struct.
-            udt_t = self._udt_var_types.get(name)
-            is_drawing = udt_t in DRAWING_TYPE_TO_CPP if udt_t else False
-            is_udt = udt_t in self._udt_defs if udt_t else False
-            from ..ast_nodes import NaLiteral
-            if (is_drawing or is_udt) and isinstance(init_ast, NaLiteral):
-                continue
-            init_cpp = self._visit_expr(init_ast)
-            # A bare-``na`` initializer for an int/int64_t/bool ``var`` member
-            # must be typed (``na<int>()``), mirroring the class-scope ctor
-            # init (``_typed_na_init`` at _emit_constructor); a raw ``na<double>()``
-            # NaN stored into an int member is UB and defeats is_na<T>().
-            init_cpp = self._typed_na_init(init_cpp, name, ptype)
-            init_lines.append(f"        {target} = {init_cpp};")
-        if not init_lines:
-            return
-        lines.append(f"        if (!{flag}) {{")
-        lines.extend(init_lines)
-        lines.append(f"            {flag} = true;")
-        lines.append("        }")
-
     def _emit_precalculate_and_run(self, lines: list[str]) -> None:
         has_static_ta = any(
             self._ta_site_uses_precalc(site)
@@ -1246,7 +1816,7 @@ class TopLevelEmitter:
                 continue
             if not (isinstance(stmt.value, FuncCall) and self._is_source_input(stmt.value)):
                 continue
-            if stmt.name in self.ctx.series_vars:
+            if self._decl_binding_is_series(id(stmt), stmt.name):
                 replayed_source_series.append(self._safe_name(stmt.name))
         replayed_source_series = sorted(set(replayed_source_series))
 
@@ -1268,7 +1838,7 @@ class TopLevelEmitter:
             if _ti in self._dead_ta_indices:
                 continue
             if self._ta_site_uses_precalc(site):
-                resolved = [self._resolve_known(a) for a in site.ctor_args]
+                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")
@@ -1354,7 +1924,7 @@ class TopLevelEmitter:
             # the normal per-bar path's ``{safe}.push({cpp_val})`` (see
             # ``_visit_var_decl``'s ``node.name in self.ctx.series_vars``
             # branch) — a plain ``=`` there is a compile error.
-            if stmt.name in self.ctx.series_vars:
+            if self._decl_binding_is_series(id(stmt), stmt.name):
                 lines.append(f'            {safe}.push({cpp_val});')
             else:
                 lines.append(f'            {safe} = {cpp_val};')
@@ -1380,7 +1950,7 @@ class TopLevelEmitter:
             if _ti in self._dead_ta_indices:
                 continue
             if self._ta_site_uses_precalc(site):
-                resolved = [self._resolve_known(a) for a in site.ctor_args]
+                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")