@pineforge/codegen-pyodide 1.0.1 → 1.1.0

package/glue.py

@@ -40,4 +40,5 @@ def transpile_json(source: str) -> str:
     # A script that transpiled carries its warnings in the same entry format.
     return json.dumps({"ok": True, "cpp": full["cpp"], "inputs": full["inputs"],
                        "strategyParams": full["strategyParams"],
-                       "diagnostics": _diagnostic_entries(full["diagnostics"])})
+                       "diagnostics": _diagnostic_entries(full["diagnostics"]),
+                       "requests": full["requests"]})

package/package.json

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

package/pineforge_codegen/__init__.py

@@ -13,6 +13,7 @@ from .finite_ta_length import expand_finite_choice_extrema_lengths
 from .library_inline import inline_libraries
 from .limits import TimeBudget, check_ast_depth, check_source_size, ensure_recursion_headroom
 from .pragmas import extract_pf_trace_pragmas
+from .request_discovery import discover_requests, request_sites
 from .security_contexts import specialize_security_contexts
 from .block_locals import rename_block_locals
 from .support_checker import check_support as _support_diagnostics
@@ -52,7 +53,9 @@ def _generate(pine_source: str, check_support: bool, filename: str,
     the member of its name cannot hold gets a name of its own, and the
     pipeline runs again (``block_locals``).
 
-    Returns ``(codegen, ctx, cpp, support_diagnostics)``."""
+    Returns ``(codegen, ctx, cpp, support_diagnostics, sites)``: ``sites``
+    are the requests of another symbol's data the support checker lowered
+    (``request_discovery.request_sites``)."""
     budget = None
     clones: frozenset[str] = frozenset()
     renamed: frozenset = frozenset()
@@ -67,6 +70,7 @@ def _generate(pine_source: str, check_support: bool, filename: str,
             if any(d.level == Level.ERROR for d in support_diagnostics):
                 raise CompileError(support_diagnostics)
         budget.check(phase=Phase.ANALYZER)
+        sites = request_sites(ast)
         ast = lower_no_data_requests(ast)
         ast = specialize_security_contexts(ast, filename=filename)
         ast = bind_builtin_keywords(expand_finite_choice_extrema_lengths(ast))
@@ -86,18 +90,18 @@ def _generate(pine_source: str, check_support: bool, filename: str,
         apart = gen.block_locals_needing_names - renamed
         if apart:
             renamed |= apart
-            del ast, ctx, gen, cpp
+            del ast, ctx, gen, cpp, sites
             continue
         needed = gen.session_functions_needing_clones
         if not needed:
-            return gen, ctx, cpp, support_diagnostics
+            return gen, ctx, cpp, support_diagnostics, sites
         # Only uncloned functions ask, so the set grows each time and the
         # loop ends by the time every function that reads a flag at an
         # offset is cloned.
         if needed <= clones:
             raise AssertionError("a cloned function asked for session clones again")
         clones |= needed
-        del ast, ctx, gen, cpp
+        del ast, ctx, gen, cpp, sites
 
 
 def transpile(pine_source: str, *, check_support: bool = True, filename: str = "<input>",
@@ -140,7 +144,8 @@ def transpile(pine_source: str, *, check_support: bool = True, filename: str = "
     Returns:
         Generated C++ source string.
     """
-    _gen, _ctx, cpp, _support = _generate(pine_source, check_support, filename, libraries)
+    _gen, _ctx, cpp, _support, _sites = _generate(pine_source, check_support, filename,
+                                                  libraries)
     return cpp
 
 
@@ -161,26 +166,36 @@ def transpile_full(pine_source: str, *, check_support: bool = True,
       source order). Each has ``title`` / ``type`` /
       ``default`` and optionally ``min`` / ``max`` / ``step`` / ``options``
       (omitted when the corresponding signature argument is absent or
-      references a non-const value). See
-      :meth:`CodeGen.extract_input_manifest`.
+      references a non-const value); an ``input.symbol`` entry also has
+      ``kind: "symbol"``. See :meth:`CodeGen.extract_input_manifest`.
     - ``strategyParams``: the literal ``strategy(...)`` kwargs the analyzer
       surfaced (e.g. ``initial_capital``, ``pyramiding``).
     - ``diagnostics``: the warnings (:class:`~pineforge_codegen.errors.Diagnostic`,
       ``Level.WARNING``) the support checker and the analyzer raised for a
       script that transpiled -- e.g. an approximated ``ta.vwap`` anchor. An
       error still raises ``CompileError``, which carries the warnings too.
+    - ``requests``: every request site that reads another symbol's feed,
+      by line: its symbol and timeframe as registration computes them
+      before the first bar (``literal`` / ``input`` / ``computed`` /
+      ``unresolvable``; ``literal`` / ``chart`` / ``input`` / ``computed``),
+      ``lookahead``, ``gaps`` and ``ignore_invalid_symbol``. A site lowered
+      to ``na`` (its value reaches display sinks only) or in a helper
+      nothing reaches is not listed. See
+      :mod:`pineforge_codegen.request_discovery`.
 
     Args mirror :func:`transpile`.
 
     Returns:
         ``{"cpp": str, "inputs": list[dict], "strategyParams": dict,
-        "diagnostics": list[Diagnostic]}``.
+        "diagnostics": list[Diagnostic], "requests": list[dict]}``.
     """
-    gen, ctx, cpp, support_diagnostics = _generate(pine_source, check_support, filename, libraries)
+    gen, ctx, cpp, support_diagnostics, sites = _generate(
+        pine_source, check_support, filename, libraries)
     return {
         "cpp": cpp,
         "inputs": gen.extract_input_manifest(),
         "strategyParams": dict(ctx.strategy_params),
         "diagnostics": [d for d in (*support_diagnostics, *ctx.diagnostics)
                         if d.level == Level.WARNING],
+        "requests": discover_requests(gen, ctx, sites),
     }

package/pineforge_codegen/analyzer/base.py

@@ -3797,6 +3797,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     symbol=sec.symbol,
                     foreign=sec.foreign,
                     ignore_invalid=sec.ignore_invalid,
+                    loc=sec.loc,
                 )
                 new_calls.append(clone)
                 next_sec_id += 1

package/pineforge_codegen/analyzer/call_handlers.py

@@ -876,6 +876,7 @@ class CallHandlers:
                 dead=bool(notes.get(DEAD_ANNOTATION)),
                 foreign=notes.get(LOWERING_ANNOTATION) == FEED_LOWERING,
                 ignore_invalid=node.kwargs.get("ignore_invalid_symbol"),
+                loc=node.loc,
             ))
 
             return PineType.STRING if string_result else PineType.FLOAT
@@ -998,6 +999,7 @@ class CallHandlers:
             is_lower_tf_array=True,
             context_resolved=context is not None,
             dead=bool(notes.get(DEAD_ANNOTATION)),
+            loc=node.loc,
         ))
 
         # ``request.security_lower_tf`` returns an array; the value-level

