@pineforge/codegen-pyodide 1.0.0 → 1.1.0

package/pineforge_codegen/codegen/collection_history.py

@@ -0,0 +1,200 @@
+"""The C++ of an array's or a matrix's history (``a[k]``, ``m[k]``).
+
+The analyzer annotates every such read with how its value is used and lists
+the variables whose history the script reads (``ctx.collection_history``;
+pineforge_codegen/collection_history.py). Such a variable keeps its own
+``std::vector`` or matrix member, so every other operation on it keeps its
+C++; beside it, ``_pf_collection_hist_<name>`` keeps the copies its
+executions left. Each execution of the declaration -- each bar, for a top
+level ``var`` -- opens a slot (``open``) and the end of the bar closes it with
+a copy (``close``), so ``a[1]`` is the array as the previous bar left it,
+TradingView's read-only history (fixtures/array_history_tv).
+"""
+
+from __future__ import annotations
+
+from ..collection_history import (
+    COLLECTION_HISTORY_CLASS_CPP,
+    COLLECTION_HISTORY_CPP,
+    COLLECTION_HISTORY_GENERIC_MATRIX_CPP,
+    COLLECTION_HISTORY_MATRIX_CPP,
+    history_annotation,
+    literal_offset,
+)
+from ..ast_nodes import FuncCall, Identifier, MemberAccess
+from ..symbols import TypeSpec
+
+
+class CollectionHistoryEmitter:
+    """CodeGen mixin: the history members of array and matrix variables."""
+
+    def _collection_history_variables(self) -> list:
+        """The declarations whose history the script reads, in key order."""
+        history = getattr(self.ctx, "collection_history", None) or {}
+        return [history[key] for key in sorted(history)]
+
+    def _collection_history_member(self, variable) -> str:
+        """``_pf_collection_hist_<name>``; a later declaration of the same
+        name (a sibling block's) gets ``_pf_collection_hist_<ordinal>_<name>``,
+        which no Pine name (none starts with a digit) can spell: ``x``'s
+        second declaration beside a variable ``x_1``."""
+        prefix = f"{variable.ordinal}_" if variable.ordinal else ""
+        return f"_pf_collection_hist_{prefix}{self._safe_name(variable.name)}"
+
+    def _collection_history_of(self, annotation):
+        history = getattr(self.ctx, "collection_history", None) or {}
+        return history.get(annotation.get("member"))
+
+    def _collection_history_cpp_type(self, variable) -> str:
+        """The history's element type: the variable member's own C++ type,
+        whatever its declaration spells (a wide int array included)."""
+        return f"decltype({self._safe_name(variable.name)})"
+
+    def _collection_history_capacity(self, variable) -> str:
+        """The ring's size: the largest literal offset read plus one, or the
+        Series default (a ``max_bars_back`` cap) for a dynamic offset."""
+        if variable.capacity is None:
+            return self._series_decl_suffix()
+        return f"{{{max(2, variable.capacity)}}}"
+
+    def _emit_collection_history_helper(self, lines: list[str]) -> None:
+        variables = self._collection_history_variables()
+        if not variables:
+            return
+        float_spec = TypeSpec.primitive("float")
+        matrices = [v.spec for v in variables if v.kind == "matrix"]
+        lines.append(COLLECTION_HISTORY_CPP.strip("\n"))
+        if any(spec.element == float_spec for spec in matrices):
+            lines.append(COLLECTION_HISTORY_MATRIX_CPP.strip("\n"))
+        if any(spec.element != float_spec for spec in matrices):
+            lines.append(COLLECTION_HISTORY_GENERIC_MATRIX_CPP.strip("\n"))
+        lines.append(COLLECTION_HISTORY_CLASS_CPP.strip("\n"))
+        lines.append("")
+
+    def _collection_history_open(self, variable) -> str:
+        """The statement opening a declaration's slot."""
+        return (f"{self._collection_history_member(variable)}.open("
+                f"{self._safe_name(variable.name)}, history_advances_new_bar());")
+
+    def _collection_history_close(self, variable) -> str:
+        return (f"{self._collection_history_member(variable)}.close("
+                f"{self._safe_name(variable.name)});")
+
+    def _collection_history_decl_statements(self, node) -> list[str]:
+        """What an execution of a declaration does first: close the history
+        of every other declaration writing the same member (a sibling
+        block's ``x``, which keeps the array its block left), then open its
+        own slot when it is not a ``var`` (a block's on the bars it runs)."""
+        statements = []
+        own = None
+        for variable in self._collection_history_variables():
+            if id(node) in variable.closed_by:
+                statements.append(self._collection_history_close(variable))
+            elif variable.decl_node_id == id(node):
+                own = variable
+        if own is not None and not (getattr(node, "is_var", False)
+                                    or getattr(node, "is_varip", False)):
+            statements.append(self._collection_history_open(own))
+        return statements
+
+    def _emit_collection_history_var_opens(self, lines: list[str], pad: str) -> None:
+        """A top-level ``var``'s slot opens on every bar, after its first
+        bar's initialization."""
+        for variable in self._collection_history_variables():
+            if variable.is_var:
+                lines.append(f"{pad}{self._collection_history_open(variable)}")
+
+    def _emit_collection_history_closes(self, lines: list[str], pad: str) -> None:
+        """The bar's end: every open slot keeps a copy of its variable."""
+        for variable in self._collection_history_variables():
+            lines.append(f"{pad}{self._collection_history_close(variable)}")
+
+    @staticmethod
+    def _roots_at_collection_history(value) -> bool:
+        """Whether ``value`` is an array's or a matrix's history or a
+        built-in's call on one (``m[1]``, ``(m[1]).copy()``,
+        ``matrix.transpose(m[1])``)."""
+        if history_annotation(value) is not None:
+            return True
+        if not isinstance(value, FuncCall):
+            return False
+        callee = value.callee
+        if isinstance(callee, MemberAccess) and history_annotation(callee.object) is not None:
+            return True
+        first = value.args[0] if value.args else None
+        return (isinstance(callee, MemberAccess)
+                and isinstance(callee.object, Identifier)
+                and callee.object.name in ("array", "matrix")
+                and first is not None and history_annotation(first) is not None)
+
+    def _collection_history_offset_cpp(self, node) -> str:
+        offset = literal_offset(node)
+        if offset is not None:
+            return str(offset)
+        return self._history_offset_cpp(self._visit_expr(node.index), node.index)
+
+    def _lower_collection_history(self, node) -> str | None:
+        """The C++ of an annotated array or matrix history read, by its use:
+        a ``const`` copy a built-in reads (``at``), a copy for a variable or a
+        parameter (``value``), the receiver of a built-in that changes it
+        (``changed``: the run stops past a zero offset), the variable itself
+        for a for...in loop (TradingView iterates the current array) and at a
+        zero offset. None for any other read."""
+        annotation = history_annotation(node)
+        if annotation is None:
+            return None
+        current = self._visit_expr(node.object)
+        use = annotation["use"]
+        offset = literal_offset(node)
+        if use == "loop" or offset == 0:
+            return current
+        member = self._collection_history_member(self._collection_history_of(annotation))
+        index = self._collection_history_offset_cpp(node)
+        dynamic = offset is None
+        if use == "change":
+            return f"{member}.changed({index}, {current})"
+        if use == "copy":
+            return (f"{member}.value({index}, {current})" if dynamic
+                    else f"{member}.value({index})")
+        return (f"{member}.at({index}, {current})" if dynamic
+                else f"{member}.at({index})")
+
+    def _collection_history_na(self, node) -> str | None:
+        """``na(a[k])``: whether the history holds no copy there (an array
+        variable itself is never na in PineForge; a matrix may be)."""
+        annotation = history_annotation(node)
+        if annotation is None or annotation["use"] != "na":
+            return None
+        current = self._visit_expr(node.object)
+        offset = literal_offset(node)
+        if offset == 0:
+            return f"is_na({current})" if annotation["kind"] == "matrix" else "false"
+        member = self._collection_history_member(self._collection_history_of(annotation))
+        index = self._collection_history_offset_cpp(node)
+        if offset is None:
+            return f"{member}.is_na({index}, {current})"
+        return f"{member}.is_na({index})"
+
+    def _matrix_history_method_expr(self, receiver, method: str, spec, node) -> str:
+        """A matrix method called on a matrix's history, lowered as the
+        variable's own method call is (visit_call: a matrix variable's
+        method)."""
+        from .tables import MATRIX_METHOD_KWARGS, MATRIX_METHODS, _merge_kwargs
+
+        recv = self._visit_expr(receiver)
+        self._check_matrix_method_allowed(method, spec, node)
+        param_names = MATRIX_METHOD_KWARGS.get(method)
+        raw_args = (
+            _merge_kwargs(node.args, node.kwargs, param_names, lambda a: a)
+            if param_names and node.kwargs else list(node.args)
+        )
+        args = self._matrix_bool_value_args(
+            method, [self._visit_expr(a) for a in raw_args], raw_args, spec)
+        try:
+            return MATRIX_METHODS[method](recv, args)
+        except IndexError:
+            self._codegen_error(
+                node,
+                f"matrix.{method}: wrong number of arguments",
+                hint="Check Pine v6 matrix method signature (positional vs keyword).",
+            )

