@pineforge/codegen-pyodide 0.10.1 → 0.10.2

package/package.json

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

package/pineforge_codegen/codegen/base.py

@@ -514,6 +514,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # the declaration-derived checkpoint inventory.
         self._inline_history_members: list[dict] = []
         self._inline_history_member_by_key: dict[tuple, str] = {}
+        # request.security/request.security_lower_tf inline their Pine helper
+        # expressions on the requested clock instead of calling the ordinary
+        # emitted UDF methods.  The chart-clocked plain-UDF history factor must
+        # therefore exclude those source nodes and any emitted helper context
+        # reached only through them.
+        self._requested_context_inline_node_ids: set[int] = set()
+        self._requested_context_only_inline_contexts: set[
+            tuple[str, str | None]
+        ] = set()
         # Unique lambda-local names used when an array lowering references its
         # receiver more than once.  The binding keeps temporary-producing or
         # side-effectful receivers single-evaluation (see TypeInferer).
@@ -3173,7 +3182,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         """
         self._inline_history_members = []
         self._inline_history_member_by_key = {}
-        counters = {"hist_call": 0, "series_arg": 0}
+        counters = {
+            "hist_call": 0,
+            "series_arg": 0,
+            "udf_series_arg": 0,
+        }
 
         def walk_nodes(value):
             """Yield AST nodes in stable field order, including tuple elements.
@@ -3345,6 +3358,113 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             lexical.update(self._func_collection_types.get(owner, {}))
             return lexical
 
+        def plain_udf_info(call: FuncCall):
+            if not isinstance(call.callee, Identifier):
+                return None
+            candidate = self._func_info_map.get(call.callee.name)
+            if (
+                candidate is None
+                or candidate.node is None
+                or getattr(candidate, "is_udt_method", False)
+            ):
+                return None
+            return candidate
+
+        # Requested-context UDF expressions are lowered independently by
+        # security.py.  Classify their otherwise-emitted helper variants so
+        # this chart-clocked factor neither allocates unused buffers for them
+        # nor changes the legacy bodies that remain in generated C++.
+        requested_node_ids: set[int] = set()
+        for security_call in self._security_calls:
+            expression = security_call.get("expr_node")
+            if expression is None:
+                continue
+            requested_node_ids.update(
+                id(child) for child in walk_nodes(expression)
+            )
+        self._requested_context_inline_node_ids = requested_node_ids
+
+        def emitted_context_for_call(
+            fi,
+            call: FuncCall,
+            owner: str | None,
+            owner_context: str | None,
+        ) -> str | None:
+            dispatch = self._instance_dispatch.get(
+                (owner_context, id(call))
+            )
+            if dispatch is not None:
+                return dispatch
+            target_cs = target_cs_for_context(
+                fi, call, owner, owner_context
+            )
+            if target_cs is not None:
+                return f"{self._func_cpp_base_name(fi.name)}_cs{target_cs}"
+            return None
+
+        requested_roots: set[tuple[str, str | None]] = set()
+        chart_roots: set[tuple[str, str | None]] = set()
+        context_edges: dict[
+            tuple[str, str | None], set[tuple[str, str | None]]
+        ] = {}
+        for call in (
+            candidate
+            for candidate in walk_nodes(self.ctx.ast)
+            if isinstance(candidate, FuncCall)
+        ):
+            fi = plain_udf_info(call)
+            if fi is None:
+                continue
+            owner = owner_by_node.get(id(call))
+            if id(call) in requested_node_ids:
+                owner_contexts = (
+                    [None]
+                    if owner is None
+                    else self._inline_history_contexts_for_owner(owner)
+                )
+                for owner_context in owner_contexts:
+                    requested_roots.add((
+                        fi.name,
+                        emitted_context_for_call(
+                            fi, call, owner, owner_context
+                        ),
+                    ))
+                continue
+            if owner is None:
+                target = (
+                    fi.name,
+                    emitted_context_for_call(fi, call, None, None),
+                )
+                chart_roots.add(target)
+                continue
+            for owner_context in self._inline_history_contexts_for_owner(owner):
+                source = (owner, owner_context)
+                target = (
+                    fi.name,
+                    emitted_context_for_call(
+                        fi, call, owner, owner_context
+                    ),
+                )
+                context_edges.setdefault(source, set()).add(target)
+
+        def reachable(
+            roots: set[tuple[str, str | None]],
+        ) -> set[tuple[str, str | None]]:
+            found = set(roots)
+            pending = list(roots)
+            while pending:
+                source = pending.pop()
+                for target in context_edges.get(source, ()):
+                    if target in found:
+                        continue
+                    found.add(target)
+                    pending.append(target)
+            return found
+
+        self._requested_context_only_inline_contexts = (
+            reachable(requested_roots) - reachable(chart_roots)
+        )
+
         for node in walk_nodes(self.ctx.ast):
             owner = owner_by_node.get(id(node))
             if isinstance(node, Subscript) and isinstance(node.object, FuncCall):
