@pineforge/codegen-pyodide 1.2.0 → 1.4.0

package/pineforge_codegen/codegen/helpers.py

@@ -262,12 +262,18 @@ CPP_STANDARD_MACROS = frozenset("""
     PINEFORGE_HAS_NATIVE_LOWERING_V1 PINEFORGE_HAS_NATIVE_LIVE_V1
     PINEFORGE_HAS_AUX_SECURITY_FEED_V1 PINEFORGE_HAS_SCRIPT_RUN_PREPARE_V1
     PINEFORGE_HAS_EXPLICIT_PINE_CAP_V1
+    PINEFORGE_HAS_RUN_FAILURE_CODES_V1
+    _PF_NO_DATA_STOP _PF_OTHER_SYMBOL_STOP _PF_ARRAY_STOP _PF_COLLECTION_STOP
+    _PF_NA_STOP _PF_LIMIT_STOP _PF_UNSUPPORTED_STOP _PF_STRING_STOP
+    _PF_ENGINE_INVARIANT _PF_INVARIANT_AT _PF_SETTING_FAILURE
     PINEFORGE_HAS_EXPLICIT_PINE_EXECUTION_ADAPTER_V1
     PINEFORGE_NO_STRATEGY_DECLS PF_PINE_TIME_HAS_SESSION_DAY
     PF_PINE_TIME_SESSION_DAY_ARGS PF_VWAP_HAS_SESSION_ANCHOR
     PF_VWAP_SESSION_ANCHOR_ARGS PF_ALMA_HAS_FLOOR
     PF_KC_HAS_USE_TRUE_RANGE PF_VWAP_HAS_ANCHOR_INPUT
     PF_PIVOT_LEVELS_HAS_ANCHOR
+    PF_ABI_VERSION PF_NATIVE_API_VERSION
+    PF_CAPABILITIES_API_VERSION PF_SETTINGS_API_VERSION
 """.split())
 
 # Identifiers used by the emitter as class/type names, namespaces, and
