@pineforge/codegen-pyodide 1.0.0 → 1.1.0

package/pineforge_codegen/codegen/base.py

@@ -145,6 +145,7 @@ TA_TUPLE_RESULT_TYPES = {
 
 # CPP_RESERVED + the NamingHelper mixin are pulled in from helpers.py so the
 # small naming/walk utilities can be shared with future visitor mixins.
+from .collection_history import CollectionHistoryEmitter
 from .helpers import (
     CPP_RESERVED, INLINE_HISTORY_KINDS, SESSION_FLAG_MEMBERS, NamingHelper,
     cpp_code_only, na_preserving_int_cast, pine_truth_cast,
@@ -194,7 +195,7 @@ from .drawing import DrawingVisitor
 # CodeGen class
 # ---------------------------------------------------------------------------
 
-class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEmitter, TaSiteHelper, TypeInferer, InputHelper, DrawingVisitor, NamingHelper):
+class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEmitter, TaSiteHelper, TypeInferer, InputHelper, DrawingVisitor, CollectionHistoryEmitter, NamingHelper):
     """Generate C++ from an AnalyzerContext (visitor pattern).
 
     Mixin chain (Python MRO is left-to-right; method names are
@@ -1945,7 +1946,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     )
                 elif (orig_safe in self._series_var_member_names
                         or vname in self.ctx.series_vars):
-                    lines.append(f"    Series<{cpp_type}> {cloned_safe}{series_suffix};")
+                    # A history-read var object keeps its references, as
+                    # its base member does.
+                    udt_t = udt_spec.name if udt_spec is not None else member_udt_type
+                    element = (self._safe_name(udt_t) if udt_t in self._udt_defs
+                               else cpp_type)
+                    lines.append(f"    Series<{element}> {cloned_safe}{series_suffix};")
                 elif collection_spec is not None:
                     lines.append(
                         f"    {self._type_spec_to_cpp(collection_spec)} {cloned_safe};"
@@ -1987,8 +1993,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     lines.append(f"    {cpp_type} {cloned_safe};")
                 return
         # Non-var series var
-        if orig_safe in [self._safe_name(n) for n in self.ctx.series_vars]:
-            cpp_type = self._series_type_for(orig_safe)
+        raw_names = [n for n in self.ctx.series_vars if self._safe_name(n) == orig_safe]
+        if raw_names:
+            # A history-read object or drawing (a receiver ``this`` spelled
+            # ``pf_safe_this``) holds handles, as its base member does.
+            handles = {self._series_handle_cpp_type(n) for n in raw_names}
+            cpp_type = (handles.pop() if len(handles) == 1 and None not in handles
+                        else self._series_type_for(orig_safe))
             lines.append(f"    Series<{cpp_type}> {cloned_safe}{series_suffix};")
         else:
             lines.append(f"    double {cloned_safe} = 0.0;")
@@ -2112,6 +2123,14 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 declared_spec = self._type_spec_from_hint_name(stmt.type_hint)
             elif isinstance(stmt.value, (Ternary, IfStmt, SwitchStmt)):
                 declared_spec = self._type_spec_from_expr(stmt.value)
+            elif self._roots_at_collection_history(stmt.value):
+                # A copy of an array's or a matrix's history, or a built-in's
+                # result on one (``pm = m[1]``, ``c = (m[1]).copy()``).
+                declared_spec = self._type_spec_from_expr(stmt.value)
+                if declared_spec is not None and declared_spec.kind == "array":
+                    self._array_vars.add(stmt.name)
+                    self._collection_types.setdefault(stmt.name, declared_spec)
+                    continue
             else:
                 continue
             if declared_spec is None or declared_spec.kind != "matrix":
@@ -2225,10 +2244,17 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         Walks chained ``FuncCall`` receivers (e.g. ``m.transpose().copy()``)
         until it finds an ``Identifier`` so the source matrix's TypeSpec can
-        be propagated through fluent call chains.
+        be propagated through fluent call chains. A history read (``m[1]``)
+        is the variable's: its copy has the variable's type.
         """
         if not isinstance(call_node, FuncCall):
             return None