@@ -3403,6 +3523,26 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     expected_cpp_type = self._series_param_element_cpp_type(
                         fi, idx, target_cs
                     )
+                    # Pine gives each plain-UDF written call its own
+                    # chart-aligned parameter history.  Even an exact Series
+                    # actual therefore needs a call-site-owned buffer: skipped
+                    # evaluations hold the last value in that bar's slot
+                    # instead of exposing the caller's independently changing
+                    # history.  Typed methods retain their established direct
+                    # binding/bridge behavior below.
+                    chart_execution_context = (
+                        id(node) not in requested_node_ids
+                        and (owner, context)
+                        not in self._requested_context_only_inline_contexts
+                    )
+                    if not method_call and chart_execution_context:
+                        register_one(
+                            "udf_series_arg",
+                            (id(node), idx),
+                            expected_cpp_type,
+                            context,
+                        )
+                        continue
                     needs_bridge = True
                     if isinstance(arg, Identifier):
                         if (

package/pineforge_codegen/codegen/emit_top.py

@@ -949,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}")

package/pineforge_codegen/codegen/security.py

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

package/pineforge_codegen/codegen/tables.py

@@ -459,45 +459,143 @@ ORDER_DIRECTION_MAP = {
 # ---------------------------------------------------------------------------
 
 
-def _checked_array_index_prelude(*, normalize_negative: bool = True) -> str:
+def _checked_array_index_prelude(
+    *,
+    normalize_negative: bool = True,
+    allow_size: bool = False,
+    name: str = "index",
+) -> str:
     """C++ body shared by checked single-index operations.
 
-    Pine v6 explicitly gives end-relative negative indices to the checked
-    ``get``, ``set``, and ``remove`` cluster. Other indexed functions such as
-    ``percentrank`` still need the same NA/non-finite/range checks, but must
-    reject negative indices instead of normalizing them. ``insert`` remains a
-    separately bounded residual.
+    Pine v6 explicitly gives end-relative negative indices to ``array.get``,
+    ``array.set``, ``array.insert``, and ``array.remove``. Other indexed
+    functions such as ``percentrank`` and the ``fill``/``slice`` range
+    endpoints still need the same NA/non-finite/range checks, but must reject
+    negative indices instead of normalizing them (``normalize_negative``).
+
+    ``allow_size`` widens the upper bound from ``index < size`` to
+    ``index <= size``. An *element access* is invalid at ``size``, but an
+    *insertion point* is not: ``array.insert(id, size, v)`` appends, and the
+    half-open ``[index_from, index_to)`` ranges of ``array.fill`` /
+    ``array.slice`` legally end at ``size``.
+
+    ``name`` renames every emitted local so two endpoints can be checked in
+    one C++ scope without colliding. ``name="index"`` reproduces the original
+    identifiers byte-for-byte.
     """
+    raw_value = f"__pf_raw_{name}_value"
+    raw_type = f"__pf_raw_{name}_type"
+    raw_text = f"__pf_raw_{name}_text"
+    raw_wide = f"__pf_raw_{name}_wide"
+    raw = f"__pf_raw_{name}"
+    checked = f"__pf_array_{name}"
+    size = "__pf_array_size" if name == "index" else f"__pf_array_size_{name}"
     checked_index = (
-        "__pf_raw_index<0?__pf_raw_index+__pf_array_size:__pf_raw_index"
-        if normalize_negative
-        else "__pf_raw_index"
+        f"{raw}<0?{raw}+{size}:{raw}" if normalize_negative else raw
     )
+    upper = ">" if allow_size else ">="
     return (
-        "using __pf_raw_index_type=std::decay_t<decltype(__pf_raw_index_value)>; "
-        "if constexpr(!std::is_same_v<__pf_raw_index_type,bool>) { "
-        "if(is_na(__pf_raw_index_value)) "
+        f"using {raw_type}=std::decay_t<decltype({raw_value})>; "
+        f"if constexpr(!std::is_same_v<{raw_type},bool>) {{ "
+        f"if(is_na({raw_value})) "
         "pine_runtime_error(std::string(\"Index na is out of bounds. Array size is \")+"
         "std::to_string((int64_t)__pf_array.size())); } "
-        "if constexpr(std::is_floating_point_v<__pf_raw_index_type>) { "
-        "if(!std::isfinite(__pf_raw_index_value)) { "
-        "std::string __pf_raw_index_text=__pf_raw_index_value>0?\"inf\":\"-inf\"; "
-        "pine_runtime_error(std::string(\"Index \")+__pf_raw_index_text+"
+        f"if constexpr(std::is_floating_point_v<{raw_type}>) {{ "
+        f"if(!std::isfinite({raw_value})) {{ "
+        f"std::string {raw_text}={raw_value}>0?\"inf\":\"-inf\"; "
+        f"pine_runtime_error(std::string(\"Index \")+{raw_text}+"
         "\" is out of bounds. Array size is \"+"
         "std::to_string((int64_t)__pf_array.size())); } "
-        "long double __pf_raw_index_wide=(long double)__pf_raw_index_value; "
-        "if(__pf_raw_index_wide<(long double)std::numeric_limits<int64_t>::min()||"
-        "__pf_raw_index_wide>(long double)std::numeric_limits<int64_t>::max()) "
+        f"long double {raw_wide}=(long double){raw_value}; "
+        f"if({raw_wide}<(long double)std::numeric_limits<int64_t>::min()||"
+        f"{raw_wide}>(long double)std::numeric_limits<int64_t>::max()) "
         "pine_runtime_error(std::string(\"Index \")+"
-        "std::to_string((double)__pf_raw_index_value)+"
+        f"std::to_string((double){raw_value})+"
         "\" is out of bounds. Array size is \"+"
         "std::to_string((int64_t)__pf_array.size())); } "
-        "int64_t __pf_raw_index=(int64_t)__pf_raw_index_value; "
-        "int64_t __pf_array_size=(int64_t)__pf_array.size(); "
-        f"int64_t __pf_array_index={checked_index}; "
-        "if(__pf_array_index<0||__pf_array_index>=__pf_array_size) "
-        "pine_runtime_error(std::string(\"Index \")+std::to_string(__pf_raw_index)+"
-        "\" is out of bounds. Array size is \"+std::to_string(__pf_array_size)); "
+        f"int64_t {raw}=(int64_t){raw_value}; "
+        f"int64_t {size}=(int64_t)__pf_array.size(); "
+        f"int64_t {checked}={checked_index}; "
+        f"if({checked}<0||{checked}{upper}{size}) "
+        f"pine_runtime_error(std::string(\"Index \")+std::to_string({raw})+"
+        f"\" is out of bounds. Array size is \"+std::to_string({size})); "
+    )
+
+
+def _checked_array_range_prelude() -> str:
+    """Validate the half-open ``[index_from, index_to)`` range of fill/slice.
+
+    Both endpoints are checked with ``allow_size`` (``index_to`` is exclusive,
+    so ``size`` is a legal endpoint) and without negative normalization
+    (neither function appears in the Pine v6 reference's negative-indexing
+    set). An inverted range is rejected rather than silently treated as empty:
+    ``begin()+from > begin()+to`` is undefined behaviour in the STL forms this
+    replaces, and no evidence pins TradingView's behaviour there.
+    """
+    return (
+        _checked_array_index_prelude(
+            normalize_negative=False, allow_size=True, name="index_from"
+        )
+        + _checked_array_index_prelude(
+            normalize_negative=False, allow_size=True, name="index_to"
+        )
+        + "if(__pf_array_index_from>__pf_array_index_to) "
+        "pine_runtime_error(std::string(\"Index range \")+"
+        "std::to_string(__pf_array_index_from)+\"..\"+"
+        "std::to_string(__pf_array_index_to)+"
+        "\" is invalid. Array size is \"+"
+        "std::to_string(__pf_array_size_index_from)); "
+    )
+
+
+def _checked_array_insert(a: str, args: list[str]) -> str:
+    """``array.insert(id, index, value)`` — index is an INSERTION point.
+
+    ``index == size`` appends, so the bound is ``index <= size``; a negative
+    index is end-relative, exactly as for ``get``/``set``/``remove``.
+    """
+    check = _checked_array_index_prelude(allow_size=True)
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_value){ "
+        "return [&](auto&& __pf_array_value){ "
+        f"{check}"
+        "__pf_array.insert(__pf_array.begin()+(size_t)__pf_array_index, "
+        "__pf_array_value); "
+        f"}}(({args[1]})); }}(({args[0]})); }}(({a}))"
+    )
+
+
+def _checked_array_fill_range(a: str, args: list[str]) -> str:
+    """``array.fill(id, value, index_from, index_to)`` — bounded range fill."""
+    check = _checked_array_range_prelude()
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_array_value){ "
+        "return [&](auto&& __pf_raw_index_from_value){ "
+        "return [&](auto&& __pf_raw_index_to_value){ "
+        f"{check}"
+        "std::fill(__pf_array.begin()+(size_t)__pf_array_index_from, "
+        "__pf_array.begin()+(size_t)__pf_array_index_to, __pf_array_value); "
+        f"}}(({args[2]})); }}(({args[1]})); }}(({args[0]})); }}(({a}))"
+    )
+
+
+def checked_array_slice(a: str, args: list[str], *, result_type: str) -> str:
+    """``array.slice(id, index_from, index_to)`` — bounded range extraction.
+
+    ``result_type`` stays caller-supplied so the typed method lane keeps
+    emitting the receiver's own element type; only the bounds checks are new.
+    """
+    check = _checked_array_range_prelude()
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_from_value){ "
+        "return [&](auto&& __pf_raw_index_to_value){ "
+        f"{check}"
+        f"return {result_type}(__pf_array.begin()+(size_t)__pf_array_index_from, "
+        "__pf_array.begin()+(size_t)__pf_array_index_to); "
+        f"}}(({args[1]})); }}(({args[0]})); }}(({a}))"
     )
 
 
