@pineforge/codegen-pyodide 0.10.0 → 0.10.2

package/pineforge_codegen/support_checker.py

@@ -10,14 +10,11 @@ Buckets:
 * HARD_REJECT_FUNC / HARD_REJECT_NAMESPACE - calls that have no PineForge
   semantics at all (e.g. ``request.financial``, ``ticker.*``).
 * DIVERGENT_VARS - built-in variables whose PineForge value diverges from
-  TradingView. Most are reported as WARNING (e.g. ``bar_index`` depends on the
-  data window, ``timenow`` is not wall-clock) — these often appear in visual or
-  logging code that does not affect trade outcomes. A subset
-  (DIVERGENT_VARS_ERROR: ``last_bar_index`` aliased to the *current* bar index,
-  ``time_close`` aliased to the bar *open* timestamp) are silent MIS-ALIASES:
-  they produce a plausible-looking but wrong value that flows straight into
-  trade logic, so a backtest would be silently wrong. Those are escalated to
-  ERROR (rejected) rather than merely warned.
+  TradingView. They are reported as WARNING (e.g. ``bar_index`` and
+  ``last_bar_index`` depend on the fed data window, ``timenow`` is not
+  wall-clock) — these often appear in visual or logging code that does not
+  affect trade outcomes. DIVERGENT_VARS_ERROR is reserved for silent
+  mis-aliases severe enough to reject; it is currently empty.
 * NOT_YET - calls the runtime could support but the transpiler does not yet
   emit (e.g. ``max_bars_back``, bare ``barssince``).
 * request.security - only ``symbol`` / ``timeframe`` / ``expression`` allowed,
@@ -81,6 +78,9 @@ SUPPORTED_INPUT: frozenset[str] = frozenset(sigs.INPUT_FUNCTIONS)
 SUPPORTED_ARRAY: frozenset[str] = frozenset(set(ARRAY_METHODS) | {"new", "new_float", "new_int", "new_bool", "new_string", "from"} | set(ARRAY_DRAWING_NEW_CTORS))
 SUPPORTED_MAP: frozenset[str] = frozenset(set(MAP_METHODS) | {"new"})
 SUPPORTED_MATRIX: frozenset[str] = frozenset(set(MATRIX_METHODS) | {"new"})
+_SUPPORTED_MAP_VALUE_TYPES: frozenset[str] = frozenset(
+    {"float", "int", "bool", "string"}
+)
 SUPPORTED_SYMINFO: frozenset[str] = frozenset(SYMINFO_MEMBER_MAP)
 # Drawing-objects-as-data (spec §4.5). Geometry methods are REAL (route to the
 # per-type arena); *_NOOP visual setters are accepted no-ops (Level.WARNING).
