@pineforge/codegen-pyodide 1.3.0 → 1.4.0

package/pineforge_codegen/codegen/collection_history.py

@@ -14,20 +14,167 @@ TradingView's read-only history (fixtures/array_history_tv).
 from __future__ import annotations
 
 from ..collection_history import (
+    COLLECTION_HISTORY_ARRAY_VALUE_CPP,
     COLLECTION_HISTORY_CLASS_CPP,
     COLLECTION_HISTORY_CPP,
     COLLECTION_HISTORY_GENERIC_MATRIX_CPP,
     COLLECTION_HISTORY_MATRIX_CPP,
+    NA_MATRIX_MESSAGE,
     history_annotation,
     literal_offset,
 )
-from ..ast_nodes import FuncCall, Identifier, MemberAccess
+from ..ast_nodes import Assignment, FuncCall, FuncDef, Identifier, MemberAccess, MethodDef, Ternary, VarDecl
+from ..limits import iter_ast_nodes
 from ..symbols import TypeSpec
 
 
 class CollectionHistoryEmitter:
     """CodeGen mixin: the history members of array and matrix variables."""
 
+    def _matrix_history_value_names(self) -> set[str]:
+        cached = getattr(self, "_matrix_history_value_bindings", None)
+        if cached is not None:
+            return cached
+        names = set()
+        bindings = {}
+        callable_depth = None
+        for node, depth in iter_ast_nodes(self.ctx.ast):
+            if callable_depth is not None:
+                if depth > callable_depth:
+                    continue
+                callable_depth = None
+            if isinstance(node, (FuncDef, MethodDef)):
+                callable_depth = depth
+                continue
+            if isinstance(node, VarDecl):
+                name, value = node.name, node.value
+            elif isinstance(node, Assignment) and isinstance(node.target, Identifier):
+                name, value = node.target.name, node.value
+            else:
+                continue
+            values = [value]
+            while values:
+                source = values.pop()
+                annotation = history_annotation(source)
+                if annotation is not None and annotation["kind"] == "matrix":
+                    names.add(name)
+                elif isinstance(source, Identifier):
+                    bindings.setdefault(source.name, []).append(name)
+                elif isinstance(source, Ternary):
+                    values.extend((source.true_val, source.false_val))
+        pending = list(names)
+        while pending:
+            source = pending.pop()
+            for name in bindings.get(source, ()):
+                if name not in names:
+                    names.add(name)
+                    pending.append(name)
+        self._matrix_history_value_bindings = names
+        return names
+
+    def _checked_matrix_history_receiver(self, receiver, receiver_node):
+        if (isinstance(receiver_node, Identifier)
+                and receiver_node.name in self._matrix_history_value_names()
+                and not self._collection_name_is_lexically_shadowed(receiver_node.name)
+                and receiver_node.name not in self._current_func_param_types):
+            return (f'([&]() -> auto& {{ if (is_na({receiver})) '
+                    f'_PF_COLLECTION_STOP("na_reference", "matrix", "{NA_MATRIX_MESSAGE}"); '
+                    f'return {receiver}; }}())')
+        return receiver
+
+    def _array_history_value_names(self) -> dict[str, TypeSpec]:
+        cached = getattr(self, "_array_history_value_specs", None)
+        if cached is not None:
+            return cached
+        bindings = {}
+        specs = {}
+        callable_depth = None
+        for node, depth in iter_ast_nodes(self.ctx.ast):
+            if callable_depth is not None:
+                if depth > callable_depth:
+                    continue
+                callable_depth = None
+            if isinstance(node, (FuncDef, MethodDef)):
+                callable_depth = depth
+                continue
+            if isinstance(node, VarDecl):
+                name, value = node.name, node.value
+            elif isinstance(node, Assignment) and isinstance(node.target, Identifier):
+                name, value = node.target.name, node.value
+            else:
+                continue
+            annotation = history_annotation(value)
+            if annotation is not None and annotation["use"] == "reference":
+                specs[name] = annotation["spec"]
+            else:
+                values = [value]
+                while values:
+                    source_value = values.pop()
+                    if isinstance(source_value, Identifier):
+                        bindings.setdefault(source_value.name, []).append(name)
+                    elif isinstance(source_value, Ternary):
+                        values.extend((source_value.true_val, source_value.false_val))
+        pending = list(specs)
+        while pending:
+            source = pending.pop()
+            for name in bindings.get(source, ()):
+                if name not in specs:
+                    specs[name] = specs[source]
+                    pending.append(name)
+        for name, spec in specs.items():
+            self._array_vars.add(name)
+            self._collection_types[name] = spec
+        self._array_history_value_specs = specs
+        return specs
+
+    def _array_history_value_cpp_type(self, name: str) -> str | None:
+        spec = self._array_history_value_names().get(name)
+        if spec is None:
+            return None
+        spec = self._widen_array_spec_for_name(name, spec)
+        return f"_PFArrayHistoryValue<{self._type_spec_to_cpp(spec)}>"
+
+    def _array_history_value_expr_cpp_type(self, value) -> str | None:
+        values = [value]
+        while values:
+            source = values.pop()
+            if isinstance(source, Identifier):
+                if (self._collection_name_is_lexically_shadowed(source.name)
+                        or source.name in self._current_func_param_types):
+                    continue
+                cpp_type = self._array_history_value_cpp_type(source.name)
+                if cpp_type is not None:
+                    return cpp_type
+            elif isinstance(source, Ternary):
+                values.extend((source.true_val, source.false_val))
+        return None
+
+    def _legacy_array_history_element(self, receiver: str, spec: TypeSpec,
+                                      offset: str, mutable: bool = False) -> str:
+        element_cpp = self._type_spec_to_cpp(spec.element)
+        if self._array_history_value_names():
+            receiver = f"_pf_array_id({receiver})"
+        if mutable:
+            return (
+                f"([&]() -> decltype(auto) {{ "
+                f"auto& _pf_history_array = {receiver}; "
+                f"const int _pf_history_offset = {offset}; "
+                f"if (_pf_history_offset < 0 || "
+                f"static_cast<size_t>(_pf_history_offset) >= _pf_history_array.size()) "
+                f'_PF_ARRAY_STOP("index_out_of_bounds", nullptr, '
+                f'"Array history element index is out of bounds."); '
+                f"return _pf_history_array.at(_pf_history_offset); }}())"
+            )
+        return (
+            f"([&]() -> {element_cpp} {{ "
+            f"const auto& _pf_history_array = {receiver}; "
+            f"const int _pf_history_offset = {offset}; "
+            f"if (_pf_history_offset < 0 || "
+            f"static_cast<size_t>(_pf_history_offset) >= _pf_history_array.size()) "
+            f"return na<{element_cpp}>(); "
+            f"return _pf_history_array[_pf_history_offset]; }}())"
+        )
+
     def _collection_history_variables(self) -> list:
         """The declarations whose history the script reads, in key order."""
         history = getattr(self.ctx, "collection_history", None) or {}
