@pineforge/codegen-pyodide 0.10.1 → 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.
@@ -459,45 +464,143 @@ ORDER_DIRECTION_MAP = {
 # ---------------------------------------------------------------------------
 
 
-def _checked_array_index_prelude(*, normalize_negative: bool = True) -> str:
+def _checked_array_index_prelude(
+    *,
+    normalize_negative: bool = True,
+    allow_size: bool = False,
+    name: str = "index",
+) -> str:
     """C++ body shared by checked single-index operations.
 
-    Pine v6 explicitly gives end-relative negative indices to the checked
-    ``get``, ``set``, and ``remove`` cluster. Other indexed functions such as
-    ``percentrank`` still need the same NA/non-finite/range checks, but must
-    reject negative indices instead of normalizing them. ``insert`` remains a
-    separately bounded residual.
+    Pine v6 explicitly gives end-relative negative indices to ``array.get``,
+    ``array.set``, ``array.insert``, and ``array.remove``. Other indexed
+    functions such as ``percentrank`` and the ``fill``/``slice`` range
+    endpoints still need the same NA/non-finite/range checks, but must reject
+    negative indices instead of normalizing them (``normalize_negative``).
+
+    ``allow_size`` widens the upper bound from ``index < size`` to
+    ``index <= size``. An *element access* is invalid at ``size``, but an
+    *insertion point* is not: ``array.insert(id, size, v)`` appends, and the
+    half-open ``[index_from, index_to)`` ranges of ``array.fill`` /
+    ``array.slice`` legally end at ``size``.
+
+    ``name`` renames every emitted local so two endpoints can be checked in
+    one C++ scope without colliding. ``name="index"`` reproduces the original
+    identifiers byte-for-byte.
     """
+    raw_value = f"__pf_raw_{name}_value"
+    raw_type = f"__pf_raw_{name}_type"
+    raw_text = f"__pf_raw_{name}_text"
+    raw_wide = f"__pf_raw_{name}_wide"
+    raw = f"__pf_raw_{name}"
+    checked = f"__pf_array_{name}"
+    size = "__pf_array_size" if name == "index" else f"__pf_array_size_{name}"
     checked_index = (
-        "__pf_raw_index<0?__pf_raw_index+__pf_array_size:__pf_raw_index"
-        if normalize_negative
-        else "__pf_raw_index"
+        f"{raw}<0?{raw}+{size}:{raw}" if normalize_negative else raw
     )
+    upper = ">" if allow_size else ">="
     return (
-        "using __pf_raw_index_type=std::decay_t<decltype(__pf_raw_index_value)>; "
-        "if constexpr(!std::is_same_v<__pf_raw_index_type,bool>) { "
-        "if(is_na(__pf_raw_index_value)) "
+        f"using {raw_type}=std::decay_t<decltype({raw_value})>; "
+        f"if constexpr(!std::is_same_v<{raw_type},bool>) {{ "
+        f"if(is_na({raw_value})) "
         "pine_runtime_error(std::string(\"Index na is out of bounds. Array size is \")+"
         "std::to_string((int64_t)__pf_array.size())); } "
-        "if constexpr(std::is_floating_point_v<__pf_raw_index_type>) { "
-        "if(!std::isfinite(__pf_raw_index_value)) { "
-        "std::string __pf_raw_index_text=__pf_raw_index_value>0?\"inf\":\"-inf\"; "
-        "pine_runtime_error(std::string(\"Index \")+__pf_raw_index_text+"
+        f"if constexpr(std::is_floating_point_v<{raw_type}>) {{ "
+        f"if(!std::isfinite({raw_value})) {{ "
+        f"std::string {raw_text}={raw_value}>0?\"inf\":\"-inf\"; "
+        f"pine_runtime_error(std::string(\"Index \")+{raw_text}+"
         "\" is out of bounds. Array size is \"+"
         "std::to_string((int64_t)__pf_array.size())); } "
-        "long double __pf_raw_index_wide=(long double)__pf_raw_index_value; "
-        "if(__pf_raw_index_wide<(long double)std::numeric_limits<int64_t>::min()||"
-        "__pf_raw_index_wide>(long double)std::numeric_limits<int64_t>::max()) "
+        f"long double {raw_wide}=(long double){raw_value}; "
+        f"if({raw_wide}<(long double)std::numeric_limits<int64_t>::min()||"
+        f"{raw_wide}>(long double)std::numeric_limits<int64_t>::max()) "
         "pine_runtime_error(std::string(\"Index \")+"
-        "std::to_string((double)__pf_raw_index_value)+"
+        f"std::to_string((double){raw_value})+"
         "\" is out of bounds. Array size is \"+"
         "std::to_string((int64_t)__pf_array.size())); } "
-        "int64_t __pf_raw_index=(int64_t)__pf_raw_index_value; "
-        "int64_t __pf_array_size=(int64_t)__pf_array.size(); "
-        f"int64_t __pf_array_index={checked_index}; "
-        "if(__pf_array_index<0||__pf_array_index>=__pf_array_size) "
-        "pine_runtime_error(std::string(\"Index \")+std::to_string(__pf_raw_index)+"
-        "\" is out of bounds. Array size is \"+std::to_string(__pf_array_size)); "
+        f"int64_t {raw}=(int64_t){raw_value}; "
+        f"int64_t {size}=(int64_t)__pf_array.size(); "
+        f"int64_t {checked}={checked_index}; "
+        f"if({checked}<0||{checked}{upper}{size}) "
+        f"pine_runtime_error(std::string(\"Index \")+std::to_string({raw})+"
+        f"\" is out of bounds. Array size is \"+std::to_string({size})); "
+    )
+
+
+def _checked_array_range_prelude() -> str:
+    """Validate the half-open ``[index_from, index_to)`` range of fill/slice.
+
+    Both endpoints are checked with ``allow_size`` (``index_to`` is exclusive,
+    so ``size`` is a legal endpoint) and without negative normalization
+    (neither function appears in the Pine v6 reference's negative-indexing
+    set). An inverted range is rejected rather than silently treated as empty:
+    ``begin()+from > begin()+to`` is undefined behaviour in the STL forms this
+    replaces, and no evidence pins TradingView's behaviour there.
+    """
+    return (
+        _checked_array_index_prelude(
+            normalize_negative=False, allow_size=True, name="index_from"
+        )
+        + _checked_array_index_prelude(
+            normalize_negative=False, allow_size=True, name="index_to"
+        )
+        + "if(__pf_array_index_from>__pf_array_index_to) "
+        "pine_runtime_error(std::string(\"Index range \")+"
+        "std::to_string(__pf_array_index_from)+\"..\"+"
+        "std::to_string(__pf_array_index_to)+"
+        "\" is invalid. Array size is \"+"
+        "std::to_string(__pf_array_size_index_from)); "
+    )
+
+
+def _checked_array_insert(a: str, args: list[str]) -> str:
+    """``array.insert(id, index, value)`` — index is an INSERTION point.
+
+    ``index == size`` appends, so the bound is ``index <= size``; a negative
+    index is end-relative, exactly as for ``get``/``set``/``remove``.
+    """
+    check = _checked_array_index_prelude(allow_size=True)
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_value){ "
+        "return [&](auto&& __pf_array_value){ "
+        f"{check}"
+        "__pf_array.insert(__pf_array.begin()+(size_t)__pf_array_index, "
+        "__pf_array_value); "
+        f"}}(({args[1]})); }}(({args[0]})); }}(({a}))"
+    )
+
+
+def _checked_array_fill_range(a: str, args: list[str]) -> str:
+    """``array.fill(id, value, index_from, index_to)`` — bounded range fill."""
+    check = _checked_array_range_prelude()
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_array_value){ "
+        "return [&](auto&& __pf_raw_index_from_value){ "
+        "return [&](auto&& __pf_raw_index_to_value){ "
+        f"{check}"
+        "std::fill(__pf_array.begin()+(size_t)__pf_array_index_from, "
+        "__pf_array.begin()+(size_t)__pf_array_index_to, __pf_array_value); "
+        f"}}(({args[2]})); }}(({args[1]})); }}(({args[0]})); }}(({a}))"
+    )
+
+
+def checked_array_slice(a: str, args: list[str], *, result_type: str) -> str:
+    """``array.slice(id, index_from, index_to)`` — bounded range extraction.
+
+    ``result_type`` stays caller-supplied so the typed method lane keeps
+    emitting the receiver's own element type; only the bounds checks are new.
+    """
+    check = _checked_array_range_prelude()
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_from_value){ "
+        "return [&](auto&& __pf_raw_index_to_value){ "
+        f"{check}"
+        f"return {result_type}(__pf_array.begin()+(size_t)__pf_array_index_from, "
+        "__pf_array.begin()+(size_t)__pf_array_index_to); "
+        f"}}(({args[1]})); }}(({args[0]})); }}(({a}))"
     )
 
 
