@pineforge/codegen-pyodide 0.7.6 → 0.8.1

package/pineforge_codegen/codegen/security.py

@@ -60,8 +60,8 @@ from __future__ import annotations
 
 from ..ast_nodes import (
     ASTNode, Assignment, BinOp, BreakStmt, ContinueStmt, ExprStmt, ForStmt,
-    ForInStmt, FuncCall, Identifier, IfStmt, NumberLiteral, Subscript,
-    SwitchStmt, Ternary, TupleAssign, TupleLiteral, UnaryOp, VarDecl,
+    ForInStmt, FuncCall, FuncDef, Identifier, IfStmt, NumberLiteral, StringLiteral,
+    Subscript, SwitchStmt, Ternary, TupleAssign, TupleLiteral, UnaryOp, VarDecl,
     WhileStmt,
 )
 from ..analyzer import (
@@ -77,6 +77,89 @@ class SecurityEmitter:
 
     Mixed into ``CodeGen``; not intended to be instantiated standalone."""
 
+    def _resolve_security_tf(self, tf_node, containing_func: str):
+        """Resolve a ``request.security`` timeframe argument to ``(tf_str, tf_expr)``.
+
+        ``tf_str`` is a compile-time string literal value; ``tf_expr`` is a runtime
+        C++ expression used at evaluator-registration time. Exactly one is non-None
+        for a usable tf (both None is acceptable only as an explicit "unknown").
+
+        A function-parameter tf (e.g. ``f(tf) => request.security(sym, tf, ...)``)
+        is not visible at class scope (the evaluator is a class method), so it is
+        resolved from the function's call sites. A dead-code UDF (never called)
+        falls back to the chart timeframe — its evaluator result is never read.
+        """
+        if isinstance(tf_node, StringLiteral):
+            return tf_node.value, None
+        if isinstance(tf_node, Identifier):
+            name = tf_node.name
+            if name in self._timeframe_period_vars:
+                return None, "script_tf_"
+            if (name in self._known_vars and name not in self._input_backed_vars
+                    and isinstance(self._known_vars[name], str)):
+                return self._known_vars[name], None
+            if name in self._input_backed_vars and name in self._input_var_to_call:
+                return None, self._visit_expr(self._input_var_to_call[name])
+            # class-scope resolvable (global / input member)?
+            if self._ident_is_resolvable(name):
+                try:
+                    return None, self._visit_expr(tf_node)
+                except Exception:
+                    pass
+            # function-parameter tf -> resolve from the call sites
+            if containing_func:
+                resolved = self._resolve_param_tf_from_callsites(containing_func, name)
+                if resolved is not None:
+                    return resolved
+            # graceful fallback so transpile does not hard-fail
+            return None, "input_tf_"
+        # any other expression — visit if it resolves at class scope
+        try:
+            return None, self._visit_expr(tf_node)
+        except Exception:
+            return None, "input_tf_"
+
+    def _resolve_param_tf_from_callsites(self, func_name: str, param_name: str):
+        """For a ``request.security`` whose tf is function parameter ``param_name``
+        of user function ``func_name``, return ``(tf_str, tf_expr)`` resolved from
+        the call sites, or None. If every call passes the same literal/member tf,
+        that tf is used; mixed timeframes or a never-called (dead-code) function
+        fall back to the chart timeframe (``input_tf_``)."""
+        fdef = None
+        for node in self._walk_ast(self.ctx.ast):
+            if isinstance(node, FuncDef) and node.name == func_name:
+                fdef = node
+                break
+        if fdef is None or param_name not in fdef.params:
+            return None
+        pidx = fdef.params.index(param_name)
+        resolved: list = []
+        found_call = False
+        for node in self._walk_ast(self.ctx.ast):
+            if (isinstance(node, FuncCall) and isinstance(node.callee, Identifier)
+                    and node.callee.name == func_name):
+                found_call = True
+                arg = node.args[pidx] if pidx < len(node.args) else None
+                if arg is None:
+                    continue
+                # Resolve the call-site arg (no further containing func — these
+                # are global-scope / input args).
+                resolved.append(self._resolve_security_tf(arg, ""))
+        if not found_call:
+            # dead code — evaluator never read; register with chart tf.
+            return (None, "input_tf_")
+        valid = [r for r in resolved if r is not None]
+        if not valid:
+            return (None, "input_tf_")
+        strs = {r[0] for r in valid}
+        exprs = {r[1] for r in valid}
+        if len(strs) == 1 and next(iter(strs), None) is not None:
+            return (next(iter(strs)), None)
+        if len(exprs) == 1 and next(iter(exprs), None) is not None:
+            return (None, next(iter(exprs)))
+        # mixed timeframes across call sites — cannot pick one statically
+        return (None, "input_tf_")
+
     def _normalize_security_call(self, item) -> dict:
         if hasattr(item, "sec_id"):
             return {
@@ -88,9 +171,12 @@ class SecurityEmitter:
                 "gaps_node": item.gaps,
                 "lookahead_node": item.lookahead,
                 "ta_range": item.ta_range,
+                "heikinashi": bool(getattr(item, "heikinashi", False)),
                 "depends_on_mutable_globals": bool(getattr(item, "depends_on_mutable_globals", False)),
                 "mutable_globals": list(getattr(item, "mutable_globals", ()) or ()),
                 "is_lower_tf_array": bool(getattr(item, "is_lower_tf_array", False)),
+                "containing_func": getattr(item, "containing_func", "") or "",
+                "callsite_idx": getattr(item, "callsite_idx", None),
             }
         return {
             "sec_id": item[0],
@@ -104,6 +190,8 @@ class SecurityEmitter:
             "depends_on_mutable_globals": False,
             "mutable_globals": [],
             "is_lower_tf_array": False,
+            "containing_func": "",
+            "callsite_idx": None,
         }
 
     def _security_state_name(self, sec_id: int, name: str) -> str:
@@ -239,6 +327,75 @@ class SecurityEmitter:
     def _security_ohlc_hist_series_cpp(self, sec_id: int, field: str) -> str:
         return f"_sec{sec_id}_hist_{field}"
 
+    def _collect_security_ta_hist_indices(self, node) -> set[int]:
+        """Which security TA call-site indices need HTF history (subscript index >= 1).
+
+        ``request.security(..., ta.ema(close, 55)[1], ...)`` reads a *confirmed*
+        HTF TA value at a past-bar offset. The inner TA call runs in the security
+        (HTF) context and commits one value per COMPLETED HTF bar; offsets read a
+        per-site ``Series`` filled (gated on ``is_complete``) in
+        ``_eval_security_N``. Mirrors ``_collect_security_ohlc_hist_fields`` for
+        OHLC offsets. Offset 0 reuses the current committed value (``_secval_*``)
+        and needs no Series, so only index >= 1 registers here."""
+        out: set[int] = set()
+        global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
+
+        def resolve_ta_site(obj, resolving: set[str] | None = None):
+            """_get_ta_site only matches the literal ta.* FuncCall node by
+            identity; fall back through global_expr_map for an indirect
+            binding (``v = ta.ema(close, 55)`` then ``...v[1]...``), mirroring
+            the same fallback in _build_security_expr's Subscript branch."""
+            site = self._get_ta_site(obj)
+            if site is not None:
+                return site
+            if isinstance(obj, Identifier):
+                if resolving is None:
+                    resolving = set()
+                if obj.name in global_expr_map and obj.name not in resolving:
+                    resolving.add(obj.name)
+                    return resolve_ta_site(global_expr_map[obj.name], resolving)
+            return None
+
+        def walk(n):
+            if n is None:
+                return
+            if isinstance(n, Subscript):
+                site = resolve_ta_site(n.object)
+                if site is not None:
+                    idx_lit = self._literal_int_for_security_index(n.index)
+                    if idx_lit is not None and idx_lit >= 1:
+                        site_idx = self._ta_index_by_site_id.get(id(site))
+                        if site_idx is not None:
+                            out.add(site_idx)
+            if isinstance(n, (list, tuple)):
+                for x in n:
+                    walk(x)
+                return
+            for _k, v in getattr(n, "__dict__", {}).items():
+                if isinstance(v, ASTNode):
+                    walk(v)
+                elif isinstance(v, (list, tuple)):
+                    for x in v:
+                        if isinstance(x, ASTNode):
+                            walk(x)
+
+        walk(node)
+        return out
+
+    def _security_ta_hist_series_cpp(self, member_name: str) -> str:
+        """Per-(sec, site) ``Series<double>`` backing ``ta.<fn>(...)[k>=1]`` HTF history."""
+        return f"{member_name}_hist"
+
+    def _security_ta_hist_series_names(self, sec_id: int) -> list[str]:
+        """Hist Series names for every security TA site (and variant) read at an
+        offset >= 1 in sec ``sec_id``."""
+        info = self._security_eval_info[sec_id]
+        names: list[str] = []
+        for idx in sorted(self._security_ta_hist_idx_by_sec.get(sec_id, ())):
+            for variant in (info.get("ta_variants") or {}).get(idx, []):
+                names.append(self._security_ta_hist_series_cpp(variant["member_name"]))
+        return names
+
     @staticmethod
     def _security_series_binding(series_name: str) -> str:
         return f"@series:{series_name}"
@@ -1160,6 +1317,59 @@ class SecurityEmitter:
         )
         return out
 
