@vibgrate/cli 2026.728.3 → 2026.728.4

package/dist/chunk-IPICO2RV.js

@@ -0,0 +1,789 @@
+import { shortId, canonicalize } from './chunk-JFGYT6BI.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+var JS_TS_EXT = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".vue", ".svelte", ".astro"];
+var OTHER_EXT = [
+  ".py",
+  ".pyi",
+  ".go",
+  ".rs",
+  ".rb",
+  ".java",
+  ".cs",
+  ".php",
+  ".kt",
+  ".kts",
+  ".swift",
+  ".scala",
+  ".sc",
+  ".dart",
+  ".lua",
+  ".ex",
+  ".exs",
+  ".sh",
+  ".bash",
+  ".zig",
+  ".c",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".hpp",
+  ".hh",
+  ".hxx",
+  ".h",
+  ".m",
+  ".mm",
+  ".ml",
+  ".mli",
+  ".res",
+  ".sol"
+];
+var EXT_GROUPS = {
+  ".py": [".py", ".pyi"],
+  ".pyi": [".py", ".pyi"],
+  ".java": [".java"],
+  ".cs": [".cs"],
+  ".go": [".go"],
+  ".rs": [".rs"],
+  ".rb": [".rb"]
+};
+for (const e of JS_TS_EXT) EXT_GROUPS[e] = JS_TS_EXT;
+var CPP_EXT = [".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx", ".h"];
+Object.assign(EXT_GROUPS, {
+  ".php": [".php"],
+  ".kt": [".kt", ".kts"],
+  ".kts": [".kt", ".kts"],
+  ".swift": [".swift"],
+  ".scala": [".scala", ".sc"],
+  ".sc": [".scala", ".sc"],
+  ".dart": [".dart"],
+  ".lua": [".lua"],
+  ".ex": [".ex", ".exs"],
+  ".exs": [".ex", ".exs"],
+  ".sh": [".sh", ".bash"],
+  ".bash": [".sh", ".bash"],
+  ".zig": [".zig"],
+  ".c": [".c", ".h"],
+  ".cpp": CPP_EXT,
+  ".cc": CPP_EXT,
+  ".cxx": CPP_EXT,
+  ".hpp": CPP_EXT,
+  ".hh": CPP_EXT,
+  ".hxx": CPP_EXT,
+  ".h": [...CPP_EXT, ".c"],
+  // ObjC #imports headers; ObjC++ additionally reaches C++ headers.
+  ".m": [".h", ".m", ".mm"],
+  ".mm": [".h", ".m", ".mm", ...CPP_EXT],
+  ".ml": [".ml", ".mli"],
+  ".mli": [".ml", ".mli"],
+  ".res": [".res"],
+  ".sol": [".sol"],
+  // Template containers: ERB fragments are Ruby; HTML/EJS script is JS.
+  ".erb": [".rb", ".erb"],
+  ".html": JS_TS_EXT,
+  ".htm": JS_TS_EXT,
+  ".ejs": JS_TS_EXT
+});
+function buildModuleResolver(root, relSet) {
+  const probe = makeProbe(relSet);
+  const suffixIndex = buildSuffixIndex(relSet);
+  const tsPaths = loadTsconfigPaths(root);
+  const workspaces = loadWorkspacePackages(root);
+  function resolveAlias(source) {
+    if (!tsPaths) return null;
+    for (const [pattern, targets] of tsPaths.paths) {
+      const m = matchPattern(pattern, source);
+      if (m === null) continue;
+      for (const target of targets) {
+        const sub = target.replace("*", m);
+        const rel = posixJoin(tsPaths.baseUrlRel, sub);
+        const hit = probe(rel);
+        if (hit) return hit;
+      }
+    }
+    return null;
+  }
+  function resolveWorkspace(source) {
+    if (!workspaces.size) return null;
+    let best = null;
+    for (const [name, dirRel] of workspaces) {
+      if (source === name || source.startsWith(`${name}/`)) {
+        const rest = source === name ? "" : source.slice(name.length + 1);
+        if (!best || name.length > best.dirRel.length) best = { dirRel, rest };
+      }
+    }
+    if (!best) return null;
+    const base = best.rest ? posixJoin(best.dirRel, best.rest) : best.dirRel;
+    return probe(base) ?? probe(posixJoin(base, "src/index")) ?? probe(posixJoin(base, "index"));
+  }
+  return {
+    resolve(fromRel, source) {
+      if (source.includes("\\")) source = source.split("\\").join(".");
+      if (source.startsWith("./") || source.startsWith("../")) {
+        return probe(posixJoin(path.posix.dirname(fromRel), source));
+      }
+      if (/\.[A-Za-z0-9]+$/.test(source) && !source.startsWith("<")) {
+        const hit = probe(posixJoin(path.posix.dirname(fromRel), source));
+        if (hit) return hit;
+      }
+      if (source.startsWith(".")) {
+        return resolvePyRelative(probe, fromRel, source);
+      }
+      return resolveAlias(source) ?? resolveWorkspace(source) ?? resolveSuffix(suffixIndex, fromRel, source) ?? resolveDotted(probe, source);
+    }
+  };
+}
+function buildSuffixIndex(relSet) {
+  const byLast = /* @__PURE__ */ new Map();
+  for (const rel of relSet) {
+    const dot = rel.lastIndexOf(".");
+    if (dot < 0) continue;
+    const ext = rel.slice(dot);
+    if (!EXT_GROUPS[ext]) continue;
+    let key = rel.slice(0, dot);
+    const base = key.slice(key.lastIndexOf("/") + 1);
+    if (base === "__init__" || base === "index") {
+      key = key.slice(0, Math.max(0, key.length - base.length - 1));
+    }
+    if (!key) continue;
+    const last = key.slice(key.lastIndexOf("/") + 1);
+    const list = byLast.get(last);
+    if (list) list.push({ rel, key, ext });
+    else byLast.set(last, [{ rel, key, ext }]);
+  }
+  return byLast;
+}
+function resolveSuffix(index, fromRel, source) {
+  if (!/^[A-Za-z_][\w.]*$/.test(source) || !source.includes(".")) return null;
+  const fromDot = fromRel.lastIndexOf(".");
+  const fromExt = fromDot >= 0 ? fromRel.slice(fromDot) : "";
+  const allowed = EXT_GROUPS[fromExt];
+  if (!allowed) return null;
+  const q = source.replace(/\./g, "/");
+  const last = q.slice(q.lastIndexOf("/") + 1);
+  const cands = index.get(last);
+  if (!cands) return null;
+  const matches = cands.filter(
+    (c) => allowed.includes(c.ext) && (c.key === q || c.key.endsWith("/" + q))
+  );
+  if (matches.length === 0) return null;
+  if (matches.length === 1) return matches[0].rel;
+  return pickClosest(matches, fromRel).rel;
+}
+function pickClosest(matches, fromRel) {
+  const fromSegs = fromRel.split("/");
+  const score = (rel) => {
+    const segs = rel.split("/");
+    let i = 0;
+    while (i < segs.length && i < fromSegs.length && segs[i] === fromSegs[i]) i++;
+    return i;
+  };
+  return [...matches].sort((a, b) => {
+    const d = score(b.rel) - score(a.rel);
+    if (d) return d;
+    if (a.rel.length !== b.rel.length) return a.rel.length - b.rel.length;
+    return a.rel < b.rel ? -1 : 1;
+  })[0];
+}
+function resolveDotted(probe, source) {
+  if (!/^[A-Za-z_][\w.]*$/.test(source) || !source.includes(".")) return null;
+  const slashed = source.replace(/\./g, "/");
+  return probe(slashed) ?? probe(posixJoin("src", slashed));
+}
+function resolvePyRelative(probe, fromRel, source) {
+  let dots = 0;
+  while (source[dots] === ".") dots++;
+  const rest = source.slice(dots);
+  let dir = path.posix.dirname(fromRel);
+  for (let i = 1; i < dots; i++) dir = path.posix.dirname(dir);
+  const sub = rest.replace(/\./g, "/");
+  return probe(sub ? posixJoin(dir, sub) : dir);
+}
+function relativeResolver(relSet) {
+  const probe = makeProbe(relSet);
+  return {
+    resolve(fromRel, source) {
+      if (source.startsWith(".")) return probe(posixJoin(path.posix.dirname(fromRel), source));
+      return resolveDotted(probe, source);
+    }
+  };
+}
+function makeProbe(relSet) {
+  return (base) => {
+    const norm = normalizeRel(base);
+    if (!norm) return null;
+    if (relSet.has(norm)) return norm;
+    for (const ext of JS_TS_EXT) if (relSet.has(norm + ext)) return norm + ext;
+    for (const ext of JS_TS_EXT) if (relSet.has(`${norm}/index${ext}`)) return `${norm}/index${ext}`;
+    for (const ext of OTHER_EXT) if (relSet.has(norm + ext)) return norm + ext;
+    if (relSet.has(`${norm}/__init__.py`)) return `${norm}/__init__.py`;
+    return null;
+  };
+}
+function normalizeRel(p) {
+  const norm = path.posix.normalize(p);
+  const stripped = norm.startsWith("./") ? norm.slice(2) : norm;
+  return stripped.startsWith("..") ? "" : stripped;
+}
+function posixJoin(a, b) {
+  return path.posix.normalize(path.posix.join(a, b));
+}
+function matchPattern(pattern, source) {
+  const star = pattern.indexOf("*");
+  if (star === -1) return source === pattern ? "" : null;
+  const prefix = pattern.slice(0, star);
+  const suffix = pattern.slice(star + 1);
+  if (!source.startsWith(prefix) || !source.endsWith(suffix)) return null;
+  if (source.length < prefix.length + suffix.length) return null;
+  return source.slice(prefix.length, source.length - suffix.length);
+}
+function loadTsconfigPaths(root) {
+  for (const name of ["tsconfig.base.json", "tsconfig.json"]) {
+    const file = path.join(root, name);
+    if (fs.existsSync(file)) {
+      const merged = readTsconfigChain(root, file, /* @__PURE__ */ new Set());
+      if (merged && merged.paths.length) return merged;
+    }
+  }
+  return null;
+}
+function readTsconfigChain(root, file, seen) {
+  if (seen.has(file) || seen.size > 6) return null;
+  seen.add(file);
+  let cfg;
+  try {
+    cfg = parseJsonc(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  const dir = path.dirname(file);
+  let base = { baseUrlRel: "", paths: [] };
+  if (cfg.extends && cfg.extends.startsWith(".")) {
+    const extPath = path.resolve(dir, cfg.extends.endsWith(".json") ? cfg.extends : `${cfg.extends}.json`);
+    if (fs.existsSync(extPath)) {
+      const inherited = readTsconfigChain(root, extPath, seen);
+      if (inherited) base = inherited;
+    }
+  }
+  const co = cfg.compilerOptions ?? {};
+  const baseUrlRel = co.baseUrl !== void 0 ? path.relative(root, path.resolve(dir, co.baseUrl)).split(path.sep).join("/") : base.baseUrlRel;
+  const paths = [...base.paths];
+  if (co.paths) for (const [k, v] of Object.entries(co.paths)) paths.push([k, v]);
+  return { baseUrlRel, paths };
+}
+function loadWorkspacePackages(root) {
+  const map = /* @__PURE__ */ new Map();
+  const globs = [];
+  const rootPkg = path.join(root, "package.json");
+  if (fs.existsSync(rootPkg)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(rootPkg, "utf8"));
+      const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
+      if (ws) globs.push(...ws);
+    } catch {
+    }
+  }
+  const pnpmWs = path.join(root, "pnpm-workspace.yaml");
+  if (fs.existsSync(pnpmWs)) {
+    for (const line of fs.readFileSync(pnpmWs, "utf8").split("\n")) {
+      const m = /^\s*-\s*['"]?([^'"\n]+)['"]?\s*$/.exec(line);
+      if (m) globs.push(m[1].trim());
+    }
+  }
+  for (const dir of expandWorkspaceGlobs(root, globs)) {
+    const pj = path.join(dir, "package.json");
+    try {
+      const name = JSON.parse(fs.readFileSync(pj, "utf8")).name;
+      if (name) map.set(name, path.relative(root, dir).split(path.sep).join("/"));
+    } catch {
+    }
+  }
+  return map;
+}
+function expandWorkspaceGlobs(root, globs) {
+  const out = /* @__PURE__ */ new Set();
+  for (const glob of globs) {
+    const clean = glob.replace(/\/\*\*$/, "").replace(/\/\*$/, "");
+    const baseDir = path.join(root, clean);
+    const recurse = glob.endsWith("**");
+    if (glob === clean) {
+      if (fs.existsSync(path.join(baseDir, "package.json"))) out.add(baseDir);
+      continue;
+    }
+    collectPackageDirs(baseDir, recurse ? 4 : 1, out);
+  }
+  return [...out];
+}
+function collectPackageDirs(dir, depth, out) {
+  if (depth < 0) return;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (!e.isDirectory() || e.name === "node_modules" || e.name.startsWith(".")) continue;
+    const child = path.join(dir, e.name);
+    if (fs.existsSync(path.join(child, "package.json"))) out.add(child);
+    else collectPackageDirs(child, depth - 1, out);
+  }
+}
+function parseJsonc(text) {
+  return JSON.parse(stripJsonc(text));
+}
+function stripJsonc(text) {
+  let out = "";
+  let inStr = false;
+  let strCh = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (inStr) {
+      out += ch;
+      if (ch === "\\") {
+        out += next ?? "";
+        i++;
+      } else if (ch === strCh) {
+        inStr = false;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inStr = true;
+      strCh = ch;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i++;
+      continue;
+    }
+    out += ch;
+  }
+  return out.replace(/,(\s*[}\]])/g, "$1");
+}
+
+// src/engine/ids.ts
+function nodeId(parts) {
+  return shortId(
+    canonicalize({
+      t: "node",
+      kind: parts.kind,
+      qn: parts.qualifiedName,
+      file: parts.file,
+      sig: parts.signature ?? ""
+    })
+  );
+}
+function edgeId(kind, src, dst) {
+  return shortId(canonicalize({ t: "edge", kind, src, dst }));
+}
+
+// src/engine/tests.ts
+function isTestFile(rel) {
+  const lower = rel.toLowerCase();
+  const base = rel.split("/").pop() ?? rel;
+  const lbase = base.toLowerCase();
+  if (/(^|\/)(__tests__|__test__)\//.test(lower)) return true;
+  if (/(^|\/)(tests?|spec|specs)\//.test(lower)) return true;
+  if (/(^|\/)src\/test\//.test(lower)) return true;
+  if (/\.(test|spec)\.[cm]?[jt]sx?$/.test(lbase)) return true;
+  if (/^test_.*\.py$/.test(lbase) || /_test\.py$/.test(lbase)) return true;
+  if (/_test\.go$/.test(lbase)) return true;
+  if (/[A-Za-z0-9](Test|Tests|IT)\.java$/.test(base)) return true;
+  if (/_spec\.rb$/.test(lbase) || /_test\.rb$/.test(lbase)) return true;
+  if (/[A-Za-z0-9](Test|Tests)\.cs$/.test(base)) return true;
+  if (/[A-Za-z0-9](Test|Tests)\.swift$/.test(base)) return true;
+  return false;
+}
+function applyStaticTestLinkage(nodes, edges) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const testFiles = /* @__PURE__ */ new Set();
+  for (const n of nodes) if (n.kind === "file" && isTestFile(n.file)) testFiles.add(n.file);
+  const fileNodeIdByRel = /* @__PURE__ */ new Map();
+  for (const n of nodes) if (n.kind === "file") fileNodeIdByRel.set(n.file, n.id);
+  const covered = /* @__PURE__ */ new Set();
+  const newEdges = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (e.kind !== "call") continue;
+    const src = byId.get(e.src);
+    const dst = byId.get(e.dst);
+    if (!src || !dst) continue;
+    if (testFiles.has(src.file) && !testFiles.has(dst.file) && dst.kind !== "external") {
+      const testFileId = fileNodeIdByRel.get(src.file);
+      if (!testFileId) continue;
+      const id = edgeId("test", testFileId, dst.id);
+      if (!newEdges.has(id)) {
+        newEdges.set(id, {
+          id,
+          kind: "test",
+          src: testFileId,
+          dst: dst.id,
+          resolution: e.resolution,
+          confidence: e.confidence
+        });
+      }
+      covered.add(dst.id);
+    }
+  }
+  const outNodes = nodes.map((n) => ({ ...n, tested: testedFlag(n, covered.has(n.id), testFiles) }));
+  const outEdges = [...edges, ...newEdges.values()].sort(
+    (a, b) => a.kind.localeCompare(b.kind) || a.src.localeCompare(b.src) || a.dst.localeCompare(b.dst)
+  );
+  return {
+    nodes: outNodes,
+    edges: outEdges,
+    testFiles: [...testFiles].sort(),
+    testEdgeCount: newEdges.size
+  };
+}
+function testedFlag(node, covered, testFiles) {
+  if (node.kind === "external" || node.kind === "file" || node.kind === "package" || node.kind === "module") {
+    return null;
+  }
+  if (testFiles.has(node.file)) return null;
+  if (node.kind === "function" || node.kind === "method") return covered;
+  return covered ? true : node.tested ?? null;
+}
+function resolve2(parses, resolver) {
+  const baseNodes = /* @__PURE__ */ new Map();
+  const relSet = new Set(parses.map((p) => p.rel));
+  const mod = resolver ?? relativeResolver(relSet);
+  const defsByName = /* @__PURE__ */ new Map();
+  const defsByFile = /* @__PURE__ */ new Map();
+  const fileNodeIdByRel = /* @__PURE__ */ new Map();
+  for (const p of parses) {
+    const fileId = nodeId({ kind: "file", qualifiedName: p.rel, file: p.rel });
+    fileNodeIdByRel.set(p.rel, fileId);
+    addNode(baseNodes, {
+      id: fileId,
+      kind: "file",
+      name: path.posix.basename(p.rel),
+      qualifiedName: p.rel,
+      file: p.rel,
+      span: { start: 1, end: 1 },
+      lang: p.lang
+    });
+    for (const d of p.defs) {
+      const id = nodeId({
+        kind: d.kind,
+        qualifiedName: d.qualifiedName,
+        file: p.rel,
+        signature: d.signature
+      });
+      addNode(baseNodes, {
+        id,
+        kind: d.kind,
+        name: d.name,
+        qualifiedName: d.qualifiedName,
+        file: p.rel,
+        span: { start: d.startLine, end: d.endLine },
+        lang: p.lang,
+        signature: d.signature,
+        doc: d.doc
+      });
+      const ref = {
+        id,
+        name: d.name,
+        qualifiedName: d.qualifiedName,
+        rel: p.rel,
+        lang: p.lang,
+        kind: d.kind,
+        startByte: d.startByte,
+        endByte: d.endByte
+      };
+      push(defsByName, d.name, ref);
+      push(defsByFile, p.rel, ref);
+    }
+  }
+  const filesByNamespace = /* @__PURE__ */ new Map();
+  for (const p of parses) for (const ns of p.namespaces ?? []) addToSet(filesByNamespace, ns, p.rel);
+  const relsByLang = /* @__PURE__ */ new Map();
+  for (const p of parses) push(relsByLang, p.lang, p.rel);
+  const nsReachableByRel = /* @__PURE__ */ new Map();
+  const moduleReachableByRel = /* @__PURE__ */ new Map();
+  for (const p of parses) {
+    if (MODULE_SCOPED_LANGS.has(p.lang)) {
+      const mod2 = /* @__PURE__ */ new Set();
+      for (const rel of relsByLang.get(p.lang) ?? []) if (rel !== p.rel) mod2.add(rel);
+      moduleReachableByRel.set(p.rel, mod2);
+    }
+    const reach = /* @__PURE__ */ new Set();
+    const namespaces = new Set(p.namespaces ?? []);
+    for (const imp of p.imports) {
+      namespaces.add(imp.source);
+      if (IMPORT_NAMES_A_TYPE.has(p.lang)) {
+        const sep2 = Math.max(imp.source.lastIndexOf("."), imp.source.lastIndexOf("\\"));
+        if (sep2 > 0) namespaces.add(imp.source.slice(0, sep2));
+      }
+    }
+    for (const ns of namespaces) for (const rel of filesByNamespace.get(ns) ?? []) if (rel !== p.rel) reach.add(rel);
+    nsReachableByRel.set(p.rel, reach);
+  }
+  const superTypesByType = /* @__PURE__ */ new Map();
+  for (const p of parses) {
+    const localDefs = defsByFile.get(p.rel) ?? [];
+    for (const h of p.heritage) {
+      const encl = enclosingDefRef(localDefs, h.byte);
+      if (encl && (encl.kind === "class" || encl.kind === "interface")) addToSet(superTypesByType, encl.name, h.superName);
+    }
+  }
+  const edges = new EdgeSet();
+  const unresolved = /* @__PURE__ */ new Map();
+  const stats = {
+    callsResolved: 0,
+    callsUnresolved: 0,
+    importsResolvedToFile: 0,
+    importsExternal: 0,
+    resolvers: ["heuristic"]
+  };
+  for (const p of parses) {
+    const fileId = fileNodeIdByRel.get(p.rel);
+    const localByQn = /* @__PURE__ */ new Map();
+    for (const ref of defsByFile.get(p.rel) ?? []) localByQn.set(ref.qualifiedName, ref.id);
+    for (const d of p.defs) {
+      const id = localByQn.get(d.qualifiedName);
+      const parentQn = parentQualifiedName(d.qualifiedName);
+      const parentId = parentQn ? localByQn.get(parentQn) : void 0;
+      edges.add("contains", parentId ?? fileId, id, "heuristic", 1);
+    }
+  }
+  const importedFilesByRel = /* @__PURE__ */ new Map();
+  for (const p of parses) {
+    const fileId = fileNodeIdByRel.get(p.rel);
+    const importedRels = /* @__PURE__ */ new Set();
+    for (const imp of p.imports) {
+      const targetRel = mod.resolve(p.rel, imp.source);
+      if (targetRel && targetRel !== p.rel) {
+        importedRels.add(targetRel);
+        edges.add("import", fileId, fileNodeIdByRel.get(targetRel), "heuristic", 0.9);
+        stats.importsResolvedToFile++;
+      } else {
+        const extId = ensureExternalNode(baseNodes, imp.source);
+        edges.add("import", fileId, extId, "heuristic", 1);
+        stats.importsExternal++;
+      }
+    }
+    importedFilesByRel.set(p.rel, importedRels);
+  }
+  for (const p of parses) {
+    const fileId = fileNodeIdByRel.get(p.rel);
+    const localDefs = defsByFile.get(p.rel) ?? [];
+    const imported = importedFilesByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    const testCaller = isTestFile(p.rel);
+    const nsReach = nsReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    const modReach = moduleReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    for (const call of p.calls) {
+      const srcId = enclosingDefId(localDefs, call.byte) ?? fileId;
+      const resolved = resolveCall(call, p.rel, p.lang, imported, defsByName, srcId, testCaller, nsReach, superTypesByType, modReach);
+      if (resolved) {
+        edges.add("call", srcId, resolved.id, "heuristic", resolved.confidence);
+        stats.callsResolved++;
+      } else {
+        stats.callsUnresolved++;
+        bumpUnresolved(unresolved, srcId, call.callee, "call", p.rel);
+      }
+    }
+  }
+  for (const p of parses) {
+    const fileId = fileNodeIdByRel.get(p.rel);
+    const localDefs = defsByFile.get(p.rel) ?? [];
+    const imported = importedFilesByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    const testCaller = isTestFile(p.rel);
+    const nsReach = nsReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    const modReach = moduleReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    for (const ref of p.typeRefs) {
+      const srcId = enclosingDefId(localDefs, ref.byte) ?? fileId;
+      const target = resolveType(ref.name, p.rel, p.lang, imported, defsByName, testCaller, nsReach, modReach);
+      if (target) edges.add("references", srcId, target.id, "heuristic", 0.7);
+    }
+  }
+  for (const p of parses) {
+    const localDefs = defsByFile.get(p.rel) ?? [];
+    const imported = importedFilesByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    const testCaller = isTestFile(p.rel);
+    for (const h of p.heritage) {
+      const srcId = enclosingDefId(localDefs, h.byte);
+      if (!srcId) continue;
+      const nsReach = nsReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+      const modReach = moduleReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+      const target = resolveType(h.superName, p.rel, p.lang, imported, defsByName, testCaller, nsReach, modReach);
+      if (target) edges.add(h.kind, srcId, target.id, "heuristic", 0.85);
+      else bumpUnresolved(unresolved, srcId, h.superName, h.kind, p.rel);
+    }
+  }
+  const nodes = [...baseNodes.values()].map((n) => ({
+    ...n,
+    importance: 0,
+    centrality: { degree: 0, pagerank: 0, betweenness: 0, eigenvector: 0 },
+    area: 0,
+    isHub: false,
+    tested: null
+  }));
+  const unresolvedList = [...unresolved.values()].sort(
+    (a, b) => a.from.localeCompare(b.from) || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)
+  );
+  return { nodes, edges: edges.toArray(), unresolved: unresolvedList, stats };
+}
+function bumpUnresolved(map, from, name, kind, fromRel) {
+  const key = `${from}${kind}${name}`;
+  const existing = map.get(key);
+  if (existing) existing.count++;
+  else map.set(key, { from, name, kind, count: 1, fromRel });
+}
+function addNode(map, n) {
+  if (!map.has(n.id)) map.set(n.id, n);
+}
+function ensureExternalNode(map, source) {
+  const id = nodeId({ kind: "external", qualifiedName: source, file: "" });
+  if (!map.has(id)) {
+    map.set(id, {
+      id,
+      kind: "external",
+      name: source,
+      qualifiedName: source,
+      file: "",
+      span: { start: 1, end: 1 },
+      lang: "external"
+    });
+  }
+  return id;
+}
+function push(map, key, value) {
+  const list = map.get(key);
+  if (list) list.push(value);
+  else map.set(key, [value]);
+}
+function parentQualifiedName(qn) {
+  const idx = qn.lastIndexOf(".");
+  return idx > 0 ? qn.slice(0, idx) : null;
+}
+function enclosingDefRef(defs, byte) {
+  let best;
+  for (const d of defs) {
+    if (d.startByte <= byte && d.endByte >= byte) {
+      if (!best || d.endByte - d.startByte < best.endByte - best.startByte) best = d;
+    }
+  }
+  return best;
+}
+function enclosingDefId(defs, byte) {
+  return enclosingDefRef(defs, byte)?.id;
+}
+function addToSet(map, key, value) {
+  const s = map.get(key);
+  if (s) s.add(value);
+  else map.set(key, /* @__PURE__ */ new Set([value]));
+}
+function parentTypeName(qualifiedName) {
+  const i = qualifiedName.lastIndexOf(".");
+  return i > 0 ? qualifiedName.slice(0, i) : null;
+}
+function disambiguateInterfaceImpl(pool, superTypesByType) {
+  const withParent = pool.map((c) => ({ c, parent: parentTypeName(c.qualifiedName) })).filter((x) => x.parent !== null);
+  if (withParent.length < 2) return null;
+  const parents = new Set(withParent.map((x) => x.parent));
+  const impls = withParent.filter(
+    (x) => [...parents].some((other) => other !== x.parent && superTypesByType.get(x.parent)?.has(other))
+  );
+  if (impls.length === 0) return null;
+  const interfaceParents = /* @__PURE__ */ new Set();
+  for (const impl of impls) for (const s of superTypesByType.get(impl.parent) ?? []) interfaceParents.add(s);
+  const interfaces = withParent.filter((x) => interfaceParents.has(x.parent));
+  const uniqueImplIds = new Set(impls.map((x) => x.c.id));
+  if (uniqueImplIds.size === 1) return impls[0].c;
+  const uniqueIfaceIds = new Set(interfaces.map((x) => x.c.id));
+  if (uniqueIfaceIds.size === 1) return interfaces[0].c;
+  return null;
+}
+var PACKAGE_SCOPED_LANGS = /* @__PURE__ */ new Set(["go", "java", "cs", "kotlin", "scala", "swift"]);
+var IMPORT_NAMES_A_TYPE = /* @__PURE__ */ new Set(["java", "kotlin", "scala", "php"]);
+var MODULE_SCOPED_LANGS = /* @__PURE__ */ new Set(["swift"]);
+function dirOf(rel) {
+  const i = rel.lastIndexOf("/");
+  return i >= 0 ? rel.slice(0, i) : "";
+}
+function resolveCall(call, fromRel, fromLang, importedRels, defsByName, enclosingId, fromIsTestFile = false, nsReachableRels = /* @__PURE__ */ new Set(), superTypesByType = /* @__PURE__ */ new Map(), moduleReachableRels = /* @__PURE__ */ new Set()) {
+  const candidates = defsByName.get(call.callee);
+  if (!candidates || candidates.length === 0) return null;
+  const callable = candidates.filter((c) => c.kind === "function" || c.kind === "method");
+  const pool = callable.length ? callable : candidates;
+  let sameFile = pool.filter((c) => c.rel === fromRel);
+  if (call.qualified && enclosingId) sameFile = sameFile.filter((c) => c.id !== enclosingId);
+  if (sameFile.length === 1) return { id: sameFile[0].id, confidence: 0.85 };
+  if (sameFile.length > 1) {
+    const pick = [...sameFile].sort((a, b) => a.id.localeCompare(b.id))[0];
+    return { id: pick.id, confidence: 0.4 };
+  }
+  const dir = dirOf(fromRel);
+  const notSelf = (c) => !(call.qualified && enclosingId && c.id === enclosingId);
+  const strict = pool.filter(
+    (c) => notSelf(c) && (importedRels.has(c.rel) || PACKAGE_SCOPED_LANGS.has(fromLang) && c.lang === fromLang && dirOf(c.rel) === dir || nsReachableRels.has(c.rel))
+  );
+  if (strict.length === 1) return { id: strict[0].id, confidence: 0.75 };
+  const broad = pool.filter((c) => notSelf(c) && (moduleReachableRels.has(c.rel) || strict.includes(c)));
+  if (broad.length > 1) {
+    const dedup = disambiguateInterfaceImpl(broad, superTypesByType);
+    if (dedup) return { id: dedup.id, confidence: 0.6 };
+  }
+  if (strict.length > 1) return null;
+  if (fromLang === "swift" && fromIsTestFile && pool.length === 1) {
+    return { id: pool[0].id, confidence: 0.5 };
+  }
+  return null;
+}
+function resolveType(name, fromRel, fromLang, importedRels, defsByName, fromIsTestFile = false, nsReachableRels = /* @__PURE__ */ new Set(), moduleReachableRels = /* @__PURE__ */ new Set()) {
+  const candidates = (defsByName.get(name) ?? []).filter(
+    (c) => c.kind === "class" || c.kind === "interface"
+  );
+  if (candidates.length === 0) return null;
+  const sameFile = candidates.filter((c) => c.rel === fromRel);
+  if (sameFile.length === 1) return { id: sameFile[0].id };
+  const imported = candidates.filter((c) => importedRels.has(c.rel));
+  if (imported.length === 1) return { id: imported[0].id };
+  if (imported.length > 1) return null;
+  if (PACKAGE_SCOPED_LANGS.has(fromLang)) {
+    const dir = dirOf(fromRel);
+    const samePkg = candidates.filter((c) => c.lang === fromLang && dirOf(c.rel) === dir);
+    if (samePkg.length === 1) return { id: samePkg[0].id };
+  }
+  if (nsReachableRels.size || moduleReachableRels.size) {
+    const reach = candidates.filter((c) => nsReachableRels.has(c.rel) || moduleReachableRels.has(c.rel));
+    if (reach.length === 1) return { id: reach[0].id };
+  }
+  if (fromLang === "swift" && fromIsTestFile && candidates.length === 1) {
+    return { id: candidates[0].id };
+  }
+  return null;
+}
+var EdgeSet = class {
+  map = /* @__PURE__ */ new Map();
+  add(kind, src, dst, resolution, confidence) {
+    const id = edgeId(kind, src, dst);
+    const existing = this.map.get(id);
+    if (existing) {
+      existing.count = (existing.count ?? 1) + 1;
+      if (confidence > existing.confidence) existing.confidence = confidence;
+      return;
+    }
+    this.map.set(id, { id, kind, src, dst, resolution, confidence, count: 1 });
+  }
+  toArray() {
+    return [...this.map.values()].sort(
+      (a, b) => a.kind.localeCompare(b.kind) || a.src.localeCompare(b.src) || a.dst.localeCompare(b.dst)
+    );
+  }
+};
+
+export { applyStaticTestLinkage, buildModuleResolver, edgeId, isTestFile, nodeId, parseJsonc, relativeResolver, resolve2 as resolve };
+//# sourceMappingURL=chunk-IPICO2RV.js.map
+//# sourceMappingURL=chunk-IPICO2RV.js.map