@@ -59,11 +206,12 @@ class CollectionHistoryEmitter:
 
     def _emit_collection_history_helper(self, lines: list[str]) -> None:
         variables = self._collection_history_variables()
-        if not variables:
+        if not variables and not self._array_history_value_names():
             return
         float_spec = TypeSpec.primitive("float")
         matrices = [v.spec for v in variables if v.kind == "matrix"]
         lines.append(COLLECTION_HISTORY_CPP.strip("\n"))
+        lines.append(COLLECTION_HISTORY_ARRAY_VALUE_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):
@@ -146,6 +294,9 @@ class CollectionHistoryEmitter:
         current = self._visit_expr(node.object)
         use = annotation["use"]
         offset = literal_offset(node)
+        if use == "reference" and offset == 0:
+            cpp_type = self._type_spec_to_cpp(annotation["spec"])
+            return f"_PFArrayHistoryValue<{cpp_type}>({current})"
         if use == "loop" or offset == 0:
             return current
         member = self._collection_history_member(self._collection_history_of(annotation))
@@ -153,6 +304,9 @@ class CollectionHistoryEmitter:
         dynamic = offset is None
         if use == "change":
             return f"{member}.changed({index}, {current})"
+        if use == "reference":
+            return (f"{member}.reference({index}, {current})" if dynamic
+                    else f"{member}.reference({index})")
         if use == "copy":
             return (f"{member}.value({index}, {current})" if dynamic
                     else f"{member}.value({index})")
