@pineforge/codegen-pyodide 0.7.0 → 0.7.2

package/glue.py

@@ -0,0 +1,35 @@
+# CANONICAL GLUE — runtime-equivalent to the body of PY_GLUE in
+# pineforge-app/apps/web/lib/pyodide-transpiler/glue.ts (produces identical
+# transpile_json output). The browser worker and this gate run the same logic,
+# so the gate's parity guarantee reflects shipped behavior.
+# (Phase 3: ship this from the npm package so there is one source of truth.)
+import json
+import sys
+
+if "/codegen" not in sys.path:
+    sys.path.insert(0, "/codegen")
+
+from pineforge_codegen import transpile
+from pineforge_codegen.errors import CompileError
+
+
+def transpile_json(source: str) -> str:
+    try:
+        cpp = transpile(source)
+    except CompileError as e:
+        diags = []
+        for d in e.diagnostics:
+            loc = d.location
+            message = d.message + " — " + d.hint if getattr(d, "hint", None) else d.message
+            entry = {
+                "line": loc.line if loc else 1,
+                "col": loc.col if loc else 1,
+                "message": message,
+                "severity": getattr(d.level, "value", "error"),
+            }
+            end_col = getattr(loc, "end_col", None) if loc else None
+            if end_col is not None:
+                entry["endCol"] = end_col
+            diags.append(entry)
+        return json.dumps({"ok": False, "error": str(e), "diagnostics": diags})
+    return json.dumps({"ok": True, "cpp": cpp})

package/index.mjs

@@ -1,6 +1,7 @@
 // Entry for @pineforge/codegen-pyodide. Resolves the packaged payload paths and
 // metadata so consumers (the app's build + Node oracle/grammar tooling) read
 // everything from this one dependency — no git submodule.
