@pineforge/codegen-pyodide 0.9.0 → 0.10.1

package/pineforge_codegen/method_binding.py

@@ -0,0 +1,163 @@
+"""Strict, source-order-preserving binding for typed Pine methods.
+
+Typed extension methods are inventoried before semantic analysis so a call may
+precede its declaration without falling through to a same-named builtin.  This
+module deliberately contains no analyzer or codegen state: both phases consume
+the same signature and binding result.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .ast_nodes import ASTNode, FuncCall, MethodDef, Program
+
+
+@dataclass(frozen=True)
+class MethodSignature:
+    key: str
+    param_names: tuple[str, ...]
+    param_defaults: tuple[ASTNode | None, ...]
+    param_type_hints: tuple[str | None, ...]
+    declaration: MethodDef | None = None
+
+
+@dataclass(frozen=True)
+class BoundMethodArgs:
+    """Non-receiver arguments in parameter and evaluation order."""
+
+    args_by_param: tuple[ASTNode, ...]
+    evaluation_order: tuple[ASTNode, ...]
+
+
+class MethodBindError(ValueError):
+    pass
+
+
+def signature_from_method_def(node: MethodDef) -> MethodSignature:
+    annotations = node.annotations or {}
+    defaults = list(annotations.get("param_defaults", ()))
+    hints = list(annotations.get("param_type_hints", ()))
+    while len(defaults) < len(node.params):
+        defaults.append(None)
+    while len(hints) < len(node.params):
+        hints.append(None)
+    return MethodSignature(
+        key=f"{node.type_name}.{node.name}",
+        param_names=tuple(node.params[1:]),
+        param_defaults=tuple(defaults[1:len(node.params)]),
+        param_type_hints=tuple(hints[1:len(node.params)]),
+        declaration=node,
+    )
+
+
+def signature_from_callable(
+    key: str,
+    param_names: list[str] | tuple[str, ...],
+    param_defaults: list[ASTNode | None] | tuple[ASTNode | None, ...],
+    param_type_hints: list[str | None] | tuple[str | None, ...] = (),
+) -> MethodSignature:
+    """Build a non-receiver signature from an analyzed method FuncInfo."""
+
+    names = tuple(param_names)
+    defaults = list(param_defaults)
+    hints = list(param_type_hints)
+    while len(defaults) < len(names):
+        defaults.append(None)
+    while len(hints) < len(names):
+        hints.append(None)
+    return MethodSignature(
+        key=key,
+        param_names=names,
+        param_defaults=tuple(defaults[:len(names)]),
+        param_type_hints=tuple(hints[:len(names)]),
+    )
+
+
+def inventory_method_signatures(program: Program) -> dict[str, MethodSignature]:
+    """Inventory direct method declarations without analyzing their bodies."""
+
+    result: dict[str, MethodSignature] = {}
+    for stmt in program.body:
+        if isinstance(stmt, MethodDef):
+            signature = signature_from_method_def(stmt)
+            # Preserve the analyzer's historical first-declaration lookup. This
+            # prepass does not introduce method overloading or duplicate policy.
+            result.setdefault(signature.key, signature)
+    return result
+
+
+def _written_actuals(call: FuncCall) -> list[ASTNode]:
+    """Recover written order lost by the parser's args/kwargs split."""
+
+    fallback = [*call.args, *call.kwargs.values()]
+    recorded = (call.annotations or {}).get("call_arg_order", ())
+    if (
+        len(recorded) == len(fallback)
+        and {id(node) for node in recorded} == {id(node) for node in fallback}
+    ):
+        return list(recorded)
+    if not fallback or any(getattr(node, "loc", None) is None for node in fallback):
+        return fallback
+    indexed = list(enumerate(fallback))
+    indexed.sort(
+        key=lambda item: (
+            item[1].loc.line,
+            item[1].loc.col,
+            item[0],
+        )
+    )
+    return [node for _index, node in indexed]
+
+
+def bind_method_call(
+    signature: MethodSignature,
+    call: FuncCall,
+) -> BoundMethodArgs:
+    """Bind one method call strictly, excluding the receiver argument."""
+
+    names = signature.param_names
+    if len(call.args) > len(names):
+        raise MethodBindError(
+            f"{signature.key}: too many positional arguments "
+            f"(expected {len(names)}, got {len(call.args)})"
+        )
+
+    for name in call.kwargs:
+        if name not in names:
+            raise MethodBindError(
+                f"{signature.key}: unknown keyword argument '{name}'"
+            )
+
+    bound: list[ASTNode | None] = [None] * len(names)
+    for index, value in enumerate(call.args):
+        bound[index] = value
+    for name, value in call.kwargs.items():
+        index = names.index(name)
+        if bound[index] is not None:
+            raise MethodBindError(
+                f"{signature.key}: argument '{name}' passed both "
+                "positionally and by keyword"
+            )
+        bound[index] = value
+
+    inserted_defaults: list[ASTNode] = []
+    for index, name in enumerate(names):
+        if bound[index] is not None:
+            continue
+        default = (
+            signature.param_defaults[index]
+            if index < len(signature.param_defaults)
+            else None
+        )
+        if default is None:
+            raise MethodBindError(
+                f"{signature.key}: missing required argument '{name}'"
+            )
+        bound[index] = default
+        inserted_defaults.append(default)
+
+    return BoundMethodArgs(
+        args_by_param=tuple(value for value in bound if value is not None),
+        evaluation_order=tuple([*_written_actuals(call), *inserted_defaults]),
+    )

