@pineforge/codegen-pyodide 0.10.2 → 0.10.4

package/pineforge_codegen/codegen/tables.py

@@ -222,6 +222,18 @@ TA_COMPUTE_ARGS = {
     "max": [0], "min": [0], "rci": [0],
 }
 
+# issue #178: ta.atr / ta.tr read their true range against the previous
+# CHART bar's close (close[1]) even when the call site executes sparsely —
+# the RMA advances on the executions only (TradingView pin 2026-09-06,
+# lab tv i178-sparse-atr-sense, BINANCE:BTCUSDT 60: 398/398 executions equal
+# the chart-close model, 0/398 the previous-execution model). The chart
+# context therefore passes ``BacktestEngine::prev_chart_close()`` as the
+# 4th compute() argument (the engine's always-on tracker); the per-object
+# prev_close (3-arg form) remains for request.security contexts, whose
+# ``bar.`` rewrite has no chart-close tracker.
+TA_CHART_PREV_CLOSE = {"atr", "tr"}
+TA_CHART_PREV_CLOSE_ARG = "prev_chart_close()"
+
 # TA functions whose ``.compute()`` always receives bar OHLC implicitly.
 TA_IMPLICIT_COMPUTE_FULL = {
     "atr": "current_bar_.high, current_bar_.low, current_bar_.close",
@@ -248,12 +260,17 @@ TA_IMPLICIT_APPEND = {
     "kc": "current_bar_.high, current_bar_.low, current_bar_.close",
     "mfi": "current_bar_.volume",
     "kcw": "current_bar_.high, current_bar_.low, current_bar_.close",
-    # ta.vwap needs the bar timestamp so the runtime can detect Daily
-    # anchor boundaries (Pine v6 default for `ta.vwap(source)` resets
-    # the cumulator at every UTC-day change).
-    "vwap": "current_bar_.volume, current_bar_.timestamp",
+    # ta.vwap needs the bar timestamp plus the symbol clock (syminfo.timezone
+    # + syminfo.session) so the runtime can detect Daily anchor boundaries:
+    # Pine v6's default `anchor = timeframe.change("1D")` is the SYMBOL's
+    # daily bar (17:00 ET on OANDA forex, 09:30 ET RTH on NASDAQ equities,
+    # 00:00 UTC on a 24x7 UTC symbol). The engine's tz/session overload
+    # reduces to the UTC-day integer math for the default UTC/24x7 syminfo.
+    # The tail is wrapped in PF_VWAP_SESSION_ANCHOR_ARGS (prelude, emit_top.py)
+    # so it compiles out against engines without the overload.
+    "vwap": "current_bar_.volume, current_bar_.timestamp PF_VWAP_SESSION_ANCHOR_ARGS(syminfo_.timezone, syminfo_.session)",
     # 3-arg bands form uses the same implicit append as the scalar form.
-    "vwap_bands": "current_bar_.volume, current_bar_.timestamp",
+    "vwap_bands": "current_bar_.volume, current_bar_.timestamp PF_VWAP_SESSION_ANCHOR_ARGS(syminfo_.timezone, syminfo_.session)",
 }
 
 # Tuple field names for TA functions returning tuples.

package/pineforge_codegen/codegen/types.py

@@ -135,8 +135,9 @@ class TypeInferer:
         if spec is None:
             return "double"
         if spec.kind == "primitive":
-            return {"float": "double", "int": "int", "bool": "bool",
-                    "string": "std::string", "color": "int"}.get(spec.name or "float", "double")
+            return {"float": "double", "int": "int", "int64": "int64_t",
+                    "bool": "bool", "string": "std::string",
+                    "color": "int"}.get(spec.name or "float", "double")
         if spec.kind == "udt" and spec.name:
             # Drawing handle structs (P1): map BEFORE the _udt_defs check so
             # array<line> -> std::vector<Line> and scalar line -> Line instead
@@ -269,6 +270,175 @@ class TypeInferer:
         return self._default_for_type(cpp_type)
 
     def _collection_spec_for_name(self, name: str) -> TypeSpec | None:
+        """``_collection_spec_for_name_raw`` with the wide-int element applied
+        (``_widen_array_spec_for_name``): an ``array<int>`` that stores epoch
+        milliseconds resolves as ``std::vector<int64_t>`` everywhere it is
+        read, declared or passed."""
+        return self._widen_array_spec_for_name(
+            name, self._collection_spec_for_name_raw(name)
+        )
+
+    # Element-returning array reads whose result carries the receiver's wide
+    # provenance (``_expr_returns_wide_int``).
+    _WIDE_ARRAY_ELEMENT_READS = frozenset({
+        "get", "first", "last", "pop", "shift", "remove", "max", "min",
+    })
+    # Writers whose VALUE argument decides whether an int array is wide:
+    # name -> (functional-form value index, method-form value index).
+    _ARRAY_ELEMENT_WRITERS = {
+        "push": (1, 0), "unshift": (1, 0), "set": (2, 1), "insert": (2, 1),
+        "fill": (1, 0),
+    }
+
+    @staticmethod
+    def _int_fits_int32(value: int) -> bool:
+        return -(1 << 31) <= value < (1 << 31)
+
+    def _pure_int_literal_value(self, node) -> int | None:
+        """Exact value of an expression built only from int literals and
+        ``+ - *`` / unary minus, else ``None``.
+
+        Pine ``int`` is 64-bit: ``90 * 24 * 60 * 60 * 1000`` (three months in
+        milliseconds) is 7 776 000 000 on TradingView. Emitted as C++ ``int``
+        literal arithmetic the same product overflows (wraps to -813 934 592),
+        so a ``(time - t0) > threeMonths`` expiry fires on every bar (round 8
+        family U: latibonit15 execution-signals-confluence, six lanes; lab tv
+        u-lati-levels-nq15 vs the engine, 2026-09-05). Folding the literal
+        subtree in Python keeps the exact value; the caller emits it as a
+        64-bit literal only when it does not fit ``int32`` so every in-range
+        expression is byte-identical to before.
+        """
+        if isinstance(node, NumberLiteral):
+            return node.value if isinstance(node.value, int) and not isinstance(node.value, bool) else None
+        if isinstance(node, UnaryOp) and node.op == "-":
+            inner = self._pure_int_literal_value(node.operand)
+            return -inner if inner is not None else None
+        if isinstance(node, BinOp) and node.op in ("+", "-", "*"):
+            left = self._pure_int_literal_value(node.left)
+            if left is None:
+                return None
+            right = self._pure_int_literal_value(node.right)
+            if right is None:
+                return None
+            if node.op == "+":
+                return left + right
+            if node.op == "-":
+                return left - right
+            return left * right
+        return None
+
+    def _literal_overflows_int32(self, node) -> bool:
+        value = self._pure_int_literal_value(node)
+        return value is not None and not self._int_fits_int32(value)
+
+    def _array_receiver_and_value(self, call):
+        """``(receiver_name, value_node)`` of an element-writing array call in
+        either form (``array.push(a, v)`` / ``a.push(v)``), else ``None``."""
+        if not isinstance(call, FuncCall):
+            return None
+        func_name, namespace = self._resolve_callee(call.callee)
+        if func_name not in self._ARRAY_ELEMENT_WRITERS:
+            return None
+        functional_idx, method_idx = self._ARRAY_ELEMENT_WRITERS[func_name]
+        if namespace == "array":
+            receiver = call.args[0] if call.args else call.kwargs.get("id")
+            value = (call.args[functional_idx]
+                     if len(call.args) > functional_idx
+                     else call.kwargs.get("value"))
+        elif (isinstance(call.callee, MemberAccess)
+              and isinstance(call.callee.object, Identifier)):
+            receiver = call.callee.object
+            value = (call.args[method_idx]
+                     if len(call.args) > method_idx
+                     else call.kwargs.get("value"))
+        else:
+            return None
+        if not isinstance(receiver, Identifier) or value is None:
+            return None
+        return receiver.name, value
+
+    def _wide_int_array_names(self) -> set[str]:
+        """Names of int arrays that hold a wide integer: one that receives an
+        epoch-millisecond value (``time``, ``time_close``, ``timestamp(...)``,
+        a wide callable result, ...) through ``array.push`` / ``unshift`` /
+        ``set`` / ``insert`` / ``fill``, or is built by ``array.new_int`` /
+        ``array.new<int>`` / ``array.from`` from one. Their element type is
+        ``int64_t`` (TypeSpec primitive ``int64``): Pine's ``int`` holds the
+        epoch, ``std::vector<int>`` truncates it. Cached on the instance."""
+        cached = getattr(self, "_wide_int_array_cache", None)
+        if cached is not None:
+            return cached
+        # The scan below asks ``_expr_returns_wide_int``, whose receiver typing
+        # resolves collection specs through ``_collection_spec_for_name`` and so
+        # back here: publish the (growing) set first so the recursion reads the
+        # partial answer instead of re-entering, then iterate to the fixpoint so
+        # an array filled from another wide array's elements widens too.
+        names: set[str] = set()
+        self._wide_int_array_cache = names
+
+        def scan(nodes, owner_info):
+            for child in nodes:
+                if isinstance(child, FuncCall):
+                    pair = self._array_receiver_and_value(child)
+                    if pair is not None and self._expr_returns_wide_int(
+                        pair[1], owner_info, set(), None
+                    ):
+                        names.add(pair[0])
+                    continue
+                target = None
+                value = None
+                if isinstance(child, VarDecl):
+                    target, value = child.name, child.value
+                elif (isinstance(child, Assignment)
+                      and isinstance(child.target, Identifier)):
+                    target, value = child.target.name, child.value
+                if target is None or not isinstance(value, FuncCall):
+                    continue
+                fn, ns = self._resolve_callee(value.callee)
+                if ns != "array":
+                    continue
+                candidates = []
+                if fn in ("new_int", "new"):
+                    if fn == "new":
+                        targs = (self._template_args_from_call(value)
+                                 if hasattr(value, "annotations") else [])
+                        if not targs or targs[0] != "int":
+                            continue
+                    if len(value.args) > 1:
+                        candidates.append(value.args[1])
+                    if "initial_value" in value.kwargs:
+                        candidates.append(value.kwargs["initial_value"])
+                elif fn == "from":
+                    candidates = list(value.args)
+                if any(self._expr_returns_wide_int(c, owner_info, set(), None)
+                       for c in candidates):
+                    names.add(target)
+
+        ast = getattr(self.ctx, "ast", None)
+        for _round in range(8):
+            before = len(names)
+            if ast is not None:
+                scan(self._walk_ast(ast), None)
+            for info in getattr(self.ctx, "func_infos", ()):
+                node = getattr(info, "node", None)
+                if node is not None:
+                    scan(self._walk_ast_list(node.body), info)
+            if len(names) == before:
+                break
+        return names
+
+    def _widen_array_spec_for_name(self, name, spec):
+        """``array<int>`` -> ``array<int64>`` when ``name`` is a wide int
+        array; every other spec (and ``None``) passes through unchanged."""
+        if (spec is None or spec.kind != "array" or spec.element is None
+                or spec.element.kind != "primitive"
+                or spec.element.name != "int"):
+            return spec
+        if name in self._wide_int_array_names():
+            return TypeSpec.array(TypeSpec.primitive("int64"))
+        return spec
+
+    def _collection_spec_for_name_raw(self, name: str) -> TypeSpec | None:
         """Resolve collection metadata with lexical precedence.
 
         Source-ordered callable locals shadow loop bindings and parameters once
@@ -417,7 +587,9 @@ class TypeInferer:
                     return TypeSpec.primitive("string")
                 if node.op == "/" or left.name == "float" or right.name == "float":
                     return TypeSpec.primitive("float")
-                if left.name == "int" and right.name == "int":
+                if left.name in ("int", "int64") and right.name in ("int", "int64"):
+                    if "int64" in (left.name, right.name):
+                        return TypeSpec.primitive("int64")
                     return TypeSpec.primitive("int")
             return None
         spec = self._type_spec_from_expr(node)
@@ -976,7 +1148,7 @@ class TypeInferer:
                 "percentrank", "abs", "standardize", "covariance", "binary_search",
                 "binary_search_leftmost", "binary_search_rightmost", "sort_indices",
             }
-            if method in numeric_only and elem_cpp not in ("double", "int"):
+            if method in numeric_only and elem_cpp not in ("double", "int", "int64_t"):
                 self._codegen_error(
                     None,
                     f"array.{method} requires a numeric array",
@@ -1187,7 +1359,7 @@ class TypeInferer:
         # truly untyped slot may consult the per-callsite specialization map.
         spec = declared_spec
         if spec is not None and spec.kind == "primitive":
-            if spec.name == "int":
+            if spec.name in ("int", "int64"):
                 return "int64_t"
             if spec.name == "bool":
                 return "bool"
@@ -1217,7 +1389,7 @@ class TypeInferer:
         specs = list(getattr(func_info, "param_type_specs", ()) or ())
         spec = specs[index] if index < len(specs) else None
         if spec is not None and spec.kind == "primitive":
-            if spec.name == "int":
+            if spec.name in ("int", "int64"):
                 return "int64_t"
             if spec.name == "bool":
                 return "bool"
@@ -1352,8 +1524,25 @@ class TypeInferer:
             return self._expr_is_int64_builtin(expr)
         if self._expr_is_int64_builtin(expr):
             return True
+        if isinstance(expr, (BinOp, UnaryOp)) and self._literal_overflows_int32(expr):
+            # ``90 * 24 * 60 * 60 * 1000``: an int-literal product beyond
+            # int32 is a 64-bit value in Pine (``_pure_int_literal_value``).
+            return True
         if isinstance(expr, FuncCall):
             func_name, namespace = self._resolve_callee(expr.callee)
+            if func_name in self._WIDE_ARRAY_ELEMENT_READS:
+                # An element read off a wide int array (``array.get(times, i)``
+                # / ``times.get(i)``) carries the epoch: the destination must
+                # not narrow it (``_wide_int_array_names``).
+                receiver = None
+                if namespace == "array":
+                    receiver = expr.args[0] if expr.args else expr.kwargs.get("id")
+                elif (isinstance(expr.callee, MemberAccess)
+                      and isinstance(expr.callee.object, Identifier)):
+                    receiver = expr.callee.object
+                if (isinstance(receiver, Identifier)
+                        and receiver.name in self._wide_int_array_names()):
+                    return True
             if namespace is None and func_name in {
                 "int",
                 "float",

package/pineforge_codegen/codegen/visit_call.py

@@ -222,6 +222,55 @@ def _parse_pine_datestring_ms(text: str) -> int | None:
     return int(dt.timestamp() * 1000)
 
 
+def _timestamp_calendar_lambda(tz: str, yr: str, mo: str, dy: str,
+                               hr: str, mn: str, sc: str) -> str:
+    """Inline C++ lambda turning calendar fields in timezone ``tz`` into Unix ms.
+
+    Shared by both ``timestamp(...)`` overloads: the tz-first form passes the
+    explicit tz expression, the numeric form passes ``syminfo_.timezone``
+    (Pine v6: "If the timezone argument is not specified, the function uses
+    the exchange time zone (syminfo.timezone)"). UTC / "" / "Etc/UTC" stays on
+    the ``timegm`` fast path — byte-identical to the historical numeric
+    emission for UTC symbols; anything else takes the mutex-guarded
+    setenv+``mktime`` block with ``tm_isdst = -1`` so DST is resolved by the
+    tz database. A per-call-site thread_local memo keeps the setenv churn to
+    one flip per distinct (tz, fields) tuple.
+    """
+    return (
+        f"[&]() -> int64_t {{ "
+        f"std::string _tz = pineforge::normalize_timezone_for_posix(({tz})); "
+        f"int _yr = ({yr}); int _mo = ({mo}); int _dy = ({dy}); "
+        f"int _hr = ({hr}); int _min = ({mn}); int _sc = ({sc}); "
+        f"static thread_local std::string _last_tz; "
+        f"static thread_local int _last_yr = -1, _last_mo = -1, _last_dy = -1, _last_hr = -1, _last_min = -1, _last_sc = -1; "
+        f"static thread_local int64_t _last_res = -1; "
+        f"if (_last_res != -1 && _last_tz == _tz && _last_yr == _yr && _last_mo == _mo && _last_dy == _dy && _last_hr == _hr && _last_min == _min && _last_sc == _sc) {{ "
+        f"return _last_res; "
+        f"}} "
+        f"struct tm t = {{}}; "
+        f"t.tm_year = _yr - 1900; t.tm_mon = _mo - 1; "
+        f"t.tm_mday = _dy; t.tm_hour = _hr; t.tm_min = _min; t.tm_sec = _sc; "
+        f"t.tm_isdst = -1; "
+        f"int64_t _res; "
+        f"if (_tz.empty() || _tz == \"UTC\" || _tz == \"Etc/UTC\") {{ "
+        f"_res = (int64_t)timegm(&t) * 1000; "
+        f"}} else {{ "
+        f"static std::mutex _pf_ts_mu; "
+        f"std::lock_guard<std::mutex> _pf_ts_mu_lock(_pf_ts_mu); "
+        f"const char* _old = std::getenv(\"TZ\"); "
+        f"std::string _old_tz = _old ? _old : \"\"; bool _had_old = (_old != nullptr); "
+        f"::setenv(\"TZ\", _tz.c_str(), 1); ::tzset(); "
+        f"_res = (int64_t)mktime(&t) * 1000; "
+        f"if (_had_old) {{ ::setenv(\"TZ\", _old_tz.c_str(), 1); }} "
+        f"else {{ ::unsetenv(\"TZ\"); }} ::tzset(); "
+        f"}} "
+        f"_last_tz = _tz; _last_yr = _yr; _last_mo = _mo; _last_dy = _dy; _last_hr = _hr; _last_min = _min; _last_sc = _sc; "
+        f"_last_res = _res; "
+        f"return _res; "
+        f"}}()"
+    )
+
+
 class CallVisitor:
     """Function-call dispatch visitor methods shared across the codegen.
 
@@ -1371,13 +1420,21 @@ class CallVisitor:
         # ta.* calls -> member.compute(...)
         site = self._get_ta_site(node)
         if site is not None:
+            # A top-level lazy-edge site already evaluated for this bar in a
+            # ``_pf_every_bar_ta_N`` local (see ``_lazy_edge_ta_hoist_plan``):
+            # read it instead of stepping the indicator again.
+            hoisted = self._hoisted_ta_values.get(id(node))
+            if hoisted is not None:
+                return hoisted
             compute_args = self._ta_compute_args_for_site(site)
             ta_mem = self._ta_member_name(site)
             uses_precalc = self._ta_site_uses_precalc(site)
             if getattr(self, "_precalc_loop_active", False) and uses_precalc:
                 return f"_precalc_{ta_mem}[i]"
-            if self._is_lazy_saturated_roc3_site(site):
-                return self._lazy_saturated_roc3_expr(site)
+            if id(node) in getattr(self, "_lazy_source_clock_by_node", {}):
+                # change/mom/roc below a top-level lazy edge: TradingView reads
+                # the call's own held ``source[length]`` (see ``ta.py``).
+                return self._lazy_source_clock_expr(site, node)
             if uses_precalc:
                 return (
                     f"(_use_precalc ? _precalc_{ta_mem}[bar_index_] : "
@@ -1498,6 +1555,12 @@ class CallVisitor:
         if namespace == "array":
             if func_name in ("new", "new_float", "new_int", "new_bool", "new_string") or func_name in ARRAY_DRAWING_NEW_CTORS:
                 spec = self._type_spec_from_expr(node) or TypeSpec.array(TypeSpec.primitive("float"))
+                # The constructor of a wide int array (``_wide_int_array_names``)
+                # must spell the declared ``std::vector<int64_t>``: the
+                # declaration site names its target here.
+                target = getattr(self, "_array_ctor_target_name", None)
+                if target is not None:
+                    spec = self._widen_array_spec_for_name(target, spec)
                 cpp_type = self._type_spec_to_cpp(spec)
                 elem_spec = spec.element if spec.element is not None else TypeSpec.primitive("float")
                 init_default = self._default_for_spec(elem_spec)
@@ -1511,6 +1574,9 @@ class CallVisitor:
                 return f"{cpp_type}()"
             if func_name == "from":
                 spec = self._type_spec_from_expr(node) or TypeSpec.array(TypeSpec.primitive("float"))
+                target = getattr(self, "_array_ctor_target_name", None)
+                if target is not None:
+                    spec = self._widen_array_spec_for_name(target, spec)
                 elems = ", ".join(self._visit_expr(a) for a in node.args)
                 return f"{self._type_spec_to_cpp(spec)}{{{elems}}}"
             # Method calls: array.method(arr, args...)
@@ -1722,22 +1788,51 @@ class CallVisitor:
             return f"pine_{func_name}((int64_t)({ts_arg}), {tz_arg})"
 
         # time(timeframe) or time(timeframe, session[, tz])
+        #
+        # Timezone of the SESSION argument (Pine v6 reference): "Timezone of
+        # the session argument. Can only be used when a session is
+        # specified. Optional. The default is syminfo.timezone." So a tz-less
+        # ``time(tf, "0930-1600")`` reads the window in the EXCHANGE timezone
+        # (America/New_York for NASDAQ/OANDA symbols), not UTC. We keep the
+        # tz slot empty (the engine's tf-open/close path is unchanged and an
+        # explicit tz still wins) and hand the engine ``syminfo_.timezone`` as
+        # the trailing session-default — the same field the tz-less
+        # hour()/minute()/dayofweek() forms above resolve against, which the
+        # harness populates from runtime_overrides.timezone. For the corpus'
+        # crypto data it is "UTC", which keeps that lane byte-identical.
+        #
+        # Composition (cand/symbol-r5): the engine's 7-arg pine_time /
+        # pine_time_close take (..., script_tf_, syminfo_.timezone,
+        # syminfo_.session). syminfo_.timezone is the tz-less session default
+        # above; the pair also lets a D/W/M `tf` WITHOUT a valid session
+        # resolve to the SYMBOL's session-day bar open (17:00 ET on OANDA
+        # forex, 09:30 ET RTH on equities, 00:00 UTC on 24x7) instead of a
+        # UTC calendar floor. A valid session keeps the explicit-tz-else-UTC
+        # floor. The pair is wrapped in PF_PINE_TIME_SESSION_DAY_ARGS (prelude,
+        # emit_top.py): it expands to ``, syminfo_.timezone, syminfo_.session``
+        # only when the engine header defines PF_PINE_TIME_HAS_SESSION_DAY and
+        # to nothing against the base engine (legacy 5-arg call), so the same
+        # generated.cpp builds in every lab-experiment cell.
+        #
         if func_name == "time" and namespace is None and (node.args or node.kwargs):
             args = _merge_kwargs(node.args, node.kwargs, sigs.get_param_names(None, "time"), self._visit_expr)
             tf_e = args[0] if len(args) > 0 else 'script_tf_'
             sess = args[1] if len(args) > 1 else 'std::string("")'
             tz_e = args[2] if len(args) > 2 else 'std::string("")'
             return (
-                f"pine_time(current_bar_.timestamp, {tf_e}, {sess}, {tz_e}, script_tf_)"
+                f"pine_time(current_bar_.timestamp, {tf_e}, {sess}, {tz_e}, script_tf_"
+                " PF_PINE_TIME_SESSION_DAY_ARGS(syminfo_.timezone, syminfo_.session))"
             )
-        # time_close(timeframe) or time_close(tf, session, tz)
+        # time_close(timeframe) or time_close(tf, session, tz) — same
+        # session-tz default as time() above.
         if func_name == "time_close" and namespace is None and (node.args or node.kwargs):
             args = _merge_kwargs(node.args, node.kwargs, sigs.get_param_names(None, "time_close"), self._visit_expr)
             tf_e = args[0] if len(args) > 0 else 'script_tf_'
             sess = args[1] if len(args) > 1 else 'std::string("")'
             tz_e = args[2] if len(args) > 2 else 'std::string("")'
             return (
-                f"pine_time_close(current_bar_.timestamp, {tf_e}, {sess}, {tz_e}, script_tf_)"
+                f"pine_time_close(current_bar_.timestamp, {tf_e}, {sess}, {tz_e}, script_tf_"
+                " PF_PINE_TIME_SESSION_DAY_ARGS(syminfo_.timezone, syminfo_.session))"
             )
 
         # timestamp(year, month, day, hour, minute) → Unix ms
@@ -1798,39 +1893,7 @@ class CallVisitor:
                 hr = args[4] if len(args) > 4 else "0"
                 mn = args[5] if len(args) > 5 else "0"
                 sc = args[6] if len(args) > 6 else "0"
-                return (
-                    f"[&]() -> int64_t {{ "
-                    f"std::string _tz = pineforge::normalize_timezone_for_posix(({tz})); "
-                    f"int _yr = ({yr}); int _mo = ({mo}); int _dy = ({dy}); "
-                    f"int _hr = ({hr}); int _min = ({mn}); int _sc = ({sc}); "
-                    f"static thread_local std::string _last_tz; "
-                    f"static thread_local int _last_yr = -1, _last_mo = -1, _last_dy = -1, _last_hr = -1, _last_min = -1, _last_sc = -1; "
-                    f"static thread_local int64_t _last_res = -1; "
-                    f"if (_last_res != -1 && _last_tz == _tz && _last_yr == _yr && _last_mo == _mo && _last_dy == _dy && _last_hr == _hr && _last_min == _min && _last_sc == _sc) {{ "
-                    f"return _last_res; "
-                    f"}} "
-                    f"struct tm t = {{}}; "
-                    f"t.tm_year = _yr - 1900; t.tm_mon = _mo - 1; "
-                    f"t.tm_mday = _dy; t.tm_hour = _hr; t.tm_min = _min; t.tm_sec = _sc; "
-                    f"t.tm_isdst = -1; "
-                    f"int64_t _res; "
-                    f"if (_tz.empty() || _tz == \"UTC\" || _tz == \"Etc/UTC\") {{ "
-                    f"_res = (int64_t)timegm(&t) * 1000; "
-                    f"}} else {{ "
-                    f"static std::mutex _pf_ts_mu; "
-                    f"std::lock_guard<std::mutex> _pf_ts_mu_lock(_pf_ts_mu); "
-                    f"const char* _old = std::getenv(\"TZ\"); "
-                    f"std::string _old_tz = _old ? _old : \"\"; bool _had_old = (_old != nullptr); "
-                    f"::setenv(\"TZ\", _tz.c_str(), 1); ::tzset(); "
-                    f"_res = (int64_t)mktime(&t) * 1000; "
-                    f"if (_had_old) {{ ::setenv(\"TZ\", _old_tz.c_str(), 1); }} "
-                    f"else {{ ::unsetenv(\"TZ\"); }} ::tzset(); "
-                    f"}} "
-                    f"_last_tz = _tz; _last_yr = _yr; _last_mo = _mo; _last_dy = _dy; _last_hr = _hr; _last_min = _min; _last_sc = _sc; "
-                    f"_last_res = _res; "
-                    f"return _res; "
-                    f"}}()"
-                )
+                return _timestamp_calendar_lambda(tz, yr, mo, dy, hr, mn, sc)
             else:
                 # Numeric form requires year, month, and day (hour/minute/
                 # second default to 0). Anything shorter used to emit "0".
@@ -1855,24 +1918,16 @@ class CallVisitor:
                 hr = args[3] if len(args) > 3 else "0"
                 mn = args[4] if len(args) > 4 else "0"
                 sc = args[5] if len(args) > 5 else "0"
-                return (
-                    f"[&]() -> int64_t {{ "
-                    f"int _yr = ({yr}); int _mo = ({mo}); int _dy = ({dy}); "
-                    f"int _hr = ({hr}); int _min = ({mn}); int _sc = ({sc}); "
-                    f"static thread_local int _last_yr = -1, _last_mo = -1, _last_dy = -1, _last_hr = -1, _last_min = -1, _last_sc = -1; "
-                    f"static thread_local int64_t _last_res = -1; "
-                    f"if (_last_res != -1 && _last_yr == _yr && _last_mo == _mo && _last_dy == _dy && _last_hr == _hr && _last_min == _min && _last_sc == _sc) {{ "
-                    f"return _last_res; "
-                    f"}} "
-                    f"struct tm t = {{}}; "
-                    f"t.tm_year = _yr - 1900; t.tm_mon = _mo - 1; "
-                    f"t.tm_mday = _dy; t.tm_hour = _hr; t.tm_min = _min; t.tm_sec = _sc; "
-                    f"int64_t _res = (int64_t)timegm(&t) * 1000; "
-                    f"_last_yr = _yr; _last_mo = _mo; _last_dy = _dy; _last_hr = _hr; _last_min = _min; _last_sc = _sc; "
-                    f"_last_res = _res; "
-                    f"return _res; "
-                    f"}}()"
-                )
+                # No timezone argument: Pine resolves the calendar fields in
+                # syminfo.timezone (the EXCHANGE tz), not UTC. This used to be
+                # a bare timegm(), which put e.g. timestamp(y, m, d, 8, 0, 0)
+                # on a NASDAQ/OANDA symbol 4-5 h early. Same field the tz-less
+                # hour()/minute() forms and the tz-first overload above use;
+                # "UTC" keeps the timegm fast path so crypto stays identical.
+                # (timestamp(dateString) is different: Pine reads a tz-less
+                # dateString as GMT+0, which _parse_pine_datestring_ms does.)
+                return _timestamp_calendar_lambda(
+                    "syminfo_.timezone", yr, mo, dy, hr, mn, sc)
 
         # barssince() — unsupported. Defensive: support_checker rejects bare
         # barssince(...) with a hint to use ta.barssince(...). Reaching here
@@ -2017,7 +2072,15 @@ class CallVisitor:
         if namespace == "timeframe":
             if func_name == "change":
                 tf_arg = self._visit_expr(node.args[0]) if node.args else 'script_tf_'
-                return f'tf_change(prev_bar_timestamp_, current_bar_.timestamp, {tf_arg})'
+                # Symbol-clock overload: D/W/M boundaries fall on the SYMBOL's
+                # session day (17:00 ET on OANDA forex, 09:30 ET RTH on
+                # equities), intraday buckets on the session-open grid — the
+                # same clock request.security aggregation uses. UTC/24x7
+                # syminfo reduces to the tz-less epoch math bit-for-bit.
+                return (
+                    f'tf_change(prev_bar_timestamp_, current_bar_.timestamp, {tf_arg}, '
+                    'syminfo_.timezone, syminfo_.session)'
+                )
             if func_name == "in_seconds":
                 tf_arg = self._visit_expr(node.args[0]) if node.args else 'script_tf_'
                 return f'tf_to_seconds({tf_arg})'

package/pineforge_codegen/codegen/visit_expr.py

@@ -673,22 +673,40 @@ class ExprVisitor:
                     # to dead ``f5``'s first-in-order ``_ta_vwap_10`` and emitted
                     # ``use of undeclared identifier '_ta_vwap_10'``. A live read
                     # must bind to a live site.
-                    for _i, site in enumerate(self.ctx.ta_call_sites):
-                        if _i in self._dead_ta_indices:
+                    # The read's OWN site first (the analyzer keys the
+                    # synthetic call-site on this MemberAccess node), so two
+                    # bare reads are two sites, each advanced once per bar;
+                    # the first-live-site scan below stays as the fallback.
+                    _own = self._get_ta_site(node)
+                    _candidates = (
+                        [(self._ta_index_by_site_id.get(id(_own)), _own)]
+                        if _own is not None else []
+                    ) + list(enumerate(self.ctx.ta_call_sites))
+                    for _i, site in _candidates:
+                        if _i is None or _i in self._dead_ta_indices:
                             continue
                         ta_short = site.class_name.split("::")[-1].lower()
                         if site.member_name.startswith(f"_ta_{node.member}_"):
                             if node.member == "vwap":
+                                # Same implicit tail as TA_IMPLICIT_APPEND["vwap"]:
+                                # the symbol clock keys the Daily anchor reset.
+                                # The bare property is the VWAP of hlc3 (Pine
+                                # v6 reference; lab tv notrade-session-vwap-f1d,
+                                # 2026-09-05: TradingView's read equals hlc3 on
+                                # a daily bar), never of the close.
+                                _hlc3 = "((current_bar_.high + current_bar_.low + current_bar_.close) / 3.0)"
                                 return (
-                                    f"(history_advances_new_bar() ? {site.member_name}.compute("
-                                    "current_bar_.close, current_bar_.volume, current_bar_.timestamp) "
-                                    f": {site.member_name}.recompute(current_bar_.close, "
-                                    "current_bar_.volume, current_bar_.timestamp))"
+                                    f"(history_advances_new_bar() ? {self._ta_member_name(site)}.compute("
+                                    f"{_hlc3}, current_bar_.volume, current_bar_.timestamp"
+                                    " PF_VWAP_SESSION_ANCHOR_ARGS(syminfo_.timezone, syminfo_.session)) "
+                                    f": {self._ta_member_name(site)}.recompute({_hlc3}, "
+                                    "current_bar_.volume, current_bar_.timestamp"
+                                    " PF_VWAP_SESSION_ANCHOR_ARGS(syminfo_.timezone, syminfo_.session)))"
                                 )
                             return (
-                                f"(history_advances_new_bar() ? {site.member_name}.compute("
+                                f"(history_advances_new_bar() ? {self._ta_member_name(site)}.compute("
                                 f"{TA_IMPLICIT_COMPUTE_FULL[node.member]}) : "
-                                f"{site.member_name}.recompute("
+                                f"{self._ta_member_name(site)}.recompute("
                                 f"{TA_IMPLICIT_COMPUTE_FULL[node.member]}))"
                             )
                     # No registered call site for this TA property read —
@@ -1033,6 +1051,13 @@ class ExprVisitor:
         return f"({left_cpp} {op} {right_cpp})"
 
     def _visit_binop(self, node: BinOp) -> str:
+        # An int-literal-only ``+ - *`` tree whose exact value leaves int32 is
+        # a 64-bit Pine int (``90 * 24 * 60 * 60 * 1000`` = 7 776 000 000);
+        # C++ ``int`` literal arithmetic would wrap it. Fold it here and spell
+        # the value as a 64-bit literal. In-range trees are emitted as before.
+        folded = self._pure_int_literal_value(node)
+        if folded is not None and not self._int_fits_int32(folded):
+            return f"static_cast<int64_t>({folded}LL)"
         left = self._visit_expr(node.left)
         right = self._visit_expr(node.right)
         cpp_ops = {"and": "&&", "or": "||"}
@@ -1114,6 +1139,12 @@ class ExprVisitor:
         # sites never share history, and on_bar clears every synthetic member at
         # run-start even when this particular expression is conditional.
         if isinstance(node.object, FuncCall):
+            # ``[k]`` on a hoisted top-level lazy-edge TA call: its Series was
+            # pushed unconditionally before the statement, so ``[1]`` is the
+            # previous chart bar in every run mode (``_lazy_edge_ta_hoist_plan``).
+            hoisted_member = self._hoisted_hist_reads.get(id(node))
+            if hoisted_member is not None:
+                return f"{hoisted_member}[(int)({idx})]"
             inner = self._visit_expr(node.object)
             cpp_t = self._infer_type(node.object)
             if cpp_t not in ("double", "int", "int64_t", "bool"):