@@ -600,7 +698,7 @@ ARRAY_METHODS = {
     "set":       _checked_array_set,
     "push":      lambda a, args: f"{a}.push_back({args[0]})",
     "unshift":   lambda a, args: f"{a}.insert({a}.begin(), {args[0]})",
-    "insert":    lambda a, args: f"{a}.insert({a}.begin() + (int)({args[0]}), {args[1]})",
+    "insert":    _checked_array_insert,
     "pop":       lambda a, args: _checked_array_end_remove(a, "pop"),
     "shift":     lambda a, args: _checked_array_end_remove(a, "shift"),
     "remove":    _checked_array_remove,
@@ -609,7 +707,7 @@ ARRAY_METHODS = {
     "size":      lambda a, args: f"(double){a}.size()",
     "clear":     lambda a, args: f"{a}.clear()",
     "fill":      lambda a, args: f"std::fill({a}.begin(), {a}.end(), {args[0]})" if len(args) == 1
-                                 else f"std::fill({a}.begin()+(int)({args[1]}), {a}.begin()+(int)({args[2]}), {args[0]})",
+                                 else _checked_array_fill_range(a, args),
     "includes":  lambda a, args: f"(std::find({a}.begin(), {a}.end(), {args[0]}) != {a}.end())",
     "indexof":   lambda a, args: f"[&](){{ auto it=std::find({a}.begin(),{a}.end(),{args[0]}); return it!={a}.end()?(double)(it-{a}.begin()):-1.0; }}()",
     "lastindexof": lambda a, args: f"[&](){{ for(int i=(int){a}.size()-1;i>=0;i--)if({a}[i]=={args[0]})return(double)i; return -1.0; }}()",
@@ -619,7 +717,7 @@ ARRAY_METHODS = {
     ),
     "reverse":   lambda a, args: f"std::reverse({a}.begin(),{a}.end())",
     "copy":      lambda a, args: f"std::vector<double>({a})",
-    "slice":     lambda a, args: f"std::vector<double>({a}.begin()+(int)({args[0]}),{a}.begin()+(int)({args[1]}))",
+    "slice":     lambda a, args: checked_array_slice(a, args, result_type="std::vector<double>"),
     "concat":    lambda a, args: f"{a}.insert({a}.end(),{args[0]}.begin(),{args[0]}.end())",
     "sum":       lambda a, args: f"({a}.empty()?na<double>():std::accumulate({a}.begin(),{a}.end(),0.0))",
     "avg":       lambda a, args: f"({a}.empty()?na<double>():std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size())",
@@ -667,6 +765,9 @@ CHECKED_ARRAY_METHOD_KWARGS: dict[str, list[str]] = {
     "set": ["index", "value"],
     "remove": ["index"],
     "percentrank": ["index"],
+    "insert": ["index", "value"],
+    "fill": ["value", "index_from", "index_to"],
+    "slice": ["index_from", "index_to"],
     "first": [],
     "last": [],
     "pop": [],

package/pineforge_codegen/codegen/types.py

@@ -50,6 +50,7 @@ from .tables import (
     MATRIX_RETURNING_METHODS,
     PINE_TYPE_TO_CPP,
     TA_RETURNS_BOOL,
+    checked_array_slice,
 )
 
 # Collection (array / map / matrix) methods that MUTATE the receiver in place.
@@ -960,7 +961,11 @@ class TypeInferer:
         if method == "copy":
             lower_receiver = lambda recv: f"{arr_cpp_type}({recv})"
         elif method == "slice":
-            lower_receiver = lambda recv: f"{arr_cpp_type}({recv}.begin()+(int)({args[0]}),{recv}.begin()+(int)({args[1]}))"
+            # Bounds-checked in the shared helper; the element type stays
+            # caller-supplied so the typed lane keeps its own vector type.
+            lower_receiver = lambda recv: checked_array_slice(
+                recv, args, result_type=arr_cpp_type
+            )
         elif method == "join" and elem_cpp == "std::string":
             sep = args[0] if args else 'std::string(",")'
             lower_receiver = lambda recv: f"[&](){{ std::string r; for(size_t i=0;i<{recv}.size();i++){{ if(i>0)r+={sep}; r+={recv}[i]; }} return r; }}()"

package/pineforge_codegen/codegen/visit_call.py

@@ -2145,25 +2145,25 @@ class CallVisitor:
                     arg_idx,
                     self._callable_target_callsite_idx(fi_lookup, node),
                 )
-                if isinstance(arg_node, Identifier):
+                chart_execution_context = (
+                    id(node) not in self._requested_context_inline_node_ids
+                    and (
+                        getattr(self, "_active_func_name", None),
+                        self._current_instance_name,
+                    ) not in self._requested_context_only_inline_contexts
+                )
+                if not chart_execution_context and isinstance(arg_node, Identifier):
+                    # request.security/request.security_lower_tf own a separate
+                    # evaluator clock and inline their UDF expressions in
+                    # security.py.  Preserve the pre-factor direct-Series
+                    # lowering in the otherwise-emitted helper bodies.
                     aname = arg_node.name
-                    # Bar field: pass _s_close instead of current_bar_.close
                     if (
                         (aname in BAR_FIELDS or aname in BAR_SERIES_PUSH)
                         and expected_cpp_type == "double"
                     ):
                         return f"_s_{aname}"
-                    # Exact Series binding: pass the Series object directly.
-                    # A raw name can also denote a scalar sibling/callable
-                    # shadow, in which case lexical state must override the
-                    # legacy ``ctx.series_vars`` union and fall through to the
-                    # synthetic history bridge below.
                     safe = self._safe_name(aname)
-                    # Function parameters are lexical C++ arguments in every
-                    # emitted variant.  The legacy function-series clone table
-                    # can contain the same raw name, but applying it here makes
-                    # cs1+ ignore the actual parameter and read an unrelated
-                    # class member instead.
                     is_current_series_param = (
                         aname in self._current_func_series_params
                     )
@@ -2188,13 +2188,31 @@ class CallVisitor:
                     expr_cpp, cpp_t
                 )
                 member = self._inline_history_member(
-                    "series_arg", node, arg_idx=arg_idx
+                    (
+                        "udf_series_arg"
+                        if chart_execution_context
+                        else "series_arg"
+                    ),
+                    node,
+                    arg_idx=arg_idx,
                 )
+                if not chart_execution_context:
+                    return (
+                        f"([&]() -> const Series<{cpp_t}>& {{ "
+                        f"{cpp_t} _sv = {bridge_cpp}; "
+                        f"if (history_advances_new_bar()) {member}.push(_sv); "
+                        f"else {member}.update(_sv); "
+                        f"return {member}; }}())"
+                    )
+                # A chart-executed plain UDF's history-reading parameter
+                # belongs to this lexical call site, not to the caller Series
+                # object.  The on_bar preamble has already advanced its
+                # synthetic buffer by one chart slot, so execution replaces
+                # that slot rather than pushing a second one.
                 return (
                     f"([&]() -> const Series<{cpp_t}>& {{ "
                     f"{cpp_t} _sv = {bridge_cpp}; "
-                    f"if (history_advances_new_bar()) {member}.push(_sv); "
-                    f"else {member}.update(_sv); "
+                    f"{member}.update(_sv); "
                     f"return {member}; }}())"
                 )
             # A concrete nullable collection specialization learned through an

package/pineforge_codegen/support_checker.py

@@ -516,11 +516,20 @@ class SupportChecker:
         # then ``request.security(haTicker, ...)``, or ``reqSym = cond ? other :
         # syminfo.tickerid``. First binding wins (closest to declaration).
         self._scalar_defs: dict[str, ASTNode] = {}
+        # EVERY reassignment value bound to a scalar name (``name := <expr>``
+        # and the compound forms). A declaration alone does not pin the value a
+        # ``request.security`` symbol argument actually carries: the engine is
+        # registered with no symbol at all, so an accepted-but-divergent rebind
+        # silently backtests the CHART feed. Collected in a whole-AST pre-pass
+        # (below) as well as during the visit, so a rebind that lexically
+        # FOLLOWS the request.security call cannot slip past.
+        self._scalar_rebinds: dict[str, list[ASTNode]] = {}
 
     # -- Public API --
 
     def check(self) -> list[Diagnostic]:
         self._collect_user_definitions(self._ast)
+        self._collect_scalar_rebinds(self._ast)
         for stmt in self._ast.body:
             self._visit(stmt)
         return self._diagnostics
@@ -533,6 +542,42 @@ class SupportChecker:
 
     # -- Setup --
 
+    def _record_scalar_rebind(self, node: Assignment) -> None:
+        """Remember ``name := <expr>`` (and the compound forms) by name.
+
+        A compound op (``+=``, ``*=``, …) records its right-hand operand, which
+        is never a current-symbol expression — so a string-built symbol is
+        rejected by the same rule that rejects a plain divergent ``:=``.
+        """
+        target = node.target
+        if not isinstance(target, Identifier) or node.value is None:
+            return
+        recorded = self._scalar_rebinds.setdefault(target.name, [])
+        if not any(value is node.value for value in recorded):
+            recorded.append(node.value)
+
+    def _collect_scalar_rebinds(self, node: ASTNode) -> None:
+        """Pre-pass: collect every scalar rebind anywhere in the AST.
+
+        The visit walks top-level statements in source order, so a rebind that
+        FOLLOWS a ``request.security`` call would otherwise never be seen by
+        that call's symbol check. Collecting up front is strictly fail-closed:
+        it can only add rejections, never remove one.
+        """
+        if isinstance(node, Assignment):
+            self._record_scalar_rebind(node)
+        for value in vars(node).values():
+            if isinstance(value, ASTNode):
+                self._collect_scalar_rebinds(value)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, ASTNode):
+                        self._collect_scalar_rebinds(item)
+            elif isinstance(value, dict):
+                for item in value.values():
+                    if isinstance(item, ASTNode):
+                        self._collect_scalar_rebinds(item)
+
     def _collect_user_definitions(self, ast: Program) -> None:
         for stmt in ast.body:
             if isinstance(stmt, TypeDecl):