@@ -168,7 +322,10 @@ class CollectionHistoryEmitter:
         current = self._visit_expr(node.object)
         offset = literal_offset(node)
         if offset == 0:
-            return f"is_na({current})" if annotation["kind"] == "matrix" else "false"
+            nullable_array = (isinstance(node.object, Identifier)
+                              and node.object.name in self._array_history_value_names())
+            return (f"is_na({current})" if annotation["kind"] == "matrix"
+                    or nullable_array else "false")
         member = self._collection_history_member(self._collection_history_of(annotation))
         index = self._collection_history_offset_cpp(node)
         if offset is None:
@@ -179,19 +336,13 @@ class CollectionHistoryEmitter:
         """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)
-        )
+        raw_args = self._matrix_method_arg_nodes(method, node)
         args = self._matrix_bool_value_args(
-            method, [self._visit_expr(a) for a in raw_args], raw_args, spec)
+            method, [self._visit_expr(a) if a is not None else None for a in raw_args], raw_args, spec)
         try:
-            return MATRIX_METHODS[method](recv, args)
+            return self._matrix_method_expr(recv, method, args, raw_args, node)
         except IndexError:
             self._codegen_error(
                 node,

package/pineforge_codegen/codegen/emit_top.py

@@ -84,6 +84,8 @@ from __future__ import annotations
 
 import re
 
+from .run_stops import RUN_STOP_SHIMS_CPP
+
 from ..ast_nodes import (
     BoolLiteral, ExprStmt, ForInStmt, ForStmt, FuncCall, Identifier, IfStmt,
     MemberAccess, SwitchStmt, TupleAssign, TupleLiteral, VarDecl, WhileStmt,
@@ -218,6 +220,7 @@ class TopLevelEmitter:
         # in favour of fully qualified names emitted at each call site.
         lines.append("using namespace pineforge;")
         lines.append("")
+        lines.append(RUN_STOP_SHIMS_CPP)
         self._emit_ta_compat_shims(lines)
         if getattr(self, "_uses_drawing", False):
             lines.append(DRAWING_LIFETIME_CPP)
@@ -1894,8 +1897,17 @@ class TopLevelEmitter:
 
     def _emit_extern_c(self, lines: list[str]) -> None:
         lines.append('extern "C" {')
+        lines.append("#if defined(PINEFORGE_HAS_RUN_FAILURE_CODES_V1) && defined(PF_SETTINGS_API_VERSION)")
+        lines.append("    int strategy_create_checked(const char* params_json, void** out, char* error, size_t error_capacity);")
+        lines.append("#endif")
         lines.append("    void* strategy_create(const char* params_json) {")
+        lines.append("#if defined(PINEFORGE_HAS_RUN_FAILURE_CODES_V1) && defined(PF_SETTINGS_API_VERSION)")
+        lines.append("        void* out = nullptr;")
+        lines.append("        strategy_create_checked(nullptr, &out, nullptr, 0);")
+        lines.append("        return out;")
+        lines.append("#else")
         lines.append("        try { return new GeneratedStrategy(); } catch (...) { return nullptr; }")
+        lines.append("#endif")
         lines.append("    }")
         lines.append("    void run_backtest(void* s, Bar* bars, int n, ReportC* out) {")
         lines.append("        try {")
@@ -1912,7 +1924,7 @@ class TopLevelEmitter:
         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('            if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest", _pf_error);')
         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");')
@@ -1969,7 +1981,7 @@ class TopLevelEmitter:
             "    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 (const std::exception& _pf_error) { if (out) *out = ReportC{}; if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest_full", _pf_error); }',
             '        catch (...) { if (out) *out = ReportC{}; if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest_full", "unknown C++ exception"); }',
             "    }",
         ])
@@ -1982,20 +1994,24 @@ class TopLevelEmitter:
         lines.append("    void strategy_set_input(void* s, const char* key, const char* value) {")
         lines.append("        if (!s || !key || !value) return;")
         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('        catch (const std::exception& _pf_error) { _PF_SETTING_FAILURE(static_cast<GeneratedStrategy*>(s), "strategy_set_input", _pf_error.what(), nullptr); }')
+        lines.append('        catch (...) { _PF_SETTING_FAILURE(static_cast<GeneratedStrategy*>(s), "strategy_set_input", "unknown C++ exception", nullptr); }')
         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("        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('#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1')
+        lines.append('        catch (const std::invalid_argument& _pf_error) { _PF_SETTING_FAILURE(static_cast<GeneratedStrategy*>(s), "strategy_set_override", _pf_error.what(), "unparseable_value"); }')
+        lines.append('        catch (const std::out_of_range& _pf_error) { _PF_SETTING_FAILURE(static_cast<GeneratedStrategy*>(s), "strategy_set_override", _pf_error.what(), "unparseable_value"); }')
+        lines.append('#endif')
+        lines.append('        catch (const std::exception& _pf_error) { _PF_SETTING_FAILURE(static_cast<GeneratedStrategy*>(s), "strategy_set_override", _pf_error.what(), nullptr); }')
+        lines.append('        catch (...) { _PF_SETTING_FAILURE(static_cast<GeneratedStrategy*>(s), "strategy_set_override", "unknown C++ exception", nullptr); }')
         lines.append("    }")
         lines.append("    void strategy_set_magnifier_volume_weighted(void* s, int on) {")
         lines.append("        if (!s) return;")
         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('        catch (const std::exception& _pf_error) { _PF_SETTING_FAILURE(static_cast<GeneratedStrategy*>(s), "strategy_set_magnifier_volume_weighted", _pf_error.what(), nullptr); }')
+        lines.append('        catch (...) { _PF_SETTING_FAILURE(static_cast<GeneratedStrategy*>(s), "strategy_set_magnifier_volume_weighted", "unknown C++ exception", nullptr); }')
         lines.append("    }")
         from .checked_settings import emit_settings_exports
         emit_settings_exports(lines)

package/pineforge_codegen/codegen/helpers.py

@@ -262,12 +262,18 @@ CPP_STANDARD_MACROS = frozenset("""
     PINEFORGE_HAS_NATIVE_LOWERING_V1 PINEFORGE_HAS_NATIVE_LIVE_V1
     PINEFORGE_HAS_AUX_SECURITY_FEED_V1 PINEFORGE_HAS_SCRIPT_RUN_PREPARE_V1
     PINEFORGE_HAS_EXPLICIT_PINE_CAP_V1