package/pineforge_codegen/analyzer/contracts.py

@@ -196,6 +196,9 @@ class SecurityCallInfo:
     # ``symbol`` string and ``ignore_invalid_symbol`` (the node, or None).
     foreign: bool = False
     ignore_invalid: Any = None
+    # The request call's source location (``request_discovery`` names the
+    # site by its line).
+    loc: Any = None
 
 
 @dataclass

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",
+    ])

package/pineforge_codegen/codegen/emit_top.py

@@ -130,6 +130,8 @@ class TopLevelEmitter:
         )
         lines.append('#include <pineforge/source/pine_strategy_host.hpp>')
         lines.append('#include <pineforge/ta.hpp>')
+        lines.extend(['#if __has_include(<pineforge/checked_settings.hpp>)',
+                      '#include <pineforge/checked_settings.hpp>', '#endif'])
         if self._ta_uses_dynamic_lengths():
             lines.append('#include <pineforge/source/pine_ta_length.hpp>')
         lines.append('#include <pineforge/math.hpp>')
@@ -598,6 +600,7 @@ class TopLevelEmitter:
             '#error "Generated lifecycle reset requires a matching PineForge engine; rebuild with script-run preparation support"',
             "#endif",
             "    void prepare_script_run(const Bar* bars, int n, bool allow_precalculation) override {",
+            "        _pf_require_settings_ok();",
             "        _pf_script_state_checkpoint_.reset();",
         ])
         seen: set[str] = set()
@@ -1277,6 +1280,8 @@ class TopLevelEmitter:
         lines.append("        }")
         lines.append("        pineforge::source::PineStrategyHost::set_strategy_override(overrides);")
         lines.append("    }")
