eminiar 0.5.2 → 0.6.1

package/dist/cli.js

@@ -4602,7 +4602,7 @@ function isRef(value) {
 function cloneIssues(issues) {
   return issues.map((iss) => iss.path ? { ...iss, path: iss.path.slice() } : { ...iss });
 }
-function isRecursive(inst, stack, resolve7) {
+function isRecursive(inst, stack, resolve8) {
   const cached5 = recursive.get(inst);
   if (cached5 !== void 0)
     return cached5 ? PROVEN : NONE;
@@ -4612,7 +4612,7 @@ function isRecursive(inst, stack, resolve7) {
   let result = NONE;
   const check3 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve7);
+      const answer = isRecursive(child, stack, resolve8);
       if (answer > result)
         result = answer;
     }
@@ -4623,7 +4623,7 @@ function isRecursive(inst, stack, resolve7) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve7) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve8) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -4687,7 +4687,7 @@ function isRecursive(inst, stack, resolve7) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve7 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve8 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -20776,7 +20776,8 @@ var init_config = __esm({
           "**/*.mjs",
           "**/*.cjs",
           "**/*.py",
-          "**/*.go"
+          "**/*.go",
+          "**/*.php"
         ]),
         exclude: external_exports.array(external_exports.string()).default([
           "**/node_modules/**",
@@ -20790,7 +20791,8 @@ var init_config = __esm({
           "**/__pycache__/**",
           "**/site-packages/**",
           "**/vendor/**",
-          "**/*.min.js"
+          "**/*.min.js",
+          "**/*.blade.php"
         ])
       }).prefault({}),
       git: external_exports.object({
@@ -22397,12 +22399,18 @@ var init_adapter = __esm({
           const ids = this.db.prepare("SELECT id FROM graph_nodes WHERE source = ? AND path = ?").all(source, path3).map((r) => r.id);
           const fileId2 = `file:${path3}`;
           const all = ids.includes(fileId2) ? ids : [...ids, fileId2];
+          this.db.prepare(
+            "DELETE FROM graph_edges WHERE source = ? AND kind = 'handles' AND dst IN (SELECT id FROM graph_nodes WHERE source = ? AND path = ? AND kind = 'route')"
+          ).run(source, source, path3);
+          const foreignRoute = "AND NOT (kind = 'handles' AND dst IN (SELECT id FROM graph_nodes WHERE kind = 'route' AND path IS NOT ?))";
           for (let i = 0; i < all.length; i += 400) {
             const slice = all.slice(i, i + 400);
             const ph = slice.map(() => "?").join(",");
-            this.db.prepare(`DELETE FROM graph_edges WHERE source = ? AND src IN (${ph})`).run(source, ...slice);
+            this.db.prepare(`DELETE FROM graph_edges WHERE source = ? AND src IN (${ph}) ${foreignRoute}`).run(source, ...slice, path3);
           }
-          this.db.prepare("DELETE FROM graph_edges WHERE source = ? AND src LIKE ? ESCAPE '\\'").run(source, `sym:${path3.replace(/[%_\\]/g, "\\$&")}#%`);
+          this.db.prepare(
+            `DELETE FROM graph_edges WHERE source = ? AND src LIKE ? ESCAPE '\\' ${foreignRoute}`
+          ).run(source, `sym:${path3.replace(/[%_\\]/g, "\\$&")}#%`, path3);
           if (opts.keepFile) {
             this.db.prepare("DELETE FROM graph_nodes WHERE source = ? AND path = ? AND kind != 'file'").run(source, path3);
           } else {
@@ -23192,13 +23200,13 @@ import { spawn } from "child_process";
 import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
 import { join as join13 } from "path";
 function mcpHandshake(bin, ms = 15e3) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn(bin, [], { stdio: ["pipe", "pipe", "pipe"] });
     let buf = "";
     let err = "";
     const timer = setTimeout(() => {
       child.kill();
-      resolve7(`no reply in ${ms / 1e3}s${err ? `: ${err.trim().slice(-200)}` : ""}`);
+      resolve8(`no reply in ${ms / 1e3}s${err ? `: ${err.trim().slice(-200)}` : ""}`);
     }, ms);
     child.stdout.on("data", (d) => {
       buf += d.toString();
@@ -23206,7 +23214,7 @@ function mcpHandshake(bin, ms = 15e3) {
         clearTimeout(timer);
         child.kill();
         const m = /"serverInfo":\{"name":"([^"]+)","version":"([^"]+)"/.exec(buf);
-        resolve7(m ? `${m[1]} v${m[2]}` : "ok");
+        resolve8(m ? `${m[1]} v${m[2]}` : "ok");
       }
     });
     child.stderr.on("data", (d) => {
@@ -23214,7 +23222,7 @@ function mcpHandshake(bin, ms = 15e3) {
     });
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve7(`spawn failed: ${e.message}`);
+      resolve8(`spawn failed: ${e.message}`);
     });
     child.stdin.write(
       `${JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "doctor", version: "0" } } })}
@@ -27473,15 +27481,15 @@ var require_pattern = __commonJS({
     exports.removeDuplicateSlashes = removeDuplicateSlashes;
     function partitionAbsoluteAndRelative(patterns) {
       const absolute = [];
-      const relative9 = [];
+      const relative10 = [];
       for (const pattern2 of patterns) {
         if (isAbsolute(pattern2)) {
           absolute.push(pattern2);
         } else {
-          relative9.push(pattern2);
+          relative10.push(pattern2);
         }
       }
-      return [absolute, relative9];
+      return [absolute, relative10];
     }
     exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
     function isAbsolute(pattern2) {
@@ -27912,11 +27920,11 @@ var require_out = __commonJS({
       async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat;
-    function statSync10(path3, optionsOrSettings) {
+    function statSync11(path3, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path3, settings);
     }
-    exports.statSync = statSync10;
+    exports.statSync = statSync11;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -28597,41 +28605,41 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p = new Promise(function(resolve7, reject) {
+        var p = new Promise(function(resolve8, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve7(result);
+            resolve8(result);
           });
         });
         p.catch(noop);
         return p;
       }
       function unshift(value) {
-        var p = new Promise(function(resolve7, reject) {
+        var p = new Promise(function(resolve8, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve7(result);
+            resolve8(result);
           });
         });
         p.catch(noop);
         return p;
       }
       function drained() {
-        var p = new Promise(function(resolve7) {
+        var p = new Promise(function(resolve8) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve7();
+              resolve8();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve7();
+                resolve8();
                 queue.drain = previousDrain;
               };
             }
@@ -29128,9 +29136,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           this._stat(filepath, this._fsStatSettings, (error62, stats) => {
-            return error62 === null ? resolve7(stats) : reject(error62);
+            return error62 === null ? resolve8(stats) : reject(error62);
           });
         });
       }
@@ -29155,10 +29163,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           this._walkAsync(root, options, (error62, entries) => {
             if (error62 === null) {
-              resolve7(entries);
+              resolve8(entries);
             } else {
               reject(error62);
             }
@@ -29168,10 +29176,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve7(entries));
+          stream.once("end", () => resolve8(entries));
         });
       }
     };
@@ -31063,6 +31071,7 @@ var init_metrics = __esm({
       "class",
       "method",
       "interface",
+      "trait",
       "type",
       "enum",
       "field",
@@ -31661,6 +31670,40 @@ function parseRestShorthand(rest2, actionName) {
   }
   return [{ method: "ALL", path: joinRoutePath(rest2) }];
 }
+function phpRoutePath(...parts) {
+  return normalizeRoutePath(
+    joinRoutePath(...parts).replace(/\{(\w+)\s*:[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g, "{$1}").replace(/\{(\w+)<[^>]*>[^}]*\}/g, "{$1}")
+  );
+}
+function resourceParam(segment) {
+  return segment.replace(/-/g, "_").replace(/ies$/, "y").replace(/(s|x|z|ch|sh)es$/, "$1").replace(/([^s])s$/, "$1");
+}
+function laravelResource(name, api = false, only, except) {
+  const segs = name.split(".").filter(Boolean);
+  const last = segs.pop();
+  if (!last) return [];
+  const base = joinRoutePath(...segs.map((s) => `${s}/:${resourceParam(s)}`), last);
+  const param = `:${resourceParam(last)}`;
+  return RESOURCE_ACTIONS.filter(
+    ([, , action]) => !(api && (action === "create" || action === "edit")) && (!only || only.includes(action)) && !except?.includes(action)
+  ).map(([method, suffix, action]) => ({
+    method,
+    path: `${base === "/" ? "" : base}${suffix.replace("{p}", param)}` || "/",
+    action
+  }));
+}
+function parseRouteAnnotations(doc) {
+  const out = [];
+  for (const m of doc.matchAll(/@Route\(([^)]*)\)/g)) {
+    const body = m[1] ?? "";
+    const path3 = /^\s*"([^"]*)"/.exec(body)?.[1] ?? /\bpath\s*=\s*"([^"]*)"/.exec(body)?.[1];
+    if (path3 === void 0) continue;
+    const list2 = /\bmethods\s*=\s*(\{[^}]*\}|"[^"]*")/.exec(body)?.[1] ?? "";
+    const methods = [...list2.matchAll(/"([^"]+)"/g)].map((x) => httpMethod(x[1])).filter((x) => !!x);
+    for (const method of methods.length ? methods : ["ALL"]) out.push({ method, path: path3 });
+  }
+  return out;
+}
 function frameworkOf(importedPackages) {
   for (const p of importedPackages) {
     const f = FRAMEWORK_PKGS[p];
@@ -31705,7 +31748,7 @@ function fileRoutes(rel, exportedNames, defaultExport) {
   }
   return out;
 }
-var ROUTE_METHODS, JS_METHOD_ALIASES, REST_ALIASES, FRAMEWORK_PKGS, routeId, NEXT_APP_ROUTE, NEXT_PAGES_API, HTTP_EXPORTS;
+var ROUTE_METHODS, JS_METHOD_ALIASES, REST_ALIASES, RESOURCE_ACTIONS, FRAMEWORK_PKGS, routeId, NEXT_APP_ROUTE, NEXT_PAGES_API, HTTP_EXPORTS;
 var init_routes = __esm({
   "src/graph/routes.ts"() {
     "use strict";
@@ -31729,6 +31772,16 @@ var init_routes = __esm({
       ["PATCH", "/:id", "patch"],
       ["DELETE", "/:id", "remove"]
     ];
+    RESOURCE_ACTIONS = [
+      ["GET", "", "index"],
+      ["GET", "/create", "create"],
+      ["POST", "", "store"],
+      ["GET", "/{p}", "show"],
+      ["GET", "/{p}/edit", "edit"],
+      ["PUT", "/{p}", "update"],
+      ["PATCH", "/{p}", "update"],
+      ["DELETE", "/{p}", "destroy"]
+    ];
     FRAMEWORK_PKGS = {
       express: "express",
       fastify: "fastify",
@@ -31759,7 +31812,18 @@ var init_routes = __esm({
       "github.com/labstack/echo": "echo",
       "github.com/gorilla/mux": "gorilla",
       "github.com/gofiber/fiber": "fiber",
-      "github.com/julienschmidt/httprouter": "httprouter"
+      "github.com/julienschmidt/httprouter": "httprouter",
+      // PHP (top-level namespace of a `use` the project cannot resolve)
+      Illuminate: "laravel",
+      Symfony: "symfony",
+      Slim: "slim",
+      CodeIgniter: "codeigniter",
+      // PHP (composer.json `require`, when no `use` in the file names the framework)
+      "laravel/lumen-framework": "lumen",
+      "laravel/framework": "laravel",
+      "symfony/framework-bundle": "symfony",
+      "slim/slim": "slim",
+      "codeigniter4/framework": "codeigniter"
     };
     routeId = (method, path3) => `route:${method} ${path3}`;
     NEXT_APP_ROUTE = /(?:^|\/)app\/(.*?)(?:\/)?route\.(?:ts|tsx|js|jsx|mjs)$/;
@@ -31789,6 +31853,8 @@ function grammarFor(path3) {
       return "python";
     case ".go":
       return "go";
+    case ".php":
+      return "php";
     default:
       return void 0;
   }
@@ -32293,28 +32359,1095 @@ var init_go = __esm({
   }
 });
 
-// src/graph/languages/python.ts
-import { existsSync as existsSync15, statSync as statSync2 } from "fs";
+// src/graph/languages/php.ts
+import { readdirSync as readdirSync6, readFileSync as readFileSync12, statSync as statSync2 } from "fs";
 import { dirname as dirname5, join as join17, normalize as normalize2, relative as relative3, resolve as resolve4 } from "path";
+function readComposer(dir) {
+  const file3 = join17(dir, "composer.json");
+  if (!isFile(file3)) return null;
+  try {
+    const json3 = JSON.parse(readFileSync12(file3, "utf8"));
+    const info = { dir, psr4: [], psr0: [], classmap: [], files: [], require: [] };
+    for (const key of ["autoload", "autoload-dev"]) {
+      const section = json3[key];
+      for (const [prefix, dirs] of Object.entries(section?.["psr-4"] ?? {})) {
+        info.psr4.push({
+          prefix: prefix && !prefix.endsWith("\\") ? `${prefix}\\` : prefix,
+          dirs: asList(dirs)
+        });
+      }
+      for (const [prefix, dirs] of Object.entries(section?.["psr-0"] ?? {}))
+        info.psr0.push({ prefix, dirs: asList(dirs) });
+      info.classmap.push(...section?.classmap ?? []);
+      info.files.push(...section?.files ?? []);
+    }
+    info.require = Object.keys(json3.require ?? {});
+    info.psr4.sort((a, b) => b.prefix.length - a.prefix.length);
+    info.psr0.sort((a, b) => b.prefix.length - a.prefix.length);
+    const empty2 = !info.psr4.length && !info.psr0.length && !info.classmap.length && !info.files.length && !info.require.length;
+    return empty2 ? null : info;
+  } catch {
+    return null;
+  }
+}
+function composerAutoload(root, fromAbs) {
+  let dir = dirname5(fromAbs);
+  while (dir.startsWith(root)) {
+    let hit = composerCache.get(dir);
+    if (hit === void 0) {
+      hit = readComposer(dir);
+      composerCache.set(dir, hit);
+    }
+    if (hit) return hit;
+    if (dir === root) break;
+    dir = dirname5(dir);
+  }
+  return void 0;
+}
+function phpFilesUnder(abs, budget) {
+  if (isFile(abs)) return abs.endsWith(".php") ? [abs] : [];
+  let entries;
+  try {
+    entries = readdirSync6(abs, { recursive: true, encoding: "utf8" });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    if (budget.left <= 0) break;
+    if (!e.endsWith(".php") || e.split(/[\\/]/).includes("vendor")) continue;
+    out.push(join17(abs, e));
+    budget.left--;
+  }
+  return out;
+}
+function classmapClasses(root, auto) {
+  if (auto.classes) return auto.classes;
+  const classes = /* @__PURE__ */ new Map();
+  const budget = { left: CLASSMAP_MAX_FILES };
+  for (const entry of auto.classmap) {
+    for (const f of phpFilesUnder(join17(auto.dir, entry), budget)) {
+      if (relative3(root, f).startsWith("..")) continue;
+      let code;
+      try {
+        code = readFileSync12(f, "utf8");
+      } catch {
+        continue;
+      }
+      const ns = /^\s*namespace\s+([\w\\]+)\s*[;{]/m.exec(code)?.[1];
+      for (const m of code.matchAll(
+        /^\s*(?:(?:abstract|final|readonly)\s+)*(?:class|interface|trait|enum)\s+(\w+)/gm
+      )) {
+        const fq = ns ? `${ns}\\${m[1]}` : m[1];
+        if (!classes.has(fq)) classes.set(fq, toRel(root, f));
+      }
+    }
+  }
+  auto.classes = classes;
+  return classes;
+}
+function autoloadedFunctions(root, auto) {
+  if (auto.functions) return auto.functions;
+  const functions = /* @__PURE__ */ new Map();
+  for (const entry of auto.files) {
+    const f = join17(auto.dir, entry);
+    if (!isFile(f) || relative3(root, f).startsWith("..")) continue;
+    let code;
+    try {
+      code = readFileSync12(f, "utf8");
+    } catch {
+      continue;
+    }
+    if (/^\s*namespace\s+[\w\\]+\s*[;{]/m.test(code)) continue;
+    for (const m of code.matchAll(/^\s*function\s+&?\s*(\w+)\s*\(/gm))
+      if (!functions.has(m[1])) functions.set(m[1], toRel(root, f));
+  }
+  auto.functions = functions;
+  return functions;
+}
+function resolvePhpClass(root, fromRel, fqcn) {
+  const name = fqcn.replace(/^\\+/, "");
+  if (!name) return void 0;
+  const candidates2 = [];
+  const auto = composerAutoload(root, resolve4(root, fromRel));
+  if (auto?.psr4.length || auto?.psr0.length) {
+    for (const { prefix, dirs } of auto.psr4) {
+      if (!name.startsWith(prefix)) continue;
+      const rest2 = name.slice(prefix.length).split("\\");
+      for (const d of dirs) candidates2.push(join17(auto.dir, d, ...rest2));
+    }
+    for (const { prefix, dirs } of auto.psr0) {
+      if (!name.startsWith(prefix)) continue;
+      const cut = name.lastIndexOf("\\");
+      const ns = cut === -1 ? [] : name.slice(0, cut).split("\\");
+      const cls = name.slice(cut + 1).split("_");
+      for (const d of dirs) candidates2.push(join17(auto.dir, d, ...ns, ...cls));
+    }
+  } else {
+    const parts = name.split("\\");
+    candidates2.push(resolve4(root, ...parts), resolve4(root, "src", ...parts));
+  }
+  for (const c of candidates2) {
+    const f = `${c}.php`;
+    if (isFile(f) && !relative3(root, f).startsWith("..")) return toRel(root, f);
+  }
+  return auto?.classmap.length ? classmapClasses(root, auto).get(name) : void 0;
+}
+function phpString(n) {
+  if (!n || n.type !== "string" && n.type !== "encapsed_string") return void 0;
+  if (n.namedChildren.some((c) => c && c.type !== "string_content" && c.type !== "escape_sequence"))
+    return void 0;
+  return literalText(n)?.replace(/\\(\\|')/g, "$1");
+}
+function argsOf(call) {
+  const list2 = call.childForFieldName("arguments") ?? call.childForFieldName("parameters");
+  return (list2?.namedChildren ?? []).filter((a) => a?.type === "argument").map((a) => a.namedChildren[a.namedChildren.length - 1]).filter((a) => !!a);
+}
+function positionalArgs(call) {
+  const list2 = call.childForFieldName("arguments") ?? call.childForFieldName("parameters");
+  return (list2?.namedChildren ?? []).filter((a) => a?.type === "argument" && !a.childForFieldName("name")).map((a) => a.namedChildren[0]).filter((a) => !!a);
+}
+function namedArg(call, name) {
+  const list2 = call.childForFieldName("arguments") ?? call.childForFieldName("parameters");
+  for (const a of list2?.namedChildren ?? []) {
+    if (a?.type === "argument" && a.childForFieldName("name")?.text === name)
+      return a.namedChildren[a.namedChildren.length - 1] ?? void 0;
+  }
+  return void 0;
+}
+function stringsOf(n) {
+  if (!n) return [];
+  if (n.type !== "array_creation_expression") {
+    const s = phpString(n);
+    return s === void 0 ? [] : [s];
+  }
+  return n.namedChildren.flatMap((el) => {
+    const s = el?.namedChildren.length === 1 ? phpString(el.namedChildren[0]) : void 0;
+    return s === void 0 ? [] : [s];
+  });
+}
+function arrayElements(arr2) {
+  const out = [];
+  for (const el of arr2.namedChildren) {
+    if (el?.type !== "array_element_initializer") continue;
+    const kids = el.namedChildren.filter((c) => !!c);
+    if (kids.length === 1) out.push({ value: kids[0] });
+    else if (kids.length === 2) out.push({ key: phpString(kids[0]), value: kids[1] });
+  }
+  return out;
+}
+function handlerShaped(a) {
+  if (!a) return false;
+  switch (a.type) {
+    case "anonymous_function":
+    case "arrow_function":
+    case "class_constant_access_expression":
+      return true;
+    case "string":
+    case "encapsed_string":
+      return CONTROLLER_STRING.test(phpString(a) ?? "");
+    case "array_creation_expression":
+      return arrayElements(a).some((e) => e.key ? e.key === "uses" : handlerShaped(e.value));
+    default:
+      return false;
+  }
+}
+async function parsePhp(root, rel, code) {
+  const p = await getParser("php");
+  const tree = p.parse(code);
+  if (!tree) return { nodes: [], edges: [], exports: [] };
+  const fid = fileId(rel);
+  const fileNode = {
+    id: fid,
+    kind: "file",
+    name: rel,
+    path: rel,
+    source: "tree-sitter"
+  };
+  const nodes = [fileNode];
+  const edges = [];
+  const exportsList = [];
+  const scope = /* @__PURE__ */ new Map();
+  let classUses = /* @__PURE__ */ new Map();
+  const usesByBlock = /* @__PURE__ */ new Map();
+  const declared = /* @__PURE__ */ new Set();
+  const localSyms = /* @__PURE__ */ new Map();
+  const varTypes = /* @__PURE__ */ new Map();
+  const propTypes = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  const imports = /* @__PURE__ */ new Map();
+  const resolvedClasses = /* @__PURE__ */ new Map();
+  const importedPkgs = /* @__PURE__ */ new Set();
+  const refs = new RefCollector();
+  let complexity = 0;
+  let namespace = "";
+  const namespaces = [];
+  const pushEdge = (e) => edges.push({ confidence: 1, weight: 1, ...e });
+  const auto = composerAutoload(root, resolve4(root, rel));
+  const stmts = [];
+  let block = 0;
+  for (const stmt of tree.rootNode.namedChildren) {
+    if (!stmt) continue;
+    if (stmt.type === "namespace_definition") {
+      block++;
+      namespace = stmt.childForFieldName("name")?.text ?? "";
+      if (namespace) addNamespace(stmt, namespace);
+      for (const s of stmt.childForFieldName("body")?.namedChildren ?? [])
+        if (s) stmts.push([s, namespace, block]);
+    } else stmts.push([stmt, namespace, block]);
+  }
+  const enter = (ns, b) => {
+    namespace = ns;
+    let uses = usesByBlock.get(b);
+    if (!uses) {
+      uses = /* @__PURE__ */ new Map();
+      usesByBlock.set(b, uses);
+    }
+    classUses = uses;
+  };
+  for (const [stmt] of stmts) {
+    const name = CLASS_KINDS[stmt.type] ? stmt.childForFieldName("name")?.text : void 0;
+    if (name) declared.add(name);
+  }
+  for (const [stmt, ns, b] of stmts) {
+    enter(ns, b);
+    if (stmt.type === "namespace_use_declaration") handleUse(stmt);
+  }
+  for (const [stmt, ns, b] of stmts) {
+    enter(ns, b);
+    if (stmt.type !== "namespace_use_declaration") collectDecls(stmt);
+  }
+  for (const [stmt, ns, b] of stmts) {
+    enter(ns, b);
+    if (stmt.type !== "namespace_use_declaration") walkRefs(stmt);
+  }
+  handleIncludes(tree.rootNode);
+  edges.push(...imports.values());
+  edges.push(...refs.edges());
+  const errors = tree.rootNode.hasError ? tree.rootNode.descendantsOfType("ERROR").length : 0;
+  fileNode.meta = {
+    loc: tree.rootNode.endPosition.row + 1,
+    complexity,
+    ...namespaces.length ? { php_namespace: namespaces[0] } : {},
+    ...errors ? { parse_errors: errors } : {}
+  };
+  return { nodes, edges, exports: exportsList, errors };
+  function addNamespace(n, name) {
+    if (namespaces.includes(name)) return;
+    namespaces.push(name);
+    const id = symId(rel, name);
+    nodes.push({
+      id,
+      kind: "namespace",
+      name,
+      path: rel,
+      startLine: n.startPosition.row + 1,
+      endLine: n.endPosition.row + 1,
+      source: "tree-sitter"
+    });
+    pushEdge({ src: fid, dst: id, kind: "defines", source: "tree-sitter" });
+  }
+  function addImport(dst, name, spec, line, conf) {
+    const cur = imports.get(dst);
+    if (cur?.meta) {
+      const names = cur.meta.names;
+      if (!names.includes(name)) names.push(name);
+      return;
+    }
+    imports.set(dst, {
+      src: fid,
+      dst,
+      kind: "imports",
+      source: "tree-sitter",
+      confidence: conf,
+      weight: 1,
+      meta: { names: [name], spec, line }
+    });
+  }
+  function handleUse(decl) {
+    const group = decl.childForFieldName("body");
+    const prefix = group ? decl.namedChildren.find((c) => c?.type === "namespace_name")?.text : void 0;
+    const declKind = decl.children.find((c) => c?.type === "function" || c?.type === "const")?.type;
+    for (const c of (group ?? decl).namedChildren) {
+      if (c?.type !== "namespace_use_clause") continue;
+      const alias = c.childForFieldName("alias");
+      const target = c.namedChildren.find(
+        (x) => x && x.id !== alias?.id && (x.type === "qualified_name" || x.type === "name")
+      );
+      if (!target) continue;
+      const fqn = (prefix ? `${prefix}\\${target.text}` : target.text).replace(/^\\+/, "");
+      const local = alias?.text ?? lastSegment(fqn);
+      const kind = c.children.find((x) => x?.type === "function" || x?.type === "const")?.type ?? declKind;
+      const line = c.startPosition.row + 1;
+      const label = alias ? `${fqn} as ${alias.text}` : fqn;
+      const file3 = kind ? void 0 : classFile(fqn);
+      if (file3) {
+        if (file3 !== rel) addImport(fileId(file3), label, fqn, line, 0.95);
+      } else {
+        const top = fqn.split("\\")[0];
+        importedPkgs.add(top);
+        if (!imports.has(pkgId(top)))
+          nodes.push({ id: pkgId(top), kind: "package", name: top, source: "tree-sitter" });
+        addImport(pkgId(top), label, fqn, line, 1);
+      }
+      if (kind) scope.set(local, { id: pkgId(fqn.split("\\")[0]), confidence: 0.6 });
+      else classUses.set(local, fqn);
+    }
+  }
+  function handleIncludes(rootNode) {
+    const here = dirname5(resolve4(root, rel));
+    for (const inc of rootNode.descendantsOfType([
+      "require_expression",
+      "require_once_expression",
+      "include_expression",
+      "include_once_expression"
+    ])) {
+      const arg = inc.namedChildren[0];
+      if (!arg) continue;
+      const candidates2 = [];
+      const plain = phpString(arg);
+      if (plain !== void 0) candidates2.push(resolve4(here, plain), resolve4(root, plain));
+      else if (arg.type === "binary_expression") {
+        const left = arg.childForFieldName("left")?.text.replace(/\s+/g, "") ?? "";
+        const right = phpString(arg.childForFieldName("right"));
+        const up = /^dirname\(__(?:DIR|FILE)__(?:,(\d+))?\)$/.exec(left);
+        let base;
+        if (left === "__DIR__" || left === "dirname(__FILE__)") base = here;
+        else if (up) {
+          base = here;
+          for (let i = left.includes("__FILE__") ? 1 : 0; i < Number(up[1] ?? 1); i++)
+            base = dirname5(base);
+        }
+        if (base && right !== void 0) candidates2.push(join17(base, right));
+      }
+      const hit = candidates2.find((c) => isFile(c) && !relative3(root, c).startsWith(".."));
+      if (!hit) continue;
+      const file3 = toRel(root, hit);
+      if (file3 !== rel) addImport(fileId(file3), "*", arg.text, inc.startPosition.row + 1, 0.9);
+    }
+  }
+  function classFile(fqcn) {
+    let hit = resolvedClasses.get(fqcn);
+    if (hit === void 0) {
+      hit = resolvePhpClass(root, rel, fqcn) ?? null;
+      resolvedClasses.set(fqcn, hit);
+    }
+    return hit ?? void 0;
+  }
+  function fqcnOf(name) {
+    if (name.startsWith("\\")) return name.slice(1);
+    const [head, ...rest2] = name.split("\\");
+    const used = classUses.get(head);
+    if (used) return [used, ...rest2].join("\\");
+    return namespace ? `${namespace}\\${name}` : name;
+  }
+  function classRef(name) {
+    if (!name || RELATIVE.has(name.toLowerCase())) return void 0;
+    if (!name.includes("\\") && !classUses.has(name) && declared.has(name))
+      return { id: symId(rel, name), confidence: 0.9 };
+    const fqcn = fqcnOf(name);
+    const file3 = classFile(fqcn);
+    if (file3) return { id: symId(file3, lastSegment(fqcn)), confidence: file3 === rel ? 0.9 : 0.85 };
+    const used = classUses.get(name.replace(/^\\/, "").split("\\")[0]);
+    if (used && !name.startsWith("\\")) return { id: pkgId(used.split("\\")[0]), confidence: 0.6 };
+    return void 0;
+  }
+  function typeRef(n) {
+    if (!n) return void 0;
+    const named = n.type === "named_type" ? n : n.descendantsOfType("named_type")[0];
+    const t = named ? classRef(named.text) : void 0;
+    return t?.id.startsWith("sym:") ? t.id : void 0;
+  }
+  function collectDecls(n) {
+    if (CLASS_KINDS[n.type]) {
+      collectClass(n);
+      return;
+    }
+    switch (n.type) {
+      case "function_definition": {
+        const name = n.childForFieldName("name")?.text;
+        if (name) addFunction(name, n);
+        return;
+      }
+      case "if_statement": {
+        for (const f of n.descendantsOfType("function_definition")) {
+          const name = f.childForFieldName("name")?.text;
+          if (name && !insideDecl(f, n)) addFunction(name, f);
+        }
+        return;
+      }
+      case "const_declaration": {
+        for (const el of n.namedChildren) {
+          const name = el?.type === "const_element" ? el.namedChildren[0]?.text : void 0;
+          if (name) addSym(name, "variable", el, true);
+        }
+        return;
+      }
+      case "expression_statement": {
+        const call = n.namedChildren[0];
+        if (call?.type !== "function_call_expression") return;
+        if (call.childForFieldName("function")?.text !== "define") return;
+        const name = phpString(argsOf(call)[0]);
+        if (name && /^\w+$/.test(name)) addSym(name, "variable", call, true);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  function insideDecl(n, top) {
+    for (let cur = n.parent; cur && cur.id !== top.id; cur = cur.parent) {
+      if (cur.type === "function_definition" || cur.type === "method_declaration") return true;
+      if (CLASS_KINDS[cur.type]) return true;
+    }
+    return false;
+  }
+  function addFunction(name, n) {
+    addSym(name, "function", n, true);
+    scope.set(name, { id: symId(rel, name), confidence: 0.9 });
+  }
+  function collectClass(n) {
+    const name = n.childForFieldName("name")?.text;
+    const kind = CLASS_KINDS[n.type];
+    if (!name || !kind) return;
+    addSym(name, kind, n, true);
+    const self = symId(rel, name);
+    for (const h of n.namedChildren) {
+      if (h?.type !== "base_clause" && h?.type !== "class_interface_clause") continue;
+      for (const b of h.namedChildren) {
+        if (b?.type !== "name" && b?.type !== "qualified_name") continue;
+        const target = heritage(self, b.text, h.type === "base_clause" ? "extends" : "implements");
+        if (target && h.type === "base_clause" && kind === "class") parents.set(name, target);
+      }
+    }
+    const body = n.childForFieldName("body");
+    for (const m of body?.namedChildren ?? []) {
+      if (!m) continue;
+      switch (m.type) {
+        case "method_declaration": {
+          const mname = m.childForFieldName("name")?.text;
+          if (!mname) break;
+          addSym(`${name}.${mname}`, "method", m, isPublic(m));
+          const params = m.childForFieldName("parameters")?.namedChildren ?? [];
+          for (const prm of params) {
+            if (prm?.type !== "property_promotion_parameter") continue;
+            const pname = prm.childForFieldName("name")?.text.replace(/^\$/, "");
+            if (!pname) continue;
+            addSym(`${name}.${pname}`, "field", prm, isPublic(prm));
+            const t = typeRef(prm.childForFieldName("type"));
+            if (t) propTypes.set(`${name}.${pname}`, t);
+          }
+          break;
+        }
+        case "property_declaration": {
+          const t = typeRef(m.childForFieldName("type"));
+          for (const el of m.namedChildren) {
+            if (el?.type !== "property_element") continue;
+            const pname = el.childForFieldName("name")?.text.replace(/^\$/, "");
+            if (!pname) continue;
+            addSym(`${name}.${pname}`, "field", el, isPublic(m));
+            if (t) propTypes.set(`${name}.${pname}`, t);
+          }
+          break;
+        }
+        case "const_declaration": {
+          for (const el of m.namedChildren) {
+            const cname = el?.type === "const_element" ? el.namedChildren[0]?.text : void 0;
+            if (cname) addSym(`${name}.${cname}`, "field", el, isPublic(m));
+          }
+          break;
+        }
+        case "enum_case": {
+          const cname = m.childForFieldName("name")?.text;
+          if (cname) addSym(`${name}.${cname}`, "field", m, true);
+          break;
+        }
+        case "use_declaration": {
+          for (const t of m.namedChildren) {
+            if (t?.type === "name" || t?.type === "qualified_name")
+              heritage(self, t.text, "extends", { trait: true });
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    attributeRoutes(n, name);
+  }
+  function heritage(src, name, kind, meta4) {
+    const ref = classRef(name) ?? (name.startsWith("\\") && !name.slice(1).includes("\\") ? void 0 : { id: symId(rel, lastSegment(name)), confidence: 0.5 });
+    if (!ref) return void 0;
+    pushEdge({
+      src,
+      dst: ref.id,
+      kind,
+      source: "tree-sitter",
+      confidence: ref.confidence,
+      ...meta4 ? { meta: meta4 } : {}
+    });
+    return ref.id.startsWith("sym:") ? ref.id : void 0;
+  }
+  function addSym(qualified, kind, n, exported) {
+    const id = symId(rel, qualified);
+    const c = kind === "function" || kind === "method" ? complexityOf(n, BRANCHES2, BOOL_OPS2) : 0;
+    complexity += c;
+    nodes.push({
+      id,
+      kind,
+      name: qualified,
+      path: rel,
+      startLine: n.startPosition.row + 1,
+      endLine: n.endPosition.row + 1,
+      source: "tree-sitter",
+      meta: {
+        ...exported ? { exported: true } : {},
+        loc: n.endPosition.row - n.startPosition.row + 1,
+        ...c ? { complexity: c } : {}
+      }
+    });
+    pushEdge({ src: fid, dst: id, kind: "defines", source: "tree-sitter" });
+    if (exported) {
+      exportsList.push(qualified);
+      pushEdge({ src: fid, dst: id, kind: "exports", source: "tree-sitter" });
+    }
+    localSyms.set(qualified, id);
+  }
+  function enclosing(n) {
+    let cur = n.parent;
+    while (cur) {
+      if (cur.type === "method_declaration") {
+        const name = cur.childForFieldName("name")?.text;
+        const owner = cur.parent?.parent?.childForFieldName("name")?.text;
+        const q = owner && name ? `${owner}.${name}` : void 0;
+        if (q && localSyms.has(q)) return q;
+      }
+      if (cur.type === "function_definition") {
+        const name = cur.childForFieldName("name")?.text;
+        if (name && localSyms.has(name)) return name;
+      }
+      cur = cur.parent;
+    }
+    return void 0;
+  }
+  function objectType(obj, caller) {
+    const cls = classOf(caller);
+    if (obj.type === "variable_name") {
+      if (obj.text === "$this") return cls ? { id: symId(rel, cls), confidence: 0.9 } : void 0;
+      const t = varTypes.get(`${caller ?? ""}\0${obj.text}`);
+      return t ? { id: t, confidence: 0.8 } : void 0;
+    }
+    if (obj.type === "member_access_expression" || obj.type === "nullsafe_member_access_expression") {
+      const inner = obj.childForFieldName("object");
+      const prop = obj.childForFieldName("name")?.text;
+      if (inner?.text !== "$this" || !cls || !prop) return void 0;
+      const t = propTypes.get(`${cls}.${prop}`);
+      return t ? { id: t, confidence: 0.8 } : void 0;
+    }
+    return void 0;
+  }
+  function scopeType(s, caller) {
+    const cls = classOf(caller);
+    if (s.type === "relative_scope" || RELATIVE.has(s.text.toLowerCase())) {
+      const word = s.text.toLowerCase();
+      if (!cls) return void 0;
+      if (word === "parent") {
+        const p2 = parents.get(cls);
+        return p2 ? { id: p2, confidence: 0.8 } : void 0;
+      }
+      return { id: symId(rel, cls), confidence: 0.9 };
+    }
+    if (s.type === "name" || s.type === "qualified_name") return classRef(s.text);
+    return void 0;
+  }
+  function callTarget(call, caller) {
+    switch (call.type) {
+      case "function_call_expression": {
+        const fn = call.childForFieldName("function");
+        if (fn?.type !== "name") return void 0;
+        const local = scope.get(fn.text);
+        if (local || !auto?.files.length) return local;
+        const file3 = autoloadedFunctions(root, auto).get(fn.text);
+        return file3 && file3 !== rel ? { id: symId(file3, fn.text), confidence: 0.8 } : void 0;
+      }
+      case "member_call_expression":
+      case "nullsafe_member_call_expression": {
+        const obj = call.childForFieldName("object");
+        const m = call.childForFieldName("name");
+        if (!obj || m?.type !== "name") return void 0;
+        const t = objectType(obj, caller);
+        return t ? { id: `${t.id}.${m.text}`, confidence: t.confidence } : void 0;
+      }
+      case "scoped_call_expression": {
+        const s = call.childForFieldName("scope");
+        const m = call.childForFieldName("name");
+        if (!s || m?.type !== "name") return void 0;
+        const t = scopeType(s, caller);
+        if (t?.id.startsWith("pkg:")) return t;
+        return t ? { id: `${t.id}.${m.text}`, confidence: t.confidence } : void 0;
+      }
+      case "object_creation_expression": {
+        const cls = call.namedChildren.find(
+          (c) => c?.type === "name" || c?.type === "qualified_name"
+        );
+        return cls ? classRef(cls.text) : void 0;
+      }
+      default:
+        return void 0;
+    }
+  }
+  function noteVarTypes(n) {
+    for (const prm of n.descendantsOfType("simple_parameter")) {
+      const t = typeRef(prm.childForFieldName("type"));
+      const v = prm.childForFieldName("name")?.text;
+      if (t && v) varTypes.set(`${enclosing(prm) ?? ""}\0${v}`, t);
+    }
+    for (const a of n.descendantsOfType("assignment_expression")) {
+      const left = a.childForFieldName("left");
+      const right = a.childForFieldName("right");
+      if (left?.type !== "variable_name" || right?.type !== "object_creation_expression") continue;
+      const cls = right.namedChildren.find(
+        (c) => c?.type === "name" || c?.type === "qualified_name"
+      );
+      const t = cls ? classRef(cls.text) : void 0;
+      if (t?.id.startsWith("sym:")) varTypes.set(`${enclosing(a) ?? ""}\0${left.text}`, t.id);
+    }
+  }
+  function addRoute(method, path3, framework, line, handlers, confidence, extra = {}) {
+    const id = routeId(method, path3);
+    if (!nodes.some((n) => n.id === id)) {
+      nodes.push({
+        id,
+        kind: "route",
+        name: `${method} ${path3}`,
+        path: rel,
+        startLine: line,
+        endLine: line,
+        source: "tree-sitter",
+        meta: { method, route: path3, framework, ...extra }
+      });
+      pushEdge({ src: fid, dst: id, kind: "defines", source: "tree-sitter" });
+    }
+    for (const h of handlers)
+      pushEdge({ src: h, dst: id, kind: "handles", source: "tree-sitter", confidence });
+  }
+  function controllerRef(name, literal2 = false) {
+    if (!literal2) {
+      const direct = classRef(name);
+      if (direct?.id.startsWith("sym:")) return direct;
+    }
+    const fq = name.replace(/^\\+/, "");
+    const candidates2 = CONTROLLER_NAMESPACES.map((ns) => `${ns}\\${fq}`);
+    if (literal2) candidates2.push(fq);
+    for (const c of candidates2) {
+      const file3 = classFile(c);
+      if (file3) return { id: symId(file3, lastSegment(fq)), confidence: 0.85 };
+    }
+    return void 0;
+  }
+  function classConstant(n) {
+    if (n.type !== "class_constant_access_expression") return void 0;
+    const [cls, member] = n.namedChildren;
+    if (!cls || member?.text !== "class") return void 0;
+    const t = controllerRef(cls.text);
+    return t?.id.startsWith("sym:") ? t : void 0;
+  }
+  function handlersOf(arg, caller, controller) {
+    const handlers = [];
+    let confidence = 0.9;
+    const self = caller ? symId(rel, caller) : fid;
+    const visit2 = (a) => {
+      if (!a) return;
+      if (a.type === "anonymous_function" || a.type === "arrow_function") {
+        handlers.push(self);
+        confidence = Math.min(confidence, 0.7);
+      } else if (a.type === "class_constant_access_expression") {
+        const t = classConstant(a);
+        if (t) handlers.push(t.id);
+      } else if (a.type === "string" || a.type === "encapsed_string") {
+        const s = phpString(a) ?? "";
+        const m = CONTROLLER_STRING.exec(s);
+        const t = m ? controllerRef(m[1], true) : void 0;
+        if (t && m) handlers.push(`${t.id}.${m[2]}`);
+        else if (controller && /^\w+$/.test(s)) handlers.push(`${controller.id}.${s}`);
+      } else if (a.type === "array_creation_expression") {
+        const els = arrayElements(a);
+        const [first, second] = els;
+        const method = second && !second.key ? phpString(second.value) : void 0;
+        const cls = first && !first.key ? classConstant(first.value) : void 0;
+        if (els.length === 2 && cls && method) handlers.push(`${cls.id}.${method}`);
+        else for (const el of els) if (!el.key || el.key === "uses") visit2(el.value);
+      }
+    };
+    visit2(arg);
+    if (!handlers.length) {
+      handlers.push(self);
+      confidence = 0.5;
+    }
+    return { handlers: [...new Set(handlers)], confidence };
+  }
+  function groupContext(n) {
+    const prefixes = [];
+    let controller;
+    for (let cur = n.parent; cur; cur = cur.parent) {
+      if (cur.type !== "anonymous_function" && cur.type !== "arrow_function") continue;
+      const call = cur.parent?.type === "argument" ? cur.parent.parent?.parent : void 0;
+      if (!call || !isCall(call) || call.childForFieldName("name")?.text !== "group") continue;
+      const own2 = [];
+      const first = argsOf(call)[0];
+      const direct = first && first.id !== cur.id ? phpString(first) : void 0;
+      if (direct !== void 0) own2.push(direct);
+      else if (first?.type === "array_creation_expression") {
+        const prefix = arrayElements(first).find((e) => e.key === "prefix");
+        const s = prefix ? phpString(prefix.value) : void 0;
+        if (s !== void 0) own2.push(s);
+      }
+      for (let link = call.childForFieldName("object"); link && isCall(link); ) {
+        const name = link.childForFieldName("name")?.text;
+        const a0 = argsOf(link)[0];
+        if (name === "prefix") {
+          const s = phpString(a0);
+          if (s !== void 0) own2.unshift(s);
+        } else if (name === "controller" && a0 && !controller) {
+          const s = phpString(a0);
+          controller = classConstant(a0) ?? (s ? controllerRef(s, true) : void 0);
+        }
+        link = link.childForFieldName("object");
+      }
+      prefixes.unshift(...own2);
+    }
+    return { prefixes, controller };
+  }
+  function laravelBase() {
+    return /(^|\/)routes\/api\.php$/.test(rel) ? "/api" : void 0;
+  }
+  function routeFromCall(call, caller) {
+    let facade = false;
+    const chained = [];
+    for (let link = call; link && isCall(link); ) {
+      if (link.type === "scoped_call_expression") {
+        facade = lastSegment(link.childForFieldName("scope")?.text ?? "") === "Route";
+        break;
+      }
+      link = link.childForFieldName("object");
+      if (link && isCall(link) && link.childForFieldName("name")?.text === "prefix") {
+        const s = phpString(argsOf(link)[0]);
+        if (s !== void 0) chained.unshift(s);
+      }
+    }
+    const obj = call.type === "member_call_expression" ? call.childForFieldName("object") : null;
+    const member = !facade && obj?.type === "variable_name" && obj.text !== "$this";
+    if (!facade && !member) return;
+    const verb = call.childForFieldName("name")?.text ?? "";
+    const lower = verb.toLowerCase();
+    const args = argsOf(call);
+    if (facade && (verb === "resource" || verb === "apiResource")) {
+      const name = phpString(args[0]);
+      if (name) resourceRoutes(call, verb === "apiResource", name, args, caller, chained);
+      return;
+    }
+    if (facade && (verb === "resources" || verb === "apiResources")) {
+      if (args[0]?.type !== "array_creation_expression") return;
+      for (const el of arrayElements(args[0])) {
+        if (el.key)
+          resourceRoutes(
+            call,
+            verb === "apiResources",
+            el.key,
+            [void 0, el.value, args[1]],
+            caller,
+            chained
+          );
+      }
+      return;
+    }
+    let methods;
+    let rest2;
+    if (facade && lower === "view") {
+      methods = ["GET"];
+      rest2 = args.slice(0, 1);
+    } else if (facade && (lower === "redirect" || lower === "permanentredirect")) {
+      methods = ["ALL"];
+      rest2 = args.slice(0, 1);
+    } else if (lower === "match" || lower === "map") {
+      methods = stringsOf(args[0]).map((m) => httpMethod(m)).filter((m) => !!m);
+      rest2 = args.slice(1);
+    } else if (lower === "any") {
+      methods = ["ALL"];
+      rest2 = args;
+    } else if (ROUTE_METHODS.has(lower) && lower !== "all") {
+      methods = [lower.toUpperCase()];
+      rest2 = args;
+    } else return;
+    const raw = phpString(rest2[0]);
+    if (raw === void 0 || !methods.length) return;
+    if (member && (!handlerShaped(rest2[1]) || !raw.startsWith("/") && !ROUTER_VARS.has(obj.text)))
+      return;
+    const ctx = groupContext(call);
+    const { handlers, confidence } = handlersOf(rest2[1], caller, ctx.controller);
+    const path3 = phpRoutePath(facade ? laravelBase() : void 0, ...ctx.prefixes, ...chained, raw);
+    const framework = facade ? "laravel" : frameworkOf(importedPkgs) ?? frameworkOf(auto?.require ?? []) ?? "http";
+    for (const m of methods)
+      addRoute(m, path3, framework, call.startPosition.row + 1, handlers, confidence);
+  }
+  function resourceRoutes(call, api, name, args, caller, chained) {
+    let only;
+    let except;
+    if (args[2]?.type === "array_creation_expression") {
+      for (const opt of arrayElements(args[2])) {
+        if (opt.key === "only") only = stringsOf(opt.value);
+        if (opt.key === "except") except = stringsOf(opt.value);
+      }
+    }
+    for (let cur = call; cur.parent?.type === "member_call_expression"; cur = cur.parent) {
+      if (cur.parent.childForFieldName("object")?.id !== cur.id) break;
+      const m = cur.parent.childForFieldName("name")?.text;
+      if (m === "only") only = stringsOf(argsOf(cur.parent)[0]);
+      if (m === "except") except = stringsOf(argsOf(cur.parent)[0]);
+    }
+    const ctx = groupContext(call);
+    const literal2 = phpString(args[1]);
+    const cls = args[1] ? classConstant(args[1]) ?? (literal2 ? controllerRef(literal2, true) : void 0) : void 0;
+    const self = caller ? symId(rel, caller) : fid;
+    for (const spec of laravelResource(name, api, only, except)) {
+      addRoute(
+        spec.method,
+        phpRoutePath(laravelBase(), ...ctx.prefixes, ...chained, spec.path),
+        "laravel",
+        call.startPosition.row + 1,
+        [cls ? `${cls.id}.${spec.action}` : self],
+        cls ? 0.9 : 0.5
+      );
+    }
+  }
+  function attributesOf(n) {
+    return (n.childForFieldName("attributes")?.descendantsOfType("attribute") ?? []).map(
+      (attr) => ({ attr, fq: fqcnOf(attr.namedChildren[0]?.text ?? "") })
+    );
+  }
+  function routeSpecs(n) {
+    const out = [];
+    for (const { attr, fq } of attributesOf(n)) {
+      const short = lastSegment(fq);
+      if (fq.startsWith(SPATIE_ATTRIBUTES)) {
+        const verb = short === "Any" ? "ALL" : httpMethod(short);
+        const pos = positionalArgs(attr);
+        const methods2 = short === "Route" ? stringsOf(namedArg(attr, "method") ?? pos.shift()).map((m) => httpMethod(m)).filter((m) => !!m) : verb ? [verb] : [];
+        const path4 = phpString(namedArg(attr, "uri") ?? pos[0]);
+        if (path4 === void 0) continue;
+        for (const method of methods2) out.push({ method, path: path4, spatie: true });
+        continue;
+      }
+      if (short !== "Route") continue;
+      const path3 = phpString(namedArg(attr, "path")) ?? phpString(positionalArgs(attr)[0]);
+      if (path3 === void 0) continue;
+      const methods = stringsOf(namedArg(attr, "methods")).map((m) => httpMethod(m)).filter((m) => !!m);
+      for (const method of methods.length ? methods : ["ALL"]) out.push({ method, path: path3 });
+    }
+    const doc = n.previousNamedSibling;
+    if (doc?.type === "comment" && doc.text.includes("@Route"))
+      out.push(...parseRouteAnnotations(doc.text));
+    return out;
+  }
+  function attributeRoutes(cls, className) {
+    const classSpecs = routeSpecs(cls);
+    let prefix = classSpecs[0]?.path;
+    const framework = frameworkOf(importedPkgs) ?? "symfony";
+    const line = cls.startPosition.row + 1;
+    for (const { attr, fq } of attributesOf(cls)) {
+      if (!fq.startsWith(SPATIE_ATTRIBUTES)) continue;
+      const short = lastSegment(fq);
+      const pos = positionalArgs(attr);
+      if (short === "Prefix") prefix = phpString(namedArg(attr, "prefix") ?? pos[0]) ?? prefix;
+      if (short !== "Resource") continue;
+      const name = phpString(namedArg(attr, "resource") ?? pos[0]);
+      if (!name) continue;
+      const api = (namedArg(attr, "apiResource") ?? pos[1])?.text === "true";
+      const only = namedArg(attr, "only");
+      const except = namedArg(attr, "except");
+      for (const spec of laravelResource(
+        name,
+        api,
+        only ? stringsOf(only) : void 0,
+        except ? stringsOf(except) : void 0
+      ))
+        addRoute(
+          spec.method,
+          phpRoutePath(prefix, spec.path),
+          "laravel",
+          line,
+          [symId(rel, `${className}.${spec.action}`)],
+          0.95
+        );
+    }
+    for (const m of cls.childForFieldName("body")?.namedChildren ?? []) {
+      if (m?.type !== "method_declaration") continue;
+      const mname = m.childForFieldName("name")?.text;
+      if (!mname) continue;
+      const specs = routeSpecs(m);
+      if (!specs.length && mname === "__invoke" && classSpecs.length) {
+        for (const s of classSpecs)
+          addRoute(
+            s.method,
+            phpRoutePath(s.path),
+            framework,
+            line,
+            [symId(rel, `${className}.${mname}`)],
+            0.95
+          );
+        continue;
+      }
+      for (const s of specs) {
+        addRoute(
+          s.method,
+          phpRoutePath(prefix, s.path),
+          s.spatie ? "laravel" : framework,
+          m.startPosition.row + 1,
+          [symId(rel, `${className}.${mname}`)],
+          0.95
+        );
+      }
+    }
+  }
+  function walkRefs(n) {
+    noteVarTypes(n);
+    for (const call of n.descendantsOfType(CALLS)) {
+      const caller = enclosing(call);
+      routeFromCall(call, caller);
+      const target = callTarget(call, caller);
+      if (!target) continue;
+      refs.push(
+        caller ? symId(rel, caller) : fid,
+        target.id,
+        "calls",
+        target.confidence,
+        call.startPosition.row + 1
+      );
+    }
+    const named = [];
+    for (const t of n.descendantsOfType("named_type")) named.push(t);
+    for (const a of n.descendantsOfType([
+      "class_constant_access_expression",
+      "scoped_property_access_expression"
+    ])) {
+      const s = a.namedChildren[0];
+      if (s && (s.type === "name" || s.type === "qualified_name")) named.push(s);
+    }
+    for (const b of n.descendantsOfType("binary_expression")) {
+      const right = b.childForFieldName("right");
+      if (b.childForFieldName("operator")?.type === "instanceof" && right) named.push(right);
+    }
+    for (const t of named) {
+      const target = classRef(t.text);
+      if (!target) continue;
+      const caller = enclosing(t);
+      refs.push(
+        caller ? symId(rel, caller) : fid,
+        target.id,
+        "references",
+        target.confidence * 0.9,
+        t.startPosition.row + 1
+      );
+    }
+    for (const me of n.descendantsOfType([
+      "member_access_expression",
+      "nullsafe_member_access_expression"
+    ])) {
+      if (me.childForFieldName("object")?.text !== "$this") continue;
+      const caller = enclosing(me);
+      const cls = classOf(caller);
+      const prop = me.childForFieldName("name")?.text;
+      if (!cls || !prop || !localSyms.has(`${cls}.${prop}`)) continue;
+      refs.push(
+        symId(rel, caller),
+        symId(rel, `${cls}.${prop}`),
+        "references",
+        0.81,
+        me.startPosition.row + 1
+      );
+    }
+  }
+}
+var BRANCHES2, BOOL_OPS2, CALLS, CLASS_KINDS, RELATIVE, ROUTER_VARS, CONTROLLER_NAMESPACES, SPATIE_ATTRIBUTES, isFile, toRel, CLASSMAP_MAX_FILES, composerCache, asList, CONTROLLER_STRING, isPublic, classOf, lastSegment, isCall;
+var init_php = __esm({
+  "src/graph/languages/php.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_ids();
+    init_routes();
+    init_parser();
+    BRANCHES2 = [
+      "if_statement",
+      "else_if_clause",
+      "for_statement",
+      "foreach_statement",
+      "while_statement",
+      "do_statement",
+      "case_statement",
+      "catch_clause",
+      "conditional_expression",
+      "match_conditional_expression",
+      "binary_expression"
+    ];
+    BOOL_OPS2 = /* @__PURE__ */ new Set(["&&", "||", "and", "or", "??"]);
+    CALLS = [
+      "function_call_expression",
+      "member_call_expression",
+      "nullsafe_member_call_expression",
+      "scoped_call_expression",
+      "object_creation_expression"
+    ];
+    CLASS_KINDS = {
+      class_declaration: "class",
+      interface_declaration: "interface",
+      trait_declaration: "trait",
+      enum_declaration: "enum"
+    };
+    RELATIVE = /* @__PURE__ */ new Set(["self", "static", "parent"]);
+    ROUTER_VARS = /* @__PURE__ */ new Set(["$app", "$router", "$routes", "$route", "$group", "$r"]);
+    CONTROLLER_NAMESPACES = ["App\\Http\\Controllers", "App\\Controllers"];
+    SPATIE_ATTRIBUTES = "Spatie\\RouteAttributes\\Attributes\\";
+    isFile = (p) => {
+      try {
+        return statSync2(p).isFile();
+      } catch {
+        return false;
+      }
+    };
+    toRel = (root, abs) => normalize2(relative3(root, abs)).split("\\").join("/");
+    CLASSMAP_MAX_FILES = 5e3;
+    composerCache = /* @__PURE__ */ new Map();
+    asList = (v) => Array.isArray(v) ? v : [v];
+    CONTROLLER_STRING = /^\\?([\w\\]+?)(?:@|::?)(\w+)$/;
+    isPublic = (m) => !m.namedChildren.some((c) => c?.type === "visibility_modifier" && c.text !== "public");
+    classOf = (caller) => caller?.includes(".") ? caller.split(".")[0] : void 0;
+    lastSegment = (name) => name.split("\\").pop() ?? name;
+    isCall = (n) => n.type === "member_call_expression" || n.type === "scoped_call_expression";
+  }
+});
+
+// src/graph/languages/python.ts
+import { existsSync as existsSync15, statSync as statSync3 } from "fs";
+import { dirname as dirname6, join as join18, normalize as normalize3, relative as relative4, resolve as resolve5 } from "path";
 function resolvePython(root, fromRel, module, level) {
   const parts = module ? module.split(".") : [];
   const candidates2 = [];
   if (level > 0) {
-    let base = dirname5(resolve4(root, fromRel));
-    for (let i = 1; i < level; i++) base = dirname5(base);
-    candidates2.push(join17(base, ...parts));
+    let base = dirname6(resolve5(root, fromRel));
+    for (let i = 1; i < level; i++) base = dirname6(base);
+    candidates2.push(join18(base, ...parts));
   } else {
-    candidates2.push(resolve4(root, ...parts), resolve4(root, "src", ...parts));
-    let dir = dirname5(resolve4(root, fromRel));
+    candidates2.push(resolve5(root, ...parts), resolve5(root, "src", ...parts));
+    let dir = dirname6(resolve5(root, fromRel));
     while (dir.startsWith(root) && dir !== root) {
-      candidates2.push(join17(dir, ...parts));
-      dir = dirname5(dir);
+      candidates2.push(join18(dir, ...parts));
+      dir = dirname6(dir);
     }
   }
   for (const c of candidates2) {
-    for (const f of [`${c}.py`, join17(c, "__init__.py"), `${c}.pyi`]) {
-      if (isFile(f) && !relative3(root, f).startsWith(".."))
-        return normalize2(relative3(root, f)).split("\\").join("/");
+    for (const f of [`${c}.py`, join18(c, "__init__.py"), `${c}.pyi`]) {
+      if (isFile2(f) && !relative4(root, f).startsWith(".."))
+        return normalize3(relative4(root, f)).split("\\").join("/");
     }
   }
   return void 0;
@@ -32351,7 +33484,7 @@ async function parsePython(root, rel, code) {
       walkRefs(stmt);
   }
   edges.push(...refs.edges());
-  if (!existsSync15(join17(root, rel))) {
+  if (!existsSync15(join18(root, rel))) {
   }
   const errors = tree.rootNode.hasError ? tree.rootNode.descendantsOfType("ERROR").length : 0;
   fileNode.meta = {
@@ -32504,7 +33637,7 @@ async function parsePython(root, rel, code) {
   }
   function addSym(qualified, kind, n, exported) {
     const id = symId(rel, qualified);
-    const c = kind === "function" || kind === "method" ? complexityOf(n, BRANCHES2, BOOL_OPS2) : 0;
+    const c = kind === "function" || kind === "method" ? complexityOf(n, BRANCHES3, BOOL_OPS3) : 0;
     complexity += c;
     nodes.push({
       id,
@@ -32647,7 +33780,7 @@ async function parsePython(root, rel, code) {
     }
   }
 }
-var BRANCHES2, BOOL_OPS2, isFile, topModule, REF_SKIP_PARENT;
+var BRANCHES3, BOOL_OPS3, isFile2, topModule, REF_SKIP_PARENT;
 var init_python = __esm({
   "src/graph/languages/python.ts"() {
     "use strict";
@@ -32655,7 +33788,7 @@ var init_python = __esm({
     init_ids();
     init_routes();
     init_parser();
-    BRANCHES2 = [
+    BRANCHES3 = [
       "if_statement",
       "elif_clause",
       "for_statement",
@@ -32666,10 +33799,10 @@ var init_python = __esm({
       "case_clause",
       "for_in_clause"
     ];
-    BOOL_OPS2 = /* @__PURE__ */ new Set(["and", "or"]);
-    isFile = (p) => {
+    BOOL_OPS3 = /* @__PURE__ */ new Set(["and", "or"]);
+    isFile2 = (p) => {
       try {
-        return statSync2(p).isFile();
+        return statSync3(p).isFile();
       } catch {
         return false;
       }
@@ -32698,21 +33831,21 @@ var init_python = __esm({
 });
 
 // src/graph/resolve.ts
-import { existsSync as existsSync16, readdirSync as readdirSync6, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
-import { dirname as dirname6, join as join18, normalize as normalize3, relative as relative4, resolve as resolve5 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync13, statSync as statSync4 } from "fs";
+import { dirname as dirname7, join as join19, normalize as normalize4, relative as relative5, resolve as resolve6 } from "path";
 function loadTsPaths(root) {
   const hit = tsPathsCache.get(root);
   if (hit !== void 0) return hit;
   let out = null;
   try {
-    const file3 = join18(root, "tsconfig.json");
+    const file3 = join19(root, "tsconfig.json");
     if (existsSync16(file3)) {
-      const raw = readFileSync12(file3, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
+      const raw = readFileSync13(file3, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
       const cfg = JSON.parse(raw);
       const co = cfg.compilerOptions ?? {};
       if (co.paths) {
         out = {
-          baseUrl: resolve5(root, co.baseUrl ?? "."),
+          baseUrl: resolve6(root, co.baseUrl ?? "."),
           paths: Object.entries(co.paths).map(([k, v]) => {
             const star = k.indexOf("*");
             return star === -1 ? { prefix: k, suffix: "\0", targets: v } : { prefix: k.slice(0, star), suffix: k.slice(star + 1), targets: v };
@@ -32729,7 +33862,7 @@ function loadTsPaths(root) {
 function probe(abs) {
   const tryFile = (p) => {
     try {
-      return statSync3(p).isFile() ? p : void 0;
+      return statSync4(p).isFile() ? p : void 0;
     } catch {
       return void 0;
     }
@@ -32745,16 +33878,16 @@ function probe(abs) {
     if (tryFile(abs + ext)) return abs + ext;
   }
   for (const ext of EXTS) {
-    const idx = join18(abs, `index${ext}`);
+    const idx = join19(abs, `index${ext}`);
     if (tryFile(idx)) return idx;
   }
   return void 0;
 }
 function readPackageJson(dir) {
   try {
-    const file3 = join18(dir, "package.json");
+    const file3 = join19(dir, "package.json");
     if (!existsSync16(file3)) return void 0;
-    return JSON.parse(readFileSync12(file3, "utf8"));
+    return JSON.parse(readFileSync13(file3, "utf8"));
   } catch {
     return void 0;
   }
@@ -32770,9 +33903,9 @@ function loadWorkspaces(root) {
   if (Array.isArray(ws)) globs.push(...ws);
   else if (ws?.packages) globs.push(...ws.packages);
   try {
-    const yaml = join18(root, "pnpm-workspace.yaml");
+    const yaml = join19(root, "pnpm-workspace.yaml");
     if (existsSync16(yaml)) {
-      for (const m of readFileSync12(yaml, "utf8").matchAll(/^\s*-\s*['"]?([^'"\n#]+?)['"]?\s*$/gm))
+      for (const m of readFileSync13(yaml, "utf8").matchAll(/^\s*-\s*['"]?([^'"\n#]+?)['"]?\s*$/gm))
         globs.push(m[1].trim());
     }
   } catch {
@@ -32781,12 +33914,12 @@ function loadWorkspaces(root) {
     if (g.startsWith("!")) continue;
     const star = g.indexOf("*");
     const dirs = [];
-    if (star === -1) dirs.push(resolve5(root, g));
+    if (star === -1) dirs.push(resolve6(root, g));
     else {
-      const base = resolve5(root, g.slice(0, star));
+      const base = resolve6(root, g.slice(0, star));
       try {
-        for (const d of readdirSync6(base, { withFileTypes: true })) {
-          if (d.isDirectory()) dirs.push(join18(base, d.name));
+        for (const d of readdirSync7(base, { withFileTypes: true })) {
+          if (d.isDirectory()) dirs.push(join19(base, d.name));
         }
       } catch {
       }
@@ -32840,16 +33973,16 @@ function resolvePackageEntry(dir, sub) {
   } else candidates2.push(sub, `src/${sub}`, `lib/${sub}`);
   for (const c of candidates2) {
     if (c.includes("*")) continue;
-    const hit = probe(resolve5(dir, c));
+    const hit = probe(resolve6(dir, c));
     if (hit) return hit;
   }
   return void 0;
 }
 function resolveImport(root, fromRel, spec) {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const abs = spec.startsWith("/") ? spec : resolve5(root, dirname6(fromRel), spec);
+    const abs = spec.startsWith("/") ? spec : resolve6(root, dirname7(fromRel), spec);
     const hit = probe(abs);
-    return hit ? normalize3(relative4(root, hit)) : void 0;
+    return hit ? normalize4(relative5(root, hit)) : void 0;
   }
   const tp = loadTsPaths(root);
   if (tp) {
@@ -32858,8 +33991,8 @@ function resolveImport(root, fromRel, spec) {
       if (exact ? spec === p.prefix : spec.startsWith(p.prefix) && spec.endsWith(p.suffix)) {
         const star = exact ? "" : spec.slice(p.prefix.length, spec.length - p.suffix.length);
         for (const t of p.targets) {
-          const hit = probe(resolve5(tp.baseUrl, t.replace("*", star)));
-          if (hit) return normalize3(relative4(root, hit));
+          const hit = probe(resolve6(tp.baseUrl, t.replace("*", star)));
+          if (hit) return normalize4(relative5(root, hit));
         }
       }
     }
@@ -32868,7 +34001,7 @@ function resolveImport(root, fromRel, spec) {
   const dir = loadWorkspaces(root).get(name);
   if (dir) {
     const hit = resolvePackageEntry(dir, spec.slice(name.length + 1));
-    if (hit && !relative4(root, hit).startsWith("..")) return normalize3(relative4(root, hit));
+    if (hit && !relative5(root, hit).startsWith("..")) return normalize4(relative5(root, hit));
   }
   return void 0;
 }
@@ -32932,6 +34065,7 @@ async function parseFile(root, rel, code) {
   if (!grammar) return { nodes: [], edges: [], exports: [] };
   if (grammar === "python") return parsePython(root, rel, code);
   if (grammar === "go") return parseGo(root, rel, code);
+  if (grammar === "php") return parsePhp(root, rel, code);
   const p = await getParser(grammar);
   const tree = p.parse(code);
   if (!tree) return { nodes: [], edges: [], exports: [] };
@@ -33524,6 +34658,7 @@ var init_treesitter = __esm({
     init_ids();
     init_go();
     init_parser();
+    init_php();
     init_python();
     init_resolve();
     init_routes();
@@ -33789,6 +34924,11 @@ function inherited(db, classId, member, depth) {
   }
   return void 0;
 }
+function ownerAncestor(db, path3, name) {
+  const dot = name.indexOf(".");
+  const owner = symId(path3, name.slice(0, dot));
+  return db.graphGetNode(owner) ? inherited(db, owner, name.slice(dot + 1), 0) : void 0;
+}
 function defaultExportOf(db, path3) {
   const f = db.graphGetNode(fileId(path3));
   if (!f?.meta) return void 0;
@@ -33837,6 +34977,10 @@ function linkGraph(db) {
           direct = true;
         } else target = goSibling(db, path3, head);
       }
+      if (!target && name.includes(".")) {
+        target = ownerAncestor(db, path3, name);
+        direct = true;
+      }
       if (target && name.includes(".") && !direct) {
         const rest3 = name.slice(name.indexOf(".") + 1);
         const member = `${target}.${rest3}`;
@@ -33875,7 +35019,7 @@ function linkGraph(db) {
       const name = meta4.unresolved;
       if (!name) continue;
       const id = symId(e.dst.slice(5), name);
-      const target = db.graphGetNode(id) ? id : viaReexports(db, e.dst.slice(5), name.split(".")[0], 0, /* @__PURE__ */ new Set());
+      const target = db.graphGetNode(id) ? id : viaReexports(db, e.dst.slice(5), name.split(".")[0], 0, /* @__PURE__ */ new Set()) ?? (name.includes(".") ? ownerAncestor(db, e.dst.slice(5), name) : void 0);
       if (!target || target === e.src) continue;
       const { unresolved: _u, ...rest2 } = meta4;
       replace(db, e, {
@@ -33918,8 +35062,8 @@ var init_link = __esm({
 });
 
 // src/graph/reindex.ts
-import { readFileSync as readFileSync13, statSync as statSync4 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync14, statSync as statSync5 } from "fs";
+import { join as join20 } from "path";
 function listCodeFiles(ctx) {
   return import_fast_glob2.default.sync(ctx.config.graph.include, {
     cwd: ctx.root,
@@ -33930,8 +35074,8 @@ function listCodeFiles(ctx) {
   });
 }
 async function indexOne(ctx, db, rel, force) {
-  const abs = join19(ctx.root, rel);
-  const st = statSync4(abs);
+  const abs = join20(ctx.root, rel);
+  const st = statSync5(abs);
   const backend = getCodeBackend(ctx);
   const language = backend.languageOf(rel) ?? null;
   if (st.size > MAX_CODE_BYTES) {
@@ -33950,7 +35094,7 @@ async function indexOne(ctx, db, rel, force) {
     }
     return "skipped";
   }
-  const code = readFileSync13(abs, "utf8");
+  const code = readFileSync14(abs, "utf8");
   const hash2 = hashText(code);
   const prev = db.fileIndexGet(rel);
   if (!force && prev?.hash === hash2 && prev.status !== "skipped") return "unchanged";
@@ -34031,7 +35175,7 @@ async function reindexCode(ctx, db, opts = {}) {
     summary.unsupported++;
     if (db.fileIndexGet(rel)?.status === "unsupported") continue;
     try {
-      const st = statSync4(join19(ctx.root, rel));
+      const st = statSync5(join20(ctx.root, rel));
       db.fileIndexSet({
         path: rel,
         hash: "",
@@ -34047,7 +35191,7 @@ async function reindexCode(ctx, db, opts = {}) {
   }
   for (const rel of targets) {
     try {
-      if (!statSafe(join19(ctx.root, rel))) {
+      if (!statSafe(join20(ctx.root, rel))) {
         if (db.fileIndexGet(rel)) {
           removeOne(db, rel);
           summary.removed++;
@@ -34059,7 +35203,7 @@ async function reindexCode(ctx, db, opts = {}) {
       const error62 = err.message;
       summary.errors.push({ path: rel, error: error62 });
       try {
-        const st = statSync4(join19(ctx.root, rel));
+        const st = statSync5(join20(ctx.root, rel));
         db.fileIndexSet({
           path: rel,
           hash: "",
@@ -34122,7 +35266,7 @@ async function reindexCode(ctx, db, opts = {}) {
 }
 function statSafe(p) {
   try {
-    return statSync4(p).isFile();
+    return statSync5(p).isFile();
   } catch {
     return false;
   }
@@ -34162,10 +35306,10 @@ function indexFreshness(ctx, db) {
   const dirty = [];
   for (const r of rows.slice(0, 400)) {
     try {
-      const abs = join19(ctx.root, r.path);
-      const st = statSync4(abs);
+      const abs = join20(ctx.root, r.path);
+      const st = statSync5(abs);
       if (r.mtime !== null && Math.abs(st.mtimeMs - r.mtime) < 1 && st.size === r.size) continue;
-      if (hashText(readFileSync13(abs, "utf8")) !== r.hash) dirty.push(r.path);
+      if (hashText(readFileSync14(abs, "utf8")) !== r.hash) dirty.push(r.path);
     } catch {
       dirty.push(r.path);
     }
@@ -34199,22 +35343,22 @@ var init_reindex = __esm({
 });
 
 // src/session/current.ts
-import { readFileSync as readFileSync14, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync15, statSync as statSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join21 } from "path";
 function file2(ctx) {
-  return join20(projectDir(ctx.id), "current-session");
+  return join21(projectDir(ctx.id), "current-session");
 }
 function getCurrentSession(ctx) {
   if (process.env.EMINIAR_SESSION_ID) return process.env.EMINIAR_SESSION_ID;
   const f = file2(ctx);
   let mtimeMs;
   try {
-    mtimeMs = statSync5(f).mtimeMs;
+    mtimeMs = statSync6(f).mtimeMs;
   } catch {
     return "unknown";
   }
   if (cached4 && cached4.file === f && cached4.mtimeMs === mtimeMs) return cached4.id;
-  const id = readFileSync14(f, "utf8").trim() || "unknown";
+  const id = readFileSync15(f, "utf8").trim() || "unknown";
   cached4 = { file: f, mtimeMs, id };
   return id;
 }
@@ -34383,13 +35527,13 @@ __export(store_exports, {
 import {
   existsSync as existsSync17,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   renameSync,
-  statSync as statSync6,
+  statSync as statSync7,
   unlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { dirname as dirname7, join as join21, relative as relative5, sep } from "path";
+import { dirname as dirname8, join as join22, relative as relative6, sep } from "path";
 function isStatus(s) {
   return typeof s === "string" && MEMORY_STATUSES.includes(s);
 }
@@ -34403,16 +35547,16 @@ function memoriesRel(ctx) {
   return ctx.config.memories.dir.replace(/^\.\//, "").replace(/\/+$/, "");
 }
 function memoriesDir(ctx) {
-  return join21(ctx.root, memoriesRel(ctx));
+  return join22(ctx.root, memoriesRel(ctx));
 }
 function relOf(ctx, name) {
   return `${memoriesRel(ctx)}/${name}.md`;
 }
 function absOf(ctx, name) {
-  return join21(ctx.root, relOf(ctx, name));
+  return join22(ctx.root, relOf(ctx, name));
 }
 function nameOfFile(ctx, abs) {
-  const rel = relative5(memoriesDir(ctx), abs).split(sep).join("/");
+  const rel = relative6(memoriesDir(ctx), abs).split(sep).join("/");
   if (!rel.endsWith(".md")) return void 0;
   const name = rel.slice(0, -3);
   return isValidName(name) ? name : void 0;
@@ -34451,7 +35595,7 @@ function normalizeRelated(ids) {
 }
 function writeMemoryFile(ctx, name, meta4, body) {
   const abs = absOf(ctx, name);
-  mkdirSync7(dirname7(abs), { recursive: true });
+  mkdirSync7(dirname8(abs), { recursive: true });
   writeFileSync7(abs, serializeMemoryFile(meta4, `
 ${body.trim()}
 `));
@@ -34496,12 +35640,12 @@ function syncFile(ctx, db, name, opts = {}) {
   const abs = absOf(ctx, name);
   const rel = relOf(ctx, name);
   if (!existsSync17(abs)) return void 0;
-  let st = statSync6(abs);
+  let st = statSync7(abs);
   const row = db.memoryGetByName(name);
   const mtime = Math.floor(st.mtimeMs);
   if (!opts.force && row && row.file_mtime === mtime && row.file_size === st.size)
     return { changed: false, row };
-  let text3 = readFileSync15(abs, "utf8");
+  let text3 = readFileSync16(abs, "utf8");
   let hash2 = hashText(text3);
   if (!opts.force && row && row.file_hash === hash2) {
     db.memoryUpsertByName({
@@ -34540,7 +35684,7 @@ function syncFile(ctx, db, name, opts = {}) {
 ${parsed.body.replace(/^\s*\n/, "")}`
     );
     writeFileSync7(abs, text3);
-    st = statSync6(abs);
+    st = statSync7(abs);
     hash2 = hashText(text3);
   }
   const body = parsed.body.trim();
@@ -34578,7 +35722,7 @@ tags: ${tags.join(", ")}` : ""}`,
 function setMeta(ctx, db, name, patch) {
   const abs = absOf(ctx, name);
   if (!existsSync17(abs)) return false;
-  const parsed = parseMemoryFile(readFileSync15(abs, "utf8"));
+  const parsed = parseMemoryFile(readFileSync16(abs, "utf8"));
   const meta4 = { ...parsed.meta };
   for (const [k, v] of Object.entries(patch)) {
     if (v === void 0) delete meta4[k];
@@ -34627,7 +35771,7 @@ function reconcile(ctx, db) {
   for (const f of files) {
     const name = nameOfFile(ctx, f);
     if (!name) {
-      out.skipped.push(relative5(ctx.root, f));
+      out.skipped.push(relative6(ctx.root, f));
       continue;
     }
     seen.add(name);
@@ -34659,7 +35803,7 @@ function write(ctx, db, input2) {
   let extra = {};
   if (exists) {
     try {
-      extra = parseMemoryFile(readFileSync15(abs, "utf8")).meta;
+      extra = parseMemoryFile(readFileSync16(abs, "utf8")).meta;
     } catch {
     }
   }
@@ -34686,7 +35830,7 @@ function write(ctx, db, input2) {
 function read(ctx, db, name) {
   const synced = syncFile(ctx, db, name);
   if (!synced) return void 0;
-  const parsed = parseMemoryFile(readFileSync15(absOf(ctx, name), "utf8"));
+  const parsed = parseMemoryFile(readFileSync16(absOf(ctx, name), "utf8"));
   return {
     name,
     kind: synced.row.kind,
@@ -34713,7 +35857,7 @@ function edit(ctx, db, name, opts) {
   const abs = absOf(ctx, name);
   if (!existsSync17(abs)) throw new Error(`memory "${name}" does not exist`);
   syncFile(ctx, db, name);
-  const parsed = parseMemoryFile(readFileSync15(abs, "utf8"));
+  const parsed = parseMemoryFile(readFileSync16(abs, "utf8"));
   const re = new RegExp(opts.regex ? opts.find : escapeRe(opts.find), "g");
   const count = (parsed.body.match(re) ?? []).length;
   if (!count) return 0;
@@ -34731,9 +35875,9 @@ function rename(ctx, db, from, to) {
   const absTo = absOf(ctx, to);
   if (!existsSync17(absFrom)) throw new Error(`memory "${from}" does not exist`);
   if (existsSync17(absTo) || db.memoryGetByName(to)) throw new Error(`memory "${to}" already exists`);
-  mkdirSync7(dirname7(absTo), { recursive: true });
+  mkdirSync7(dirname8(absTo), { recursive: true });
   renameSync(absFrom, absTo);
-  const parsed = parseMemoryFile(readFileSync15(absTo, "utf8"));
+  const parsed = parseMemoryFile(readFileSync16(absTo, "utf8"));
   writeFileSync7(
     absTo,
     serializeMemoryFile(
@@ -34749,7 +35893,7 @@ function rename(ctx, db, from, to) {
     if (!row.name || row.name === to) continue;
     const abs = absOf(ctx, row.name);
     if (!existsSync17(abs)) continue;
-    const text3 = readFileSync15(abs, "utf8");
+    const text3 = readFileSync16(abs, "utf8");
     if (!ref.test(text3)) continue;
     ref.lastIndex = 0;
     writeFileSync7(abs, text3.replace(ref, `mem:${to}`));
@@ -34768,11 +35912,11 @@ function remove(ctx, db, name) {
 function gitignoreHint(ctx) {
   if (hinted.has(ctx.root)) return void 0;
   hinted.add(ctx.root);
-  const file3 = join21(ctx.root, ".gitignore");
+  const file3 = join22(ctx.root, ".gitignore");
   if (!existsSync17(file3)) return void 0;
   const dir = memoriesRel(ctx);
   const top = dir.split("/")[0];
-  const ignored = readFileSync15(file3, "utf8").split(/\r?\n/).map((l) => l.trim().replace(/^\//, "").replace(/\/$/, "")).some((l) => l === top || l === dir || l === `${top}/**` || l === `${dir}/**`);
+  const ignored = readFileSync16(file3, "utf8").split(/\r?\n/).map((l) => l.trim().replace(/^\//, "").replace(/\/$/, "")).some((l) => l === top || l === dir || l === `${top}/**` || l === `${dir}/**`);
   return ignored ? `note: .gitignore ignores ${dir}, so memories stay local to this machine (remove that line to share them with the team)` : void 0;
 }
 var import_fast_glob3, MEMORY_KINDS, SEGMENT, NAME_RE, hinted;
@@ -34846,7 +35990,7 @@ var init_em_graph = __esm({
     });
     emGraphQuery = defineTool({
       name: "em_graph_query",
-      description: 'Look up nodes in the project knowledge graph (files, functions, classes, routes, packages, people, concepts, memories) by name/path, run a preset (hotspots, coupled, orphans, dead_code, routes, cycles, clusters, stats), or run a structured pattern: start at nodes matching `from`, walk `edge.kinds` in `edge.direction` for `edge.depth` hops, keep what matches `to` \u2014 e.g. {from:{kind:"route"}, edge:{kinds:["handles"], direction:"in"}} lists every route handler, {from:{name:"^parseFile$"}, edge:{kinds:["calls"], direction:"in", depth:2}} its callers two levels up. Built from tree-sitter (TS/JS, Python, Go), git history, memories and em_graph_add.',
+      description: 'Look up nodes in the project knowledge graph (files, functions, classes, routes, packages, people, concepts, memories) by name/path, run a preset (hotspots, coupled, orphans, dead_code, routes, cycles, clusters, stats), or run a structured pattern: start at nodes matching `from`, walk `edge.kinds` in `edge.direction` for `edge.depth` hops, keep what matches `to` \u2014 e.g. {from:{kind:"route"}, edge:{kinds:["handles"], direction:"in"}} lists every route handler, {from:{name:"^parseFile$"}, edge:{kinds:["calls"], direction:"in", depth:2}} its callers two levels up. Built from tree-sitter (TS/JS, Python, Go, PHP), git history, memories and em_graph_add.',
       schema: {
         query: external_exports.string().optional().describe("Substring of a name, path or id"),
         kind: external_exports.string().optional().describe(
@@ -35400,12 +36544,12 @@ var init_em_graph_changes = __esm({
 });
 
 // src/graph/architecture.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync17 } from "fs";
+import { join as join23 } from "path";
 function pkgJson(root) {
   try {
-    const f = join22(root, "package.json");
-    return existsSync18(f) ? JSON.parse(readFileSync16(f, "utf8")) : {};
+    const f = join23(root, "package.json");
+    return existsSync18(f) ? JSON.parse(readFileSync17(f, "utf8")) : {};
   } catch {
     return {};
   }
@@ -36757,8 +37901,8 @@ var init_catalog = __esm({
 });
 
 // src/docs/manifest.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname8, join as join23 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname9, join as join24 } from "path";
 function docsTag(name) {
   return `${DOCS_PREFIX}${name}`;
 }
@@ -36770,7 +37914,7 @@ function slugify3(input2) {
   return (s || "source").slice(0, 64);
 }
 function manifestPathAt(root, rel = ".eminiar/docs.json") {
-  return join23(root, rel);
+  return join24(root, rel);
 }
 function manifestPath(ctx) {
   return manifestPathAt(ctx.root, ctx.config.docs.manifest);
@@ -36778,7 +37922,7 @@ function manifestPath(ctx) {
 function empty() {
   return { version: 1, sources: [] };
 }
-function normalize4(raw) {
+function normalize5(raw) {
   if (!raw || typeof raw !== "object") return empty();
   const sources = Array.isArray(raw.sources) ? raw.sources : [];
   const out = [];
@@ -36800,7 +37944,7 @@ function normalize4(raw) {
 function readManifestAt(file3) {
   if (!existsSync19(file3)) return empty();
   try {
-    return normalize4(JSON.parse(readFileSync17(file3, "utf8")));
+    return normalize5(JSON.parse(readFileSync18(file3, "utf8")));
   } catch {
     return empty();
   }
@@ -36810,7 +37954,7 @@ function readManifest(ctx) {
 }
 function writeManifest(ctx, m) {
   const file3 = manifestPath(ctx);
-  mkdirSync8(dirname8(file3), { recursive: true });
+  mkdirSync8(dirname9(file3), { recursive: true });
   const sorted = {
     version: 1,
     sources: [...m.sources].sort((a, b) => a.name.localeCompare(b.name))
@@ -36911,11 +38055,11 @@ var init_manifest = __esm({
 });
 
 // src/docs/discover.ts
-import { existsSync as existsSync20, readFileSync as readFileSync18, statSync as statSync7 } from "fs";
-import { basename, join as join24, relative as relative6 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync19, statSync as statSync8 } from "fs";
+import { basename, join as join25, relative as relative7 } from "path";
 function readText(file3) {
   try {
-    return readFileSync18(file3, "utf8");
+    return readFileSync19(file3, "utf8");
   } catch {
     return void 0;
   }
@@ -36933,14 +38077,14 @@ function sizeOf(files) {
   let n = 0;
   for (const f of files) {
     try {
-      n += statSync7(f).size;
+      n += statSync8(f).size;
     } catch {
     }
   }
   return n;
 }
 function hiddenPath(cwd, file3) {
-  const parts = relative6(cwd, file3).split("/");
+  const parts = relative7(cwd, file3).split("/");
   return parts.slice(0, -1).some((p, i) => {
     if (!p.startsWith(".")) return false;
     if (p === ".claude") return !["agents", "skills", "commands"].includes(parts[i + 1] ?? "");
@@ -36969,8 +38113,8 @@ function findProjects(root, opts) {
   const found = /* @__PURE__ */ new Set();
   for (const m of markers) {
     for (const f of glob(root, [`*/${m}`, `*/*/${m}`], 3)) {
-      const dir = join24(f, "..");
-      const rel = relative6(root, dir);
+      const dir = join25(f, "..");
+      const rel = relative7(root, dir);
       if (!rel || rel.split("/").some((p) => p.startsWith(".") || p === "node_modules")) continue;
       found.add(dir);
     }
@@ -36978,7 +38122,7 @@ function findProjects(root, opts) {
   const max = opts.maxProjects ?? 40;
   const seenNames = /* @__PURE__ */ new Set();
   const nameOf = (dir) => {
-    const pkg = readJson3(join24(dir, "package.json"));
+    const pkg = readJson3(join25(dir, "package.json"));
     return typeof pkg?.name === "string" ? pkg.name : void 0;
   };
   const rootName = nameOf(root);
@@ -36996,7 +38140,7 @@ function findProjects(root, opts) {
   return out;
 }
 function npmSignals(dir, includeDev, project) {
-  const pkg = readJson3(join24(dir, "package.json"));
+  const pkg = readJson3(join25(dir, "package.json"));
   if (!pkg) return [];
   const sections = ["dependencies", ...includeDev ? ["devDependencies"] : []];
   const out = [];
@@ -37013,13 +38157,13 @@ function npmSignals(dir, includeDev, project) {
 }
 function pythonSignals(dir, project) {
   const out = [];
-  const py = readText(join24(dir, "pyproject.toml"));
+  const py = readText(join25(dir, "pyproject.toml"));
   if (py) {
     const block = /dependencies\s*=\s*\[([\s\S]*?)\]/.exec(py)?.[1] ?? "";
     for (const m of block.matchAll(/["']([A-Za-z0-9_.-]+)/g))
       out.push({ kind: "pypi", key: m[1].toLowerCase(), project });
   }
-  const req = readText(join24(dir, "requirements.txt"));
+  const req = readText(join25(dir, "requirements.txt"));
   if (req) {
     for (const line of req.split("\n")) {
       const name = /^\s*([A-Za-z0-9_.-]+)/.exec(line)?.[1];
@@ -37030,7 +38174,7 @@ function pythonSignals(dir, project) {
   return out;
 }
 function goSignals(dir, project) {
-  const mod = readText(join24(dir, "go.mod"));
+  const mod = readText(join25(dir, "go.mod"));
   if (!mod) return [];
   const out = [];
   const block = /require\s*\(([\s\S]*?)\)/g;
@@ -37096,18 +38240,18 @@ function isDocLink(host, path3) {
 function apiSignals(dir, project) {
   const hits = /* @__PURE__ */ new Map();
   const docLinks = /* @__PURE__ */ new Map();
-  const files = glob(dir, CODE_GLOBS, 8).filter((f) => !/\.min\.(js|mjs|cjs)$/.test(f)).filter((f) => !TEST_PATH_RE.test(relative6(dir, f))).slice(0, 4e3);
+  const files = glob(dir, CODE_GLOBS, 8).filter((f) => !/\.min\.(js|mjs|cjs)$/.test(f)).filter((f) => !TEST_PATH_RE.test(relative7(dir, f))).slice(0, 4e3);
   for (const file3 of files) {
     let size = 0;
     try {
-      size = statSync7(file3).size;
+      size = statSync8(file3).size;
     } catch {
       continue;
     }
     if (size > 400 * 1024) continue;
     const text3 = readText(file3);
     if (!text3 || text3.includes("\0")) continue;
-    const rel = relative6(dir, file3).split("\\").join("/");
+    const rel = relative7(dir, file3).split("\\").join("/");
     const isEnv = basename(file3).startsWith(".env");
     const lines = text3.split("\n");
     const found = [];
@@ -37197,7 +38341,7 @@ function fileSignals(dir, project) {
 function localCandidates(root, dir, project, isRegistered) {
   const out = [];
   const prefix = project ? `${slugify3(basename(dir))}-` : "";
-  const rel = (abs) => relative6(root, abs).split("\\").join("/");
+  const rel = (abs) => relative7(root, abs).split("\\").join("/");
   const push = (c) => {
     if (!c.files) return;
     out.push({ ...c, project, registered: isRegistered(c) });
@@ -37227,7 +38371,7 @@ function localCandidates(root, dir, project, isRegistered) {
       why: "project readme and top-level guides"
     });
   for (const d of ["docs", "doc", "documentation"]) {
-    const abs = join24(dir, d);
+    const abs = join25(dir, d);
     if (!existsSync20(abs)) continue;
     const files = glob(abs, ["**/*.md", "**/*.mdx", "**/*.rst", "**/*.txt"]).filter(
       (f) => !SKIP_EXT.has(f.slice(f.lastIndexOf(".")))
@@ -37251,7 +38395,7 @@ function localCandidates(root, dir, project, isRegistered) {
     "docs/decisions",
     "decisions"
   ]) {
-    const abs = join24(dir, d);
+    const abs = join25(dir, d);
     if (!existsSync20(abs)) continue;
     if (out.some((c) => c.path && rel(abs).startsWith(`${c.path}/`))) break;
     const files = glob(abs, ["**/*.md"]);
@@ -37311,7 +38455,7 @@ function localCandidates(root, dir, project, isRegistered) {
     push({
       name: `${prefix}api-specs`,
       path: rel(dir) || ".",
-      glob: api.map((f) => relative6(dir, f).split("\\").join("/")),
+      glob: api.map((f) => relative7(dir, f).split("\\").join("/")),
       files: api.length,
       bytes: sizeOf(api),
       why: "OpenAPI / Postman / GraphQL / protobuf specs"
@@ -37385,7 +38529,7 @@ function discoverDocs(ctx, opts = {}) {
   const apiHits = /* @__PURE__ */ new Map();
   const docLinks = /* @__PURE__ */ new Map();
   for (const dir of projects) {
-    const project = dir === root ? "" : relative6(root, dir).split("\\").join("/");
+    const project = dir === root ? "" : relative7(root, dir).split("\\").join("/");
     const own2 = dir === root && projects.length > 1 ? void 0 : dir;
     local.push(...localCandidates(root, dir, project, isRegistered));
     signals.push(...npmSignals(dir, includeDev, project));
@@ -37395,7 +38539,7 @@ function discoverDocs(ctx, opts = {}) {
     signals.push(...fileSignals(dir, project));
     const api = apiSignals(own2 ?? dir, project);
     const inSubproject = (samples) => own2 === void 0 && projects.some(
-      (p) => p !== root && samples.some((s) => s.startsWith(`${relative6(root, p)}/`))
+      (p) => p !== root && samples.some((s) => s.startsWith(`${relative7(root, p)}/`))
     );
     for (const hit of api.hits.values()) {
       if (inSubproject(hit.samples)) continue;
@@ -37585,7 +38729,7 @@ function discoverDocs(ctx, opts = {}) {
   );
   return {
     root,
-    projects: projects.map((p) => p === root ? "." : relative6(root, p)),
+    projects: projects.map((p) => p === root ? "." : relative7(root, p)),
     local,
     providers
   };
@@ -39859,14 +41003,14 @@ var init_em_search = __esm({
 });
 
 // src/ui/api.ts
-import { existsSync as existsSync21, readdirSync as readdirSync7 } from "fs";
-import { join as join25, relative as relative7 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync8 } from "fs";
+import { join as join26, relative as relative8 } from "path";
 function listProjects() {
   const dir = paths().projects;
   const out = [];
-  for (const id of readdirSync7(dir, { withFileTypes: true })) {
+  for (const id of readdirSync8(dir, { withFileTypes: true })) {
     if (!id.isDirectory()) continue;
-    const db = join25(dir, id.name, "eminiar.db");
+    const db = join26(dir, id.name, "eminiar.db");
     try {
       const a = new SqliteAdapter(db, { vectors: false });
       out.push({ id: id.name, root: a.sessionLatest()?.project_root ?? null });
@@ -39892,8 +41036,8 @@ function statsPayload(ctx) {
   const db = getStorage(ctx);
   const sessionId = getCurrentSession(ctx);
   const g = globalDb();
-  const onboardingDir = join25(memoriesDir(ctx), "onboarding");
-  const onboarding = existsSync21(onboardingDir) ? readdirSync7(onboardingDir).filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3)) : [];
+  const onboardingDir = join26(memoriesDir(ctx), "onboarding");
+  const onboarding = existsSync21(onboardingDir) ? readdirSync8(onboardingDir).filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3)) : [];
   return {
     project: ctx.root,
     projectId: ctx.id,
@@ -40085,7 +41229,7 @@ function docsPayload(ctx) {
   const known = new Set(m.sources.map((s) => docsTag(s.name)));
   const orphans2 = [...stats.values()].filter((s) => !known.has(s.source)).map((s) => ({ source: s.source, documents: s.documents, chunks: s.chunks }));
   return {
-    manifest: relative7(ctx.root, manifestPath(ctx)),
+    manifest: relative8(ctx.root, manifestPath(ctx)),
     sources,
     orphans: orphans2,
     totals: {
@@ -40146,32 +41290,58 @@ function graphMap(ctx, opts = {}) {
   let files = db.graphFileNodes();
   if (opts.pathFilter)
     files = files.filter((f) => (f.path ?? f.name).includes(opts.pathFilter));
-  const ids = files.map((f) => f.id);
-  const idSet = new Set(ids);
-  const kinds = opts.coChanges === false ? ["imports"] : ["imports", "co_changes"];
-  const raw = db.graphEdgesFrom(ids, kinds).filter((e) => idSet.has(e.dst));
+  const fileSet = new Set(files.map((f) => f.id));
+  const kinds = opts.kinds ?? (opts.coChanges === false ? ["imports"] : ["imports", "co_changes"]);
+  const lift = (id) => {
+    const kind = parseId(id).kind;
+    if (kind === "file" || kind === "sym") {
+      const rel = fileOf(id);
+      const f = rel === void 0 ? void 0 : fileId(rel);
+      return f && fileSet.has(f) ? f : void 0;
+    }
+    return kind === "pkg" ? void 0 : id;
+  };
+  const merged = /* @__PURE__ */ new Map();
+  for (const kind of kinds) {
+    for (const e of db.graphEdgesByKind(kind, MAP_EDGES_PER_KIND)) {
+      if (kind === "co_changes" && e.weight < 0.3) continue;
+      const src = lift(e.src);
+      const dst = lift(e.dst);
+      if (!src || !dst || src === dst) continue;
+      if (!fileSet.has(src) && !fileSet.has(dst)) continue;
+      const key = kind === "co_changes" ? `${[src, dst].sort().join("|")}|co` : `${src}|${dst}|${kind}`;
+      const prev = merged.get(key);
+      if (prev)
+        prev.weight = kind === "co_changes" ? Math.max(prev.weight, e.weight) : prev.weight + 1;
+      else merged.set(key, { src, dst, kind, weight: kind === "co_changes" ? e.weight : 1 });
+    }
+  }
   const degree = /* @__PURE__ */ new Map();
-  for (const e of raw) {
+  for (const e of merged.values()) {
     degree.set(e.src, (degree.get(e.src) ?? 0) + 1);
     degree.set(e.dst, (degree.get(e.dst) ?? 0) + 1);
   }
   const keep = new Set(
     [...files].sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0)).slice(0, limit).map((f) => f.id)
   );
-  const seenEdge = /* @__PURE__ */ new Set();
   const edges = [];
-  for (const e of raw) {
-    if (!keep.has(e.src) || !keep.has(e.dst)) continue;
-    if (e.kind === "co_changes" && e.weight < 0.3) continue;
-    const key = e.kind === "co_changes" ? `${[e.src, e.dst].sort().join("|")}|co` : `${e.src}|${e.dst}|${e.kind}`;
-    if (seenEdge.has(key)) continue;
-    seenEdge.add(key);
-    edges.push({ src: e.src, dst: e.dst, kind: e.kind, weight: e.weight });
-  }
+  const extra = /* @__PURE__ */ new Set();
+  for (const e of merged.values()) {
+    const srcOk = keep.has(e.src) || !fileSet.has(e.src) && keep.has(e.dst);
+    const dstOk = keep.has(e.dst) || !fileSet.has(e.dst) && keep.has(e.src);
+    if (!srcOk || !dstOk) continue;
+    if (!keep.has(e.src)) extra.add(e.src);
+    if (!keep.has(e.dst)) extra.add(e.dst);
+    edges.push(e);
+  }
+  const extraRows = new Map(db.graphGetNodes([...extra]).map((n) => [n.id, n]));
   return {
     mode: "map",
     total: files.length,
-    nodes: files.filter((f) => keep.has(f.id)).map((f) => visNode(f, f.id)),
+    nodes: [
+      ...files.filter((f) => keep.has(f.id)).map((f) => visNode(f, f.id)),
+      ...[...extra].map((id) => visNode(extraRows.get(id), id))
+    ],
     edges
   };
 }
@@ -40333,7 +41503,7 @@ async function runAction(ctx, input2) {
       return done(false, `unknown action ${String(input2.action)}`);
   }
 }
-var memoryKinds;
+var memoryKinds, MAP_EDGES_PER_KIND;
 var init_api2 = __esm({
   "src/ui/api.ts"() {
     "use strict";
@@ -40348,6 +41518,7 @@ var init_api2 = __esm({
     init_sync();
     init_queue();
     init_format2();
+    init_ids();
     init_query2();
     init_doctor2();
     init_store();
@@ -40362,6 +41533,7 @@ var init_api2 = __esm({
     init_em_purge();
     init_em_search();
     memoryKinds = [...MEMORY_KINDS];
+    MAP_EDGES_PER_KIND = 5e4;
   }
 });
 
@@ -40403,8 +41575,8 @@ var init_namepath = __esm({
 });
 
 // src/code/symbols.ts
-import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
+import { join as join27 } from "path";
 function isExported2(n) {
   if (!n.meta) return false;
   try {
@@ -40440,8 +41612,8 @@ var init_symbols2 = __esm({
 });
 
 // src/ui/graph-api.ts
-import { readFileSync as readFileSync20, realpathSync as realpathSync2, statSync as statSync8 } from "fs";
-import { relative as relative8, resolve as resolve6 } from "path";
+import { readFileSync as readFileSync21, realpathSync as realpathSync2, statSync as statSync9 } from "fs";
+import { relative as relative9, resolve as resolve7 } from "path";
 function metaOf2(row) {
   if (!row?.meta) return {};
   try {
@@ -40502,17 +41674,17 @@ function treePayload(ctx) {
 }
 function filePayload(ctx, rel) {
   const clean = rel.replace(/^\.\//, "");
-  const abs = resolve6(ctx.root, clean);
-  if (relative8(ctx.root, abs).startsWith("..")) throw new Error("path outside the project");
+  const abs = resolve7(ctx.root, clean);
+  if (relative9(ctx.root, abs).startsWith("..")) throw new Error("path outside the project");
   let real = abs;
   try {
     real = realpathSync2(abs);
   } catch {
     return { error: "not found", path: clean };
   }
-  if (relative8(realpathSync2(ctx.root), real).startsWith(".."))
+  if (relative9(realpathSync2(ctx.root), real).startsWith(".."))
     throw new Error("path outside the project");
-  const st = statSync8(real);
+  const st = statSync9(real);
   if (!st.isFile()) return { error: "not a file", path: clean };
   const db = getStorage(ctx);
   const row = db.fileIndexGet(clean);
@@ -40526,7 +41698,7 @@ function filePayload(ctx, rel) {
   }));
   if (st.size > MAX_CODE_BYTES)
     return { path: clean, tooLarge: true, size: st.size, status: row?.status ?? null, symbols };
-  const content = readFileSync20(real, "utf8");
+  const content = readFileSync21(real, "utf8");
   return {
     path: clean,
     size: st.size,
@@ -41248,14 +42420,14 @@ function buildHistory(ctx, db, opts = {}) {
     };
   });
   const bySha = new Map(commits.map((c) => [c.sha, c]));
-  const resolve7 = (prefix) => {
+  const resolve8 = (prefix) => {
     if (bySha.has(prefix)) return bySha.get(prefix);
     for (const c of commits) if (c.sha.startsWith(prefix)) return c;
     return void 0;
   };
   for (const c of commits) {
     if (c.kind !== "revert" || !c.revertOf) continue;
-    const target = resolve7(c.revertOf);
+    const target = resolve8(c.revertOf);
     if (target) {
       target.revertedBy = c.sha;
       c.origins.push(target.sha);
@@ -42104,9 +43276,9 @@ __export(server_exports, {
   uiDir: () => uiDir
 });
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync21, statSync as statSync9 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync22, statSync as statSync10 } from "fs";
 import { createServer } from "http";
-import { extname as extname3, join as join27, normalize as normalize5 } from "path";
+import { extname as extname3, join as join28, normalize as normalize6 } from "path";
 import { URL as URL2 } from "url";
 function json2(res, status, body) {
   res.writeHead(status, {
@@ -42128,7 +43300,7 @@ function strList(v) {
   return void 0;
 }
 function uiDir() {
-  return process.env.EMINIAR_UI_DIR || join27(pluginRoot(), "dist", "ui");
+  return process.env.EMINIAR_UI_DIR || join28(pluginRoot(), "dist", "ui");
 }
 function originAllowed(req, port) {
   const host = req.headers.host ?? "";
@@ -42152,25 +43324,25 @@ function originAllowed(req, port) {
 function serveStatic(res, p) {
   const dir = uiDir();
   const rel = p === "/" ? "index.html" : p.replace(/^\/+/, "");
-  const file3 = normalize5(join27(dir, rel));
-  if (!file3.startsWith(normalize5(dir))) return false;
-  if (!existsSync23(file3) || !statSync9(file3).isFile()) return false;
+  const file3 = normalize6(join28(dir, rel));
+  if (!file3.startsWith(normalize6(dir))) return false;
+  if (!existsSync23(file3) || !statSync10(file3).isFile()) return false;
   const type = MIME[extname3(file3).toLowerCase()] ?? "application/octet-stream";
   if (rel === "index.html") {
     const stamp = (name) => {
       try {
-        return `/${name}?v=${Math.floor(statSync9(join27(dir, name)).mtimeMs)}`;
+        return `/${name}?v=${Math.floor(statSync10(join28(dir, name)).mtimeMs)}`;
       } catch {
         return `/${name}`;
       }
     };
-    const html = readFileSync21(file3, "utf8").replace('"/app.global.js"', `"${stamp("app.global.js")}"`).replace('"/styles.css"', `"${stamp("styles.css")}"`);
+    const html = readFileSync22(file3, "utf8").replace('"/app.global.js"', `"${stamp("app.global.js")}"`).replace('"/styles.css"', `"${stamp("styles.css")}"`);
     res.writeHead(200, { "content-type": type, "cache-control": "no-store" });
     res.end(html);
     return true;
   }
   res.writeHead(200, { "content-type": type, "cache-control": "no-cache" });
-  res.end(readFileSync21(file3));
+  res.end(readFileSync22(file3));
   return true;
 }
 async function serve(opts) {
@@ -42332,6 +43504,7 @@ async function serve(opts) {
             200,
             graphMap(ctx(), {
               limit: num2("limit", 150),
+              kinds: q.has("kinds") ? strList(q.get("kinds")) : void 0,
               coChanges: q.get("cochanges") !== "0",
               pathFilter: str2("path")
             })
@@ -42511,9 +43684,9 @@ async function serve(opts) {
       json2(res, 500, { error: err.message });
     }
   });
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve8, reject) => {
     server.once("error", reject);
-    server.listen(opts.port, "127.0.0.1", resolve7);
+    server.listen(opts.port, "127.0.0.1", resolve8);
   });
   const url2 = `http://127.0.0.1:${opts.port}/`;
   console.log(`eminiar dashboard at ${url2} (Ctrl-C to stop)`);
@@ -42554,7 +43727,7 @@ var statusline_exports = {};
 __export(statusline_exports, {
   renderStatusline: () => renderStatusline
 });
-import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync9 } from "fs";
 function renderStatusline(raw) {
   let input2 = {};
   try {
@@ -42564,7 +43737,7 @@ function renderStatusline(raw) {
   const cache3 = paths().statuslineCache;
   try {
     if (existsSync24(cache3)) {
-      const c = JSON.parse(readFileSync22(cache3, "utf8"));
+      const c = JSON.parse(readFileSync23(cache3, "utf8"));
       if (Date.now() - c.at < 5e3 && c.key === (input2.session_id ?? "")) return c.line;
     }
   } catch {