+    PINEFORGE_HAS_RUN_FAILURE_CODES_V1
+    _PF_NO_DATA_STOP _PF_OTHER_SYMBOL_STOP _PF_ARRAY_STOP _PF_COLLECTION_STOP
+    _PF_NA_STOP _PF_LIMIT_STOP _PF_UNSUPPORTED_STOP _PF_STRING_STOP
+    _PF_ENGINE_INVARIANT _PF_INVARIANT_AT _PF_SETTING_FAILURE
     PINEFORGE_HAS_EXPLICIT_PINE_EXECUTION_ADAPTER_V1
     PINEFORGE_NO_STRATEGY_DECLS PF_PINE_TIME_HAS_SESSION_DAY
     PF_PINE_TIME_SESSION_DAY_ARGS PF_VWAP_HAS_SESSION_ANCHOR
     PF_VWAP_SESSION_ANCHOR_ARGS PF_ALMA_HAS_FLOOR
     PF_KC_HAS_USE_TRUE_RANGE PF_VWAP_HAS_ANCHOR_INPUT
     PF_PIVOT_LEVELS_HAS_ANCHOR
+    PF_ABI_VERSION PF_NATIVE_API_VERSION
+    PF_CAPABILITIES_API_VERSION PF_SETTINGS_API_VERSION
 """.split())
 
 # Identifiers used by the emitter as class/type names, namespaces, and
@@ -283,6 +289,9 @@ CPP_EMITTER_NAMES = frozenset("""
     commit_script_state set_strategy_override set_input
     set_magnifier_volume_weighted strategy_declares_bar_magnifier fill_report run
     strategy_capabilities_api_version strategy_capabilities_receipt
