@pineforge/codegen-pyodide 1.2.0 → 1.4.0

package/LICENSE

@@ -1,6 +1,14 @@
-PineForge Source License 1.1
+PineForge Source License 1.2
 ============================
 
+Version 1.2, 2026-10-05. Compared with 1.1, two places change. In the
+Personal Trading section, the last bullet now says that an account a
+proprietary-trading firm or funded-trader program provides or allocates,
+including a challenge, evaluation or simulated account, is not the
+person's own account or capital. In the Commercial Use section, the
+definition of investment capital now covers the capital in such an
+account, real or simulated.
+
 Copyright 2025-2026 pineforge, LLC
 
 Required Notice: Copyright 2025-2026 pineforge, LLC (https://github.com/pineforge-4pass/pineforge-codegen-oss)
@@ -134,7 +142,12 @@ For Personal Trading:
     program or anyone else outside the person's household provides or
     allocates to the person to trade, and that the provider still owns or
     whose losses the provider bears, is not the person's own capital, even
-    if the person shares in the profits.
+    if the person shares in the profits. An account that a
+    proprietary-trading firm or a funded-trader program provides or
+    allocates to the person to trade, including a challenge, evaluation or
+    simulated account, whether the capital in it is real or simulated, is
+    likewise not the person's own account and is not funded by the
+    person's own capital.
 
 
 ## Commercial Use
@@ -149,7 +162,10 @@ in each case whoever the capital belongs to and whether or not for a fee.
 trading, including capital belonging to any other person or entity, such as a
 friend or relative, clients or investors, an endowment, a pension or
 retirement fund, a sovereign or other public fund, or the treasury or reserves
-of a foundation or other organization.
+of a foundation or other organization. The capital in an account that a
+proprietary-trading firm or a funded-trader program provides or allocates
+to a person or entity to trade, including a challenge, evaluation or
+simulated account, is investment capital whether it is real or simulated.
 
 **Commercial Use** means any use of the software that is not a permitted
 purpose, other than distributing copies under the Distribution License

package/README.md

@@ -19,7 +19,8 @@ Stable releases are on the `latest` dist-tag. A prerelease (for example
 - `pineforge_codegen/diagnostics_catalog.json` — the diagnostics catalog (since 1.2.0), also
   importable as `@pineforge/codegen-pyodide/diagnostics_catalog.json`; the repository's
   `docs/PUBLIC_CONTRACT.md` describes it.
-- `LICENSE` — the PineForge Source License 1.1 (since 1.2.0), which `package.json` names.
+- `LICENSE` — the PineForge Source License (since 1.2.0), which `package.json` names:
+  version 1.1 in release 1.2.0, version 1.2 from release 1.3.0 on.
 
 ## Publishing (maintainers)
 A `v*` tag push, which the release workflow makes, publishes through npm OIDC Trusted

package/package.json

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

package/pineforge_codegen/__init__.py

@@ -164,11 +164,12 @@ def transpile_full(pine_source: str, *, check_support: bool = True,
     - ``cpp``: the generated C++ source (identical to :func:`transpile`).
     - ``inputs``: a list of ``InputDef`` dicts (one per global-scope
       ``input(...)`` / ``input.*(...)`` call, inline calls included, in
-      source order). Each has ``title`` / ``type`` /
-      ``default`` and optionally ``min`` / ``max`` / ``step`` / ``options``
-      (omitted when the corresponding signature argument is absent or
-      references a non-const value); an ``input.symbol`` entry also has
-      ``kind: "symbol"``. See :meth:`CodeGen.extract_input_manifest`.
+      source order). Each has ``title`` / ``type`` / ``default`` /
+      ``supported`` (the checked-settings receipt's flag) and optionally
+      ``min`` / ``max`` / ``step`` / ``options`` (omitted when the
+      corresponding signature argument is absent or is not a literal the
+      receipt holds); an ``input.symbol`` entry also has ``kind: "symbol"``.
+      See :meth:`CodeGen.extract_input_manifest`.
     - ``strategyParams``: the literal ``strategy(...)`` kwargs the analyzer
       surfaced (e.g. ``initial_capital``, ``pyramiding``).
     - ``diagnostics``: the warnings (:class:`~pineforge_codegen.errors.Diagnostic`,

package/pineforge_codegen/analyzer/base.py

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

package/pineforge_codegen/analyzer/types.py

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

package/pineforge_codegen/codegen/base.py

@@ -31,6 +31,7 @@ from ..symbols import PineType, TypeSpec, method_receiver_type_name
 from .. import signatures as sigs
 from ..errors import CompileError, Diagnostic, Level, Phase, SourceLocation
 from ..limits import TimeBudget, iter_ast_nodes
+from ..matrix_overloads import matrix_sum_has_rhs
 from ..session_reads import emitted_session_reads
 from ..block_locals import block_declarations, decl_key
 from ..pine_spelling import (
@@ -240,6 +241,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     def __init__(self, ctx: AnalyzerContext,
                  budget: TimeBudget | None = None) -> None:
         self.ctx = ctx
+        self._order_shape_calls = {}
+        self._order_shape_host_reads: set[str] = set()
+        self._order_shape_constructor: list[str] = []
         self._budget = budget
         self._budget_visit_count = 0
         self._initialise_safe_names(ctx.ast)
@@ -1079,7 +1083,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 # (index, signature) of each TA variant computed inline, and
                 # (index, _SECURITY_THROUGH_GLOBAL) of a global's site a
                 # multi-statement helper reads, which the prologue computes.
-                "inline_helper_ta_indices": sorted(inline_helper_ta_indices, key=repr),
+                "inline_helper_ta_indices": inline_helper_ta_indices,
                 "depends_on_mutable_globals": item.get("depends_on_mutable_globals", False),
                 "mutable_globals": list(item.get("mutable_globals", [])),
                 "is_lower_tf_array": bool(item.get("is_lower_tf_array", False)),
@@ -2153,6 +2157,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 # to the analyzer's default ``double`` and the emitted C++
                 # fails to compile (``double = PineMatrix``).
                 or fn in MATRIX_RETURNING_METHODS
+                or (fn == "sum" and matrix_sum_has_rhs(expr, namespace=True))
             ):
                 if fn == "new":
                     targs = self._template_args_from_call(expr) if hasattr(expr, "annotations") else []
@@ -2210,7 +2215,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 outer_callee = expr.callee
                 if (
                     isinstance(outer_callee, MemberAccess)
-                    and outer_callee.member in MATRIX_RETURNING_METHODS
+                    and (outer_callee.member in MATRIX_RETURNING_METHODS or (
+                        outer_callee.member == "sum" and matrix_sum_has_rhs(expr)))
                 ):
                     recv_name2 = self._extract_receiver_name(expr)
                     if recv_name2 is not None and recv_name2 in self._matrix_specs:
@@ -4490,7 +4496,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._prepare_lazy_source_clock_sites()
         self.block_locals_needing_names = self._block_locals_needing_names()
 
-        lines: list[str] = []
+        from .order_shapes import HostReadLines
+        lines: list[str] = HostReadLines(self._order_shape_host_reads)
 
         # Series<T> ctor-arg suffix from any max_bars_back directive (empty when
         # absent, so directive-free output is byte-identical to before).
@@ -4549,7 +4556,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "",
                 "    Snapshot snapshot() {",
                 "        if (_pf_generation_ == std::numeric_limits<uint64_t>::max()) {",
-                '            throw std::overflow_error("UDT checkpoint generation exhausted");',
+                '            _PF_ENGINE_INVARIANT("UDT checkpoint generation exhausted", std::overflow_error);',
                 "        }",
                 "        ++_pf_generation_;",
                 "        _pf_undo_.clear();",
@@ -4561,13 +4568,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    bool empty() const { return _pf_undo_.empty(); }",
                 "    void record(uint64_t generation, std::function<void()> undo) {",
                 "        if (!_pf_active_ || generation != _pf_generation_) {",
-                '            throw std::runtime_error("invalid UDT undo generation");',
+                '            _PF_ENGINE_INVARIANT("invalid UDT undo generation", std::runtime_error);',
                 "        }",
                 "        _pf_undo_.push_back(std::move(undo));",
                 "    }",
                 "    void restore(const Snapshot& snapshot) {",
                 "        if (!_pf_active_ || snapshot.generation != _pf_generation_) {",
-                '            throw std::runtime_error("invalid UDT coordinator checkpoint token");',
+                '            _PF_ENGINE_INVARIANT("invalid UDT coordinator checkpoint token", std::runtime_error);',
                 "        }",
                 "        for (auto entry = _pf_undo_.rbegin();",
                 "                entry != _pf_undo_.rend(); ++entry) (*entry)();",
@@ -4591,13 +4598,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "",
                 "    void capture(std::size_t index) {",
                 "        if (!_pf_checkpoint_active_) return;",
-                "        auto& slot = _pf_records_.at(index);",
+                "        auto& slot = _PF_INVARIANT_AT(_pf_records_, index);",
                 "        if (slot.logged_generation",
                 "                == _pf_checkpoint_generation_) return;",
                 "        auto snapshot = _PFRecordTraits::take(slot.value);",
                 "        _pf_coordinator_->record(_pf_checkpoint_generation_,",
                 "            [this, index, snapshot = std::move(snapshot)]() mutable {",
-                "                auto& restore_slot = _pf_records_.at(index);",
+                "                auto& restore_slot = _PF_INVARIANT_AT(_pf_records_, index);",
                 "                _PFRecordTraits::restore(restore_slot.value, snapshot);",
                 "                restore_slot.logged_generation = 0;",
                 "            });",
@@ -4613,7 +4620,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 f"            {self._udt_undo_coordinator_cpp_name}* coordinator)",
                 "            : _pf_coordinator_(coordinator) {",
                 "        if (!_pf_coordinator_)",
-                '            throw std::invalid_argument("UDT arena requires undo coordinator");',
+                '            _PF_ENGINE_INVARIANT("UDT arena requires undo coordinator", std::invalid_argument);',
                 "    }",
                 f"    {self._udt_arena_template_cpp_name}(",
                 f"        const {self._udt_arena_template_cpp_name}&) = delete;",
@@ -4635,7 +4642,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    _PFHandle create(_PFRecord value) {",
                 "        if (_pf_records_.size() > static_cast<std::size_t>(",
                 "                std::numeric_limits<int32_t>::max())) {",
-                '            throw std::length_error("UDT object-ID capacity exceeded");',
+                '            _PF_LIMIT_STOP("udt_objects", 2147483647LL, "UDT object-ID capacity exceeded");',
                 "        }",
                 "        const auto id = static_cast<int32_t>(_pf_records_.size());",
                 "        _pf_records_.push_back(_PFSlot{std::move(value), 0});",
@@ -4648,7 +4655,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    _PFRecord& get(_PFHandle value) {",
                 "        if (value.__pf_id < 0",
                 "                || static_cast<std::size_t>(value.__pf_id) >= _pf_records_.size()) {",
-                '            throw std::runtime_error("UDT access on na or invalid object ID");',
+                '            _PF_NA_STOP("udt_object", "UDT access on na or invalid object ID");',
                 "        }",
                 "        const auto index = static_cast<std::size_t>(value.__pf_id);",
                 "        capture(index);",
@@ -4657,7 +4664,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    const _PFRecord& get(_PFHandle value) const {",
                 "        if (value.__pf_id < 0",
                 "                || static_cast<std::size_t>(value.__pf_id) >= _pf_records_.size()) {",
-                '            throw std::runtime_error("UDT access on na or invalid object ID");',
+                '            _PF_NA_STOP("udt_object", "UDT access on na or invalid object ID");',
                 "        }",
                 "        return _pf_records_[static_cast<std::size_t>(value.__pf_id)].value;",
                 "    }",
@@ -4667,14 +4674,14 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "    std::size_t size() const { return _pf_records_.size(); }",
                 "    _PFRecord& record_at(std::size_t index) {",
                 "        capture(index);",
-                "        return _pf_records_.at(index).value;",
+                "        return _PF_INVARIANT_AT(_pf_records_, index).value;",
                 "    }",
                 "    const _PFRecord& record_at(std::size_t index) const {",
-                "        return _pf_records_.at(index).value;",
+                "        return _PF_INVARIANT_AT(_pf_records_, index).value;",
                 "    }",
                 "    Snapshot snapshot() {",
                 "        if (!_pf_coordinator_->active()) {",
-                '            throw std::runtime_error("UDT coordinator checkpoint is not active");',
+                '            _PF_ENGINE_INVARIANT("UDT coordinator checkpoint is not active", std::runtime_error);',
                 "        }",
                 "        _pf_checkpoint_generation_ = _pf_coordinator_->generation();",
                 "        _pf_checkpoint_size_ = _pf_records_.size();",
@@ -4689,7 +4696,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 "                || snapshot.size != _pf_checkpoint_size_",
                 "                || _pf_records_.size() < snapshot.size",
                 "                || !_pf_coordinator_->empty()) {",
-                '            throw std::runtime_error("invalid UDT checkpoint token");',
+                '            _PF_ENGINE_INVARIANT("invalid UDT checkpoint token", std::runtime_error);',
                 "        }",
                 "        _pf_records_.resize(snapshot.size);",
                 "    }",
@@ -4980,6 +4987,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 if name in self._global_collection_types
                 else self._callable_var_collection_spec(name)
             )
+            history_value_cpp = self._array_history_value_cpp_type(name)
+            if history_value_cpp is not None:
+                lines.append(f"    {history_value_cpp} {safe};")
+                continue
             if callable_collection_spec is not None:
                 lines.append(
                     f"    {self._type_spec_to_cpp(callable_collection_spec)} {safe};"
@@ -5178,7 +5189,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             seen_global.add(name)
             safe = self._safe_name(name)
             
-            if name in self._matrix_specs:
+            history_value_cpp = self._array_history_value_cpp_type(name)
+            if history_value_cpp is not None:
+                lines.append(f"    {history_value_cpp} {safe};")
+            elif name in self._matrix_specs:
                 lines.append(f"    {self._type_spec_to_cpp(self._matrix_specs[name])} {safe};")
             elif name in self._array_vars:
                 lines.append(f"    {self._type_spec_to_cpp(self._array_spec_for_name(name))} {safe};")
@@ -5450,7 +5464,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         if self._uses_session_market:
             lines.insert(_session_market_member_at, SESSION_MARKET_MEMBER)
             lines.insert(_session_market_at, SESSION_MARKET_CPP)
+            self._capabilities_export_at += 2
 
+        from .capabilities import emit_capabilities_exports
+        exports: list[str] = []
+        emit_capabilities_exports(self, exports)
+        lines[self._capabilities_export_at:self._capabilities_export_at] = exports
         cpp = "\n".join(lines)
         self._settle_session_reads(cpp)
         return cpp

package/pineforge_codegen/codegen/capabilities.py

@@ -3,7 +3,7 @@
 import json
 import math
 
-from ..ast_nodes import BoolLiteral, FuncCall, Identifier, MemberAccess, NumberLiteral, StrategyDecl, StringLiteral, UnaryOp, VarDecl
+from ..ast_nodes import BoolLiteral, FuncCall, Identifier, MemberAccess, NumberLiteral, StrategyDecl, StringLiteral, Subscript, UnaryOp, VarDecl
 from ..external_requests import CAPABILITY_UNPINNED_ANNOTATION
 from ..limits import iter_ast_nodes
 
@@ -34,6 +34,28 @@ DECLARATION_DEFAULTS = {
     "calc_on_every_history_tick": False,
 }
 
+MODELED_ORDER_ARGUMENTS = {
+    "strategy.entry": frozenset(("id", "direction", "limit", "stop")),
+    "strategy.exit": frozenset(("id", "from_entry", "limit", "stop")),
+    "strategy.close": frozenset(("id", "immediately")),
+    "strategy.close_all": frozenset(("immediately",)),
+}
+READ_ONLY_STRATEGY_CALLS = frozenset(
+    f"strategy.{namespace}.{accessor}"
+    for namespace in ("opentrades", "closedtrades")
+    for accessor in ("entry_id", "entry_price", "entry_time", "entry_bar_index", "size",
+                     "profit", "profit_percent", "commission", "max_runup", "max_runup_percent",
+                     "max_drawdown", "max_drawdown_percent", "exit_id", "exit_price",
+                     "exit_time", "exit_bar_index", "entry_comment", "exit_comment")
+) | frozenset(("strategy.convert_to_account", "strategy.convert_to_symbol"))
+ORDER_SETTINGS = frozenset(("pyramiding", "default_qty_type", "default_qty_value", "initial_capital",
+                           "slippage", "commission_type", "commission_value", "close_entries_rule",
+                           "margin_long", "margin_short", "risk_free_rate"))
+PROVEN_BRACKET_SETTINGS = {"default_qty_type": "strategy.fixed", "default_qty_value": 1,
+                          "commission_type": "strategy.commission.percent", "commission_value": 0}
+PROVEN_SLIPPED_SETTINGS = {"default_qty_type": "strategy.percent_of_equity",
+                          "default_qty_value": 100, "slippage": 15}
+
 
 def _expression(node):
     if isinstance(node, (StringLiteral, NumberLiteral, BoolLiteral)):
@@ -44,6 +66,8 @@ def _expression(node):
         return f"{_expression(node.object)}.{node.member}"
     if isinstance(node, FuncCall):
         return f"{_expression(node.callee)}({','.join(str(_expression(arg)) for arg in node.args)})"
+    if isinstance(node, Subscript):
+        return f"{_expression(node.object)}[{_expression(node.index)}]"
     return None
 
 
@@ -61,13 +85,57 @@ def _literal(node):
     return _expression(node), False
 
 
-def capabilities_document(emitter) -> str:
+def _order_arguments(node):
+    name = _expression(node.callee)
+    positional = {
+        "strategy.entry": ("id", "direction", "qty", "limit", "stop", "oca_name", "oca_type", "comment", "alert_message", "disable_alert"),
+        "strategy.exit": ("id", "from_entry", "qty", "qty_percent", "profit", "limit", "loss", "stop", "trail_price", "trail_points", "trail_offset", "oca_name", "comment", "alert_message", "alert_profit", "alert_loss", "alert_trailing", "disable_alert"),
+        "strategy.close": ("id", "comment", "qty", "qty_percent", "alert_message", "immediately", "disable_alert"),
+        "strategy.close_all": ("comment", "alert_message", "immediately", "disable_alert"),
+    }.get(name, ())
+    arguments = {positional[index] if index < len(positional) else f"positional_{index}": argument
+                 for index, argument in enumerate(node.args)}
+    if arguments.keys() & node.kwargs.keys():
+        arguments["duplicate_argument"] = None
+    arguments.update(node.kwargs)
+    return arguments
+
+
+def _order_shape(node, short_ids):
+    name = _expression(node.callee)
+    arguments = _order_arguments(node)
+    if name not in MODELED_ORDER_ARGUMENTS or not set(arguments) <= MODELED_ORDER_ARGUMENTS[name]:
+        return name + (" (unproven exit terms)" if name == "strategy.exit" else " (unproven order shape)")
+    if name != "strategy.close_all" and not isinstance(arguments.get("id"), StringLiteral):
+        return name + " (unproven order id)"
+    if name == "strategy.entry" and _expression(arguments.get("direction")) in ("strategy.long", "strategy.short"):
+        priced = {key for key in ("limit", "stop") if key in arguments}
+        if len(priced) < 2 and not (set(arguments) & {"oca_name", "oca_type"}):
+            return "entry:" + (next(iter(priced)) if priced else "market")
+    if name == "strategy.exit":
+        if (set(arguments) & {"profit", "loss", "trail_price", "trail_points", "trail_offset", "qty", "qty_percent"}):
+            return name + " (unproven exit terms)"
+        if ("limit" in arguments and "stop" in arguments
+                and isinstance(arguments.get("from_entry"), StringLiteral)
+                and _expression(arguments["from_entry"]) in short_ids):
+            return "exit:short_bracket"
+    if name in ("strategy.close", "strategy.close_all"):
+        immediate = arguments.get("immediately")
+        if immediate is None or isinstance(immediate, BoolLiteral) and not immediate.value:
+            if not (set(arguments) & {"qty", "qty_percent"}):
+                return "close:market"
+    return name + " (unproven order shape)"
+
+
+def capabilities_documents(emitter) -> tuple[str, str]:
     declarations = dict(DECLARATION_DEFAULTS)
     unresolved = []
     requests = []
     lower_symbols = {}
     intrabar = False
     recorded = False
+    order_nodes = []
+    order_settings = {}
     for node, _depth in iter_ast_nodes(emitter.ctx.ast):
         if isinstance(node, StrategyDecl):
             arguments = {STRATEGY_PARAMETERS[index] if index < len(STRATEGY_PARAMETERS)
@@ -75,6 +143,8 @@ def capabilities_document(emitter) -> str:
                          for index, argument in enumerate(node.args)}
             unresolved.extend(arguments.keys() & node.kwargs.keys())
             arguments.update(node.kwargs)
+            order_settings.update({name: _literal(argument)[0] for name, argument in arguments.items()
+                                   if name in ORDER_SETTINGS})
             for name, argument in arguments.items():
                 value, valid = _literal(argument)
                 default = DECLARATION_DEFAULTS.get(name)
@@ -92,6 +162,9 @@ def capabilities_document(emitter) -> str:
             intrabar |= node.is_varip
         elif isinstance(node, FuncCall):
             name, namespace = emitter._resolve_callee(node.callee)
+            qualified = _expression(node.callee) or ""
+            if qualified.startswith("strategy.") and qualified not in READ_ONLY_STRATEGY_CALLS:
+                order_nodes.append(node)
             if namespace == "request" and name == "security_lower_tf":
                 expression = node.args[2] if len(node.args) > 2 else node.kwargs.get("expression")
                 lower_symbols[id(expression)] = node.args[0] if node.args else node.kwargs.get("symbol")
@@ -118,22 +191,27 @@ def capabilities_document(emitter) -> str:
             unresolved.append(f"{_expression(node)} (stream endpoint is not batch-equivalent)")
 
     auxiliary = False
+    confirmed_requests = []
+    lowering_sites = {site["sec_id"]: site for site in emitter._security_eval_info}
     for site in emitter._security_calls:
+        lowering = lowering_sites[site["sec_id"]]
         symbol_node = site.get("symbol_node")
         if site.get("is_lower_tf_array"):
             symbol_node = lower_symbols.get(id(site.get("expr_node")), symbol_node)
         if isinstance(symbol_node, FuncCall) and site.get("heikinashi") and symbol_node.args:
             symbol_node = symbol_node.args[0]
         symbol = _expression(symbol_node) if symbol_node is not None else "syminfo.tickerid"
-        timeframe = _expression(site.get("tf_node"))
+        timeframe = lowering.get("tf")
+        if timeframe is None:
+            timeframe = "timeframe.period" if lowering.get("tf_expr") == "script_tf_" else _expression(site.get("tf_node"))
         lookahead = _expression(site.get("lookahead_node")) or "barmerge.lookahead_off"
         gaps = _expression(site.get("gaps_node")) or "barmerge.gaps_off"
         if isinstance(symbol_node, Identifier) and symbol_node.name not in emitter._global_mutable_infos:
             symbol = _expression((getattr(emitter.ctx, "global_expr_map", {}) or {}).get(
                 symbol_node.name, symbol_node))
-        feed = "chart" if symbol in ("syminfo.tickerid", "syminfo.ticker", "") else "auxiliary"
+        feed = "auxiliary" if lowering.get("foreign") else "chart"
         auxiliary |= feed == "auxiliary"
-        if not isinstance(site.get("tf_node"), StringLiteral) and timeframe != "timeframe.period":
+        if lowering.get("tf") is None and timeframe != "timeframe.period":
             unresolved.append(f"request.security[{site['sec_id']}].timeframe")
         if lookahead not in ("barmerge.lookahead_off", "barmerge.lookahead_on"):
             unresolved.append(f"request.security[{site['sec_id']}].lookahead")
@@ -143,9 +221,14 @@ def capabilities_document(emitter) -> str:
             "timeframe": timeframe,
             "lookahead": lookahead,
             "gaps": gaps,
-            "heikinashi": bool(site.get("heikinashi")),
+            "heikinashi": bool(lowering.get("heikinashi")),
             "feed": feed,
         })
+        expression = _expression(site.get("expr_node"))
+        if expression in ("close", "close[1]", "ta.sma(close,4)", "ta.ema(close,3)") and "close" in (
+                getattr(emitter.ctx, "global_expr_map", {}) or {}):
+            unresolved.append("request.security.expression (user-bound close)")
+        confirmed_requests.append({**requests[-1], "expression": expression})
     for index, site in enumerate((emitter.ctx.ast.annotations or {}).get(CAPABILITY_UNPINNED_ANNOTATION, ())):
         requests.append({
             "function": site["function"],
@@ -166,13 +249,46 @@ def capabilities_document(emitter) -> str:
         "historical_probe_overrides": False,
         "intrabar_persistence": intrabar,
     }
-    return json.dumps({"version": 1, "declarations": declarations, "requests": requests,
-                       "requirements": requirements, "unresolved": sorted(set(unresolved))},
-                      sort_keys=True, separators=(",", ":"), allow_nan=False)
+    short_ids = set()
+    conflicting_ids = set()
+    dynamic_entry_id = False
+    for node in order_nodes:
+        if _expression(node.callee) != "strategy.entry":
+            continue
+        arguments = _order_arguments(node)
+        identifier = arguments.get("id")
+        if not isinstance(identifier, StringLiteral):
+            dynamic_entry_id = True
+        elif _expression(arguments.get("direction")) == "strategy.short":
+            short_ids.add(identifier.value)
+        else:
+            conflicting_ids.add(identifier.value)
+    if dynamic_entry_id or conflicting_ids:
+        short_ids.clear()
+    orders = set(_order_shape(node, short_ids - conflicting_ids) for node in order_nodes)
+    if declarations["process_orders_on_close"]:
+        bracket = orders == {"entry:market", "exit:short_bracket"}
+        proven = (not order_settings and not bracket) or (
+            bracket and order_settings == PROVEN_BRACKET_SETTINGS) or (
+            orders == {"entry:market"} and order_settings == PROVEN_SLIPPED_SETTINGS
+            and not confirmed_requests and not intrabar)
+        if not proven:
+            orders.add("strategy() (unproven POOC sizing, slippage or account settings)")
+    confirmed = {"version": 1, "requests": confirmed_requests,
+                 "orders": sorted(orders),
+                 "intrabar_persistence": intrabar}
+    encode = lambda value: json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False)
+    return (encode({"version": 1, "declarations": declarations, "requests": requests,
+                    "requirements": requirements, "unresolved": sorted(set(unresolved))}), encode(confirmed))
+
+
+def capabilities_document(emitter) -> str:
+    return capabilities_documents(emitter)[0]
 
 
 def emit_capabilities_exports(emitter, lines: list[str]) -> None:
-    literal = json.dumps(capabilities_document(emitter))
+    legacy, confirmed = capabilities_documents(emitter)
+    literal = json.dumps(legacy)
     lines.extend([
         "#ifdef PF_SETTINGS_API_VERSION",
         "#ifdef PF_CAPABILITIES_API_VERSION",
@@ -182,5 +298,22 @@ def emit_capabilities_exports(emitter, lines: list[str]) -> None:
         "        return ::pineforge::checked_settings::boundary(error, error_capacity, [&] {",
         '            ::pineforge::checked_settings::require(s != nullptr, "null strategy");',
         f"            ::pineforge::checked_settings::receipt({literal}, json, capacity, required);",
+        "        });", "    }",
+        "    uint32_t strategy_confirmed_bar_api_version(void) { return 1u; }",
+        "    int strategy_confirmed_bar_receipt(void* s, char* json, size_t capacity, size_t* required, char* error, size_t error_capacity) {",
+        "        if (required) *required = 0;",
+        "        return ::pineforge::checked_settings::boundary(error, error_capacity, [&] {",
+        '            ::pineforge::checked_settings::require(s != nullptr, "null strategy");',
+        f"            ::pineforge::checked_settings::receipt({json.dumps(confirmed)}, json, capacity, required);",
         "        });", "    }", "#endif", "#endif",
     ])
+    from .order_shapes import order_shapes_document
+    lines[-2:-2] = [
+        "    uint32_t strategy_order_shapes_api_version(void) { return 1u; }",
+        "    int strategy_order_shapes_receipt(void* s, char* json, size_t capacity, size_t* required, char* error, size_t error_capacity) {",
+        "        if (required) *required = 0;",
+        "        return ::pineforge::checked_settings::boundary(error, error_capacity, [&] {",
+        '            ::pineforge::checked_settings::require(s != nullptr, "null strategy");',
+        f"            ::pineforge::checked_settings::receipt({json.dumps(order_shapes_document(emitter))}, json, capacity, required);",
+        "        });", "    }",
+    ]