@pineforge/codegen-pyodide 1.2.0 → 1.4.0

package/pineforge_codegen/codegen/checked_settings.py

@@ -1,7 +1,40 @@
 """Opt-in settings metadata, validation and exception-contained C exports."""
 
+import re
+
 from ..ast_nodes import Identifier, MemberAccess
 from ..errors import CompileError
+from .tables import ALERT_FREQ_VALUES, NAME_ECHO_STRING_MEMBERS, ORDER_DIRECTION_MAP
+
+
+_QUOTED_STRING = r'"(?:[^"\\\x00\r\n]|\\(?:["\\nrt]|000))*"'
+_STRING_LITERAL = re.compile(rf'(?:std::string\({_QUOTED_STRING}\)|{_QUOTED_STRING})')
+_STRING_ESCAPE = re.compile(r'\\(?:["\\nrt]|000)')
+_STRING_ESCAPE_VALUES = {
+    r'\"': '"', r'\\': '\\', r'\n': '\n', r'\r': '\r', r'\t': '\t', r'\000': '\0',
+}
+
+
+def _string_setting_arg(expr, lowered: str) -> str | None:
+    """Use the body's known string constants, never its inert visual codes.
+
+    Name-echo strings are accepted only for inventoried currency/format members.
+    Unknown constants leave the checked input unsupported; legacy getters
+    and setters retain their existing execution semantics.
+    """
+    if isinstance(expr, MemberAccess):
+        if not isinstance(expr.object, Identifier):
+            return None
+        namespace = expr.object.name
+        known = (
+            namespace == "alert" and expr.member in ALERT_FREQ_VALUES
+            or namespace == "order" and expr.member in ORDER_DIRECTION_MAP
+            or namespace == "session" and expr.member in ("regular", "extended")
+            or expr.member in NAME_ECHO_STRING_MEMBERS.get(namespace, ())
+        )
+        if not known:
+            return None
+    return lowered if _STRING_LITERAL.fullmatch(lowered) else None
 
 
 def _visit_setting_arg(emitter, expr) -> str:
@@ -16,22 +49,97 @@ def _visit_setting_arg(emitter, expr) -> str:
         return "0"
 
 