@@ -1001,6 +1046,14 @@ class SupportChecker:
             )
         self._visit_children(node)
 
+    def _visit_Assignment(self, node: Assignment) -> None:
+        # ``_scalar_defs`` records only the DECLARATION, so a later ``:=``
+        # rebind used to be invisible to the request.security symbol check.
+        # (``check`` also pre-collects these; recording here keeps the visit
+        # self-consistent for any caller that drives visitors directly.)
+        self._record_scalar_rebind(node)
+        self._visit_children(node)
+
     def _visit_TupleAssign(self, node: TupleAssign) -> None:
         drawing_mask = self._tuple_assign_drawing_mask(node.value)
         if drawing_mask:
@@ -1723,10 +1776,21 @@ class SupportChecker:
                     or self._is_current_symbol_expr(node.false_val, _seen))
         # Def-use: resolve a bare identifier through its declaration value so an
         # aliased symbol is accepted (``haTicker = ticker.heikinashi(...)`` then
-        # ``request.security(haTicker, ...)``). Name-cycle-guarded.
-        if isinstance(node, Identifier) and node.name in self._scalar_defs and node.name not in _seen:
-            _seen.add(node.name)
-            return self._is_current_symbol_expr(self._scalar_defs[node.name], _seen)
+        # ``request.security(haTicker, ...)``). Every ``:=`` rebind of the name
+        # must resolve to the chart symbol too: the declaration alone does not
+        # pin the value the call actually receives. Name-cycle-guarded.
+        if isinstance(node, Identifier) and node.name not in _seen:
+            definition = self._scalar_defs.get(node.name)
+            rebinds = self._scalar_rebinds.get(node.name)
+            if definition is not None or rebinds:
+                _seen.add(node.name)
+                if rebinds and not all(
+                    self._is_current_symbol_expr(value, _seen) for value in rebinds
+                ):
+                    return False
+                if definition is None:
+                    return False
+                return self._is_current_symbol_expr(definition, _seen)
         return False
 
     # -- Pine timeframe-literal validation --

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "0.10.1",
+  "codegen": "0.10.2",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "e0d1ec121b40e4be39c958e338900789768fb1e6ec39b99b4cb3301c80f13a89"
+  "sha256": "97ebb8d0b14c32d3c88b9521c8f13150ee9cb9e3859227af970ec4dcbfa6bf71"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "0.10.1",
+  "CODEGEN_VERSION": "0.10.2",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",