+
+        def unwrap(node):
+            if isinstance(node, Subscript) and isinstance(node.object, Identifier):
+                return node.object
+            return node
+
         callee = call_node.callee
         # Method form: m.method(...) — possibly chained: m.foo().bar()
         if isinstance(callee, MemberAccess):
@@ -2240,12 +2266,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     obj = inner_callee.object
                 else:
                     break
+            obj = unwrap(obj)
             if isinstance(obj, Identifier):
                 if obj.name != "matrix":
                     return obj.name
                 # matrix.method(m, ...) functional form
                 if call_node.args:
-                    first = call_node.args[0]
+                    first = unwrap(call_node.args[0])
                     if isinstance(first, Identifier):
                         return first.name
         return None
@@ -3623,13 +3650,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if len(states) > 1
         }
 
+        # A history parameter holding a user-defined object or a drawing keeps
+        # the references its calls passed (``_series_param_element_cpp_type``).
+        handle_cpp_types = {
+            *DRAWING_TYPE_TO_CPP.values(),
+            *(self._safe_name(name) for name in self._udt_defs),
+        }
+
         def register_one(
             kind: str,
             source_key: tuple,
             cpp_type: str,
             context: str | None,
         ) -> None:
-            if cpp_type not in ("double", "int", "int64_t", "bool"):
+            if (cpp_type not in ("double", "int", "int64_t", "bool")
+                    and cpp_type not in handle_cpp_types):
                 cpp_type = "double"
             key = (kind, *source_key, context)
             if key in self._inline_history_member_by_key:
@@ -3721,6 +3756,27 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             lexical.update(self._func_collection_types.get(owner, {}))
             return lexical
 
+        def owner_typed(owner: str | None, compute):
+            """``compute()`` with the owner's parameter types bound, as the
+            emitter binds them: a history read of a typed parameter's field
+            (``f(Outer p) => p.inner[1]``) types its Series by the field."""
+            previous = self.__dict__.get("_current_func_param_specs")
+            self._current_func_param_specs = owner_lexical_specs(owner)
+            try:
+                return compute()
+            finally:
+                if previous is None:
+                    self.__dict__.pop("_current_func_param_specs", None)
+                else:
+                    self._current_func_param_specs = previous
+
+        def history_cpp_type(expr, owner: str | None) -> str:
+            """``_history_value_cpp_type`` of ``expr``, a reference's handle
+            resolved with the owner's parameters bound; any other value keeps
+            the inference every earlier build registered."""
+            return (owner_typed(owner, lambda: self._reference_cpp_type(expr))
+                    or self._infer_type(expr))
+
         def plain_udf_info(call: FuncCall):
             if not isinstance(call.callee, Identifier):
                 return None
@@ -3846,7 +3902,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             owner = owner_by_node.get(id(node))
             if isinstance(node, Subscript) and isinstance(node.object, FuncCall):
                 register(
-                    "hist_call", (id(node),), self._infer_type(node.object), owner
+                    "hist_call", (id(node),), history_cpp_type(node.object, owner),
+                    owner,
                 )
             elif (isinstance(node, Subscript)
                     and self._is_session_flag(node.object)):
@@ -3865,9 +3922,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                         self._session_call_flags.setdefault(owner, set()).add(flag)
                         register("session_call", (owner, flag), "bool", owner)
             elif (isinstance(node, Subscript)
-                    and self._is_compound_history_object(node.object)):
+                    and (self._is_compound_history_object(node.object)
+                         or (isinstance(node.object, (Ternary, MemberAccess))
+                             and owner_typed(owner, lambda: self._reference_cpp_type(
+                                 node.object)) is not None))):
                 register(
-                    "hist_call", (id(node),), self._infer_type(node.object), owner
+                    "hist_call", (id(node),), history_cpp_type(node.object, owner),
+                    owner,
                 )
 
             if not isinstance(node, FuncCall):
@@ -4021,6 +4082,38 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             ("fn_global_hist", id(fi.node), name, self._current_instance_name)
         )
 