package/pineforge_codegen/parser.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import re
 
 from .lexer import Token, TokenType
-from .errors import SourceLocation
+from .errors import CompileError, Diagnostic, Level, Phase, SourceLocation
 from .ast_nodes import (
     ASTNode,
     Program, StrategyDecl, ImportStmt,
@@ -56,6 +56,7 @@ class Parser:
         self.pos = 0
         self._source = source
         self._filename = filename
+        self._recovery_count = 0
 
     # ------------------------------------------------------------------
     # Helpers
@@ -143,6 +144,9 @@ class Parser:
                 self._recover()
             self._skip_newlines()
 
+        if self._recovery_count:
+            prog.annotations = dict(prog.annotations or {})
+            prog.annotations["parse_recovery_count"] = self._recovery_count
         return prog
 
     def _extract_version(self) -> int | None:
@@ -156,6 +160,7 @@ class Parser:
 
     def _recover(self) -> None:
         """Skip tokens until next NEWLINE or EOF for error recovery."""
+        self._recovery_count += 1
         while not self._at_end() and not self._check(TokenType.NEWLINE):
             self._advance()
         if self._check(TokenType.NEWLINE):
@@ -400,10 +405,13 @@ class Parser:
         start_tok = self._advance()  # consume 'strategy' or 'indicator'
         # Parse arguments as a function call, then convert to StrategyDecl
         self._consume(TokenType.LPAREN)
-        args, kwargs = self._parse_call_args()
+        args, kwargs, call_arg_order = self._parse_call_args()
         self._consume(TokenType.RPAREN)
         node = StrategyDecl(args=args, kwargs=kwargs)
-        node.annotations = {"decl_kind": start_tok.value}
+        node.annotations = {
+            "decl_kind": start_tok.value,
+            "call_arg_order": call_arg_order,
+        }
         return self._set_loc(node, start_tok)
 
     def _parse_import_stmt(self) -> ImportStmt:
@@ -786,8 +794,16 @@ class Parser:
         start_tok = self._advance()  # consume 'method'
         name = self._consume(TokenType.IDENT).value
         self._consume(TokenType.LPAREN)
-        # First param is the type + self: TypeName self
-        type_name = self._consume(TokenType.IDENT).value
+        # First param is the required receiver type + self name.  Receiver
+        # types use the same complete Pine hint grammar as ordinary typed
+        # parameters: primitives lex as TYPE_* tokens, while collections may
+        # carry nested ``<...>`` arguments or postfix ``[]``.  Consuming only
+        # IDENT here silently dropped valid declarations such as
+        # ``method id(int self)`` and ``method push(array<int> self, ...)``
+        # through the parser's top-level recovery path.
+        if self._current().type not in TYPE_KEYWORDS | {TokenType.IDENT}:
+            self._consume(TokenType.IDENT)  # raises a located ParseError
+        type_name = self._parse_type_hint_string()
         params = [self._consume(TokenType.IDENT).value]  # 'self' or user's name
         param_type_hints = [type_name]
         # Preserve per-param default expressions so codegen can substitute
@@ -1212,15 +1228,17 @@ class Parser:
         """Parse (args, kwargs) after callee expression."""
         start_tok = self._current()
         self._consume(TokenType.LPAREN)
-        args, kwargs = self._parse_call_args()
+        args, kwargs, call_arg_order = self._parse_call_args()
         self._consume(TokenType.RPAREN)
         node = FuncCall(callee=callee, args=args, kwargs=kwargs)
+        node.annotations = {"call_arg_order": call_arg_order}
         return self._set_loc(node, start_tok)
 
-    def _parse_call_args(self) -> tuple[list, dict]:
+    def _parse_call_args(self) -> tuple[list, dict, list]:
         """Parse function call arguments and keyword arguments."""
         args: list = []
         kwargs: dict = {}
+        call_arg_order: list = []
 
         while not self._check(TokenType.RPAREN) and not self._at_end():
             # Detect kwargs: IDENT = value (but not IDENT == value)
@@ -1228,15 +1246,36 @@ class Parser:
                     and self._peek().type == TokenType.EQUALS
                     and self._peek(2).type != TokenType.EQUALS):
                 key_tok = self._advance()