@@ -174,11 +174,11 @@ HARD_REJECT_NAMESPACE: dict[str, str] = {
 # logging or visual logic that does not affect trade outcomes. The checker still
 # flags divergence so users see the risk.
 #
-# DIVERGENT_VARS_ERROR is a SUBSET that is escalated to ERROR (rejected): these
-# are silent MIS-ALIASES, not merely data-window divergences. They return a
-# plausible value that is the WRONG quantity (last_bar_index -> current bar
-# index) and that value flows directly into trade logic, so the backtest would
-# be silently wrong. A WARNING is not enough.
+# DIVERGENT_VARS_ERROR is a SUBSET reserved for silent MIS-ALIASES that must be
+# escalated to ERROR (rejected), rather than merely warned. It is currently
+# empty: last_bar_index lowers to the true final index of the fed data window,
+# but that index can still differ from TradingView when the window does not
+# cover the same chart history.
 #
 # NOTE: the bare ``time_close`` variable is NOT divergent — codegen lowers it to
 # the engine's ``time_close()`` accessor, which returns the true bar-close
@@ -188,20 +188,32 @@ HARD_REJECT_NAMESPACE: dict[str, str] = {
 # separate supported builtin handled in visit_call.)
 DIVERGENT_VARS: dict[str, str] = {
     "bar_index":      "bar_index depends on the data window; PineForge and TradingView produce different values for the same script.",
-    "last_bar_index": "last_bar_index is aliased to the CURRENT bar index in PineForge codegen (not the index of the last bar); backtest would be silently wrong — rejected.",
+    "last_bar_index": "last_bar_index is the final index of PineForge's fed data window; it can diverge from TradingView when the window does not cover the same chart history.",
     "timenow":        "timenow is aliased to the current bar timestamp in PineForge; it is not real wall-clock time.",
 }
 
 # Subset of DIVERGENT_VARS escalated from WARNING to ERROR (see comment above).
-DIVERGENT_VARS_ERROR: frozenset[str] = frozenset({"last_bar_index"})
+DIVERGENT_VARS_ERROR: frozenset[str] = frozenset()
 
 BARSTATE_APPROX_VARS: dict[str, str] = {
-    "barstate.islast": "barstate.islast is always false in PineForge batch backtests.",
+    "barstate.islast": (
+        "In direct batch chart-scope evaluation, barstate.islast is true only "
+        "on the final bar of PineForge's fed chart-data window. Inside a "
+        "request.security() history index, PineForge currently selects the "
+        "false branch; requested-context last-bar state is not modeled."
+    ),
     "barstate.ishistory": "barstate.ishistory is always true in PineForge batch backtests.",
     "barstate.isrealtime": "barstate.isrealtime is always false in PineForge batch backtests.",
     "barstate.isnew": "barstate.isnew follows PineForge first-tick execution state.",
     "barstate.isconfirmed": "barstate.isconfirmed follows PineForge last-tick execution state.",
-    "barstate.islastconfirmedhistory": "barstate.islastconfirmedhistory is always false in PineForge batch backtests.",
+    "barstate.islastconfirmedhistory": (
+        "In direct historical batch chart-scope evaluation, PineForge "
+        "approximates barstate.islastconfirmedhistory as true only on the "
+        "final bar of the fed chart-data window. Inside a request.security() "
+        "history index, PineForge currently selects the false branch; "
+        "TradingView's requested-context and realtime-boundary semantics are "
+        "not modeled."
+    ),
 }
 
 STRATEGY_UNSUPPORTED_PARAMS: dict[str, set[str]] = {
@@ -209,9 +221,13 @@ STRATEGY_UNSUPPORTED_PARAMS: dict[str, set[str]] = {
     "order": {"comment", "alert_message", "disable_alert", "qty_type"},
     "exit": {"comment_profit", "comment_loss", "comment_trailing", "alert_message", "alert_profit", "alert_loss", "alert_trailing", "disable_alert"},
     "close": {"alert_message", "disable_alert"},
-    "close_all": {"comment", "alert_message", "disable_alert", "immediately"},
+    "close_all": {"alert_message", "disable_alert"},
 }
 
+# Alert delivery remains outside the backtest runtime contract. Keep these
+# parameters warning-only so strategies that use webhook metadata still run;
+# a follow-up must plumb alert events before codegen may claim support.
+
 # strategy.closedtrades / strategy.opentrades accessor surfaces are NOT
 # symmetric in Pine v6. opentrades has no exit_* fields (a trade has not
 # closed yet). Both lack ``direction`` (Pine has ``size`` whose sign carries
@@ -461,6 +477,12 @@ class SupportChecker:
         # shapes before codegen.
         self._udt_drawing_fields: dict[str, set[str]] = {}
         self._var_udt_types: dict[str, str] = {}
+        # PineMap IDs require runtime snapshots during COOF rollback. History
+        # buffers and generic matrices still value-copy their elements, so
+        # map-bearing shapes that would silently retain live aliases are gated
+        # until those containers have recursive checkpoint adapters.
+        self._udt_field_type_names: dict[str, dict[str, str]] = {}
+        self._map_bearing_udts: set[str] = set()
         # Names (vars and function params) declared as a scalar visual-container
         # type (table/box/line/label/linefill). A method call on one of these
         # (``panel.cell(...)``) is a visual sink whose args may carry visual
@@ -494,11 +516,20 @@ class SupportChecker:
         # then ``request.security(haTicker, ...)``, or ``reqSym = cond ? other :
         # syminfo.tickerid``. First binding wins (closest to declaration).
         self._scalar_defs: dict[str, ASTNode] = {}
+        # EVERY reassignment value bound to a scalar name (``name := <expr>``
+        # and the compound forms). A declaration alone does not pin the value a
+        # ``request.security`` symbol argument actually carries: the engine is
+        # registered with no symbol at all, so an accepted-but-divergent rebind
+        # silently backtests the CHART feed. Collected in a whole-AST pre-pass
+        # (below) as well as during the visit, so a rebind that lexically
+        # FOLLOWS the request.security call cannot slip past.
+        self._scalar_rebinds: dict[str, list[ASTNode]] = {}
 
     # -- Public API --
 
     def check(self) -> list[Diagnostic]:
         self._collect_user_definitions(self._ast)
+        self._collect_scalar_rebinds(self._ast)
         for stmt in self._ast.body:
             self._visit(stmt)
         return self._diagnostics
@@ -511,10 +542,50 @@ class SupportChecker:
 
     # -- Setup --
 
+    def _record_scalar_rebind(self, node: Assignment) -> None:
+        """Remember ``name := <expr>`` (and the compound forms) by name.
+
+        A compound op (``+=``, ``*=``, …) records its right-hand operand, which
+        is never a current-symbol expression — so a string-built symbol is
+        rejected by the same rule that rejects a plain divergent ``:=``.
+        """
+        target = node.target
+        if not isinstance(target, Identifier) or node.value is None:
+            return
+        recorded = self._scalar_rebinds.setdefault(target.name, [])
+        if not any(value is node.value for value in recorded):
+            recorded.append(node.value)
+
+    def _collect_scalar_rebinds(self, node: ASTNode) -> None:
+        """Pre-pass: collect every scalar rebind anywhere in the AST.
+
+        The visit walks top-level statements in source order, so a rebind that
+        FOLLOWS a ``request.security`` call would otherwise never be seen by
+        that call's symbol check. Collecting up front is strictly fail-closed:
+        it can only add rejections, never remove one.
+        """
+        if isinstance(node, Assignment):
+            self._record_scalar_rebind(node)
+        for value in vars(node).values():
+            if isinstance(value, ASTNode):
+                self._collect_scalar_rebinds(value)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, ASTNode):
+                        self._collect_scalar_rebinds(item)
+            elif isinstance(value, dict):
+                for item in value.values():
+                    if isinstance(item, ASTNode):
+                        self._collect_scalar_rebinds(item)
+
     def _collect_user_definitions(self, ast: Program) -> None:
         for stmt in ast.body:
             if isinstance(stmt, TypeDecl):
                 self._user_types.add(stmt.name)
+                self._udt_field_type_names[stmt.name] = {
+                    field.name: str(field.type_name or "").replace(" ", "")
+                    for field in stmt.fields
+                }
                 drawing_fields = {
                     field.name
                     for field in stmt.fields
@@ -536,6 +607,140 @@ class SupportChecker:
                 self._user_methods.add(stmt.name)
                 self._collect_visual_container_params(stmt)
 
+        # Resolve direct and transitively nested map-bearing UDTs. Pine type
+        # declarations are normally dependency ordered, but the fixed point
+        # also keeps this guard deterministic for synthetic test ASTs.
+        changed = True
+        while changed:
+            changed = False
+            for udt_name, fields in self._udt_field_type_names.items():
+                bearing_fields = {
+                    field_name
+                    for field_name, type_name in fields.items()
+                    if "map<" in type_name
+                    or any(
+                        type_name == nested
+                        or f"<{nested}>" in type_name
+                        or f"<{nested}," in type_name
+                        or f",{nested}>" in type_name
+                        for nested in self._map_bearing_udts
+                    )
+                }
+                if bearing_fields:
+                    if udt_name not in self._map_bearing_udts:
+                        self._map_bearing_udts.add(udt_name)
+                        changed = True
+
+        # Constructor checks alone are insufficient: a typed ``na``
+        # declaration, UDT field, or unused callable parameter can introduce
+        # the same unsupported runtime shape without ever calling map.new() or
+        # matrix.new().  Validate every declared type boundary after the UDT
+        # fixed point is known so unsupported shapes fail with a Pine source
+        # diagnostic instead of a generated-C++ static_assert.
+        for stmt in ast.body:
+            if isinstance(stmt, TypeDecl):
+                for field in stmt.fields:
+                    self._validate_declared_type_hint(
+                        stmt,
+                        field.type_name,
+                        context=f"field '{stmt.name}.{field.name}'",
+                    )
+            elif isinstance(stmt, (FuncDef, MethodDef)):
+                hints = (
+                    (getattr(stmt, "annotations", None) or {})
+                    .get("param_type_hints")
+                    or []
+                )
+                for index, param_name in enumerate(stmt.params):
+                    hint = hints[index] if index < len(hints) else None
+                    if hint:
+                        self._validate_declared_type_hint(
+                            stmt,
+                            hint,
+                            context=f"parameter '{param_name}'",
+                        )
+
+    @staticmethod
+    def _split_declared_type_args(text: str) -> list[str]:
+        """Split ``K,V`` while preserving nested generic arguments."""
+        args: list[str] = []
+        current: list[str] = []
+        depth = 0
+        for char in text:
+            if char == "<":
+                depth += 1
+            elif char == ">":
+                depth -= 1
+            if char == "," and depth == 0:
+                args.append("".join(current))
+                current = []
+            else:
+                current.append(char)
+        if current:
+            args.append("".join(current))
+        return args
+
+    def _validate_declared_type_hint(
+        self,
+        node: ASTNode,
+        type_name: str | None,
+        *,
+        context: str,
+    ) -> None:
+        """Fail closed for runtime collection limits at every type boundary."""
+        if not type_name:
+            return
+        compact = str(type_name).replace(" ", "")
+        if compact.endswith("[]"):
+            compact = f"array<{compact[:-2]}>"
+
+        if compact.startswith("map<") and compact.endswith(">"):
+            parts = self._split_declared_type_args(compact[4:-1])
+            if len(parts) != 2:
+                return
+            key_type, value_type = parts
+            if key_type != "string":
+                self._err(
+                    node,
+                    f"{context}: map keys must be string in PineForge's "
+                    "supported map subset.",
+                )
+            if value_type not in _SUPPORTED_MAP_VALUE_TYPES:
+                self._err(
+                    node,
+                    f"{context}: map values must be primitive in PineForge's "
+                    "supported map subset.",
+                )
+            return
+
+        if compact.startswith("matrix<") and compact.endswith(">"):
+            element_type = compact[len("matrix<"):-1]
+            if element_type in self._map_bearing_udts:
+                self._err(
+                    node,
+                    f"matrix<{element_type}> is not supported when the UDT "
+                    "contains a map field; rollback would retain live map "
+                    "aliases.",
+                    hint="Use array<UDT> for recursively checkpointed state.",
+                )
+                return
+            if "<" in element_type:
+                self._err(
+                    node,
+                    f"matrix<{element_type}>: nested collection element types "
+                    "not supported in v1.",
+                )
+                return
+
+        # Arrays are recursively checkpointed and may contain valid maps, but
+        # the nested map still has the same key/value boundary.
+        if compact.startswith("array<") and compact.endswith(">"):
+            self._validate_declared_type_hint(
+                node,
+                compact[len("array<"):-1],
+                context=context,
+            )
+
     def _collect_visual_container_params(self, fn) -> None:
         """Register a function's parameters that are declared with a scalar
         visual-container type (``table panel``, ``line ln``) so method calls on
@@ -814,6 +1019,12 @@ class SupportChecker:
         # so a direct ``dash.cell(..., text.align_left)`` is treated as a visual
         # sink (mirrors the table/box/line/label/linefill PARAM tracking).
         decl_hint = str(node.type_hint).replace(" ", "") if node.type_hint else None
+        if decl_hint:
+            self._validate_declared_type_hint(
+                node,
+                decl_hint,
+                context=f"variable '{node.name}'",
+            )
         if decl_hint in _VISUAL_CONTAINER_TYPES:
             self._visual_container_vars.add(node.name)
         elif isinstance(node.value, FuncCall):
@@ -835,6 +1046,14 @@ class SupportChecker:
             )
         self._visit_children(node)
 
+    def _visit_Assignment(self, node: Assignment) -> None:
+        # ``_scalar_defs`` records only the DECLARATION, so a later ``:=``
+        # rebind used to be invisible to the request.security symbol check.
+        # (``check`` also pre-collects these; recording here keeps the visit
+        # self-consistent for any caller that drives visitors directly.)
+        self._record_scalar_rebind(node)
+        self._visit_children(node)
+
     def _visit_TupleAssign(self, node: TupleAssign) -> None:
         drawing_mask = self._tuple_assign_drawing_mask(node.value)
         if drawing_mask:
@@ -1160,7 +1379,7 @@ class SupportChecker:
             targs = [str(t).replace(" ", "") for t in targs]
             if targs and targs[0] != "string":
                 self._err(node, "map keys must be string in PineForge's supported map subset.")
-            if len(targs) > 1 and targs[1] not in {"float", "int", "bool", "string"}:
+            if len(targs) > 1 and targs[1] not in _SUPPORTED_MAP_VALUE_TYPES:
                 self._err(node, "map values must be primitive in PineForge's supported map subset.")
         if ns == "matrix" and name == "new":
             targs = (getattr(node.callee, "annotations", None) or {}).get("template_args") or []
@@ -1172,6 +1391,15 @@ class SupportChecker:
                     self._visit_children(node)
                     return
                 allowed_prim = {"float", "int", "bool", "string", "color"}
+                if t in self._map_bearing_udts:
+                    self._err(
+                        node,
+                        f"matrix<{t}> is not supported when the UDT contains "
+                        "a map field; rollback would retain live map aliases.",
+                        hint="Use array<UDT> for recursively checkpointed state.",
+                    )
+                    self._visit_children(node)
+                    return
                 if t not in allowed_prim and t not in self._user_types:
                     self._err(node, f"matrix<{t}> element type not supported. Allowed: float, int, bool, string, color, or a declared UDT.")
                     self._visit_children(node)
@@ -1548,10 +1776,21 @@ class SupportChecker:
                     or self._is_current_symbol_expr(node.false_val, _seen))
         # Def-use: resolve a bare identifier through its declaration value so an
         # aliased symbol is accepted (``haTicker = ticker.heikinashi(...)`` then
-        # ``request.security(haTicker, ...)``). Name-cycle-guarded.
-        if isinstance(node, Identifier) and node.name in self._scalar_defs and node.name not in _seen:
-            _seen.add(node.name)
-            return self._is_current_symbol_expr(self._scalar_defs[node.name], _seen)
+        # ``request.security(haTicker, ...)``). Every ``:=`` rebind of the name
+        # must resolve to the chart symbol too: the declaration alone does not
+        # pin the value the call actually receives. Name-cycle-guarded.
+        if isinstance(node, Identifier) and node.name not in _seen:
+            definition = self._scalar_defs.get(node.name)
+            rebinds = self._scalar_rebinds.get(node.name)
+            if definition is not None or rebinds:
+                _seen.add(node.name)
+                if rebinds and not all(
+                    self._is_current_symbol_expr(value, _seen) for value in rebinds
+                ):
+                    return False
+                if definition is None:
+                    return False
+                return self._is_current_symbol_expr(definition, _seen)
         return False
 
     # -- Pine timeframe-literal validation --

package/pineforge_codegen/symbols.py

@@ -56,9 +56,74 @@ class TypeSpec:
             return f"array<{self.element}>"
         if self.kind == "map" and self.key is not None and self.value is not None:
             return f"map<{self.key},{self.value}>"
+        if self.kind == "matrix" and self.element is not None:
+            return f"matrix<{self.element}>"
         return self.name or self.kind
 
 
+def method_receiver_type_name(spec: TypeSpec | None) -> str | None:
+    """Canonical Pine type name used to key a user method receiver.
+
+    ``MethodDef.type_name`` is the parser-normalized spelling (for example
+    ``array<int>``).  Calls are resolved from structured ``TypeSpec`` values,
+    so both sides need one lossless spelling across primitive, UDT, and
+    collection receivers.  Incomplete collection specs stay unresolved rather
+    than accidentally colliding under a coarse ``array``/``map``/``matrix``
+    key.
+    """
+
+    if spec is None:
+        return None
+    if spec.kind in {"primitive", "udt"}:
+        return spec.name
+    if spec.kind == "array" and spec.element is not None:
+        element = method_receiver_type_name(spec.element)
+        return f"array<{element}>" if element is not None else None
+    if spec.kind == "map" and spec.key is not None and spec.value is not None:
+        key = method_receiver_type_name(spec.key)
+        value = method_receiver_type_name(spec.value)
+        if key is not None and value is not None:
+            return f"map<{key},{value}>"
+        return None
+    if spec.kind == "matrix" and spec.element is not None:
+        element = method_receiver_type_name(spec.element)
+        return f"matrix<{element}>" if element is not None else None
+    return None
+
+
+def method_receiver_cpp_token(
+    spec: TypeSpec | None,
+    fallback_name: str | None = None,
+) -> str:
+    """Return a stable C++ identifier fragment for a method receiver type.
+
+    Existing primitive, UDT, and drawing receiver spellings remain unchanged.
+    Generic Pine types cannot be embedded directly in an identifier, so their
+    structure is encoded recursively (``array<int>`` -> ``array_int``).  The
+    fallback only supports older/synthetic ``FuncInfo`` records that lack the
+    structured receiver spec.
+    """
+
+    if spec is not None:
+        if spec.kind in {"primitive", "udt"} and spec.name:
+            return spec.name
+        if spec.kind == "array" and spec.element is not None:
+            return f"array_{method_receiver_cpp_token(spec.element)}"
+        if spec.kind == "map" and spec.key is not None and spec.value is not None:
+            return (
+                f"map_{method_receiver_cpp_token(spec.key)}_"
+                f"{method_receiver_cpp_token(spec.value)}"
+            )
+        if spec.kind == "matrix" and spec.element is not None:
+            return f"matrix_{method_receiver_cpp_token(spec.element)}"
+
+    raw = fallback_name or "receiver"
+    token = "".join(ch if ch.isalnum() or ch == "_" else "_" for ch in raw)
+    if token and token[0].isdigit():
+        token = f"type_{token}"
+    return token or "receiver"
+
+
 @dataclass
 class Symbol:
     name: str

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "0.10.0",
+  "codegen": "0.10.2",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "66102b3b3eb6f1e118de1a816f9b56a73311c0340a0a208fd97241f568b43fb1"
+  "sha256": "97ebb8d0b14c32d3c88b9521c8f13150ee9cb9e3859227af970ec4dcbfa6bf71"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "0.10.0",
+  "CODEGEN_VERSION": "0.10.2",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",
@@ -861,14 +861,14 @@
       "qty",
       "qty_percent",
       "alert_message",
-      "disable_alert",
-      "immediately"
+      "immediately",
+      "disable_alert"
     ],
     "strategy.close_all": [
       "comment",
       "alert_message",
-      "disable_alert",
-      "immediately"
+      "immediately",
+      "disable_alert"
     ],
     "strategy.cancel": [
       "id"
@@ -1449,16 +1449,16 @@
   },
   "DIVERGENT_VARS": {
     "bar_index": "bar_index depends on the data window; PineForge and TradingView produce different values for the same script.",
-    "last_bar_index": "last_bar_index is aliased to the CURRENT bar index in PineForge codegen (not the index of the last bar); backtest would be silently wrong — rejected.",
+    "last_bar_index": "last_bar_index is the final index of PineForge's fed data window; it can diverge from TradingView when the window does not cover the same chart history.",
     "timenow": "timenow is aliased to the current bar timestamp in PineForge; it is not real wall-clock time."
   },
   "BARSTATE_APPROX_VARS": {
-    "barstate.islast": "barstate.islast is always false in PineForge batch backtests.",
+    "barstate.islast": "In direct batch chart-scope evaluation, barstate.islast is true only on the final bar of PineForge's fed chart-data window. Inside a request.security() history index, PineForge currently selects the false branch; requested-context last-bar state is not modeled.",
     "barstate.ishistory": "barstate.ishistory is always true in PineForge batch backtests.",
     "barstate.isrealtime": "barstate.isrealtime is always false in PineForge batch backtests.",
     "barstate.isnew": "barstate.isnew follows PineForge first-tick execution state.",
     "barstate.isconfirmed": "barstate.isconfirmed follows PineForge last-tick execution state.",
-    "barstate.islastconfirmedhistory": "barstate.islastconfirmedhistory is always false in PineForge batch backtests."
+    "barstate.islastconfirmedhistory": "In direct historical batch chart-scope evaluation, PineForge approximates barstate.islastconfirmedhistory as true only on the final bar of the fed chart-data window. Inside a request.security() history index, PineForge currently selects the false branch; TradingView's requested-context and realtime-boundary semantics are not modeled."
   },
   "STRATEGY_UNSUPPORTED_PARAMS": {
     "entry": [
@@ -1487,9 +1487,7 @@
     ],
     "close_all": [
       "alert_message",
-      "comment",
-      "disable_alert",
-      "immediately"
+      "disable_alert"
     ]
   },
   "CLOSED_TRADE_ACCESSOR_METHODS": [