+    def _emit_security_ohlc_hist_pushes(self, sec_id: int, lines: list[str]) -> None:
+        """Emit the OHLC history-offset Series pushes for ``sec_id``, gated on
+        ``is_complete``.
+
+        ``request.security(..., [high[1], low[1], ...], ...)`` reads HTF OHLC at
+        past-bar offsets. Each offset is backed by a per-field Series whose
+        history must advance once per COMPLETED HTF bar — not once per (partial)
+        chart-bar evaluation. ``_eval_security_N`` fires on every chart bar; only
+        the bar that completes the HTF aggregate has ``is_complete == true``.
+        Pushing unconditionally advanced the offset history every chart bar, so
+        ``high[1]`` resolved to a recent partial bar instead of the prior
+        completed HTF bar. Gate all pushes for this sec in one combined block."""
+        fields = sorted(self._security_ohlc_hist_fields_by_sec.get(sec_id, ()))
+        if not fields:
+            return
+        lines.append("        if (is_complete) {")
+        for field in fields:
+            lines.append(
+                f"            {self._security_ohlc_hist_series_cpp(sec_id, field)}.push(bar.{field});"
+            )
+        lines.append("        }")
+
+    def _emit_security_ta_hist_pushes(
+        self, sec_id: int, info: dict, ta_results: dict, lines: list[str]
+    ) -> None:
+        """Emit the TA history-offset Series pushes for ``sec_id``, gated on
+        ``is_complete`` (mirrors ``_emit_security_ohlc_hist_pushes``).
+
+        ``request.security(..., ta.ema(close, 55)[1], ...)`` reads a confirmed
+        HTF TA value at a past-bar offset. The committed value (``_secval_*``,
+        produced with ``.compute()`` only when ``is_complete``) is pushed onto a
+        per-site Series once per COMPLETED HTF bar, AFTER the expression
+        assignment so the offset read sees the prior completed bar. Pushing on
+        every chart-bar eval would otherwise advance the offset history per
+        partial eval / chart tick (the bug this replaces, where the chart-context
+        ``_hist_call`` buffer advanced on ``is_first_tick_``)."""
+        indices = sorted(self._security_ta_hist_idx_by_sec.get(sec_id, ()))
+        if not indices:
+            return
+        pushes: list[str] = []
+        for idx in indices:
+            for variant in (info.get("ta_variants") or {}).get(idx, []):
+                result_name = ta_results.get((idx, variant["signature"]))
+                if result_name is None:
+                    continue
+                hist = self._security_ta_hist_series_cpp(variant["member_name"])
+                pushes.append(f"            {hist}.push({result_name});")
+        if not pushes:
+            return
+        lines.append("        if (is_complete) {")
+        lines.extend(pushes)
+        lines.append("        }")
+
     def _emit_security_evaluators(self, lines: list[str]) -> None:
         """Emit _eval_security_N() methods and evaluate_security() dispatch."""
         if not self._security_calls:
@@ -1223,7 +1433,7 @@ class SecurityEmitter:
                         )
                         var_name = variant["result_name"]
                         sec_name = variant["member_name"]
-                        lines.append(f"        auto {var_name} = is_complete "
+                        lines.append(f"        auto {var_name} = security_series_slot_is_new({sec_id}) "
                                      f"? {sec_name}.compute({compute_args}) "
                                      f": {sec_name}.recompute({compute_args});")
                         ta_results[(idx, variant["signature"])] = var_name
@@ -1232,6 +1442,35 @@ class SecurityEmitter:
 
             self._emit_security_rebinds(sec_id, info, lines, ta_results, indent=2, emitted_lines=lines)
             emit_security_ta(post_rebind_ta_indices)
+            returns_tuple = item.get("returns_tuple", False)
+            tuple_size = item.get("tuple_size", 0)
+            if (
+                returns_tuple
+                and tuple_size
+                and tuple_size > 0
+                and isinstance(expr_node, TupleLiteral)
+            ):
+                # A tuple body destructures into per-element scalar members
+                # ``_req_sec_{sec_id}_{i}`` (declared in ``base.py`` and reset in
+                # ``clear_security``). Assign each element individually rather
+                # than building the whole ``TupleLiteral`` (which lowers to an
+                # ``std::make_tuple(...)`` against the non-existent aggregate
+                # member ``_req_sec_{sec_id}``).
+                for i, el in enumerate(expr_node.elements):
+                    el_cpp = self._build_security_expr(
+                        sec_id,
+                        el,
+                        None,
+                        ta_results,
+                        security_mutable_names=security_mutable_names,
+                        emitted_lines=lines,
+                    )
+                    lines.append(f"        _req_sec_{sec_id}_{i} = {el_cpp};")
+                self._emit_security_ohlc_hist_pushes(sec_id, lines)
+                self._emit_security_ta_hist_pushes(sec_id, info, ta_results, lines)
+                lines.append("    }")
+                lines.append("")
+                continue
             expr_cpp = self._build_security_expr(
                 sec_id,
                 expr_node,
@@ -1256,10 +1495,8 @@ class SecurityEmitter:
                 )
             else:
                 lines.append(f"        _req_sec_{sec_id} = {expr_cpp};")
-            for field in sorted(self._security_ohlc_hist_fields_by_sec.get(sec_id, ())):
-                lines.append(
-                    f"        {self._security_ohlc_hist_series_cpp(sec_id, field)}.push(bar.{field});"
-                )
+            self._emit_security_ohlc_hist_pushes(sec_id, lines)
+            self._emit_security_ta_hist_pushes(sec_id, info, ta_results, lines)
             lines.append("    }")
             lines.append("")
 
@@ -1296,6 +1533,8 @@ class SecurityEmitter:
                     lines.append(
                         f"                {self._security_ohlc_hist_series_cpp(sec_id, field)}.clear();"
                     )
+                for name in self._security_ta_hist_series_names(sec_id):
+                    lines.append(f"                {name}.clear();")
                 lines.append("                break;")
                 continue
             if returns_tuple and tuple_size and tuple_size > 0 and isinstance(expr_node, TupleLiteral):
@@ -1318,16 +1557,21 @@ class SecurityEmitter:
                     lines.append(
                         f"                {self._security_ohlc_hist_series_cpp(sec_id, field)}.clear();"
                     )
+                for name in self._security_ta_hist_series_names(sec_id):
+                    lines.append(f"                {name}.clear();")
                 lines.append("                break;")
             else:
                 hist = self._security_ohlc_hist_fields_by_sec.get(sec_id, ())
-                if hist:
+                ta_hist_names = self._security_ta_hist_series_names(sec_id)
+                if hist or ta_hist_names:
                     lines.append(f"            case {sec_id}:")
                     lines.append(f"                _req_sec_{sec_id} = na<double>();")
                     for field in sorted(hist):
                         lines.append(
                             f"                {self._security_ohlc_hist_series_cpp(sec_id, field)}.clear();"
                         )
+                    for name in ta_hist_names:
+                        lines.append(f"                {name}.clear();")
                     lines.append("                break;")
                 else:
                     lines.append(f"            case {sec_id}: _req_sec_{sec_id} = na<double>(); break;")
@@ -1463,6 +1707,74 @@ class SecurityEmitter:
                         "request.security() OHLC history index must be a literal integer (e.g. high[1])",
                     )
 