@@ -600,7 +703,7 @@ ARRAY_METHODS = {
     "set":       _checked_array_set,
     "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]})",
+    "insert":    _checked_array_insert,
     "pop":       lambda a, args: _checked_array_end_remove(a, "pop"),
     "shift":     lambda a, args: _checked_array_end_remove(a, "shift"),
     "remove":    _checked_array_remove,
@@ -609,7 +712,7 @@ ARRAY_METHODS = {
     "size":      lambda a, args: f"(double){a}.size()",
     "clear":     lambda a, args: f"{a}.clear()",
     "fill":      lambda a, args: f"std::fill({a}.begin(), {a}.end(), {args[0]})" if len(args) == 1
-                                 else f"std::fill({a}.begin()+(int)({args[1]}), {a}.begin()+(int)({args[2]}), {args[0]})",
+                                 else _checked_array_fill_range(a, args),
     "includes":  lambda a, args: f"(std::find({a}.begin(), {a}.end(), {args[0]}) != {a}.end())",
     "indexof":   lambda a, args: f"[&](){{ auto it=std::find({a}.begin(),{a}.end(),{args[0]}); return it!={a}.end()?(double)(it-{a}.begin()):-1.0; }}()",
     "lastindexof": lambda a, args: f"[&](){{ for(int i=(int){a}.size()-1;i>=0;i--)if({a}[i]=={args[0]})return(double)i; return -1.0; }}()",
@@ -619,7 +722,7 @@ ARRAY_METHODS = {
     ),
     "reverse":   lambda a, args: f"std::reverse({a}.begin(),{a}.end())",
     "copy":      lambda a, args: f"std::vector<double>({a})",
-    "slice":     lambda a, args: f"std::vector<double>({a}.begin()+(int)({args[0]}),{a}.begin()+(int)({args[1]}))",
+    "slice":     lambda a, args: checked_array_slice(a, args, result_type="std::vector<double>"),
     "concat":    lambda a, args: f"{a}.insert({a}.end(),{args[0]}.begin(),{args[0]}.end())",
     "sum":       lambda a, args: f"({a}.empty()?na<double>():std::accumulate({a}.begin(),{a}.end(),0.0))",
     "avg":       lambda a, args: f"({a}.empty()?na<double>():std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size())",
@@ -667,6 +770,9 @@ CHECKED_ARRAY_METHOD_KWARGS: dict[str, list[str]] = {
     "set": ["index", "value"],
     "remove": ["index"],
     "percentrank": ["index"],
+    "insert": ["index", "value"],
+    "fill": ["value", "index_from", "index_to"],
+    "slice": ["index_from", "index_to"],
     "first": [],
     "last": [],
     "pop": [],

package/pineforge_codegen/codegen/types.py

@@ -50,6 +50,7 @@ from .tables import (
     MATRIX_RETURNING_METHODS,
     PINE_TYPE_TO_CPP,
     TA_RETURNS_BOOL,
+    checked_array_slice,
 )
 
 # Collection (array / map / matrix) methods that MUTATE the receiver in place.
@@ -960,7 +961,11 @@ class TypeInferer:
         if method == "copy":
             lower_receiver = lambda recv: f"{arr_cpp_type}({recv})"
         elif method == "slice":
-            lower_receiver = lambda recv: f"{arr_cpp_type}({recv}.begin()+(int)({args[0]}),{recv}.begin()+(int)({args[1]}))"
+            # Bounds-checked in the shared helper; the element type stays
+            # caller-supplied so the typed lane keeps its own vector type.
+            lower_receiver = lambda recv: checked_array_slice(
+                recv, args, result_type=arr_cpp_type
+            )
         elif method == "join" and elem_cpp == "std::string":
             sep = args[0] if args else 'std::string(",")'
             lower_receiver = lambda recv: f"[&](){{ std::string r; for(size_t i=0;i<{recv}.size();i++){{ if(i>0)r+={sep}; r+={recv}[i]; }} return r; }}()"

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})'
@@ -2145,25 +2199,25 @@ class CallVisitor:
                     arg_idx,
                     self._callable_target_callsite_idx(fi_lookup, node),
                 )
