@pineforge/codegen-pyodide 0.10.2 → 0.10.3

package/pineforge_codegen/codegen/tables.py

@@ -248,12 +248,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/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_] : "
@@ -1722,22 +1779,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 +1884,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 +1909,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 +2063,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

@@ -679,11 +679,15 @@ class ExprVisitor:
                         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.
                                 return (
                                     f"(history_advances_new_bar() ? {site.member_name}.compute("
-                                    "current_bar_.close, current_bar_.volume, current_bar_.timestamp) "
+                                    "current_bar_.close, current_bar_.volume, current_bar_.timestamp"
+                                    " PF_VWAP_SESSION_ANCHOR_ARGS(syminfo_.timezone, syminfo_.session)) "
                                     f": {site.member_name}.recompute(current_bar_.close, "
-                                    "current_bar_.volume, current_bar_.timestamp))"
+                                    "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("
@@ -1114,6 +1118,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"):

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "0.10.2",
+  "codegen": "0.10.3",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "97ebb8d0b14c32d3c88b9521c8f13150ee9cb9e3859227af970ec4dcbfa6bf71"
+  "sha256": "50f545e8a008c23ec01a752a5e8bd00e885dda9dcd2bb417e2af18d680c22a6e"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "0.10.2",
+  "CODEGEN_VERSION": "0.10.3",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",