+    def _reference_cpp_type(self, expr) -> str | None:
+        """The handle type of an expression whose value is a user-defined
+        object or a drawing reference (``Cell``, ``Box``), else None."""
+        spec = self._type_spec_from_expr(expr)
+        if (spec is None or spec.kind != "udt"
+                or not (spec.name in DRAWING_TYPE_TO_CPP
+                        or spec.name in self._udt_defs)):
+            return None
+        return DRAWING_TYPE_TO_CPP.get(spec.name) or self._safe_name(spec.name)
+
+    def _registered_history_handle(self, node: Subscript) -> str | None:
+        """The handle type of the synthetic history Series the prepass
+        registered for ``node`` (``_prepare_inline_history_members``), else
+        None: emission reads the type the member was declared with."""
+        member = self._inline_history_member_by_key.get(
+            ("hist_call", id(node), self._current_instance_name))
+        if member is None:
+            return None
+        handles = {*DRAWING_TYPE_TO_CPP.values(),
+                   *(self._safe_name(name) for name in self._udt_defs)}
+        for info in self._inline_history_members:
+            if info["member_name"] == member:
+                return info["cpp_type"] if info["cpp_type"] in handles else None
+        return None
+
+    def _history_value_cpp_type(self, expr) -> str:
+        """The element type of the synthetic Series that keeps ``expr``'s
+        history: a reference's handle (TradingView's history of such an
+        expression is the reference it produced at its previous evaluation:
+        fixtures/udt_history_tv udth_expr), else the scalar it infers."""
+        return self._reference_cpp_type(expr) or self._infer_type(expr)
+
     def _is_compound_history_object(self, node) -> bool:
         """Whether ``node[k]`` is history on an operator expression or a
         ``session.*`` flag.
@@ -4038,6 +4131,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         """
         if self._is_session_flag(node):
             return True
+        if (isinstance(node, (Ternary, MemberAccess))
+                and self._reference_cpp_type(node) is not None):
+            # ``(c ? a : b)[1]`` and an object-typed field's ``o.inner[1]``:
+            # the reference the expression produced at its previous
+            # evaluation (fixtures/udt_history_tv udth_expr).
+            return True
         return (isinstance(node, (BinOp, UnaryOp, Ternary))
                 and self._infer_type(node) in ("double", "int", "int64_t", "bool"))
 
@@ -4614,6 +4713,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # per-callsite instances are declared below inside GeneratedStrategy
         # and therefore join the automatic COOF checkpoint inventory.
         self._emit_lazy_source_clock_helper(lines)
+        # The history of an array or a matrix variable: its support types
+        # (pineforge_codegen/collection_history.py), emitted only for a script
+        # that reads one.
+        self._emit_collection_history_helper(lines)
         # The chart-bar session type, inserted here once the class is lowered
         # and known to call it (codegen/session_market.py).
         _session_market_at = len(lines)
@@ -4847,9 +4950,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 continue
             callable_udt_spec = self._callable_var_udt_spec(name)
             if callable_udt_spec is not None:
-                lines.append(
-                    f"    {self._type_spec_to_cpp(callable_udt_spec)} {safe};"
-                )
+                handle_cpp = self._type_spec_to_cpp(callable_udt_spec)
+                if safe in self._series_var_member_names:
+                    # A history-read var object: its history holds the
+                    # references it held (``_series_handle_cpp_type``).
+                    lines.append(f"    Series<{handle_cpp}> {safe}{_mbb};")
+                else:
+                    lines.append(f"    {handle_cpp} {safe};")
                 continue
             # Detect array vars from init expression. Guard the substring
             # heuristic against a UDT constructor that merely WRAPS array.new /
@@ -4941,7 +5048,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                         udt_type = udt_name
                         break
             if udt_type:
-                lines.append(f"    {self._safe_name(udt_type)} {safe};")
+                if safe in self._series_var_member_names:
+                    # A history-read var object: its history holds the
+                    # references it held (``_series_handle_cpp_type``).
+                    lines.append(
+                        f"    Series<{self._safe_name(udt_type)}> {safe}{_mbb};")
+                else:
+                    lines.append(f"    {self._safe_name(udt_type)} {safe};")
                 continue
             cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
             # Promote int->int64_t when init RHS is an int64-returning builtin
@@ -5150,6 +5263,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             lines.append("    DrawingArena<LabelRec> _pf_labels_{_PF_DRAWING_UNBOUNDED};")
             lines.append("    DrawingArena<LinefillRec> _pf_linefills_{_PF_DRAWING_UNBOUNDED};")
 