-                if isinstance(arg_node, Identifier):
+                chart_execution_context = (
+                    id(node) not in self._requested_context_inline_node_ids
+                    and (
+                        getattr(self, "_active_func_name", None),
+                        self._current_instance_name,
+                    ) not in self._requested_context_only_inline_contexts
+                )
+                if not chart_execution_context and isinstance(arg_node, Identifier):
+                    # request.security/request.security_lower_tf own a separate
+                    # evaluator clock and inline their UDF expressions in
+                    # security.py.  Preserve the pre-factor direct-Series
+                    # lowering in the otherwise-emitted helper bodies.
                     aname = arg_node.name
-                    # Bar field: pass _s_close instead of current_bar_.close
                     if (
                         (aname in BAR_FIELDS or aname in BAR_SERIES_PUSH)
                         and expected_cpp_type == "double"
                     ):
                         return f"_s_{aname}"
-                    # Exact Series binding: pass the Series object directly.
-                    # A raw name can also denote a scalar sibling/callable
-                    # shadow, in which case lexical state must override the
-                    # legacy ``ctx.series_vars`` union and fall through to the
-                    # synthetic history bridge below.
                     safe = self._safe_name(aname)
-                    # Function parameters are lexical C++ arguments in every
-                    # emitted variant.  The legacy function-series clone table
-                    # can contain the same raw name, but applying it here makes
-                    # cs1+ ignore the actual parameter and read an unrelated
-                    # class member instead.
                     is_current_series_param = (
                         aname in self._current_func_series_params
                     )