+                if key_tok.value in kwargs:
+                    raise CompileError(
+                        [
+                            Diagnostic(
+                                level=Level.ERROR,
+                                phase=Phase.PARSER,
+                                location=self._loc(key_tok),
+                                message=(
+                                    "duplicate keyword argument "
+                                    f"'{key_tok.value}'"
+                                ),
+                                hint=(
+                                    f"Remove one '{key_tok.value}=' binding; "
+                                    "a keyword argument may be specified only once."
+                                ),
+                            )
+                        ]
+                    )
                 self._advance()  # consume =
                 val = self._parse_expression()
                 kwargs[key_tok.value] = val
+                call_arg_order.append(val)
             else:
-                args.append(self._parse_expression())
+                val = self._parse_expression()
+                args.append(val)
+                call_arg_order.append(val)
 
             self._match(TokenType.COMMA)
 
-        return args, kwargs
+        return args, kwargs, call_arg_order
 
     # -- Primary expressions --
 

package/pineforge_codegen/signatures.py

@@ -229,7 +229,7 @@ _math("round",
       _sig([("x", F)], ret=I),                             # round(x) → int
       _sig([("x", F), ("precision", I)]))                  # round(x, n) → float
 _math("round_to_mintick", _sig([("x", F)]))
-_math("sign",   _sig([("x", F)], ret=I))
+_math("sign",   _sig([("x", F)], ret=F))
 _math("max",
       _sig([("x", F), ("y", F)]),                          # 2-arg
       _sig([("x", F), ("y", F), ("z", F)]),                # 3-arg
@@ -307,13 +307,13 @@ _strat("exit", _sig([
 _strat("close", _sig([
     ("id", S), ("comment", S, None),
     ("qty", F, None), ("qty_percent", F, None),
-    ("alert_message", S, None), ("disable_alert", B, None),
-    ("immediately", B, False),
+    ("alert_message", S, None), ("immediately", B, False),
+    ("disable_alert", B, None),
 ], ret=VOID))
 
 _strat("close_all", _sig([
     ("comment", S, None), ("alert_message", S, None),
-    ("disable_alert", B, None), ("immediately", B, False),
+    ("immediately", B, False), ("disable_alert", B, None),
 ], ret=VOID))
 
 _strat("cancel", _sig([("id", S)], ret=VOID))

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
@@ -515,6 +537,10 @@ class SupportChecker:
         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 +562,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 +974,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):
@@ -1160,7 +1326,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 +1338,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)