+        from .checked_settings import emit_settings_members
+        emit_settings_members(self, lines, ctor_body)
 
         if self._uses_recorded_requests():
             lines.extend([
@@ -1889,24 +1894,38 @@ class TopLevelEmitter:
     def _emit_extern_c(self, lines: list[str]) -> None:
         lines.append('extern "C" {')
         lines.append("    void* strategy_create(const char* params_json) {")
-        lines.append("        return new GeneratedStrategy();")
+        lines.append("        try { return new GeneratedStrategy(); } catch (...) { return nullptr; }")
         lines.append("    }")
         lines.append("    void run_backtest(void* s, Bar* bars, int n, ReportC* out) {")
+        lines.append("        try {")
         lines.append("        auto* strat = static_cast<GeneratedStrategy*>(s);")
+        lines.append("#ifndef PF_SETTINGS_API_VERSION")
+        lines.append("        if (strat->_pf_refuse_failed_setting(out)) return;")
+        lines.append("#endif")
         if self._security_calls:
             # If there are security calls, use the full run path. Pass empty strings
             # so the C++ runtime auto-detects input_tf from bar timestamps.
             lines.append('        strat->run(bars, n, "", "", false, 4, MagnifierDistribution::ENDPOINTS);')
         else:
             lines.append("        strat->run(bars, n);")
-        lines.append("        strat->fill_report(out);")
+        lines.append("        if (!strat->_pf_refuse_failed_setting(out)) strat->fill_report(out);")
+        lines.append('        } catch (const std::exception& _pf_error) {')
+        lines.append('            if (out) *out = ReportC{};')
+        lines.append('            if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest", _pf_error.what());')
+        lines.append('        } catch (...) {')
+        lines.append('            if (out) *out = ReportC{};')
+        lines.append('            if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest", "unknown C++ exception");')
+        lines.append('        }')
         lines.append("    }")
-        lines.append("    void run_backtest_full(void* s, Bar* bars, int n,")
+        lines.append("    static void _pf_run_backtest_full_impl(void* s, Bar* bars, int n,")
         lines.append('                           const char* input_tf, const char* script_tf,')
         lines.append("                           int bar_magnifier, int magnifier_samples,")
         lines.append("                           int magnifier_dist,")
         lines.append("                           ReportC* out) {")
         lines.append('        auto* strat = static_cast<GeneratedStrategy*>(s);')
+        lines.append("#ifndef PF_SETTINGS_API_VERSION")
+        lines.append("        if (strat->_pf_refuse_failed_setting(out)) return;")
+        lines.append("#endif")
         lines.append('        std::string itf = input_tf ? input_tf : "";')
         lines.append('        std::string stf = script_tf ? script_tf : "";')
         if self._security_calls:
@@ -1943,26 +1962,42 @@ class TopLevelEmitter:
             lines.append("            strat->run(bars, n, itf, stf, bar_magnifier != 0, magnifier_samples,")
             lines.append("                       static_cast<MagnifierDistribution>(magnifier_dist));")
             lines.append("        }")
-        lines.append("        strat->fill_report(out);")
+        lines.append("        if (!strat->_pf_refuse_failed_setting(out)) strat->fill_report(out);")
         lines.append("    }")
+        lines.extend([
+            "    void run_backtest_full(void* s, Bar* bars, int n, const char* input_tf, const char* script_tf,",
+            "                           int bar_magnifier, int magnifier_samples, int magnifier_dist, ReportC* out) {",
+            "        try { _pf_run_backtest_full_impl(s, bars, n, input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist, out); }",
+            '        catch (const std::exception& _pf_error) { if (out) *out = ReportC{}; if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest_full", _pf_error.what()); }',
+            '        catch (...) { if (out) *out = ReportC{}; if (s) static_cast<GeneratedStrategy*>(s)->_pf_record_failure("run_backtest_full", "unknown C++ exception"); }',
+            "    }",
+        ])
         lines.append("    void strategy_free(void* s) {")
-        lines.append("        delete static_cast<GeneratedStrategy*>(s);")
+        lines.append("        try { delete static_cast<GeneratedStrategy*>(s); } catch (...) {}")
         lines.append("    }")
         lines.append("    void report_free(ReportC* report) {")
-        lines.append("        BacktestEngine::free_report(report);")
+        lines.append("        try { BacktestEngine::free_report(report); } catch (...) {}")
         lines.append("    }")
         lines.append("    void strategy_set_input(void* s, const char* key, const char* value) {")
         lines.append("        if (!s || !key || !value) return;")
-        lines.append("        static_cast<GeneratedStrategy*>(s)->set_input(key, value);")
+        lines.append("        try { static_cast<GeneratedStrategy*>(s)->set_input(key, value); }")
+        lines.append('        catch (const std::exception& _pf_error) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_input", _pf_error.what()); }')
+        lines.append('        catch (...) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_input", "unknown C++ exception"); }')
         lines.append("    }")
         lines.append("    void strategy_set_override(void* s, const char* key, const char* value) {")
         lines.append("        if (!s || !key || !value) return;")
-        lines.append("        static_cast<GeneratedStrategy*>(s)->set_strategy_override(key, value);")
+        lines.append("        try { static_cast<GeneratedStrategy*>(s)->set_strategy_override(key, value); }")
+        lines.append('        catch (const std::exception& _pf_error) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_override", _pf_error.what()); }')
+        lines.append('        catch (...) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_override", "unknown C++ exception"); }')
         lines.append("    }")
         lines.append("    void strategy_set_magnifier_volume_weighted(void* s, int on) {")
         lines.append("        if (!s) return;")
-        lines.append("        static_cast<GeneratedStrategy*>(s)->set_magnifier_volume_weighted(on != 0);")
+        lines.append("        try { static_cast<GeneratedStrategy*>(s)->set_magnifier_volume_weighted(on != 0); }")
+        lines.append('        catch (const std::exception& _pf_error) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_magnifier_volume_weighted", _pf_error.what()); }')
+        lines.append('        catch (...) { static_cast<GeneratedStrategy*>(s)->_pf_record_setting_failure("strategy_set_magnifier_volume_weighted", "unknown C++ exception"); }')
         lines.append("    }")
+        from .checked_settings import emit_settings_exports
+        emit_settings_exports(lines)
         if self._declares_bar_magnifier():
             # TradingView runs a script that declares use_bar_magnifier = true
             # on its bar magnifier; the host reads this export to run it on

package/pineforge_codegen/codegen/helpers.py

@@ -314,7 +314,13 @@ CPP_EMITTER_NAMES = frozenset("""
     _pf_drawing_na _pf_collect_drawings _pf_collect_lines_ _pf_collect_boxes_
     _pf_collect_labels_ _pf_new _pf_held
     get_input_int get_input_float get_input_bool get_input_string
-    trace is_na na nz fixnan
+    _pf_record_failure _pf_refuse_failed_setting _pf_settings_declared_config
+    _pf_record_setting_failure _pf_require_settings_ok
+    _pf_setting_failed_ _pf_setting_failure_
+    _pf_settings_inputs _pf_settings_overrides _pf_set_input_checked
+    _pf_set_override_checked _pf_settings_receipt
+    _pf_close_entries_rule_word _pf_default_qty_type_word _pf_commission_type_word
+    checked_settings trace is_na na nz fixnan
 """.split())
 
 # The generated history members, ``_<kind>_<n>`` (codegen/base.py

package/pineforge_codegen/codegen/host_members.py

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

package/pineforge_codegen/codegen/input.py

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

package/pineforge_codegen/external_requests.py

@@ -858,6 +858,9 @@ def unpin_requests(program: Program, reasons: dict[int, str]) -> None:
             lowered.annotations = {**(lowered.annotations or {}),
                                    UNPINNED_ANNOTATION: marker["message"]}
         swaps[request_id] = lowered
+        # The request leaves the program; its lowering is the deferred
+        # refusal's now (``request_discovery`` lists it so).
+        request.annotations = {**(request.annotations or {}), LOWERING_ANNOTATION: "unpinned"}
         warnings.append(pass_warning(
             request,
             f"{spell_call(request)}: no data is pinned for this request; the run stops with "

package/pineforge_codegen/request_discovery.py

@@ -0,0 +1,506 @@
+"""The other symbols' data a script requests, listed before it runs.
+
+``transpile_full(...)["requests"]`` names every request site that reads
+another symbol's feed, so a host can fetch the bars a run needs before it
+starts it. A run supplies another symbol's bars as one feed per (symbol
+string, timeframe) and the engine looks a site's feed up byte for byte
+(``codegen/emit_top.py``, ``_emit_foreign_security_registration``), so each
+entry states both the way registration computes them:
+
+    {"line": 7, "fn": "request.security",
+     "symbol":    {"kind": "input", "title": "Other symbol", "default": "BINANCE:ETHUSDT"},
+     "timeframe": {"kind": "chart"},
+     "lookahead": false, "gaps": false, "ignore_invalid_symbol": false}
+
+The sites are the registrations the C++ makes: ``request.security`` of
+another symbol that the support checker lowered onto its feed
+(``external_requests.FEED_LOWERING``), one entry per context a helper's call
+paths give it (``security_contexts``), with the feed column a footprint reads
+(``column``). A site whose value reaches display and alert sinks only is
+lowered to ``na`` and reads nothing, and a helper nothing reaches never runs:
+neither is listed. A deferred refusal -- another symbol's request whose value
+can reach a trade but which registration cannot key before the first bar --
+is listed with an ``unresolvable`` symbol: its first read stops the run.
+Every other request reads no feed: the chart's symbol, ``request.*`` of
+fundamentals (recorded series, not bars) and ``request.security_lower_tf`` of
+another symbol (it stops the run where it is evaluated).
+
+Names are expanded as registration expands them
+(``_substitute_tf_input_reads``: the expression the C++ renders and the run
+evaluates before the first bar), and a ``value`` is computed only over
+``ScriptIndex.registration_value``'s grammar -- literals, inputs at their
+defaults, ``+ == != and or not``, ternaries and ``ticker.inherit`` /
+``standard`` -- so discovery states a value where the run computes the same
+one from the same expression.
+"""
+
+from __future__ import annotations
+
+from .ast_nodes import (
+    BinOp, BoolLiteral, ExprStmt, FuncCall, Identifier, MemberAccess, NaLiteral,
+    NumberLiteral, StringLiteral, Subscript, SwitchStmt, Ternary, UnaryOp,
+)
+from .errors import CompileError, Phase
+from .external_requests import FEED_LOWERING, LOWERING_ANNOTATION, _nodes
+from .pine_spelling import is_input_call, pine_string_literal
+from .security_contexts import _REGISTRATION_INPUTS, ScriptIndex, _reached, ticker_symbol_arg
+
+# A deferred refusal's lowering (``support_checker._lower_no_data_request``,
+# ``external_requests.unpin_requests``).
+_UNPINNED_LOWERING = "unpinned"
+# The chart's own timeframe where a fold meets ``timeframe.period``.
+_CHART = object()
+_UNKNOWN = object()
+# A folded value longer than any symbol or timeframe is no key.
+_MAX_VALUE_CHARS = 1024
+# Names a fold follows, one through another, and nodes it visits, before it
+# gives up (the value is then unknown).
+_MAX_FOLD_DEPTH = 256
+_MAX_FOLD_STEPS = 100_000
+
+
+class _Fold:
+    """One value's fold: each name expanded and folded once."""
+
+    def __init__(self, gen) -> None:
+        self.gen = gen
+        self.names: dict[str, object] = {}
+        self.steps = 0
+_PRECEDENCE = {"or": 1, "and": 2, "==": 3, "!=": 3, "<": 4, "<=": 4, ">": 4, ">=": 4,
+               "+": 5, "-": 5, "*": 6, "/": 6, "%": 6}
+
+
+def request_sites(program) -> list[FuncCall]:
+    """The ``request.security`` calls the support checker lowered onto
+    another symbol's feed or to a deferred refusal, outside the helpers
+    nothing reaches: taken before the passes that replace a refusal by its
+    ``na`` (``lower_no_data_requests``) or turn a feed back into one
+    (``unpin_requests``), which mark it so."""
+    sites = [node for node in _nodes(program)
+             if isinstance(node, FuncCall) and _call_name(node) == ("request", "security")
+             and (node.annotations or {}).get(LOWERING_ANNOTATION)
+             in (FEED_LOWERING, _UNPINNED_LOWERING)]
+    if not sites:
+        return sites
+    index = ScriptIndex(program)
+    reached = _reached(index)
+    return [site for site in sites
+            if (owner := index.owner.get(id(site))) not in index.funcs or owner in reached]
+
+
+def discover_requests(gen, ctx, sites: list[FuncCall]) -> list[dict]:
+    """The requests of another symbol's data (module docstring), by line,
+    each distinct entry once."""
+    entries: list[tuple[tuple, dict]] = []
+    calls = {call.sec_id: call for call in ctx.security_calls}
+    mutable_reads = set(gen._security_tf_mutable_reads)
+
+    def add(loc, entry: dict) -> None:
+        entry = {"line": loc.line if loc is not None else None, "fn": "request.security",
+                 **entry}
+        where = (loc.line or 0, loc.col or 0) if loc is not None else (0, 0)
+        entries.append(((*where, len(entries)), entry))
+
+    budget = getattr(gen, "_budget", None)
+    foreign = [info for info in gen._security_eval_info if info.get("foreign")]
+    helpers: set[str] = set()
+    unreached: set[str] = set()
+    if any(getattr(calls.get(info["sec_id"]), "containing_func", "") for info in foreign):
+        # A helper nothing reaches never runs: its registration is never read.
+        index = ScriptIndex(ctx.ast)
+        helpers = set(index.funcs)
+        unreached = helpers - _reached(index)
+    try:
+        for info in foreign:
+            helper = getattr(calls.get(info["sec_id"]), "containing_func", "")
+            if helper in helpers and helper in unreached:
+                continue
+            # Past the time budget the rest are listed as written, unexpanded:
+            # discovery never fails a script that transpiled.
+            expand = _within(budget)
+            entry = {
+                "symbol": _guarded(_symbol, gen, info["symbol_node"], expand=expand),
+                "timeframe": _guarded(_registered_timeframe, gen, info, expand=expand),
+                "lookahead": bool(info.get("lookahead_on")),
+                "gaps": bool(info.get("gaps_on")),
+                "ignore_invalid_symbol": _guarded(
+                    _flag, gen, info.get("ignore_invalid_node"), expand=expand),
+            }
+            column = gen._security_footprint_column(info["sec_id"])
+            if column:
+                entry["column"] = column
+            add(getattr(calls.get(info["sec_id"]), "loc", None), entry)
+        for site in sites:
+            if (site.annotations or {}).get(LOWERING_ANNOTATION) != _UNPINNED_LOWERING:
+                continue
+            # The C++ never registered it, so nothing expands its names here:
+            # its arguments are listed as written.
+            symbol, timeframe = _request_args(site)
+            gaps, lookahead = _gaps_lookahead(site)
+            ignore = site.kwargs.get("ignore_invalid_symbol")
+            add(site.loc, {
+                "symbol": {"kind": "unresolvable", "expr": _spell(symbol)},
+                "timeframe": _guarded(_timeframe, gen, timeframe, expand=False),
+                "lookahead": _barmerge(lookahead, "lookahead_on"),
+                "gaps": _barmerge(gaps, "gaps_on"),
+                "ignore_invalid_symbol": (
+                    False if ignore is None else
+                    ignore.value if isinstance(ignore, BoolLiteral) else None),
+            })
+    finally:
+        # Expanding a name registers a reassigned global's read with the
+        # first-bar replay; generation is over, so leave its record as it was.
+        gen._security_tf_mutable_reads = mutable_reads
+    out: list[dict] = []
+    for _, entry in sorted(entries, key=lambda item: item[0]):
+        if entry not in out:
+            out.append(entry)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Symbol and timeframe
+# ---------------------------------------------------------------------------
+
+def _within(budget) -> bool:
+    """Whether the transpile's time budget still holds."""
+    if budget is None:
+        return True
+    try:
+        budget.check(phase=Phase.CODEGEN)
+    except CompileError:
+        return False
+    return True
+
+
+def _guarded(classify, gen, node, **options):
+    """``classify(gen, node)``; a shape it does not know is listed as
+    computed, with no value: discovery never fails a script that
+    transpiled."""
+    try:
+        return classify(gen, node, **options)
+    except Exception:  # noqa: BLE001
+        if isinstance(node, dict):
+            node = node.get("tf_node")
+        return None if classify is _flag else {"kind": "computed", "expr": _spell(node)}
+
+
+def _symbol(gen, node, expand: bool = True) -> dict:
+    """``literal`` / ``input`` / ``computed`` as registration computes the
+    symbol string the run keys its feed on."""
+    resolved = _passthrough(_expand(gen, node) if expand else node)
+    if isinstance(resolved, StringLiteral):
+        return {"kind": "literal", "value": resolved.value}
+    if _is_registered_input(resolved):
+        return _input(gen, resolved)
+    if not expand:
+        return {"kind": "computed", "expr": _spell(node)}
+    return _computed(gen, node, resolved, timeframe=False)
+
+
+def _registered_timeframe(gen, info: dict, expand: bool = True) -> dict:
+    """The timeframe a feed site registers with (``_resolve_security_tf``'s
+    ``tf`` / ``tf_expr``, ``configure_security_evaluators``). ``input_tf_``
+    is the chart's: a run reading another symbol's feed takes the chart's
+    bars unaggregated (the engine refuses it otherwise)."""
+    tf, tf_expr = info.get("tf"), info.get("tf_expr")
+    if tf:
+        return {"kind": "literal", "value": canonical_timeframe(tf)}
+    if tf == "" or tf_expr in ("input_tf_", "script_tf_"):
+        return {"kind": "chart"}
+    return _timeframe(gen, info.get("tf_node"), expand=expand)
+
+
+def _timeframe(gen, node, expand: bool = True) -> dict:
+    """A timeframe registration expands (``expand``), or as written."""
+    if node is None:
+        return {"kind": "chart"}
+    resolved = _expand(gen, node) if expand else node
+    if isinstance(resolved, StringLiteral):
+        if resolved.value == "":
+            return {"kind": "chart"}
+        return {"kind": "literal", "value": canonical_timeframe(resolved.value)}
+    if _is_timeframe_period(resolved):
+        return {"kind": "chart"}
+    if _is_registered_input(resolved, timeframe=True):
+        return _input(gen, resolved)
+    if not expand:
+        return {"kind": "computed", "expr": _spell(node)}
+    return _computed(gen, node, resolved, timeframe=True)
+
+
+def canonical_timeframe(tf: str) -> str:
+    """The engine's spelling of a feed's timeframe
+    (``canonical_symbol_timeframe``): Pine's bare ``D`` / ``W`` / ``M`` /
+    ``S`` folded to ``1D`` / ``1W`` / ``1M`` / ``1S``, any other text kept
+    as it is (whole minutes ``"240"``, ``<n>D|W|M|S``; a feed matches no
+    other spelling)."""
+    return "1" + tf if tf in ("D", "W", "M", "S") else tf
+
+
+def _input(gen, call: FuncCall) -> dict:
+    default = _input_default(gen, call)
+    return {"kind": "input", "title": gen._get_input_title(call),
+            "default": None if default is _UNKNOWN else default}
+
+
+def _computed(gen, node, resolved, *, timeframe: bool) -> dict:
+    out = {"kind": "computed", "expr": _spell(node)}
+    value = _fold(_Fold(gen), resolved)
+    if value is _CHART and timeframe:
+        out["value"] = ""
+    elif isinstance(value, str):
+        out["value"] = canonical_timeframe(value) if timeframe and value else value
+    titles: list[str] = []
+    for call in _input_calls(gen, resolved):
+        title = gen._get_input_title(call)
+        if title not in titles:
+            titles.append(title)
+    if titles:
+        out["inputs"] = titles
+    return out
+
+
+def _flag(gen, node, expand: bool = True) -> bool | None:
+    """``ignore_invalid_symbol`` as registration reads it: false when left
+    out, else its value at the inputs' defaults (None when unknown)."""
+    if node is None:
+        return False
+    if not expand:
+        return node.value if isinstance(node, BoolLiteral) else None
+    value = _fold(_Fold(gen), _expand(gen, node))
+    return value if isinstance(value, bool) else None
+
+
+def _expand(gen, node):
+    """``node`` with its names expanded as registration expands them."""
+    return gen._substitute_tf_input_reads(node, set())
+
+
+def _passthrough(node):
+    """``ticker.inherit`` / ``ticker.standard`` render their symbol argument
+    unchanged (``visit_call``)."""
+    while (isinstance(node, FuncCall) and _call_name(node) in (
+            ("ticker", "inherit"), ("ticker", "standard"))):
+        symbol = ticker_symbol_arg(node)
+        if symbol is None:
+            break
+        node = symbol
+    return node
+
+
+def _is_registered_input(node, timeframe: bool = False) -> bool:
+    """An input whose value registration reads: ``input.symbol`` /
+    ``string`` (``timeframe`` for a timeframe), or ``input()`` of a string."""
+    if not is_input_call(node):
+        return False
+    ns, name = _call_name(node)
+    if ns is None:
+        default = node.args[0] if node.args else node.kwargs.get("defval")
+        return isinstance(default, StringLiteral)
+    return name in (_REGISTRATION_INPUTS - {"bool"}) or (timeframe and name == "timeframe")
+
+
+def _input_default(gen, call: FuncCall):
+    default = gen._get_input_default(call)
+    if isinstance(default, (StringLiteral, BoolLiteral, NumberLiteral)):
+        return default.value
+    return _UNKNOWN
+
+
+def _input_calls(gen, node) -> list[FuncCall]:
+    """The input calls ``node`` reads, through the names registration
+    expands (a ``switch``'s too), in source order."""
+    found: dict[int, FuncCall] = {}
+    seen: set[str] = set()
+    pending = [node]
+    while pending:
+        for item in _nodes(pending.pop()):
+            if is_input_call(item):
+                found.setdefault(id(item), item)
+            elif isinstance(item, Identifier) and item.name not in seen:
+                seen.add(item.name)
+                expanded = _expand(gen, item)
+                if expanded is not item:
+                    pending.append(expanded)
+    return sorted(found.values(), key=lambda call: (call.loc.line, call.loc.col)
+                  if call.loc is not None else (0, 0))
+
+
+def _fold(state: _Fold, node, depth: int = 0):
+    """The value at the inputs' defaults of an expression in
+    ``ScriptIndex.registration_value``'s grammar (and, for a timeframe, a
+    ``switch`` of single-expression arms, as registration renders it), else
+    ``_UNKNOWN``. The chart's own symbol strings are the chart's (unknown
+    here); ``timeframe.period`` is ``_CHART``."""
+    state.steps += 1
+    if depth > _MAX_FOLD_DEPTH or state.steps > _MAX_FOLD_STEPS:
+        return _UNKNOWN
+    depth += 1
+    if isinstance(node, (StringLiteral, BoolLiteral)):
+        return node.value
+    if isinstance(node, NumberLiteral):
+        return node.value
+    if _is_timeframe_period(node):
+        return _CHART
+    if isinstance(node, Identifier):
+        # A name registration expands (a switch's subject: the expansion
+        # leaves a switch as written); one it keeps has no value here.
+        if node.name not in state.names:
+            state.names[node.name] = _UNKNOWN  # a name read inside its own value
+            expanded = _expand(state.gen, node)
+            state.names[node.name] = (_UNKNOWN if expanded is node
+                                      else _fold(state, expanded, depth))
+        return state.names[node.name]
+    if isinstance(node, SwitchStmt):
+        return _fold_switch(state, node, depth)
+    if isinstance(node, FuncCall):
+        if is_input_call(node):
+            ns, name = _call_name(node)
+            if ns is None or name in _REGISTRATION_INPUTS or name == "timeframe":
+                return _input_default(state.gen, node)
+            return _UNKNOWN
+        passed = _passthrough(node)
+        return _UNKNOWN if passed is node else _fold(state, passed, depth)
+    if isinstance(node, Ternary):
+        condition = _fold(state, node.condition, depth)
+        if not isinstance(condition, bool):
+            return _UNKNOWN
+        return _fold(state, node.true_val if condition else node.false_val, depth)
+    if isinstance(node, UnaryOp):
+        operand = _fold(state, node.operand, depth)
+        return (not operand) if node.op == "not" and isinstance(operand, bool) else _UNKNOWN
+    if isinstance(node, BinOp) and node.op in ("+", "==", "!=", "and", "or"):
+        left = _fold(state, node.left, depth)
+        if left is _UNKNOWN or left is _CHART:
+            return _UNKNOWN
+        right = _fold(state, node.right, depth)
+        if right is _UNKNOWN or right is _CHART:
+            return _UNKNOWN
+        if node.op == "+":
+            if not (isinstance(left, str) and isinstance(right, str)
+                    and len(left) + len(right) <= _MAX_VALUE_CHARS):
+                return _UNKNOWN
+            return left + right
+        if node.op in ("and", "or"):
+            if not (isinstance(left, bool) and isinstance(right, bool)):
+                return _UNKNOWN
+            return (left and right) if node.op == "and" else (left or right)
+        if type(left) is not type(right):
+            return _UNKNOWN
+        return (left == right) if node.op == "==" else (left != right)
+    return _UNKNOWN
+
+
+def _fold_switch(state: _Fold, node: SwitchStmt, depth: int):
+    """A timeframe ``switch`` as registration renders it
+    (``_security_tf_switch_runtime_expr``): the first arm whose value equals
+    the subject (or whose condition holds), else the default arm, else the
+    chart's timeframe; every arm one expression."""
+    subject = None
+    if node.expr is not None:
+        subject = _fold(state, node.expr, depth)
+        if subject is _UNKNOWN or subject is _CHART:
+            return _UNKNOWN
+
+    def arm(body):
+        if len(body) != 1 or not isinstance(body[0], ExprStmt) or isinstance(
+                body[0].expr, NaLiteral):
+            return _UNKNOWN
+        return _fold(state, body[0].expr, depth)
+
+    default = node.default_body or None
+    for condition, body in node.cases:
+        if condition is None:
+            default = default or body
+            continue
+        value = _fold(state, condition, depth)
+        if value is _UNKNOWN or value is _CHART:
+            return _UNKNOWN
+        if (value is True if node.expr is None
+                else type(value) is type(subject) and value == subject):
+            return arm(body)
+    return arm(default) if default else _CHART
+
+
+# ---------------------------------------------------------------------------
+# Call shapes and spelling
+# ---------------------------------------------------------------------------
+
+def _call_name(node: FuncCall) -> tuple[str | None, str | None]:
+    callee = node.callee
+    if isinstance(callee, Identifier):
+        return None, callee.name
+    if isinstance(callee, MemberAccess) and isinstance(callee.object, Identifier):
+        return callee.object.name, callee.member
+    return None, None
+
+
+def _is_timeframe_period(node) -> bool:
+    """``timeframe.period`` or ``timeframe.main_period``: the chart's."""
+    return (isinstance(node, MemberAccess) and node.member in ("period", "main_period")
+            and isinstance(node.object, Identifier) and node.object.name == "timeframe")
+
+
+def _request_args(node: FuncCall):
+    symbol = node.args[0] if node.args else node.kwargs.get("symbol")
+    timeframe = node.args[1] if len(node.args) > 1 else node.kwargs.get("timeframe")
+    return symbol, timeframe
+
+
+def _gaps_lookahead(node: FuncCall):
+    gaps = node.kwargs.get("gaps")
+    if gaps is None and len(node.args) > 3:
+        gaps = node.args[3]
+    lookahead = node.kwargs.get("lookahead")
+    if lookahead is None and len(node.args) > 4:
+        lookahead = node.args[4]
+    return gaps, lookahead
+
+
+def _barmerge(node, on: str) -> bool | None:
+    """A ``barmerge.*`` constant's flag; left out is off; None when computed."""
+    if node is None:
+        return False
+    if (isinstance(node, MemberAccess) and isinstance(node.object, Identifier)
+            and node.object.name == "barmerge"):
+        return node.member == on
+    return None
+
+
+def _spell(node, parent: int = 0, right: bool = False) -> str:
+    """``node`` spelled as Pine source (display only)."""
+    if node is None:
+        return ""
+    if isinstance(node, StringLiteral):
+        return pine_string_literal(node.value)
+    if isinstance(node, BoolLiteral):
+        return "true" if node.value else "false"
+    if isinstance(node, NumberLiteral):
+        return str(node.value)
+    if isinstance(node, NaLiteral):
+        return "na"
+    if isinstance(node, Identifier):
+        return node.name
+    if isinstance(node, MemberAccess):
+        return f"{_spell(node.object, 9)}.{node.member}"
+    if isinstance(node, FuncCall):
+        args = [_spell(a) for a in node.args]
+        args += [f"{key} = {_spell(value)}" for key, value in node.kwargs.items()]
+        return f"{_spell(node.callee, 9)}({', '.join(args)})"
+    if isinstance(node, Subscript):
+        return f"{_spell(node.object, 9)}[{_spell(node.index)}]"
+    if isinstance(node, UnaryOp):
+        text = f"not {_spell(node.operand, 7)}" if node.op == "not" else (
+            f"{node.op}{_spell(node.operand, 7)}")
+        return f"({text})" if parent > 7 else text
+    if isinstance(node, BinOp):
+        level = _PRECEDENCE.get(node.op, 5)
+        text = (f"{_spell(node.left, level)} {node.op} "
+                f"{_spell(node.right, level, right=True)}")
+        return f"({text})" if level < parent or (right and level == parent) else text
+    if isinstance(node, Ternary):
+        text = (f"{_spell(node.condition, 1)} ? {_spell(node.true_val)} : "
+                f"{_spell(node.false_val)}")
+        return f"({text})" if parent else text
+    return "..."

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "1.0.1",
+  "codegen": "1.1.0",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "2ad9a8595850ce2c485dcddb049fd738097d9149d2136ce83a951a506541a113"
+  "sha256": "37b1ca85a2006f6f07d52074a7180187536047bfbb857681978a372b1d7f9bef"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "1.0.1",
+  "CODEGEN_VERSION": "1.1.0",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",

package/transpile.worker.mjs

@@ -49,7 +49,8 @@ def transpile_json(source: str) -> str:
     # A script that transpiled carries its warnings in the same entry format.
     return json.dumps({"ok": True, "cpp": full["cpp"], "inputs": full["inputs"],
                        "strategyParams": full["strategyParams"],
-                       "diagnostics": _diagnostic_entries(full["diagnostics"])})
+                       "diagnostics": _diagnostic_entries(full["diagnostics"]),
+                       "requests": full["requests"]})
 `;
 
 const post = (m) => self.postMessage(m);