@pineforge/codegen-pyodide 1.2.0 → 1.4.0

package/pineforge_codegen/codegen/types.py

@@ -46,6 +46,7 @@ from ..collection_history import history_annotation
 from ..errors import Phase
 from ..external_requests import UNPINNED_ANNOTATION
 from ..limits import iter_ast_nodes
+from ..matrix_overloads import matrix_sum_has_rhs
 from ..symbols import PineType, TypeSpec, method_receiver_type_name
 from .helpers import (
     NA_PRESERVING_INT_TYPES,
@@ -59,6 +60,7 @@ from .tables import (
     ARRAY_ARGS_READ_REPEATEDLY,
     ARRAY_DRAWING_NEW_CTORS,
     ARRAY_METHODS,
+    MATRIX_METHODS,
     V5_ARRAY_INDEX_METHODS,
     BAR_BUILTINS,
     BAR_FIELDS,
@@ -68,6 +70,7 @@ from .tables import (
     MATRIX_RETURNING_METHODS,
     PINE_TYPE_TO_CPP,
     TA_RETURNS_BOOL,
+    _matrix_functional_receiver,
     checked_array_slice,
 )
 
@@ -1776,8 +1779,10 @@ class TypeInferer:
                     if func_name in ("copy", "slice"):
                         return arg_spec
                     return arg_spec.element
-            if namespace == "matrix" and func_name in MATRIX_RETURNING_METHODS:
-                receiver_node = node.args[0] if node.args else node.kwargs.get("id")
+            if namespace == "matrix" and (func_name in MATRIX_RETURNING_METHODS or (
+                    func_name == "sum" and matrix_sum_has_rhs(node, namespace=True))):
+                receiver_node = (node.args[0] if node.args else
+                                 node.kwargs.get("id1", node.kwargs.get("id")))
                 receiver_spec = self._type_spec_from_expr(receiver_node)
                 if receiver_spec is not None and receiver_spec.kind == "matrix":
                     return receiver_spec
@@ -1869,7 +1874,8 @@ class TypeInferer:
                     method = (member_name
                               if history_annotation(node.callee.object) is not None
                               else func_name)
-                    if method in MATRIX_RETURNING_METHODS:
+                    if method in MATRIX_RETURNING_METHODS or (
+                            method == "sum" and matrix_sum_has_rhs(node)):
                         return recv_spec
                     if method in ("row", "col"):
                         return TypeSpec.array(recv_spec.element)
@@ -1961,6 +1967,70 @@ class TypeInferer:
     # Method lowering for collection types (used by visit_call paths)
     # ------------------------------------------------------------------
 
+    def _matrix_method_expr(self, receiver, method, arguments, argument_nodes, node):
+        functional = (isinstance(node.callee, MemberAccess)
+                      and isinstance(node.callee.object, Identifier)
+                      and node.callee.object.name == "matrix")
+        receiver_node = (_matrix_functional_receiver(method, node)
+                         if functional else node.callee.object)
+        receiver = self._checked_matrix_history_receiver(receiver, receiver_node)
+        if method in ("add_row", "add_col") and len(arguments) == 2 and arguments[0] is None:
+            # Only ``array_id`` is written (``m.add_row(array_id = a)``): the
+            # call is the array-only form, which appends it.
+            arguments = [arguments[1]]
+            argument_nodes = [argument_nodes[1]]
+        if method in ("add_row", "add_col") and len(arguments) < 2:
+            argument_spec = (self._type_spec_from_expr(argument_nodes[0])
+                             if argument_nodes else None)
+            # An index-only call: the argument is a number whose spec the
+            # analysis knows, or one it cannot type that reads as a number
+            # (a call, an input, ``bar_index % 2``): the generated lambda then
+            # tells an index from an array by the argument's C++ type.
+            typed_index = not arguments or (
+                argument_spec is not None and argument_spec.kind == "primitive")
+            untyped_number = (argument_spec is None and bool(arguments)
+                              and self._infer_type(argument_nodes[0]) in ("double", "int", "int64_t"))
+            receiver_spec = self._type_spec_from_expr(receiver_node)
+            if ((typed_index or untyped_number) and receiver_spec is not None
+                    and receiver_spec.element is not None):
+                element_spec = receiver_spec.element
+                element_cpp = self._type_spec_to_cpp(element_spec)
+                count = "columns" if method == "add_row" else "rows"
+                append = "rows" if method == "add_row" else "columns"
+                values = (f"std::vector<{element_cpp}>((size_t)_pf_matrix_target.{count}(), "
+                          f"{self._array_init_value_expr(element_spec, NaLiteral())})")
+                if untyped_number:
+                    inserted = MATRIX_METHODS[method]("_pf_matrix_target", ["_pf_matrix_arg", values])
+                    appended = MATRIX_METHODS[method]("_pf_matrix_target", ["_pf_matrix_arg"])
+                    return (
+                        "[&](auto&& _pf_matrix_target, auto&& _pf_matrix_arg) { "
+                        "if constexpr (std::is_arithmetic_v<std::decay_t<decltype(_pf_matrix_arg)>>) { "
+                        f"{inserted}; }} else {{ {appended}; }} }}({receiver}, {arguments[0]})")
+                index = arguments[0] if arguments else f"_pf_matrix_target.{append}()"
+                mutation = MATRIX_METHODS[method]("_pf_matrix_target", [index, values])
+                return f"[&](auto&& _pf_matrix_target) {{ {mutation}; }}({receiver})"
+        if method in ("sum", "diff", "mult") and argument_nodes:
+            other_spec = self._type_spec_from_expr(argument_nodes[0])
+            if (method == "mult" and other_spec is not None
+                    and other_spec.kind == "array"):
+                name = method
+                self._codegen_error(
+                    node, f"matrix.{name}(...) is not implemented in PineForge runtime.")
+            numeric_scalar = ((other_spec is not None and other_spec.kind == "primitive"
+                               and other_spec.name in ("int", "float"))
+                              or (other_spec is None and self._infer_type(argument_nodes[0])
+                                  in ("double", "int", "int64_t")))
+            if method in ("diff", "mult") and len(arguments) == 1 and numeric_scalar:
+                operation = "-=" if method == "diff" else "*="
+                return (
+                    "([](const auto& _pf_matrix_left, const auto _pf_matrix_right) { "
+                    "auto _pf_matrix_result = _pf_matrix_left.copy(); "
+                    f"_pf_matrix_result.data().array() {operation} _pf_matrix_right; "
+                    "return _pf_matrix_result; "
+                    f"}}({receiver}, {arguments[0]}))"
+                )
+        return MATRIX_METHODS[method](receiver, arguments)
+
     def _array_receiver_once_expr(
         self, array_expr: str, args: list[str], lower_receiver,
     ) -> str:
@@ -2004,6 +2074,10 @@ class TypeInferer:
         spec: TypeSpec | None = None, node: ASTNode | None = None,
     ) -> str:
         """Lower ``arr.method(...)`` to its C++ form, validating numeric requirements."""
+        if self._array_history_value_names():
+            array_expr = f"_pf_array_id({array_expr})"
+            if method in ("covariance", "concat") and args:
+                args = [f"_pf_array_id({args[0]})", *args[1:]]
         spec = spec or TypeSpec.array(TypeSpec.primitive("float"))
         arr_cpp_type = self._type_spec_to_cpp(spec)
         elem_cpp = self._type_spec_to_cpp(spec.element) if spec.element is not None else "double"
@@ -2103,7 +2177,10 @@ class TypeInferer:
                     )
                 return lowered
 
