@pineforge/codegen-pyodide 1.1.0 → 1.3.0

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/security.py

@@ -194,13 +194,19 @@ class SecurityEmitter:
         chart timeframe — its evaluator result is never read. Any other
         timeframe registration cannot compute is refused: it used to register
         the chart timeframe, silently.
+
+        Every timeframe string resolved from the script -- the literal, a
+        constant, a helper parameter's argument, a ternary or switch arm --
+        is a Pine timeframe (``_refuse_invalid_security_tf``).
         """
         if isinstance(tf_node, StringLiteral):
+            self._refuse_invalid_security_tf(tf_node.value, tf_node)
             return tf_node.value, None
         if isinstance(tf_node, SwitchStmt):
             # Keep diagnostics from the registration-time switch renderer
             # visible; the broad expression fallback below intentionally
             # catches ordinary unresolved expressions.
+            self._check_security_tf_arms(tf_node, set())
             return None, self._security_tf_runtime_expr(tf_node)
         if isinstance(tf_node, Identifier):
             name = tf_node.name
@@ -209,6 +215,7 @@ class SecurityEmitter:
             if (name in self._known_vars and name not in self._input_backed_vars
                     and not self._known_var_is_lexically_shadowed(name)
                     and isinstance(self._known_vars[name], str)):
+                self._refuse_invalid_security_tf(self._known_vars[name], tf_node)
                 return self._known_vars[name], None
             if (name in self._input_backed_vars
                     and name in self._input_var_to_call
@@ -216,6 +223,7 @@ class SecurityEmitter:
                 return None, self._visit_expr(self._input_var_to_call[name])
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
             if name in global_expr_map:
+                self._check_security_tf_arms(global_expr_map[name], {name})
                 expanded = self._security_tf_runtime_expr(
                     global_expr_map[name], resolving={name}
                 )
@@ -238,6 +246,7 @@ class SecurityEmitter:
             self._security_tf_unresolved(tf_node, f"timeframe '{name}'")
         # any other expression — visit if it resolves at class scope
         try:
+            self._check_security_tf_arms(tf_node, set())
             expanded = self._security_tf_runtime_expr(tf_node)
             return None, expanded if expanded is not None else self._visit_expr(tf_node)
         except CompileError:
@@ -245,6 +254,45 @@ class SecurityEmitter:
         except Exception:
             self._security_tf_unresolved(tf_node, "timeframe expression")
 
+    def _refuse_invalid_security_tf(self, value: str, node) -> None:
+        """Refuse a timeframe string resolved from the script that is not a
+        Pine timeframe, with the support checker's diagnostic for the same
+        string written in the call (``invalid_tf_literal``): it reaches the
+        C++ registration. An empty string registers the chart's timeframe."""
+        if not value:
+            return
+        from ..support_checker import invalid_tf_literal
+        fn_label = ("request.security_lower_tf" if getattr(self, "_security_tf_lower", False)
+                    else "request.security")
+        refusal = invalid_tf_literal(value, fn_label)
+        if refusal is not None:
+            message, hint = refusal
+            self._codegen_error(node, message, hint=hint)
+
+    def _check_security_tf_arms(self, node, resolving: set[str]) -> None:
+        """Refuse an invalid timeframe string a registration-time timeframe
+        expression can select: the expression itself, a ternary or switch
+        arm, read through the constants and globals it names."""
+        def check(value) -> None:
+            if isinstance(value, StringLiteral):
+                self._refuse_invalid_security_tf(value.value, value)
+            elif isinstance(value, Ternary):
+                check(value.true_val)
+                check(value.false_val)
+            elif isinstance(value, SwitchStmt):
+                arms = [body for _case, body in value.cases]
+                for body in arms + ([value.default_body] if value.default_body else []):
+                    if len(body) == 1 and isinstance(body[0], ExprStmt):
+                        check(self._substitute_tf_input_reads(body[0].expr, resolving))
+
+        check(node if isinstance(node, SwitchStmt)
+              else self._substitute_tf_input_reads(node, resolving))
+
+    def _security_tf_literal(self, tf: str) -> str:
+        """A timeframe string as the C++ string literal registration and the
+        evaluator's ``timeframe.*`` reads spell it."""
+        return f'"{self._cpp_string_escape(tf)}"'
+
     def _security_tf_unresolved(self, tf_node, what: str) -> None:
         """Refuse a request.security timeframe registration cannot compute."""
         self._codegen_error(
@@ -1981,8 +2029,9 @@ class SecurityEmitter:
         parts = request.annotations[RECORDED_KEY_ANNOTATION]
         tail = (f"|{parts['field']}|{parts['period']}|gaps_{parts['gaps']}"
                 f"|lookahead_{parts['lookahead']}")
-        return (f'(std::string("{parts["fn"]}|") + {self._visit_expr(request.args[0])} + '
-                f'std::string("{tail}"))')
+        fn = self._cpp_string_escape(parts["fn"])
+        return (f'(std::string("{fn}|") + {self._visit_expr(request.args[0])} + '
+                f'std::string("{self._cpp_string_escape(tail)}"))')
 
     def _recorded_sites(self) -> dict[int, int]:
         """Each recorded request's index N: ``_pf_recorded`` sets its
@@ -2709,7 +2758,7 @@ class SecurityEmitter:
         """C++ expression for the timeframe of a request.security evaluator."""
         info = self._security_eval_info[sec_id]
         if info.get("tf"):
-            return f'"{info["tf"]}"'
+            return self._security_tf_literal(info["tf"])
         if info.get("tf_expr"):
             return info["tf_expr"]
         return "input_tf_"
@@ -2775,7 +2824,7 @@ class SecurityEmitter:
             if series_name in self._security_string_series
             else "_security_helper_series_"
         )
-        return f'{store}["{series_name}"]'
+        return f'{store}["{self._cpp_string_escape(series_name)}"]'
 
     def _security_helper_var_state_type(self, stmt: VarDecl) -> str:
         """The type family of a helper ``var`` whose declaration reads
@@ -6377,7 +6426,7 @@ class SecurityEmitter:
         if column is not None and self._security_foreign(sec_id):
             # request.footprint(...) of another symbol: the delta its feed
             # records for the requested bar (the value its delta() reads).
-            return f'_pf_symbol_column({sec_id}, "{column}")'
+            return f'_pf_symbol_column({sec_id}, "{self._cpp_string_escape(column)}")'
 
         if resolving is None:
             resolving = set()

package/pineforge_codegen/codegen/tables.py

@@ -545,6 +545,18 @@ ORDER_DIRECTION_MAP = {
     "descending": 'std::string("descending")',
 }
 
+NAME_ECHO_STRING_MEMBERS = {
+    "currency": frozenset({
+        "AED", "ARS", "AUD", "BDT", "BHD", "BRL", "BTC", "CAD", "CHF", "CLP",
+        "CNY", "COP", "CZK", "DKK", "EGP", "ETH", "EUR", "GBP", "HKD", "HUF",
+        "IDR", "ILS", "INR", "ISK", "JPY", "KES", "KRW", "KWD", "LKR", "MAD",
+        "MXN", "MYR", "NGN", "NOK", "NONE", "NZD", "PEN", "PHP", "PKR", "PLN",
+        "QAR", "RON", "RSD", "RUB", "SAR", "SEK", "SGD", "THB", "TND", "TRY",
+        "TWD", "USD", "USDT", "VES", "VND", "ZAR",
+    }),
+    "format": frozenset({"inherit", "price", "volume", "percent", "mintick"}),
+}
+
 
 # ---------------------------------------------------------------------------
 # Array / Map / Matrix method dispatch

package/pineforge_codegen/codegen/visit_call.py

@@ -432,6 +432,7 @@ class CallVisitor:
 
         close = "true" if func_name == "time_close" else "false"
         empty = 'std::string("")'
+        self._order_shape_host_reads.add("pine_time_offset")
         return (
             f"pine_time_offset(current_bar_.timestamp, {offset('bars_back')}, "
             f"{text('timeframe', 'script_tf_')}, {text('session', empty)}, "
@@ -3166,6 +3167,7 @@ class CallVisitor:
         return f"{token}ULL"
 
     def _visit_strategy_call(self, func_name: str, node: FuncCall) -> str:
+        from .order_shapes import record_order_call
         if func_name in ("convert_to_account", "convert_to_symbol"):
             p = self._resolve_func_args(node, f"strategy.{func_name}")
             v = self._visit_expr(p.get("value")) if p.get("value") is not None else "0.0"
@@ -3200,6 +3202,16 @@ class CallVisitor:
             if stop is not None or limit is not None or qty is not None or oca_name is not None or oca_type is not None or qty_type is not None:
                 limit_val = self._visit_expr(limit) if limit else "na<double>()"
                 stop_val = self._visit_expr(stop) if stop else "na<double>()"
+                record_order_call(self, node, "entry", {
+                    "id": (entry_id, p.get("id")), "direction": (direction, direction_node),
+                    "limit": (limit_val, limit, "na<double>()"),
+                    "stop": (stop_val, stop, "na<double>()"),
+                    "qty": (qty_val, qty, "na<double>()"),
+                    "comment": (comment_val, comment, '""'),
+                    "oca_name": (oca_name_val, oca_name, '""'),
+                    "oca_type": (oca_type_val, oca_type, "0"),
+                    "qty_type": (qty_type_val, qty_type, "-1"),
+                })
                 # pineforge-engine v0.2 dropped the vestigial `market_price`
                 # third positional from `BacktestEngine::strategy_entry`
                 # (the runtime never read it; fill price always came from
@@ -3207,6 +3219,15 @@ class CallVisitor:
                 # matches the new signature: (id, direction, limit, stop,
                 # qty, comment, oca_name, oca_type, qty_type).
                 return f"strategy_entry({entry_id}, {direction}, {limit_val}, {stop_val}, {qty_val}, {comment_val}, {oca_name_val}, {oca_type_val}, {qty_type_val})"
+            record_order_call(self, node, "entry", {
+                "id": (entry_id, p.get("id")), "direction": (direction, direction_node),
+                "limit": ("na<double>()", None, "na<double>()"),
+                "stop": ("na<double>()", None, "na<double>()"),
+                "qty": ("na<double>()", None, "na<double>()"),
+                "comment": (comment_val, comment, '""'),
+                "oca_name": ('""', None, '""'), "oca_type": ("0", None, "0"),
+                "qty_type": ("-1", None, "-1"),
+            })
             return f"strategy_entry({entry_id}, {direction}, na<double>(), na<double>(), na<double>(), {comment_val})"
 
         if func_name == "close":
@@ -3223,6 +3244,12 @@ class CallVisitor:
                 if immediately_node is not None else "false"
             )
             callsite = self._strategy_close_callsite_token(node)
+            record_order_call(self, node, "close", {
+                "id": (close_id, p.get("id")), "comment": (comment, p.get("comment"), '""'),
+                "qty": (qty, p.get("qty"), "na<double>()"),
+                "qty_percent": (qty_pct, p.get("qty_percent"), "na<double>()"),
+                "immediately": (immediately, immediately_node, "false"),
+            })
             return f"strategy_close({close_id}, {comment}, {qty}, {qty_pct}, {immediately}, {callsite})"
 
         if func_name == "close_all":
@@ -3235,6 +3262,12 @@ class CallVisitor:
                 )
                 if immediately_node is not None else "false"
             )