+                # Indirect TA binding: ``v = ta.ema(close, 55)`` then
+                # ``request.security(..., v[1], ...)``. _get_ta_site below only
+                # matches the literal ta.* FuncCall node by identity, so a bare
+                # Identifier subscript target silently misses it and falls
+                # through to a chart-resolution read of the wrong (non-HTF)
+                # series. Resolve through the same global_expr_map the
+                # non-subscript Identifier path above already uses, and
+                # recurse on a synthetic Subscript over the resolved value so
+                # it re-enters this whole branch (TA site, OHLC field, or
+                # helper binding, whichever the resolved expression turns out
+                # to be) instead of duplicating that dispatch here.
+                global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
+                if (expr_node.object.name in global_expr_map
+                        and expr_node.object.name not in resolving):
+                    resolving.add(expr_node.object.name)
+                    resolved = self._build_security_expr(
+                        sec_id,
+                        Subscript(object=global_expr_map[expr_node.object.name], index=expr_node.index),
+                        ta_range,
+                        ta_results,
+                        resolving,
+                        security_mutable_names,
+                        helper_binding_stack,
+                        emitted_lines,
+                    )
+                    resolving.remove(expr_node.object.name)
+                    return resolved
+            ta_site = self._get_ta_site(expr_node.object)
+            if ta_site is not None:
+                # ``ta.<fn>(...)[k]`` inside request.security(): the inner TA call
+                # runs in the HTF (security) context and commits one value per
+                # COMPLETED HTF bar. Read the already-emitted security TA result —
+                # offset 0 reuses the current committed value (``_secval_*``),
+                # offset k>=1 reads a per-site Series that advances on
+                # ``is_complete`` (HTF-bar boundary) in ``_eval_security_N``. The
+                # buggy generic path re-lowered the inner TA to the CHART member
+                # and gated a ``_hist_call`` buffer on ``is_first_tick_`` (chart
+                # tick), so without a magnifier it advanced every chart bar and
+                # produced the chart-tf TA instead of the confirmed HTF value.
+                idx = self._ta_index_by_site_id.get(id(ta_site))
+                sig = self._security_binding_stack_signature(helper_binding_stack)
+                idx_lit = self._literal_int_for_security_index(expr_node.index)
+                if idx_lit is None:
+                    self._codegen_error(
+                        expr_node,
+                        "request.security() TA history index must be a literal integer (e.g. ta.ema(close, 55)[1])",
+                    )
+                if idx_lit == 0:
+                    # Current completed-HTF-bar value: reuse the bare-TA emission.
+                    return self._build_security_expr(
+                        sec_id,
+                        expr_node.object,
+                        ta_range,
+                        ta_results,
+                        resolving,
+                        security_mutable_names,
+                        helper_binding_stack,
+                        emitted_lines,
+                    )
+                member_name = self._security_ta_variant_names.get(
+                    (sec_id, idx, sig),
+                    f"_sec{sec_id}_{ta_site.member_name}",
+                )
+                hist = self._security_ta_hist_series_cpp(member_name)
+                # ta(...)[k] -> hist[k-1]: hist[0] is the prior completed HTF bar
+                # (current value not yet pushed — push happens after this assign).
+                return f"{hist}[{idx_lit - 1}]"
+
         if isinstance(expr_node, BinOp):
             left = self._build_security_expr(
                 sec_id, expr_node.left, ta_range, ta_results, resolving, security_mutable_names, helper_binding_stack, emitted_lines
@@ -1558,7 +1870,7 @@ class SecurityEmitter:
                 helper_binding_stack,
                 emitted_lines,
             )