+def _string_setting_value(lowered: str) -> str:
+    """Decode the emitter's literals as native std::string(const char*) values.
+
+    Only the serializer's escape grammar is accepted; Unicode stays literal.
+    The receipt's string constructors stop at the first NUL, including one
+    followed by digits, while an escaped backslash remains ordinary data.
+    """
+    if not _STRING_LITERAL.fullmatch(lowered):
+        raise ValueError("setting value is not an emitted C++ string literal")
+    literal = lowered[len("std::string("):-1] if lowered.startswith("std::string(") else lowered
+    decoded = _STRING_ESCAPE.sub(lambda match: _STRING_ESCAPE_VALUES[match.group()], literal[1:-1])
+    return decoded.partition("\0")[0]
+
+
+_NUMERIC_LITERAL = re.compile(r"[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?(?:LL|ULL|L|UL|[fF])?")
+_NUMERIC_SUFFIX = re.compile(r"(?:LL|ULL|L|UL|[fF])$")
+
+
+def _numeric_setting_value(lowered: str) -> int | float | bool | None:
+    """The number or bool a lowered C++ setting expression is, or None.
+
+    Only a plain literal, signed or in parentheses, is read: what the codegen
+    emits for a literal or for a named constant it inlines. Anything the C++
+    computes at run time (an arithmetic expression, a call, a series) stays
+    with the receipt, which evaluates it.
+    """
+    text = lowered.strip()
+    while text.startswith("(") and text.endswith(")"):
+        text = text[1:-1].strip()
+    if text in ("true", "false"):
+        return text == "true"
+    if not _NUMERIC_LITERAL.fullmatch(text):
+        return None
+    text = _NUMERIC_SUFFIX.sub("", text)
+    return float(text) if re.search(r"[.eE]", text) else int(text)
+
+
+def _is_number(value) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
 def emit_settings_members(emitter, lines: list[str], constructor: list[str]) -> None:
     lines.extend([
         "    bool _pf_setting_failed_ = false;",
         "    std::string _pf_setting_failure_;",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "    ::pineforge::RunFailureInfo _pf_setting_failure_info_{::pineforge::RunFailureCode::none, {}};",
+        "#ifdef PF_SETTINGS_API_VERSION",
+        "    using _pf_setting_error_base = ::pineforge::checked_settings::LatchedSettingsFailure;",
+        "#else",
+        "    using _pf_setting_error_base = std::runtime_error;",
+        "#endif",
+        "    struct _pf_latched_setting_error : _pf_setting_error_base, ::pineforge::RunFailureInfo {",
+        "        _pf_latched_setting_error(const std::string& text, const ::pineforge::RunFailureInfo& info)",
+        "            : _pf_setting_error_base(text), ::pineforge::RunFailureInfo(info) {}",
+        "    };",
+        "#endif",
         "    void _pf_record_failure(const char* entrypoint, const char* message) noexcept {",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "        try { ::pineforge::note_run_failure_unknown(*this, entrypoint); } catch (...) {}",
+        "#else",
         "        try { last_error_ = entrypoint; last_error_ += \": \"; last_error_ += message; } catch (...) {}",
+        "#endif",
+        "    }",
+        "    void _pf_record_failure(const char* entrypoint, const std::exception& error) noexcept {",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "        try { ::pineforge::note_run_failure(*this, entrypoint, error); } catch (...) {}",
+        "#else",
+        "        _pf_record_failure(entrypoint, error.what());",
+        "#endif",
         "    }",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "    template <typename FailureInfo>",
+        "    void _pf_record_setting_failure(const char* entrypoint, const char* message, FailureInfo failure_info) noexcept {",
+        "#else",
         "    void _pf_record_setting_failure(const char* entrypoint, const char* message) noexcept {",
+        "#endif",
         "        if (!_pf_setting_failed_) {",
         "            _pf_setting_failed_ = true;",
         '            try { _pf_setting_failure_ = entrypoint; _pf_setting_failure_ += ": "; _pf_setting_failure_ += message; } catch (...) {}',
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "            try { _pf_setting_failure_info_ = failure_info(); }",
+        "            catch (...) { _pf_setting_failure_info_ = ::pineforge::RunFailureInfo(::pineforge::RunFailureCode::out_of_memory, {}); }",
+        "#endif",
         "        }",
         "        _pf_refuse_failed_setting(nullptr);",
         "    }",
         "    void _pf_require_settings_ok() const {",
-        "#ifdef PF_SETTINGS_API_VERSION",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        '        if (_pf_setting_failed_) throw _pf_latched_setting_error(_pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_, _pf_setting_failure_info_);',
+        "#elif defined(PF_SETTINGS_API_VERSION)",
         '        if (_pf_setting_failed_) throw ::pineforge::checked_settings::LatchedSettingsFailure(_pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_);',
         "#else",
         '        if (_pf_setting_failed_) throw std::runtime_error(_pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_);',
@@ -39,19 +147,25 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
         "    }",
         "    bool _pf_refuse_failed_setting(ReportC* out) noexcept {",
         "        if (!_pf_setting_failed_) return false;",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        '        try { ::pineforge::note_run_failure(*this, _pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_, _pf_setting_failure_info_.run_failure()); } catch (...) {}',
+        "#else",
         '        try { last_error_ = _pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_; } catch (...) {}',
+        "#endif",
         "        if (out) *out = ReportC{};",
         "        return true;",
         "    }",
     ])
     inputs = []
+    emitter._input_settings_metadata = {}
     for node, binding in emitter._global_input_calls_with_names():
         func_name, namespace = emitter._resolve_callee(node.callee)
         name = emitter._get_input_title(node, var_name=binding)
         key = emitter._input_key_literal(name)
         default = emitter._get_input_default(node)
         getter = emitter._input_getter_for_call(node, func_name, namespace)
-        default_cpp = _visit_setting_arg(emitter, default) if default is not None else "0"
+        default_lowered = _visit_setting_arg(emitter, default) if default is not None else "0"
+        default_cpp = default_lowered
         default_cpp = emitter._coerce_string_input_default(getter, default_cpp)
         value_type = {
             "get_input_int": "int", "get_input_int64": "int",
@@ -60,9 +174,15 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
         }[getter]
         kind = emitter._FORM_TYPE.get(func_name, value_type) if namespace == "input" else value_type
         options = []
+        numeric_options = []
         option_values = []
         supported = "true"
         default_serialized = None
+        if getter == "get_input_string":
+            default_serialized = _string_setting_arg(default, default_lowered)
+            if default_serialized is None:
+                default_serialized = 'std::string("")'
+                supported = "false"
         names, merged = emitter._merged_args(node, func_name, namespace)
         arguments = dict(zip(names or [], merged))
         arguments.update(node.kwargs)