@@ -2188,13 +2242,31 @@ class CallVisitor:
                     expr_cpp, cpp_t
                 )
                 member = self._inline_history_member(
-                    "series_arg", node, arg_idx=arg_idx
+                    (
+                        "udf_series_arg"
+                        if chart_execution_context
+                        else "series_arg"
+                    ),
+                    node,
+                    arg_idx=arg_idx,
                 )
+                if not chart_execution_context:
+                    return (
+                        f"([&]() -> const Series<{cpp_t}>& {{ "
+                        f"{cpp_t} _sv = {bridge_cpp}; "
+                        f"if (history_advances_new_bar()) {member}.push(_sv); "
+                        f"else {member}.update(_sv); "
+                        f"return {member}; }}())"
+                    )
+                # A chart-executed plain UDF's history-reading parameter
+                # belongs to this lexical call site, not to the caller Series
+                # object.  The on_bar preamble has already advanced its
+                # synthetic buffer by one chart slot, so execution replaces
+                # that slot rather than pushing a second one.
                 return (
                     f"([&]() -> const Series<{cpp_t}>& {{ "
                     f"{cpp_t} _sv = {bridge_cpp}; "
-                    f"if (history_advances_new_bar()) {member}.push(_sv); "
-                    f"else {member}.update(_sv); "
+                    f"{member}.update(_sv); "
                     f"return {member}; }}())"
                 )
             # A concrete nullable collection specialization learned through an

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"):