-            return f"(is_complete ? {sec_name}.compute({compute_args}) : {sec_name}.recompute({compute_args}))"
+            return f"(security_series_slot_is_new({sec_id}) ? {sec_name}.compute({compute_args}) : {sec_name}.recompute({compute_args}))"
 
         result = self._visit_expr(expr_node)
         return self._rewrite_security_cpp(result, sec_id, security_mutable_names, helper_binding_stack)

package/pineforge_codegen/codegen/ta.py

@@ -295,4 +295,7 @@ class TaSiteHelper:
             return True
         except ValueError:
             pass
-        return val in ("true", "false", "0", "0.0", "na<double>()")
+        return val in (
+            "true", "false", "0", "0.0",
+            "na<double>()", "na<int>()", "na<int64_t>()", "na<bool>()",
+        )

package/pineforge_codegen/codegen/tables.py

@@ -255,7 +255,12 @@ TA_TUPLE_FIELDS = {
 # must be promoted to ``int64_t`` so the ``na`` sentinel (``INT64_MIN``)
 # survives — narrowing to 32-bit ``int`` collapses it to ``0`` and breaks
 # ``is_na<int>`` detection.
-INT64_BUILTINS = {"time", "time_close", "timestamp", "time_tradingday"}
+INT64_BUILTINS = {"time", "time_close", "timenow", "timestamp", "time_tradingday"}
+
+# Subset of INT64_BUILTINS spelled as a bare identifier (no call args) in Pine.
+# ``entryTime := time`` parses the RHS as an ``Identifier`` named ``time`` (not a
+# ``FuncCall``), so int64 promotion must match these by identifier name too.
+INT64_BUILTIN_IDENTIFIERS = {"time", "time_close", "timenow"}
 
 PINE_TYPE_TO_CPP = {
     "int": "int", "float": "double", "bool": "bool", "string": "std::string",
@@ -263,15 +268,66 @@ PINE_TYPE_TO_CPP = {
     PineType.STRING: "std::string", PineType.NA: "double",
     PineType.UNKNOWN: "double", PineType.VOID: "double",
     PineType.COLOR: "int",
+    # Drawing-objects-as-data: the value-view handle structs (see
+    # drawing.hpp). Explicit-hint decls (``var line x``), UDT-method drawing
+    # params, and ``_type_for_decl`` resolve through here.
+    "line": "Line", "box": "Box", "label": "Label",
+    "linefill": "Linefill", "chart.point": "ChartPoint",
+}
+
+# ---------------------------------------------------------------------------
+# Drawing-objects-as-data (spec §4.1)
+# ---------------------------------------------------------------------------
+# Pine drawing type name -> C++ handle struct (pineforge/drawing.hpp).
+# ``table`` / ``polyline`` are DELIBERATELY absent — they stay 100% no-op
+# (kept in SKIP_NAMESPACES / SKIP_VAR_TYPES / _DRAWING_TYPES_INIT).
+DRAWING_TYPE_TO_CPP = {
+    "line": "Line", "box": "Box", "label": "Label",
+    "linefill": "Linefill", "chart.point": "ChartPoint",
 }
+# Function-call namespaces routed to the per-type arena dispatch.
+DRAWING_NS = {"line", "box", "label", "linefill"}
+# Constant member reads (``line.style_solid`` -> "0"). chart.point/linefill
+# carry no style constants.
+DRAWING_STYLE_NS = {"line", "box", "label"}
+# Per-type arena member name on the generated strategy.
+DRAWING_ARENA = {
+    "line": "_pf_lines_", "box": "_pf_boxes_",
+    "label": "_pf_labels_", "linefill": "_pf_linefills_",
+}
+
+# Pine typed array constructors for drawing handles — ``array.new_line(...)``
+# is the typed alias of ``array.new<line>(...)`` (and likewise for box/label/
+# linefill). Maps the constructor name to the drawing element type name, so the
+# element TypeSpec resolves to the C++ handle struct (Line/Box/Label/Linefill).
+ARRAY_DRAWING_NEW_CTORS = {
+    "new_line": "line", "new_box": "box",
+    "new_label": "label", "new_linefill": "linefill",
+}
+# Pine array methods whose C++ lowering is void (or a non-scalar iterator) and
+# whose Pine semantics is mutate-in-place: a function whose body ends in one of
+# these returns void, so the codegen must emit it as a statement + default
+# return rather than ``return arr.clear();`` / ``return arr.insert(...);``.
+ARRAY_VOID_METHODS = frozenset({
+    "push", "unshift", "insert", "clear", "set", "fill",
+    "sort", "reverse", "concat",
+})
+# All recognised ``array.new_*`` scalar+drawing constructor names (``new`` itself
+# is template-form and handled separately).
+ARRAY_NEW_CTORS = frozenset(
+    {"new_float", "new_int", "new_bool", "new_string"} | set(ARRAY_DRAWING_NEW_CTORS)
+)
 
 SKIP_FUNC_NAMES = {
     "plot", "plotshape", "plotchar", "plotcandle", "plotbar", "plotarrow",
     "fill", "hline", "barcolor", "bgcolor", "alert", "alertcondition",
 }
+# line / box / label / linefill REMOVED — they now route to real drawing
+# codegen (gated on _uses_drawing). table / polyline / chart / display / size
+# / position stay no-op.
 SKIP_NAMESPACES = {
-    "table", "label", "line", "box", "polyline", "chart",
-    "linefill", "display", "size", "position",
+    "table", "polyline", "chart",
+    "display", "size", "position",
 }
 SKIP_VAR_TYPES = {"table"}
 
@@ -382,14 +438,14 @@ ORDER_DIRECTION_MAP = {
 
 # Methods called as ``array.method(arr, ...)`` or ``arr.method(...)``.
 ARRAY_METHODS = {
-    "get":       lambda a, args: f"{a}[{args[0]}]",
-    "set":       lambda a, args: f"{a}[{args[0]}] = {args[1]}",
+    "get":       lambda a, args: f"{a}[({args[0]})]",
+    "set":       lambda a, args: f"{a}[({args[0]})] = {args[1]}",
     "push":      lambda a, args: f"{a}.push_back({args[0]})",
     "unshift":   lambda a, args: f"{a}.insert({a}.begin(), {args[0]})",
     "insert":    lambda a, args: f"{a}.insert({a}.begin() + (int)({args[0]}), {args[1]})",
     "pop":       lambda a, args: f"[&](){{ auto v={a}.back(); {a}.pop_back(); return v; }}()",
     "shift":     lambda a, args: f"[&](){{ auto v={a}.front(); {a}.erase({a}.begin()); return v; }}()",
-    "remove":    lambda a, args: f"[&](){{ auto v={a}[{args[0]}]; {a}.erase({a}.begin()+(int)({args[0]})); return v; }}()",
+    "remove":    lambda a, args: f"[&](){{ auto v={a}[({args[0]})]; {a}.erase({a}.begin()+(int)({args[0]})); return v; }}()",
     "first":     lambda a, args: f"{a}.front()",
     "last":      lambda a, args: f"{a}.back()",
     "size":      lambda a, args: f"(double){a}.size()",
@@ -435,7 +491,7 @@ ARRAY_METHODS = {
     "mode":      lambda a, args: f"[&](){{ std::unordered_map<double,int> m; for(auto v:{a})m[v]++; double best=0; int bc=0; for(auto&[v,c]:m)if(c>bc||(c==bc&&v<best)){{bc=c;best=v;}} return best; }}()",
     "percentile_linear_interpolation": lambda a, args: f"[&](){{ auto c={a}; std::sort(c.begin(),c.end()); double k=({args[0]}/100.0)*c.size()-0.5; int i=std::max(0,(int)k); double f=k-i; if(i+1>=(int)c.size()) return c.back(); return c[i]*(1-f)+c[i+1]*f; }}()",
     "percentile_nearest_rank": lambda a, args: f"[&](){{ auto c={a}; std::sort(c.begin(),c.end()); int r=(int)std::ceil(({args[0]}/100.0)*c.size()); return c[std::min(r-1,(int)c.size()-1)]; }}()",
-    "percentrank": lambda a, args: f"[&](){{ if({a}.size()<=1) return na<double>(); double v={a}[{args[0]}]; if(std::isnan(v)) return na<double>(); int le=0; for(auto x:{a}) if(!std::isnan(x) && x<=v) le++; return (double)(le-1)/({a}.size()-1)*100.0; }}()",
+    "percentrank": lambda a, args: f"[&](){{ if({a}.size()<=1) return na<double>(); double v={a}[({args[0]})]; if(std::isnan(v)) return na<double>(); int le=0; for(auto x:{a}) if(!std::isnan(x) && x<=v) le++; return (double)(le-1)/({a}.size()-1)*100.0; }}()",
     "abs":       lambda a, args: f"[&](){{ std::vector<double> r; for(auto v:{a})r.push_back(std::abs(v)); return r; }}()",
     "join":      lambda a, args: "[&](){{ std::string r; for(size_t i=0;i<{arr}.size();i++){{ if(i>0)r+={sep}; r+=std::to_string({arr}[i]); }} return r; }}()".format(arr=a, sep=args[0] if args else 'std::string(",")'),
     "standardize": lambda a, args: f"[&](){{ double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); s=std::sqrt(s/{a}.size()); std::vector<double> r; for(auto v:{a})r.push_back(s==0?1.0:(v-m)/s); return r; }}()",