+            record_order_call(self, node, "close_all", {
+                "comment": (comment, p.get("comment"), '""'),
+                "qty": ("na<double>()", None, "na<double>()"),
+                "qty_percent": ("na<double>()", None, "na<double>()"),
+                "immediately": (immediately, immediately_node, "false"),
+            })
             # The engine's ID-less strategy_close path closes the complete
             # position. Reuse it so close_all preserves the Pine order comment
             # and same-tick fill flag instead of silently discarding both.
@@ -3278,18 +3311,38 @@ class CallVisitor:
                 if loss_n and not stop_n:
                     loss_ticks = self._visit_expr(loss_n)
 
+                record_order_call(self, node, "exit", {
+                    "id": (exit_id, p.get("id")), "from_entry": (from_id, p.get("from_entry")),
+                    "limit": (limit_val, limit_n, "na<double>()"),
+                    "stop": (stop_val, stop_n, "na<double>()"),
+                    "trail_points": (trail_pts, trail_pts_n, "na<double>()"),
+                    "trail_offset": (trail_off, trail_off_n, "na<double>()"),
+                    "trail_price": (trail_pr, trail_pr_n, "na<double>()"),
+                    "qty_percent": (qty_pct, qty_pct_n, "100.0"),
+                    "comment": (comment, comment_n, '""'),
+                    "qty": (qty_val, qty_n, "na<double>()"),
+                    "oca_name": (oca_val, oca_name_n, '""'),
+                    "profit_ticks": (profit_ticks, profit_n if not limit_n else None, "na<double>()"),
+                    "loss_ticks": (loss_ticks, loss_n if not stop_n else None, "na<double>()"),
+                }, form="levels")
                 return (f"strategy_exit({exit_id}, {from_id}, {limit_val}, {stop_val}, "
                         f"{trail_pts}, {trail_off}, {trail_pr}, {qty_pct}, {comment}, "
                         f"{qty_val}, {oca_val}, {profit_ticks}, {loss_ticks})")
             comment = self._visit_expr(comment_n) if comment_n is not None else '""'
