@geml/geml 1.1.1 → 1.4.2

package/codemap/entries.mjs

@@ -0,0 +1,129 @@
+// geml-code-graph app-entry detection — WHERE does this repo start running?
+//
+// Emits entry HINTS ({ file, via, name? }) from three signal tiers, each
+// carrying an honest `via` label (the codemap never claims an entry without
+// saying what convention identified it):
+//   L2 manifest/layout   Cargo [[bin]] & src/main.rs & src/bin/*, package.json
+//                        bin, wrangler.toml main, Nuxt app.vue, Next root
+//                        page, SvelteKit root route, Django manage.py,
+//                        python __main__.py
+//   L3 source markers    workers-rs #[event(...)], createApp().mount() /
+//                        createRoot() / svelte mount (SPA bootstraps),
+//                        .listen() (node servers), export default { fetch }
+//                        (JS workers), Flask()/FastAPI() apps,
+//                        @SpringBootApplication
+// (L1 — a function literally named `main` — is already flagged by the scip
+// and joern adapters at extraction time; hints here ADD to it.)
+//
+// Pure by design: given precomputed { files, manifests, pkgs } lists it walks
+// nothing; `readText`/`readJson` are injectable, and every source peek is
+// bounded to a handful of conventional entry files per project — never a
+// repo-wide grep. A hint is only emitted for files the build actually indexes
+// (present in `files`), so a pkg-bin pointing at dist/ never leaks in.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const dirOf = (p) => (p.includes("/") ? p.slice(0, p.lastIndexOf("/")) : "");
+
+export function detectEntries(root, { files = [], manifests = [], pkgs = [], readText, readJson } = {}) {
+  readText ??= (p) => readFileSync(p, "utf8");
+  readJson ??= (p) => JSON.parse(readText(p));
+  const fileSet = new Set(files);
+  const hints = [];
+  const seen = new Set();
+  const add = (file, via, name) => {
+    if (!file || !fileSet.has(file)) return;
+    const k = `${file}
${via}
${name ?? ""}`;
+    if (seen.has(k)) return;
+    seen.add(k);
+    hints.push(name ? { file, via, name } : { file, via });
+  };
+  const tryText = (rel) => {
+    try { return readText(join(root, ...rel.split("/"))); } catch { return null; }
+  };
+
+  // ---- Rust: cargo bin targets + workers-rs event handlers ----
+  for (const m of manifests.filter((x) => x.endsWith("Cargo.toml"))) {
+    const dir = dirOf(m);
+    const at = (rel) => (dir ? `${dir}/${rel}` : rel);
+    add(at("src/main.rs"), "cargo-bin", "main");
+    for (const f of files) if (f.startsWith(at("src/bin/")) && f.endsWith(".rs")) add(f, "cargo-bin", "main");
+    const toml = tryText(m);
+    if (toml) {
+      for (const b of toml.matchAll(/^\[\[bin\]\][^[]*/gm)) {
+        const p = /path\s*=\s*"([^"]+)"/.exec(b[0]);
+        if (p) add(at(p[1].replace(/\\/g, "/")), "cargo-bin", "main");
+      }
+    }
+    for (const rel of ["src/main.rs", "src/lib.rs"]) {
+      const t = fileSet.has(at(rel)) ? tryText(at(rel)) : null;
+      if (!t) continue;
+      for (const ev of t.matchAll(/#\[event\((\w+)[^)]*\)\]\s*(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_][A-Za-z0-9_]*)/g)) {
+        add(at(rel), `worker-${ev[1]}`, ev[2]);
+      }
+    }
+  }
+
+  // ---- Node/TS/frontends: one look per package ----
+  for (const p of pkgs) {
+    const dir = dirOf(p);
+    const at = (rel) => (dir ? `${dir}/${rel}` : rel);
+    let pkg = {};
+    try { pkg = readJson(join(root, ...p.split("/"))) ?? {}; } catch { /* unreadable manifest */ }
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const norm = (v) => (typeof v === "string" ? v.replace(/^\.\//, "").replace(/\\/g, "/") : null);
+    const bins = typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin ?? {});
+    for (const b of bins) { const f = norm(b); if (f) add(at(f), "pkg-bin"); }
+    const wrangler = tryText(at("wrangler.toml"));
+    if (wrangler) {
+      const mm = /^\s*main\s*=\s*"([^"]+)"/m.exec(wrangler);
+      if (mm) add(at(norm(mm[1])), "worker-fetch");
+    }
+    // Nuxt: the app shell is the entry; individual pages are routes, not
+    // program starts — deliberately NOT flooded into app-entries.
+    if (deps.nuxt || fileSet.has(at("nuxt.config.ts")) || fileSet.has(at("nuxt.config.js"))) {
+      if (fileSet.has(at("app.vue"))) add(at("app.vue"), "nuxt-app");
+      else add(at("pages/index.vue"), "nuxt-page");
+    }
+    if (deps.next) {
+      for (const rel of ["app/page.tsx", "app/page.jsx", "src/app/page.tsx", "pages/index.tsx", "pages/index.jsx", "src/pages/index.tsx"]) {
+        if (fileSet.has(at(rel))) { add(at(rel), "next-page"); break; }
+      }
+    }
+    if (deps["@sveltejs/kit"]) add(at("src/routes/+page.svelte"), "kit-route");
+    // SPA bootstrap / server start markers — conventional entry files only.
+    for (const rel of ["src/main.ts", "src/main.tsx", "src/main.js", "src/main.jsx",
+      "src/index.ts", "src/index.tsx", "src/index.js", "index.ts", "index.js",
+      "src/server.ts", "src/server.js", "server.js", "src/app.ts", "app.js"]) {
+      const f = at(rel);
+      if (!fileSet.has(f)) continue;
+      const t = tryText(f);
+      if (!t) continue;
+      if (/createApp\s*\(/.test(t) && /\.mount\s*\(/.test(t)) add(f, "vue-mount");
+      else if (/createRoot\s*\(|ReactDOM\.render\s*\(/.test(t)) add(f, "react-mount");
+      else if (deps.svelte && /\bnew\s+\w+\s*\(\s*\{[^}]*target|\bmount\s*\(/.test(t)) add(f, "svelte-mount");
+      if (/\.listen\s*\(/.test(t)) add(f, "server-listen");
+      if (/export\s+default\s*\{[^}]*\bfetch\b/s.test(t)) add(f, "worker-fetch");
+    }
+  }
+
+  // ---- Python ----
+  for (const f of files) {
+    if (/(^|\/)manage\.py$/.test(f)) add(f, "django-manage");
+    else if (/(^|\/)__main__\.py$/.test(f)) add(f, "py-main");
+    else if (/(^|\/)(app|main|wsgi|asgi)\.py$/.test(f)) {
+      const t = tryText(f);
+      if (t && /\bFlask\s*\(|\bFastAPI\s*\(/.test(t)) add(f, "wsgi-app");
+    }
+  }
+
+  // ---- Java: Spring Boot (convention-named files only, never a repo grep) ----
+  for (const f of files) {
+    if (/Application\.java$/.test(f)) {
+      const t = tryText(f);
+      if (t && /@SpringBootApplication/.test(t)) add(f, "spring-boot", "main");
+    }
+  }
+
+  return hints;
+}

package/codemap/exclude.mjs

@@ -1,52 +1,52 @@
-// Source exclusion for the codemap build.
-//
-// Two mechanisms, both matching on a symbol's repo-relative POSIX file path:
-//   1. .gitignore — the default. Whatever git ignores (vendored copies, build
-//      output, dependency dumps) never enters the graph. Uses `git check-ignore`
-//      so the semantics are exactly git's, including un-committed .gitignore
-//      edits (check-ignore reads the working tree).
-//   2. --exclude <glob> — explicit, repeatable, for paths git still tracks that
-//      you nonetheless don't want in the graph.
-// Neither touches the raw indexer output; excluded symbols are dropped before
-// emit, and the edge tables (which key on surviving anchors) follow.
-
-import { execFileSync as _execFileSync } from "node:child_process";
-
-// Minimal gitignore-flavoured glob: `**` spans path separators, `*` stays
-// within a segment, everything else is literal. Anchored to the whole path.
-export function globToRegExp(glob) {
-  let re = "";
-  for (let i = 0; i < glob.length; i++) {
-    const c = glob[i];
-    if (c === "*") {
-      if (glob[i + 1] === "*") { re += ".*"; i++; if (glob[i + 1] === "/") i++; }
-      else re += "[^/]*";
-    } else if ("\\^$+?.()|{}[]".includes(c)) {
-      re += "\\" + c;
-    } else {
-      re += c;
-    }
-  }
-  return new RegExp("^" + re + "$");
-}
-
-// Ask git which of `files` it ignores. Returns a Set of the ignored paths.
-// check-ignore exits 1 when nothing matches and 128 when git is unavailable /
-// the dir is not a repo — both mean "ignore nothing", not a build failure.
-export function gitIgnored(root, files, exec = _execFileSync) {
-  if (!files.length) return new Set();
-  try {
-    const out = exec("git", ["-C", root, "check-ignore", "--stdin"], { input: files.join("\n"), encoding: "utf8" });
-    return new Set(out.split(/\r?\n/).filter(Boolean));
-  } catch (e) {
-    const out = e && e.stdout ? String(e.stdout) : "";
-    return new Set(out.split(/\r?\n/).filter(Boolean));
-  }
-}
-
-// Build a predicate (file) => shouldExclude.
-export function makeExcluder({ root, globs = [], gitignore = true, files = [], exec } = {}) {
-  const res = globs.map(globToRegExp);
-  const ignored = gitignore ? gitIgnored(root, files, exec) : new Set();
-  return (file) => ignored.has(file) || res.some((r) => r.test(file));
-}
+// Source exclusion for the codemap build.
+//
+// Two mechanisms, both matching on a symbol's repo-relative POSIX file path:
+//   1. .gitignore — the default. Whatever git ignores (vendored copies, build
+//      output, dependency dumps) never enters the graph. Uses `git check-ignore`
+//      so the semantics are exactly git's, including un-committed .gitignore
+//      edits (check-ignore reads the working tree).
+//   2. --exclude <glob> — explicit, repeatable, for paths git still tracks that
+//      you nonetheless don't want in the graph.
+// Neither touches the raw indexer output; excluded symbols are dropped before
+// emit, and the edge tables (which key on surviving anchors) follow.
+
+import { execFileSync as _execFileSync } from "node:child_process";
+
+// Minimal gitignore-flavoured glob: `**` spans path separators, `*` stays
+// within a segment, everything else is literal. Anchored to the whole path.
+export function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") { re += ".*"; i++; if (glob[i + 1] === "/") i++; }
+      else re += "[^/]*";
+    } else if ("\\^$+?.()|{}[]".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp("^" + re + "$");
+}
+
+// Ask git which of `files` it ignores. Returns a Set of the ignored paths.
+// check-ignore exits 1 when nothing matches and 128 when git is unavailable /
+// the dir is not a repo — both mean "ignore nothing", not a build failure.
+export function gitIgnored(root, files, exec = _execFileSync) {
+  if (!files.length) return new Set();
+  try {
+    const out = exec("git", ["-C", root, "check-ignore", "--stdin"], { input: files.join("\n"), encoding: "utf8" });
+    return new Set(out.split(/\r?\n/).filter(Boolean));
+  } catch (e) {
+    const out = e && e.stdout ? String(e.stdout) : "";
+    return new Set(out.split(/\r?\n/).filter(Boolean));
+  }
+}
+
+// Build a predicate (file) => shouldExclude.
+export function makeExcluder({ root, globs = [], gitignore = true, files = [], exec } = {}) {
+  const res = globs.map(globToRegExp);
+  const ignored = gitignore ? gitIgnored(root, files, exec) : new Set();
+  return (file) => ignored.has(file) || res.some((r) => r.test(file));
+}

package/codemap/find.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// geml codemap find <name> [codemap-dir]
+//
+// Locate a function/class by (substring, case-insensitive) name in a built
+// codemap. Prints each candidate as  <name> \t <doc>#<id> \t <src>  — the
+// document + block id to open, and the true source location. NO browser: pure
+// stdout, so it pipes/greps. `dir` defaults to ./.geml-code-graph.
+//
+// Same index the MCP `resolve_name` tool and the viewer search box use
+// (_index/name-lookup.json); a name with several rows is real ambiguity
+// (overloads / same short name across classes) — every candidate is printed.
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+// `find x | head` closes stdout after a few lines — that is normal pipe
+// usage, not an error (POSIX would kill us silently with SIGPIPE; Windows
+// node surfaces it as an EPIPE error event): exit quietly instead of
+// crashing with an unhandled-error stack trace.
+process.stdout.on("error", (e) => { if (e.code === "EPIPE") process.exit(0); throw e; });
+
+const args = process.argv.slice(2);
+if (!args.length || args[0] === "--help" || args[0] === "-h") {
+  console.error("usage: geml codemap find <name> [codemap-dir]   # locate a symbol by substring name (dir defaults to ./.geml-code-graph)");
+  process.exit(args.length ? 0 : 2);
+}
+const query = args[0];
+const dir = args[1] || ".geml-code-graph";
+const lookupPath = join(dir, "_index", "name-lookup.json");
+if (!existsSync(lookupPath)) {
+  console.error(`no name-lookup at ${lookupPath} — build the codemap first (geml codemap build)`);
+  process.exit(1);
+}
+const lookup = JSON.parse(readFileSync(lookupPath, "utf8"));
+const q = query.toLowerCase();
+const names = Object.keys(lookup).filter((n) => n.toLowerCase().includes(q)).sort();
+if (!names.length) { console.error(`no symbol matching "${query}"`); process.exit(1); }
+
+// src= lives on the block header line in the doc; read each doc once, index by id.
+const docCache = new Map(); // doc -> Map(id -> src)
+const srcOf = (doc, id) => {
+  if (!docCache.has(doc)) {
+    const map = new Map();
+    try {
+      const text = readFileSync(join(dir, doc), "utf8");
+      // src= may be quoted or a bare token (path#Lx-y, no spaces).
+      const re = /\{#([A-Za-z0-9._-]+)\b[^}]*?\bsrc=(?:"([^"]+)"|([^\s}]+))/g;
+      let m;
+      while ((m = re.exec(text))) map.set(m[1], m[2] || m[3]);
+    } catch { /* doc unreadable — skip src */ }
+    docCache.set(doc, map);
+  }
+  return docCache.get(doc).get(id) || "";
+};
+
+let n = 0;
+for (const name of names) {
+  for (const c of lookup[name]) {
+    const src = srcOf(c.doc, c.id);
+    process.stdout.write(`${name}\t${c.doc}#${c.id}${src ? `\t${src}` : ""}\n`);
+    n++;
+  }
+}
+console.error(`\n${n} match(es) for "${query}" across ${names.length} name(s).`);

package/codemap/foldings.mjs

@@ -0,0 +1,110 @@
+// foldings.geml — the visible, human-owned config for codemap ceremony folding.
+// GEML (dogfooded; the viewer renders it): a meta header, three bullet-list
+// sections (fold-prefixes / source-roots / test-roots) and an options section.
+// Read via the bundled parser; group-id shared-prefix stripping stays
+// algorithmic (only its on/off toggle lives here).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "../dist/geml.js";
+import { deriveFoldLayers, DEFAULT_SOURCE_ROOTS, DEFAULT_TEST_ROOTS, LANG_FOLD_PREFIXES } from "./normalize.mjs";
+
+const SECTIONS = { "fold-prefixes": "foldPrefixes", "source-roots": "sourceRoots", "test-roots": "testRoots", "module-roots": "moduleRoots" };
+// Plain text of a bullet-list item. GEML list items carry `.text`; fall back to
+// joining inline `.value`s if a build ever changes that shape.
+const itemText = (it) => (typeof it.text === "string" ? it.text : (it.inlines ?? []).map((n) => n.value ?? "").join("")).trim();
+
+export function parseFoldings(text) {
+  const doc = parse(text);
+  // A malformed hand-edit must fail LOUDLY, not silently drop every rule: the
+  // caller (loadOrSeedFoldings) catches this and falls back to the defaults.
+  // An intentionally empty file carries NO error diagnostics and yields empty
+  // sections — the "fold nothing" off-switch, a deliberately different outcome.
+  const errs = doc.diagnostics.filter((d) => d.severity === "error");
+  if (errs.length) throw new Error(`invalid GEML in foldings config: ${errs[0].message} (line ${errs[0].line})`);
+  const cfg = { foldPrefixes: [], sourceRoots: [], testRoots: [], moduleRoots: [], stripSharedPrefix: true };
+  let section = null;
+  for (const b of doc.children) {
+    if (b.kind === "heading") { section = b.text.trim().toLowerCase(); continue; }
+    if (b.kind !== "list") continue;
+    const items = b.items.map(itemText).filter(Boolean);
+    if (Object.hasOwn(SECTIONS, section)) cfg[SECTIONS[section]] = items;
+    else if (section === "options") {
+      for (const it of items) {
+        const m = it.match(/^strip-shared-prefix\s*:\s*(on|off|true|false)$/i);
+        if (m) cfg.stripSharedPrefix = /^(on|true)$/i.test(m[1]);
+      }
+    }
+  }
+  return cfg;
+}
+
+export function serializeFoldings(cfg) {
+  const list = (xs) => xs.map((x) => `- ${x}`).join("\n");
+  return [
+    "=== meta",
+    'title = "codemap foldings"',
+    "===",
+    "",
+    "Ceremony folded out of module display names. Seeded on first build; edit",
+    "freely — build never rewrites this. The shared package prefix (group-ids",
+    "like com/acme/app) is stripped automatically and needs no entry here; set",
+    "strip-shared-prefix to off under Options to disable it.",
+    "",
+    "Add a directory under module-roots to force it to display as its own",
+    "module — for a submodule a build tool declares centrally but whose folder",
+    "carries no manifest, or any layout the detector cannot see.",
+    "",
+    "## fold-prefixes",
+    "",
+    list(cfg.foldPrefixes),
+    "",
+    "## source-roots",
+    "",
+    list(cfg.sourceRoots),
+    "",
+    "## test-roots",
+    "",
+    list(cfg.testRoots),
+    "",
+    "## module-roots",
+    "",
+    list(cfg.moduleRoots ?? []),
+    "",
+    "## options",
+    "",
+    `- strip-shared-prefix: ${cfg.stripSharedPrefix ? "on" : "off"}`,
+    "",
+  ].join("\n");
+}
+
+// Seeded config for a first build: structural fold-layers (above-root
+// ceremony dirs, derived from the discovered module roots) unioned with
+// known per-language ceremony (Cargo's `crates/`). Source/test roots always
+// start from the same global defaults — the human edits foldings.geml from
+// there; the build never rewrites it once it exists.
+export function defaultFoldings({ moduleRoots, languages }) {
+  const langPrefixes = (languages ?? []).flatMap((l) => LANG_FOLD_PREFIXES[l] ?? []);
+  const foldPrefixes = [...new Set([...deriveFoldLayers(moduleRoots ?? []), ...langPrefixes])].sort();
+  return { foldPrefixes, sourceRoots: [...DEFAULT_SOURCE_ROOTS], testRoots: [...DEFAULT_TEST_ROOTS], moduleRoots: [], stripSharedPrefix: true };
+}
+
+// Read <outDir>/_index/foldings.geml, or seed it on first build. Write-once:
+// an existing file is the human's — we read it and never rewrite it (the
+// refresh.json contract). A missing or unreadable file never crashes the
+// build: seed/fall back to defaults and say so. Returns { config, seeded }.
+export function loadOrSeedFoldings({ outDir, moduleRoots, languages }) {
+  const path = join(outDir, "_index", "foldings.geml");
+  if (existsSync(path)) {
+    try { return { config: parseFoldings(readFileSync(path, "utf8")), seeded: false }; }
+    catch (e) {
+      console.error(`warning: ignoring ${path} (${e.message}) — using default foldings; fix the file to re-enable your edits.`);
+      return { config: defaultFoldings({ moduleRoots, languages }), seeded: false };
+    }
+  }
+  const config = defaultFoldings({ moduleRoots, languages });
+  try {
+    mkdirSync(join(outDir, "_index"), { recursive: true });
+    writeFileSync(path, serializeFoldings(config));
+  } catch (e) { console.error(`warning: could not seed ${path} (${e.message}).`); }
+  return { config, seeded: true };
+}

package/codemap/joern-export.sc

@@ -1,83 +1,83 @@
-// geml-code-graph Joern export (P1, DESIGN §3.4).
-// Runs INSIDE joern; emits raw method/call records as JSONL for adapters/joern.mjs.
-//
-// Parameters come from ENVIRONMENT VARIABLES, not --param: on Windows the
-// joern.bat -> repl-bridge.bat hop re-tokenizes %* and cmd.exe treats `=` as a
-// delimiter, so `--param k=v` never survives intact. Env vars pass through
-// every layer on every OS:
-//
-//   GEML_SRC=/abs/path/to/src GEML_OUT=/abs/path/to/build/raw \
-//     joern --script geml-parser/codemap/joern-export.sc
-//
-// Output:
-//   <GEML_OUT>/methods.jsonl   one record per internal method
-//   <GEML_OUT>/calls.jsonl     one record per call site, callees resolved by Joern
-//
-// Identity: methods are keyed by fullName|signature|filename — the adapter
-// mints anchors and stable ids from these; this script stays dumb on purpose.
-import java.io.{File, PrintWriter}
-
-@main def exec(): Unit = {
-  val codeDir = sys.env.getOrElse("GEML_SRC", { System.err.println("GEML_SRC not set"); sys.exit(2) })
-  val outDir = sys.env.getOrElse("GEML_OUT", { System.err.println("GEML_OUT not set"); sys.exit(2) })
-  // GEML_LANG (optional): force a frontend in mixed-language repos, where
-  // auto-detection may pick the majority language instead of the intended one.
-  // Values are Joern's --language names: JAVASRC, NEWC, PYTHONSRC, JSSRC, …
-  sys.env.get("GEML_LANG") match {
-    case Some(lang) => importCode(inputPath = codeDir, projectName = "geml-code-graph", language = lang)
-    case None       => importCode(inputPath = codeDir, projectName = "geml-code-graph")
-  }
-
-  def esc(s: String): String =
-    s.replace("\\", "\\\\").replace("\"", "\\\"")
-     .replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
-  def jstr(s: String): String = "\"" + esc(s) + "\""
-
-  new File(outDir).mkdirs()
-
-  val skipName = (n: String) => n == "<global>" || n.startsWith("<operator>") || n.startsWith("<clinit>")
-
-  // ---- methods ----
-  val mOut = new PrintWriter(new File(outDir, "methods.jsonl"), "UTF-8")
-  cpg.method.filter(m => !m.isExternal && !skipName(m.name)).foreach { m =>
-    mOut.println(
-      s"""{"name":${jstr(m.name)},"fullName":${jstr(m.fullName)},"signature":${jstr(m.signature)},""" +
-      s""""file":${jstr(m.filename)},"lineStart":${m.lineNumber.map(_.toString).getOrElse("null")},""" +
-      s""""lineEnd":${m.lineNumberEnd.map(_.toString).getOrElse("null")}}"""
-    )
-  }
-  mOut.close()
-
-  // ---- calls ----
-  // For each call site inside an internal method: Joern-resolved callees.
-  // Several internal callees = dispatch candidates (the adapter keeps them ALL,
-  // per the "never force a single candidate" red line). No internal callee =
-  // unresolved from the graph's point of view (external / pointer call).
-  // Operator calls are noise (arithmetic, casts, field access) EXCEPT
-  // <operator>.pointerCall — a function-pointer invocation is a real dispatch
-  // site the graph cannot resolve statically, so it must surface as an
-  // unresolved call (blind spots are shown, not hidden). Its readable label is
-  // the source expression itself.
-  val cOut = new PrintWriter(new File(outDir, "calls.jsonl"), "UTF-8")
-  cpg.call.filterNot(c => c.name.startsWith("<operator>") && c.name != "<operator>.pointerCall").foreach { c =>
-    val caller = c.method
-    if (!caller.isExternal && !skipName(caller.name)) {
-      val callees = c.callee.l
-      val internal = callees.filter(m => !m.isExternal && !skipName(m.name))
-      val tos = internal.map(m =>
-        s"""{"fullName":${jstr(m.fullName)},"signature":${jstr(m.signature)},"file":${jstr(m.filename)}}"""
-      ).mkString("[", ",", "]")
-      val label =
-        if (c.name == "<operator>.pointerCall") c.code.takeWhile(_ != '\n').take(48)
-        else c.name
-      cOut.println(
-        s"""{"callerFullName":${jstr(caller.fullName)},"callerSignature":${jstr(caller.signature)},""" +
-        s""""callerFile":${jstr(caller.filename)},"name":${jstr(label)},""" +
-        s""""line":${c.lineNumber.map(_.toString).getOrElse("null")},"callees":$tos}"""
-      )
-    }
-  }
-  cOut.close()
-
-  println(s"geml-code-graph joern-export: done -> $outDir")
-}
+// geml-code-graph Joern export (P1, DESIGN §3.4).
+// Runs INSIDE joern; emits raw method/call records as JSONL for adapters/joern.mjs.
+//
+// Parameters come from ENVIRONMENT VARIABLES, not --param: on Windows the
+// joern.bat -> repl-bridge.bat hop re-tokenizes %* and cmd.exe treats `=` as a
+// delimiter, so `--param k=v` never survives intact. Env vars pass through
+// every layer on every OS:
+//
+//   GEML_SRC=/abs/path/to/src GEML_OUT=/abs/path/to/build/raw \
+//     joern --script geml-parser/codemap/joern-export.sc
+//
+// Output:
+//   <GEML_OUT>/methods.jsonl   one record per internal method
+//   <GEML_OUT>/calls.jsonl     one record per call site, callees resolved by Joern
+//
+// Identity: methods are keyed by fullName|signature|filename — the adapter
+// mints anchors and stable ids from these; this script stays dumb on purpose.
+import java.io.{File, PrintWriter}
+
+@main def exec(): Unit = {
+  val codeDir = sys.env.getOrElse("GEML_SRC", { System.err.println("GEML_SRC not set"); sys.exit(2) })
+  val outDir = sys.env.getOrElse("GEML_OUT", { System.err.println("GEML_OUT not set"); sys.exit(2) })
+  // GEML_LANG (optional): force a frontend in mixed-language repos, where
+  // auto-detection may pick the majority language instead of the intended one.
+  // Values are Joern's --language names: JAVASRC, NEWC, PYTHONSRC, JSSRC, …
+  sys.env.get("GEML_LANG") match {
+    case Some(lang) => importCode(inputPath = codeDir, projectName = "geml-code-graph", language = lang)
+    case None       => importCode(inputPath = codeDir, projectName = "geml-code-graph")
+  }
+
+  def esc(s: String): String =
+    s.replace("\\", "\\\\").replace("\"", "\\\"")
+     .replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
+  def jstr(s: String): String = "\"" + esc(s) + "\""
+
+  new File(outDir).mkdirs()
+
+  val skipName = (n: String) => n == "<global>" || n.startsWith("<operator>") || n.startsWith("<clinit>")
+
+  // ---- methods ----
+  val mOut = new PrintWriter(new File(outDir, "methods.jsonl"), "UTF-8")
+  cpg.method.filter(m => !m.isExternal && !skipName(m.name)).foreach { m =>
+    mOut.println(
+      s"""{"name":${jstr(m.name)},"fullName":${jstr(m.fullName)},"signature":${jstr(m.signature)},""" +
+      s""""file":${jstr(m.filename)},"lineStart":${m.lineNumber.map(_.toString).getOrElse("null")},""" +
+      s""""lineEnd":${m.lineNumberEnd.map(_.toString).getOrElse("null")}}"""
+    )
+  }
+  mOut.close()
+
+  // ---- calls ----
+  // For each call site inside an internal method: Joern-resolved callees.
+  // Several internal callees = dispatch candidates (the adapter keeps them ALL,
+  // per the "never force a single candidate" red line). No internal callee =
+  // unresolved from the graph's point of view (external / pointer call).
+  // Operator calls are noise (arithmetic, casts, field access) EXCEPT
+  // <operator>.pointerCall — a function-pointer invocation is a real dispatch
+  // site the graph cannot resolve statically, so it must surface as an
+  // unresolved call (blind spots are shown, not hidden). Its readable label is
+  // the source expression itself.
+  val cOut = new PrintWriter(new File(outDir, "calls.jsonl"), "UTF-8")
+  cpg.call.filterNot(c => c.name.startsWith("<operator>") && c.name != "<operator>.pointerCall").foreach { c =>
+    val caller = c.method
+    if (!caller.isExternal && !skipName(caller.name)) {
+      val callees = c.callee.l
+      val internal = callees.filter(m => !m.isExternal && !skipName(m.name))
+      val tos = internal.map(m =>
+        s"""{"fullName":${jstr(m.fullName)},"signature":${jstr(m.signature)},"file":${jstr(m.filename)}}"""
+      ).mkString("[", ",", "]")
+      val label =
+        if (c.name == "<operator>.pointerCall") c.code.takeWhile(_ != '\n').take(48)
+        else c.name
+      cOut.println(
+        s"""{"callerFullName":${jstr(caller.fullName)},"callerSignature":${jstr(caller.signature)},""" +
+        s""""callerFile":${jstr(caller.filename)},"name":${jstr(label)},""" +
+        s""""line":${c.lineNumber.map(_.toString).getOrElse("null")},"callees":$tos}"""
+      )
+    }
+  }
+  cOut.close()
+
+  println(s"geml-code-graph joern-export: done -> $outDir")
+}