pineforge-codegen 0.7.1__tar.gz → 0.7.3__tar.gz

pineforge_codegen-0.7.3/.github/dependabot.yml

@@ -0,0 +1,20 @@
+version: 2
+updates:
+  # Keep the SHA-pinned GitHub Actions in workflows up to date with
+  # reviewable PRs (security review: pinned actions need a bump path).
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  # The conformance-gate / npm-package tooling (pyodide pinned to PYODIDE_TARGET,
+  # tar caret range) — get reviewable bump PRs. NOTE: a pyodide bump must move
+  # PYODIDE_TARGET in lockstep (the gate validates against it), so review these.
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  # Python dev deps (pytest).
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"

{pineforge_codegen-0.7.1 → pineforge_codegen-0.7.3}/.github/workflows/release.yml

@@ -36,8 +36,9 @@ jobs:
   release:
     runs-on: ubuntu-latest
     env:
-      BUMP:     ${{ inputs.bump }}
-      OVERRIDE: ${{ inputs.override }}
+      BUMP:          ${{ inputs.bump }}
+      OVERRIDE:      ${{ inputs.override }}
+      PYTHONHASHSEED: "0"   # deterministic gate runtime (match gate.yml)
     steps:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5  # v4
         with:
@@ -83,7 +84,22 @@ jobs:
 
       - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065  # v5
         with:
-          python-version: "3.12"
+          python-version: "3.14"   # match the gate's runtime
+
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020  # v4
+        with:
+          node-version: "22"
+
+      # Conformance gate (BLOCKING): the differential parity gate must pass
+      # before anything is built, published, or tagged. A gate-broken codegen
+      # fails the release here — nothing reaches PyPI, no tag is pushed (so the
+      # tag->npm trigger never fires), and no GitHub Release is created.
+      - name: Run conformance gate (blocking)
+        run: |
+          python -m pip install -e .
+          npm ci
+          npm run gate:selftest
+          npm run gate:full
 
       - name: Build sdist + wheel
         run: |
@@ -91,8 +107,16 @@ jobs:
           python -m build
           ls -l dist/
 
-      # Commit + tag before publishing so a tag always corresponds to a built
-      # artifact set; the GitHub Release (with files) comes after PyPI succeeds.
+      # Publish to PyPI BEFORE the tag is pushed. The tag push triggers
+      # publish-pyodide.yml (npm), so PyPI must land first — otherwise a PyPI
+      # failure would leave npm shipping a version PyPI never got.
+      - name: Publish to PyPI
+        if: ${{ !inputs.dry_run }}
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b  # release/v1
+
+      # Commit + tag + push AFTER PyPI succeeds. The `git push --tags` triggers
+      # publish-pyodide.yml for npm (which re-runs the gate — defense in depth),
+      # so the tag only exists once the gate passed and PyPI published.
       - name: Commit + tag + push
         if: ${{ !inputs.dry_run }}
         env:
@@ -105,10 +129,6 @@ jobs:
           git tag "v${NEW_VERSION}"
           git push origin HEAD --tags
 
-      - name: Publish to PyPI
-        if: ${{ !inputs.dry_run }}
-        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b  # release/v1
-
       - name: Create GitHub Release
         if: ${{ !inputs.dry_run }}
         env:

{pineforge_codegen-0.7.1 → pineforge_codegen-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineforge-codegen
-Version: 0.7.1
+Version: 0.7.3
 Summary: PineScript v6 to C++ transpiler that targets the pineforge-engine runtime.
 Project-URL: Homepage, https://github.com/pineforge-4pass/pineforge-codegen-oss
 Project-URL: Issues, https://github.com/pineforge-4pass/pineforge-codegen-oss/issues

pineforge_codegen-0.7.3/VERSION

@@ -0,0 +1 @@
+0.7.3

pineforge_codegen-0.7.3/gate/compare.mjs

@@ -0,0 +1,69 @@
+// Pure, side-effect-free comparator for the gate. Both run-gate.mjs (the runner)
+// and selftest.mjs (the canary) import this — so importing it never triggers a
+// gate run. Each side is {json: "<transpile_json string>"} (normal return) or
+// {unexpected: "Type: msg"} (non-CompileError exception). Returns a mismatch
+// string, or null if the two sides agree.
+export function compareResults(name, native, browser) {
+  if (!native) return `${name}: oracle produced no result`;
+  if (!browser) return `${name}: pyodide produced no result`;
+  if (native.unexpected || browser.unexpected) {
+    if (native.unexpected !== browser.unexpected) {
+      return `${name}: unexpected-exception mismatch\n  native : ${native.unexpected ?? "<none>"}\n  pyodide: ${browser.unexpected ?? "<none>"}`;
+    }
+    return null;
+  }
+  if (native.json !== browser.json) {
+    let detail = "";
+    try {
+      const n = JSON.parse(native.json);
+      const b = JSON.parse(browser.json);
+      if (n.ok !== b.ok) detail = `verdict ${b.ok} (pyodide) != ${n.ok} (native)`;
+      else if (n.ok) detail = "C++ output differs";
+      else detail = `error/diagnostics differ\n  native : ${native.json}\n  pyodide: ${browser.json}`;
+    } catch {
+      detail = `raw json differs\n  native : ${native.json}\n  pyodide: ${browser.json}`;
+    }
+    return `${name}: ${detail}`;
+  }
+  return null;
+}
+
+// Expected verdict for a corpus branch: "ok/*" fixtures must transpile
+// successfully (result.ok === true), "err/*" fixtures must be rejected
+// (result.ok === false). Anything else — the wrong verdict, an unparseable
+// payload, or an unexpected (non-CompileError) exception — is a gate failure
+// even when native and wasm agree (two identical crashes must NOT pass).
+//
+// This is intentionally separate from compareResults so the gate enforces BOTH
+// (a) native↔wasm parity and (b) the right answer. `side` is {json} or
+// {unexpected}; `expectOk` is true for "ok", false for "err".
+function verdictOf(side) {
+  if (!side) return { kind: "missing" };
+  if (side.unexpected) return { kind: "unexpected", detail: side.unexpected };
+  try {
+    const v = JSON.parse(side.json);
+    if (typeof v.ok !== "boolean") return { kind: "malformed", detail: side.json };
+    return { kind: "verdict", ok: v.ok };
+  } catch {
+    return { kind: "malformed", detail: side.json };
+  }
+}
+
+// Returns a failure string if either side does not match the expected verdict
+// for the fixture's branch, or null if both sides produced the expected verdict.
+export function checkExpectedVerdict(name, expectOk, native, browser) {
+  for (const [label, side] of [["native", native], ["pyodide", browser]]) {
+    const r = verdictOf(side);
+    if (r.kind === "missing") return `${name}: ${label} produced no result`;
+    if (r.kind === "unexpected") {
+      return `${name}: ${label} threw an unexpected exception (expected ok=${expectOk}): ${r.detail}`;
+    }
+    if (r.kind === "malformed") {
+      return `${name}: ${label} returned a malformed result (expected ok=${expectOk}): ${r.detail}`;
+    }
+    if (r.ok !== expectOk) {
+      return `${name}: ${label} verdict ok=${r.ok} but corpus dir expects ok=${expectOk}`;
+    }
+  }
+  return null;
+}

{pineforge_codegen-0.7.1 → pineforge_codegen-0.7.3}/gate/run-gate.mjs

@@ -13,7 +13,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { compareResults } from "./compare.mjs";
+import { checkExpectedVerdict, compareResults } from "./compare.mjs";
 
 const require = createRequire(import.meta.url);
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -79,8 +79,14 @@ async function main() {
   });
   const native = JSON.parse(oracleOut);
 
-  // 4. Pyodide side + compare.
+  // 4. Pyodide side + compare. The gate enforces TWO independent properties:
+  //    (a) native↔wasm parity (compareResults) and
+  //    (b) the EXPECTED verdict by corpus dir (checkExpectedVerdict): ok/* must
+  //        succeed, err/* must be rejected. A purely differential check would
+  //        let two identical crashes — or an ok/ fixture that erroneously errors
+  //        — slip through; (b) closes that gap.
   const mismatches = [];
