eminiar 0.5.1 → 0.6.0

package/dist/server.js

@@ -2266,8 +2266,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize6) {
-      if (normalize6 !== false)
+    function getFullPath(resolver, id = "", normalize7) {
+      if (normalize7 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -3019,7 +3019,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve7.call(this, root, ref);
+      let _sch = resolve8.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -3046,7 +3046,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve7(root, ref) {
+    function resolve8(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3869,7 +3869,7 @@ var require_fast_uri = __commonJS({
       }
       return decodedScheme;
     }
-    function normalize6(uri, options) {
+    function normalize7(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         normalizeString(uri, options);
@@ -3879,7 +3879,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve7(baseURI, relativeURI, options) {
+    function resolve8(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -3912,49 +3912,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative8, options, skipNormalization) {
+    function resolveComponent(base, relative9, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative8 = parse3(serialize(relative8, options), options);
+        relative9 = parse3(serialize(relative9, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative8.scheme) {
-        target.scheme = relative8.scheme;
-        target.userinfo = relative8.userinfo;
-        target.host = relative8.host;
-        target.port = relative8.port;
-        target.path = removeDotSegments(relative8.path || "");
-        target.query = relative8.query;
+      if (!options.tolerant && relative9.scheme) {
+        target.scheme = relative9.scheme;
+        target.userinfo = relative9.userinfo;
+        target.host = relative9.host;
+        target.port = relative9.port;
+        target.path = removeDotSegments(relative9.path || "");
+        target.query = relative9.query;
       } else {
-        if (relative8.userinfo !== void 0 || relative8.host !== void 0 || relative8.port !== void 0) {
-          target.userinfo = relative8.userinfo;
-          target.host = relative8.host;
-          target.port = relative8.port;
-          target.path = removeDotSegments(relative8.path || "");
-          target.query = relative8.query;
+        if (relative9.userinfo !== void 0 || relative9.host !== void 0 || relative9.port !== void 0) {
+          target.userinfo = relative9.userinfo;
+          target.host = relative9.host;
+          target.port = relative9.port;
+          target.path = removeDotSegments(relative9.path || "");
+          target.query = relative9.query;
         } else {
-          if (!relative8.path) {
+          if (!relative9.path) {
             target.path = base.path;
-            if (relative8.query !== void 0) {
-              target.query = relative8.query;
+            if (relative9.query !== void 0) {
+              target.query = relative9.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative8.path[0] === "/") {
-              target.path = removeDotSegments(relative8.path);
+            if (relative9.path[0] === "/") {
+              target.path = removeDotSegments(relative9.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative8.path;
+                target.path = "/" + relative9.path;
               } else if (!base.path) {
-                target.path = relative8.path;
+                target.path = relative9.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative8.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative9.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative8.query;
+            target.query = relative9.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3962,7 +3962,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative8.fragment;
+      target.fragment = relative9.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -4247,8 +4247,8 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize: normalize6,
-      resolve: resolve7,
+      normalize: normalize7,
+      resolve: resolve8,
       resolveComponent,
       equal,
       serialize,
@@ -10972,15 +10972,15 @@ var require_pattern2 = __commonJS({
     exports.removeDuplicateSlashes = removeDuplicateSlashes;
     function partitionAbsoluteAndRelative(patterns) {
       const absolute = [];
-      const relative8 = [];
+      const relative9 = [];
       for (const pattern2 of patterns) {
         if (isAbsolute2(pattern2)) {
           absolute.push(pattern2);
         } else {
-          relative8.push(pattern2);
+          relative9.push(pattern2);
         }
       }
-      return [absolute, relative8];
+      return [absolute, relative9];
     }
     exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
     function isAbsolute2(pattern2) {
@@ -11411,11 +11411,11 @@ var require_out = __commonJS({
       async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat;
-    function statSync9(path3, optionsOrSettings) {
+    function statSync10(path3, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path3, settings);
     }
-    exports.statSync = statSync9;
+    exports.statSync = statSync10;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -12096,41 +12096,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;
               };
             }
@@ -12627,9 +12627,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);
           });
         });
       }
@@ -12654,10 +12654,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);
             }
@@ -12667,10 +12667,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));
         });
       }
     };
@@ -13845,6 +13845,40 @@ function parseRestShorthand(rest, actionName) {
   }
   return [{ method: "ALL", path: joinRoutePath(rest) }];
 }
+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];
@@ -13889,7 +13923,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";
@@ -13913,6 +13947,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",
@@ -13943,7 +13987,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)$/;
@@ -13999,6 +14054,8 @@ function grammarFor(path3) {
       return "python";
     case ".go":
       return "go";
+    case ".php":
+      return "php";
     default:
       return void 0;
   }
@@ -14503,28 +14560,1095 @@ var init_go = __esm({
   }
 });
 
-// src/graph/languages/python.ts
-import { existsSync as existsSync5, statSync } from "fs";
+// src/graph/languages/php.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "fs";
 import { dirname as dirname4, join as join7, normalize as normalize2, relative as relative2, resolve as resolve3 } from "path";
+function readComposer(dir) {
+  const file3 = join7(dir, "composer.json");
+  if (!isFile(file3)) return null;
+  try {
+    const json2 = JSON.parse(readFileSync4(file3, "utf8"));
+    const info = { dir, psr4: [], psr0: [], classmap: [], files: [], require: [] };
+    for (const key of ["autoload", "autoload-dev"]) {
+      const section = json2[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(json2.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 = dirname4(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 = dirname4(dir);
+  }
+  return void 0;
+}
+function phpFilesUnder(abs, budget) {
+  if (isFile(abs)) return abs.endsWith(".php") ? [abs] : [];
+  let entries;
+  try {
+    entries = readdirSync2(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(join7(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(join7(auto.dir, entry), budget)) {
+      if (relative2(root, f).startsWith("..")) continue;
+      let code;
+      try {
+        code = readFileSync4(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 = join7(auto.dir, entry);
+    if (!isFile(f) || relative2(root, f).startsWith("..")) continue;
+    let code;
+    try {
+      code = readFileSync4(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, resolve3(root, fromRel));
+  if (auto?.psr4.length || auto?.psr0.length) {
+    for (const { prefix, dirs } of auto.psr4) {
+      if (!name.startsWith(prefix)) continue;
+      const rest = name.slice(prefix.length).split("\\");
+      for (const d of dirs) candidates2.push(join7(auto.dir, d, ...rest));
+    }
+    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(join7(auto.dir, d, ...ns, ...cls));
+    }
+  } else {
+    const parts = name.split("\\");
+    candidates2.push(resolve3(root, ...parts), resolve3(root, "src", ...parts));
+  }
+  for (const c of candidates2) {
+    const f = `${c}.php`;
+    if (isFile(f) && !relative2(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, resolve3(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 = dirname4(resolve3(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(resolve3(here, plain), resolve3(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 = dirname4(base);
+        }
+        if (base && right !== void 0) candidates2.push(join7(base, right));
+      }
+      const hit = candidates2.find((c) => isFile(c) && !relative2(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, ...rest] = name.split("\\");
+    const used = classUses.get(head);
+    if (used) return [used, ...rest].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 objectType2(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 = objectType2(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 rest;
+    if (facade && lower === "view") {
+      methods = ["GET"];
+      rest = args.slice(0, 1);
+    } else if (facade && (lower === "redirect" || lower === "permanentredirect")) {
+      methods = ["ALL"];
+      rest = args.slice(0, 1);
+    } else if (lower === "match" || lower === "map") {
+      methods = stringsOf(args[0]).map((m) => httpMethod(m)).filter((m) => !!m);
+      rest = args.slice(1);
+    } else if (lower === "any") {
+      methods = ["ALL"];
+      rest = args;
+    } else if (ROUTE_METHODS.has(lower) && lower !== "all") {
+      methods = [lower.toUpperCase()];
+      rest = args;
+    } else return;
+    const raw = phpString(rest[0]);
+    if (raw === void 0 || !methods.length) return;
+    if (member && (!handlerShaped(rest[1]) || !raw.startsWith("/") && !ROUTER_VARS.has(obj.text)))
+      return;
+    const ctx = groupContext(call);
+    const { handlers, confidence } = handlersOf(rest[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 statSync(p).isFile();
+      } catch {
+        return false;
+      }
+    };
+    toRel = (root, abs) => normalize2(relative2(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 existsSync5, statSync as statSync2 } from "fs";
+import { dirname as dirname5, join as join8, normalize as normalize3, relative as relative3, resolve as resolve4 } from "path";
 function resolvePython(root, fromRel, module, level) {
   const parts = module ? module.split(".") : [];
   const candidates2 = [];
   if (level > 0) {
-    let base = dirname4(resolve3(root, fromRel));
-    for (let i = 1; i < level; i++) base = dirname4(base);
-    candidates2.push(join7(base, ...parts));
+    let base = dirname5(resolve4(root, fromRel));
+    for (let i = 1; i < level; i++) base = dirname5(base);
+    candidates2.push(join8(base, ...parts));
   } else {
-    candidates2.push(resolve3(root, ...parts), resolve3(root, "src", ...parts));
-    let dir = dirname4(resolve3(root, fromRel));
+    candidates2.push(resolve4(root, ...parts), resolve4(root, "src", ...parts));
+    let dir = dirname5(resolve4(root, fromRel));
     while (dir.startsWith(root) && dir !== root) {
-      candidates2.push(join7(dir, ...parts));
-      dir = dirname4(dir);
+      candidates2.push(join8(dir, ...parts));
+      dir = dirname5(dir);
     }
   }
   for (const c of candidates2) {
-    for (const f of [`${c}.py`, join7(c, "__init__.py"), `${c}.pyi`]) {
-      if (isFile(f) && !relative2(root, f).startsWith(".."))
-        return normalize2(relative2(root, f)).split("\\").join("/");
+    for (const f of [`${c}.py`, join8(c, "__init__.py"), `${c}.pyi`]) {
+      if (isFile2(f) && !relative3(root, f).startsWith(".."))
+        return normalize3(relative3(root, f)).split("\\").join("/");
     }
   }
   return void 0;
@@ -14561,7 +15685,7 @@ async function parsePython(root, rel, code) {
       walkRefs(stmt);
   }
   edges.push(...refs.edges());
-  if (!existsSync5(join7(root, rel))) {
+  if (!existsSync5(join8(root, rel))) {
   }
   const errors = tree.rootNode.hasError ? tree.rootNode.descendantsOfType("ERROR").length : 0;
   fileNode.meta = {
@@ -14714,7 +15838,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,
@@ -14857,7 +15981,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";
@@ -14865,7 +15989,7 @@ var init_python = __esm({
     init_ids();
     init_routes();
     init_parser();
-    BRANCHES2 = [
+    BRANCHES3 = [
       "if_statement",
       "elif_clause",
       "for_statement",
@@ -14876,10 +16000,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 statSync(p).isFile();
+        return statSync2(p).isFile();
       } catch {
         return false;
       }
@@ -14908,21 +16032,21 @@ var init_python = __esm({
 });
 
 // src/graph/resolve.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { dirname as dirname5, join as join8, normalize as normalize3, relative as relative3, resolve as resolve4 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { dirname as dirname6, join as join9, normalize as normalize4, relative as relative4, resolve as resolve5 } from "path";
 function loadTsPaths(root) {
   const hit = tsPathsCache.get(root);
   if (hit !== void 0) return hit;
   let out = null;
   try {
-    const file3 = join8(root, "tsconfig.json");
+    const file3 = join9(root, "tsconfig.json");
     if (existsSync6(file3)) {
-      const raw = readFileSync4(file3, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
+      const raw = readFileSync5(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: resolve4(root, co.baseUrl ?? "."),
+          baseUrl: resolve5(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 };
@@ -14939,7 +16063,7 @@ function loadTsPaths(root) {
 function probe(abs) {
   const tryFile = (p) => {
     try {
-      return statSync2(p).isFile() ? p : void 0;
+      return statSync3(p).isFile() ? p : void 0;
     } catch {
       return void 0;
     }
@@ -14955,16 +16079,16 @@ function probe(abs) {
     if (tryFile(abs + ext)) return abs + ext;
   }
   for (const ext of EXTS) {
-    const idx = join8(abs, `index${ext}`);
+    const idx = join9(abs, `index${ext}`);
     if (tryFile(idx)) return idx;
   }
   return void 0;
 }
 function readPackageJson(dir) {
   try {
-    const file3 = join8(dir, "package.json");
+    const file3 = join9(dir, "package.json");
     if (!existsSync6(file3)) return void 0;
-    return JSON.parse(readFileSync4(file3, "utf8"));
+    return JSON.parse(readFileSync5(file3, "utf8"));
   } catch {
     return void 0;
   }
@@ -14980,9 +16104,9 @@ function loadWorkspaces(root) {
   if (Array.isArray(ws)) globs.push(...ws);
   else if (ws?.packages) globs.push(...ws.packages);
   try {
-    const yaml = join8(root, "pnpm-workspace.yaml");
+    const yaml = join9(root, "pnpm-workspace.yaml");
     if (existsSync6(yaml)) {
-      for (const m of readFileSync4(yaml, "utf8").matchAll(/^\s*-\s*['"]?([^'"\n#]+?)['"]?\s*$/gm))
+      for (const m of readFileSync5(yaml, "utf8").matchAll(/^\s*-\s*['"]?([^'"\n#]+?)['"]?\s*$/gm))
         globs.push(m[1].trim());
     }
   } catch {
@@ -14991,12 +16115,12 @@ function loadWorkspaces(root) {
     if (g.startsWith("!")) continue;
     const star = g.indexOf("*");
     const dirs = [];
-    if (star === -1) dirs.push(resolve4(root, g));
+    if (star === -1) dirs.push(resolve5(root, g));
     else {
-      const base = resolve4(root, g.slice(0, star));
+      const base = resolve5(root, g.slice(0, star));
       try {
-        for (const d of readdirSync2(base, { withFileTypes: true })) {
-          if (d.isDirectory()) dirs.push(join8(base, d.name));
+        for (const d of readdirSync3(base, { withFileTypes: true })) {
+          if (d.isDirectory()) dirs.push(join9(base, d.name));
         }
       } catch {
       }
@@ -15050,16 +16174,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(resolve4(dir, c));
+    const hit = probe(resolve5(dir, c));
     if (hit) return hit;
   }
   return void 0;
 }
 function resolveImport(root, fromRel, spec) {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const abs = spec.startsWith("/") ? spec : resolve4(root, dirname5(fromRel), spec);
+    const abs = spec.startsWith("/") ? spec : resolve5(root, dirname6(fromRel), spec);
     const hit = probe(abs);
-    return hit ? normalize3(relative3(root, hit)) : void 0;
+    return hit ? normalize4(relative4(root, hit)) : void 0;
   }
   const tp = loadTsPaths(root);
   if (tp) {
@@ -15068,8 +16192,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(resolve4(tp.baseUrl, t.replace("*", star)));
-          if (hit) return normalize3(relative3(root, hit));
+          const hit = probe(resolve5(tp.baseUrl, t.replace("*", star)));
+          if (hit) return normalize4(relative4(root, hit));
         }
       }
     }
@@ -15078,7 +16202,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 && !relative3(root, hit).startsWith("..")) return normalize3(relative3(root, hit));
+    if (hit && !relative4(root, hit).startsWith("..")) return normalize4(relative4(root, hit));
   }
   return void 0;
 }
@@ -15142,6 +16266,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: [] };
@@ -15734,6 +16859,7 @@ var init_treesitter = __esm({
     init_ids();
     init_go();
     init_parser();
+    init_php();
     init_python();
     init_resolve();
     init_routes();
@@ -15822,8 +16948,8 @@ __export(indexer_exports, {
   indexContent: () => indexContent,
   indexPath: () => indexPath
 });
-import { readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { relative as relative4, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync6, statSync as statSync4 } from "fs";
+import { relative as relative5, resolve as resolve6 } from "path";
 function indexContent(db, input2) {
   const kind = input2.kind ?? (input2.contentType === "code" ? "code" : input2.contentType === "json" ? "json" : void 0);
   const { chunks, kind: k } = input2.chunks ? { chunks: finalize2(input2.chunks, input2.contentType ?? "code"), kind: kind ?? "code" } : chunk(input2.content, input2.title, kind, input2.uri);
@@ -15856,9 +16982,9 @@ function indexContent(db, input2) {
   return { documentId: id, created, chunks: chunks.length, chars: input2.content.length, kind: k };
 }
 function indexPath(db, root, target, opts = {}) {
-  const abs = resolve5(root, target);
+  const abs = resolve6(root, target);
   const summary = { files: 0, indexed: 0, unchanged: 0, skipped: [], chunks: 0 };
-  const st = statSync3(abs);
+  const st = statSync4(abs);
   const files = st.isDirectory() ? import_fast_glob.default.sync(opts.globs ?? ["**/*.md"], {
     cwd: abs,
     absolute: true,
@@ -15869,14 +16995,14 @@ function indexPath(db, root, target, opts = {}) {
   }) : [abs];
   for (const file3 of files) {
     summary.files++;
-    const rel = relative4(root, file3) || file3;
+    const rel = relative5(root, file3) || file3;
     try {
-      const size = statSync3(file3).size;
+      const size = statSync4(file3).size;
       if (size > MAX_FILE_BYTES) {
         summary.skipped.push({ path: rel, reason: `too large (${size} bytes)` });
         continue;
       }
-      const content = readFileSync5(file3, "utf8");
+      const content = readFileSync6(file3, "utf8");
       if (content.includes("\0")) {
         summary.skipped.push({ path: rel, reason: "binary" });
         continue;
@@ -16094,6 +17220,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;
@@ -16142,6 +17273,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 rest2 = name.slice(name.indexOf(".") + 1);
         const member = `${target}.${rest2}`;
@@ -16180,7 +17315,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, ...rest } = meta4;
       replace(db, e, {
@@ -16503,6 +17638,7 @@ var init_metrics = __esm({
       "class",
       "method",
       "interface",
+      "trait",
       "type",
       "enum",
       "field",
@@ -16532,8 +17668,8 @@ __export(reindex_exports, {
   reindexCode: () => reindexCode,
   reindexGitSignals: () => reindexGitSignals
 });
-import { readFileSync as readFileSync6, statSync as statSync4 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync7, statSync as statSync5 } from "fs";
+import { join as join10 } from "path";
 function listCodeFiles(ctx) {
   return import_fast_glob2.default.sync(ctx.config.graph.include, {
     cwd: ctx.root,
@@ -16544,8 +17680,8 @@ function listCodeFiles(ctx) {
   });
 }
 async function indexOne(ctx, db, rel, force) {
-  const abs = join9(ctx.root, rel);
-  const st = statSync4(abs);
+  const abs = join10(ctx.root, rel);
+  const st = statSync5(abs);
   const backend = getCodeBackend(ctx);
   const language = backend.languageOf(rel) ?? null;
   if (st.size > MAX_CODE_BYTES) {
@@ -16564,7 +17700,7 @@ async function indexOne(ctx, db, rel, force) {
     }
     return "skipped";
   }
-  const code = readFileSync6(abs, "utf8");
+  const code = readFileSync7(abs, "utf8");
   const hash2 = hashText(code);
   const prev = db.fileIndexGet(rel);
   if (!force && prev?.hash === hash2 && prev.status !== "skipped") return "unchanged";
@@ -16645,7 +17781,7 @@ async function reindexCode(ctx, db, opts = {}) {
     summary.unsupported++;
     if (db.fileIndexGet(rel)?.status === "unsupported") continue;
     try {
-      const st = statSync4(join9(ctx.root, rel));
+      const st = statSync5(join10(ctx.root, rel));
       db.fileIndexSet({
         path: rel,
         hash: "",
@@ -16661,7 +17797,7 @@ async function reindexCode(ctx, db, opts = {}) {
   }
   for (const rel of targets) {
     try {
-      if (!statSafe(join9(ctx.root, rel))) {
+      if (!statSafe(join10(ctx.root, rel))) {
         if (db.fileIndexGet(rel)) {
           removeOne(db, rel);
           summary.removed++;
@@ -16673,7 +17809,7 @@ async function reindexCode(ctx, db, opts = {}) {
       const error62 = err.message;
       summary.errors.push({ path: rel, error: error62 });
       try {
-        const st = statSync4(join9(ctx.root, rel));
+        const st = statSync5(join10(ctx.root, rel));
         db.fileIndexSet({
           path: rel,
           hash: "",
@@ -16736,7 +17872,7 @@ async function reindexCode(ctx, db, opts = {}) {
 }
 function statSafe(p) {
   try {
-    return statSync4(p).isFile();
+    return statSync5(p).isFile();
   } catch {
     return false;
   }
@@ -16776,10 +17912,10 @@ function indexFreshness(ctx, db) {
   const dirty = [];
   for (const r of rows.slice(0, 400)) {
     try {
-      const abs = join9(ctx.root, r.path);
-      const st = statSync4(abs);
+      const abs = join10(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(readFileSync6(abs, "utf8")) !== r.hash) dirty.push(r.path);
+      if (hashText(readFileSync7(abs, "utf8")) !== r.hash) dirty.push(r.path);
     } catch {
       dirty.push(r.path);
     }
@@ -16899,13 +18035,13 @@ __export(store_exports, {
 import {
   existsSync as existsSync8,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   renameSync,
-  statSync as statSync5,
+  statSync as statSync6,
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname6, join as join11, relative as relative5, sep } from "path";
+import { dirname as dirname7, join as join12, relative as relative6, sep } from "path";
 function isStatus(s) {
   return typeof s === "string" && MEMORY_STATUSES.includes(s);
 }
@@ -16919,16 +18055,16 @@ function memoriesRel(ctx) {
   return ctx.config.memories.dir.replace(/^\.\//, "").replace(/\/+$/, "");
 }
 function memoriesDir(ctx) {
-  return join11(ctx.root, memoriesRel(ctx));
+  return join12(ctx.root, memoriesRel(ctx));
 }
 function relOf(ctx, name) {
   return `${memoriesRel(ctx)}/${name}.md`;
 }
 function absOf(ctx, name) {
-  return join11(ctx.root, relOf(ctx, name));
+  return join12(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;
@@ -16967,7 +18103,7 @@ function normalizeRelated(ids) {
 }
 function writeMemoryFile(ctx, name, meta4, body) {
   const abs = absOf(ctx, name);
-  mkdirSync3(dirname6(abs), { recursive: true });
+  mkdirSync3(dirname7(abs), { recursive: true });
   writeFileSync2(abs, serializeMemoryFile(meta4, `
 ${body.trim()}
 `));
@@ -17012,12 +18148,12 @@ function syncFile(ctx, db, name, opts = {}) {
   const abs = absOf(ctx, name);
   const rel = relOf(ctx, name);
   if (!existsSync8(abs)) return void 0;
-  let st = statSync5(abs);
+  let st = statSync6(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 text2 = readFileSync7(abs, "utf8");
+  let text2 = readFileSync8(abs, "utf8");
   let hash2 = hashText(text2);
   if (!opts.force && row && row.file_hash === hash2) {
     db.memoryUpsertByName({
@@ -17056,7 +18192,7 @@ function syncFile(ctx, db, name, opts = {}) {
 ${parsed.body.replace(/^\s*\n/, "")}`
     );
     writeFileSync2(abs, text2);
-    st = statSync5(abs);
+    st = statSync6(abs);
     hash2 = hashText(text2);
   }
   const body = parsed.body.trim();
@@ -17094,7 +18230,7 @@ tags: ${tags.join(", ")}` : ""}`,
 function setMeta(ctx, db, name, patch) {
   const abs = absOf(ctx, name);
   if (!existsSync8(abs)) return false;
-  const parsed = parseMemoryFile(readFileSync7(abs, "utf8"));
+  const parsed = parseMemoryFile(readFileSync8(abs, "utf8"));
   const meta4 = { ...parsed.meta };
   for (const [k, v] of Object.entries(patch)) {
     if (v === void 0) delete meta4[k];
@@ -17143,7 +18279,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);
@@ -17175,7 +18311,7 @@ function write(ctx, db, input2) {
   let extra = {};
   if (exists) {
     try {
-      extra = parseMemoryFile(readFileSync7(abs, "utf8")).meta;
+      extra = parseMemoryFile(readFileSync8(abs, "utf8")).meta;
     } catch {
     }
   }
@@ -17202,7 +18338,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(readFileSync7(absOf(ctx, name), "utf8"));
+  const parsed = parseMemoryFile(readFileSync8(absOf(ctx, name), "utf8"));
   return {
     name,
     kind: synced.row.kind,
@@ -17229,7 +18365,7 @@ function edit(ctx, db, name, opts) {
   const abs = absOf(ctx, name);
   if (!existsSync8(abs)) throw new Error(`memory "${name}" does not exist`);
   syncFile(ctx, db, name);
-  const parsed = parseMemoryFile(readFileSync7(abs, "utf8"));
+  const parsed = parseMemoryFile(readFileSync8(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;
@@ -17247,9 +18383,9 @@ function rename(ctx, db, from, to) {
   const absTo = absOf(ctx, to);
   if (!existsSync8(absFrom)) throw new Error(`memory "${from}" does not exist`);
   if (existsSync8(absTo) || db.memoryGetByName(to)) throw new Error(`memory "${to}" already exists`);
-  mkdirSync3(dirname6(absTo), { recursive: true });
+  mkdirSync3(dirname7(absTo), { recursive: true });
   renameSync(absFrom, absTo);
-  const parsed = parseMemoryFile(readFileSync7(absTo, "utf8"));
+  const parsed = parseMemoryFile(readFileSync8(absTo, "utf8"));
   writeFileSync2(
     absTo,
     serializeMemoryFile(
@@ -17265,7 +18401,7 @@ function rename(ctx, db, from, to) {
     if (!row.name || row.name === to) continue;
     const abs = absOf(ctx, row.name);
     if (!existsSync8(abs)) continue;
-    const text2 = readFileSync7(abs, "utf8");
+    const text2 = readFileSync8(abs, "utf8");
     if (!ref.test(text2)) continue;
     ref.lastIndex = 0;
     writeFileSync2(abs, text2.replace(ref, `mem:${to}`));
@@ -17284,11 +18420,11 @@ function remove(ctx, db, name) {
 function gitignoreHint(ctx) {
   if (hinted.has(ctx.root)) return void 0;
   hinted.add(ctx.root);
-  const file3 = join11(ctx.root, ".gitignore");
+  const file3 = join12(ctx.root, ".gitignore");
   if (!existsSync8(file3)) return void 0;
   const dir = memoriesRel(ctx);
   const top = dir.split("/")[0];
-  const ignored = readFileSync7(file3, "utf8").split(/\r?\n/).map((l) => l.trim().replace(/^\//, "").replace(/\/$/, "")).some((l) => l === top || l === dir || l === `${top}/**` || l === `${dir}/**`);
+  const ignored = readFileSync8(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;
@@ -17815,14 +18951,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);
@@ -27085,7 +28221,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve7) {
+function isRecursive(inst, stack, resolve8) {
   const cached5 = recursive.get(inst);
   if (cached5 !== void 0)
     return cached5 ? PROVEN : NONE;
@@ -27095,7 +28231,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;
     }
@@ -27106,7 +28242,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;
     }
@@ -27170,7 +28306,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;
     }
@@ -45763,7 +46899,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+        await new Promise((resolve8) => setTimeout(resolve8, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error62) {
@@ -45780,7 +46916,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       const earlyReject = (error62) => {
         reject(error62);
       };
@@ -45858,7 +46994,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve7(parseResult.data);
+            resolve8(parseResult.data);
           }
         } catch (error62) {
           reject(error62);
@@ -46120,12 +47256,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve7, interval);
+      const timeoutId = setTimeout(resolve8, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -47268,7 +48404,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+      await new Promise((resolve8) => setTimeout(resolve8, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -47934,12 +49070,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve7();
+        resolve8();
       } else {
-        this._stdout.once("drain", resolve7);
+        this._stdout.once("drain", resolve8);
       }
     });
   }
@@ -47988,7 +49124,8 @@ var ConfigSchema = external_exports.object({
       "**/*.mjs",
       "**/*.cjs",
       "**/*.py",
-      "**/*.go"
+      "**/*.go",
+      "**/*.php"
     ]),
     exclude: external_exports.array(external_exports.string()).default([
       "**/node_modules/**",
@@ -48002,7 +49139,8 @@ var ConfigSchema = external_exports.object({
       "**/__pycache__/**",
       "**/site-packages/**",
       "**/vendor/**",
-      "**/*.min.js"
+      "**/*.min.js",
+      "**/*.blade.php"
     ])
   }).prefault({}),
   git: external_exports.object({
@@ -48200,15 +49338,15 @@ init_reindex();
 // src/session/server-alive.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync as readdirSync3, rmSync, writeFileSync } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync as readdirSync4, rmSync, writeFileSync } from "fs";
+import { join as join11 } from "path";
 function markersDir(ctx) {
-  return join10(projectDir(ctx.id), "servers");
+  return join11(projectDir(ctx.id), "servers");
 }
 function markServerAlive(ctx, pid = process.pid) {
   const dir = markersDir(ctx);
   mkdirSync2(dir, { recursive: true });
-  const file3 = join10(dir, String(pid));
+  const file3 = join11(dir, String(pid));
   writeFileSync(file3, (/* @__PURE__ */ new Date()).toISOString());
   return () => {
     try {
@@ -48229,11 +49367,11 @@ function liveServers(ctx) {
   const dir = markersDir(ctx);
   if (!existsSync7(dir)) return [];
   const live = [];
-  for (const name of readdirSync3(dir)) {
+  for (const name of readdirSync4(dir)) {
     const pid = Number(name);
     if (!Number.isInteger(pid) || pid <= 0) continue;
     if (processAlive(pid)) live.push(pid);
-    else rmSync(join10(dir, name), { force: true });
+    else rmSync(join11(dir, name), { force: true });
   }
   return live;
 }
@@ -49237,12 +50375,18 @@ var SqliteAdapter = class _SqliteAdapter {
       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 {
@@ -49589,8 +50733,8 @@ init_esm_shims();
 init_esm_shims();
 init_store();
 init_metrics();
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { join as join13 } from "path";
 
 // src/graph/query.ts
 init_esm_shims();
@@ -50009,8 +51153,8 @@ var ASPECTS = [
 ];
 function pkgJson(root) {
   try {
-    const f = join12(root, "package.json");
-    return existsSync9(f) ? JSON.parse(readFileSync8(f, "utf8")) : {};
+    const f = join13(root, "package.json");
+    return existsSync9(f) ? JSON.parse(readFileSync9(f, "utf8")) : {};
   } catch {
     return {};
   }
@@ -50188,10 +51332,10 @@ init_esm_shims();
 // src/session/current.ts
 init_esm_shims();
 init_paths();
-import { readFileSync as readFileSync9, statSync as statSync6, writeFileSync as writeFileSync3 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync10, statSync as statSync7, writeFileSync as writeFileSync3 } from "fs";
+import { join as join14 } from "path";
 function file2(ctx) {
-  return join13(projectDir(ctx.id), "current-session");
+  return join14(projectDir(ctx.id), "current-session");
 }
 var cached3;
 function getCurrentSession(ctx) {
@@ -50199,12 +51343,12 @@ function getCurrentSession(ctx) {
   const f = file2(ctx);
   let mtimeMs;
   try {
-    mtimeMs = statSync6(f).mtimeMs;
+    mtimeMs = statSync7(f).mtimeMs;
   } catch {
     return "unknown";
   }
   if (cached3 && cached3.file === f && cached3.mtimeMs === mtimeMs) return cached3.id;
-  const id = readFileSync9(f, "utf8").trim() || "unknown";
+  const id = readFileSync10(f, "utf8").trim() || "unknown";
   cached3 = { file: f, mtimeMs, id };
   return id;
 }
@@ -50417,7 +51561,7 @@ var NodeFilterSchema = external_exports.object({
 });
 var 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(
@@ -50778,13 +51922,13 @@ init_esm_shims();
 // src/sandbox/execute.ts
 init_esm_shims();
 import { unlinkSync as unlinkSync2 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 
 // src/permissions/settings.ts
 init_esm_shims();
-import { existsSync as existsSync10, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/permissions/rules.ts
 init_esm_shims();
@@ -50911,7 +52055,7 @@ function splitCommand(line) {
     i++;
   }
   flush();
-  return segments.map(normalize4).filter(Boolean);
+  return segments.map(normalize5).filter(Boolean);
 }
 function matchParen(s, open3) {
   let d = 0;
@@ -50924,7 +52068,7 @@ function matchParen(s, open3) {
   }
   return s.length;
 }
-function normalize4(seg) {
+function normalize5(seg) {
   let s = seg.trim();
   for (; ; ) {
     const before = s;
@@ -50940,7 +52084,7 @@ function normalize4(seg) {
 function readRules(file3) {
   if (!existsSync10(file3)) return {};
   try {
-    const s = JSON.parse(readFileSync10(file3, "utf8"));
+    const s = JSON.parse(readFileSync11(file3, "utf8"));
     return s.permissions ?? {};
   } catch {
     return {};
@@ -50948,7 +52092,7 @@ function readRules(file3) {
 }
 function stamp(file3) {
   try {
-    return statSync7(file3).mtimeMs;
+    return statSync8(file3).mtimeMs;
   } catch {
     return -1;
   }
@@ -50956,9 +52100,9 @@ function stamp(file3) {
 var cache2 = /* @__PURE__ */ new Map();
 function loadPermissionRules(root, extraDeny = []) {
   const files = [
-    join14(homedir2(), ".claude", "settings.json"),
-    join14(root, ".claude", "settings.json"),
-    join14(root, ".claude", "settings.local.json")
+    join15(homedir2(), ".claude", "settings.json"),
+    join15(root, ".claude", "settings.json"),
+    join15(root, ".claude", "settings.local.json")
   ];
   const key = `${root}\0${extraDeny.join("\0")}`;
   const stamps = files.map(stamp);
@@ -51068,12 +52212,12 @@ init_esm_shims();
 init_paths();
 import { accessSync, constants, existsSync as existsSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
 import { createRequire } from "module";
-import { delimiter, join as join15 } from "path";
+import { delimiter, join as join16 } from "path";
 var require2 = createRequire(import.meta.url);
 function findOnPath(bin) {
   for (const dir of (process.env.PATH ?? "").split(delimiter)) {
     if (!dir) continue;
-    const p = join15(dir, bin);
+    const p = join16(dir, bin);
     try {
       accessSync(p, constants.X_OK);
       return p;
@@ -51208,7 +52352,7 @@ function writeScratch(code, ext) {
     mkdirSync4(dir, { recursive: true });
     scratchDir = dir;
   }
-  const file3 = join15(dir, `em-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`);
+  const file3 = join16(dir, `em-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`);
   try {
     writeFileSync4(file3, code, { mode: 384 });
   } catch (err) {
@@ -51224,7 +52368,7 @@ init_esm_shims();
 import { spawn } from "child_process";
 function runProcess(argv, opts) {
   const started = Date.now();
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const [cmd, ...args] = argv;
     const child = spawn(cmd, args, {
       cwd: opts.cwd,
@@ -51267,7 +52411,7 @@ function runProcess(argv, opts) {
       if (done) return;
       done = true;
       clearTimeout(timer);
-      resolve7({
+      resolve8({
         stdout: Buffer.concat(out).toString("utf8"),
         stderr: errTail,
         exitCode,
@@ -51310,7 +52454,7 @@ async function execute(ctx, input2) {
   const file3 = writeScratch(input2.code, lang.ext);
   const env = buildEnv(ctx.config.sandbox.envAllow, {
     EMINIAR_PROJECT_ROOT: ctx.root,
-    NODE_PATH: [join16(ctx.root, "node_modules"), process.env.NODE_PATH].filter(Boolean).join(":"),
+    NODE_PATH: [join17(ctx.root, "node_modules"), process.env.NODE_PATH].filter(Boolean).join(":"),
     ...input2.env
   });
   try {
@@ -52882,13 +54026,13 @@ function catalogForProvider(provider, catalog = CATALOG) {
 // src/docs/discover.ts
 init_esm_shims();
 var import_fast_glob4 = __toESM(require_out4(), 1);
-import { existsSync as existsSync13, readFileSync as readFileSync12, statSync as statSync8 } from "fs";
-import { basename, join as join18, relative as relative6 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync13, statSync as statSync9 } from "fs";
+import { basename, join as join19, relative as relative7 } from "path";
 
 // src/docs/manifest.ts
 init_esm_shims();
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname7, join as join17 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname8, join as join18 } from "path";
 var DOCS_PREFIX = "docs:";
 var NAME_RE2 = /^[a-z0-9][a-z0-9._-]{0,63}$/;
 function docsTag(name) {
@@ -52902,7 +54046,7 @@ function slugify3(input2) {
   return (s || "source").slice(0, 64);
 }
 function manifestPathAt(root, rel = ".eminiar/docs.json") {
-  return join17(root, rel);
+  return join18(root, rel);
 }
 function manifestPath(ctx) {
   return manifestPathAt(ctx.root, ctx.config.docs.manifest);
@@ -52910,7 +54054,7 @@ function manifestPath(ctx) {
 function empty() {
   return { version: 1, sources: [] };
 }
-function normalize5(raw) {
+function normalize6(raw) {
   if (!raw || typeof raw !== "object") return empty();
   const sources = Array.isArray(raw.sources) ? raw.sources : [];
   const out = [];
@@ -52932,7 +54076,7 @@ function normalize5(raw) {
 function readManifestAt(file3) {
   if (!existsSync12(file3)) return empty();
   try {
-    return normalize5(JSON.parse(readFileSync11(file3, "utf8")));
+    return normalize6(JSON.parse(readFileSync12(file3, "utf8")));
   } catch {
     return empty();
   }
@@ -52942,7 +54086,7 @@ function readManifest(ctx) {
 }
 function writeManifest(ctx, m) {
   const file3 = manifestPath(ctx);
-  mkdirSync5(dirname7(file3), { recursive: true });
+  mkdirSync5(dirname8(file3), { recursive: true });
   const sorted = {
     version: 1,
     sources: [...m.sources].sort((a, b) => a.name.localeCompare(b.name))
@@ -53193,7 +54337,7 @@ var GENERIC_ENV = /* @__PURE__ */ new Set([
 var SKIP_EXT = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".pdf", ".zip", ".ico"]);
 function readText(file3) {
   try {
-    return readFileSync12(file3, "utf8");
+    return readFileSync13(file3, "utf8");
   } catch {
     return void 0;
   }
@@ -53211,7 +54355,7 @@ function sizeOf(files) {
   let n = 0;
   for (const f of files) {
     try {
-      n += statSync8(f).size;
+      n += statSync9(f).size;
     } catch {
     }
   }
@@ -53219,7 +54363,7 @@ function sizeOf(files) {
 }
 var VISIBLE_DOT_DIRS = /* @__PURE__ */ new Set([".github", ".claude", ".cursor", ".gitlab", ".circleci"]);
 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] ?? "");
@@ -53248,8 +54392,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 = join18(f, "..");
-      const rel = relative6(root, dir);
+      const dir = join19(f, "..");
+      const rel = relative7(root, dir);
       if (!rel || rel.split("/").some((p) => p.startsWith(".") || p === "node_modules")) continue;
       found.add(dir);
     }
@@ -53257,7 +54401,7 @@ function findProjects(root, opts) {
   const max = opts.maxProjects ?? 40;
   const seenNames = /* @__PURE__ */ new Set();
   const nameOf = (dir) => {
-    const pkg = readJson2(join18(dir, "package.json"));
+    const pkg = readJson2(join19(dir, "package.json"));
     return typeof pkg?.name === "string" ? pkg.name : void 0;
   };
   const rootName = nameOf(root);
@@ -53275,7 +54419,7 @@ function findProjects(root, opts) {
   return out;
 }
 function npmSignals(dir, includeDev, project) {
-  const pkg = readJson2(join18(dir, "package.json"));
+  const pkg = readJson2(join19(dir, "package.json"));
   if (!pkg) return [];
   const sections = ["dependencies", ...includeDev ? ["devDependencies"] : []];
   const out = [];
@@ -53292,13 +54436,13 @@ function npmSignals(dir, includeDev, project) {
 }
 function pythonSignals(dir, project) {
   const out = [];
-  const py = readText(join18(dir, "pyproject.toml"));
+  const py = readText(join19(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(join18(dir, "requirements.txt"));
+  const req = readText(join19(dir, "requirements.txt"));
   if (req) {
     for (const line of req.split("\n")) {
       const name = /^\s*([A-Za-z0-9_.-]+)/.exec(line)?.[1];
@@ -53309,7 +54453,7 @@ function pythonSignals(dir, project) {
   return out;
 }
 function goSignals(dir, project) {
-  const mod = readText(join18(dir, "go.mod"));
+  const mod = readText(join19(dir, "go.mod"));
   if (!mod) return [];
   const out = [];
   const block = /require\s*\(([\s\S]*?)\)/g;
@@ -53494,62 +54638,67 @@ var DOC_HOST_RE = /^(docs?|developer|developers|devdocs|apidocs|api-docs|help|su
 var DOC_HOST_SUFFIX = /\.(readthedocs\.io|gitbook\.io|github\.io|gitlab\.io|netlify\.app|vercel\.app|mintlify\.app|readme\.io|redoc\.ly|stoplight\.io)$/i;
 var DOC_PATH_RE = /^\/(docs?|documentation|developers?|guides?|learn|reference|manual|wiki|help|en|latest|stable|v\d+(\.\d+)*\/docs)(\/|$)/i;
 var COMMENT_RE = /^\s*(\/\/|#|\*|\/\*|<!--|--|;|'''|""")/;
+var PLACEHOLDER_RE = /\bplaceholder\b/i;
+var REFERENCE_TABLE_HOSTS = 15;
 function isDocLink(host, path3) {
   return DOC_HOST_RE.test(host) || DOC_HOST_SUFFIX.test(host) || DOC_PATH_RE.test(path3) && !API_HOST_RE.test(host);
 }
 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 = statSync8(file3).size;
+      size = statSync9(file3).size;
     } catch {
       continue;
     }
     if (size > 400 * 1024) continue;
     const text2 = readText(file3);
     if (!text2 || text2.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 = text2.split("\n");
+    const found = [];
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      if (!line.includes("http")) continue;
-      const comment = COMMENT_RE.test(line);
+      if (!line.includes("http") || PLACEHOLDER_RE.test(line)) continue;
       for (const m of line.matchAll(URL_RE)) {
         const host = m[1].toLowerCase();
-        const path3 = m[2] ?? "/";
-        if (!isApiHostCandidate(host)) continue;
-        const spec = SPEC_URL_RE.test(path3);
-        if (!spec && isDocLink(host, path3)) {
-          if (comment && !isEnv) continue;
-          const link = docLinks.get(host) ?? { host, urls: [], samples: [], project };
-          const full = `https://${host}${path3.replace(/[#?].*$/, "")}`;
-          if (!link.urls.includes(full) && link.urls.length < 3) link.urls.push(full);
-          if (link.samples.length < 3) link.samples.push(`${rel}:${i + 1}`);
-          docLinks.set(host, link);
-          continue;
-        }
-        const callLike = !comment && (spec || isEnv || CALL_RE.test(line) || API_PATH_RE.test(path3) || API_HOST_RE.test(host));
-        const cur = hits.get(host) ?? {
-          host,
-          calls: 0,
-          mentions: 0,
-          samples: [],
-          specUrls: [],
-          project
-        };
-        if (callLike) cur.calls++;
-        else cur.mentions++;
-        if (callLike && cur.samples.length < 3) cur.samples.push(`${rel}:${i + 1}`);
-        if (spec) {
-          const full = `https://${host}${path3}`;
-          if (!cur.specUrls.includes(full) && cur.specUrls.length < 4) cur.specUrls.push(full);
-        }
-        hits.set(host, cur);
+        if (isApiHostCandidate(host)) found.push({ host, path: m[2] ?? "/", line, i });
+      }
+    }
+    if (new Set(found.map((f) => f.host)).size >= REFERENCE_TABLE_HOSTS) continue;
+    for (const { host, path: path3, line, i } of found) {
+      const comment = COMMENT_RE.test(line);
+      const spec = SPEC_URL_RE.test(path3);
+      if (!spec && isDocLink(host, path3)) {
+        if (comment && !isEnv) continue;
+        const link = docLinks.get(host) ?? { host, urls: [], samples: [], project };
+        const full = `https://${host}${path3.replace(/[#?].*$/, "")}`;
+        if (!link.urls.includes(full) && link.urls.length < 3) link.urls.push(full);
+        if (link.samples.length < 3) link.samples.push(`${rel}:${i + 1}`);
+        docLinks.set(host, link);
+        continue;
+      }
+      const callLike = !comment && (spec || isEnv || CALL_RE.test(line) || API_PATH_RE.test(path3) || API_HOST_RE.test(host));
+      const cur = hits.get(host) ?? {
+        host,
+        calls: 0,
+        mentions: 0,
+        samples: [],
+        specUrls: [],
+        project
+      };
+      if (callLike) cur.calls++;
+      else cur.mentions++;
+      if (callLike && cur.samples.length < 3) cur.samples.push(`${rel}:${i + 1}`);
+      if (spec) {
+        const full = `https://${host}${path3}`;
+        if (!cur.specUrls.includes(full) && cur.specUrls.length < 4) cur.specUrls.push(full);
       }
+      hits.set(host, cur);
     }
   }
   return { hits, docLinks };
@@ -53598,7 +54747,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) });
@@ -53628,7 +54777,7 @@ function localCandidates(root, dir, project, isRegistered) {
       why: "project readme and top-level guides"
     });
   for (const d of ["docs", "doc", "documentation"]) {
-    const abs = join18(dir, d);
+    const abs = join19(dir, d);
     if (!existsSync13(abs)) continue;
     const files = glob(abs, ["**/*.md", "**/*.mdx", "**/*.rst", "**/*.txt"]).filter(
       (f) => !SKIP_EXT.has(f.slice(f.lastIndexOf(".")))
@@ -53652,7 +54801,7 @@ function localCandidates(root, dir, project, isRegistered) {
     "docs/decisions",
     "decisions"
   ]) {
-    const abs = join18(dir, d);
+    const abs = join19(dir, d);
     if (!existsSync13(abs)) continue;
     if (out.some((c) => c.path && rel(abs).startsWith(`${c.path}/`))) break;
     const files = glob(abs, ["**/*.md"]);
@@ -53712,7 +54861,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"
@@ -53786,7 +54935,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));
@@ -53796,7 +54945,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;
@@ -53986,7 +55135,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
   };
@@ -55525,9 +56674,9 @@ init_esm_shims();
 init_esm_shims();
 init_paths();
 init_version();
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync14, readFileSync as readFileSync14 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var require4 = createRequire3(import.meta.url);
 function check2(name, fn) {
   try {
@@ -55557,7 +56706,7 @@ function runDoctor() {
   checks.push(
     check2("node-path pin", () => {
       if (!existsSync14(p.nodePathFile)) return "not pinned (run `eminiar install`); using PATH node";
-      const pinned = readFileSync13(p.nodePathFile, "utf8").trim();
+      const pinned = readFileSync14(p.nodePathFile, "utf8").trim();
       accessSync2(pinned, constants2.X_OK);
       return pinned;
     })
@@ -55566,8 +56715,8 @@ function runDoctor() {
     check2("root-path pin", () => {
       if (!existsSync14(p.rootPathFile))
         return "not pinned (run `eminiar install`); the bin/ shims run only from a directory that has node_modules";
-      const root = readFileSync13(p.rootPathFile, "utf8").trim();
-      if (!existsSync14(join19(root, "dist", "server.js")))
+      const root = readFileSync14(p.rootPathFile, "utf8").trim();
+      if (!existsSync14(join20(root, "dist", "server.js")))
         throw new Error(`${root} has no dist/server.js (run \`eminiar install\`)`);
       return root;
     })
@@ -55626,8 +56775,8 @@ init_queue();
 
 // src/hooks/coexist.ts
 init_esm_shims();
-import { readFileSync as readFileSync15 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync16 } from "fs";
+import { join as join22 } from "path";
 
 // src/install/claude-config.ts
 init_esm_shims();
@@ -55636,24 +56785,24 @@ import {
   copyFileSync,
   existsSync as existsSync15,
   mkdirSync as mkdirSync6,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync14,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync15,
   writeFileSync as writeFileSync6
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname8, join as join20 } from "path";
-var claudeDir = () => process.env.CLAUDE_CONFIG_DIR || join20(homedir3(), ".claude");
-var pluginsDir = () => join20(claudeDir(), "plugins");
+import { dirname as dirname9, join as join21 } from "path";
+var claudeDir = () => process.env.CLAUDE_CONFIG_DIR || join21(homedir3(), ".claude");
+var pluginsDir = () => join21(claudeDir(), "plugins");
 function readJson3(file3) {
   if (!existsSync15(file3)) return {};
   try {
-    return JSON.parse(readFileSync14(file3, "utf8"));
+    return JSON.parse(readFileSync15(file3, "utf8"));
   } catch (err) {
     throw new Error(`${file3} is not valid JSON: ${err.message}`);
   }
 }
 var PLUGIN_SERVER_ID = "plugin:eminiar:eminiar";
-var mcpNeedsAuthPath = () => join20(claudeDir(), "mcp-needs-auth-cache.json");
+var mcpNeedsAuthPath = () => join21(claudeDir(), "mcp-needs-auth-cache.json");
 function needsAuthEntry(id = PLUGIN_SERVER_ID) {
   try {
     const entry = readJson3(mcpNeedsAuthPath())[id];
@@ -55668,7 +56817,7 @@ var cached4;
 function contextModeInstalled() {
   if (cached4 !== void 0) return cached4;
   try {
-    const reg = JSON.parse(readFileSync15(join21(pluginsDir(), "installed_plugins.json"), "utf8"));
+    const reg = JSON.parse(readFileSync16(join22(pluginsDir(), "installed_plugins.json"), "utf8"));
     cached4 = Object.keys(reg.plugins ?? {}).some((id) => id.startsWith("context-mode@"));
   } catch {
     cached4 = false;
@@ -55788,16 +56937,16 @@ init_esm_shims();
 // src/sandbox/file.ts
 init_esm_shims();
 import { realpathSync as realpathSync2 } from "fs";
-import { isAbsolute, relative as relative7, resolve as resolve6 } from "path";
+import { isAbsolute, relative as relative8, resolve as resolve7 } from "path";
 function confinePath(root, target, rules) {
-  const abs = resolve6(root, target);
+  const abs = resolve7(root, target);
   let real;
   try {
     real = realpathSync2(abs);
   } catch {
     throw new Error(`file not found: ${target}`);
   }
-  const rel = relative7(root, real);
+  const rel = relative8(root, real);
   const inside = rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
   if (inside) return real;
   if (rules.allow.some((r) => matchRead(r, real))) return real;
@@ -56154,8 +57303,8 @@ init_esm_shims();
 
 // src/code/symbols.ts
 init_esm_shims();
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync17 } from "fs";
+import { join as join23 } from "path";
 
 // src/code/namepath.ts
 init_esm_shims();
@@ -56224,10 +57373,10 @@ function children(db, parent, depth = 1) {
 }
 function symbolBody(db, root, n) {
   if (!n.path || !n.start_line || !n.end_line) return void 0;
-  const abs = join22(root, n.path);
+  const abs = join23(root, n.path);
   if (existsSync16(abs)) {
     try {
-      return readFileSync16(abs, "utf8").split("\n").slice(n.start_line - 1, n.end_line).join("\n");
+      return readFileSync17(abs, "utf8").split("\n").slice(n.start_line - 1, n.end_line).join("\n");
     } catch {
     }
   }
@@ -57253,7 +58402,7 @@ function referrerLabel(db, id, nodes) {
 }
 var emSymbols = defineTool({
   name: "em_symbols",
-  description: "Symbol-level code navigation on the tree-sitter graph (TS/JS, Python, Go): overview lists every symbol in a file with kinds and line ranges; find matches a name path (`method`, `Class/method`, `Class.method`, `/Class/method` for whole-name, `src/x.ts#Class.method`), optionally with the body; references lists what calls, references, extends or implements a symbol, grouped by the referencing symbol. Compact output; prefer this over reading whole files.",
+  description: "Symbol-level code navigation on the tree-sitter graph (TS/JS, Python, Go, PHP): overview lists every symbol in a file with kinds and line ranges; find matches a name path (`method`, `Class/method`, `Class.method`, `/Class/method` for whole-name, `src/x.ts#Class.method`), optionally with the body; references lists what calls, references, extends or implements a symbol, grouped by the referencing symbol. Compact output; prefer this over reading whole files.",
   schema: {
     mode: external_exports.enum(["overview", "find", "references"]).optional().describe("default find"),
     file: external_exports.string().optional().describe("overview: the file; find/references: restrict to (or referrers in) this path"),