-        return self._array_receiver_once_expr(array_expr, args, lower_receiver)
+        try:
+            return self._array_receiver_once_expr(array_expr, args, lower_receiver)
+        except IndexError:
+            self._codegen_error(node, f"array.{method}: wrong number of arguments")
 
     def _map_method_expr(
         self, map_expr: str, method: str, args: list[str], spec: TypeSpec | None = None,
@@ -2150,6 +2227,10 @@ class TypeInferer:
 
     def _type_for_decl(self, node: VarDecl) -> str:
         """Determine the C++ type for a ``VarDecl``: explicit hint, then symbol, then RHS inference."""
+        history_value_cpp = (self._array_history_value_cpp_type(node.name)
+                             if not getattr(self, "_active_func_name", None) else None)
+        if history_value_cpp is not None:
+            return history_value_cpp
         def promote_wide_int(cpp_type: str) -> str:
             if cpp_type != "int":
                 return cpp_type

package/pineforge_codegen/codegen/visit_call.py

@@ -169,6 +169,7 @@ from .helpers import (
 from .tables import (
     ARRAY_DRAWING_NEW_CTORS,
     ARRAY_METHODS,
+    ARRAY_OPTIONAL_PARAMS,
     BAR_FIELDS,
     BAR_SERIES_PUSH,
     CHECKED_ARRAY_METHOD_KWARGS,
@@ -179,7 +180,10 @@ from .tables import (
     MATH_FUNC_MAP,
     MATRIX_METHODS,
     MATRIX_METHOD_KWARGS,
+    MATRIX_METHOD_KWARG_ALIASES,
     MATRIX_NUMERIC_ONLY,
+    MATRIX_OPTIONAL_PARAMS,
+    MATRIX_RECEIVER_KEYWORD,
     SKIP_FUNC_NAMES,
     SKIP_NAMESPACES,
     SKIP_VAR_TYPES,
@@ -188,6 +192,7 @@ from .tables import (
     TIME_FIELD_EXPRS,
     _math_minmax_na_expr,
     _math_round_digits_expr,
+    _matrix_functional_receiver,
     _merge_kwargs,
 )
 
@@ -432,6 +437,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)}, "
@@ -689,10 +695,73 @@ class CallVisitor:
 
     def _array_method_arg_nodes(self, method: str, node: FuncCall) -> list:
         """Merge checked-array method kwargs into Pine signature order."""
-        param_names = CHECKED_ARRAY_METHOD_KWARGS.get(method)
-        if param_names is None:
+        return self._collection_arg_nodes("array", method, node, False)
+
+    def _collection_arg_nodes(self, namespace, method, node, functional):
+        """The arguments of a matrix or checked-array method call in Pine's
+        parameter order (the receiver first in the namespace form).
+
+        A keyword argument binds to its parameter's own slot, never shifted
+        left over a gap, and the gap before a later argument takes the
+        omitted optional parameter's default (a ``None`` default is the
+        receiver's own extent, which the method's template reads). A keyword
+        the lowering does not consume -- an unknown name, a parameter given
+        twice -- is refused, as is a gap before a required parameter. A call
+        without keywords, and an array method outside the checked-index
+        table, keep their arguments as written."""
+        if not node.kwargs:
             return list(node.args)
-        return _merge_kwargs(node.args, node.kwargs, param_names, lambda arg: arg)
+        if namespace == "matrix":
+            slots = list(MATRIX_METHOD_KWARGS.get(method, []))
+            optional = MATRIX_OPTIONAL_PARAMS.get(method, {})
+            aliases = MATRIX_METHOD_KWARG_ALIASES.get(method, {})
+            receiver = MATRIX_RECEIVER_KEYWORD.get(method, "id")
+        elif method in CHECKED_ARRAY_METHOD_KWARGS:
+            slots = list(CHECKED_ARRAY_METHOD_KWARGS[method])
+            optional = ARRAY_OPTIONAL_PARAMS.get(method, {})
+            aliases = {}
+            receiver = "id"
+        else:
+            return list(node.args)
+        if functional:
+            slots.insert(0, receiver)
+        arguments = list(node.args)
+        for name, value in node.kwargs.items():
+            slot = aliases.get(name, name)
+            if slot not in slots:
+                self._collection_argument_error(node, namespace, method, "unknown", name)
+            index = slots.index(slot)
+            if index < len(arguments) and arguments[index] is not None:
+                self._collection_argument_error(node, namespace, method, "twice", name)
+            arguments.extend([None] * (index + 1 - len(arguments)))
+            arguments[index] = value
+        for index, argument in enumerate(arguments):
+            if argument is not None:
+                continue
+            if slots[index] not in optional:
+                self._collection_argument_error(node, namespace, method, "missing", slots[index])
+            default = optional[slots[index]]
+            arguments[index] = None if default is None else NumberLiteral(value=default)
+        return arguments
+
+    def _collection_argument_error(self, node, namespace, method, problem, name):
+        """Refuse a collection call's keyword binding with the diagnostic its
+        namespace already reports for a call that does not bind."""
+        if namespace == "matrix":
+            self._codegen_error(
+                node, f"matrix.{method}: wrong number of arguments",
+                hint="Check Pine v6 matrix method signature (positional vs keyword).")
+        key = ".".join((namespace, method))
+        if problem == "unknown":
+            self._codegen_error(node, f"{key}: unknown keyword argument '{name}'")
+        if problem == "twice":
+            self._codegen_error(
+                node, f"{key}: argument '{name}' passed both positionally and by keyword")
+        self._codegen_error(node, f"{key}: missing required argument '{name}'")
+
+    def _matrix_method_arg_nodes(self, method, node, functional=False):
+        arguments = self._collection_arg_nodes("matrix", method, node, functional)
+        return arguments[1:] if functional else arguments
 
     def _matrix_bool_value_args(
         self, method: str, args: list[str], arg_nodes: list,
@@ -739,12 +808,7 @@ class CallVisitor:
                 "array.copy: expected exactly one receiver 'id'",
                 hint="Use array.copy(source) or array.copy(id=source).",
             )
-        param_names = CHECKED_ARRAY_METHOD_KWARGS.get(method)
-        if param_names is None:
-            return list(node.args)
-        return _merge_kwargs(
-            node.args, node.kwargs, ["id", *param_names], lambda arg: arg
-        )
+        return self._collection_arg_nodes("array", method, node, True)
 
     def _map_identifier_is_visible_binding(self, node: FuncCall) -> bool:
         """Whether ``map`` is a lexical value at this exact source position.
@@ -1662,6 +1726,18 @@ class CallVisitor:
                 return self._matrix_history_method_expr(
                     callee.object, callee.member, recv_spec, node)
 
+        if (isinstance(callee, MemberAccess)
+                and isinstance(callee.object, (FuncCall, Ternary))
+                and callee.member in MATRIX_METHODS):
+            receiver_spec = self._type_spec_from_expr(callee.object)
+            if receiver_spec is not None and receiver_spec.kind == "matrix":
+                self._check_matrix_method_allowed(callee.member, receiver_spec, node)
+                raw_args = self._matrix_method_arg_nodes(callee.member, node)
+                arguments = self._matrix_bool_value_args(
+                    callee.member, [self._visit_expr(arg) if arg is not None else None for arg in raw_args], raw_args, receiver_spec)
+                return self._matrix_method_expr(
+                    self._visit_expr(callee.object), callee.member, arguments, raw_args, node)
+
         # chart.point.now/new/from_index/from_time/copy — REAL data (a ChartPoint
         # aggregate). Routed here BEFORE the obj.field.method receiver logic,
         # which would otherwise mis-treat ``chart.point`` as a receiver object
@@ -1820,20 +1896,16 @@ class CallVisitor:
                     ):
                         arr = self._collection_receiver_expr(oname)
                         self._check_matrix_method_allowed(meth_raw, recv_spec, node)
-                        param_names = MATRIX_METHOD_KWARGS.get(meth_raw)
-                        raw_args = (
-                            _merge_kwargs(node.args, node.kwargs, param_names, lambda a: a)
-                            if param_names and node.kwargs else list(node.args)
-                        )
+                        raw_args = self._matrix_method_arg_nodes(meth_raw, node)
                         margs = self._matrix_bool_value_args(
                             meth_raw,
-                            [self._visit_expr(a) for a in raw_args],
+                            [self._visit_expr(a) if a is not None else None for a in raw_args],
                             raw_args,
                             recv_spec,
                         )
                         fn = MATRIX_METHODS[meth_raw]
                         try:
-                            return fn(arr, margs)
+                            return self._matrix_method_expr(arr, meth_raw, margs, raw_args, node)
                         except IndexError:
                             self._codegen_error(
                                 node,
@@ -2053,20 +2125,16 @@ class CallVisitor:
         ):
             arr = self._collection_receiver_expr(namespace)
             self._check_matrix_method_allowed(func_name, namespace_spec, node)
-            param_names = MATRIX_METHOD_KWARGS.get(func_name)
-            raw_args = (
-                _merge_kwargs(node.args, node.kwargs, param_names, lambda a: a)
-                if param_names and node.kwargs else list(node.args)
-            )
+            raw_args = self._matrix_method_arg_nodes(func_name, node)
             args = self._matrix_bool_value_args(
                 func_name,
-                [self._visit_expr(a) for a in raw_args],
+                [self._visit_expr(a) if a is not None else None for a in raw_args],
                 raw_args,
                 namespace_spec,
             )
             fn = MATRIX_METHODS[func_name]
             try:
-                return fn(arr, args)
+                return self._matrix_method_expr(arr, func_name, args, raw_args, node)
             except IndexError:
                 self._codegen_error(
                     node,
@@ -2107,7 +2175,22 @@ class CallVisitor:
                         init_val = self._array_init_value_expr(elem_spec, node.args[1])
                     else:
                         init_val = init_default
-                    return f"{cpp_type}((size_t)({size_arg}), {init_val})"
+                    return (
+                        "[&](auto _pf_array_new_size, auto _pf_array_new_value){ "
+                        "using _pf_array_new_size_type=decltype(_pf_array_new_size); "
+                        "if constexpr(!std::is_same_v<_pf_array_new_size_type,bool>) { "
+                        "if(is_na(_pf_array_new_size)) "
+                        '_PF_ARRAY_STOP("size_invalid", "new", "cannot create std::vector larger than max_size()"); '
+                        "} if(!std::isfinite((double)_pf_array_new_size)||"
+                        "_pf_array_new_size<0||"
+                        "(long double)_pf_array_new_size>(long double)std::numeric_limits<size_t>::max()) "
+                        '_PF_ARRAY_STOP("size_invalid", "new", "cannot create std::vector larger than max_size()"); '
+                        f"try {{ return {cpp_type}((size_t)(_pf_array_new_size), _pf_array_new_value); "
+                        "} catch (const std::length_error& _pf_array_new_error) { "
+                        '_PF_ARRAY_STOP("size_invalid", "new", _pf_array_new_error.what()); '
+                        f"return {cpp_type}(); }} "
+                        f"}}(({size_arg}), ({init_val}))"
+                    )
                 return f"{cpp_type}()"
             if func_name == "from":
                 spec = self._type_spec_from_expr(node) or TypeSpec.array(TypeSpec.primitive("float"))
@@ -2281,8 +2364,8 @@ class CallVisitor:
         # runtime.error() and other runtime.* calls
         if namespace == "runtime":
             if func_name == "error":
-                rt_args = [self._visit_expr(a) for a in node.args]
-                msg_arg = rt_args[0] if rt_args else '""'
+                message = node.args[0] if node.args else node.kwargs.get("message")
+                msg_arg = self._visit_expr(message) if message is not None else '""'
                 return f'pine_runtime_error({msg_arg})'
             return '"" /* unsupported runtime */'
 
@@ -2614,10 +2697,31 @@ class CallVisitor:
             return f"na<double>() /* unsupported: ta.{func_name} */"
 
         if namespace == "syminfo":
-            if func_name == "prefix":
-                return "_pf_derive_prefix(syminfo_.tickerid)"
-            if func_name == "ticker":
-                return "syminfo_.ticker"
+            if func_name in {"prefix", "ticker"}:
+                symbol = node.args[0] if node.args else node.kwargs.get("symbol")
+                symbol_expr = self._visit_expr(symbol) if symbol is not None else "syminfo_.tickerid"
+                if symbol_expr == "syminfo_.tickerid":
+                    return ("_pf_derive_prefix(syminfo_.tickerid)" if func_name == "prefix"
+                            else "syminfo_.ticker")
+                if func_name == "prefix":
+                    result_expr = (
+                        "_pf_colon == std::string::npos "
+                        "|| _pf_colon + 1 == _pf_symbol.size() "
+                        "? std::string() : _pf_symbol.substr(0, _pf_colon)"
+                    )
+                else:
+                    result_expr = (
+                        "_pf_colon == std::string::npos "
+                        "? _pf_symbol : _pf_symbol.substr(_pf_colon + 1)"
+                    )
+                return (
+                    "([](const auto& _pf_symbol) { "
+                    "if constexpr (std::is_same_v<std::decay_t<decltype(_pf_symbol)>, std::string>) { "
+                    "const auto _pf_colon = _pf_symbol.find(':'); "
+                    f"return {result_expr}; "
+                    "} else { return std::string(); } "
+                    f"}})({symbol_expr})"
+                )
             return f"na<double>() /* unsupported: syminfo.{func_name} */"
 
         # str.* fallback now handled by _visit_str_call above
@@ -2642,41 +2746,48 @@ class CallVisitor:
                     if len(args_e) > 2 else self._default_for_spec(elem_spec)
                 )
                 return f"PineGenericMatrix<{cpp_t}>::new_({rows}, {cols}, {init})"
-            if func_name in MATRIX_METHODS and node.args:
+            matrix_receiver = _matrix_functional_receiver(func_name, node)
+            if func_name in MATRIX_METHODS and matrix_receiver is None:
+                self._codegen_error(
+                    node, f"matrix.{func_name}: wrong number of arguments",
+                    hint="Check Pine v6 matrix method signature (positional vs keyword).")
+            if func_name in MATRIX_METHODS and matrix_receiver is not None:
                 from ..ast_nodes import Identifier as _Ident
                 if func_name in MATRIX_NUMERIC_ONLY:
-                    recv_node = node.args[0]
+                    recv_node = matrix_receiver
                     if history_annotation(recv_node) is not None:
                         # A matrix's history is a matrix of its type.
                         recv_node = recv_node.object
-                    if not isinstance(recv_node, _Ident):
-                        self._codegen_error(node, f"matrix.{func_name} receiver must be a variable reference")
-                    recv_name = recv_node.name
-                    recv_spec = self._collection_spec_for_name(recv_name)
-                    if recv_spec is None or recv_spec.kind != "matrix":
-                        self._codegen_error(node, f"matrix.{func_name}: receiver '{recv_name}' is not a known matrix variable")
+                    if func_name == "sum":
+                        recv_spec = self._type_spec_from_expr(recv_node)
+                        if recv_spec is None or recv_spec.kind != "matrix":
+                            name = func_name
+                            self._codegen_error(node, f"matrix.{name}(...) is not implemented in PineForge runtime.")
+                    else:
+                        if not isinstance(recv_node, _Ident):
+                            self._codegen_error(node, f"matrix.{func_name} receiver must be a variable reference")
+                        recv_name = recv_node.name
+                        recv_spec = self._collection_spec_for_name(recv_name)
+                        if recv_spec is None or recv_spec.kind != "matrix":
+                            self._codegen_error(node, f"matrix.{func_name}: receiver '{recv_name}' is not a known matrix variable")
                     self._check_matrix_method_allowed(func_name, recv_spec, node)
                 if func_name == "sort":
-                    if isinstance(node.args[0], _Ident):
-                        recv_name = node.args[0].name
+                    if isinstance(matrix_receiver, _Ident):
+                        recv_name = matrix_receiver.name
                         recv_spec = self._collection_spec_for_name(recv_name)
                         if recv_spec is not None and recv_spec.kind == "matrix":
                             self._check_matrix_method_allowed(func_name, recv_spec, node)
-                obj = self._visit_expr(node.args[0])
-                param_names = MATRIX_METHOD_KWARGS.get(func_name)
-                raw_rest = (
-                    _merge_kwargs(node.args[1:], node.kwargs, param_names, lambda a: a)
-                    if param_names else list(node.args[1:])
-                )
+                obj = self._visit_expr(matrix_receiver)
+                raw_rest = self._matrix_method_arg_nodes(func_name, node, True)
                 rest = self._matrix_bool_value_args(
                     func_name,
-                    [self._visit_expr(a) for a in raw_rest],
+                    [self._visit_expr(a) if a is not None else None for a in raw_rest],
                     raw_rest,
-                    self._type_spec_from_expr(node.args[0]),
+                    self._type_spec_from_expr(matrix_receiver),
                 )
                 fn = MATRIX_METHODS[func_name]
                 try:
-                    return fn(obj, rest)
+                    return self._matrix_method_expr(obj, func_name, rest, raw_rest, node)
                 except IndexError:
                     self._codegen_error(
                         node,
@@ -3166,6 +3277,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 +3312,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 +3329,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 +3354,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 +3372,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 +3421,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 +3470,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":
@@ -3570,13 +3741,22 @@ class CallVisitor:
             return 'std::string("")'
 
         if func_name == "substring":
-            if len(args) == 3:
-                # begin_pos is read twice: evaluate it once.
+            if len(args) in (2, 3):
+                end_parameter = ", auto _pf_substring_end" if len(args) == 3 else ""
+                count = ", _pf_substring_end - _pf_substring_begin" if len(args) == 3 else ""
+
+                def checked_substring(bound):
+                    return (
+                        f"[&](const std::string& _pf_substring_text, auto _pf_substring_begin{end_parameter}){{ "
+                        "try { return _pf_substring_text.substr(_pf_substring_begin"
+                        f"{count}); }} catch (const std::out_of_range& _pf_substring_error) {{ "
+                        '_PF_STRING_STOP("substring_out_of_range", _pf_substring_error.what()); '
+                        "return std::string(); } "
+                        "}(" + ", ".join(f"({arg})" for arg in bound) + ")"
+                    )
+
                 return evaluate_args_once(
-                    args, (1,), lambda a: f"{a[0]}.substr({a[1]}, {a[2]} - {a[1]})",
-                    "_pf_str_a")
-            elif len(args) == 2:
-                return f"{args[0]}.substr({args[1]})"
+                    args, range(len(args)), checked_substring, "_pf_substring_arg")
             return 'std::string("")'
 
         if func_name == "format":