package/pineforge_codegen/codegen/emit_top.py

@@ -130,6 +130,8 @@ class TopLevelEmitter:
         )
         lines.append('#include <pineforge/source/pine_strategy_host.hpp>')
         lines.append('#include <pineforge/ta.hpp>')
+        lines.extend(['#if __has_include(<pineforge/checked_settings.hpp>)',
+                      '#include <pineforge/checked_settings.hpp>', '#endif'])
         if self._ta_uses_dynamic_lengths():
             lines.append('#include <pineforge/source/pine_ta_length.hpp>')
         lines.append('#include <pineforge/math.hpp>')
@@ -598,6 +600,7 @@ class TopLevelEmitter:
             '#error "Generated lifecycle reset requires a matching PineForge engine; rebuild with script-run preparation support"',
             "#endif",
             "    void prepare_script_run(const Bar* bars, int n, bool allow_precalculation) override {",
+            "        _pf_require_settings_ok();",
             "        _pf_script_state_checkpoint_.reset();",
         ])
         seen: set[str] = set()
@@ -1277,6 +1280,8 @@ class TopLevelEmitter:
         lines.append("        }")
         lines.append("        pineforge::source::PineStrategyHost::set_strategy_override(overrides);")
         lines.append("    }")
+        from .checked_settings import emit_settings_members
+        emit_settings_members(self, lines, ctor_body)
 
         if self._uses_recorded_requests():
             lines.extend([
@@ -1721,7 +1726,12 @@ class TopLevelEmitter:
                                 name,
                                 target_cpp_type=udt_name,
                             )
-                            lines.append(f"            {safe} = {cpp_val};")
+                            if self._binding_is_series(name, safe):
+                                # A history-read var object: its first
+                                # bar's slot holds the reference.
+                                lines.append(f"            {safe}.push({cpp_val});")
+                            else:
+                                lines.append(f"            {safe} = {cpp_val};")
                             break
                     continue
                 if self._binding_is_series(name, safe):
@@ -1797,6 +1807,10 @@ class TopLevelEmitter:
         # c. Push non-var series (they start fresh each bar with a push)
         # (actual push happens in visit_VarDecl when the decl is visited)
 
+        # c1. A top-level var array's or matrix's history slot opens on every
+        # bar (pineforge_codegen/collection_history.py).
+        self._emit_collection_history_var_opens(lines, "        ")
+
         # c2. First-bar TA resize: rebuild any TA object whose ctor args come
         # from input-backed variables so strategy_set_input() actually changes
         # the circular-buffer sizes. Emits nothing when no TA site depends on
@@ -1815,6 +1829,10 @@ class TopLevelEmitter:
             finally:
                 self._clear_lazy_edge_ta_hoists()
 
+        # d2. The bar's end: each array or matrix variable whose history the
+        #     script reads keeps a copy of the value it ends the bar with.
+        self._emit_collection_history_closes(lines, "        ")
+
         # e. ``// @pf-trace`` pragma block — emitted last so trace values
         #    reflect every assignment / strategy call made earlier in the
         #    bar. The block is wrapped in ``if (trace_enabled_)`` so cost
@@ -1876,24 +1894,38 @@ class TopLevelEmitter:
     def _emit_extern_c(self, lines: list[str]) -> None:
         lines.append('extern "C" {')
         lines.append("    void* strategy_create(const char* params_json) {")
-        lines.append("        return new GeneratedStrategy();")
+        lines.append("        try { return new GeneratedStrategy(); } catch (...) { return nullptr; }")
         lines.append("    }")
         lines.append("    void run_backtest(void* s, Bar* bars, int n, ReportC* out) {")
+        lines.append("        try {")
         lines.append("        auto* strat = static_cast<GeneratedStrategy*>(s);")
+        lines.append("#ifndef PF_SETTINGS_API_VERSION")
+        lines.append("        if (strat->_pf_refuse_failed_setting(out)) return;")
+        lines.append("#endif")
         if self._security_calls:
             # If there are security calls, use the full run path. Pass empty strings
             # so the C++ runtime auto-detects input_tf from bar timestamps.
             lines.append('        strat->run(bars, n, "", "", false, 4, MagnifierDistribution::ENDPOINTS);')
         else:
             lines.append("        strat->run(bars, n);")
-        lines.append("        strat->fill_report(out);")
+        lines.append("        if (!strat->_pf_refuse_failed_setting(out)) strat->fill_report(out);")
+        lines.append('        } catch (const std::exception& _pf_error) {')
+        lines.append('            if (out) *out = ReportC{};')
+        lines.append('            if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest", _pf_error.what());')
+        lines.append('        } catch (...) {')
+        lines.append('            if (out) *out = ReportC{};')
+        lines.append('            if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest", "unknown C++ exception");')
+        lines.append('        }')
         lines.append("    }")
-        lines.append("    void run_backtest_full(void* s, Bar* bars, int n,")
+        lines.append("    static void _pf_run_backtest_full_impl(void* s, Bar* bars, int n,")
         lines.append('                           const char* input_tf, const char* script_tf,')
         lines.append("                           int bar_magnifier, int magnifier_samples,")
         lines.append("                           int magnifier_dist,")
         lines.append("                           ReportC* out) {")
         lines.append('        auto* strat = static_cast<GeneratedStrategy*>(s);')
+        lines.append("#ifndef PF_SETTINGS_API_VERSION")
+        lines.append("        if (strat->_pf_refuse_failed_setting(out)) return;")
+        lines.append("#endif")
         lines.append('        std::string itf = input_tf ? input_tf : "";')
         lines.append('        std::string stf = script_tf ? script_tf : "";')
         if self._security_calls:
@@ -1930,26 +1962,42 @@ class TopLevelEmitter:
             lines.append("            strat->run(bars, n, itf, stf, bar_magnifier != 0, magnifier_samples,")
             lines.append("                       static_cast<MagnifierDistribution>(magnifier_dist));")
             lines.append("        }")
-        lines.append("        strat->fill_report(out);")
+        lines.append("        if (!strat->_pf_refuse_failed_setting(out)) strat->fill_report(out);")
         lines.append("    }")
+        lines.extend([
+            "    void run_backtest_full(void* s, Bar* bars, int n, const char* input_tf, const char* script_tf,",
+            "                           int bar_magnifier, int magnifier_samples, int magnifier_dist, ReportC* out) {",
+            "        try { _pf_run_backtest_full_impl(s, bars, n, input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist, out); }",
+            '        catch (const std::exception& _pf_error) { if (out) *out = ReportC{}; if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest_full", _pf_error.what()); }',
+            '        catch (...) { if (out) *out = ReportC{}; if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest_full", "unknown C++ exception"); }',
+            "    }",
+        ])
         lines.append("    void strategy_free(void* s) {")
-        lines.append("        delete static_cast<GeneratedStrategy*>(s);")
+        lines.append("        try { delete static_cast<GeneratedStrategy*>(s); } catch (...) {}")
         lines.append("    }")
         lines.append("    void report_free(ReportC* report) {")
-        lines.append("        BacktestEngine::free_report(report);")
+        lines.append("        try { BacktestEngine::free_report(report); } catch (...) {}")
         lines.append("    }")
         lines.append("    void strategy_set_input(void* s, const char* key, const char* value) {")
         lines.append("        if (!s || !key || !value) return;")
-        lines.append("        static_cast<GeneratedStrategy*>(s)->set_input(key, value);")
+        lines.append("        try { static_cast<GeneratedStrategy*>(s)->set_input(key, value); }")
+        lines.append('        catch (const std::exception& _pf_error) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_input", _pf_error.what()); }')
+        lines.append('        catch (...) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_input", "unknown C++ exception"); }')
         lines.append("    }")
         lines.append("    void strategy_set_override(void* s, const char* key, const char* value) {")
         lines.append("        if (!s || !key || !value) return;")
-        lines.append("        static_cast<GeneratedStrategy*>(s)->set_strategy_override(key, value);")
+        lines.append("        try { static_cast<GeneratedStrategy*>(s)->set_strategy_override(key, value); }")
+        lines.append('        catch (const std::exception& _pf_error) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_override", _pf_error.what()); }')
+        lines.append('        catch (...) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_override", "unknown C++ exception"); }')
         lines.append("    }")
         lines.append("    void strategy_set_magnifier_volume_weighted(void* s, int on) {")
         lines.append("        if (!s) return;")
-        lines.append("        static_cast<GeneratedStrategy*>(s)->set_magnifier_volume_weighted(on != 0);")
+        lines.append("        try { static_cast<GeneratedStrategy*>(s)->set_magnifier_volume_weighted(on != 0); }")
+        lines.append('        catch (const std::exception& _pf_error) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_magnifier_volume_weighted", _pf_error.what()); }')
+        lines.append('        catch (...) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_magnifier_volume_weighted", "unknown C++ exception"); }')
         lines.append("    }")
+        from .checked_settings import emit_settings_exports
+        emit_settings_exports(lines)
         if self._declares_bar_magnifier():
             # TradingView runs a script that declares use_bar_magnifier = true
             # on its bar magnifier; the host reads this export to run it on
@@ -2103,11 +2151,16 @@ class TopLevelEmitter:
 
             if (
                 receiver_spec is not None
-                and receiver_spec.kind == "primitive"
+                and (receiver_spec.kind == "primitive"
+                     or (receiver_spec.kind == "udt"
+                         and (receiver_spec.name in DRAWING_TYPE_TO_CPP
+                              or receiver_spec.name in self._udt_defs)))
                 and p in func_sv
             ):
                 # A primitive receiver used with history is a Series boundary,
-                # just like an ordinary history-bearing UDF parameter.
+                # just like an ordinary history-bearing UDF parameter; so is
+                # an object or drawing receiver (``this[1]`` is the receiver of
+                # the previous call: fixtures/udt_history_tv udth_method).
                 elem_cpp_t = self._series_param_element_cpp_type(
                     fi, i, call_site_idx
                 )
@@ -2118,6 +2171,9 @@ class TopLevelEmitter:
                 self._current_func_series_param_types[
                     self._safe_name(p)
                 ] = elem_cpp_t
+                if receiver_spec.kind == "udt":
+                    self._udt_param_udt[self._safe_name(p)] = receiver_spec.name
+                    self._udt_param_udt[p] = receiver_spec.name
             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:
@@ -2352,10 +2408,16 @@ class TopLevelEmitter:
                 ),
             )
             if (drawing_name in DRAWING_TYPE_TO_CPP
-                and self._current_func_param_types.get(
+                and (self._current_func_param_types.get(
                     param, ""
                 ).removesuffix("&").removesuffix("*")
-                == DRAWING_TYPE_TO_CPP[drawing_name])
+                == DRAWING_TYPE_TO_CPP[drawing_name]
+                # A history-read drawing parameter or receiver is a
+                # ``const Series<Box>&``: ``(x[1]).get_top()`` dispatches on
+                # the handle it holds (udth_drawparam).
+                or (param in self._current_func_series_params
+                    and self._current_func_series_param_types.get(param)
+                    == DRAWING_TYPE_TO_CPP[drawing_name])))
         }
         self._lexical_udt_types = {
             param: (

package/pineforge_codegen/codegen/helpers.py

@@ -314,7 +314,13 @@ CPP_EMITTER_NAMES = frozenset("""
     _pf_drawing_na _pf_collect_drawings _pf_collect_lines_ _pf_collect_boxes_
     _pf_collect_labels_ _pf_new _pf_held
     get_input_int get_input_float get_input_bool get_input_string
-    trace is_na na nz fixnan
+    _pf_record_failure _pf_refuse_failed_setting _pf_settings_declared_config
+    _pf_record_setting_failure _pf_require_settings_ok
+    _pf_setting_failed_ _pf_setting_failure_
+    _pf_settings_inputs _pf_settings_overrides _pf_set_input_checked
+    _pf_set_override_checked _pf_settings_receipt
+    _pf_close_entries_rule_word _pf_default_qty_type_word _pf_commission_type_word
+    checked_settings trace is_na na nz fixnan
 """.split())
 
 # The generated history members, ``_<kind>_<n>`` (codegen/base.py
@@ -345,7 +351,10 @@ CPP_RESERVED = set(
 # ``_nz_v``) or initialized itself from itself (``_pna_l > close`` did not
 # compile). ``_safe_name`` escapes an authored spelling of any of them. A
 # temporary whose name the emitter allocates against the authored spellings
-# itself (``__pf_map_iter_N``, ``_pf_udt_Item__pf2``) is not listed.
+# itself (``__pf_map_iter_N``, ``_pf_udt_Item__pf2``) is not listed. An
+# array's or a matrix's history member (``_pf_collection_hist_<name>``,
+# ``_pf_collection_hist_<n>_<name>``) is reserved the same way: a script
+# variable of that spelling was a second member of one name.
 CPP_TEMPORARY_NAMES = frozenset("""
     _nz_v _nz_y _fixnan_v _pna_l _pna_r _pfc_l _pfc_r _pfc_eq _hv _hidx _sv
     _out _func_ret _pf_v _pf_idx_v _pf_idx_t _pf_bool_v _pf_bool_t
@@ -364,6 +373,7 @@ _CPP_TEMPORARY_PATTERN = re.compile(
     r"_v\d+|_secval_\d+(?:_v\d+)?|_tuple_result_\d+|_tuple_unused_\d+|__switch_val_\d+"
     r"|_for_(?:start|end|end_eval)_\d+|_pf_(?:str|array|round)_a\d+"
     r"|_pf_every_bar_ta_\d+|_pf_shared_\d+_\d+|__pf_array\w*|__pf_raw_\w+"
+    r"|_pf_collection_hist_\w+"
 )
 
 

package/pineforge_codegen/codegen/host_members.py

@@ -8,6 +8,7 @@ strategy class, so ``_safe_name`` renames it.
 """
 
 HOST_MEMBER_NAMES = frozenset({
+    "StreamPhase",
     "_src_close_",
     "_src_high_",
     "_src_hl2_",
@@ -50,6 +51,7 @@ HOST_MEMBER_NAMES = frozenset({
     "closed_trade_profit_percent",
     "closed_trade_size",
     "commit_script_state",
+    "config_",
     "configure_pine_strategy",
     "configure_security_evaluators",
     "count_losstrades",
@@ -74,9 +76,12 @@ HOST_MEMBER_NAMES = frozenset({
     "history_advances_new_bar",
     "initial_capital_",
     "input_tf_",
+    "inputs_",
     "is_first_tick",
     "is_last_tick_",
     "last_bar_time_",
+    "last_error",
+    "last_error_",
     "main_period",
     "margin_liquidation_price",
     "max_contracts_held_all",
@@ -104,6 +109,7 @@ HOST_MEMBER_NAMES = frozenset({
     "open_trade_profit_percent",
     "open_trade_size",
     "open_trades_capital_held",
+    "override_",
     "pine_bar_index",
     "pine_last_bar_index",
     "pine_session_ismarket",
@@ -123,6 +129,7 @@ HOST_MEMBER_NAMES = frozenset({
     "restore_script_state",
     "round_to_mintick",
     "run",
+    "script_bars_processed",
     "script_tf_",
     "security_column_value",
     "security_eval_states_",
@@ -151,6 +158,7 @@ HOST_MEMBER_NAMES = frozenset({
     "strategy_exit",
     "strategy_exit_cancel_bracket",
     "strategy_order",
+    "stream_phase_",
     "symbol_facts_",
     "symbol_feeds_",
     "syminfo_",

package/pineforge_codegen/codegen/input.py

@@ -85,14 +85,43 @@ class InputHelper:
             while merged and merged[-1] is None:
                 merged.pop()
             if merged and merged[0] is not None:
-                return merged[0]
+                return self._fold_enum_input_default(node, merged[0])
             return None
         if node.args:
-            return node.args[0]
+            return self._fold_enum_input_default(node, node.args[0])
         if "defval" in node.kwargs:
-            return node.kwargs["defval"]
+            return self._fold_enum_input_default(node, node.kwargs["defval"])
         return None
 
+    def _fold_enum_input_default(self, node: FuncCall, default):
+        """Resolve an enum defval's immutable, source-ordered initializer."""
+        func_name, namespace = self._resolve_callee(node.callee)
+        if namespace != "input" or func_name != "enum" or not isinstance(default, Identifier):
+            return default
+        declarations = {}
+        reassigned = self._find_reassigned_vars()
+        for statement in self.ctx.ast.body:
+            if any(candidate is node for candidate in self._walk_ast(statement)):
+                break
+            if isinstance(statement, VarDecl):
+                declarations.setdefault(statement.name, []).append(statement)
+        candidate = default
+        visited = set()
+        while isinstance(candidate, Identifier) and candidate.name not in visited:
+            visited.add(candidate.name)
+            bindings = declarations.get(candidate.name, [])
+            if len(bindings) != 1 or candidate.name in reassigned:
+                return default
+            declaration = bindings[0]
+            if declaration.is_var or declaration.is_varip:
+                return default
+            candidate = declaration.value
+        if isinstance(candidate, MemberAccess) and isinstance(candidate.object, Identifier):
+            members = self._enum_defs.get(candidate.object.name, [])
+            if candidate.member in members:
+                return candidate
+        return default
+
     def _input_default_value(self, node: FuncCall) -> tuple[bool, object]:
         """``(True, value)`` when the defval is the constant a ``v = input...``
         binding records as ``v``'s known value -- a number, bool or string
@@ -527,6 +556,10 @@ class InputHelper:
             "type": form_type,
             "default": default_val,
         }
+        if namespace == "input" and func_name == "symbol":
+            # A symbol string, which the type does not tell from a string's:
+            # the requests of another symbol key their feeds on its value.
+            entry["kind"] = "symbol"
         # Pull min/max/step/options by signature param name; emit only
         # const literals so the override form never references a runtime
         # value it can't reproduce.

package/pineforge_codegen/codegen/security.py

@@ -88,7 +88,7 @@ from .helpers import na_preserving_int_cast, unary_sign_cpp
 from ..security_contexts import GLOBAL_ANNOTATION, UNREACHED_ANNOTATION
 from ..symbols import PineType, method_receiver_type_name
 from .tables import (
-    BAR_BUILTINS, MATH_FUNC_MAP, PINE_TYPE_TO_CPP, SECURITY_BAR_FIELDS,
+    BAR_BUILTINS, DRAWING_TYPE_TO_CPP, MATH_FUNC_MAP, PINE_TYPE_TO_CPP, SECURITY_BAR_FIELDS,
     SECURITY_BAR_FIELD_EXPRS, SECURITY_BAR_FIELD_TYPES, TA_TUPLE_FIELDS,
     _math_minmax_na_expr, _math_round_digits_expr, _merge_kwargs,
 )
@@ -6127,11 +6127,66 @@ class SecurityEmitter:
         lines.append("    }")
         lines.append("")
 
+    def _refuse_security_reference_history(self, item: dict) -> None:
+        """A request.security expression that reads the history of an
+        object or drawing reference, itself or in a function or method it
+        calls. TradingView evaluates it on the requested bars, where the
+        variable holds the objects of that timeframe's bars; PineForge keeps
+        such a history on the chart's bars only, and the payload read the
+        chart's (it never compiled before: the history was a
+        ``Series<double>``). Refused."""
+        if item["expr_node"] is None:
+            # ``request.security(sym, tf)`` with no expression: lowered to na
+            # as it always was (TradingView refuses it, CE10165).
+            return
+        pending = [item["expr_node"]]
+        seen: set[str] = set()
+        while pending:
+            for node, _depth in iter_ast_nodes(pending.pop()):
+                if isinstance(node, Subscript):
+                    receiver = node.object
+                    kind = (self._series_handle_type_name(receiver.name)
+                            if isinstance(receiver, Identifier) else None)
+                    if kind is None:
+                        spec = self._type_spec_from_expr(receiver)
+                        if (spec is not None and spec.kind == "udt"
+                                and (spec.name in DRAWING_TYPE_TO_CPP
+                                     or spec.name in self._udt_defs)):
+                            kind = spec.name
+                    if kind is not None:
+                        self._codegen_error(
+                            node,
+                            f"History of a {kind} reference inside a "
+                            "request.security expression is not supported in "
+                            "PineForge: TradingView reads the references the "
+                            "variable held on the requested timeframe's bars, "
+                            "which PineForge does not keep.",
+                            hint="Request the field values the expression "
+                                 "needs (request.security(..., obj.field)) "
+                                 "and read their history on the chart.",
+                        )
+                if not isinstance(node, FuncCall):
+                    continue
+                func_name, namespace = self._resolve_callee(node.callee)
+                keys = []
+                if namespace is None and func_name in self._func_info_map:
+                    keys.append(func_name)
+                if isinstance(node.callee, MemberAccess):
+                    keys.extend(key for key in self._func_info_map
+                                if key.endswith(f".{node.callee.member}"))
+                for key in keys:
+                    body = getattr(self._func_info_map[key], "node", None)
+                    if key not in seen and body is not None:
+                        seen.add(key)
+                        pending.append(body)
+
     def _emit_security_evaluators(self, lines: list[str]) -> None:
         """Emit _eval_security_N() methods and evaluate_security() dispatch."""
         if not self._security_calls:
             return
 
+        for item in self._security_calls:
+            self._refuse_security_reference_history(item)
         for item in self._security_calls:
             self._emit_security_evaluator_requested(item, lines)