+    strategy_confirmed_bar_api_version strategy_confirmed_bar_receipt
+    strategy_order_shapes_api_version strategy_order_shapes_receipt
+    strategy_settings_api_version strategy_get_effective_settings
     precalculate
     strategy_entry strategy_close strategy_close_all strategy_exit
     strategy_exit_cancel_bracket strategy_cancel strategy_cancel_all strategy_order
@@ -291,6 +300,9 @@ CPP_EMITTER_NAMES = frozenset("""
     live_position_size pending_order_count market_admission_journal
     pine_time pine_time_close pine_time_tradingday pine_random
     pine_runtime_error pine_enum_str_at pine_session_ismarket
+    pine_no_data_stop pine_other_symbol_stop pine_array_stop pine_collection_stop
+    pine_na_stop pine_limit_stop pine_unsupported_stop pine_string_stop
+    pine_engine_invariant note_run_failure note_run_failure_unknown
     pine_session_ispostmarket pine_session_ispremarket _PFSessionMarket
     _pf_session_market_ script_tf_
     tf_change tf_is_daily tf_is_intraday tf_is_monthly tf_is_seconds
@@ -317,7 +329,8 @@ CPP_EMITTER_NAMES = frozenset("""
     get_input_int get_input_float get_input_bool get_input_string
     _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_setting_failed_ _pf_setting_failure_ _pf_setting_failure_info_
+    _pf_setting_error_base _pf_latched_setting_error _pf_invariant_at
     _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
@@ -369,12 +382,16 @@ CPP_TEMPORARY_NAMES = frozenset("""
     __pf_s __pf_r __pf_p __pf_i __pf_j __pf_t __pf_it __pf_m __pf_c __pf_n
     __pf_k __pf_b __pf_ma __pf_mb __pf_f __pf_d __pf_best __pf_bc __pf_rank
     __pf_idx __pf_occ
+    _pf_number_text
+    _pf_substring_text _pf_substring_begin _pf_substring_end _pf_substring_error
+    _pf_array_new_size _pf_array_new_value _pf_array_new_size_type _pf_array_new_error
 """.split())
 _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+"
+    r"|_pf_substring_arg\d+"
 )
 
 
@@ -432,6 +449,7 @@ class NamingHelper:
             .replace("\n", "\\n")
             .replace("\r", "\\r")
             .replace("\t", "\\t")
+            .replace("\0", "\\000")
         )
 
     @staticmethod

package/pineforge_codegen/codegen/host_members.py