+  const verdictFailures = [];
   for (const { name, src } of items) {
     let browser;
     try {
@@ -90,6 +96,9 @@ async function main() {
     }
     const m = compareResults(name, native[name], browser);
     if (m) mismatches.push(m);
+    const expectOk = name.startsWith("ok/");
+    const v = checkExpectedVerdict(name, expectOk, native[name], browser);
+    if (v) verdictFailures.push(v);
   }
 
   // 5. release.json (versions derived from the loaded Pyodide lock).
@@ -106,11 +115,16 @@ async function main() {
   writeFileSync(join(ROOT, "release.json"), JSON.stringify(release, null, 2) + "\n");
   console.log("gate: release.json ->", JSON.stringify(release));
 
-  if (mismatches.length) {
-    console.error(`gate: ${mismatches.length} MISMATCH(es):\n` + mismatches.join("\n"));
+  if (mismatches.length || verdictFailures.length) {
+    if (mismatches.length) {
+      console.error(`gate: ${mismatches.length} PARITY MISMATCH(es):\n` + mismatches.join("\n"));
+    }
+    if (verdictFailures.length) {
+      console.error(`gate: ${verdictFailures.length} VERDICT FAILURE(s) (wrong ok/err result):\n` + verdictFailures.join("\n"));
+    }
     process.exit(1);
   }
-  console.log(`gate: PARITY OK over ${items.length} fixtures`);
+  console.log(`gate: PARITY OK over ${items.length} fixtures (verdicts asserted: ok/* succeed, err/* rejected)`);
 }
 
 main().catch((e) => {

pineforge_codegen-0.7.3/gate/selftest.mjs

@@ -0,0 +1,57 @@
+// Canary: prove the gate's checks actually catch divergences. Imports the PURE
+// comparator + verdict checker (gate/compare.mjs) so it runs in <1s without
+// loading Pyodide. Covers BOTH (a) native↔wasm parity (compareResults) and
+// (b) expected-verdict-by-corpus-dir (checkExpectedVerdict).
+import { checkExpectedVerdict, compareResults } from "./compare.mjs";
+
+const OK = '{"ok":true,"cpp":"X"}';
+const ERR = '{"ok":false,"error":"e","diagnostics":[]}';
+
+// --- (a) differential comparator cases: [name, native, browser, mustFlag] ---
+const cmpCases = [
+  ["same-ok", { json: OK }, { json: OK }, false],
+  ["cpp-differs", { json: '{"ok":true,"cpp":"X"}' }, { json: '{"ok":true,"cpp":"Y"}' }, true],
+  ["verdict-differs", { json: OK }, { json: ERR }, true],
+  ["error-differs", { json: '{"ok":false,"error":"a","diagnostics":[]}' }, { json: '{"ok":false,"error":"b","diagnostics":[]}' }, true],
+  ["unexpected-one-side", { json: OK }, { unexpected: "TypeError: boom" }, true],
+  ["unexpected-both-same", { unexpected: "TypeError: boom" }, { unexpected: "TypeError: boom" }, false],
+  ["unexpected-both-diff", { unexpected: "TypeError: a" }, { unexpected: "ValueError: b" }, true],
+  ["missing-native", undefined, { json: OK }, true],
+];
+
+// --- (b) expected-verdict cases: [name, expectOk, native, browser, mustFlag] ---
+// A native↔wasm match with the WRONG verdict (e.g. ok/ that errors, or a shared
+// unexpected exception) must FAIL even though compareResults would pass it.
+const verdictCases = [
+  ["ok/good", true, { json: OK }, { json: OK }, false],
+  ["err/bad", false, { json: ERR }, { json: ERR }, false],
+  ["ok/that-errors-both-sides", true, { json: ERR }, { json: ERR }, true],
+  ["err/that-succeeds-both-sides", false, { json: OK }, { json: OK }, true],
+  ["ok/unexpected-both-same", true, { unexpected: "TypeError: boom" }, { unexpected: "TypeError: boom" }, true],
+  ["err/unexpected-both-same", false, { unexpected: "TypeError: boom" }, { unexpected: "TypeError: boom" }, true],
+  ["ok/native-wrong-only", true, { json: ERR }, { json: OK }, true],
+  ["ok/pyodide-wrong-only", true, { json: OK }, { json: ERR }, true],
+  ["ok/missing-native", true, undefined, { json: OK }, true],
+  ["ok/malformed", true, { json: "not json" }, { json: OK }, true],
+];
+
+let failed = 0;
+for (const [name, n, b, mustFlag] of cmpCases) {
+  const flagged = compareResults(name, n, b) !== null;
+  if (flagged !== mustFlag) {
+    console.error(`selftest FAIL (compareResults): ${name} expected mustFlag=${mustFlag} got ${flagged}`);
+    failed++;
+  }
+}
+for (const [name, expectOk, n, b, mustFlag] of verdictCases) {
+  const flagged = checkExpectedVerdict(name, expectOk, n, b) !== null;
+  if (flagged !== mustFlag) {
+    console.error(`selftest FAIL (checkExpectedVerdict): ${name} expected mustFlag=${mustFlag} got ${flagged}`);
+    failed++;
+  }
+}
+if (failed) {
+  console.error(`gate selftest: ${failed} case(s) failed`);
+  process.exit(1);
+}
+console.log(`gate selftest: ${cmpCases.length} comparator + ${verdictCases.length} verdict cases OK`);

{pineforge_codegen-0.7.1 → pineforge_codegen-0.7.3}/pineforge_codegen/codegen/base.py

@@ -185,19 +185,31 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # This ensures sub-function series vars get cloned for the parent's call sites.
         func_var_originals: dict[str, list[str]] = {}  # func_name -> list of original var names
 
-        # First, collect all function-scoped series vars (union across all functions)
-        all_func_scoped_series: set[str] = set()
+        # First, collect all function-scoped series vars (union across all functions).
+        # Use an ordered, de-duplicated list (NOT a set): set iteration order is
+        # PYTHONHASHSEED-randomized, and this order reaches emitted C++ member
+        # declarations via ``orig_names`` -> ``func_var_originals`` ->
+        # ``_func_cs_var_remap``. ``ctx.func_series_vars`` is a dict whose VALUES
+        # are themselves sets (analyzer stores ``dict[str, set]``), so we must
+        # iterate each value in ``sorted`` order to be hash-seed independent.
+        all_func_scoped_series: list[str] = []
         for svars in ctx.func_series_vars.values():
-            all_func_scoped_series.update(svars)
-        # Also include function-scoped var_members
-        all_func_scoped_vars: set[str] = set()
+            for sv in sorted(svars):
+                if sv not in all_func_scoped_series:
+                    all_func_scoped_series.append(sv)
+        # Also include function-scoped var_members (same ordered-list rationale).
+        # ``ctx.func_var_members`` values are lists (already insertion-ordered).
+        all_func_scoped_vars: list[str] = []
         for vlist in ctx.func_var_members.values():
             for n, _, _ in vlist:
-                all_func_scoped_vars.add(n)
+                if n not in all_func_scoped_vars:
+                    all_func_scoped_vars.append(n)
 
         # For each function with call-site cloning (has TA ranges or is called multiple times),
-        # include ALL function-scoped series/var vars that could be used in its body
-        for fname in set(ctx.func_call_site_counts.keys()):
+        # include ALL function-scoped series/var vars that could be used in its body.
+        # Iterate the dict directly (insertion-ordered) rather than ``set(...keys())``,
+        # which would randomize the order of emitted clones across hash seeds.
+        for fname in ctx.func_call_site_counts:
             total_cs = ctx.func_call_site_counts[fname]
             if total_cs <= 1:
                 continue  # No cloning needed for single-call-site functions
@@ -207,9 +219,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 for n, _, _ in ctx.func_var_members[fname]:
                     if n not in orig_names:
                         orig_names.append(n)
-            # Include function's own series vars
+            # Include function's own series vars (set -> sorted for determinism)
             if fname in ctx.func_series_vars:
-                for sv in ctx.func_series_vars[fname]:
+                for sv in sorted(ctx.func_series_vars[fname]):
                     if sv not in orig_names:
                         orig_names.append(sv)
             # Include series vars from sub-functions (they share the same class members)
@@ -457,6 +469,79 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._register_global_aggregate_member_types()
         self._uses_matrix = self._detect_matrix_usage()
 
+        # max_bars_back: the per-variable history depth the engine's Series<T>
+        # ring buffer should retain. Pine exposes this two ways — the
+        # ``strategy(..., max_bars_back=N)`` kwarg (global) and the
+        # ``max_bars_back(var, N)`` function (per-var). The engine's
+        # ``Series<T>(int max_len)`` ctor (default 500, include/pineforge/
+        # series.hpp) is the wiring point: reads past the retained depth return
+        # na, so honoring the directive means constructing each Series with a
+        # capacity >= the requested depth. We take the MAX requested N and apply
+        # it (via ``_series_decl_suffix`` -> ``{N}``) to the directly-declared
+        # ``Series<T>`` members — a safe superset of Pine's per-var semantics
+        # (it never retains LESS than Pine, so any history access that succeeds
+        # in Pine succeeds here). ``None`` => no directive => keep the engine
+        # default 500 (emit a bare ``Series<T>`` with no ctor arg, so
+        # directive-free output is byte-identical to before).
+        #
+        # KNOWN LIMITATION: the lazily-constructed security-helper map series
+        # (``_security_helper_series_``, the ``std::unordered_map<std::string,
+        # Series<double>>`` ~line 971) do NOT pick up the cap. Their entries are
+        # default-constructed on first ``operator[]`` access, so they always use
+        # the engine default 500 regardless of the requested ``N``. A
+        # max_bars_back directive larger than 500 is therefore not honored for
+        # history reads off security-helper series.
+        self._max_bars_back_cap: int | None = self._compute_max_bars_back_cap()
+
+    @staticmethod
+    def _int_literal_value(node: ASTNode | None) -> int | None:
+        """Return the integer value of a (possibly unary-minus) NumberLiteral,
+        or None if ``node`` is not an integer literal expression."""
+        if isinstance(node, UnaryOp) and node.op == "-":
+            inner = CodeGen._int_literal_value(node.operand)
+            return -inner if inner is not None else None
+        if isinstance(node, NumberLiteral) and isinstance(node.value, int):
+            return node.value
+        if isinstance(node, NumberLiteral) and isinstance(node.value, float):
+            # Pine accepts ``max_bars_back=5e2`` style; accept integral floats.
+            return int(node.value) if node.value.is_integer() else None
+        return None
+
+    def _compute_max_bars_back_cap(self) -> int | None:
+        """Scan the AST for max_bars_back directives (strategy() kwarg AND the
+        bare function call) and return the largest positive integer requested,
+        or None if none is present / none is a usable literal."""
+        ast = getattr(self.ctx, "ast", None)
+        if ast is None:
+            return None
+        caps: list[int] = []
+        for node in self._walk_ast(ast):
+            if isinstance(node, StrategyDecl):
+                val = self._int_literal_value(node.kwargs.get("max_bars_back"))
+                if val is not None and val > 0:
+                    caps.append(val)
+            elif (
+                isinstance(node, FuncCall)
+                and isinstance(node.callee, Identifier)
+                and node.callee.name == "max_bars_back"
+            ):
+                # max_bars_back(var, num) — second positional arg, or the
+                # ``num=`` kwarg, is the depth.
+                num_node = None
+                if len(node.args) >= 2:
+                    num_node = node.args[1]
+                elif "num" in node.kwargs:
+                    num_node = node.kwargs["num"]
+                val = self._int_literal_value(num_node)
+                if val is not None and val > 0:
+                    caps.append(val)
+        return max(caps) if caps else None
+
+    def _series_decl_suffix(self) -> str:
+        """C++ constructor-arg suffix for Series<T> member declarations. Empty
+        (engine default 500) unless a max_bars_back directive raised the cap."""
+        return f"{{{self._max_bars_back_cap}}}" if self._max_bars_back_cap else ""
+
     def _register_global_aggregate_member_types(self) -> None:
         """Infer matrix/array/map class members for global non-var declarations from RHS AST.
 
@@ -790,6 +875,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         lines: list[str] = []
 
+        # Series<T> ctor-arg suffix from any max_bars_back directive (empty when
+        # absent, so directive-free output is byte-identical to before).
+        _mbb = self._series_decl_suffix()
+
         # 1. Includes
         self._emit_includes(lines)
 
@@ -863,7 +952,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     self._security_ohlc_hist_fields_by_sec.get(sec_id, ())
                 ):
                     lines.append(
-                        f"    Series<double> {self._security_ohlc_hist_series_cpp(sec_id, field)};"
+                        f"    Series<double> {self._security_ohlc_hist_series_cpp(sec_id, field)}{_mbb};"
                     )
                 continue
             if returns_tuple and tuple_size and tuple_size > 0 and isinstance(expr_node, TupleLiteral):
@@ -884,7 +973,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 lines.append(f"    double _req_sec_{sec_id} = na<double>();")
             for field in sorted(self._security_ohlc_hist_fields_by_sec.get(sec_id, ())):
                 lines.append(
-                    f"    Series<double> {self._security_ohlc_hist_series_cpp(sec_id, field)};"
+                    f"    Series<double> {self._security_ohlc_hist_series_cpp(sec_id, field)}{_mbb};"
                 )
 
         if self._security_calls:
@@ -899,7 +988,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 state_name = self._security_state_name(info["sec_id"], name)
                 cpp_type = self._security_cpp_type_for_mutable(name, ginfo)
                 if getattr(ginfo, "is_series", False):
-                    lines.append(f"    Series<{cpp_type}> {state_name};")
+                    lines.append(f"    Series<{cpp_type}> {state_name}{_mbb};")
                 else:
                     default = self._default_for_type(cpp_type)
                     lines.append(f"    {cpp_type} {state_name} = {default};")
@@ -926,7 +1015,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         # 4. Series members for bar field history
         for field_name in sorted(self.ctx.series_bar_fields):
-            lines.append(f"    Series<double> _s_{field_name};")
+            lines.append(f"    Series<double> _s_{field_name}{_mbb};")
 
         # 5. var/varip members (deduplicate by name)
         seen_var_members: set[str] = set()
@@ -975,7 +1064,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if cpp_type == "int" and self._is_int64_builtin_init(name):
                 cpp_type = "int64_t"
             if name in self.ctx.series_vars:
-                lines.append(f"    Series<{cpp_type}> {safe};")
+                lines.append(f"    Series<{cpp_type}> {safe}{_mbb};")
             else:
                 lines.append(f"    {cpp_type} {safe};")
 
@@ -984,7 +1073,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if name not in self._var_names:
                 safe = self._safe_name(name)
                 cpp_type = self._series_type_for(name)
-                lines.append(f"    Series<{cpp_type}> {safe};")
+                lines.append(f"    Series<{cpp_type}> {safe}{_mbb};")
 
         # 7. Fixnan members
         for site in self.ctx.fixnan_sites:
@@ -997,9 +1086,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # Determine type: int for count vars, double for float vars
             if member in ("closedtrades", "opentrades", "wintrades", "losstrades",
                           "eventrades"):
-                lines.append(f"    Series<int> {svar};")
+                lines.append(f"    Series<int> {svar}{_mbb};")
             else:
-                lines.append(f"    Series<double> {svar};")
+                lines.append(f"    Series<double> {svar}{_mbb};")
 
         # 8b. Global-scope non-var declarations as class members
         #     (so user-defined functions can reference them)
@@ -1051,7 +1140,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     if self._safe_name(vname) == orig_safe:
                         cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
                         if vname in self.ctx.series_vars:
-                            lines.append(f"    Series<{cpp_type}> {cloned_safe};")
+                            lines.append(f"    Series<{cpp_type}> {cloned_safe}{_mbb};")
                         elif vname in self._matrix_specs:
                             lines.append(f"    {self._type_spec_to_cpp(self._matrix_specs[vname])} {cloned_safe};")
                         elif vname in self._array_vars:
@@ -1066,7 +1155,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     # Non-var series var
                     if orig_safe in [self._safe_name(n) for n in self.ctx.series_vars]:
                         cpp_type = self._series_type_for(orig_safe)
-                        lines.append(f"    Series<{cpp_type}> {cloned_safe};")
+                        lines.append(f"    Series<{cpp_type}> {cloned_safe}{_mbb};")
                     else:
                         lines.append(f"    double {cloned_safe} = 0.0;")
 

{pineforge_codegen-0.7.1 → pineforge_codegen-0.7.3}/pineforge_codegen/codegen/visit_call.py

@@ -444,6 +444,11 @@ class CallVisitor:
             return "0"
         if func_name in SKIP_FUNC_NAMES and namespace is None:
             return "0"
+        # max_bars_back(var, num): a history-depth DIRECTIVE, not a value.
+        # Its effect is captured in CodeGen._compute_max_bars_back_cap (which
+        # sizes every Series<T> ring buffer), so the call itself emits nothing.
+        if func_name == "max_bars_back" and namespace is None:
+            return "0"
 
         # request.* calls
         if namespace == "request":