+import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -18,3 +19,12 @@ export const archivePath = join(HERE, `pineforge_codegen-${release.codegen}.tar.
 // so `import pineforge_codegen` resolves (oracle tests, grammar gen).
 export const sourceRoot = HERE;
 export const codegenSourceDir = join(HERE, "pineforge_codegen");
+
+// Absolute path to the shipped ESM module worker — consumers copy it into their
+// served /pyodide/ dir and load it via `new Worker(url, { type: "module" })`.
+export const workerPath = join(HERE, "transpile.worker.mjs");
+
+// Canonical Pyodide glue source (single source: gate/glue.py) — runPython'd to
+// define transpile_json. The worker embeds this verbatim; exported here too so
+// Node consumers (parity tests) run the exact same glue.
+export const glue = readFileSync(join(HERE, "glue.py"), "utf8");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pineforge/codegen-pyodide",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Gate-validated Pyodide payload for the PineScript v6 -> C++ transpiler: archive (run in Pyodide), unpacked source, introspected tables, and release metadata.",
   "type": "module",
   "main": "index.mjs",
@@ -14,7 +14,9 @@
     "pineforge_codegen-*.tar.gz",
     "pineforge_codegen/**/*",
     "tables.json",
-    "release.json"
+    "release.json",
+    "transpile.worker.mjs",
+    "glue.py"
   ],
   "engines": {
     "node": ">=20"
@@ -22,7 +24,12 @@
   "peerDependencies": {
     "pyodide": "314.0.0"
   },
-  "keywords": ["pinescript", "transpiler", "pyodide", "codegen"],
+  "keywords": [
+    "pinescript",
+    "transpiler",
+    "pyodide",
+    "codegen"
+  ],
   "homepage": "https://github.com/pineforge-4pass/pineforge-codegen-oss",
   "repository": {
     "type": "git",

package/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)

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "0.7.0",
+  "codegen": "0.7.2",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "1ff4cb99ed80119cb6a9bd639bec1c2a6739654320fb4cf2f6fa37a8d4441710"
+  "sha256": "343bba428db5fc925dc0ba459fed888bdf974496333b7d74c27f695afaca3e23"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "0.7.0",
+  "CODEGEN_VERSION": "0.7.2",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",

package/transpile.worker.mjs

@@ -0,0 +1,84 @@
+// GENERATED by scripts/build-npm-package.mjs from gate/glue.py — DO NOT EDIT.
+// Canonical client-side Pyodide transpile worker, shipped by
+// @pineforge/codegen-pyodide. Consumers serve it from /pyodide/ and load it via:
+//   new Worker("/pyodide/transpile.worker.mjs", { type: "module" })
+// A real ESM module worker (string-URL load bypasses the bundler), so Pyodide
+// 314's module-worker requirement is satisfied. Mirrors the old in-app
+// transpile.worker.ts; protocol is identical (see app protocol.ts).
+import { loadPyodide } from "/pyodide/pyodide.mjs";
+
+const GLUE = `# CANONICAL GLUE — runtime-equivalent to the body of PY_GLUE in
+# pineforge-app/apps/web/lib/pyodide-transpiler/glue.ts (produces identical
+# transpile_json output). The browser worker and this gate run the same logic,
+# so the gate's parity guarantee reflects shipped behavior.
+# (Phase 3: ship this from the npm package so there is one source of truth.)
+import json
+import sys
+
+if "/codegen" not in sys.path:
+    sys.path.insert(0, "/codegen")
+
+from pineforge_codegen import transpile
+from pineforge_codegen.errors import CompileError
+
+
+def transpile_json(source: str) -> str:
+    try:
+        cpp = transpile(source)
+    except CompileError as e:
+        diags = []
+        for d in e.diagnostics:
+            loc = d.location
+            message = d.message + " — " + d.hint if getattr(d, "hint", None) else d.message
+            entry = {
+                "line": loc.line if loc else 1,
+                "col": loc.col if loc else 1,
+                "message": message,
+                "severity": getattr(d.level, "value", "error"),
+            }
+            end_col = getattr(loc, "end_col", None) if loc else None
+            if end_col is not None:
+                entry["endCol"] = end_col
+            diags.append(entry)
+        return json.dumps({"ok": False, "error": str(e), "diagnostics": diags})
+    return json.dumps({"ok": True, "cpp": cpp})
+`;
+
+const post = (m) => self.postMessage(m);
+let transpileJson = null;
+
+async function init() {
+  try {
+    const pyodide = await loadPyodide({ indexURL: "/pyodide/" });
+    const manifestRes = await fetch("/pyodide/manifest.json", { cache: "no-cache" });
+    if (!manifestRes.ok) throw new Error(`fetch /pyodide/manifest.json: ${manifestRes.status}`);
+    const manifest = await manifestRes.json();
+    const archiveRes = await fetch(`/pyodide/${manifest.archive}`);
+    if (!archiveRes.ok) throw new Error(`fetch /pyodide/${manifest.archive}: ${archiveRes.status}`);
+    const buf = await archiveRes.arrayBuffer();
+    pyodide.unpackArchive(buf, "gztar", { extractDir: "/codegen" });
+    pyodide.runPython(GLUE);
+    const fn = pyodide.globals.get("transpile_json");
+    transpileJson = (source) => fn(source);
+    post({ type: "ready", codegenVersion: manifest.codegenVersion });
+  } catch (err) {
+    post({ type: "init-error", error: err instanceof Error ? err.message : String(err) });
+  }
+}
+
+const initPromise = init();
+
+self.onmessage = async (ev) => {
+  const { id, source } = ev.data;
+  await initPromise;
+  if (!transpileJson) {
+    post({ type: "crash", id, error: "pyodide failed to initialize" });
+    return;
+  }
+  try {
+    const result = JSON.parse(transpileJson(source));
+    post({ type: "result", id, result });
+  } catch (err) {
+    post({ type: "crash", id, error: err instanceof Error ? err.message : String(err) });
+  }
+};