@@ -148,6 +148,7 @@ HOST_MEMBER_NAMES = frozenset({
     "set_pine_risk_max_intraday_filled_orders",
     "set_pine_risk_max_intraday_loss",
     "set_pine_risk_max_position_size",
+    "set_recorded_series",
     "set_strategy_override",
     "signed_position_size",
     "snapshot_script_state",

package/pineforge_codegen/codegen/input.py

@@ -25,6 +25,7 @@ from ..ast_nodes import (
     MemberAccess,
     NumberLiteral,
     StringLiteral,
+    UnaryOp,
     VarDecl,
 )
 from .. import signatures as sigs
@@ -453,7 +454,7 @@ class InputHelper:
     # Input manifest extraction (host UI override-form source of truth)
     # ------------------------------------------------------------------
 
-    def _literal_or_none(self, node):
+    def _literal_or_none(self, node, *, signed: bool = False):
         """Return a JSON scalar for a *const* literal AST node, else None.
 
         ``None`` signals non-const (an identifier, computed expression, …) so
@@ -469,6 +470,10 @@ class InputHelper:
             return node.value
         if isinstance(node, NumberLiteral):
             return node.value
+        if signed and isinstance(node, UnaryOp) and node.op in ("+", "-"):
+            value = self._literal_or_none(node.operand, signed=True)
+            if isinstance(value, (int, float)) and not isinstance(value, bool):
+                return value if node.op == "+" else -value
         # enum member ref like ``Dir.Up`` -> "Dir.Up" (string tag)
         if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
             return f"{node.object.name}.{node.member}"
@@ -503,12 +508,17 @@ class InputHelper:
         ``var = input.*(...)`` declaration and an inline call inside an
         expression (``ta.ema(close, input.int(9, "Fast"))``) alike.
 
-        Each entry: ``{title, type, default[, min, max, step, options]}``. The
-        optional keys are emitted only when the corresponding signature
-        argument is a const literal; a bound/option referencing a non-literal
-        is omitted (never crashes). ``title`` is the key the emitted C++ reads
-        the input by: the title argument, else the name of the declaration
-        holding the call (``pine_spelling.input_binding_names``), else "".
+        Each entry: ``{title, type, default, supported[, min, max, step,
+        options]}``. ``supported``, a string input's default and options, a
+        source input's default and choices, an enum's choices and a typed
+        numeric input's literal default, bounds and options are the values
+        of the checked-settings receipt (the descriptor ``generate()``
+        builds with it). The optional keys are emitted only when the
+        corresponding signature argument is a const literal; a bound/option
+        referencing a non-literal is omitted (never crashes). ``title`` is
+        the key the emitted C++ reads the input by: the title argument, else
+        the name of the declaration holding the call
+        (``pine_spelling.input_binding_names``), else "".
         """
         return [self._input_manifest_entry(node, name)
                 for node, name in self._global_input_calls_with_names()]
@@ -528,7 +538,7 @@ class InputHelper:
         title = self._get_input_title(node, var_name=var_name)
         default_node = self._get_input_default(node)
         default_val = (
-            self._literal_or_none(default_node)
+            self._literal_or_none(default_node, signed=True)
             if default_node is not None
             else None
         )
@@ -581,4 +591,9 @@ class InputHelper:
                     # any non-const element -> omit the whole options list
                     if vals and all(isinstance(v, str) for v in vals):
                         entry["options"] = vals
+        descriptors = getattr(self, "_input_settings_metadata", None)
+        if descriptors is None:
+            raise RuntimeError("the input manifest reads the settings descriptors "
+                               "generate() builds: call generate() first")
+        entry.update(descriptors[id(node)])
         return entry

package/pineforge_codegen/codegen/run_stops.py

@@ -0,0 +1,52 @@
+"""Optional coded run stops, with the original throws on older engines."""
+
+from .helpers import NamingHelper
+
+
+RUN_STOP_SHIMS_CPP = r"""
+#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1
+#define _PF_NO_DATA_STOP(function, call, line, english) ::pineforge::pine_no_data_stop(function, call, line, english)
+#define _PF_OTHER_SYMBOL_STOP(function, symbol, call, line, english) ::pineforge::pine_other_symbol_stop(function, symbol, call, line, english)
+#define _PF_ARRAY_STOP(reason, method, english) ::pineforge::pine_array_stop(reason, method, std::string(english).c_str())
+#define _PF_COLLECTION_STOP(reason, object, english) ::pineforge::pine_collection_stop(object, reason, english)
+#define _PF_NA_STOP(object, english) ::pineforge::pine_na_stop(object, english)
+#define _PF_LIMIT_STOP(limit, max, english) ::pineforge::pine_limit_stop(limit, max, english)
+#define _PF_UNSUPPORTED_STOP(reason, line, english) ::pineforge::pine_unsupported_stop(reason, line, english)
+#define _PF_STRING_STOP(reason, english) ::pineforge::pine_string_stop(reason, english)
+#define _PF_ENGINE_INVARIANT(english, legacy_type) ::pineforge::pine_engine_invariant(english)
+#define _PF_INVARIANT_AT(container, index) _pf_invariant_at(container, index)
+#define _PF_SETTING_FAILURE(strategy, entrypoint, message, reason) (strategy)->_pf_record_setting_failure(entrypoint, message, [] { return reason ? ::pineforge::RunFailureInfo(::pineforge::RunFailureCode::setting_rejected, {{"entrypoint", entrypoint}, {"reason", reason}}) : ::pineforge::RunFailureInfo(::pineforge::RunFailureCode::setting_rejected, {{"entrypoint", entrypoint}}); })
+template <typename Container, typename Index>
+decltype(auto) _pf_invariant_at(Container& container, Index index) {
+    try { return container.at(index); }
+    catch (const std::out_of_range& error) { ::pineforge::pine_engine_invariant(error.what()); }
+}
+#else
+#define _PF_NO_DATA_STOP(function, call, line, english) pine_runtime_error(std::string(english))
+#define _PF_OTHER_SYMBOL_STOP(function, symbol, call, line, english) pine_runtime_error(std::string(english))
+#define _PF_ARRAY_STOP(reason, method, english) pine_runtime_error(english)
+#define _PF_COLLECTION_STOP(reason, object, english) pine_runtime_error(english)
+#define _PF_NA_STOP(object, english) throw std::runtime_error(english)
+#define _PF_LIMIT_STOP(limit, max, english) throw std::length_error(english)
+#define _PF_UNSUPPORTED_STOP(reason, line, english) pine_runtime_error(std::string(english))
+#define _PF_STRING_STOP(reason, english) pine_runtime_error(std::string(english))
+#define _PF_ENGINE_INVARIANT(english, legacy_type) throw legacy_type(english)
+#define _PF_INVARIANT_AT(container, index) (container).at(index)
+#define _PF_SETTING_FAILURE(strategy, entrypoint, message, reason) (strategy)->_pf_record_setting_failure(entrypoint, message)
+#endif
+"""
+
+
+def request_stop(marker: dict) -> str:
+    """Metadata comes only from the original request's compile-time spelling."""
+    escape = NamingHelper._cpp_string_escape
+    function = f'"{escape(marker["function"])}"'
+    call = f'"{escape(marker["call"])}"'
+    english = f'"{escape(marker["message"])}"'
+    arguments = f'{function}, {call}, {marker["line"]}, {english}'
+    if marker["kind"] == "other_symbol":
+        literal = marker["symbol_literal"]
+        symbol = "nullptr" if literal is None else f'"{escape(literal)}"'
+        arguments = f'{function}, {symbol}, {call}, {marker["line"]}, {english}'
+        return f"_PF_OTHER_SYMBOL_STOP({arguments})"
+    return f"_PF_NO_DATA_STOP({arguments})"

package/pineforge_codegen/codegen/security.py

@@ -2655,7 +2655,7 @@ class SecurityEmitter:
 
     def _security_expr_hist_series_names(self, sec_id: int) -> list[str]:
         names = []
-        for (sid, _node_id), meta in sorted(self._security_expr_hist_by_node.items()):
+        for (sid, _node_id), meta in self._security_expr_hist_by_node.items():
             if sid == sec_id:
                 names.append(meta["name"])
         return names
@@ -7227,7 +7227,8 @@ class SecurityEmitter:
                 "request.security: a Heikin-Ashi request inside another request's "
                 "expression reads that request's Heikin-Ashi bars, which PineForge "
                 "does not build")
-            return (f'([&]() -> {cpp_t} {{ pine_runtime_error(std::string("{message}")); '
+            line = expr_node.loc.line if expr_node.loc else 1
+            return (f'([&]() -> {cpp_t} {{ _PF_UNSUPPORTED_STOP("nested_heikinashi_request", {line}, "{message}"); '
                     f"return {na_value}; }}())")
 
         site = self._get_ta_site(expr_node)
@@ -7886,8 +7887,9 @@ class SecurityEmitter:
     def _security_variant_order_key(self, signature: tuple, binding_stack) -> tuple:
         """The order of a TA site's requested-context variants (``_v0``,
         ``_v1``, ...): where each argument binding's value is written in the
-        source, then the signature. The signature names a bound node by its
-        ``id()``, so ordering by its ``repr`` followed memory addresses, and
+        source, then the signature's stable scope snapshot, preserving
+        traversal order at ties. The signature names a bound node by its
+        ``id()``, so ordering by its raw ``repr`` followed memory addresses, and
         the same script could number its variants differently from run to
         run or between CPython and Pyodide."""
         frames = []
@@ -7909,4 +7911,9 @@ class SecurityEmitter:
                 frames.append(("arguments", tuple(items)))
             else:
                 frames.append(("locals", tuple(sorted(frame.keys()))))
-        return tuple(frames), repr(signature)
+        def stable_part(value):
+            if isinstance(value, tuple):
+                return tuple(stable_part(item) for item in value)
+            return 0 if isinstance(value, int) else value
+
+        return tuple(frames), repr(stable_part(signature))