+            record_order_call(self, node, "exit", {
+                "id": (exit_id, p.get("id")), "from_entry": (from_id, p.get("from_entry")),
+                "comment": (comment, comment_n, '""'),
+            }, form="cancel_bracket")
             return f"strategy_exit_cancel_bracket({exit_id}, {from_id}, {comment})"
 
         if func_name == "cancel":
             p = self._resolve_func_args(node, "strategy.close")  # same shape: id first
             cancel_id = self._visit_expr(p.get("id")) if "id" in p else '""'
+            record_order_call(self, node, "cancel", {"id": (cancel_id, p.get("id"))})
             return f"strategy_cancel({cancel_id})"
 
         if func_name == "cancel_all":
+            record_order_call(self, node, "cancel_all", {})
             return "strategy_cancel_all()"
 
         if func_name == "order":
@@ -3307,6 +3360,14 @@ class CallVisitor:
             stop_arg = self._visit_expr(p.get("stop")) if "stop" in p else "na<double>()"
             oca_name = self._visit_expr(p.get("oca_name")) if "oca_name" in p else '""'
             oca_type = self._visit_expr(p.get("oca_type")) if "oca_type" in p else "0"
+            record_order_call(self, node, "order", {
+                "id": (order_id, p.get("id")), "direction": (direction, direction_node),
+                "qty": (qty, p.get("qty"), "0"),
+                "limit": (limit_arg, p.get("limit"), "na<double>()"),
+                "stop": (stop_arg, p.get("stop"), "na<double>()"),
+                "oca_name": (oca_name, p.get("oca_name"), '""'),
+                "oca_type": (oca_type, p.get("oca_type"), "0"),
+            })
             return f"strategy_order({order_id}, {direction}, {qty}, {limit_arg}, {stop_arg}, {oca_name}, {oca_type})"
 
         if func_name == "risk":