@@ -103,8 +223,20 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
             if declared:
                 for option in declared:
                     option_cpp = _visit_setting_arg(emitter, option)
-                    options.append(option_cpp if getter == "get_input_string" else
-                                   f'::pineforge::checked_settings::number({option_cpp})')
+                    if getter == "get_input_string":
+                        option_cpp = _string_setting_arg(option, option_cpp)
+                        if option_cpp is None:
+                            supported = "false"
+                        else:
+                            options.append(option_cpp)
+                    else:
+                        options.append(f'::pineforge::checked_settings::number({option_cpp})')
+                        numeric_options.append(option_cpp)
+            if getter == "get_input_string":
+                if arguments.get("options") is not None and declared is None:
+                    supported = "false"
+                if supported == "false":
+                    options = []
             expression = f'{getter}({key}, {default_cpp})'
             effective = (expression if getter == "get_input_string" else
                          f'::pineforge::checked_settings::number({expression})')
@@ -119,6 +251,31 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
                     f'{64 if getter == "get_input_int64" else 32}, {supported}, '
                     f'{{{", ".join(option_values)}}}, "{kind}"}}')
         inputs.append((metadata, effective))
+        manifest = {}
+        if getter == "get_input_string":
+            manifest["default"] = _string_setting_value(default_serialized)
+            if arguments.get("options") is not None or supported == "false":
+                manifest["options"] = [_string_setting_value(option) for option in options]
+        elif value_type == "source":
+            manifest["default"] = source
+            manifest["options"] = [_string_setting_value(option) for option in options]
+        elif value_type == "enum":
+            manifest["options"] = [_string_setting_value(option) for option in options]
+        elif namespace == "input" and kind in ("int", "float", "bool"):
+            # A typed numeric or bool input publishes the numbers the receipt
+            # holds, where its C++ is a plain literal.
+            default_value = _numeric_setting_value(default_cpp) if default is not None else None
+            if default_value is not None and isinstance(default_value, bool) == (kind == "bool"):
+                manifest["default"] = default_value
+            for field, lowered in zip(("min", "max", "step"), constraints):
+                bound = _numeric_setting_value(lowered)
+                if _is_number(bound):
+                    manifest[field] = bound
+            values = [_numeric_setting_value(option) for option in numeric_options]
+            if values and all(_is_number(value) for value in values):
+                manifest["options"] = values
+        manifest["supported"] = supported == "true"
+        emitter._input_settings_metadata[id(node)] = manifest
 
     overrides = [
         ("initial_capital", "float", "initial_capital", "initial_capital", "0.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)
@@ -1281,6 +1284,7 @@ class TopLevelEmitter:
         lines.append("        pineforge::source::PineStrategyHost::set_strategy_override(overrides);")
         lines.append("    }")
         from .checked_settings import emit_settings_members
+        self._order_shape_constructor = tuple(ctor_body)
         emit_settings_members(self, lines, ctor_body)
 
         if self._uses_recorded_requests():
@@ -1314,7 +1318,7 @@ class TopLevelEmitter:
                 tf = info.get("tf")
                 tf_expr = info.get("tf_expr")
                 if tf:
-                    tf_expr = f'"{tf}"'
+                    tf_expr = self._security_tf_literal(tf)
                 elif tf == "" and not tf_expr:
                     # An empty timeframe string is the chart's.
                     tf_expr = "input_tf_"
@@ -1421,7 +1425,7 @@ class TopLevelEmitter:
         sec_id = info["sec_id"]
         symbol = self._security_tf_runtime_expr(info["symbol_node"])
         column = self._security_footprint_column(sec_id)
-        column = f', "{column}"' if column else ""
+        column = f', "{self._cpp_string_escape(column)}"' if column else ""
         ignore_node = info.get("ignore_invalid_node")
         if ignore_node is None:
             ignore = "false"
@@ -1886,15 +1890,24 @@ class TopLevelEmitter:
         for pragma in pragmas:
             cpp_expr = self._visit_expr(pragma.expr_node)
             lines.append(
-                f'{inner}trace(std::string("{pragma.name}"), '
+                f'{inner}trace(std::string("{self._cpp_string_escape(pragma.name)}"), '
                 f"(double)({cpp_expr}));"
             )
         lines.append(f"{pad}}}")
 
     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 {")
@@ -1911,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");')
@@ -1968,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"); }',
             "    }",
         ])
@@ -1981,25 +1994,28 @@ 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)
-        from .capabilities import emit_capabilities_exports
-        emit_capabilities_exports(self, lines)
+        self._capabilities_export_at = len(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