@pineforge/codegen-pyodide 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pineforge/codegen-pyodide",
-  "version": "1.3.0",
+  "version": "1.4.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

@@ -164,11 +164,12 @@ def transpile_full(pine_source: str, *, check_support: bool = True,
     - ``cpp``: the generated C++ source (identical to :func:`transpile`).
     - ``inputs``: a list of ``InputDef`` dicts (one per global-scope
       ``input(...)`` / ``input.*(...)`` call, inline calls included, in
-      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); an ``input.symbol`` entry also has
-      ``kind: "symbol"``. See :meth:`CodeGen.extract_input_manifest`.
+      source order). Each has ``title`` / ``type`` / ``default`` /
+      ``supported`` (the checked-settings receipt's flag) and optionally
+      ``min`` / ``max`` / ``step`` / ``options`` (omitted when the
+      corresponding signature argument is absent or is not a literal the
+      receipt holds); 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`,

package/pineforge_codegen/analyzer/base.py

@@ -1758,7 +1758,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             for collection_owner, collection_names in persistent_collections.items():
                 if series_owner == collection_owner:
                     continue
-                for exact_name in exact_series_names & collection_names:
+                for exact_name in sorted(exact_series_names & collection_names):
                     raw_name = next(
                         (
                             name for name in names
@@ -4999,7 +4999,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 # ``exit_scope()`` can bind a same-named top-level collection
                 # and falsely turn a scalar UDF return into an array.
                 ret_spec = terminal_direct_return_spec
-                if ret_spec is not None and ret_spec.kind == "array":
+                if ret_spec is not None and ret_spec.kind in ("array", "matrix"):
                     self._func_return_type_specs[node.name] = ret_spec
             if (terminal_direct_return_spec is not None
                     and terminal_direct_return_spec.kind == "map"):
@@ -5150,7 +5150,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 ret_type = self._statement_value_type(node.body[-1], ret_type)
             if terminal_ret_expr is not None:
                 terminal_spec = self._type_spec_from_expr(terminal_ret_expr)
-                if terminal_spec is not None and terminal_spec.kind == "map":
+                if terminal_spec is not None and terminal_spec.kind in ("map", "matrix"):
                     return_type_spec = terminal_spec
                 if terminal_spec is not None and terminal_spec.kind == "udt":
                     # Methods may return ``self`` or another UDT-typed

package/pineforge_codegen/analyzer/types.py

@@ -45,6 +45,7 @@ from ..ast_nodes import (
     SwitchStmt, TupleLiteral, UnaryOp,
 )
 from ..errors import Phase
+from ..matrix_overloads import matrix_sum_has_rhs
 from ..symbols import PineType, TypeSpec, method_receiver_type_name
 
 # Drawing-objects-as-data type names (spec §4.1). Defined locally — the
@@ -537,8 +538,10 @@ class TypeHelper:
                 else:
                     elem = TypeSpec.primitive("float")
                 return TypeSpec.matrix(elem)
-            if ns == "matrix" and func in _MATRIX_RETURNING_METHODS:
-                receiver = value.args[0] if value.args else value.kwargs.get("id")
+            if ns == "matrix" and (func in _MATRIX_RETURNING_METHODS or (
+                    func == "sum" and matrix_sum_has_rhs(value, namespace=True))):
+                receiver = (value.args[0] if value.args else
+                            value.kwargs.get("id1", value.kwargs.get("id")))
                 receiver_spec = self._type_spec_from_expr(receiver)
                 if receiver_spec is not None and receiver_spec.kind == "matrix":
                     return receiver_spec
@@ -607,7 +610,8 @@ class TypeHelper:
                     if func == "size":
                         return TypeSpec.primitive("int")
                 if recv_spec is not None and recv_spec.kind == "matrix":
-                    if func in _MATRIX_RETURNING_METHODS:
+                    if func in _MATRIX_RETURNING_METHODS or (
+                            func == "sum" and matrix_sum_has_rhs(value)):
                         return recv_spec
                     if func in ("row", "col"):
                         return TypeSpec.array(recv_spec.element)

package/pineforge_codegen/codegen/base.py

@@ -31,6 +31,7 @@ from ..symbols import PineType, TypeSpec, method_receiver_type_name
 from .. import signatures as sigs
 from ..errors import CompileError, Diagnostic, Level, Phase, SourceLocation
 from ..limits import TimeBudget, iter_ast_nodes
+from ..matrix_overloads import matrix_sum_has_rhs
 from ..session_reads import emitted_session_reads
 from ..block_locals import block_declarations, decl_key
 from ..pine_spelling import (
@@ -1082,7 +1083,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 # (index, signature) of each TA variant computed inline, and
                 # (index, _SECURITY_THROUGH_GLOBAL) of a global's site a
                 # multi-statement helper reads, which the prologue computes.
-                "inline_helper_ta_indices": sorted(inline_helper_ta_indices, key=repr),
+                "inline_helper_ta_indices": inline_helper_ta_indices,
                 "depends_on_mutable_globals": item.get("depends_on_mutable_globals", False),
                 "mutable_globals": list(item.get("mutable_globals", [])),
                 "is_lower_tf_array": bool(item.get("is_lower_tf_array", False)),
@@ -2156,6 +2157,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 # to the analyzer's default ``double`` and the emitted C++
                 # fails to compile (``double = PineMatrix``).
                 or fn in MATRIX_RETURNING_METHODS
+                or (fn == "sum" and matrix_sum_has_rhs(expr, namespace=True))
             ):
                 if fn == "new":
                     targs = self._template_args_from_call(expr) if hasattr(expr, "annotations") else []
@@ -2213,7 +2215,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 outer_callee = expr.callee
                 if (
                     isinstance(outer_callee, MemberAccess)
-                    and outer_callee.member in MATRIX_RETURNING_METHODS
+                    and (outer_callee.member in MATRIX_RETURNING_METHODS or (
+                        outer_callee.member == "sum" and matrix_sum_has_rhs(expr)))
                 ):
                     recv_name2 = self._extract_receiver_name(expr)
                     if recv_name2 is not None and recv_name2 in self._matrix_specs:
@@ -4553,7 +4556,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "",
                 "    Snapshot snapshot() {",
                 "        if (_pf_generation_ == std::numeric_limits<uint64_t>::max()) {",
-                '            throw std::overflow_error("UDT checkpoint generation exhausted");',
+                '            _PF_ENGINE_INVARIANT("UDT checkpoint generation exhausted", std::overflow_error);',
                 "        }",
                 "        ++_pf_generation_;",
                 "        _pf_undo_.clear();",
@@ -4565,13 +4568,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    bool empty() const { return _pf_undo_.empty(); }",
                 "    void record(uint64_t generation, std::function<void()> undo) {",
                 "        if (!_pf_active_ || generation != _pf_generation_) {",
-                '            throw std::runtime_error("invalid UDT undo generation");',
+                '            _PF_ENGINE_INVARIANT("invalid UDT undo generation", std::runtime_error);',
                 "        }",
                 "        _pf_undo_.push_back(std::move(undo));",
                 "    }",
                 "    void restore(const Snapshot& snapshot) {",
                 "        if (!_pf_active_ || snapshot.generation != _pf_generation_) {",
-                '            throw std::runtime_error("invalid UDT coordinator checkpoint token");',
+                '            _PF_ENGINE_INVARIANT("invalid UDT coordinator checkpoint token", std::runtime_error);',
                 "        }",
                 "        for (auto entry = _pf_undo_.rbegin();",
                 "                entry != _pf_undo_.rend(); ++entry) (*entry)();",
@@ -4595,13 +4598,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "",
                 "    void capture(std::size_t index) {",
                 "        if (!_pf_checkpoint_active_) return;",
-                "        auto& slot = _pf_records_.at(index);",
+                "        auto& slot = _PF_INVARIANT_AT(_pf_records_, index);",
                 "        if (slot.logged_generation",
                 "                == _pf_checkpoint_generation_) return;",
                 "        auto snapshot = _PFRecordTraits::take(slot.value);",
                 "        _pf_coordinator_->record(_pf_checkpoint_generation_,",
                 "            [this, index, snapshot = std::move(snapshot)]() mutable {",
-                "                auto& restore_slot = _pf_records_.at(index);",
+                "                auto& restore_slot = _PF_INVARIANT_AT(_pf_records_, index);",
                 "                _PFRecordTraits::restore(restore_slot.value, snapshot);",
                 "                restore_slot.logged_generation = 0;",
                 "            });",
@@ -4617,7 +4620,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 f"            {self._udt_undo_coordinator_cpp_name}* coordinator)",
                 "            : _pf_coordinator_(coordinator) {",
                 "        if (!_pf_coordinator_)",
-                '            throw std::invalid_argument("UDT arena requires undo coordinator");',
+                '            _PF_ENGINE_INVARIANT("UDT arena requires undo coordinator", std::invalid_argument);',
                 "    }",
                 f"    {self._udt_arena_template_cpp_name}(",
                 f"        const {self._udt_arena_template_cpp_name}&) = delete;",
@@ -4639,7 +4642,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    _PFHandle create(_PFRecord value) {",
                 "        if (_pf_records_.size() > static_cast<std::size_t>(",
                 "                std::numeric_limits<int32_t>::max())) {",
-                '            throw std::length_error("UDT object-ID capacity exceeded");',
+                '            _PF_LIMIT_STOP("udt_objects", 2147483647LL, "UDT object-ID capacity exceeded");',
                 "        }",
                 "        const auto id = static_cast<int32_t>(_pf_records_.size());",
                 "        _pf_records_.push_back(_PFSlot{std::move(value), 0});",
@@ -4652,7 +4655,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    _PFRecord& get(_PFHandle value) {",
                 "        if (value.__pf_id < 0",
                 "                || static_cast<std::size_t>(value.__pf_id) >= _pf_records_.size()) {",
-                '            throw std::runtime_error("UDT access on na or invalid object ID");',
+                '            _PF_NA_STOP("udt_object", "UDT access on na or invalid object ID");',
                 "        }",
                 "        const auto index = static_cast<std::size_t>(value.__pf_id);",
                 "        capture(index);",
@@ -4661,7 +4664,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    const _PFRecord& get(_PFHandle value) const {",
                 "        if (value.__pf_id < 0",
                 "                || static_cast<std::size_t>(value.__pf_id) >= _pf_records_.size()) {",
-                '            throw std::runtime_error("UDT access on na or invalid object ID");',
+                '            _PF_NA_STOP("udt_object", "UDT access on na or invalid object ID");',
                 "        }",
                 "        return _pf_records_[static_cast<std::size_t>(value.__pf_id)].value;",
                 "    }",
@@ -4671,14 +4674,14 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    std::size_t size() const { return _pf_records_.size(); }",
                 "    _PFRecord& record_at(std::size_t index) {",
                 "        capture(index);",
-                "        return _pf_records_.at(index).value;",
+                "        return _PF_INVARIANT_AT(_pf_records_, index).value;",
                 "    }",
                 "    const _PFRecord& record_at(std::size_t index) const {",
-                "        return _pf_records_.at(index).value;",
+                "        return _PF_INVARIANT_AT(_pf_records_, index).value;",
                 "    }",
                 "    Snapshot snapshot() {",
                 "        if (!_pf_coordinator_->active()) {",
-                '            throw std::runtime_error("UDT coordinator checkpoint is not active");',
+                '            _PF_ENGINE_INVARIANT("UDT coordinator checkpoint is not active", std::runtime_error);',
                 "        }",
                 "        _pf_checkpoint_generation_ = _pf_coordinator_->generation();",
                 "        _pf_checkpoint_size_ = _pf_records_.size();",
@@ -4693,7 +4696,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "                || snapshot.size != _pf_checkpoint_size_",
                 "                || _pf_records_.size() < snapshot.size",
                 "                || !_pf_coordinator_->empty()) {",
-                '            throw std::runtime_error("invalid UDT checkpoint token");',
+                '            _PF_ENGINE_INVARIANT("invalid UDT checkpoint token", std::runtime_error);',
                 "        }",
                 "        _pf_records_.resize(snapshot.size);",
                 "    }",
@@ -4984,6 +4987,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 if name in self._global_collection_types
                 else self._callable_var_collection_spec(name)
             )
+            history_value_cpp = self._array_history_value_cpp_type(name)
+            if history_value_cpp is not None:
+                lines.append(f"    {history_value_cpp} {safe};")
+                continue
             if callable_collection_spec is not None:
                 lines.append(
                     f"    {self._type_spec_to_cpp(callable_collection_spec)} {safe};"
@@ -5182,7 +5189,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             seen_global.add(name)
             safe = self._safe_name(name)
             
-            if name in self._matrix_specs:
+            history_value_cpp = self._array_history_value_cpp_type(name)
+            if history_value_cpp is not None:
+                lines.append(f"    {history_value_cpp} {safe};")
+            elif name in self._matrix_specs:
                 lines.append(f"    {self._type_spec_to_cpp(self._matrix_specs[name])} {safe};")
             elif name in self._array_vars:
                 lines.append(f"    {self._type_spec_to_cpp(self._array_spec_for_name(name))} {safe};")

package/pineforge_codegen/codegen/checked_settings.py

@@ -7,8 +7,12 @@ from ..errors import CompileError
 from .tables import ALERT_FREQ_VALUES, NAME_ECHO_STRING_MEMBERS, ORDER_DIRECTION_MAP
 
 
-_QUOTED_STRING = r'"(?:[^"\\]|\\.)*"'
+_QUOTED_STRING = r'"(?:[^"\\\x00\r\n]|\\(?:["\\nrt]|000))*"'
 _STRING_LITERAL = re.compile(rf'(?:std::string\({_QUOTED_STRING}\)|{_QUOTED_STRING})')
+_STRING_ESCAPE = re.compile(r'\\(?:["\\nrt]|000)')
+_STRING_ESCAPE_VALUES = {
+    r'\"': '"', r'\\': '\\', r'\n': '\n', r'\r': '\r', r'\t': '\t', r'\000': '\0',
+}
 
 
 def _string_setting_arg(expr, lowered: str) -> str | None:
@@ -45,22 +49,97 @@ def _visit_setting_arg(emitter, expr) -> str:
         return "0"
 
 
+def _string_setting_value(lowered: str) -> str:
+    """Decode the emitter's literals as native std::string(const char*) values.
+
+    Only the serializer's escape grammar is accepted; Unicode stays literal.
+    The receipt's string constructors stop at the first NUL, including one
+    followed by digits, while an escaped backslash remains ordinary data.
+    """
+    if not _STRING_LITERAL.fullmatch(lowered):
+        raise ValueError("setting value is not an emitted C++ string literal")
+    literal = lowered[len("std::string("):-1] if lowered.startswith("std::string(") else lowered
+    decoded = _STRING_ESCAPE.sub(lambda match: _STRING_ESCAPE_VALUES[match.group()], literal[1:-1])
+    return decoded.partition("\0")[0]
+
+
+_NUMERIC_LITERAL = re.compile(r"[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?(?:LL|ULL|L|UL|[fF])?")
+_NUMERIC_SUFFIX = re.compile(r"(?:LL|ULL|L|UL|[fF])$")
+
+
+def _numeric_setting_value(lowered: str) -> int | float | bool | None:
+    """The number or bool a lowered C++ setting expression is, or None.
+
+    Only a plain literal, signed or in parentheses, is read: what the codegen
+    emits for a literal or for a named constant it inlines. Anything the C++
+    computes at run time (an arithmetic expression, a call, a series) stays
+    with the receipt, which evaluates it.
+    """
+    text = lowered.strip()
+    while text.startswith("(") and text.endswith(")"):
+        text = text[1:-1].strip()
+    if text in ("true", "false"):
+        return text == "true"
+    if not _NUMERIC_LITERAL.fullmatch(text):
+        return None
+    text = _NUMERIC_SUFFIX.sub("", text)
+    return float(text) if re.search(r"[.eE]", text) else int(text)
+
+
+def _is_number(value) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
 def emit_settings_members(emitter, lines: list[str], constructor: list[str]) -> None:
     lines.extend([
         "    bool _pf_setting_failed_ = false;",
         "    std::string _pf_setting_failure_;",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "    ::pineforge::RunFailureInfo _pf_setting_failure_info_{::pineforge::RunFailureCode::none, {}};",
+        "#ifdef PF_SETTINGS_API_VERSION",
+        "    using _pf_setting_error_base = ::pineforge::checked_settings::LatchedSettingsFailure;",
+        "#else",
+        "    using _pf_setting_error_base = std::runtime_error;",
+        "#endif",
+        "    struct _pf_latched_setting_error : _pf_setting_error_base, ::pineforge::RunFailureInfo {",
+        "        _pf_latched_setting_error(const std::string& text, const ::pineforge::RunFailureInfo& info)",
+        "            : _pf_setting_error_base(text), ::pineforge::RunFailureInfo(info) {}",
+        "    };",
+        "#endif",
         "    void _pf_record_failure(const char* entrypoint, const char* message) noexcept {",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "        try { ::pineforge::note_run_failure_unknown(*this, entrypoint); } catch (...) {}",
+        "#else",
         "        try { last_error_ = entrypoint; last_error_ += \": \"; last_error_ += message; } catch (...) {}",
+        "#endif",
+        "    }",
+        "    void _pf_record_failure(const char* entrypoint, const std::exception& error) noexcept {",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "        try { ::pineforge::note_run_failure(*this, entrypoint, error); } catch (...) {}",
+        "#else",
+        "        _pf_record_failure(entrypoint, error.what());",
+        "#endif",
         "    }",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "    template <typename FailureInfo>",
+        "    void _pf_record_setting_failure(const char* entrypoint, const char* message, FailureInfo failure_info) noexcept {",
+        "#else",
         "    void _pf_record_setting_failure(const char* entrypoint, const char* message) noexcept {",
+        "#endif",
         "        if (!_pf_setting_failed_) {",
         "            _pf_setting_failed_ = true;",
         '            try { _pf_setting_failure_ = entrypoint; _pf_setting_failure_ += ": "; _pf_setting_failure_ += message; } catch (...) {}',
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        "            try { _pf_setting_failure_info_ = failure_info(); }",
+        "            catch (...) { _pf_setting_failure_info_ = ::pineforge::RunFailureInfo(::pineforge::RunFailureCode::out_of_memory, {}); }",
+        "#endif",
         "        }",
         "        _pf_refuse_failed_setting(nullptr);",
         "    }",
         "    void _pf_require_settings_ok() const {",
-        "#ifdef PF_SETTINGS_API_VERSION",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        '        if (_pf_setting_failed_) throw _pf_latched_setting_error(_pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_, _pf_setting_failure_info_);',
+        "#elif defined(PF_SETTINGS_API_VERSION)",
         '        if (_pf_setting_failed_) throw ::pineforge::checked_settings::LatchedSettingsFailure(_pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_);',
         "#else",
         '        if (_pf_setting_failed_) throw std::runtime_error(_pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_);',
@@ -68,12 +147,17 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
         "    }",
         "    bool _pf_refuse_failed_setting(ReportC* out) noexcept {",
         "        if (!_pf_setting_failed_) return false;",
+        "#ifdef PINEFORGE_HAS_RUN_FAILURE_CODES_V1",
+        '        try { ::pineforge::note_run_failure(*this, _pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_, _pf_setting_failure_info_.run_failure()); } catch (...) {}',
+        "#else",
         '        try { last_error_ = _pf_setting_failure_.empty() ? "legacy strategy setter failed" : _pf_setting_failure_; } catch (...) {}',
+        "#endif",
         "        if (out) *out = ReportC{};",
         "        return true;",
         "    }",
     ])
     inputs = []
+    emitter._input_settings_metadata = {}
     for node, binding in emitter._global_input_calls_with_names():
         func_name, namespace = emitter._resolve_callee(node.callee)
         name = emitter._get_input_title(node, var_name=binding)
@@ -90,6 +174,7 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
         }[getter]
         kind = emitter._FORM_TYPE.get(func_name, value_type) if namespace == "input" else value_type
         options = []
+        numeric_options = []
         option_values = []
         supported = "true"
         default_serialized = None
@@ -146,6 +231,7 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
                             options.append(option_cpp)
                     else:
                         options.append(f'::pineforge::checked_settings::number({option_cpp})')
+                        numeric_options.append(option_cpp)
             if getter == "get_input_string":
                 if arguments.get("options") is not None and declared is None:
                     supported = "false"
@@ -165,6 +251,31 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
                     f'{64 if getter == "get_input_int64" else 32}, {supported}, '
                     f'{{{", ".join(option_values)}}}, "{kind}"}}')
         inputs.append((metadata, effective))
+        manifest = {}
+        if getter == "get_input_string":
+            manifest["default"] = _string_setting_value(default_serialized)
+            if arguments.get("options") is not None or supported == "false":
+                manifest["options"] = [_string_setting_value(option) for option in options]
+        elif value_type == "source":
+            manifest["default"] = source
+            manifest["options"] = [_string_setting_value(option) for option in options]
+        elif value_type == "enum":
+            manifest["options"] = [_string_setting_value(option) for option in options]
+        elif namespace == "input" and kind in ("int", "float", "bool"):
+            # A typed numeric or bool input publishes the numbers the receipt
+            # holds, where its C++ is a plain literal.
+            default_value = _numeric_setting_value(default_cpp) if default is not None else None
+            if default_value is not None and isinstance(default_value, bool) == (kind == "bool"):
+                manifest["default"] = default_value
+            for field, lowered in zip(("min", "max", "step"), constraints):
+                bound = _numeric_setting_value(lowered)
+                if _is_number(bound):
+                    manifest[field] = bound
+            values = [_numeric_setting_value(option) for option in numeric_options]
+            if values and all(_is_number(value) for value in values):
+                manifest["options"] = values
+        manifest["supported"] = supported == "true"
+        emitter._input_settings_metadata[id(node)] = manifest
 
     overrides = [
         ("initial_capital", "float", "initial_capital", "initial_capital", "0.0"),