@@ -283,6 +289,9 @@ CPP_EMITTER_NAMES = frozenset("""
     commit_script_state set_strategy_override set_input
     set_magnifier_volume_weighted strategy_declares_bar_magnifier fill_report run
     strategy_capabilities_api_version strategy_capabilities_receipt
+    strategy_confirmed_bar_api_version strategy_confirmed_bar_receipt
+    strategy_order_shapes_api_version strategy_order_shapes_receipt
+    strategy_settings_api_version strategy_get_effective_settings
     precalculate
     strategy_entry strategy_close strategy_close_all strategy_exit
     strategy_exit_cancel_bracket strategy_cancel strategy_cancel_all strategy_order
@@ -291,6 +300,9 @@ CPP_EMITTER_NAMES = frozenset("""
     live_position_size pending_order_count market_admission_journal
     pine_time pine_time_close pine_time_tradingday pine_random
     pine_runtime_error pine_enum_str_at pine_session_ismarket
+    pine_no_data_stop pine_other_symbol_stop pine_array_stop pine_collection_stop
+    pine_na_stop pine_limit_stop pine_unsupported_stop pine_string_stop
+    pine_engine_invariant note_run_failure note_run_failure_unknown
     pine_session_ispostmarket pine_session_ispremarket _PFSessionMarket
     _pf_session_market_ script_tf_
     tf_change tf_is_daily tf_is_intraday tf_is_monthly tf_is_seconds
@@ -317,7 +329,8 @@ CPP_EMITTER_NAMES = frozenset("""
     get_input_int get_input_float get_input_bool get_input_string
     _pf_record_failure _pf_refuse_failed_setting _pf_settings_declared_config
     _pf_record_setting_failure _pf_require_settings_ok
-    _pf_setting_failed_ _pf_setting_failure_
+    _pf_setting_failed_ _pf_setting_failure_ _pf_setting_failure_info_
+    _pf_setting_error_base _pf_latched_setting_error _pf_invariant_at
     _pf_settings_inputs _pf_settings_overrides _pf_set_input_checked
     _pf_set_override_checked _pf_settings_receipt
     _pf_close_entries_rule_word _pf_default_qty_type_word _pf_commission_type_word
@@ -369,12 +382,16 @@ CPP_TEMPORARY_NAMES = frozenset("""
     __pf_s __pf_r __pf_p __pf_i __pf_j __pf_t __pf_it __pf_m __pf_c __pf_n
     __pf_k __pf_b __pf_ma __pf_mb __pf_f __pf_d __pf_best __pf_bc __pf_rank
     __pf_idx __pf_occ
+    _pf_number_text
+    _pf_substring_text _pf_substring_begin _pf_substring_end _pf_substring_error
+    _pf_array_new_size _pf_array_new_value _pf_array_new_size_type _pf_array_new_error
 """.split())
 _CPP_TEMPORARY_PATTERN = re.compile(
     r"_v\d+|_secval_\d+(?:_v\d+)?|_tuple_result_\d+|_tuple_unused_\d+|__switch_val_\d+"
     r"|_for_(?:start|end|end_eval)_\d+|_pf_(?:str|array|round)_a\d+"
     r"|_pf_every_bar_ta_\d+|_pf_shared_\d+_\d+|__pf_array\w*|__pf_raw_\w+"
     r"|_pf_collection_hist_\w+"
+    r"|_pf_substring_arg\d+"
 )
 
 
@@ -432,8 +449,15 @@ class NamingHelper:
             .replace("\n", "\\n")
             .replace("\r", "\\r")
             .replace("\t", "\\t")
+            .replace("\0", "\\000")
         )
 
+    @staticmethod
+    def _cpp_comment_escape(s: str) -> str:
+        """Keep text (a script's string rendered into it) inside the C++
+        ``/* ... */`` comment it is written in."""
+        return s.replace("/*", "/ *").replace("*/", "* /")
+
     def _initialise_safe_names(self, ast) -> None:
         """Reserve all authored spellings before assigning escaped ones.
 

package/pineforge_codegen/codegen/host_members.py

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

package/pineforge_codegen/codegen/input.py

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

package/pineforge_codegen/codegen/order_shapes.py

@@ -0,0 +1,356 @@
+"""Immutable facts about emitted order parameters and execution context."""
+
+from collections import ChainMap, Counter
+from dataclasses import dataclass
+import json
+import math
+import re
+
+from ..ast_nodes import (
+    BinOp, BoolLiteral, ForInStmt, ForStmt, FuncCall, FuncDef, Identifier, IfStmt,
+    MemberAccess, MethodDef, NumberLiteral, StringLiteral, SwitchStmt, TupleAssign,
+    UnaryOp, VarDecl, WhileStmt,
+)
+from ..limits import iter_ast_nodes, syntax_children
+from .capabilities import READ_ONLY_STRATEGY_CALLS, _expression
+from .host_members import HOST_MEMBER_NAMES
+
+
+NUMERIC_PARAMETERS = frozenset((
+    "limit", "stop", "qty", "qty_percent", "trail_points", "trail_offset",
+    "trail_price", "profit_ticks", "loss_ticks",
+))
+FINITE_BAR_VALUES = frozenset(("open", "high", "low", "close", "hl2", "hlc3", "ohlc4", "hlcc4"))
+ENUM_VALUES = {
+    "strategy.oca.none": 0, "strategy.oca.cancel": 1, "strategy.oca.reduce": 2,
+    "strategy.fixed": 0, "strategy.percent_of_equity": 1, "strategy.cash": 2,
+}
+SETTING_DEFAULTS = {
+    "initial_capital": 10000.0, "default_qty_type": "fixed", "default_qty_value": 1.0,
+    "pyramiding": 1, "commission_type": "percent", "commission_value": 0.0,
+    "slippage": 0, "margin_long": 100.0, "margin_short": 100.0,
+    "close_entries_rule": "FIFO",
+}
+SETTING_ENUMS = {
+    "QtyType::FIXED": "fixed", "QtyType::PERCENT_OF_EQUITY": "percent_of_equity",
+    "QtyType::CASH": "cash", "CommissionType::PERCENT": "percent",
+    "CommissionType::CASH_PER_ORDER": "cash_per_order",
+    "CommissionType::CASH_PER_CONTRACT": "cash_per_contract",
+}
+CPP_TOKENS = re.compile(
+    r'R"(?P<delimiter>[^ ()\\\t\r\n]{0,16})\(.*?\)(?P=delimiter)"'
+    r'|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\''
+    r'|//[^\n]*|/\*.*?(?:\*/|\Z)|[A-Za-z_][A-Za-z_0-9]*',
+    re.DOTALL,
+)
+
+
+def scan_host_reads(cpp: str) -> set[str]:
+    """Cross-check host tokens, excluding C++ strings and comments."""
+    return {match.group() for match in CPP_TOKENS.finditer(cpp)
+            if match.group() in HOST_MEMBER_NAMES}
+
+
+class HostReadLines(list):
+    """Record scaffold references when each fragment enters the emission buffer."""
+
+    def __init__(self, reads: set[str]):
+        super().__init__()
+        self.reads = reads
+        self.in_comment = False
+
+    def _record(self, fragment: str) -> None:
+        if self.in_comment:
+            end = fragment.find("*/")
+            if end < 0:
+                return
+            fragment = fragment[end + 2:]
+            self.in_comment = False
+        for match in CPP_TOKENS.finditer(fragment):
+            token = match.group()
+            if token in HOST_MEMBER_NAMES:
+                self.reads.add(token)
+            if token.startswith("/*") and not token.endswith("*/"):
+                self.in_comment = True
+
+    def append(self, fragment: str) -> None:
+        self._record(fragment)
+        super().append(fragment)
+
+    def extend(self, fragments) -> None:
+        if fragments is self:
+            fragments = list(fragments)
+        for fragment in fragments:
+            self.append(fragment)
+
+    def _record_rewrite(self) -> None:
+        self.in_comment = False
+        for fragment in self:
+            self._record(fragment)
+
+    def insert(self, index: int, fragment: str) -> None:
+        super().insert(index, fragment)
+        self._record_rewrite()
+
+    def __setitem__(self, index, fragments) -> None:
+        super().__setitem__(index, fragments)
+        self._record_rewrite()
+
+    def __iadd__(self, fragments):
+        self.extend(fragments)
+        return self
+
+    def __imul__(self, count):
+        super().__imul__(count)
+        self._record_rewrite()
+        return self
+
+    def __delitem__(self, index) -> None:
+        super().__delitem__(index)
+        self._record_rewrite()
+
+    def clear(self) -> None:
+        super().clear()
+        self._record_rewrite()
+
+    def pop(self, index=-1):
+        fragment = super().pop(index)
+        self._record_rewrite()
+        return fragment
+
+    def remove(self, fragment) -> None:
+        super().remove(fragment)
+        self._record_rewrite()
+
+    def reverse(self) -> None:
+        super().reverse()
+        self._record_rewrite()
+
+    def sort(self, *, key=None, reverse=False) -> None:
+        try:
+            super().sort(key=key, reverse=reverse)
+        finally:
+            self._record_rewrite()
+
+
+@dataclass(frozen=True)
+class LoweredParameter:
+    text: str
+    node: object
+    default: str | None = None
+
+
+@dataclass
+class LoweredCall:
+    node: FuncCall
+    call: str
+    parameters: dict[str, LoweredParameter]
+    context: str
+    form: str | None = None
+
+
+def record_order_call(emitter, node, call, parameters, form=None) -> None:
+    """Called only by a branch that lowers the corresponding order command."""
+    key = (id(node), getattr(emitter, "_current_instance_name", None))
+    emitter._order_shape_calls.setdefault(key, LoweredCall(
+        node, call, {name: LoweredParameter(*value) for name, value in parameters.items()},
+        "repeatable" if getattr(emitter, "_current_func_body", None) is not None else "straight", form,
+    ))
+
+
+def _literal(node, bindings):
+    if isinstance(node, (NumberLiteral, StringLiteral, BoolLiteral)):
+        return node.value
+    if isinstance(node, Identifier):
+        return bindings.get(node.name)
+    if isinstance(node, UnaryOp) and node.op in ("+", "-"):
+        value = _literal(node.operand, bindings)
+        if type(value) in (int, float):
+            return value if node.op == "+" else -value
+    return None
+
+
+def _finite(value) -> bool:
+    return type(value) in (int, float) and math.isfinite(value)
+
+
+def _never_na(node, bindings) -> bool:
+    if _finite(_literal(node, bindings)):
+        return True
+    if isinstance(node, Identifier):
+        return node.name in FINITE_BAR_VALUES and node.name not in bindings
+    if isinstance(node, UnaryOp) and node.op in ("+", "-"):
+        return _never_na(node.operand, bindings)
+    if isinstance(node, BinOp):
+        if node.op in ("+", "-"):
+            return _never_na(node.left, bindings) and _never_na(node.right, bindings)
+        if node.op == "*":
+            return ((_finite(_literal(node.left, bindings)) and _never_na(node.right, bindings))
+                    or (_finite(_literal(node.right, bindings)) and _never_na(node.left, bindings)))
+    return False
+
+
+def parameter_class(name, parameter, bindings):
+    if parameter.text == parameter.default:
+        return "absent"
+    value = _literal(parameter.node, bindings)
+    if name in ("id", "from_entry"):
+        if parameter.node is None and parameter.text == '\"\"':
+            value = ""
+        if isinstance(value, str):
+            return ("global" if not value else "named") if name == "from_entry" else (
+                "literal" if value else "empty")
+        return "dynamic"
+    if name == "direction":
+        if parameter.text == "true":
+            return "long"
+        if parameter.text == "false":
+            return "short"
+        return "dynamic"
+    if name in NUMERIC_PARAMETERS:
+        if _finite(value):
+            return "literal"
+        return "never_na" if _never_na(parameter.node, bindings) else "maybe_na"
+    if name in ("comment", "oca_name"):
+        if value == "":
+            return "absent"
+        return "literal" if isinstance(value, str) else "dynamic"
+    if name in ("oca_type", "qty_type"):
+        if isinstance(parameter.node, MemberAccess):
+            value = ENUM_VALUES.get(_expression(parameter.node))
+        if _finite(value) and str(int(value)) == parameter.default and value == int(value):
+            return "absent"
+        return f"literal:{int(value)}" if _finite(value) and value == int(value) else "dynamic"
+    if name == "immediately":
+        return "literal:true" if value is True else "dynamic"
+    raise ValueError(f"unclassified lowered order parameter: {name}")
+
+
+def _site_facts(ast, mutable_globals, recorded_nodes):
+    """Source ordering, lexical shadows, and repeatability for authored call sites."""
+    bindings = {}
+    for node in ast.body:
+        if isinstance(node, VarDecl):
+            value = _literal(node.value, bindings)
+            bindings[node.name] = (value if not node.is_var and not node.is_varip
+                                   and node.name not in mutable_globals else None)
+    facts = {}
+
+    def block(statements, repeatable, visible, names=()):
+        local = {name: None for name in names}
+        scope = ChainMap(local, visible)
+        for statement in statements:
+            walk(statement, repeatable, scope)
+            if isinstance(statement, VarDecl):
+                local[statement.name] = None
+            elif isinstance(statement, TupleAssign):
+                local.update({name: None for name in statement.names})
+
+    def walk(node, repeatable, visible):
+        if id(node) in recorded_nodes:
+            facts[id(node)] = (len(facts), "repeatable" if repeatable else "straight", dict(visible))
+        if isinstance(node, (FuncDef, MethodDef)):
+            block(node.body, True, visible,
+                  (name if isinstance(name, str) else name[0] for name in node.params))
+        elif isinstance(node, (ForStmt, ForInStmt, WhileStmt)):
+            for field in ("start", "end", "step", "iterable", "condition"):
+                expression = getattr(node, field, None)
+                if expression is not None:
+                    walk(expression, True, visible)
+            names = ([node.var] if node.var else node.vars or []) if isinstance(node, (ForStmt, ForInStmt)) else ()
+            block(node.body, True, visible, names)
+        elif isinstance(node, IfStmt):
+            walk(node.condition, repeatable, visible)
+            block(node.body, repeatable, visible)
+            block(node.else_body, repeatable, visible)
+        elif isinstance(node, SwitchStmt):
+            if node.expr is not None:
+                walk(node.expr, repeatable, visible)
+            for condition, statements in node.cases:
+                if condition is not None:
+                    walk(condition, repeatable, visible)
+                block(statements, repeatable, visible)
+            block(node.default_body, repeatable, visible)
+        else:
+            for child in reversed(list(syntax_children(node))):
+                walk(child, repeatable, visible)
+
+    for statement in ast.body:
+        walk(statement, False, bindings)
+    return facts
+
+
+def settings_echo(constructor):
+    settings = dict(SETTING_DEFAULTS)
+    pooc = False
+    for statement in constructor:
+        match = re.fullmatch(r"        cfg\.(\w+) = (.*);", statement)
+        if match is None:
+            continue
+        name, text = match.groups()
+        if name == "process_orders_on_close":
+            pooc = text == "true"
+        elif name == "close_entries_rule_any":
+            settings["close_entries_rule"] = "ANY" if text == "true" else "FIFO"
+        elif name in settings:
+            if text.startswith("static_cast<int>("):
+                settings[name] = SETTING_ENUMS[text[len("static_cast<int>("):-1]]
+            else:
+                value = float(text)
+                settings[name] = (int(value) if name in ("pyramiding", "slippage") else value) if math.isfinite(value) else None
+    return settings, pooc
+
+
+def order_shapes_document(emitter) -> str:
+    recorded_nodes = {id(record.node) for record in emitter._order_shape_calls.values()}
+    facts = _site_facts(emitter.ctx.ast, emitter.ctx.global_mutable_infos, recorded_nodes)
+    records = sorted(emitter._order_shape_calls.values(), key=lambda record: (
+        record.node.loc.line if record.node.loc else 0,
+        record.node.loc.col if record.node.loc else 0,
+        facts.get(id(record.node), (len(facts),))[0],
+    ))
+    calls = []
+    ids = []
+    for site, record in enumerate(records):
+        _order, context, bindings = facts.get(id(record.node), (site, record.context, {}))
+        descriptor = {"site": site, "call": record.call, "context": context}
+        if record.form is not None:
+            descriptor["form"] = record.form
+        descriptor.update({name: parameter_class(name, parameter, bindings)
+                           for name, parameter in record.parameters.items()})
+        calls.append(descriptor)
+        ids.append({name: _literal(parameter.node, bindings) if parameter.node is not None else ""
+                    for name, parameter in record.parameters.items() if name in ("id", "from_entry")})
+    entries = [(site, ids[site].get("id"), call.get("direction"))
+               for site, call in enumerate(calls) if call["call"] in ("entry", "order")
+               and call["id"] in ("literal", "empty")]
+    long_ids = {name for _site, name, direction in entries if direction == "long"}
+    short_ids = {name for _site, name, direction in entries if direction == "short"}
+    for site, call in enumerate(calls):
+        if call["call"] not in ("exit", "close", "cancel"):
+            continue
+        target = ids[site].get("from_entry" if call["call"] == "exit" else "id")
+        global_target = target == "" and call["call"] in ("exit", "close")
+        matching = [(entry_site, direction) for entry_site, name, direction in entries
+                    if global_target or target is not None and target == name]
+        directions = {direction for _entry_site, direction in matching}
+        call["target"] = ("both" if "dynamic" in directions or directions >= {"long", "short"}
+                          else "long" if "long" in directions else "short" if "short" in directions
+                          else "dangling")
+        if call["call"] == "exit":
+            before = any(entry_site > site for entry_site, _direction in matching)
+            after = any(entry_site < site for entry_site, _direction in matching)
+            call["order"] = "mixed" if before and after or not matching else "before" if before else "after"
+    counts = Counter(name for _site, name, _direction in entries)
+    settings, pooc = settings_echo(emitter._order_shape_constructor)
+    unmodeled = {_expression(node.callee) for node, _depth in iter_ast_nodes(emitter.ctx.ast)
+                 if isinstance(node, FuncCall) and (_expression(node.callee) or "").startswith("strategy.")
+                 and _expression(node.callee) not in READ_ONLY_STRATEGY_CALLS
+                 and id(node) not in recorded_nodes}
+    return json.dumps({
+        "version": 1, "process_orders_on_close": pooc, "calls": calls,
+        "entry_ids": {"long": len(long_ids), "short": len(short_ids),
+                      "shared": len(long_ids & short_ids), "multi_site": sum(count > 1 for count in counts.values())},
+        "host_reads": sorted(emitter._order_shape_host_reads), "settings": settings,
+        "unmodeled": sorted(unmodeled),
+    }, sort_keys=True, separators=(",", ":"), allow_nan=False)

package/pineforge_codegen/codegen/run_stops.py

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