+        # 8e. The copies an array or a matrix variable's executions left
+        #     (pineforge_codegen/collection_history.py).
+        for variable in self._collection_history_variables():
+            lines.append(
+                f"    _PFCollectionHistory<{self._collection_history_cpp_type(variable)}> "
+                f"{self._collection_history_member(variable)}"
+                f"{self._collection_history_capacity(variable)};"
+            )
+
         # 9. _var_initialized flag
         if self.ctx.var_members:
             lines.append("    bool _var_initialized = false;")

package/pineforge_codegen/codegen/checked_settings.py

@@ -0,0 +1,272 @@
+"""Opt-in settings metadata, validation and exception-contained C exports."""
+
+from ..ast_nodes import Identifier, MemberAccess
+
+
+def emit_settings_members(emitter, lines: list[str], constructor: list[str]) -> None:
+    lines.extend([
+        "    bool _pf_setting_failed_ = false;",
+        "    std::string _pf_setting_failure_;",
+        "    void _pf_record_failure(const char* entrypoint, const char* message) noexcept {",
+        "        try { last_error_ = entrypoint; last_error_ += \": \"; last_error_ += message; } catch (...) {}",
+        "    }",
+        "    void _pf_record_setting_failure(const char* entrypoint, const char* message) noexcept {",
+        "        if (!_pf_setting_failed_) {",
+        "            _pf_setting_failed_ = true;",
+        '            try { _pf_setting_failure_ = entrypoint; _pf_setting_failure_ += ": "; _pf_setting_failure_ += message; } catch (...) {}',
+        "        }",
+        "        _pf_refuse_failed_setting(nullptr);",
+        "    }",
+        "    void _pf_require_settings_ok() const {",
+        "#ifdef 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_);',
+        "#endif",
+        "    }",
+        "    bool _pf_refuse_failed_setting(ReportC* out) noexcept {",
+        "        if (!_pf_setting_failed_) return false;",
+        '        try { last_error_ = _pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_; } catch (...) {}',
+        "        if (out) *out = ReportC{};",
+        "        return true;",
+        "    }",
+    ])
+    inputs = []
+    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 = emitter._visit_expr(default) if default is not None else "0"
+        default_cpp = emitter._coerce_string_input_default(getter, default_cpp)
+        value_type = {
+            "get_input_int": "int", "get_input_int64": "int",
+            "get_input_double": "float", "get_input_bool": "bool",
+            "get_input_string": "string",
+        }[getter]
+        kind = emitter._FORM_TYPE.get(func_name, value_type) if namespace == "input" else value_type
+        options = []
+        option_values = []
+        supported = "true"
+        default_serialized = None
+        names, merged = emitter._merged_args(node, func_name, namespace)
+        arguments = dict(zip(names or [], merged))
+        arguments.update(node.kwargs)
+        if emitter._is_source_input(node):
+            value_type = "source"
+            source = emitter._source_defval_to_base_series(default)[5:-1]
+            default_cpp = emitter._input_key_literal(source)
+            effective = f'(inputs_.count({key}) ? inputs_.at({key}) : {default_cpp})'
+            options = [emitter._input_key_literal(value)
+                       for value in sorted(emitter._NATIVE_SOURCE_SERIES)]
+        elif namespace == "input" and func_name == "enum":
+            value_type = "enum"
+            declared = getattr(arguments.get("options"), "elements", None)
+            enum_members = ([default] if isinstance(default, MemberAccess) else []) + list(declared or [])
+            enum_names = {member.object.name for member in enum_members
+                          if isinstance(member, MemberAccess) and isinstance(member.object, Identifier)}
+            if (len(enum_names) == 1 and enum_members
+                    and all(isinstance(member, MemberAccess) and isinstance(member.object, Identifier)
+                            for member in enum_members)):
+                enum_name = next(iter(enum_names))
+                members = emitter._enum_defs.get(enum_name, [])
+                selected = [member.member for member in declared] if declared is not None else members
+                options = [emitter._input_key_literal(f"{enum_name}.{member}")
+                           for member in selected]
+                option_values = [emitter._input_key_literal(str(members.index(member)))
+                                 for member in selected if member in members]
+                supported = "true" if options and len(options) == len(option_values) else "false"
+            else:
+                supported = "false"
+            if not isinstance(default, MemberAccess):
+                supported = "false"
+                default_serialized = 'std::string("na")'
+                effective = f'(inputs_.count({key}) ? inputs_.at({key}) : std::string("na"))'
+            else:
+                effective = f'::pineforge::checked_settings::number({getter}({key}, {default_cpp}))'
+        else:
+            declared = getattr(arguments.get("options"), "elements", None)
+            if declared:
+                for option in declared:
+                    option_cpp = emitter._visit_expr(option)
+                    options.append(option_cpp if getter == "get_input_string" else
+                                   f'::pineforge::checked_settings::number({option_cpp})')
+            expression = f'{getter}({key}, {default_cpp})'
+            effective = (expression if getter == "get_input_string" else
+                         f'::pineforge::checked_settings::number({expression})')
+        if default_serialized is None:
+            default_serialized = (default_cpp if value_type in ("string", "source") else
+                                  f'::pineforge::checked_settings::number({default_cpp})')
+        constraints = [emitter._visit_expr(arguments[name]) if arguments.get(name) is not None
+                       else "std::numeric_limits<double>::quiet_NaN()"
+                       for name in ("minval", "maxval", "step")]
+        metadata = (f'{{{key}, "{value_type}", {default_serialized}, '
+                    f'{{{", ".join(options)}}}, {", ".join(constraints)}, '
+                    f'{64 if getter == "get_input_int64" else 32}, {supported}, '
+                    f'{{{", ".join(option_values)}}}, "{kind}"}}')
+        inputs.append((metadata, effective))
+
+    overrides = [
+        ("initial_capital", "float", "initial_capital", "initial_capital", "0.0"),
+        ("commission_value", "float", "commission_value", "commission_value", "0.0"),
+        ("default_qty_value", "float", "default_qty_value", "default_qty_value", "0.0"),
+        ("pyramiding", "int", "pyramiding", "pyramiding", "0.0"),
+        ("slippage", "int", "slippage", "slippage", "0.0"),
+        ("process_orders_on_close", "bool", "process_orders_on_close", "process_orders_on_close", "nan"),
+        ("calc_on_order_fills", "bool", "calc_on_order_fills", "calc_on_order_fills", "nan"),
+        ("close_entries_rule", "string", "close_entries_rule_any", "close_entries_rule", "nan"),
+        ("default_qty_type", "string", "default_qty_type", "default_qty_type", "nan"),
+        ("commission_type", "string", "commission_type", "commission_type", "nan"),
+    ]
+    enum_options = {
+        "close_entries_rule": ["FIFO", "ANY"],
+        "default_qty_type": ["fixed", "percent_of_equity", "cash"],
+        "commission_type": ["percent", "cash_per_order", "cash_per_contract"],
+    }
+    lines.extend([
+        "#ifdef PF_SETTINGS_API_VERSION",
+        "    static pineforge::source::PineStrategyConfig _pf_settings_declared_config() {",
+        "        pineforge::source::PineStrategyConfig cfg{};",
+    ])
+    lines.extend(statement for statement in constructor if statement.startswith("        cfg."))
+    lines.extend([
+        "        return cfg;", "    }",
+        "    std::vector<::pineforge::checked_settings::Setting> _pf_settings_inputs() const {",
+        "        return {",
+    ])
+    lines.extend(f"            {metadata}," for metadata, _effective in inputs)
+    lines.extend([
+        "        };", "    }",
+        "    std::vector<::pineforge::checked_settings::Setting> _pf_settings_overrides() const {",
+        "        const double _pf_nan = std::numeric_limits<double>::quiet_NaN();",
+        "        const auto _pf_defaults = _pf_settings_declared_config();",
+        "        return {",
+    ])
+    override_effective = []
+    for name, value_type, config_field, override_field, minimum in overrides:
+        raw = f'config_.{config_field}'
+        declared_default = f'_pf_defaults.{config_field}'
+        overridden = f'override_.{override_field}'
+        selected = (f'(std::isnan({overridden}) ? {raw} : {overridden})'
+                    if value_type == "float" else
+                    f'({overridden} < 0 ? {raw} : {overridden})')
+        if name in enum_options:
+            options = enum_options[name]
+            default_value = f'_pf_{name}_word({declared_default})'
+            effective = f'_pf_{name}_word({selected})'
+        else:
+            options = []
+            default_value = f'::pineforge::checked_settings::number({declared_default})'
+            effective = f'::pineforge::checked_settings::number({selected})'
+            if value_type == "bool":
+                effective = f'::pineforge::checked_settings::number(static_cast<bool>({selected}))'
+        option_cpp = ", ".join(emitter._input_key_literal(option) for option in options)
+        floor = "_pf_nan" if minimum == "nan" else minimum
+        lines.append(f'            {{"{name}", "{value_type}", {default_value}, '
+                     f'{{{option_cpp}}}, {floor}}},')
+        override_effective.append(effective)
+    lines.extend(["        };", "    }"])
+    for name, options in enum_options.items():
+        lines.append(f'    static std::string _pf_{name}_word(int _pf_value) {{')
+        for index, option in enumerate(options):
+            lines.append(f'        if (_pf_value == {index}) return "{option}";')
+        lines.extend(['        return "invalid";', '    }'])
+    lines.extend([
+        "    void _pf_set_input_checked(const std::string& _pf_key, const std::string& _pf_value) {",
+        "        if (_pf_refuse_failed_setting(nullptr)) throw ::pineforge::checked_settings::Error{PF_SETTINGS_RUN_FAILED, last_error_.c_str()};",
+        '        ::pineforge::checked_settings::require(script_bars_processed() == 0 && stream_phase_ == StreamPhase::IDLE, "settings are frozen after execution begins", PF_SETTINGS_UNSUPPORTED);',
+        "        const auto _pf_inputs = _pf_settings_inputs();",
+        "        const ::pineforge::checked_settings::Setting* _pf_match = nullptr;",
+        "        for (const auto& _pf_input : _pf_inputs) {",
+        "            if (_pf_input.name != _pf_key) continue;",
+        '            ::pineforge::checked_settings::require(_pf_match == nullptr, "ambiguous input key", PF_SETTINGS_UNSUPPORTED);',
+        "            _pf_match = &_pf_input;",
+        "        }",
+        '        ::pineforge::checked_settings::require(_pf_match != nullptr, "unknown input key");',
+        "        const auto _pf_canonical = ::pineforge::checked_settings::validate(*_pf_match, _pf_value);",
+        "        set_input(_pf_key, _pf_canonical);",
+        '        ::pineforge::checked_settings::require(inputs_.count(_pf_key) && inputs_.at(_pf_key) == _pf_canonical, "input was not installed", PF_SETTINGS_UNSUPPORTED);',
+        "    }",
+        "    void _pf_set_override_checked(const std::string& _pf_key, const std::string& _pf_value) {",
+        "        if (_pf_refuse_failed_setting(nullptr)) throw ::pineforge::checked_settings::Error{PF_SETTINGS_RUN_FAILED, last_error_.c_str()};",
+        '        ::pineforge::checked_settings::require(script_bars_processed() == 0 && stream_phase_ == StreamPhase::IDLE, "settings are frozen after execution begins", PF_SETTINGS_UNSUPPORTED);',
+        "        for (const auto& _pf_override : _pf_settings_overrides()) {",
+        "            if (_pf_override.name != _pf_key) continue;",
+        "            auto _pf_alias = _pf_value;",
+    ])
+    for name, options in enum_options.items():
+        lines.append(f'            if (_pf_key == "{name}") {{')
+        for index, option in enumerate(options):
+            aliases = [str(index)]
+            if name == "close_entries_rule":
+                aliases.append(option.lower())
+            else:
+                prefix = "strategy.commission." if name == "commission_type" else "strategy."
+                aliases.append(prefix + option)
+            condition = " || ".join(f'_pf_value == "{alias}"' for alias in aliases)
+            lines.append(f'                if ({condition}) _pf_alias = "{option}";')
+        lines.append("            }")
+    lines.extend([
+        "            const auto _pf_canonical = ::pineforge::checked_settings::validate(_pf_override, _pf_alias);",
+        "            set_strategy_override(_pf_key, _pf_canonical);",
+        "            return;",
+        "        }",
+        '        throw ::pineforge::checked_settings::Error{PF_SETTINGS_INVALID_ARGUMENT, "unknown override key"};',
+        "    }",
+        "    std::string _pf_settings_receipt() const {",
+        '        ::pineforge::checked_settings::require(!_pf_setting_failed_, _pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_.c_str(), PF_SETTINGS_RUN_FAILED);',
+        '        std::string _pf_document = "{\\\"version\\\":1,\\\"inputs\\\":[";',
+        "        const auto _pf_inputs = _pf_settings_inputs();",
+    ])
+    for index, (_metadata, effective) in enumerate(inputs):
+        if index:
+            lines.append("        _pf_document += ',';")
+        lines.append(f"        _pf_document += ::pineforge::checked_settings::describe(_pf_inputs[{index}], {effective});")
+    lines.extend([
+        '        _pf_document += "],\\\"overrides\\\":[";',
+        "        const auto _pf_overrides = _pf_settings_overrides();",
+    ])
+    for index, effective in enumerate(override_effective):
+        if index:
+            lines.append("        _pf_document += ',';")
+        lines.append(f"        _pf_document += ::pineforge::checked_settings::describe(_pf_overrides[{index}], {effective});")
+    lines.extend(['        return _pf_document + "]}";', "    }", "#endif"])
+
+
+def emit_settings_exports(lines: list[str]) -> None:
+    lines.extend([
+        "#ifdef PF_SETTINGS_API_VERSION",
+        "    uint32_t strategy_settings_api_version(void) { return PF_SETTINGS_API_VERSION; }",
+        "    int strategy_create_checked(const char* params_json, void** out, char* error, size_t error_capacity) {",
+        "        if (out) *out = nullptr;",
+        "        return ::pineforge::checked_settings::boundary(error, error_capacity, [&] {",
+        '            ::pineforge::checked_settings::require(out != nullptr, "strategy output pointer is null");',
+        '            ::pineforge::checked_settings::require(!params_json || !*params_json, "params_json is reserved; use checked setters", PF_SETTINGS_UNSUPPORTED);',
+        "            *out = new GeneratedStrategy();",
+        "        });",
+        "    }",
+    ])
+    for kind in ("input", "override"):
+        lines.extend([
+            f"    int strategy_set_{kind}_checked(void* s, const char* key, const char* value, char* error, size_t error_capacity) {{",
+            "        return ::pineforge::checked_settings::boundary(error, error_capacity, [&] {",
+            '            ::pineforge::checked_settings::require(s && key && value, "null strategy, key or value");',
+            f"            static_cast<GeneratedStrategy*>(s)->_pf_set_{kind}_checked(key, value);",
+            "        });", "    }",
+        ])
+    lines.extend([
+        "    int strategy_get_effective_settings(void* s, char* json, size_t capacity, size_t* required, char* error, size_t error_capacity) {",
+        "        if (required) *required = 0;",
+        "        return ::pineforge::checked_settings::boundary(error, error_capacity, [&] {",
+        '            ::pineforge::checked_settings::require(s != nullptr, "null strategy");',
+        "            ::pineforge::checked_settings::receipt(static_cast<GeneratedStrategy*>(s)->_pf_settings_receipt(), json, capacity, required);",
+        "        });", "    }",
+        "    int run_backtest_full_checked(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, char* error, size_t error_capacity) {",
+        "        return ::pineforge::checked_settings::boundary(error, error_capacity, [&] {",
+        '            ::pineforge::checked_settings::require(s && out && n >= 0 && (n == 0 || bars), "invalid batch arguments");',
+        "            _pf_run_backtest_full_impl(s, bars, n, input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist, out);",
+        "            const auto& _pf_error = static_cast<GeneratedStrategy*>(s)->last_error();",
+        '            ::pineforge::checked_settings::require(_pf_error.empty(), _pf_error.c_str(), PF_SETTINGS_RUN_FAILED);',
+        "        });", "    }", "#endif",
+    ])