@neat.is/core 0.7.3 → 0.7.4

package/dist/cli.cjs

@@ -825,8 +825,8 @@ init_cjs_shims();
 
 // src/ingest.ts
 init_cjs_shims();
-var import_node_fs7 = require("fs");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_fs8 = require("fs");
+var import_node_path9 = __toESM(require("path"), 1);
 var sourceMapJs = __toESM(require("source-map-js"), 1);
 
 // src/policy.ts
@@ -2175,16 +2175,16 @@ var PolicyViolationsLog = class {
 };
 
 // src/ingest.ts
-var import_types7 = require("@neat.is/types");
+var import_types8 = require("@neat.is/types");
 
 // src/extract/routes.ts
 init_cjs_shims();
-var import_node_path7 = __toESM(require("path"), 1);
-var import_tree_sitter = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_javascript = __toESM(require("tree-sitter-javascript"), 1);
-var import_tree_sitter_python = __toESM(require("tree-sitter-python"), 1);
-var import_tree_sitter_go = __toESM(require("tree-sitter-go"), 1);
-var import_types5 = require("@neat.is/types");
+var import_node_path8 = __toESM(require("path"), 1);
+var import_tree_sitter2 = __toESM(require("tree-sitter"), 1);
+var import_tree_sitter_javascript2 = __toESM(require("tree-sitter-javascript"), 1);
+var import_tree_sitter_python2 = __toESM(require("tree-sitter-python"), 1);
+var import_tree_sitter_go2 = __toESM(require("tree-sitter-go"), 1);
+var import_types6 = require("@neat.is/types");
 
 // src/extract/shared.ts
 init_cjs_shims();
@@ -2567,7 +2567,15 @@ function ensureFileNode(graph, serviceName, serviceNodeId, relPath) {
   return { fileNodeId, nodesAdded, edgesAdded };
 }
 
-// src/extract/routes.ts
+// src/extract/imports.ts
+init_cjs_shims();
+var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs7 = require("fs");
+var import_tree_sitter = __toESM(require("tree-sitter"), 1);
+var import_tree_sitter_javascript = __toESM(require("tree-sitter-javascript"), 1);
+var import_tree_sitter_python = __toESM(require("tree-sitter-python"), 1);
+var import_tree_sitter_go = __toESM(require("tree-sitter-go"), 1);
+var import_types5 = require("@neat.is/types");
 var PARSE_CHUNK = 16384;
 function parseSource(parser, source) {
   return parser.parse(
@@ -2589,533 +2597,910 @@ function makeGoParser() {
   p.setLanguage(import_tree_sitter_go.default);
   return p;
 }
-var ROUTER_METHODS = /* @__PURE__ */ new Set([
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "options",
-  "head",
-  "all"
-]);
-var NEXT_APP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
-var JS_ROUTE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"]);
-function ginRoutesFromSource(source, parser) {
-  const tree = parseSource(parser, source);
-  const prefixes = /* @__PURE__ */ new Map();
-  const out = [];
-  walk(tree.rootNode, (node) => {
-    if (node.type === "short_var_declaration" || node.type === "var_spec") {
-      const name = node.childForFieldName("left")?.namedChild(0)?.text ?? node.childForFieldName("name")?.text;
-      const value = node.childForFieldName("right")?.namedChild(0) ?? node.childForFieldName("value");
-      if (name && value?.type === "call_expression") {
-        const fn2 = value.childForFieldName("function");
-        const field = fn2?.childForFieldName("field")?.text;
-        const first2 = value.childForFieldName("arguments")?.namedChild(0);
-        if (field === "Group" && first2?.type === "interpreted_string_literal") {
-          prefixes.set(name, first2.text.slice(1, -1));
-        }
-      }
-      return;
-    }
-    if (node.type !== "call_expression") return;
-    const fn = node.childForFieldName("function");
-    if (fn?.type !== "selector_expression") return;
-    const method = fn.childForFieldName("field")?.text?.toUpperCase();
-    if (!method || !ROUTER_METHODS.has(method.toLowerCase())) return;
-    const receiver = fn.childForFieldName("operand")?.text ?? "";
-    const first = node.childForFieldName("arguments")?.namedChild(0);
-    if (first?.type !== "interpreted_string_literal") return;
-    const leaf = first.text.slice(1, -1);
-    out.push({
-      method: method === "ALL" ? "ALL" : method,
-      pathTemplate: canonicalizeTemplate((prefixes.get(receiver) ?? "") + leaf),
-      line: node.startPosition.row + 1,
-      framework: "gin"
-    });
-  });
-  return out;
-}
-var FASTAPI_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "options", "head", "trace"]);
-var NESTJS_METHODS = /* @__PURE__ */ new Map([
-  ["Get", "GET"],
-  ["Post", "POST"],
-  ["Put", "PUT"],
-  ["Patch", "PATCH"],
-  ["Delete", "DELETE"],
-  ["Options", "OPTIONS"],
-  ["Head", "HEAD"],
-  ["All", "ALL"]
-]);
-function canonicalizeTemplate(raw) {
-  let p = raw.split("?")[0].split("#")[0];
-  if (!p.startsWith("/")) p = "/" + p;
-  if (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
-  return p;
-}
-function isDynamicSegment(seg) {
-  if (seg.length === 0) return false;
-  if (seg.includes(":")) return true;
-  if (seg.startsWith("{") || seg.startsWith("[")) return true;
-  if (/^\d+$/.test(seg)) return true;
-  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(seg)) return true;
-  if (/^[0-9a-f]{24,}$/i.test(seg)) return true;
-  return false;
+function stringLiteralText(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child?.type === "string_fragment") return child.text;
+  }
+  const raw = node.text;
+  if (raw.length >= 2) return raw.slice(1, -1);
+  return raw.length === 0 ? null : "";
 }
-function normalizePathTemplate(raw) {
-  const canonical = canonicalizeTemplate(raw);
-  const segments = canonical.split("/").filter((s) => s.length > 0);
-  const normalised = segments.map((seg) => isDynamicSegment(seg) ? ":param" : seg.toLowerCase());
-  return "/" + normalised.join("/");
+function clipSnippet(text) {
+  const oneLine = text.split("\n")[0] ?? text;
+  return oneLine.length > 120 ? oneLine.slice(0, 120) : oneLine;
 }
-function walk(node, visit) {
-  visit(node);
+function collectGoImports(node, out) {
+  if (node.type === "import_spec") {
+    const pathNode = node.childForFieldName("path");
+    if (pathNode) {
+      const specifier = pathNode.text.replace(/^`|`$/g, "").replace(/^"|"$/g, "");
+      if (specifier) out.push({ specifier, line: node.startPosition.row + 1, snippet: clipSnippet(node.text) });
+    }
+    return;
+  }
   for (let i = 0; i < node.namedChildCount; i++) {
     const child = node.namedChild(i);
-    if (child) walk(child, visit);
+    if (child) collectGoImports(child, out);
   }
 }
-function staticStringText(node) {
-  if (node.type === "string") {
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child?.type === "string_fragment") return child.text;
+function collectJsImports(node, out) {
+  if (node.type === "import_statement") {
+    const source = node.childForFieldName("source");
+    if (source) {
+      const specifier = stringLiteralText(source);
+      if (specifier) {
+        out.push({ specifier, line: node.startPosition.row + 1, snippet: clipSnippet(node.text) });
+      }
     }
-    return "";
+    return;
   }
-  if (node.type === "template_string") {
-    for (let i = 0; i < node.namedChildCount; i++) {
-      if (node.namedChild(i)?.type === "template_substitution") return null;
+  if (node.type === "call_expression") {
+    const fn = node.childForFieldName("function");
+    if (fn?.type === "identifier" && fn.text === "require") {
+      const args = node.childForFieldName("arguments");
+      const firstArg = args?.namedChild(0);
+      if (firstArg?.type === "string") {
+        const specifier = stringLiteralText(firstArg);
+        if (specifier) {
+          out.push({ specifier, line: node.startPosition.row + 1, snippet: clipSnippet(node.text) });
+        }
+      }
     }
-    const raw = node.text;
-    return raw.length >= 2 ? raw.slice(1, -1) : "";
   }
-  return null;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child) collectJsImports(child, out);
+  }
 }
-function objectStringProp(objNode, key) {
-  for (let i = 0; i < objNode.namedChildCount; i++) {
-    const pair = objNode.namedChild(i);
-    if (!pair || pair.type !== "pair") continue;
-    const k = pair.childForFieldName("key");
-    if (!k) continue;
-    const kText = k.type === "string" ? staticStringText(k) : k.text;
-    if (kText !== key) continue;
-    const v = pair.childForFieldName("value");
-    if (v) return staticStringText(v);
+function collectImportedNames(node, out) {
+  if (node.type === "aliased_import") {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) out.push(nameNode.text);
+    return;
+  }
+  if (node.type === "dotted_name") {
+    out.push(node.text);
+    return;
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child) collectImportedNames(child, out);
   }
-  return null;
 }
-function fastifyRouteMethods(objNode) {
-  for (let i = 0; i < objNode.namedChildCount; i++) {
-    const pair = objNode.namedChild(i);
-    if (!pair || pair.type !== "pair") continue;
-    const k = pair.childForFieldName("key");
-    const kText = k ? k.type === "string" ? staticStringText(k) : k.text : null;
-    if (kText !== "method") continue;
-    const v = pair.childForFieldName("value");
-    if (!v) return [];
-    if (v.type === "string" || v.type === "template_string") {
-      const s = staticStringText(v);
-      return s ? [s.toUpperCase()] : [];
-    }
-    if (v.type === "array") {
-      const out = [];
-      for (let j = 0; j < v.namedChildCount; j++) {
-        const el = v.namedChild(j);
-        if (el && (el.type === "string" || el.type === "template_string")) {
-          const s = staticStringText(el);
-          if (s) out.push(s.toUpperCase());
+function collectPyImports(node, out) {
+  if (node.type === "import_from_statement") {
+    let level = 0;
+    let modulePath = "";
+    const names = [];
+    let pastFrom = false;
+    let pastImport = false;
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (!pastFrom) {
+        if (child.type === "from") pastFrom = true;
+        continue;
+      }
+      if (!pastImport) {
+        if (child.type === "import") {
+          pastImport = true;
+          continue;
+        }
+        if (child.type === "relative_import") {
+          for (let j = 0; j < child.childCount; j++) {
+            const rc = child.child(j);
+            if (!rc) continue;
+            if (rc.type === "import_prefix") {
+              for (let k = 0; k < rc.childCount; k++) {
+                if (rc.child(k)?.type === ".") level++;
+              }
+            } else if (rc.type === "dotted_name") modulePath = rc.text;
+          }
+        } else if (child.type === "dotted_name") {
+          modulePath = child.text;
         }
+        continue;
       }
-      return out;
+      collectImportedNames(child, names);
+    }
+    if (level > 0 || modulePath) {
+      out.push({ modulePath, level, names, line: node.startPosition.row + 1, snippet: clipSnippet(node.text) });
     }
   }
-  return [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child) collectPyImports(child, out);
+  }
 }
-function nestDecoratorImports(root) {
-  const imports = /* @__PURE__ */ new Map();
-  walk(root, (node) => {
-    if (node.type !== "import_statement") return;
-    const source = node.childForFieldName("source");
-    if (!source || staticStringText(source) !== "@nestjs/common") return;
-    walk(node, (child) => {
-      if (child.type !== "import_specifier") return;
-      const imported = child.childForFieldName("name")?.text;
-      const local = child.childForFieldName("alias")?.text ?? imported;
-      if (!imported || !local) return;
-      if (imported === "Controller" || NESTJS_METHODS.has(imported)) {
-        imports.set(local, imported);
-      }
-    });
-  });
-  return imports;
-}
-function decoratorCall(node) {
-  if (node.type !== "decorator") return null;
-  const expression = node.namedChild(0);
-  return expression?.type === "call_expression" ? expression : null;
+async function fileExists(p) {
+  try {
+    await import_node_fs7.promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function decoratorCanonicalName(decorator, imports) {
-  const call = decoratorCall(decorator);
-  const fn = call?.childForFieldName("function");
-  if (!fn || fn.type !== "identifier") return null;
-  return imports.get(fn.text) ?? null;
+function isWithinServiceDir(candidate, serviceDir) {
+  const rel = import_node_path7.default.relative(serviceDir, candidate);
+  return rel !== "" && !rel.startsWith("..") && !import_node_path7.default.isAbsolute(rel);
 }
-function nestStaticPaths(call) {
-  const args = call.childForFieldName("arguments");
-  const first = args?.namedChild(0);
-  if (!first) return [""];
-  const single = staticStringText(first);
-  if (single !== null) return [single];
-  if (first.type !== "array") return [];
-  const paths = [];
-  for (let i = 0; i < first.namedChildCount; i++) {
-    const item = first.namedChild(i);
-    if (!item) continue;
-    const value = staticStringText(item);
-    if (value !== null) paths.push(value);
+var JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var JS_INDEX_FILES = JS_EXTENSIONS.map((ext) => `index${ext}`);
+async function firstExistingCandidate(base, serviceDir) {
+  for (const ext of JS_EXTENSIONS) {
+    const candidate = base + ext;
+    if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
+      return toPosix(import_node_path7.default.relative(serviceDir, candidate));
+    }
   }
-  return paths;
+  for (const indexFile of JS_INDEX_FILES) {
+    const candidate = import_node_path7.default.join(base, indexFile);
+    if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
+      return toPosix(import_node_path7.default.relative(serviceDir, candidate));
+    }
+  }
+  return null;
 }
-function nestJoinedPath(prefix, leaf) {
-  const segments = [prefix, leaf].map((part) => part.replace(/^\/+|\/+$/g, "")).filter((part) => part.length > 0);
-  return canonicalizeTemplate(segments.join("/"));
+async function loadTsPathConfig(serviceDir) {
+  const tsconfigPath = import_node_path7.default.join(serviceDir, "tsconfig.json");
+  let raw;
+  try {
+    raw = await import_node_fs7.promises.readFile(tsconfigPath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    const paths = parsed.compilerOptions?.paths;
+    if (!paths || Object.keys(paths).length === 0) return null;
+    const baseUrl = parsed.compilerOptions?.baseUrl;
+    return { paths, baseDir: baseUrl ? import_node_path7.default.resolve(serviceDir, baseUrl) : serviceDir };
+  } catch (err) {
+    recordExtractionError("import alias resolution", tsconfigPath, err);
+    return null;
+  }
 }
-function nestjsRoutesFromSource(source, parser) {
-  const tree = parseSource(parser, source);
-  const imports = nestDecoratorImports(tree.rootNode);
-  if (![...imports.values()].includes("Controller")) return [];
-  const out = [];
-  walk(tree.rootNode, (node) => {
-    if (node.type !== "class_declaration") return;
-    const decoratorOwner = node.parent?.type === "export_statement" ? node.parent : node;
-    const classDecorators = [];
-    for (let i = 0; i < decoratorOwner.namedChildCount; i++) {
-      const child = decoratorOwner.namedChild(i);
-      if (child?.type === "decorator") classDecorators.push(child);
+async function resolveTsAlias(specifier, config, serviceDir) {
+  for (const [pattern, targets] of Object.entries(config.paths)) {
+    let suffix = null;
+    if (pattern === specifier) {
+      suffix = "";
+    } else if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -1);
+      if (specifier.startsWith(prefix)) suffix = specifier.slice(prefix.length);
     }
-    const controller = classDecorators.find(
-      (decorator) => decoratorCanonicalName(decorator, imports) === "Controller"
-    );
-    const controllerCall = controller ? decoratorCall(controller) : null;
-    if (!controllerCall) return;
-    const prefixes = nestStaticPaths(controllerCall);
-    if (prefixes.length === 0) return;
-    const body = node.childForFieldName("body");
-    if (!body) return;
-    for (let i = 0; i < body.namedChildCount; i++) {
-      const methodNode = body.namedChild(i);
-      if (methodNode?.type !== "method_definition") continue;
-      for (let j = 0; j < methodNode.namedChildCount; j++) {
-        const decorator = methodNode.namedChild(j);
-        if (decorator?.type !== "decorator") continue;
-        const canonical = decoratorCanonicalName(decorator, imports);
-        const method = canonical ? NESTJS_METHODS.get(canonical) : void 0;
-        const call = decoratorCall(decorator);
-        if (!method || !call) continue;
-        const leaves = nestStaticPaths(call);
-        for (const prefix of prefixes) {
-          for (const leaf of leaves) {
-            out.push({
-              method,
-              pathTemplate: nestJoinedPath(prefix, leaf),
-              line: decorator.startPosition.row + 1,
-              framework: "nestjs"
-            });
-          }
-        }
+    if (suffix === null) continue;
+    for (const target of targets) {
+      const targetBase = target.endsWith("/*") ? target.slice(0, -2) : target.replace(/\*$/, "");
+      const resolvedBase = import_node_path7.default.resolve(config.baseDir, targetBase, suffix);
+      const hit = await firstExistingCandidate(resolvedBase, serviceDir);
+      if (hit) return hit;
+      if (isWithinServiceDir(resolvedBase, serviceDir) && await fileExists(resolvedBase)) {
+        return toPosix(import_node_path7.default.relative(serviceDir, resolvedBase));
       }
     }
-  });
-  return out;
+  }
+  return null;
 }
-function serverRoutesFromSource(source, parser, hasExpress, hasFastify, hasHono = false) {
-  const tree = parseSource(parser, source);
-  const out = [];
-  const framework = hasExpress ? "express" : hasFastify ? "fastify" : hasHono ? "hono" : "unknown";
-  walk(tree.rootNode, (node) => {
-    if (node.type !== "call_expression") return;
-    const fn = node.childForFieldName("function");
-    if (!fn || fn.type !== "member_expression") return;
-    const prop = fn.childForFieldName("property");
-    if (!prop) return;
-    const method = prop.text.toLowerCase();
-    const args = node.childForFieldName("arguments");
-    const first = args?.namedChild(0);
-    if (!first) return;
-    const line = node.startPosition.row + 1;
-    if (ROUTER_METHODS.has(method)) {
-      const p = staticStringText(first);
-      if (p && p.startsWith("/")) {
-        out.push({
-          method: method === "all" ? "ALL" : method.toUpperCase(),
-          pathTemplate: canonicalizeTemplate(p),
-          line,
-          framework
-        });
+async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
+  if (!specifier) return null;
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    const base = import_node_path7.default.resolve(importerDir, specifier);
+    const ext = import_node_path7.default.extname(specifier);
+    if (ext) {
+      if (ext === ".js" || ext === ".jsx") {
+        const tsExt = ext === ".jsx" ? ".tsx" : ".ts";
+        const tsSibling = base.slice(0, -ext.length) + tsExt;
+        if (isWithinServiceDir(tsSibling, serviceDir) && await fileExists(tsSibling)) {
+          return toPosix(import_node_path7.default.relative(serviceDir, tsSibling));
+        }
       }
-      return;
-    }
-    if (method === "route" && hasFastify && first.type === "object") {
-      const url = objectStringProp(first, "url");
-      if (!url || !url.startsWith("/")) return;
-      const methods = fastifyRouteMethods(first);
-      const list = methods.length > 0 ? methods : ["ALL"];
-      for (const m of list) {
-        out.push({
-          method: m === "ALL" ? "ALL" : m.toUpperCase(),
-          pathTemplate: canonicalizeTemplate(url),
-          line,
-          framework: "fastify"
-        });
+      if (isWithinServiceDir(base, serviceDir) && await fileExists(base)) {
+        return toPosix(import_node_path7.default.relative(serviceDir, base));
+      }
+      if (!JS_EXTENSIONS.includes(ext)) {
+        return firstExistingCandidate(base, serviceDir);
       }
+      return null;
     }
-  });
-  return out;
-}
-function segmentsOf(relFile) {
-  return toPosix(relFile).split("/").filter((s) => s.length > 0);
-}
-function isNextAppRouteFile(relFile) {
-  const segs = segmentsOf(relFile);
-  if (!segs.includes("app")) return false;
-  const base = segs[segs.length - 1] ?? "";
-  return /^route\.(?:js|jsx|mjs|cjs|ts|tsx)$/.test(base);
-}
-function isNextPagesApiFile(relFile) {
-  const segs = segmentsOf(relFile);
-  const pagesIdx = segs.indexOf("pages");
-  if (pagesIdx === -1 || segs[pagesIdx + 1] !== "api") return false;
-  const base = segs[segs.length - 1] ?? "";
-  if (/^_(app|document|middleware)\./.test(base)) return false;
-  return JS_ROUTE_EXTENSIONS.has(import_node_path7.default.extname(base));
-}
-function nextSegment(seg) {
-  if (seg.startsWith("(") && seg.endsWith(")")) return null;
-  const catchAll = seg.match(/^\[\[?\.\.\.(.+?)\]?\]$/);
-  if (catchAll) return ":" + catchAll[1];
-  const dynamic = seg.match(/^\[(.+?)\]$/);
-  if (dynamic) return ":" + dynamic[1];
-  return seg;
-}
-function nextAppPathTemplate(relFile) {
-  const segs = segmentsOf(relFile);
-  const appIdx = segs.lastIndexOf("app");
-  const between = segs.slice(appIdx + 1, segs.length - 1);
-  const parts = [];
-  for (const seg of between) {
-    const mapped = nextSegment(seg);
-    if (mapped !== null) parts.push(mapped);
+    return firstExistingCandidate(base, serviceDir);
   }
-  return "/" + parts.join("/");
+  if (tsPaths) return resolveTsAlias(specifier, tsPaths, serviceDir);
+  return null;
 }
-function nextPagesApiPathTemplate(relFile) {
-  const segs = segmentsOf(relFile);
-  const pagesIdx = segs.indexOf("pages");
-  const rest = segs.slice(pagesIdx + 1);
-  const parts = [];
-  for (let i = 0; i < rest.length; i++) {
-    let seg = rest[i];
-    if (i === rest.length - 1) {
-      seg = seg.replace(/\.(?:js|jsx|mjs|cjs|ts|tsx)$/, "");
-      if (seg === "index") continue;
+async function resolvePyImport(imp, importerPath, serviceDir) {
+  let baseDir;
+  if (imp.level > 0) {
+    baseDir = import_node_path7.default.dirname(importerPath);
+    for (let i = 1; i < imp.level; i++) baseDir = import_node_path7.default.dirname(baseDir);
+  } else {
+    baseDir = serviceDir;
+  }
+  const moduleBase = imp.modulePath ? import_node_path7.default.join(baseDir, imp.modulePath.split(".").join("/")) : baseDir;
+  const resolved = /* @__PURE__ */ new Set();
+  let needModuleFile = imp.names.length === 0;
+  for (const name of imp.names) {
+    const submoduleFile = import_node_path7.default.join(moduleBase, `${name}.py`);
+    const subpackageInit = import_node_path7.default.join(moduleBase, name, "__init__.py");
+    if (isWithinServiceDir(submoduleFile, serviceDir) && await fileExists(submoduleFile)) {
+      resolved.add(toPosix(import_node_path7.default.relative(serviceDir, submoduleFile)));
+    } else if (isWithinServiceDir(subpackageInit, serviceDir) && await fileExists(subpackageInit)) {
+      resolved.add(toPosix(import_node_path7.default.relative(serviceDir, subpackageInit)));
+    } else {
+      needModuleFile = true;
     }
-    const mapped = nextSegment(seg);
-    if (mapped !== null) parts.push(mapped);
   }
-  return "/" + parts.join("/");
+  if (needModuleFile) {
+    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, import_node_path7.default.join(moduleBase, "__init__.py")] : [import_node_path7.default.join(moduleBase, "__init__.py")];
+    for (const candidate of moduleFileCandidates) {
+      if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
+        resolved.add(toPosix(import_node_path7.default.relative(serviceDir, candidate)));
+        break;
+      }
+    }
+  }
+  return [...resolved];
 }
-function nextAppMethods(root) {
-  const out = [];
-  walk(root, (node) => {
-    if (node.type !== "export_statement") return;
-    const decl = node.childForFieldName("declaration");
-    if (!decl) return;
-    const line = node.startPosition.row + 1;
-    if (decl.type === "function_declaration") {
-      const name = decl.childForFieldName("name")?.text;
-      if (name && NEXT_APP_METHODS.has(name)) out.push({ method: name, line });
-      return;
+async function resolveGoImport(specifier, modulePath, serviceDir) {
+  if (specifier !== modulePath && !specifier.startsWith(`${modulePath}/`)) return null;
+  const suffix = specifier === modulePath ? "" : specifier.slice(modulePath.length + 1);
+  const dir = import_node_path7.default.join(serviceDir, suffix);
+  const entries = await import_node_fs7.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const candidates = entries.filter((entry2) => entry2.isFile() && entry2.name.endsWith(".go") && !entry2.name.endsWith("_test.go")).map((entry2) => import_node_path7.default.join(dir, entry2.name));
+  if (candidates.length !== 1) return null;
+  return toPosix(import_node_path7.default.relative(serviceDir, candidates[0]));
+}
+function emitImportEdge(graph, serviceName, importerFileId, importerRelPath, importeeRelPath, line, snippet2) {
+  const importeeFileId = (0, import_types5.fileId)(serviceName, importeeRelPath);
+  if (!graph.hasNode(importeeFileId)) return 0;
+  const edgeId = (0, import_types5.extractedEdgeId)(importerFileId, importeeFileId, import_types5.EdgeType.IMPORTS);
+  if (graph.hasEdge(edgeId)) return 0;
+  const edge = {
+    id: edgeId,
+    source: importerFileId,
+    target: importeeFileId,
+    type: import_types5.EdgeType.IMPORTS,
+    provenance: import_types5.Provenance.EXTRACTED,
+    confidence: (0, import_types5.confidenceForExtracted)("structural"),
+    evidence: { file: importerRelPath, line, snippet: snippet2 }
+  };
+  graph.addEdgeWithKey(edgeId, importerFileId, importeeFileId, edge);
+  return 1;
+}
+async function addImports(graph, services) {
+  const jsParser = makeJsParser();
+  const pyParser = makePyParser();
+  const goParser = makeGoParser();
+  let edgesAdded = 0;
+  for (const service of services) {
+    const tsPaths = await loadTsPathConfig(service.dir);
+    const files = await loadSourceFiles(service.dir);
+    for (const file of files) {
+      if (isTestPath(file.path)) continue;
+      const relFile = toPosix(import_node_path7.default.relative(service.dir, file.path));
+      const importerFileId = (0, import_types5.fileId)(service.pkg.name, relFile);
+      const isPython = import_node_path7.default.extname(file.path) === ".py";
+      const isGo = import_node_path7.default.extname(file.path) === ".go";
+      if (isGo) {
+        let goImports = [];
+        try {
+          const tree = parseSource(goParser, file.content);
+          collectGoImports(tree.rootNode, goImports);
+        } catch (err) {
+          recordExtractionError("import extraction", file.path, err);
+          continue;
+        }
+        const goMod = await import_node_fs7.promises.readFile(import_node_path7.default.join(service.dir, "go.mod"), "utf8").catch(() => "");
+        const modulePath = goMod.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
+        if (!modulePath) continue;
+        for (const imp of goImports) {
+          const resolved = await resolveGoImport(imp.specifier, modulePath, service.dir);
+          if (!resolved) continue;
+          edgesAdded += emitImportEdge(graph, service.pkg.name, importerFileId, relFile, resolved, imp.line, imp.snippet);
+        }
+        continue;
+      }
+      if (isPython) {
+        let pyImports = [];
+        try {
+          const tree = parseSource(pyParser, file.content);
+          collectPyImports(tree.rootNode, pyImports);
+        } catch (err) {
+          recordExtractionError("import extraction", file.path, err);
+          continue;
+        }
+        for (const imp of pyImports) {
+          const resolvedPaths = await resolvePyImport(imp, file.path, service.dir);
+          for (const resolved of resolvedPaths) {
+            edgesAdded += emitImportEdge(
+              graph,
+              service.pkg.name,
+              importerFileId,
+              relFile,
+              resolved,
+              imp.line,
+              imp.snippet
+            );
+          }
+        }
+        continue;
+      }
+      let jsImports = [];
+      try {
+        const tree = parseSource(jsParser, file.content);
+        collectJsImports(tree.rootNode, jsImports);
+      } catch (err) {
+        recordExtractionError("import extraction", file.path, err);
+        continue;
+      }
+      for (const imp of jsImports) {
+        const resolved = await resolveJsImport(imp.specifier, import_node_path7.default.dirname(file.path), service.dir, tsPaths);
+        if (!resolved) continue;
+        edgesAdded += emitImportEdge(
+          graph,
+          service.pkg.name,
+          importerFileId,
+          relFile,
+          resolved,
+          imp.line,
+          imp.snippet
+        );
+      }
     }
-    if (decl.type === "lexical_declaration" || decl.type === "variable_declaration") {
-      for (let i = 0; i < decl.namedChildCount; i++) {
-        const d = decl.namedChild(i);
-        if (d?.type !== "variable_declarator") continue;
-        const name = d.childForFieldName("name")?.text;
-        if (name && NEXT_APP_METHODS.has(name)) out.push({ method: name, line });
+  }
+  return { nodesAdded: 0, edgesAdded };
+}
+
+// src/extract/routes.ts
+var PARSE_CHUNK2 = 16384;
+function parseSource2(parser, source) {
+  return parser.parse(
+    (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK2)
+  );
+}
+function makeJsParser2() {
+  const p = new import_tree_sitter2.default();
+  p.setLanguage(import_tree_sitter_javascript2.default);
+  return p;
+}
+function makePyParser2() {
+  const p = new import_tree_sitter2.default();
+  p.setLanguage(import_tree_sitter_python2.default);
+  return p;
+}
+function makeGoParser2() {
+  const p = new import_tree_sitter2.default();
+  p.setLanguage(import_tree_sitter_go2.default);
+  return p;
+}
+var ROUTER_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "options",
+  "head",
+  "all"
+]);
+var NEXT_APP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var JS_ROUTE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"]);
+function ginRoutesFromSource(source, parser) {
+  const tree = parseSource2(parser, source);
+  const prefixes = /* @__PURE__ */ new Map();
+  const out = [];
+  walk(tree.rootNode, (node) => {
+    if (node.type === "short_var_declaration" || node.type === "var_spec") {
+      const name = node.childForFieldName("left")?.namedChild(0)?.text ?? node.childForFieldName("name")?.text;
+      const value = node.childForFieldName("right")?.namedChild(0) ?? node.childForFieldName("value");
+      if (name && value?.type === "call_expression") {
+        const fn2 = value.childForFieldName("function");
+        const field = fn2?.childForFieldName("field")?.text;
+        const first2 = value.childForFieldName("arguments")?.namedChild(0);
+        if (field === "Group" && first2?.type === "interpreted_string_literal") {
+          prefixes.set(name, first2.text.slice(1, -1));
+        }
       }
+      return;
     }
+    if (node.type !== "call_expression") return;
+    const fn = node.childForFieldName("function");
+    if (fn?.type !== "selector_expression") return;
+    const method = fn.childForFieldName("field")?.text?.toUpperCase();
+    if (!method || !ROUTER_METHODS.has(method.toLowerCase())) return;
+    const receiver = fn.childForFieldName("operand")?.text ?? "";
+    const first = node.childForFieldName("arguments")?.namedChild(0);
+    if (first?.type !== "interpreted_string_literal") return;
+    const leaf = first.text.slice(1, -1);
+    out.push({
+      method: method === "ALL" ? "ALL" : method,
+      pathTemplate: canonicalizeTemplate((prefixes.get(receiver) ?? "") + leaf),
+      line: node.startPosition.row + 1,
+      framework: "gin"
+    });
   });
   return out;
 }
-function nextRoutesFromFile(source, relFile, parser) {
-  if (isNextAppRouteFile(relFile)) {
-    const tree = parseSource(parser, source);
-    const template = nextAppPathTemplate(relFile);
-    return nextAppMethods(tree.rootNode).map(({ method, line }) => ({
-      method,
-      pathTemplate: canonicalizeTemplate(template),
-      line,
-      framework: "next"
-    }));
-  }
-  if (isNextPagesApiFile(relFile)) {
-    return [
-      {
-        method: "ALL",
-        pathTemplate: canonicalizeTemplate(nextPagesApiPathTemplate(relFile)),
-        line: 1,
-        framework: "next"
-      }
-    ];
-  }
-  return [];
+var FASTAPI_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "options", "head", "trace"]);
+var NESTJS_METHODS = /* @__PURE__ */ new Map([
+  ["Get", "GET"],
+  ["Post", "POST"],
+  ["Put", "PUT"],
+  ["Patch", "PATCH"],
+  ["Delete", "DELETE"],
+  ["Options", "OPTIONS"],
+  ["Head", "HEAD"],
+  ["All", "ALL"]
+]);
+function canonicalizeTemplate(raw) {
+  let p = raw.split("?")[0].split("#")[0];
+  if (!p.startsWith("/")) p = "/" + p;
+  if (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
+  return p;
 }
-function pyStaticStringText(node) {
-  if (node.type !== "string") return null;
+function isDynamicSegment(seg) {
+  if (seg.length === 0) return false;
+  if (seg.includes(":")) return true;
+  if (seg.startsWith("{") || seg.startsWith("[")) return true;
+  if (/^\d+$/.test(seg)) return true;
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(seg)) return true;
+  if (/^[0-9a-f]{24,}$/i.test(seg)) return true;
+  return false;
+}
+function normalizePathTemplate(raw) {
+  const canonical = canonicalizeTemplate(raw);
+  const segments = canonical.split("/").filter((s) => s.length > 0);
+  const normalised = segments.map((seg) => isDynamicSegment(seg) ? ":param" : seg.toLowerCase());
+  return "/" + normalised.join("/");
+}
+function walk(node, visit) {
+  visit(node);
   for (let i = 0; i < node.namedChildCount; i++) {
     const child = node.namedChild(i);
-    if (child?.type === "interpolation") return null;
-    if (child?.type === "string_content") return child.text;
+    if (child) walk(child, visit);
   }
-  return "";
 }
-function keywordArrayStrings(argsNode, key) {
-  for (let i = 0; i < argsNode.namedChildCount; i++) {
-    const arg = argsNode.namedChild(i);
-    if (arg?.type !== "keyword_argument") continue;
-    if (arg.childForFieldName("name")?.text !== key) continue;
-    const val = arg.childForFieldName("value");
-    if (!val || val.type !== "list") return [];
-    const out = [];
-    for (let j = 0; j < val.namedChildCount; j++) {
-      const el = val.namedChild(j);
-      if (el?.type === "string") {
-        const s = pyStaticStringText(el);
-        if (s) out.push(s);
-      }
+function staticStringText(node) {
+  if (node.type === "string") {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type === "string_fragment") return child.text;
     }
-    return out;
+    return "";
   }
-  return [];
-}
-function collectPythonRouterPrefixes(root) {
-  const prefixes = /* @__PURE__ */ new Map();
-  walk(root, (node) => {
-    if (node.type !== "assignment") return;
-    const right = node.childForFieldName("right");
-    if (!right || right.type !== "call") return;
-    const fn = right.childForFieldName("function");
-    if (!fn) return;
-    const ctor = fn.type === "attribute" ? fn.childForFieldName("attribute")?.text : fn.text;
-    const prefixKey = ctor === "APIRouter" ? "prefix" : ctor === "Blueprint" ? "url_prefix" : null;
-    if (!prefixKey) return;
-    const left = node.childForFieldName("left");
-    if (!left || left.type !== "identifier") return;
-    const args = right.childForFieldName("arguments");
-    if (!args) return;
-    for (let i = 0; i < args.namedChildCount; i++) {
-      const arg = args.namedChild(i);
-      if (arg?.type !== "keyword_argument") continue;
-      if (arg.childForFieldName("name")?.text !== prefixKey) continue;
-      const val = arg.childForFieldName("value");
-      const p = val ? pyStaticStringText(val) : null;
-      if (p !== null) prefixes.set(left.text, p);
+  if (node.type === "template_string") {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      if (node.namedChild(i)?.type === "template_substitution") return null;
     }
-  });
-  return prefixes;
+    const raw = node.text;
+    return raw.length >= 2 ? raw.slice(1, -1) : "";
+  }
+  return null;
 }
-function collectStringConstants(root) {
-  const consts = /* @__PURE__ */ new Map();
+function objectStringProp(objNode, key) {
+  for (let i = 0; i < objNode.namedChildCount; i++) {
+    const pair = objNode.namedChild(i);
+    if (!pair || pair.type !== "pair") continue;
+    const k = pair.childForFieldName("key");
+    if (!k) continue;
+    const kText = k.type === "string" ? staticStringText(k) : k.text;
+    if (kText !== key) continue;
+    const v = pair.childForFieldName("value");
+    if (v) return staticStringText(v);
+  }
+  return null;
+}
+function fastifyRouteMethods(objNode) {
+  for (let i = 0; i < objNode.namedChildCount; i++) {
+    const pair = objNode.namedChild(i);
+    if (!pair || pair.type !== "pair") continue;
+    const k = pair.childForFieldName("key");
+    const kText = k ? k.type === "string" ? staticStringText(k) : k.text : null;
+    if (kText !== "method") continue;
+    const v = pair.childForFieldName("value");
+    if (!v) return [];
+    if (v.type === "string" || v.type === "template_string") {
+      const s = staticStringText(v);
+      return s ? [s.toUpperCase()] : [];
+    }
+    if (v.type === "array") {
+      const out = [];
+      for (let j = 0; j < v.namedChildCount; j++) {
+        const el = v.namedChild(j);
+        if (el && (el.type === "string" || el.type === "template_string")) {
+          const s = staticStringText(el);
+          if (s) out.push(s.toUpperCase());
+        }
+      }
+      return out;
+    }
+  }
+  return [];
+}
+function nestDecoratorImports(root) {
+  const imports = /* @__PURE__ */ new Map();
   walk(root, (node) => {
-    if (node.type !== "assignment") return;
-    const left = node.childForFieldName("left");
-    const right = node.childForFieldName("right");
-    if (left?.type !== "identifier" || right?.type !== "string") return;
-    const v = pyStaticStringText(right);
-    if (v !== null) consts.set(left.text, v);
+    if (node.type !== "import_statement") return;
+    const source = node.childForFieldName("source");
+    if (!source || staticStringText(source) !== "@nestjs/common") return;
+    walk(node, (child) => {
+      if (child.type !== "import_specifier") return;
+      const imported = child.childForFieldName("name")?.text;
+      const local = child.childForFieldName("alias")?.text ?? imported;
+      if (!imported || !local) return;
+      if (imported === "Controller" || NESTJS_METHODS.has(imported)) {
+        imports.set(local, imported);
+      }
+    });
   });
-  return consts;
+  return imports;
 }
-function resolvePrefixArg(node, consts) {
-  if (!node) return null;
-  if (node.type === "string") return pyStaticStringText(node);
-  if (node.type === "identifier") return consts.get(node.text) ?? null;
-  if (node.type === "attribute") {
-    const attr = node.childForFieldName("attribute")?.text;
-    return attr ? consts.get(attr) ?? null : null;
+function decoratorCall(node) {
+  if (node.type !== "decorator") return null;
+  const expression = node.namedChild(0);
+  return expression?.type === "call_expression" ? expression : null;
+}
+function decoratorCanonicalName(decorator, imports) {
+  const call = decoratorCall(decorator);
+  const fn = call?.childForFieldName("function");
+  if (!fn || fn.type !== "identifier") return null;
+  return imports.get(fn.text) ?? null;
+}
+function nestStaticPaths(call) {
+  const args = call.childForFieldName("arguments");
+  const first = args?.namedChild(0);
+  if (!first) return [""];
+  const single = staticStringText(first);
+  if (single !== null) return [single];
+  if (first.type !== "array") return [];
+  const paths = [];
+  for (let i = 0; i < first.namedChildCount; i++) {
+    const item = first.namedChild(i);
+    if (!item) continue;
+    const value = staticStringText(item);
+    if (value !== null) paths.push(value);
   }
-  return null;
+  return paths;
 }
-function collectMountPrefixes(root, consts) {
-  const mounts = /* @__PURE__ */ new Map();
-  walk(root, (node) => {
-    if (node.type !== "call") return;
-    const fn = node.childForFieldName("function");
-    if (fn?.type !== "attribute") return;
-    const method = fn.childForFieldName("attribute")?.text;
-    const prefixKey = method === "include_router" ? "prefix" : method === "register_blueprint" ? "url_prefix" : null;
-    if (!prefixKey) return;
-    const args = node.childForFieldName("arguments");
-    const first = args?.namedChild(0);
-    if (first?.type !== "identifier") return;
-    let prefix = null;
-    for (let i = 0; i < (args?.namedChildCount ?? 0); i++) {
-      const a = args.namedChild(i);
-      if (a?.type !== "keyword_argument") continue;
-      if (a.childForFieldName("name")?.text !== prefixKey) continue;
-      prefix = resolvePrefixArg(a.childForFieldName("value"), consts);
+function nestJoinedPath(prefix, leaf) {
+  const segments = [prefix, leaf].map((part) => part.replace(/^\/+|\/+$/g, "")).filter((part) => part.length > 0);
+  return canonicalizeTemplate(segments.join("/"));
+}
+function nestjsRoutesFromSource(source, parser) {
+  const tree = parseSource2(parser, source);
+  const imports = nestDecoratorImports(tree.rootNode);
+  if (![...imports.values()].includes("Controller")) return [];
+  const out = [];
+  walk(tree.rootNode, (node) => {
+    if (node.type !== "class_declaration") return;
+    const decoratorOwner = node.parent?.type === "export_statement" ? node.parent : node;
+    const classDecorators = [];
+    for (let i = 0; i < decoratorOwner.namedChildCount; i++) {
+      const child = decoratorOwner.namedChild(i);
+      if (child?.type === "decorator") classDecorators.push(child);
+    }
+    const controller = classDecorators.find(
+      (decorator) => decoratorCanonicalName(decorator, imports) === "Controller"
+    );
+    const controllerCall = controller ? decoratorCall(controller) : null;
+    if (!controllerCall) return;
+    const prefixes = nestStaticPaths(controllerCall);
+    if (prefixes.length === 0) return;
+    const body = node.childForFieldName("body");
+    if (!body) return;
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const methodNode = body.namedChild(i);
+      if (methodNode?.type !== "method_definition") continue;
+      for (let j = 0; j < methodNode.namedChildCount; j++) {
+        const decorator = methodNode.namedChild(j);
+        if (decorator?.type !== "decorator") continue;
+        const canonical = decoratorCanonicalName(decorator, imports);
+        const method = canonical ? NESTJS_METHODS.get(canonical) : void 0;
+        const call = decoratorCall(decorator);
+        if (!method || !call) continue;
+        const leaves = nestStaticPaths(call);
+        for (const prefix of prefixes) {
+          for (const leaf of leaves) {
+            out.push({
+              method,
+              pathTemplate: nestJoinedPath(prefix, leaf),
+              line: decorator.startPosition.row + 1,
+              framework: "nestjs"
+            });
+          }
+        }
+      }
     }
-    if (prefix !== null && prefix.length > 0) mounts.set(first.text, prefix);
   });
-  return mounts;
+  return out;
 }
-function pythonRoutesFromSource(source, parser, framework) {
-  const tree = parseSource(parser, source);
-  const prefixes = collectPythonRouterPrefixes(tree.rootNode);
-  const consts = collectStringConstants(tree.rootNode);
-  const mounts = collectMountPrefixes(tree.rootNode, consts);
+function serverRoutesFromSource(source, parser, hasExpress, hasFastify, hasHono = false) {
+  const tree = parseSource2(parser, source);
   const out = [];
+  const framework = hasExpress ? "express" : hasFastify ? "fastify" : hasHono ? "hono" : "unknown";
   walk(tree.rootNode, (node) => {
-    if (node.type !== "decorator") return;
-    const call = node.namedChild(0);
-    if (!call || call.type !== "call") return;
-    const fn = call.childForFieldName("function");
-    if (!fn || fn.type !== "attribute") return;
-    const method = fn.childForFieldName("attribute")?.text?.toLowerCase();
-    if (!method) return;
-    const isVerb = FASTAPI_METHODS.has(method);
-    const isFlaskRoute = method === "route";
-    const isApiRoute = method === "api_route";
-    if (!isVerb && !isFlaskRoute && !isApiRoute) return;
-    const args = call.childForFieldName("arguments");
+    if (node.type !== "call_expression") return;
+    const fn = node.childForFieldName("function");
+    if (!fn || fn.type !== "member_expression") return;
+    const prop = fn.childForFieldName("property");
+    if (!prop) return;
+    const method = prop.text.toLowerCase();
+    const args = node.childForFieldName("arguments");
     const first = args?.namedChild(0);
-    if (!first || first.type !== "string") return;
-    const rawPath = pyStaticStringText(first);
-    if (rawPath === null || !rawPath.startsWith("/")) return;
-    const obj = fn.childForFieldName("object")?.text;
-    const routerPrefix = obj ? prefixes.get(obj) ?? "" : "";
-    const mountPrefix = obj ? mounts.get(obj) ?? "" : "";
-    const pathTemplate = canonicalizeTemplate(mountPrefix + routerPrefix + rawPath);
+    if (!first) return;
     const line = node.startPosition.row + 1;
-    if (isVerb) {
-      out.push({ method: method.toUpperCase(), pathTemplate, line, framework });
+    if (ROUTER_METHODS.has(method)) {
+      const p = staticStringText(first);
+      if (p && p.startsWith("/")) {
+        out.push({
+          method: method === "all" ? "ALL" : method.toUpperCase(),
+          pathTemplate: canonicalizeTemplate(p),
+          line,
+          framework
+        });
+      }
       return;
     }
-    const methods = keywordArrayStrings(args, "methods");
-    const list = methods.length > 0 ? methods : isFlaskRoute ? ["GET"] : ["ALL"];
-    for (const m of list) {
-      out.push({ method: m === "ALL" ? "ALL" : m.toUpperCase(), pathTemplate, line, framework });
+    if (method === "route" && hasFastify && first.type === "object") {
+      const url = objectStringProp(first, "url");
+      if (!url || !url.startsWith("/")) return;
+      const methods = fastifyRouteMethods(first);
+      const list = methods.length > 0 ? methods : ["ALL"];
+      for (const m of list) {
+        out.push({
+          method: m === "ALL" ? "ALL" : m.toUpperCase(),
+          pathTemplate: canonicalizeTemplate(url),
+          line,
+          framework: "fastify"
+        });
+      }
     }
   });
   return out;
 }
-function djangoRoutesFromSource(source, parser) {
-  const tree = parseSource(parser, source);
-  const out = [];
-  walk(tree.rootNode, (node) => {
-    if (node.type !== "assignment") return;
+function segmentsOf(relFile) {
+  return toPosix(relFile).split("/").filter((s) => s.length > 0);
+}
+function isNextAppRouteFile(relFile) {
+  const segs = segmentsOf(relFile);
+  if (!segs.includes("app")) return false;
+  const base = segs[segs.length - 1] ?? "";
+  return /^route\.(?:js|jsx|mjs|cjs|ts|tsx)$/.test(base);
+}
+function isNextPagesApiFile(relFile) {
+  const segs = segmentsOf(relFile);
+  const pagesIdx = segs.indexOf("pages");
+  if (pagesIdx === -1 || segs[pagesIdx + 1] !== "api") return false;
+  const base = segs[segs.length - 1] ?? "";
+  if (/^_(app|document|middleware)\./.test(base)) return false;
+  return JS_ROUTE_EXTENSIONS.has(import_node_path8.default.extname(base));
+}
+function nextSegment(seg) {
+  if (seg.startsWith("(") && seg.endsWith(")")) return null;
+  const catchAll = seg.match(/^\[\[?\.\.\.(.+?)\]?\]$/);
+  if (catchAll) return ":" + catchAll[1];
+  const dynamic = seg.match(/^\[(.+?)\]$/);
+  if (dynamic) return ":" + dynamic[1];
+  return seg;
+}
+function nextAppPathTemplate(relFile) {
+  const segs = segmentsOf(relFile);
+  const appIdx = segs.lastIndexOf("app");
+  const between = segs.slice(appIdx + 1, segs.length - 1);
+  const parts = [];
+  for (const seg of between) {
+    const mapped = nextSegment(seg);
+    if (mapped !== null) parts.push(mapped);
+  }
+  return "/" + parts.join("/");
+}
+function nextPagesApiPathTemplate(relFile) {
+  const segs = segmentsOf(relFile);
+  const pagesIdx = segs.indexOf("pages");
+  const rest = segs.slice(pagesIdx + 1);
+  const parts = [];
+  for (let i = 0; i < rest.length; i++) {
+    let seg = rest[i];
+    if (i === rest.length - 1) {
+      seg = seg.replace(/\.(?:js|jsx|mjs|cjs|ts|tsx)$/, "");
+      if (seg === "index") continue;
+    }
+    const mapped = nextSegment(seg);
+    if (mapped !== null) parts.push(mapped);
+  }
+  return "/" + parts.join("/");
+}
+function nextAppMethods(root) {
+  const out = [];
+  walk(root, (node) => {
+    if (node.type !== "export_statement") return;
+    const decl = node.childForFieldName("declaration");
+    if (!decl) return;
+    const line = node.startPosition.row + 1;
+    if (decl.type === "function_declaration") {
+      const name = decl.childForFieldName("name")?.text;
+      if (name && NEXT_APP_METHODS.has(name)) out.push({ method: name, line });
+      return;
+    }
+    if (decl.type === "lexical_declaration" || decl.type === "variable_declaration") {
+      for (let i = 0; i < decl.namedChildCount; i++) {
+        const d = decl.namedChild(i);
+        if (d?.type !== "variable_declarator") continue;
+        const name = d.childForFieldName("name")?.text;
+        if (name && NEXT_APP_METHODS.has(name)) out.push({ method: name, line });
+      }
+    }
+  });
+  return out;
+}
+function nextRoutesFromFile(source, relFile, parser) {
+  if (isNextAppRouteFile(relFile)) {
+    const tree = parseSource2(parser, source);
+    const template = nextAppPathTemplate(relFile);
+    return nextAppMethods(tree.rootNode).map(({ method, line }) => ({
+      method,
+      pathTemplate: canonicalizeTemplate(template),
+      line,
+      framework: "next"
+    }));
+  }
+  if (isNextPagesApiFile(relFile)) {
+    return [
+      {
+        method: "ALL",
+        pathTemplate: canonicalizeTemplate(nextPagesApiPathTemplate(relFile)),
+        line: 1,
+        framework: "next"
+      }
+    ];
+  }
+  return [];
+}
+function pyStaticStringText(node) {
+  if (node.type !== "string") return null;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === "interpolation") return null;
+    if (child?.type === "string_content") return child.text;
+  }
+  return "";
+}
+function keywordArrayStrings(argsNode, key) {
+  for (let i = 0; i < argsNode.namedChildCount; i++) {
+    const arg = argsNode.namedChild(i);
+    if (arg?.type !== "keyword_argument") continue;
+    if (arg.childForFieldName("name")?.text !== key) continue;
+    const val = arg.childForFieldName("value");
+    if (!val || val.type !== "list") return [];
+    const out = [];
+    for (let j = 0; j < val.namedChildCount; j++) {
+      const el = val.namedChild(j);
+      if (el?.type === "string") {
+        const s = pyStaticStringText(el);
+        if (s) out.push(s);
+      }
+    }
+    return out;
+  }
+  return [];
+}
+function collectPythonRouterPrefixes(root) {
+  const prefixes = /* @__PURE__ */ new Map();
+  walk(root, (node) => {
+    if (node.type !== "assignment") return;
+    const right = node.childForFieldName("right");
+    if (!right || right.type !== "call") return;
+    const fn = right.childForFieldName("function");
+    if (!fn) return;
+    const ctor = fn.type === "attribute" ? fn.childForFieldName("attribute")?.text : fn.text;
+    const prefixKey = ctor === "APIRouter" ? "prefix" : ctor === "Blueprint" ? "url_prefix" : null;
+    if (!prefixKey) return;
+    const left = node.childForFieldName("left");
+    if (!left || left.type !== "identifier") return;
+    const args = right.childForFieldName("arguments");
+    if (!args) return;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (arg?.type !== "keyword_argument") continue;
+      if (arg.childForFieldName("name")?.text !== prefixKey) continue;
+      const val = arg.childForFieldName("value");
+      const p = val ? pyStaticStringText(val) : null;
+      if (p !== null) prefixes.set(left.text, p);
+    }
+  });
+  return prefixes;
+}
+function collectStringConstants(root) {
+  const consts = /* @__PURE__ */ new Map();
+  walk(root, (node) => {
+    if (node.type !== "assignment") return;
+    const left = node.childForFieldName("left");
+    const right = node.childForFieldName("right");
+    if (left?.type !== "identifier" || right?.type !== "string") return;
+    const v = pyStaticStringText(right);
+    if (v !== null) consts.set(left.text, v);
+  });
+  return consts;
+}
+function resolvePrefixArg(node, consts) {
+  if (!node) return null;
+  if (node.type === "string") return pyStaticStringText(node);
+  if (node.type === "identifier") return consts.get(node.text) ?? null;
+  if (node.type === "attribute") {
+    const attr = node.childForFieldName("attribute")?.text;
+    return attr ? consts.get(attr) ?? null : null;
+  }
+  return null;
+}
+function collectMountPrefixes(root, consts) {
+  const mounts = /* @__PURE__ */ new Map();
+  walk(root, (node) => {
+    if (node.type !== "call") return;
+    const fn = node.childForFieldName("function");
+    if (fn?.type !== "attribute") return;
+    const method = fn.childForFieldName("attribute")?.text;
+    const prefixKey = method === "include_router" ? "prefix" : method === "register_blueprint" ? "url_prefix" : null;
+    if (!prefixKey) return;
+    const args = node.childForFieldName("arguments");
+    const first = args?.namedChild(0);
+    if (first?.type !== "identifier") return;
+    let prefix = null;
+    for (let i = 0; i < (args?.namedChildCount ?? 0); i++) {
+      const a = args.namedChild(i);
+      if (a?.type !== "keyword_argument") continue;
+      if (a.childForFieldName("name")?.text !== prefixKey) continue;
+      prefix = resolvePrefixArg(a.childForFieldName("value"), consts);
+    }
+    if (prefix !== null && prefix.length > 0) mounts.set(first.text, prefix);
+  });
+  return mounts;
+}
+function pythonRoutesFromSource(source, parser, framework) {
+  const tree = parseSource2(parser, source);
+  const prefixes = collectPythonRouterPrefixes(tree.rootNode);
+  const consts = collectStringConstants(tree.rootNode);
+  const mounts = collectMountPrefixes(tree.rootNode, consts);
+  const out = [];
+  walk(tree.rootNode, (node) => {
+    if (node.type !== "decorator") return;
+    const call = node.namedChild(0);
+    if (!call || call.type !== "call") return;
+    const fn = call.childForFieldName("function");
+    if (!fn || fn.type !== "attribute") return;
+    const method = fn.childForFieldName("attribute")?.text?.toLowerCase();
+    if (!method) return;
+    const isVerb = FASTAPI_METHODS.has(method);
+    const isFlaskRoute = method === "route";
+    const isApiRoute = method === "api_route";
+    if (!isVerb && !isFlaskRoute && !isApiRoute) return;
+    const args = call.childForFieldName("arguments");
+    const first = args?.namedChild(0);
+    if (!first || first.type !== "string") return;
+    const rawPath = pyStaticStringText(first);
+    if (rawPath === null || !rawPath.startsWith("/")) return;
+    const obj = fn.childForFieldName("object")?.text;
+    const routerPrefix = obj ? prefixes.get(obj) ?? "" : "";
+    const mountPrefix = obj ? mounts.get(obj) ?? "" : "";
+    const pathTemplate = canonicalizeTemplate(mountPrefix + routerPrefix + rawPath);
+    const line = node.startPosition.row + 1;
+    if (isVerb) {
+      out.push({ method: method.toUpperCase(), pathTemplate, line, framework });
+      return;
+    }
+    const methods = keywordArrayStrings(args, "methods");
+    const list = methods.length > 0 ? methods : isFlaskRoute ? ["GET"] : ["ALL"];
+    for (const m of list) {
+      out.push({ method: m === "ALL" ? "ALL" : m.toUpperCase(), pathTemplate, line, framework });
+    }
+  });
+  return out;
+}
+function djangoRoutesFromSource(source, parser) {
+  const tree = parseSource2(parser, source);
+  const out = [];
+  walk(tree.rootNode, (node) => {
+    if (node.type !== "assignment") return;
     if (node.childForFieldName("left")?.text !== "urlpatterns") return;
     const list = node.childForFieldName("right");
     if (!list || list.type !== "list") return;
@@ -3140,36 +3525,347 @@ function djangoRoutesFromSource(source, parser) {
   });
   return out;
 }
-async function addRoutes(graph, services) {
-  const jsParser = makeJsParser();
-  const pyParser = makePyParser();
-  const goParser = makeGoParser();
-  let nodesAdded = 0;
-  let edgesAdded = 0;
-  for (const service of services) {
-    const deps = {
-      ...service.pkg.dependencies ?? {},
-      ...service.pkg.devDependencies ?? {}
-    };
-    const hasExpress = deps["express"] !== void 0;
-    const hasFastify = deps["fastify"] !== void 0;
-    const hasHono = deps["hono"] !== void 0;
-    const hasNext = deps["next"] !== void 0;
-    const hasNestjs = deps["@nestjs/core"] !== void 0;
-    const hasFastapi = deps["fastapi"] !== void 0;
-    const hasFlask = deps["flask"] !== void 0;
+function namedArgs(argsNode) {
+  const out = [];
+  if (!argsNode) return out;
+  for (let i = 0; i < argsNode.namedChildCount; i++) {
+    const c = argsNode.namedChild(i);
+    if (c && c.type !== "comment") out.push(c);
+  }
+  return out;
+}
+function parseUseMount(callNode) {
+  const args = namedArgs(callNode.childForFieldName("arguments"));
+  if (args.length === 0) return null;
+  const first = args[0];
+  const firstStr = first.type === "string" || first.type === "template_string" ? staticStringText(first) : null;
+  if (firstStr !== null && firstStr.startsWith("/")) {
+    const prefix = canonicalizeTemplate(firstStr);
+    const second = args[1];
+    const target = second && second.type === "identifier" ? second.text : null;
+    return { prefix: prefix === "/" ? "" : prefix, target };
+  }
+  if (args.length === 1 && first.type === "identifier") return { prefix: "", target: first.text };
+  return null;
+}
+function unwrapRouterExpr(node, expressLocals, routerCtors) {
+  if (node.type === "identifier") return { base: { alias: node.text }, mounts: [] };
+  if (node.type !== "call_expression") return null;
+  const fn = node.childForFieldName("function");
+  if (!fn) return null;
+  if (fn.type === "member_expression") {
+    const prop = fn.childForFieldName("property")?.text;
+    const obj = fn.childForFieldName("object");
+    if (!prop || !obj) return null;
+    if (prop === "use") {
+      const inner = unwrapRouterExpr(obj, expressLocals, routerCtors);
+      if (!inner) return null;
+      const mount = parseUseMount(node);
+      return { base: inner.base, mounts: mount ? [...inner.mounts, mount] : inner.mounts };
+    }
+    if (prop === "Router" && obj.type === "identifier" && expressLocals.has(obj.text)) {
+      return { base: "newRouter", mounts: [] };
+    }
+    return null;
+  }
+  if (fn.type === "identifier") {
+    if (expressLocals.has(fn.text)) return { base: "app", mounts: [] };
+    if (routerCtors.has(fn.text)) return { base: "newRouter", mounts: [] };
+  }
+  return null;
+}
+function collectExpressImports(root) {
+  const expressLocals = /* @__PURE__ */ new Set();
+  const routerCtors = /* @__PURE__ */ new Set();
+  const bindings = [];
+  const addFromExpress = (local, sel, exported) => {
+    if (sel === "default" || sel === "namespace") expressLocals.add(local);
+    else if (exported === "Router") routerCtors.add(local);
+  };
+  walk(root, (node) => {
+    if (node.type === "import_statement") {
+      const source = node.childForFieldName("source");
+      const spec = source ? staticStringText(source) : null;
+      if (!spec) return;
+      let clause = null;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c?.type === "import_clause") clause = c;
+      }
+      if (!clause) return;
+      for (let i = 0; i < clause.namedChildCount; i++) {
+        const c = clause.namedChild(i);
+        if (!c) continue;
+        if (c.type === "identifier") {
+          if (spec === "express") addFromExpress(c.text, "default", "default");
+          else bindings.push({ local: c.text, specifier: spec, sel: "default" });
+        } else if (c.type === "namespace_import") {
+          const id = c.namedChild(0);
+          if (id?.type === "identifier") {
+            if (spec === "express") addFromExpress(id.text, "namespace", "namespace");
+            else bindings.push({ local: id.text, specifier: spec, sel: "namespace" });
+          }
+        } else if (c.type === "named_imports") {
+          for (let j = 0; j < c.namedChildCount; j++) {
+            const s = c.namedChild(j);
+            if (s?.type !== "import_specifier") continue;
+            const name = s.childForFieldName("name")?.text;
+            if (!name) continue;
+            const local = s.childForFieldName("alias")?.text ?? name;
+            if (spec === "express") addFromExpress(local, name, name);
+            else bindings.push({ local, specifier: spec, sel: name });
+          }
+        }
+      }
+      return;
+    }
+    if (node.type === "variable_declarator") {
+      const value = node.childForFieldName("value");
+      if (value?.type !== "call_expression") return;
+      const fn = value.childForFieldName("function");
+      if (fn?.type !== "identifier" || fn.text !== "require") return;
+      const arg = namedArgs(value.childForFieldName("arguments"))[0];
+      const spec = arg ? staticStringText(arg) : null;
+      if (!spec) return;
+      const name = node.childForFieldName("name");
+      if (name?.type === "identifier") {
+        if (spec === "express") expressLocals.add(name.text);
+        else bindings.push({ local: name.text, specifier: spec, sel: "default" });
+      } else if (name?.type === "object_pattern") {
+        for (let i = 0; i < name.namedChildCount; i++) {
+          const el = name.namedChild(i);
+          if (!el) continue;
+          let local;
+          let exported;
+          if (el.type === "shorthand_property_identifier_pattern") {
+            local = el.text;
+            exported = el.text;
+          } else if (el.type === "pair_pattern") {
+            exported = el.childForFieldName("key")?.text;
+            local = el.childForFieldName("value")?.text ?? exported;
+          }
+          if (!local || !exported) continue;
+          if (spec === "express") addFromExpress(local, exported, exported);
+          else bindings.push({ local, specifier: spec, sel: exported });
+        }
+      }
+    }
+  });
+  return { expressLocals, routerCtors, bindings };
+}
+function analyzeExpressFile(root, dir) {
+  const { expressLocals, routerCtors, bindings } = collectExpressImports(root);
+  const routerVars = /* @__PURE__ */ new Map();
+  const appVars = /* @__PURE__ */ new Set();
+  const exportNamed = /* @__PURE__ */ new Map();
+  let exportDefaultName = null;
+  const getVar = (name) => {
+    let rv = routerVars.get(name);
+    if (!rv) {
+      rv = { declares: false, mounts: [] };
+      routerVars.set(name, rv);
+    }
+    return rv;
+  };
+  const refFromExpr = (expr, key) => {
+    if (expr.type === "identifier") return expr.text;
+    const u = unwrapRouterExpr(expr, expressLocals, routerCtors);
+    if (!u) return null;
+    const rv = getVar(key);
+    for (const m of u.mounts) rv.mounts.push(m);
+    if (typeof u.base === "object") rv.aliasOf = u.base.alias;
+    return key;
+  };
+  const isExported = (declarator) => {
+    const decl = declarator.parent;
+    return decl?.parent?.type === "export_statement";
+  };
+  walk(root, (node) => {
+    if (node.type === "variable_declarator") {
+      const value = node.childForFieldName("value");
+      const name = node.childForFieldName("name");
+      if (name?.type !== "identifier" || !value) return;
+      if (value.type === "call_expression") {
+        const fn = value.childForFieldName("function");
+        if (fn?.type === "identifier" && fn.text === "require") return;
+      }
+      const u = unwrapRouterExpr(value, expressLocals, routerCtors);
+      if (!u) return;
+      const rv = getVar(name.text);
+      for (const m of u.mounts) rv.mounts.push(m);
+      if (u.base === "app") appVars.add(name.text);
+      else if (typeof u.base === "object") rv.aliasOf = u.base.alias;
+      if (isExported(node)) exportNamed.set(name.text, name.text);
+      return;
+    }
+    if (node.type === "call_expression") {
+      const fn = node.childForFieldName("function");
+      if (fn?.type !== "member_expression") return;
+      const obj = fn.childForFieldName("object");
+      const prop = fn.childForFieldName("property")?.text;
+      if (obj?.type !== "identifier" || !prop) return;
+      if (prop === "use") {
+        const m = parseUseMount(node);
+        if (m) getVar(obj.text).mounts.push(m);
+      } else if (ROUTER_METHODS.has(prop.toLowerCase())) {
+        const first = namedArgs(node.childForFieldName("arguments"))[0];
+        const p = first ? staticStringText(first) : null;
+        if (p !== null && p.startsWith("/")) getVar(obj.text).declares = true;
+      }
+      return;
+    }
+    if (node.type === "export_statement") {
+      let clause = null;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c?.type === "export_clause") clause = c;
+      }
+      if (clause) {
+        for (let i = 0; i < clause.namedChildCount; i++) {
+          const spec = clause.namedChild(i);
+          if (spec?.type !== "export_specifier") continue;
+          const local = spec.childForFieldName("name")?.text;
+          if (!local) continue;
+          const exportedAs = spec.childForFieldName("alias")?.text ?? local;
+          if (exportedAs === "default") exportDefaultName = local;
+          else exportNamed.set(exportedAs, local);
+        }
+        return;
+      }
+      if (node.childForFieldName("declaration")) return;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type !== "export_clause") {
+          exportDefaultName = refFromExpr(c, "#default");
+          break;
+        }
+      }
+      return;
+    }
+    if (node.type === "assignment_expression") {
+      const left = node.childForFieldName("left");
+      const right = node.childForFieldName("right");
+      if (left?.type !== "member_expression" || !right) return;
+      const lobj = left.childForFieldName("object")?.text;
+      const lprop = left.childForFieldName("property")?.text;
+      if (lobj === "module" && lprop === "exports") exportDefaultName = refFromExpr(right, "#default");
+      else if (lobj === "exports" && lprop) {
+        const key = refFromExpr(right, `#exp:${lprop}`);
+        if (key) exportNamed.set(lprop, key);
+      }
+    }
+  });
+  return {
+    dir,
+    routerVars,
+    appVars,
+    exportDefaultName,
+    exportNamed,
+    rawBindings: bindings,
+    importedRouters: /* @__PURE__ */ new Map()
+  };
+}
+async function expressMountPrefixes(files, serviceDir, tsPaths) {
+  const jsParser = makeJsParser2();
+  const fileInfo = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    if (!JS_ROUTE_EXTENSIONS.has(import_node_path8.default.extname(f.path))) continue;
+    if (isTestPath(f.path)) continue;
+    const rel = toPosix(import_node_path8.default.relative(serviceDir, f.path));
+    try {
+      const tree = parseSource2(jsParser, f.content);
+      fileInfo.set(rel, analyzeExpressFile(tree.rootNode, import_node_path8.default.dirname(f.path)));
+    } catch {
+    }
+  }
+  if (fileInfo.size === 0) return /* @__PURE__ */ new Map();
+  for (const info of fileInfo.values()) {
+    for (const b of info.rawBindings) {
+      const resolved = await resolveJsImport(b.specifier, info.dir, serviceDir, tsPaths);
+      if (!resolved || !fileInfo.has(resolved)) continue;
+      info.importedRouters.set(b.local, { file: resolved, sel: b.sel === "namespace" ? "default" : b.sel });
+    }
+  }
+  const resolveTarget = (name, file) => {
+    const info = fileInfo.get(file);
+    if (!info) return null;
+    if (info.routerVars.has(name)) return { file, name };
+    const imp = info.importedRouters.get(name);
+    if (!imp) return null;
+    const target = fileInfo.get(imp.file);
+    if (!target) return null;
+    const key = imp.sel === "default" ? target.exportDefaultName : target.exportNamed.get(imp.sel);
+    if (!key) return null;
+    return { file: imp.file, name: key };
+  };
+  const filePrefix = /* @__PURE__ */ new Map();
+  const conflicted = /* @__PURE__ */ new Set();
+  const apply4 = (file, prefix) => {
+    if (conflicted.has(file)) return;
+    const existing = filePrefix.get(file);
+    if (existing === void 0) filePrefix.set(file, prefix);
+    else if (existing !== prefix) {
+      filePrefix.delete(file);
+      conflicted.add(file);
+    }
+  };
+  const visited = /* @__PURE__ */ new Set();
+  const collect = (file, name, accPrefix) => {
+    const key = `${file}|${name}|${accPrefix}`;
+    if (visited.has(key)) return;
+    visited.add(key);
+    const info = fileInfo.get(file);
+    const rv = info?.routerVars.get(name);
+    if (!info || !rv) return;
+    if (rv.declares && info.appVars.size === 0) apply4(file, accPrefix);
+    for (const m of rv.mounts) {
+      if (!m.target) continue;
+      const t = resolveTarget(m.target, file);
+      if (t) collect(t.file, t.name, accPrefix + m.prefix);
+    }
+    if (rv.aliasOf) {
+      const t = resolveTarget(rv.aliasOf, file);
+      if (t) collect(t.file, t.name, accPrefix);
+    }
+  };
+  for (const [rel, info] of fileInfo) {
+    for (const appVar of info.appVars) collect(rel, appVar, "");
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [file, prefix] of filePrefix) if (prefix && prefix !== "/") out.set(file, prefix);
+  return out;
+}
+async function addRoutes(graph, services) {
+  const jsParser = makeJsParser2();
+  const pyParser = makePyParser2();
+  const goParser = makeGoParser2();
+  let nodesAdded = 0;
+  let edgesAdded = 0;
+  for (const service of services) {
+    const deps = {
+      ...service.pkg.dependencies ?? {},
+      ...service.pkg.devDependencies ?? {}
+    };
+    const hasExpress = deps["express"] !== void 0;
+    const hasFastify = deps["fastify"] !== void 0;
+    const hasHono = deps["hono"] !== void 0;
+    const hasNext = deps["next"] !== void 0;
+    const hasNestjs = deps["@nestjs/core"] !== void 0;
+    const hasFastapi = deps["fastapi"] !== void 0;
+    const hasFlask = deps["flask"] !== void 0;
     const hasDjango = deps["django"] !== void 0;
     const hasGin = deps["github.com/gin-gonic/gin"] !== void 0;
     if (!hasExpress && !hasFastify && !hasHono && !hasNext && !hasNestjs && !hasFastapi && !hasFlask && !hasDjango && !hasGin)
       continue;
     const files = await loadSourceFiles(service.dir);
+    const mountPrefixes = hasExpress ? await expressMountPrefixes(files, service.dir, await loadTsPathConfig(service.dir)) : /* @__PURE__ */ new Map();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const ext = import_node_path7.default.extname(file.path);
+      const ext = import_node_path8.default.extname(file.path);
       const isPy = ext === ".py";
       const isGo = ext === ".go";
       if (!JS_ROUTE_EXTENSIONS.has(ext) && !isPy && !isGo) continue;
-      const relFile = toPosix(import_node_path7.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path8.default.relative(service.dir, file.path));
       let routes;
       try {
         if (isGo) {
@@ -3191,16 +3887,18 @@ async function addRoutes(graph, services) {
         continue;
       }
       if (routes.length === 0) continue;
+      const mountPrefix = mountPrefixes.get(relFile);
       for (const route of routes) {
-        const rid = (0, import_types5.routeId)(service.pkg.name, route.method, route.pathTemplate);
+        const pathTemplate = mountPrefix ? canonicalizeTemplate(mountPrefix + route.pathTemplate) : route.pathTemplate;
+        const rid = (0, import_types6.routeId)(service.pkg.name, route.method, pathTemplate);
         if (!graph.hasNode(rid)) {
           const node = {
             id: rid,
-            type: import_types5.NodeType.RouteNode,
-            name: `${route.method} ${route.pathTemplate}`,
+            type: import_types6.NodeType.RouteNode,
+            name: `${route.method} ${pathTemplate}`,
             service: service.pkg.name,
             method: route.method,
-            pathTemplate: route.pathTemplate,
+            pathTemplate,
             path: relFile,
             line: route.line,
             framework: route.framework,
@@ -3209,15 +3907,15 @@ async function addRoutes(graph, services) {
           graph.addNode(rid, node);
           nodesAdded++;
         }
-        const containsId = (0, import_types5.extractedEdgeId)(service.node.id, rid, import_types5.EdgeType.CONTAINS);
+        const containsId = (0, import_types6.extractedEdgeId)(service.node.id, rid, import_types6.EdgeType.CONTAINS);
         if (!graph.hasEdge(containsId)) {
           const edge = {
             id: containsId,
             source: service.node.id,
             target: rid,
-            type: import_types5.EdgeType.CONTAINS,
-            provenance: import_types5.Provenance.EXTRACTED,
-            confidence: (0, import_types5.confidenceForExtracted)("structural"),
+            type: import_types6.EdgeType.CONTAINS,
+            provenance: import_types6.Provenance.EXTRACTED,
+            confidence: (0, import_types6.confidenceForExtracted)("structural"),
             evidence: {
               file: relFile,
               line: route.line,
@@ -3235,7 +3933,7 @@ async function addRoutes(graph, services) {
 
 // src/columns.ts
 init_cjs_shims();
-var import_types6 = require("@neat.is/types");
+var import_types7 = require("@neat.is/types");
 var OBSERVED_COLUMN_CONFIDENCE = 0.9;
 function normalizeProvenances(provenances) {
   return [...new Set(provenances)].sort();
@@ -3263,10 +3961,10 @@ function foldColumns(existing, names, provenance, confidence) {
   return out;
 }
 function columnIsDeclared(col) {
-  return col.provenances.includes(import_types6.Provenance.EXTRACTED);
+  return col.provenances.includes(import_types7.Provenance.EXTRACTED);
 }
 function columnIsObserved(col) {
-  return col.provenances.includes(import_types6.Provenance.OBSERVED);
+  return col.provenances.includes(import_types7.Provenance.OBSERVED);
 }
 
 // src/ingest.ts
@@ -3489,7 +4187,7 @@ function languageForExt(relPath) {
 function relPathForRuntimeFile(filepath, serviceNode, scanPath) {
   let p = toPosix2(filepath).replace(/^file:\/\//, "");
   if (scanPath && scanPath.length > 0) {
-    const absRoot = toPosix2(import_node_path8.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
+    const absRoot = toPosix2(import_node_path9.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
     const anchor = absRoot.endsWith("/") ? absRoot : `${absRoot}/`;
     if (p.startsWith(anchor)) return p.slice(anchor.length);
   }
@@ -3517,10 +4215,10 @@ function resolveDistToSrc(absFilepath, line) {
     entry2 = null;
     const mapPath = `${absFilepath}.map`;
     try {
-      if ((0, import_node_fs7.existsSync)(mapPath)) {
-        const raw = JSON.parse((0, import_node_fs7.readFileSync)(mapPath, "utf8"));
+      if ((0, import_node_fs8.existsSync)(mapPath)) {
+        const raw = JSON.parse((0, import_node_fs8.readFileSync)(mapPath, "utf8"));
         const consumer = new sourceMapJs.SourceMapConsumer(raw);
-        entry2 = { consumer, dir: import_node_path8.default.dirname(mapPath) };
+        entry2 = { consumer, dir: import_node_path9.default.dirname(mapPath) };
       }
     } catch {
       entry2 = null;
@@ -3535,7 +4233,7 @@ function resolveDistToSrc(absFilepath, line) {
     });
     if (!pos || !pos.source) return null;
     const root = entry2.consumer.sourceRoot ?? "";
-    const resolved = import_node_path8.default.resolve(entry2.dir, root, pos.source);
+    const resolved = import_node_path9.default.resolve(entry2.dir, root, pos.source);
     return { filepath: resolved, ...pos.line ? { line: pos.line } : {} };
   } catch {
     return null;
@@ -3568,11 +4266,11 @@ function callSiteFromSpan(span, serviceNode, scanPath) {
   };
 }
 function reconcileObservedRelPath(graph, serviceName, relPath) {
-  if (graph.hasNode((0, import_types7.fileId)(serviceName, relPath))) return relPath;
+  if (graph.hasNode((0, import_types8.fileId)(serviceName, relPath))) return relPath;
   let best = null;
   graph.forEachNode((_id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types7.NodeType.FileNode || a.service !== serviceName) return;
+    if (a.type !== import_types8.NodeType.FileNode || a.service !== serviceName) return;
     if (a.discoveredVia === "otel") return;
     const p = a.path;
     if (!p) return;
@@ -3584,14 +4282,14 @@ function reconcileObservedRelPath(graph, serviceName, relPath) {
 }
 function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
   const svcAttrs = graph.hasNode(serviceNodeId) ? graph.getNodeAttributes(serviceNodeId) : void 0;
-  const canonicalService = svcAttrs && svcAttrs.type === import_types7.NodeType.ServiceNode && typeof svcAttrs.name === "string" ? svcAttrs.name : serviceName;
+  const canonicalService = svcAttrs && svcAttrs.type === import_types8.NodeType.ServiceNode && typeof svcAttrs.name === "string" ? svcAttrs.name : serviceName;
   const relPath = reconcileObservedRelPath(graph, canonicalService, callSite.relPath);
-  const fileNodeId = (0, import_types7.fileId)(canonicalService, relPath);
+  const fileNodeId = (0, import_types8.fileId)(canonicalService, relPath);
   if (!graph.hasNode(fileNodeId)) {
     const language = languageForExt(relPath);
     const node = {
       id: fileNodeId,
-      type: import_types7.NodeType.FileNode,
+      type: import_types8.NodeType.FileNode,
       service: canonicalService,
       path: relPath,
       ...language ? { language } : {},
@@ -3600,14 +4298,14 @@ function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
     };
     graph.addNode(fileNodeId, node);
   }
-  const containsId = makeObservedEdgeId(import_types7.EdgeType.CONTAINS, serviceNodeId, fileNodeId);
+  const containsId = makeObservedEdgeId(import_types8.EdgeType.CONTAINS, serviceNodeId, fileNodeId);
   if (!graph.hasEdge(containsId)) {
     const edge = {
       id: containsId,
       source: serviceNodeId,
       target: fileNodeId,
-      type: import_types7.EdgeType.CONTAINS,
-      provenance: import_types7.Provenance.OBSERVED
+      type: import_types8.EdgeType.CONTAINS,
+      provenance: import_types8.Provenance.OBSERVED
     };
     graph.addEdgeWithKey(containsId, serviceNodeId, fileNodeId, edge);
   }
@@ -3631,11 +4329,11 @@ function pickContainingSymbol(candidates, fn) {
   return [...candidates].sort(bySpan)[0].id;
 }
 function ensureObservedSymbolNode(graph, fileNodeId, service, relPath, fn, line) {
-  const sid = (0, import_types7.symbolId)(service, relPath, fn);
+  const sid = (0, import_types8.symbolId)(service, relPath, fn);
   if (!graph.hasNode(sid)) {
     const node = {
       id: sid,
-      type: import_types7.NodeType.SymbolNode,
+      type: import_types8.NodeType.SymbolNode,
       kind: "function",
       qualname: fn,
       span: { startLine: line, endLine: line },
@@ -3645,14 +4343,14 @@ function ensureObservedSymbolNode(graph, fileNodeId, service, relPath, fn, line)
     };
     graph.addNode(sid, node);
   }
-  const containsId = makeObservedEdgeId(import_types7.EdgeType.CONTAINS, fileNodeId, sid);
+  const containsId = makeObservedEdgeId(import_types8.EdgeType.CONTAINS, fileNodeId, sid);
   if (!graph.hasEdge(containsId)) {
     const edge = {
       id: containsId,
       source: fileNodeId,
       target: sid,
-      type: import_types7.EdgeType.CONTAINS,
-      provenance: import_types7.Provenance.OBSERVED
+      type: import_types8.EdgeType.CONTAINS,
+      provenance: import_types8.Provenance.OBSERVED
     };
     graph.addEdgeWithKey(containsId, fileNodeId, sid, edge);
   }
@@ -3664,9 +4362,9 @@ function landObservedSymbol(graph, fileNodeId, service, relPath, callSite) {
   let sawSymbol = false;
   const candidates = [];
   graph.forEachOutboundEdge(fileNodeId, (_edge, edgeAttrs, _source, target) => {
-    if (edgeAttrs.type !== import_types7.EdgeType.CONTAINS) return;
+    if (edgeAttrs.type !== import_types8.EdgeType.CONTAINS) return;
     const t = graph.getNodeAttributes(target);
-    if (t.type !== import_types7.NodeType.SymbolNode) return;
+    if (t.type !== import_types8.NodeType.SymbolNode) return;
     sawSymbol = true;
     if (line >= t.span.startLine && line <= t.span.endLine) {
       candidates.push({ id: target, symbol: t });
@@ -3679,17 +4377,17 @@ function landObservedSymbol(graph, fileNodeId, service, relPath, callSite) {
   return fileNodeId;
 }
 function makeObservedEdgeId(type, source, target) {
-  return (0, import_types7.observedEdgeId)(source, target, type);
+  return (0, import_types8.observedEdgeId)(source, target, type);
 }
 function makeInferredEdgeId(type, source, target) {
-  return (0, import_types7.inferredEdgeId)(source, target, type);
+  return (0, import_types8.inferredEdgeId)(source, target, type);
 }
 var INFERRED_CONFIDENCE = 0.6;
 var STITCH_MAX_DEPTH = 2;
 var STITCH_EDGE_TYPES = /* @__PURE__ */ new Set([
-  import_types7.EdgeType.CALLS,
-  import_types7.EdgeType.CONNECTS_TO,
-  import_types7.EdgeType.DEPENDS_ON
+  import_types8.EdgeType.CALLS,
+  import_types8.EdgeType.CONNECTS_TO,
+  import_types8.EdgeType.DEPENDS_ON
 ]);
 var WIRE_SPAN_KIND_CLIENT = 3;
 var WIRE_SPAN_KIND_PRODUCER = 4;
@@ -3705,11 +4403,11 @@ function spanServesGraphqlOperation(kind) {
   return kind !== WIRE_SPAN_KIND_CLIENT && kind !== WIRE_SPAN_KIND_PRODUCER && kind !== WIRE_SPAN_KIND_CONSUMER;
 }
 function ensureGraphqlOperationNode(graph, serviceName, operationType, operationName) {
-  const id = (0, import_types7.graphqlOperationId)(serviceName, operationType, operationName);
+  const id = (0, import_types8.graphqlOperationId)(serviceName, operationType, operationName);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.GraphQLOperationNode,
+    type: import_types8.NodeType.GraphQLOperationNode,
     name: operationName,
     service: serviceName,
     operationType: operationType.toLowerCase(),
@@ -3723,11 +4421,11 @@ function spanServesGrpcMethod(kind) {
   return kind !== WIRE_SPAN_KIND_CLIENT && kind !== WIRE_SPAN_KIND_PRODUCER && kind !== WIRE_SPAN_KIND_CONSUMER;
 }
 function ensureGrpcMethodNode(graph, rpcService, rpcMethod) {
-  const id = (0, import_types7.grpcMethodId)(rpcService, rpcMethod);
+  const id = (0, import_types8.grpcMethodId)(rpcService, rpcMethod);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.GrpcMethodNode,
+    type: import_types8.NodeType.GrpcMethodNode,
     name: `${rpcService}/${rpcMethod}`,
     rpcService,
     rpcMethod,
@@ -3740,11 +4438,11 @@ function spanServesWebsocketChannel(kind) {
   return kind !== WIRE_SPAN_KIND_CLIENT && kind !== WIRE_SPAN_KIND_PRODUCER && kind !== WIRE_SPAN_KIND_CONSUMER;
 }
 function ensureWebsocketChannelNode(graph, serviceName, channel) {
-  const id = (0, import_types7.websocketChannelId)(serviceName, channel);
+  const id = (0, import_types8.websocketChannelId)(serviceName, channel);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.WebSocketChannelNode,
+    type: import_types8.NodeType.WebSocketChannelNode,
     name: channel,
     service: serviceName,
     channel,
@@ -3757,11 +4455,11 @@ function messagingDestinationKind(system) {
   return `${system}-topic`;
 }
 function ensureMessagingDestinationNode(graph, system, destination) {
-  const id = (0, import_types7.infraId)(messagingDestinationKind(system), destination);
+  const id = (0, import_types8.infraId)(messagingDestinationKind(system), destination);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.InfraNode,
+    type: import_types8.NodeType.InfraNode,
     name: destination,
     provider: "self",
     kind: messagingDestinationKind(system)
@@ -3805,9 +4503,9 @@ function lookupParentSpan(traceId, parentSpanId, now) {
   };
 }
 function resolveServiceId(graph, host, env) {
-  const envTagged = (0, import_types7.serviceId)(host, env);
+  const envTagged = (0, import_types8.serviceId)(host, env);
   if (graph.hasNode(envTagged)) return envTagged;
-  const envLess = (0, import_types7.serviceId)(host);
+  const envLess = (0, import_types8.serviceId)(host);
   if (envLess !== envTagged && graph.hasNode(envLess)) return envLess;
   let sameEnv = null;
   let envLessMatch = null;
@@ -3815,7 +4513,7 @@ function resolveServiceId(graph, host, env) {
   graph.forEachNode((id, attrs) => {
     if (sameEnv) return;
     const a = attrs;
-    if (a.type !== import_types7.NodeType.ServiceNode) return;
+    if (a.type !== import_types8.NodeType.ServiceNode) return;
     const matchesByName = a.name === host;
     const matchesByAlias = a.aliases ? a.aliases.includes(host) : false;
     if (!matchesByName && !matchesByAlias) return;
@@ -3830,14 +4528,14 @@ function resolveServiceId(graph, host, env) {
   return sameEnv ?? envLessMatch ?? anyMatch;
 }
 function frontierIdFor(host) {
-  return (0, import_types7.frontierId)(host);
+  return (0, import_types8.frontierId)(host);
 }
 function ensureServiceNode(graph, serviceName, env) {
-  const id = (0, import_types7.serviceId)(serviceName, env);
+  const id = (0, import_types8.serviceId)(serviceName, env);
   if (graph.hasNode(id)) return id;
   const wanted = serviceName.toLowerCase();
   const extractedId = graph.findNode((_nid, attrs) => {
-    if (attrs.type !== import_types7.NodeType.ServiceNode) return false;
+    if (attrs.type !== import_types8.NodeType.ServiceNode) return false;
     const svc = attrs;
     if (svc.discoveredVia === "otel") return false;
     return typeof svc.name === "string" && svc.name.toLowerCase() === wanted;
@@ -3845,7 +4543,7 @@ function ensureServiceNode(graph, serviceName, env) {
   if (extractedId) return extractedId;
   const node = {
     id,
-    type: import_types7.NodeType.ServiceNode,
+    type: import_types8.NodeType.ServiceNode,
     name: serviceName,
     language: "unknown",
     discoveredVia: "otel",
@@ -3855,11 +4553,11 @@ function ensureServiceNode(graph, serviceName, env) {
   return id;
 }
 function ensureInfraNode(graph, kind, name, provider) {
-  const id = (0, import_types7.infraId)(kind, name);
+  const id = (0, import_types8.infraId)(kind, name);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.InfraNode,
+    type: import_types8.NodeType.InfraNode,
     name,
     provider,
     kind
@@ -3871,7 +4569,7 @@ var COLUMN_BEARING_INFRA_KINDS = /* @__PURE__ */ new Set(["sql-table", "supabase
 function mergeColumnsAt(graph, tableNodeId, columns, provenance, confidence) {
   if (!columns || columns.length === 0 || !graph.hasNode(tableNodeId)) return;
   const node = graph.getNodeAttributes(tableNodeId);
-  if (node.type !== import_types7.NodeType.InfraNode || !node.kind || !COLUMN_BEARING_INFRA_KINDS.has(node.kind)) {
+  if (node.type !== import_types8.NodeType.InfraNode || !node.kind || !COLUMN_BEARING_INFRA_KINDS.has(node.kind)) {
     return;
   }
   graph.replaceNodeAttributes(tableNodeId, {
@@ -3880,14 +4578,14 @@ function mergeColumnsAt(graph, tableNodeId, columns, provenance, confidence) {
   });
 }
 function mergeObservedColumns(graph, tableNodeId, columns) {
-  mergeColumnsAt(graph, tableNodeId, columns, import_types7.Provenance.OBSERVED, OBSERVED_COLUMN_CONFIDENCE);
+  mergeColumnsAt(graph, tableNodeId, columns, import_types8.Provenance.OBSERVED, OBSERVED_COLUMN_CONFIDENCE);
 }
 function ensureDatabaseNode(graph, host, engine) {
-  const id = (0, import_types7.databaseId)(host);
+  const id = (0, import_types8.databaseId)(host);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.DatabaseNode,
+    type: import_types8.NodeType.DatabaseNode,
     name: host,
     engine,
     engineVersion: "unknown",
@@ -3899,11 +4597,11 @@ function ensureDatabaseNode(graph, host, engine) {
   return id;
 }
 function ensureLocalDatabaseNode(graph, serviceName, name, engine) {
-  const id = (0, import_types7.localDatabaseId)(serviceName, name);
+  const id = (0, import_types8.localDatabaseId)(serviceName, name);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types7.NodeType.DatabaseNode,
+    type: import_types8.NodeType.DatabaseNode,
     name,
     engine,
     engineVersion: "unknown",
@@ -3918,17 +4616,17 @@ function findDeclaredDatabaseForService(graph, serviceNodeId, engine) {
   const sources = [serviceNodeId];
   for (const edgeId of graph.outboundEdges(serviceNodeId)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type === import_types7.EdgeType.CONTAINS) sources.push(e.target);
+    if (e.type === import_types8.EdgeType.CONTAINS) sources.push(e.target);
   }
   const matches = /* @__PURE__ */ new Set();
   for (const src of sources) {
     if (!graph.hasNode(src)) continue;
     for (const edgeId of graph.outboundEdges(src)) {
       const edge = graph.getEdgeAttributes(edgeId);
-      if (edge.type !== import_types7.EdgeType.CONNECTS_TO || edge.provenance !== import_types7.Provenance.EXTRACTED) continue;
+      if (edge.type !== import_types8.EdgeType.CONNECTS_TO || edge.provenance !== import_types8.Provenance.EXTRACTED) continue;
       if (!graph.hasNode(edge.target)) continue;
       const target = graph.getNodeAttributes(edge.target);
-      if (target.type !== import_types7.NodeType.DatabaseNode || target.engine !== engine) continue;
+      if (target.type !== import_types8.NodeType.DatabaseNode || target.engine !== engine) continue;
       matches.add(edge.target);
     }
   }
@@ -3943,7 +4641,7 @@ function ensureFrontierNode(graph, host, ts) {
   }
   const node = {
     id,
-    type: import_types7.NodeType.FrontierNode,
+    type: import_types8.NodeType.FrontierNode,
     name: host,
     host,
     firstObserved: ts,
@@ -3967,11 +4665,11 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     };
     const updated = {
       ...existing,
-      provenance: import_types7.Provenance.OBSERVED,
+      provenance: import_types8.Provenance.OBSERVED,
       lastObserved: ts,
       callCount: newSpanCount,
       signal: newSignal,
-      confidence: (0, import_types7.confidenceForObservedSignal)(newSignal),
+      confidence: (0, import_types8.confidenceForObservedSignal)(newSignal),
       grain
       // backfills legacy edges that predate ADR-142
     };
@@ -3988,8 +4686,8 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     source,
     target,
     type,
-    provenance: import_types7.Provenance.OBSERVED,
-    confidence: (0, import_types7.confidenceForObservedSignal)(signal),
+    provenance: import_types8.Provenance.OBSERVED,
+    confidence: (0, import_types8.confidenceForObservedSignal)(signal),
     lastObserved: ts,
     callCount: 1,
     signal,
@@ -4011,9 +4709,9 @@ function stitchTrace(graph, sourceServiceId, ts) {
     const outbound = graph.outboundEdges(nodeId);
     for (const edgeId of outbound) {
       const edge = graph.getEdgeAttributes(edgeId);
-      if (edge.provenance !== import_types7.Provenance.EXTRACTED) continue;
+      if (edge.provenance !== import_types8.Provenance.EXTRACTED) continue;
       if (!STITCH_EDGE_TYPES.has(edge.type)) continue;
-      if (graph.hasEdge((0, import_types7.observedEdgeId)(edge.source, edge.target, edge.type))) continue;
+      if (graph.hasEdge((0, import_types8.observedEdgeId)(edge.source, edge.target, edge.type))) continue;
       upsertInferredEdge(graph, edge.type, edge.source, edge.target, ts);
       if (!visited.has(edge.target)) {
         visited.add(edge.target);
@@ -4035,23 +4733,23 @@ function upsertInferredEdge(graph, type, source, target, ts) {
     source,
     target,
     type,
-    provenance: import_types7.Provenance.INFERRED,
+    provenance: import_types8.Provenance.INFERRED,
     confidence: INFERRED_CONFIDENCE,
     lastObserved: ts
   };
   graph.addEdgeWithKey(id, source, target, edge);
 }
 async function appendErrorEvent(ctx, ev) {
-  await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(ctx.errorsPath), { recursive: true });
-  await import_node_fs7.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(ctx.errorsPath), { recursive: true });
+  await import_node_fs8.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
 function incidentAffectedNode(span, graph, scanPath) {
-  const sid = (0, import_types7.serviceId)(span.service, span.env);
+  const sid = (0, import_types8.serviceId)(span.service, span.env);
   const serviceNode = graph && graph.hasNode(sid) ? graph.getNodeAttributes(sid) : void 0;
   const callSite = callSiteFromSpan(span, serviceNode, scanPath);
   if (callSite) {
     const relPath = graph ? reconcileObservedRelPath(graph, span.service, callSite.relPath) : callSite.relPath;
-    return (0, import_types7.fileId)(span.service, relPath);
+    return (0, import_types8.fileId)(span.service, relPath);
   }
   return sid;
 }
@@ -4084,8 +4782,8 @@ function makeErrorSpanWriter(errorsPath, graph, scanPath) {
   return async (span) => {
     const ev = buildErrorEventForReceiver(span, graph, scanPath);
     if (!ev) return;
-    await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(errorsPath), { recursive: true });
-    await import_node_fs7.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+    await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(errorsPath), { recursive: true });
+    await import_node_fs8.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
   };
 }
 async function recordFailingResponseIncident(ctx, span, affectedNode, timestamp, statusCode, count, firstTimestamp) {
@@ -4176,7 +4874,7 @@ function findRouteNodeByHttpRoute(graph, serviceName, method, httpRoute) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types7.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types8.NodeType.RouteNode || a.service !== serviceName) return;
     if (m && a.method !== "ALL" && a.method !== m) return;
     if (normalizePathTemplate(a.pathTemplate) === target) found = id;
   });
@@ -4207,7 +4905,7 @@ async function handleSpan(ctx, span) {
       let targetId;
       if (host) {
         ensureDatabaseNode(ctx.graph, host, span.dbSystem);
-        targetId = (0, import_types7.databaseId)(host);
+        targetId = (0, import_types8.databaseId)(host);
       } else {
         const declared = findDeclaredDatabaseForService(ctx.graph, sourceId, span.dbSystem);
         if (declared) {
@@ -4224,7 +4922,7 @@ async function handleSpan(ctx, span) {
       }
       const result = upsertObservedEdge(
         ctx.graph,
-        import_types7.EdgeType.CONNECTS_TO,
+        import_types8.EdgeType.CONNECTS_TO,
         observedSource(),
         targetId,
         ts,
@@ -4236,7 +4934,7 @@ async function handleSpan(ctx, span) {
         const collectionId = ensureInfraNode(ctx.graph, "mongodb-collection", span.dbCollection, "self");
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           observedSource(),
           collectionId,
           ts,
@@ -4248,7 +4946,7 @@ async function handleSpan(ctx, span) {
         const tableId = ensureInfraNode(ctx.graph, "sql-table", span.dbTable, "self");
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           observedSource(),
           tableId,
           ts,
@@ -4264,7 +4962,7 @@ async function handleSpan(ctx, span) {
       span.messagingSystem,
       span.messagingDestination
     );
-    const edgeType = span.kind === WIRE_SPAN_KIND_CONSUMER ? import_types7.EdgeType.CONSUMES_FROM : import_types7.EdgeType.PUBLISHES_TO;
+    const edgeType = span.kind === WIRE_SPAN_KIND_CONSUMER ? import_types8.EdgeType.CONSUMES_FROM : import_types8.EdgeType.PUBLISHES_TO;
     const result = upsertObservedEdge(
       ctx.graph,
       edgeType,
@@ -4284,7 +4982,7 @@ async function handleSpan(ctx, span) {
     );
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types7.EdgeType.CONTAINS,
+      import_types8.EdgeType.CONTAINS,
       observedSource(),
       targetId,
       ts,
@@ -4296,7 +4994,7 @@ async function handleSpan(ctx, span) {
     const targetId = ensureGrpcMethodNode(ctx.graph, span.rpcService, span.rpcMethod);
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types7.EdgeType.CONTAINS,
+      import_types8.EdgeType.CONTAINS,
       observedSource(),
       targetId,
       ts,
@@ -4312,7 +5010,7 @@ async function handleSpan(ctx, span) {
     );
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types7.EdgeType.CONNECTS_TO,
+      import_types8.EdgeType.CONNECTS_TO,
       observedSource(),
       targetId,
       ts,
@@ -4328,7 +5026,7 @@ async function handleSpan(ctx, span) {
       if (targetId && targetId !== sourceId) {
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           observedSource(),
           targetId,
           ts,
@@ -4341,7 +5039,7 @@ async function handleSpan(ctx, span) {
         const frontierNodeId = ensureFrontierNode(ctx.graph, host, ts);
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           observedSource(),
           frontierNodeId,
           ts,
@@ -4367,7 +5065,7 @@ async function handleSpan(ctx, span) {
         } : void 0;
         upsertObservedEdge(
           ctx.graph,
-          import_types7.EdgeType.CALLS,
+          import_types8.EdgeType.CALLS,
           fallbackSource,
           sourceId,
           ts,
@@ -4386,7 +5084,7 @@ async function handleSpan(ctx, span) {
     );
     if (routeNodeId) {
       const routeSvc = ctx.graph.getNodeAttributes(routeNodeId).service;
-      upsertObservedEdge(ctx.graph, import_types7.EdgeType.CONTAINS, (0, import_types7.serviceId)(routeSvc), routeNodeId, ts, isError);
+      upsertObservedEdge(ctx.graph, import_types8.EdgeType.CONTAINS, (0, import_types8.serviceId)(routeSvc), routeNodeId, ts, isError);
     }
   }
   if (span.statusCode === 2) {
@@ -4425,7 +5123,7 @@ function promoteFrontierNodes(graph, opts = {}) {
   const aliasIndex = /* @__PURE__ */ new Map();
   graph.forEachNode((id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types7.NodeType.ServiceNode) return;
+    if (a.type !== import_types8.NodeType.ServiceNode) return;
     aliasIndex.set(a.name, id);
     if (a.aliases) {
       for (const alias of a.aliases) aliasIndex.set(alias, id);
@@ -4434,7 +5132,7 @@ function promoteFrontierNodes(graph, opts = {}) {
   const toPromote = [];
   graph.forEachNode((id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types7.NodeType.FrontierNode) return;
+    if (a.type !== import_types8.NodeType.FrontierNode) return;
     const target = aliasIndex.get(a.host);
     if (!target) return;
     if (target === id) return;
@@ -4468,7 +5166,7 @@ function rewireFrontierEdges(graph, frontierId2, serviceId7) {
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
   graph.dropEdge(oldEdgeId);
-  const newId = edge.provenance === import_types7.Provenance.OBSERVED ? (0, import_types7.observedEdgeId)(newSource, newTarget, edge.type) : edge.provenance === import_types7.Provenance.INFERRED ? (0, import_types7.inferredEdgeId)(newSource, newTarget, edge.type) : (0, import_types7.extractedEdgeId)(newSource, newTarget, edge.type);
+  const newId = edge.provenance === import_types8.Provenance.OBSERVED ? (0, import_types8.observedEdgeId)(newSource, newTarget, edge.type) : edge.provenance === import_types8.Provenance.INFERRED ? (0, import_types8.inferredEdgeId)(newSource, newTarget, edge.type) : (0, import_types8.extractedEdgeId)(newSource, newTarget, edge.type);
   if (graph.hasEdge(newId)) {
     const existing = graph.getEdgeAttributes(newId);
     const merged = {
@@ -4502,12 +5200,12 @@ async function markStaleEdges(graph, options = {}) {
   const project = options.project ?? DEFAULT_PROJECT;
   graph.forEachEdge((id, attrs) => {
     const e = attrs;
-    if (e.provenance !== import_types7.Provenance.OBSERVED) return;
+    if (e.provenance !== import_types8.Provenance.OBSERVED) return;
     if (!e.lastObserved) return;
     const threshold = thresholdForEdgeType(e.type, thresholds);
     const age = now - new Date(e.lastObserved).getTime();
     if (age > threshold) {
-      const updated = { ...e, provenance: import_types7.Provenance.STALE, confidence: 0.3 };
+      const updated = { ...e, provenance: import_types8.Provenance.STALE, confidence: 0.3 };
       graph.replaceEdgeAttributes(id, updated);
       events.push({
         edgeId: id,
@@ -4524,8 +5222,8 @@ async function markStaleEdges(graph, options = {}) {
         project,
         payload: {
           edgeId: id,
-          from: import_types7.Provenance.OBSERVED,
-          to: import_types7.Provenance.STALE
+          from: import_types8.Provenance.OBSERVED,
+          to: import_types8.Provenance.STALE
         }
       });
     }
@@ -4536,13 +5234,13 @@ async function markStaleEdges(graph, options = {}) {
   return { count: events.length, events };
 }
 async function appendStaleEvents(staleEventsPath, events) {
-  await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(staleEventsPath), { recursive: true });
+  await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(staleEventsPath), { recursive: true });
   const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await import_node_fs7.promises.appendFile(staleEventsPath, lines, "utf8");
+  await import_node_fs8.promises.appendFile(staleEventsPath, lines, "utf8");
 }
 async function readStaleEvents(staleEventsPath) {
   try {
-    const raw = await import_node_fs7.promises.readFile(staleEventsPath, "utf8");
+    const raw = await import_node_fs8.promises.readFile(staleEventsPath, "utf8");
     return raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
   } catch (err) {
     if (err.code === "ENOENT") return [];
@@ -4576,7 +5274,7 @@ function startStalenessLoop(graph, options = {}) {
 }
 async function readErrorEvents(errorsPath) {
   try {
-    const raw = await import_node_fs7.promises.readFile(errorsPath, "utf8");
+    const raw = await import_node_fs8.promises.readFile(errorsPath, "utf8");
     const events = raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
     return dedupeIncidents(events);
   } catch (err) {
@@ -4634,7 +5332,7 @@ function mergeSnapshot(graph, snapshot) {
   const validEdges = [];
   for (const node of incomingNodes) {
     if (node.attributes === void 0) continue;
-    const parsed = import_types7.GraphNodeSchema.safeParse(node.attributes);
+    const parsed = import_types8.GraphNodeSchema.safeParse(node.attributes);
     if (!parsed.success) {
       issues.push(`node "${node.key}": ${describeZodIssues(parsed.error)}`);
       continue;
@@ -4643,7 +5341,7 @@ function mergeSnapshot(graph, snapshot) {
   }
   for (const edge of incomingEdges) {
     if (edge.attributes === void 0) continue;
-    const parsed = import_types7.GraphEdgeSchema.safeParse(edge.attributes);
+    const parsed = import_types8.GraphEdgeSchema.safeParse(edge.attributes);
     if (!parsed.success) {
       const label = edge.key ?? `${edge.source}->${edge.target}`;
       issues.push(`edge "${label}": ${describeZodIssues(parsed.error)}`);
@@ -4673,16 +5371,16 @@ function mergeSnapshot(graph, snapshot) {
 
 // src/extract/services.ts
 init_cjs_shims();
-var import_node_fs11 = require("fs");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_fs12 = require("fs");
+var import_node_path13 = __toESM(require("path"), 1);
 var import_ignore = __toESM(require("ignore"), 1);
 var import_minimatch2 = require("minimatch");
-var import_types9 = require("@neat.is/types");
+var import_types10 = require("@neat.is/types");
 
 // src/extract/python.ts
 init_cjs_shims();
-var import_node_fs8 = require("fs");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
 var import_smol_toml = require("smol-toml");
 var REQUIREMENT_LINE = /^\s*([A-Za-z0-9_.-]+)(?:\[[^\]]*\])?\s*(?:(==)\s*([A-Za-z0-9_.+-]+))?/;
 function parseRequirementsTxt(content) {
@@ -4715,25 +5413,25 @@ function depsFromPyProject(pyproject) {
   return out;
 }
 async function discoverPythonService(serviceDir) {
-  const pyprojectPath = import_node_path9.default.join(serviceDir, "pyproject.toml");
-  const requirementsPath = import_node_path9.default.join(serviceDir, "requirements.txt");
-  const setupPath = import_node_path9.default.join(serviceDir, "setup.py");
+  const pyprojectPath = import_node_path10.default.join(serviceDir, "pyproject.toml");
+  const requirementsPath = import_node_path10.default.join(serviceDir, "requirements.txt");
+  const setupPath = import_node_path10.default.join(serviceDir, "setup.py");
   const hasPyproject = await exists(pyprojectPath);
   const hasRequirements = await exists(requirementsPath);
   const hasSetup = await exists(setupPath);
   if (!hasPyproject && !hasRequirements && !hasSetup) return null;
-  let name = import_node_path9.default.basename(serviceDir);
+  let name = import_node_path10.default.basename(serviceDir);
   let version;
   const dependencies = {};
   if (hasPyproject) {
-    const raw = await import_node_fs8.promises.readFile(pyprojectPath, "utf8");
+    const raw = await import_node_fs9.promises.readFile(pyprojectPath, "utf8");
     const pyproject = (0, import_smol_toml.parse)(raw);
     name = pyproject.project?.name ?? pyproject.tool?.poetry?.name ?? name;
     version = pyproject.project?.version ?? pyproject.tool?.poetry?.version ?? void 0;
     Object.assign(dependencies, depsFromPyProject(pyproject));
   }
   if (hasRequirements) {
-    const raw = await import_node_fs8.promises.readFile(requirementsPath, "utf8");
+    const raw = await import_node_fs9.promises.readFile(requirementsPath, "utf8");
     Object.assign(dependencies, parseRequirementsTxt(raw));
   }
   return { name, version, dependencies };
@@ -4748,9 +5446,9 @@ function pythonToPackage(service) {
 
 // src/extract/go.ts
 init_cjs_shims();
-var import_node_fs9 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
-var import_types8 = require("@neat.is/types");
+var import_node_fs10 = require("fs");
+var import_node_path11 = __toESM(require("path"), 1);
+var import_types9 = require("@neat.is/types");
 function parseGoMod(source) {
   const module2 = source.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
   if (!module2) return null;
@@ -4769,7 +5467,7 @@ function parseGoMod(source) {
 async function discoverGoService(scanPath, dir) {
   let raw;
   try {
-    raw = await import_node_fs9.promises.readFile(import_node_path10.default.join(dir, "go.mod"), "utf8");
+    raw = await import_node_fs10.promises.readFile(import_node_path11.default.join(dir, "go.mod"), "utf8");
   } catch {
     return null;
   }
@@ -4778,12 +5476,12 @@ async function discoverGoService(scanPath, dir) {
   const name = mod.module.split("/").filter(Boolean).pop() ?? mod.module;
   const pkg = { name, dependencies: mod.dependencies };
   const node = {
-    id: (0, import_types8.serviceId)(name),
-    type: import_types8.NodeType.ServiceNode,
+    id: (0, import_types9.serviceId)(name),
+    type: import_types9.NodeType.ServiceNode,
     name,
     language: "go",
     dependencies: mod.dependencies,
-    repoPath: import_node_path10.default.relative(scanPath, dir),
+    repoPath: import_node_path11.default.relative(scanPath, dir),
     ...mod.dependencies["github.com/gin-gonic/gin"] ? { framework: "gin" } : {}
   };
   return { pkg, dir, node };
@@ -4791,17 +5489,17 @@ async function discoverGoService(scanPath, dir) {
 
 // src/extract/owners.ts
 init_cjs_shims();
-var import_node_fs10 = require("fs");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs11 = require("fs");
+var import_node_path12 = __toESM(require("path"), 1);
 var import_minimatch = require("minimatch");
 async function loadCodeowners(scanPath) {
   const candidates = [
-    import_node_path11.default.join(scanPath, "CODEOWNERS"),
-    import_node_path11.default.join(scanPath, ".github", "CODEOWNERS")
+    import_node_path12.default.join(scanPath, "CODEOWNERS"),
+    import_node_path12.default.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists(file)) {
-      const raw = await import_node_fs10.promises.readFile(file, "utf8");
+      const raw = await import_node_fs11.promises.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -4819,7 +5517,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(import_node_path11.default.sep).join("/");
+  const normalized = repoPath.split(import_node_path12.default.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -4835,7 +5533,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = import_node_path11.default.join(serviceDir, "package.json");
+  const pkgPath = import_node_path12.default.join(serviceDir, "package.json");
   if (!await exists(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -4847,985 +5545,601 @@ async function readPackageJsonAuthor(serviceDir) {
     return null;
   }
 }
-async function computeServiceOwner(codeowners, repoPath, serviceDir) {
-  if (codeowners && repoPath !== void 0) {
-    const owner = matchOwner(codeowners, repoPath);
-    if (owner) return owner;
-  }
-  const author = await readPackageJsonAuthor(serviceDir);
-  return author ?? void 0;
-}
-
-// src/extract/services.ts
-var DEFAULT_SCAN_DEPTH = 5;
-function parseScanDepth() {
-  const raw = process.env.NEAT_SCAN_DEPTH;
-  if (!raw) return DEFAULT_SCAN_DEPTH;
-  const n = Number.parseInt(raw, 10);
-  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_SCAN_DEPTH;
-}
-function workspaceGlobs(pkg) {
-  const ws = pkg.workspaces;
-  if (!ws) return null;
-  if (Array.isArray(ws)) return ws.length > 0 ? ws : null;
-  if (Array.isArray(ws.packages)) return ws.packages.length > 0 ? ws.packages : null;
-  return null;
-}
-async function hasPythonManifest(dir) {
-  return await exists(import_node_path12.default.join(dir, "pyproject.toml")) || await exists(import_node_path12.default.join(dir, "requirements.txt")) || await exists(import_node_path12.default.join(dir, "setup.py"));
-}
-async function hasGoManifest(dir) {
-  return exists(import_node_path12.default.join(dir, "go.mod"));
-}
-async function loadGitignore(scanPath) {
-  const gitignorePath = import_node_path12.default.join(scanPath, ".gitignore");
-  if (!await exists(gitignorePath)) return null;
-  const raw = await import_node_fs11.promises.readFile(gitignorePath, "utf8");
-  return (0, import_ignore.default)().add(raw);
-}
-async function walkDirs(start, scanPath, options, visit) {
-  async function recurse(current, depth) {
-    if (depth > options.maxDepth) return;
-    const entries = await import_node_fs11.promises.readdir(current, { withFileTypes: true }).catch(() => []);
-    for (const entry2 of entries) {
-      if (!entry2.isDirectory()) continue;
-      if (IGNORED_DIRS.has(entry2.name)) continue;
-      const child = import_node_path12.default.join(current, entry2.name);
-      if (options.ig) {
-        const rel = import_node_path12.default.relative(scanPath, child).split(import_node_path12.default.sep).join("/");
-        if (rel && options.ig.ignores(rel + "/")) continue;
-      }
-      if (await isPythonVenvDir(child)) continue;
-      await visit(child);
-      await recurse(child, depth + 1);
-    }
-  }
-  await recurse(start, 0);
-}
-async function expandWorkspaceGlobs(scanPath, globs) {
-  const found = /* @__PURE__ */ new Set();
-  const scanDepth = parseScanDepth();
-  for (const raw of globs) {
-    const pattern = raw.replace(/^\.\//, "");
-    if (!pattern.includes("*")) {
-      const candidate = import_node_path12.default.join(scanPath, pattern);
-      if (await exists(import_node_path12.default.join(candidate, "package.json"))) found.add(candidate);
-      continue;
-    }
-    const segments = pattern.split("/");
-    const staticSegments = [];
-    for (const seg of segments) {
-      if (seg.includes("*")) break;
-      staticSegments.push(seg);
-    }
-    const start = import_node_path12.default.join(scanPath, ...staticSegments);
-    if (!await exists(start)) continue;
-    const hasDoubleStar = pattern.includes("**");
-    const walkDepth = hasDoubleStar ? scanDepth : Math.max(0, segments.length - staticSegments.length - 1);
-    await walkDirs(start, scanPath, { maxDepth: walkDepth, ig: null }, async (dir) => {
-      const rel = import_node_path12.default.relative(scanPath, dir).split(import_node_path12.default.sep).join("/");
-      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists(import_node_path12.default.join(dir, "package.json"))) {
-        found.add(dir);
-      }
-    });
-  }
-  return [...found];
-}
-function detectJsFramework(pkg) {
-  const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
-  if (deps["next"] !== void 0) return "next";
-  if (deps["remix"] !== void 0) return "remix";
-  for (const k of Object.keys(deps)) {
-    if (k.startsWith("@remix-run/")) return "remix";
-  }
-  if (deps["@sveltejs/kit"] !== void 0) return "sveltekit";
-  if (deps["nuxt"] !== void 0) return "nuxt";
-  if (deps["astro"] !== void 0) return "astro";
-  if (deps["@nestjs/core"] !== void 0) return "nestjs";
-  return void 0;
-}
-async function detectJsServiceLanguage(dir, pkg) {
-  const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
-  if (deps["typescript"] !== void 0) return "typescript";
-  const entries = await import_node_fs11.promises.readdir(dir).catch(() => []);
-  if (entries.some((name) => /^tsconfig(\..+)?\.json$/.test(name))) return "typescript";
-  return "javascript";
-}
-async function discoverNodeService(scanPath, dir) {
-  const pkgPath = import_node_path12.default.join(dir, "package.json");
-  if (!await exists(pkgPath)) return null;
-  let pkg;
-  try {
-    pkg = await readJson(pkgPath);
-  } catch (err) {
-    recordExtractionError("services", import_node_path12.default.relative(scanPath, pkgPath), err);
-    return null;
-  }
-  if (!pkg.name) return null;
-  const framework = detectJsFramework(pkg);
-  const language = await detectJsServiceLanguage(dir, pkg);
-  const node = {
-    id: (0, import_types9.serviceId)(pkg.name),
-    type: import_types9.NodeType.ServiceNode,
-    name: pkg.name,
-    language,
-    version: pkg.version,
-    dependencies: pkg.dependencies ?? {},
-    repoPath: import_node_path12.default.relative(scanPath, dir),
-    ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
-    ...framework ? { framework } : {}
-  };
-  return { pkg, dir, node };
-}
-async function discoverPyService(scanPath, dir) {
-  const py = await discoverPythonService(dir);
-  if (!py) return null;
-  const pkg = pythonToPackage(py);
-  const node = {
-    id: (0, import_types9.serviceId)(py.name),
-    type: import_types9.NodeType.ServiceNode,
-    name: py.name,
-    language: "python",
-    version: py.version,
-    dependencies: py.dependencies,
-    repoPath: import_node_path12.default.relative(scanPath, dir)
-  };
-  return { pkg, dir, node };
-}
-async function discoverServices(scanPath) {
-  const rootPkgPath = import_node_path12.default.join(scanPath, "package.json");
-  let rootPkg = null;
-  if (await exists(rootPkgPath)) {
-    try {
-      rootPkg = await readJson(rootPkgPath);
-    } catch (err) {
-      recordExtractionError(
-        "services workspaces",
-        import_node_path12.default.relative(scanPath, rootPkgPath),
-        err
-      );
-    }
-  }
-  const wsGlobs = rootPkg ? workspaceGlobs(rootPkg) : null;
-  const candidateDirs = [];
-  if (wsGlobs) {
-    candidateDirs.push(...await expandWorkspaceGlobs(scanPath, wsGlobs));
-  } else {
-    if (rootPkg && rootPkg.name) {
-      candidateDirs.push(scanPath);
-    } else if (await hasPythonManifest(scanPath) || await hasGoManifest(scanPath)) {
-      candidateDirs.push(scanPath);
-    }
-    const ig = await loadGitignore(scanPath);
-    await walkDirs(
-      scanPath,
-      scanPath,
-      { maxDepth: parseScanDepth(), ig },
-      async (dir) => {
-        if (await exists(import_node_path12.default.join(dir, "package.json"))) {
-          candidateDirs.push(dir);
-        } else if (await hasPythonManifest(dir) || await hasGoManifest(dir)) {
-          candidateDirs.push(dir);
-        }
-      }
-    );
-  }
-  candidateDirs.sort();
-  const seen = /* @__PURE__ */ new Map();
-  const out = [];
-  for (const dir of candidateDirs) {
-    const service = await discoverNodeService(scanPath, dir) ?? await discoverPyService(scanPath, dir) ?? await discoverGoService(scanPath, dir);
-    if (!service) continue;
-    const existingDir = seen.get(service.node.name);
-    if (existingDir !== void 0) {
-      const a = import_node_path12.default.relative(scanPath, existingDir) || ".";
-      const b = import_node_path12.default.relative(scanPath, dir) || ".";
-      console.warn(
-        `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
-      );
-      continue;
-    }
-    seen.set(service.node.name, dir);
-    out.push(service);
-  }
-  const codeowners = await loadCodeowners(scanPath);
-  for (const service of out) {
-    const owner = await computeServiceOwner(codeowners, service.node.repoPath, service.dir);
-    if (owner !== void 0) service.node.owner = owner;
-  }
-  return out;
-}
-function addServiceNodes(graph, services) {
-  let nodesAdded = 0;
-  for (const service of services) {
-    if (!graph.hasNode(service.node.id)) {
-      graph.addNode(service.node.id, { ...service.node, discoveredVia: "static" });
-      nodesAdded++;
-      continue;
-    }
-    const existing = graph.getNodeAttributes(service.node.id);
-    const mergedDiscoveredVia = existing.discoveredVia === "otel" ? "merged" : "static";
-    graph.replaceNodeAttributes(service.node.id, {
-      ...existing,
-      ...service.node,
-      discoveredVia: mergedDiscoveredVia
-    });
-  }
-  return nodesAdded;
-}
-
-// src/extract/aliases.ts
-init_cjs_shims();
-var import_node_path13 = __toESM(require("path"), 1);
-var import_node_fs12 = require("fs");
-var import_yaml2 = require("yaml");
-var import_types10 = require("@neat.is/types");
-var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
-  "Service",
-  "Deployment",
-  "StatefulSet",
-  "DaemonSet"
-]);
-function addAliases(graph, serviceId7, candidates) {
-  if (!graph.hasNode(serviceId7)) return;
-  const node = graph.getNodeAttributes(serviceId7);
-  if (node.type !== import_types10.NodeType.ServiceNode) return;
-  const set = new Set(node.aliases ?? []);
-  for (const c of candidates) {
-    if (!c) continue;
-    if (c === node.name) continue;
-    set.add(c);
-  }
-  if (set.size === 0) return;
-  const updated = { ...node, aliases: [...set].sort() };
-  graph.replaceNodeAttributes(serviceId7, updated);
-}
-function indexServicesByName(services) {
-  const map = /* @__PURE__ */ new Map();
-  for (const s of services) {
-    map.set(s.node.name, s.node.id);
-    map.set(import_node_path13.default.basename(s.dir), s.node.id);
-  }
-  return map;
-}
-async function collectComposeAliases(graph, scanPath, serviceIndex) {
-  let composePath = null;
-  for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path13.default.join(scanPath, name);
-    if (await exists(abs)) {
-      composePath = abs;
-      break;
-    }
-  }
-  if (!composePath) return;
-  let compose;
-  try {
-    compose = await readYaml(composePath);
-  } catch (err) {
-    recordExtractionError(
-      "aliases compose",
-      import_node_path13.default.relative(scanPath, composePath),
-      err
-    );
-    return;
-  }
-  if (!compose?.services) return;
-  for (const [composeName, svc] of Object.entries(compose.services)) {
-    const serviceId7 = serviceIndex.get(composeName);
-    if (!serviceId7) continue;
-    const aliases = /* @__PURE__ */ new Set([composeName]);
-    if (svc.container_name) aliases.add(svc.container_name);
-    if (svc.hostname) aliases.add(svc.hostname);
-    addAliases(graph, serviceId7, aliases);
-  }
-}
-var LABEL_KEYS = /* @__PURE__ */ new Set([
-  "service",
-  "service.name",
-  "app",
-  "app.name",
-  "com.docker.compose.service",
-  "org.opencontainers.image.title"
-]);
-function parseDockerfileLabels(content) {
-  const out = [];
-  const lineRegex = /^\s*label\s+(.+)$/i;
-  for (const raw of content.split("\n")) {
-    const m = lineRegex.exec(raw);
-    if (!m) continue;
-    const rest = m[1];
-    const pairRegex = /([\w.-]+)\s*=\s*("([^"]*)"|'([^']*)'|([^\s]+))/g;
-    let pair;
-    while ((pair = pairRegex.exec(rest)) !== null) {
-      const key = pair[1].toLowerCase();
-      if (!LABEL_KEYS.has(key)) continue;
-      const value = pair[3] ?? pair[4] ?? pair[5] ?? "";
-      if (value) out.push(value);
-    }
-  }
-  return out;
-}
-async function collectDockerfileAliases(graph, services) {
-  for (const service of services) {
-    const dockerfilePath = import_node_path13.default.join(service.dir, "Dockerfile");
-    if (!await exists(dockerfilePath)) continue;
-    let content;
-    try {
-      content = await import_node_fs12.promises.readFile(dockerfilePath, "utf8");
-    } catch (err) {
-      recordExtractionError("aliases dockerfile", dockerfilePath, err);
-      continue;
-    }
-    const aliases = parseDockerfileLabels(content);
-    if (aliases.length > 0) addAliases(graph, service.node.id, aliases);
-  }
-}
-async function walkYamlFiles(start, depth = 0, max = 5) {
-  if (depth > max) return [];
-  const out = [];
-  const entries = await import_node_fs12.promises.readdir(start, { withFileTypes: true }).catch(() => []);
-  for (const entry2 of entries) {
-    if (entry2.isDirectory()) {
-      if (IGNORED_DIRS.has(entry2.name)) continue;
-      const child = import_node_path13.default.join(start, entry2.name);
-      if (await isPythonVenvDir(child)) continue;
-      out.push(...await walkYamlFiles(child, depth + 1, max));
-    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path13.default.extname(entry2.name))) {
-      out.push(import_node_path13.default.join(start, entry2.name));
-    }
-  }
-  return out;
-}
-function k8sHostnames(name, namespace) {
-  const ns = namespace ?? "default";
-  return [
-    name,
-    `${name}.${ns}`,
-    `${name}.${ns}.svc`,
-    `${name}.${ns}.svc.cluster.local`
-  ];
-}
-function k8sServiceTarget(doc, byName) {
-  const selector = doc.spec?.selector;
-  const selectorApp = selector?.app ?? selector?.matchLabels?.app;
-  if (selectorApp && byName.has(selectorApp)) return byName.get(selectorApp);
-  const labelApp = doc.metadata?.labels?.app;
-  if (labelApp && byName.has(labelApp)) return byName.get(labelApp);
-  const metaName = doc.metadata?.name;
-  if (metaName && byName.has(metaName)) return byName.get(metaName);
-  return null;
-}
-async function collectK8sAliases(graph, scanPath, serviceIndex) {
-  const files = await walkYamlFiles(scanPath);
-  for (const file of files) {
-    const content = await import_node_fs12.promises.readFile(file, "utf8");
-    let docs;
-    try {
-      docs = (0, import_yaml2.parseAllDocuments)(content).map((d) => d.toJSON());
-    } catch {
-      continue;
-    }
-    for (const doc of docs) {
-      if (!doc?.kind || !doc.metadata?.name) continue;
-      if (!K8S_KINDS_WITH_HOSTNAMES.has(doc.kind)) continue;
-      const target = k8sServiceTarget(doc, serviceIndex);
-      if (!target) continue;
-      addAliases(graph, target, k8sHostnames(doc.metadata.name, doc.metadata.namespace));
-    }
-  }
-}
-async function addServiceAliases(graph, scanPath, services) {
-  const byName = indexServicesByName(services);
-  await collectComposeAliases(graph, scanPath, byName);
-  await collectDockerfileAliases(graph, services);
-  await collectK8sAliases(graph, scanPath, byName);
-}
-
-// src/extract/files.ts
-init_cjs_shims();
-var import_node_path14 = __toESM(require("path"), 1);
-async function addFiles(graph, services) {
-  let nodesAdded = 0;
-  let edgesAdded = 0;
-  for (const service of services) {
-    const filePaths = await walkSourceFiles(service.dir);
-    for (const filePath of filePaths) {
-      const relPath = toPosix(import_node_path14.default.relative(service.dir, filePath));
-      const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
-        graph,
-        service.pkg.name,
-        service.node.id,
-        relPath
-      );
-      nodesAdded += n;
-      edgesAdded += e;
-    }
-  }
-  return { nodesAdded, edgesAdded };
-}
-
-// src/extract/symbols.ts
-init_cjs_shims();
-var import_node_path15 = __toESM(require("path"), 1);
-var import_tree_sitter2 = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_javascript2 = __toESM(require("tree-sitter-javascript"), 1);
-var import_tree_sitter_typescript = __toESM(require("tree-sitter-typescript"), 1);
-var import_types11 = require("@neat.is/types");
-var PARSE_CHUNK2 = 16384;
-var GRAMMAR_BY_EXT = {
-  ".ts": import_tree_sitter_typescript.default.typescript,
-  ".tsx": import_tree_sitter_typescript.default.tsx,
-  ".js": import_tree_sitter_javascript2.default,
-  ".jsx": import_tree_sitter_javascript2.default,
-  ".mjs": import_tree_sitter_javascript2.default,
-  ".cjs": import_tree_sitter_javascript2.default
-};
-function parseSource2(parser, source) {
-  return parser.parse(
-    (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK2)
-  );
-}
-function methodName(node) {
-  const name = node.childForFieldName("name");
-  return name ? name.text : null;
-}
-function collectSymbolDefs(root) {
-  const out = [];
-  const push = (kind, qualname, node) => {
-    out.push({
-      kind,
-      qualname,
-      startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1
-    });
-  };
-  const visit = (node, classCtx) => {
-    switch (node.type) {
-      case "function_declaration":
-      case "generator_function_declaration": {
-        const name = node.childForFieldName("name")?.text;
-        if (name) push("function", name, node);
-        break;
-      }
-      case "class_declaration":
-      case "abstract_class_declaration":
-      case "class": {
-        const name = node.childForFieldName("name")?.text;
-        if (name) push("class", name, node);
-        const body = node.childForFieldName("body");
-        if (body) {
-          for (let i = 0; i < body.namedChildCount; i++) {
-            const child = body.namedChild(i);
-            if (child) visit(child, name ?? classCtx);
-          }
-        }
-        return;
-      }
-      case "method_definition": {
-        const name = methodName(node);
-        if (name) {
-          const kind = name === "constructor" ? "constructor" : "method";
-          push(kind, classCtx ? `${classCtx}.${name}` : name, node);
-        }
-        break;
-      }
-      case "variable_declarator": {
-        const value = node.childForFieldName("value");
-        if (value && (value.type === "arrow_function" || value.type === "function" || value.type === "function_expression" || value.type === "generator_function")) {
-          const nameNode = node.childForFieldName("name");
-          if (nameNode && nameNode.type === "identifier") {
-            push("function", nameNode.text, node);
-          }
-        }
-        break;
-      }
-    }
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child) visit(child, classCtx);
-    }
-  };
-  visit(root, void 0);
-  return out;
-}
-function disambiguate(defs) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const def of defs) counts.set(def.qualname, (counts.get(def.qualname) ?? 0) + 1);
-  const seen = /* @__PURE__ */ new Map();
-  return defs.map((def) => {
-    if ((counts.get(def.qualname) ?? 0) <= 1) return { def };
-    const ordinal = seen.get(def.qualname) ?? 0;
-    seen.set(def.qualname, ordinal + 1);
-    return { def, disambiguator: ordinal };
-  });
-}
-async function addSymbols(graph, services) {
-  const parsers = /* @__PURE__ */ new Map();
-  const parserForExt2 = (ext) => {
-    const grammar = GRAMMAR_BY_EXT[ext];
-    if (!grammar) return null;
-    let parser = parsers.get(ext);
-    if (!parser) {
-      parser = new import_tree_sitter2.default();
-      parser.setLanguage(grammar);
-      parsers.set(ext, parser);
-    }
-    return parser;
-  };
-  let nodesAdded = 0;
-  let edgesAdded = 0;
-  for (const service of services) {
-    const files = await loadSourceFiles(service.dir);
-    for (const file of files) {
-      const parser = parserForExt2(import_node_path15.default.extname(file.path));
-      if (!parser) continue;
-      const relPath = toPosix(import_node_path15.default.relative(service.dir, file.path));
-      let defs;
-      try {
-        const tree = parseSource2(parser, file.content);
-        defs = collectSymbolDefs(tree.rootNode);
-      } catch (err) {
-        recordExtractionError("symbol extraction", file.path, err);
-        continue;
-      }
-      if (defs.length === 0) continue;
-      const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
-        graph,
-        service.pkg.name,
-        service.node.id,
-        relPath
-      );
-      nodesAdded += fn;
-      edgesAdded += fe;
-      for (const { def, disambiguator } of disambiguate(defs)) {
-        const sid = (0, import_types11.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
-        if (!graph.hasNode(sid)) {
-          const node = {
-            id: sid,
-            type: import_types11.NodeType.SymbolNode,
-            kind: def.kind,
-            qualname: def.qualname,
-            span: { startLine: def.startLine, endLine: def.endLine },
-            service: service.pkg.name,
-            relPath,
-            discoveredVia: "static"
-          };
-          graph.addNode(sid, node);
-          nodesAdded++;
-        }
-        const containsId = (0, import_types11.extractedEdgeId)(fileNodeId, sid, import_types11.EdgeType.CONTAINS);
-        if (!graph.hasEdge(containsId)) {
-          const edge = {
-            id: containsId,
-            source: fileNodeId,
-            target: sid,
-            type: import_types11.EdgeType.CONTAINS,
-            provenance: import_types11.Provenance.EXTRACTED,
-            confidence: (0, import_types11.confidenceForExtracted)("structural"),
-            evidence: {
-              file: relPath,
-              line: def.startLine,
-              snippet: snippet(file.content, def.startLine)
-            }
-          };
-          graph.addEdgeWithKey(containsId, fileNodeId, sid, edge);
-          edgesAdded++;
-        }
-      }
-    }
+async function computeServiceOwner(codeowners, repoPath, serviceDir) {
+  if (codeowners && repoPath !== void 0) {
+    const owner = matchOwner(codeowners, repoPath);
+    if (owner) return owner;
   }
-  return { nodesAdded, edgesAdded };
+  const author = await readPackageJsonAuthor(serviceDir);
+  return author ?? void 0;
 }
 
-// src/extract/symbol-edges.ts
-init_cjs_shims();
-var import_node_path17 = __toESM(require("path"), 1);
-var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
-var import_types13 = require("@neat.is/types");
-
-// src/extract/imports.ts
-init_cjs_shims();
-var import_node_path16 = __toESM(require("path"), 1);
-var import_node_fs13 = require("fs");
-var import_tree_sitter3 = __toESM(require("tree-sitter"), 1);
-var import_tree_sitter_javascript3 = __toESM(require("tree-sitter-javascript"), 1);
-var import_tree_sitter_python2 = __toESM(require("tree-sitter-python"), 1);
-var import_tree_sitter_go2 = __toESM(require("tree-sitter-go"), 1);
-var import_types12 = require("@neat.is/types");
-var PARSE_CHUNK3 = 16384;
-function parseSource3(parser, source) {
-  return parser.parse(
-    (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK3)
-  );
+// src/extract/services.ts
+var DEFAULT_SCAN_DEPTH = 5;
+function parseScanDepth() {
+  const raw = process.env.NEAT_SCAN_DEPTH;
+  if (!raw) return DEFAULT_SCAN_DEPTH;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_SCAN_DEPTH;
 }
-function makeJsParser2() {
-  const p = new import_tree_sitter3.default();
-  p.setLanguage(import_tree_sitter_javascript3.default);
-  return p;
+function workspaceGlobs(pkg) {
+  const ws = pkg.workspaces;
+  if (!ws) return null;
+  if (Array.isArray(ws)) return ws.length > 0 ? ws : null;
+  if (Array.isArray(ws.packages)) return ws.packages.length > 0 ? ws.packages : null;
+  return null;
 }
-function makePyParser2() {
-  const p = new import_tree_sitter3.default();
-  p.setLanguage(import_tree_sitter_python2.default);
-  return p;
+async function hasPythonManifest(dir) {
+  return await exists(import_node_path13.default.join(dir, "pyproject.toml")) || await exists(import_node_path13.default.join(dir, "requirements.txt")) || await exists(import_node_path13.default.join(dir, "setup.py"));
 }
-function makeGoParser2() {
-  const p = new import_tree_sitter3.default();
-  p.setLanguage(import_tree_sitter_go2.default);
-  return p;
+async function hasGoManifest(dir) {
+  return exists(import_node_path13.default.join(dir, "go.mod"));
 }
-function stringLiteralText(node) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child?.type === "string_fragment") return child.text;
-  }
-  const raw = node.text;
-  if (raw.length >= 2) return raw.slice(1, -1);
-  return raw.length === 0 ? null : "";
+async function loadGitignore(scanPath) {
+  const gitignorePath = import_node_path13.default.join(scanPath, ".gitignore");
+  if (!await exists(gitignorePath)) return null;
+  const raw = await import_node_fs12.promises.readFile(gitignorePath, "utf8");
+  return (0, import_ignore.default)().add(raw);
 }
-function clipSnippet(text) {
-  const oneLine = text.split("\n")[0] ?? text;
-  return oneLine.length > 120 ? oneLine.slice(0, 120) : oneLine;
+async function walkDirs(start, scanPath, options, visit) {
+  async function recurse(current, depth) {
+    if (depth > options.maxDepth) return;
+    const entries = await import_node_fs12.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    for (const entry2 of entries) {
+      if (!entry2.isDirectory()) continue;
+      if (IGNORED_DIRS.has(entry2.name)) continue;
+      const child = import_node_path13.default.join(current, entry2.name);
+      if (options.ig) {
+        const rel = import_node_path13.default.relative(scanPath, child).split(import_node_path13.default.sep).join("/");
+        if (rel && options.ig.ignores(rel + "/")) continue;
+      }
+      if (await isPythonVenvDir(child)) continue;
+      await visit(child);
+      await recurse(child, depth + 1);
+    }
+  }
+  await recurse(start, 0);
 }
-function collectGoImports(node, out) {
-  if (node.type === "import_spec") {
-    const pathNode = node.childForFieldName("path");
-    if (pathNode) {
-      const specifier = pathNode.text.replace(/^`|`$/g, "").replace(/^"|"$/g, "");
-      if (specifier) out.push({ specifier, line: node.startPosition.row + 1, snippet: clipSnippet(node.text) });
+async function expandWorkspaceGlobs(scanPath, globs) {
+  const found = /* @__PURE__ */ new Set();
+  const scanDepth = parseScanDepth();
+  for (const raw of globs) {
+    const pattern = raw.replace(/^\.\//, "");
+    if (!pattern.includes("*")) {
+      const candidate = import_node_path13.default.join(scanPath, pattern);
+      if (await exists(import_node_path13.default.join(candidate, "package.json"))) found.add(candidate);
+      continue;
     }
-    return;
+    const segments = pattern.split("/");
+    const staticSegments = [];
+    for (const seg of segments) {
+      if (seg.includes("*")) break;
+      staticSegments.push(seg);
+    }
+    const start = import_node_path13.default.join(scanPath, ...staticSegments);
+    if (!await exists(start)) continue;
+    const hasDoubleStar = pattern.includes("**");
+    const walkDepth = hasDoubleStar ? scanDepth : Math.max(0, segments.length - staticSegments.length - 1);
+    await walkDirs(start, scanPath, { maxDepth: walkDepth, ig: null }, async (dir) => {
+      const rel = import_node_path13.default.relative(scanPath, dir).split(import_node_path13.default.sep).join("/");
+      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists(import_node_path13.default.join(dir, "package.json"))) {
+        found.add(dir);
+      }
+    });
   }
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child) collectGoImports(child, out);
+  return [...found];
+}
+function detectJsFramework(pkg) {
+  const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  if (deps["next"] !== void 0) return "next";
+  if (deps["remix"] !== void 0) return "remix";
+  for (const k of Object.keys(deps)) {
+    if (k.startsWith("@remix-run/")) return "remix";
   }
+  if (deps["@sveltejs/kit"] !== void 0) return "sveltekit";
+  if (deps["nuxt"] !== void 0) return "nuxt";
+  if (deps["astro"] !== void 0) return "astro";
+  if (deps["@nestjs/core"] !== void 0) return "nestjs";
+  return void 0;
 }
-function collectJsImports(node, out) {
-  if (node.type === "import_statement") {
-    const source = node.childForFieldName("source");
-    if (source) {
-      const specifier = stringLiteralText(source);
-      if (specifier) {
-        out.push({ specifier, line: node.startPosition.row + 1, snippet: clipSnippet(node.text) });
-      }
+async function detectJsServiceLanguage(dir, pkg) {
+  const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  if (deps["typescript"] !== void 0) return "typescript";
+  const entries = await import_node_fs12.promises.readdir(dir).catch(() => []);
+  if (entries.some((name) => /^tsconfig(\..+)?\.json$/.test(name))) return "typescript";
+  return "javascript";
+}
+async function discoverNodeService(scanPath, dir) {
+  const pkgPath = import_node_path13.default.join(dir, "package.json");
+  if (!await exists(pkgPath)) return null;
+  let pkg;
+  try {
+    pkg = await readJson(pkgPath);
+  } catch (err) {
+    recordExtractionError("services", import_node_path13.default.relative(scanPath, pkgPath), err);
+    return null;
+  }
+  if (!pkg.name) return null;
+  const framework = detectJsFramework(pkg);
+  const language = await detectJsServiceLanguage(dir, pkg);
+  const node = {
+    id: (0, import_types10.serviceId)(pkg.name),
+    type: import_types10.NodeType.ServiceNode,
+    name: pkg.name,
+    language,
+    version: pkg.version,
+    dependencies: pkg.dependencies ?? {},
+    repoPath: import_node_path13.default.relative(scanPath, dir),
+    ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
+    ...framework ? { framework } : {}
+  };
+  return { pkg, dir, node };
+}
+async function discoverPyService(scanPath, dir) {
+  const py = await discoverPythonService(dir);
+  if (!py) return null;
+  const pkg = pythonToPackage(py);
+  const node = {
+    id: (0, import_types10.serviceId)(py.name),
+    type: import_types10.NodeType.ServiceNode,
+    name: py.name,
+    language: "python",
+    version: py.version,
+    dependencies: py.dependencies,
+    repoPath: import_node_path13.default.relative(scanPath, dir)
+  };
+  return { pkg, dir, node };
+}
+async function discoverServices(scanPath) {
+  const rootPkgPath = import_node_path13.default.join(scanPath, "package.json");
+  let rootPkg = null;
+  if (await exists(rootPkgPath)) {
+    try {
+      rootPkg = await readJson(rootPkgPath);
+    } catch (err) {
+      recordExtractionError(
+        "services workspaces",
+        import_node_path13.default.relative(scanPath, rootPkgPath),
+        err
+      );
     }
-    return;
   }
-  if (node.type === "call_expression") {
-    const fn = node.childForFieldName("function");
-    if (fn?.type === "identifier" && fn.text === "require") {
-      const args = node.childForFieldName("arguments");
-      const firstArg = args?.namedChild(0);
-      if (firstArg?.type === "string") {
-        const specifier = stringLiteralText(firstArg);
-        if (specifier) {
-          out.push({ specifier, line: node.startPosition.row + 1, snippet: clipSnippet(node.text) });
+  const wsGlobs = rootPkg ? workspaceGlobs(rootPkg) : null;
+  const candidateDirs = [];
+  if (wsGlobs) {
+    candidateDirs.push(...await expandWorkspaceGlobs(scanPath, wsGlobs));
+  } else {
+    if (rootPkg && rootPkg.name) {
+      candidateDirs.push(scanPath);
+    } else if (await hasPythonManifest(scanPath) || await hasGoManifest(scanPath)) {
+      candidateDirs.push(scanPath);
+    }
+    const ig = await loadGitignore(scanPath);
+    await walkDirs(
+      scanPath,
+      scanPath,
+      { maxDepth: parseScanDepth(), ig },
+      async (dir) => {
+        if (await exists(import_node_path13.default.join(dir, "package.json"))) {
+          candidateDirs.push(dir);
+        } else if (await hasPythonManifest(dir) || await hasGoManifest(dir)) {
+          candidateDirs.push(dir);
         }
       }
+    );
+  }
+  candidateDirs.sort();
+  const seen = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const dir of candidateDirs) {
+    const service = await discoverNodeService(scanPath, dir) ?? await discoverPyService(scanPath, dir) ?? await discoverGoService(scanPath, dir);
+    if (!service) continue;
+    const existingDir = seen.get(service.node.name);
+    if (existingDir !== void 0) {
+      const a = import_node_path13.default.relative(scanPath, existingDir) || ".";
+      const b = import_node_path13.default.relative(scanPath, dir) || ".";
+      console.warn(
+        `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
+      );
+      continue;
+    }
+    seen.set(service.node.name, dir);
+    out.push(service);
+  }
+  const codeowners = await loadCodeowners(scanPath);
+  for (const service of out) {
+    const owner = await computeServiceOwner(codeowners, service.node.repoPath, service.dir);
+    if (owner !== void 0) service.node.owner = owner;
+  }
+  return out;
+}
+function addServiceNodes(graph, services) {
+  let nodesAdded = 0;
+  for (const service of services) {
+    if (!graph.hasNode(service.node.id)) {
+      graph.addNode(service.node.id, { ...service.node, discoveredVia: "static" });
+      nodesAdded++;
+      continue;
     }
+    const existing = graph.getNodeAttributes(service.node.id);
+    const mergedDiscoveredVia = existing.discoveredVia === "otel" ? "merged" : "static";
+    graph.replaceNodeAttributes(service.node.id, {
+      ...existing,
+      ...service.node,
+      discoveredVia: mergedDiscoveredVia
+    });
+  }
+  return nodesAdded;
+}
+
+// src/extract/aliases.ts
+init_cjs_shims();
+var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs13 = require("fs");
+var import_yaml2 = require("yaml");
+var import_types11 = require("@neat.is/types");
+var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
+  "Service",
+  "Deployment",
+  "StatefulSet",
+  "DaemonSet"
+]);
+function addAliases(graph, serviceId7, candidates) {
+  if (!graph.hasNode(serviceId7)) return;
+  const node = graph.getNodeAttributes(serviceId7);
+  if (node.type !== import_types11.NodeType.ServiceNode) return;
+  const set = new Set(node.aliases ?? []);
+  for (const c of candidates) {
+    if (!c) continue;
+    if (c === node.name) continue;
+    set.add(c);
   }
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child) collectJsImports(child, out);
+  if (set.size === 0) return;
+  const updated = { ...node, aliases: [...set].sort() };
+  graph.replaceNodeAttributes(serviceId7, updated);
+}
+function indexServicesByName(services) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of services) {
+    map.set(s.node.name, s.node.id);
+    map.set(import_node_path14.default.basename(s.dir), s.node.id);
   }
+  return map;
 }
-function collectImportedNames(node, out) {
-  if (node.type === "aliased_import") {
-    const nameNode = node.childForFieldName("name");
-    if (nameNode) out.push(nameNode.text);
-    return;
+async function collectComposeAliases(graph, scanPath, serviceIndex) {
+  let composePath = null;
+  for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
+    const abs = import_node_path14.default.join(scanPath, name);
+    if (await exists(abs)) {
+      composePath = abs;
+      break;
+    }
   }
-  if (node.type === "dotted_name") {
-    out.push(node.text);
+  if (!composePath) return;
+  let compose;
+  try {
+    compose = await readYaml(composePath);
+  } catch (err) {
+    recordExtractionError(
+      "aliases compose",
+      import_node_path14.default.relative(scanPath, composePath),
+      err
+    );
     return;
   }
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child) collectImportedNames(child, out);
+  if (!compose?.services) return;
+  for (const [composeName, svc] of Object.entries(compose.services)) {
+    const serviceId7 = serviceIndex.get(composeName);
+    if (!serviceId7) continue;
+    const aliases = /* @__PURE__ */ new Set([composeName]);
+    if (svc.container_name) aliases.add(svc.container_name);
+    if (svc.hostname) aliases.add(svc.hostname);
+    addAliases(graph, serviceId7, aliases);
   }
 }
-function collectPyImports(node, out) {
-  if (node.type === "import_from_statement") {
-    let level = 0;
-    let modulePath = "";
-    const names = [];
-    let pastFrom = false;
-    let pastImport = false;
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (!child) continue;
-      if (!pastFrom) {
-        if (child.type === "from") pastFrom = true;
-        continue;
-      }
-      if (!pastImport) {
-        if (child.type === "import") {
-          pastImport = true;
-          continue;
-        }
-        if (child.type === "relative_import") {
-          for (let j = 0; j < child.childCount; j++) {
-            const rc = child.child(j);
-            if (!rc) continue;
-            if (rc.type === "import_prefix") {
-              for (let k = 0; k < rc.childCount; k++) {
-                if (rc.child(k)?.type === ".") level++;
-              }
-            } else if (rc.type === "dotted_name") modulePath = rc.text;
-          }
-        } else if (child.type === "dotted_name") {
-          modulePath = child.text;
-        }
-        continue;
-      }
-      collectImportedNames(child, names);
-    }
-    if (level > 0 || modulePath) {
-      out.push({ modulePath, level, names, line: node.startPosition.row + 1, snippet: clipSnippet(node.text) });
+var LABEL_KEYS = /* @__PURE__ */ new Set([
+  "service",
+  "service.name",
+  "app",
+  "app.name",
+  "com.docker.compose.service",
+  "org.opencontainers.image.title"
+]);
+function parseDockerfileLabels(content) {
+  const out = [];
+  const lineRegex = /^\s*label\s+(.+)$/i;
+  for (const raw of content.split("\n")) {
+    const m = lineRegex.exec(raw);
+    if (!m) continue;
+    const rest = m[1];
+    const pairRegex = /([\w.-]+)\s*=\s*("([^"]*)"|'([^']*)'|([^\s]+))/g;
+    let pair;
+    while ((pair = pairRegex.exec(rest)) !== null) {
+      const key = pair[1].toLowerCase();
+      if (!LABEL_KEYS.has(key)) continue;
+      const value = pair[3] ?? pair[4] ?? pair[5] ?? "";
+      if (value) out.push(value);
     }
   }
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child) collectPyImports(child, out);
+  return out;
+}
+async function collectDockerfileAliases(graph, services) {
+  for (const service of services) {
+    const dockerfilePath = import_node_path14.default.join(service.dir, "Dockerfile");
+    if (!await exists(dockerfilePath)) continue;
+    let content;
+    try {
+      content = await import_node_fs13.promises.readFile(dockerfilePath, "utf8");
+    } catch (err) {
+      recordExtractionError("aliases dockerfile", dockerfilePath, err);
+      continue;
+    }
+    const aliases = parseDockerfileLabels(content);
+    if (aliases.length > 0) addAliases(graph, service.node.id, aliases);
   }
 }
-async function fileExists(p) {
-  try {
-    await import_node_fs13.promises.access(p);
-    return true;
-  } catch {
-    return false;
+async function walkYamlFiles(start, depth = 0, max = 5) {
+  if (depth > max) return [];
+  const out = [];
+  const entries = await import_node_fs13.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  for (const entry2 of entries) {
+    if (entry2.isDirectory()) {
+      if (IGNORED_DIRS.has(entry2.name)) continue;
+      const child = import_node_path14.default.join(start, entry2.name);
+      if (await isPythonVenvDir(child)) continue;
+      out.push(...await walkYamlFiles(child, depth + 1, max));
+    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path14.default.extname(entry2.name))) {
+      out.push(import_node_path14.default.join(start, entry2.name));
+    }
   }
+  return out;
 }
-function isWithinServiceDir(candidate, serviceDir) {
-  const rel = import_node_path16.default.relative(serviceDir, candidate);
-  return rel !== "" && !rel.startsWith("..") && !import_node_path16.default.isAbsolute(rel);
+function k8sHostnames(name, namespace) {
+  const ns = namespace ?? "default";
+  return [
+    name,
+    `${name}.${ns}`,
+    `${name}.${ns}.svc`,
+    `${name}.${ns}.svc.cluster.local`
+  ];
 }
-var JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-var JS_INDEX_FILES = JS_EXTENSIONS.map((ext) => `index${ext}`);
-async function firstExistingCandidate(base, serviceDir) {
-  for (const ext of JS_EXTENSIONS) {
-    const candidate = base + ext;
-    if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix(import_node_path16.default.relative(serviceDir, candidate));
+function k8sServiceTarget(doc, byName) {
+  const selector = doc.spec?.selector;
+  const selectorApp = selector?.app ?? selector?.matchLabels?.app;
+  if (selectorApp && byName.has(selectorApp)) return byName.get(selectorApp);
+  const labelApp = doc.metadata?.labels?.app;
+  if (labelApp && byName.has(labelApp)) return byName.get(labelApp);
+  const metaName = doc.metadata?.name;
+  if (metaName && byName.has(metaName)) return byName.get(metaName);
+  return null;
+}
+async function collectK8sAliases(graph, scanPath, serviceIndex) {
+  const files = await walkYamlFiles(scanPath);
+  for (const file of files) {
+    const content = await import_node_fs13.promises.readFile(file, "utf8");
+    let docs;
+    try {
+      docs = (0, import_yaml2.parseAllDocuments)(content).map((d) => d.toJSON());
+    } catch {
+      continue;
     }
-  }
-  for (const indexFile of JS_INDEX_FILES) {
-    const candidate = import_node_path16.default.join(base, indexFile);
-    if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix(import_node_path16.default.relative(serviceDir, candidate));
+    for (const doc of docs) {
+      if (!doc?.kind || !doc.metadata?.name) continue;
+      if (!K8S_KINDS_WITH_HOSTNAMES.has(doc.kind)) continue;
+      const target = k8sServiceTarget(doc, serviceIndex);
+      if (!target) continue;
+      addAliases(graph, target, k8sHostnames(doc.metadata.name, doc.metadata.namespace));
     }
   }
-  return null;
 }
-async function loadTsPathConfig(serviceDir) {
-  const tsconfigPath = import_node_path16.default.join(serviceDir, "tsconfig.json");
-  let raw;
-  try {
-    raw = await import_node_fs13.promises.readFile(tsconfigPath, "utf8");
-  } catch {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    const paths = parsed.compilerOptions?.paths;
-    if (!paths || Object.keys(paths).length === 0) return null;
-    const baseUrl = parsed.compilerOptions?.baseUrl;
-    return { paths, baseDir: baseUrl ? import_node_path16.default.resolve(serviceDir, baseUrl) : serviceDir };
-  } catch (err) {
-    recordExtractionError("import alias resolution", tsconfigPath, err);
-    return null;
-  }
+async function addServiceAliases(graph, scanPath, services) {
+  const byName = indexServicesByName(services);
+  await collectComposeAliases(graph, scanPath, byName);
+  await collectDockerfileAliases(graph, services);
+  await collectK8sAliases(graph, scanPath, byName);
 }
-async function resolveTsAlias(specifier, config, serviceDir) {
-  for (const [pattern, targets] of Object.entries(config.paths)) {
-    let suffix = null;
-    if (pattern === specifier) {
-      suffix = "";
-    } else if (pattern.endsWith("/*")) {
-      const prefix = pattern.slice(0, -1);
-      if (specifier.startsWith(prefix)) suffix = specifier.slice(prefix.length);
-    }
-    if (suffix === null) continue;
-    for (const target of targets) {
-      const targetBase = target.endsWith("/*") ? target.slice(0, -2) : target.replace(/\*$/, "");
-      const resolvedBase = import_node_path16.default.resolve(config.baseDir, targetBase, suffix);
-      const hit = await firstExistingCandidate(resolvedBase, serviceDir);
-      if (hit) return hit;
-      if (isWithinServiceDir(resolvedBase, serviceDir) && await fileExists(resolvedBase)) {
-        return toPosix(import_node_path16.default.relative(serviceDir, resolvedBase));
-      }
+
+// src/extract/files.ts
+init_cjs_shims();
+var import_node_path15 = __toESM(require("path"), 1);
+async function addFiles(graph, services) {
+  let nodesAdded = 0;
+  let edgesAdded = 0;
+  for (const service of services) {
+    const filePaths = await walkSourceFiles(service.dir);
+    for (const filePath of filePaths) {
+      const relPath = toPosix(import_node_path15.default.relative(service.dir, filePath));
+      const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
+        graph,
+        service.pkg.name,
+        service.node.id,
+        relPath
+      );
+      nodesAdded += n;
+      edgesAdded += e;
     }
   }
-  return null;
+  return { nodesAdded, edgesAdded };
+}
+
+// src/extract/symbols.ts
+init_cjs_shims();
+var import_node_path16 = __toESM(require("path"), 1);
+var import_tree_sitter3 = __toESM(require("tree-sitter"), 1);
+var import_tree_sitter_javascript3 = __toESM(require("tree-sitter-javascript"), 1);
+var import_tree_sitter_typescript = __toESM(require("tree-sitter-typescript"), 1);
+var import_types12 = require("@neat.is/types");
+var PARSE_CHUNK3 = 16384;
+var GRAMMAR_BY_EXT = {
+  ".ts": import_tree_sitter_typescript.default.typescript,
+  ".tsx": import_tree_sitter_typescript.default.tsx,
+  ".js": import_tree_sitter_javascript3.default,
+  ".jsx": import_tree_sitter_javascript3.default,
+  ".mjs": import_tree_sitter_javascript3.default,
+  ".cjs": import_tree_sitter_javascript3.default
+};
+function parseSource3(parser, source) {
+  return parser.parse(
+    (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK3)
+  );
 }
-async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
-  if (!specifier) return null;
-  if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    const base = import_node_path16.default.resolve(importerDir, specifier);
-    const ext = import_node_path16.default.extname(specifier);
-    if (ext) {
-      if (ext === ".js" || ext === ".jsx") {
-        const tsExt = ext === ".jsx" ? ".tsx" : ".ts";
-        const tsSibling = base.slice(0, -ext.length) + tsExt;
-        if (isWithinServiceDir(tsSibling, serviceDir) && await fileExists(tsSibling)) {
-          return toPosix(import_node_path16.default.relative(serviceDir, tsSibling));
+function methodName(node) {
+  const name = node.childForFieldName("name");
+  return name ? name.text : null;
+}
+function collectSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const visit = (node, classCtx) => {
+    switch (node.type) {
+      case "function_declaration":
+      case "generator_function_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("function", name, node);
+        break;
+      }
+      case "class_declaration":
+      case "abstract_class_declaration":
+      case "class": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("class", name, node);
+        const body = node.childForFieldName("body");
+        if (body) {
+          for (let i = 0; i < body.namedChildCount; i++) {
+            const child = body.namedChild(i);
+            if (child) visit(child, name ?? classCtx);
+          }
         }
+        return;
       }
-      if (isWithinServiceDir(base, serviceDir) && await fileExists(base)) {
-        return toPosix(import_node_path16.default.relative(serviceDir, base));
+      case "method_definition": {
+        const name = methodName(node);
+        if (name) {
+          const kind = name === "constructor" ? "constructor" : "method";
+          push(kind, classCtx ? `${classCtx}.${name}` : name, node);
+        }
+        break;
       }
-      return null;
-    }
-    return firstExistingCandidate(base, serviceDir);
-  }
-  if (tsPaths) return resolveTsAlias(specifier, tsPaths, serviceDir);
-  return null;
-}
-async function resolvePyImport(imp, importerPath, serviceDir) {
-  let baseDir;
-  if (imp.level > 0) {
-    baseDir = import_node_path16.default.dirname(importerPath);
-    for (let i = 1; i < imp.level; i++) baseDir = import_node_path16.default.dirname(baseDir);
-  } else {
-    baseDir = serviceDir;
-  }
-  const moduleBase = imp.modulePath ? import_node_path16.default.join(baseDir, imp.modulePath.split(".").join("/")) : baseDir;
-  const resolved = /* @__PURE__ */ new Set();
-  let needModuleFile = imp.names.length === 0;
-  for (const name of imp.names) {
-    const submoduleFile = import_node_path16.default.join(moduleBase, `${name}.py`);
-    const subpackageInit = import_node_path16.default.join(moduleBase, name, "__init__.py");
-    if (isWithinServiceDir(submoduleFile, serviceDir) && await fileExists(submoduleFile)) {
-      resolved.add(toPosix(import_node_path16.default.relative(serviceDir, submoduleFile)));
-    } else if (isWithinServiceDir(subpackageInit, serviceDir) && await fileExists(subpackageInit)) {
-      resolved.add(toPosix(import_node_path16.default.relative(serviceDir, subpackageInit)));
-    } else {
-      needModuleFile = true;
-    }
-  }
-  if (needModuleFile) {
-    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, import_node_path16.default.join(moduleBase, "__init__.py")] : [import_node_path16.default.join(moduleBase, "__init__.py")];
-    for (const candidate of moduleFileCandidates) {
-      if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-        resolved.add(toPosix(import_node_path16.default.relative(serviceDir, candidate)));
+      case "variable_declarator": {
+        const value = node.childForFieldName("value");
+        if (value && (value.type === "arrow_function" || value.type === "function" || value.type === "function_expression" || value.type === "generator_function")) {
+          const nameNode = node.childForFieldName("name");
+          if (nameNode && nameNode.type === "identifier") {
+            push("function", nameNode.text, node);
+          }
+        }
         break;
       }
     }
-  }
-  return [...resolved];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) visit(child, classCtx);
+    }
+  };
+  visit(root, void 0);
+  return out;
 }
-async function resolveGoImport(specifier, modulePath, serviceDir) {
-  if (specifier !== modulePath && !specifier.startsWith(`${modulePath}/`)) return null;
-  const suffix = specifier === modulePath ? "" : specifier.slice(modulePath.length + 1);
-  const dir = import_node_path16.default.join(serviceDir, suffix);
-  const entries = await import_node_fs13.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
-  const candidates = entries.filter((entry2) => entry2.isFile() && entry2.name.endsWith(".go") && !entry2.name.endsWith("_test.go")).map((entry2) => import_node_path16.default.join(dir, entry2.name));
-  if (candidates.length !== 1) return null;
-  return toPosix(import_node_path16.default.relative(serviceDir, candidates[0]));
+function disambiguate(defs) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const def of defs) counts.set(def.qualname, (counts.get(def.qualname) ?? 0) + 1);
+  const seen = /* @__PURE__ */ new Map();
+  return defs.map((def) => {
+    if ((counts.get(def.qualname) ?? 0) <= 1) return { def };
+    const ordinal = seen.get(def.qualname) ?? 0;
+    seen.set(def.qualname, ordinal + 1);
+    return { def, disambiguator: ordinal };
+  });
 }
-function emitImportEdge(graph, serviceName, importerFileId, importerRelPath, importeeRelPath, line, snippet2) {
-  const importeeFileId = (0, import_types12.fileId)(serviceName, importeeRelPath);
-  if (!graph.hasNode(importeeFileId)) return 0;
-  const edgeId = (0, import_types12.extractedEdgeId)(importerFileId, importeeFileId, import_types12.EdgeType.IMPORTS);
-  if (graph.hasEdge(edgeId)) return 0;
-  const edge = {
-    id: edgeId,
-    source: importerFileId,
-    target: importeeFileId,
-    type: import_types12.EdgeType.IMPORTS,
-    provenance: import_types12.Provenance.EXTRACTED,
-    confidence: (0, import_types12.confidenceForExtracted)("structural"),
-    evidence: { file: importerRelPath, line, snippet: snippet2 }
+async function addSymbols(graph, services) {
+  const parsers = /* @__PURE__ */ new Map();
+  const parserForExt2 = (ext) => {
+    const grammar = GRAMMAR_BY_EXT[ext];
+    if (!grammar) return null;
+    let parser = parsers.get(ext);
+    if (!parser) {
+      parser = new import_tree_sitter3.default();
+      parser.setLanguage(grammar);
+      parsers.set(ext, parser);
+    }
+    return parser;
   };
-  graph.addEdgeWithKey(edgeId, importerFileId, importeeFileId, edge);
-  return 1;
-}
-async function addImports(graph, services) {
-  const jsParser = makeJsParser2();
-  const pyParser = makePyParser2();
-  const goParser = makeGoParser2();
+  let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const tsPaths = await loadTsPathConfig(service.dir);
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
-      if (isTestPath(file.path)) continue;
-      const relFile = toPosix(import_node_path16.default.relative(service.dir, file.path));
-      const importerFileId = (0, import_types12.fileId)(service.pkg.name, relFile);
-      const isPython = import_node_path16.default.extname(file.path) === ".py";
-      const isGo = import_node_path16.default.extname(file.path) === ".go";
-      if (isGo) {
-        let goImports = [];
-        try {
-          const tree = parseSource3(goParser, file.content);
-          collectGoImports(tree.rootNode, goImports);
-        } catch (err) {
-          recordExtractionError("import extraction", file.path, err);
-          continue;
-        }
-        const goMod = await import_node_fs13.promises.readFile(import_node_path16.default.join(service.dir, "go.mod"), "utf8").catch(() => "");
-        const modulePath = goMod.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
-        if (!modulePath) continue;
-        for (const imp of goImports) {
-          const resolved = await resolveGoImport(imp.specifier, modulePath, service.dir);
-          if (!resolved) continue;
-          edgesAdded += emitImportEdge(graph, service.pkg.name, importerFileId, relFile, resolved, imp.line, imp.snippet);
-        }
-        continue;
-      }
-      if (isPython) {
-        let pyImports = [];
-        try {
-          const tree = parseSource3(pyParser, file.content);
-          collectPyImports(tree.rootNode, pyImports);
-        } catch (err) {
-          recordExtractionError("import extraction", file.path, err);
-          continue;
-        }
-        for (const imp of pyImports) {
-          const resolvedPaths = await resolvePyImport(imp, file.path, service.dir);
-          for (const resolved of resolvedPaths) {
-            edgesAdded += emitImportEdge(
-              graph,
-              service.pkg.name,
-              importerFileId,
-              relFile,
-              resolved,
-              imp.line,
-              imp.snippet
-            );
-          }
-        }
-        continue;
-      }
-      let jsImports = [];
+      const parser = parserForExt2(import_node_path16.default.extname(file.path));
+      if (!parser) continue;
+      const relPath = toPosix(import_node_path16.default.relative(service.dir, file.path));
+      let defs;
       try {
-        const tree = parseSource3(jsParser, file.content);
-        collectJsImports(tree.rootNode, jsImports);
+        const tree = parseSource3(parser, file.content);
+        defs = collectSymbolDefs(tree.rootNode);
       } catch (err) {
-        recordExtractionError("import extraction", file.path, err);
+        recordExtractionError("symbol extraction", file.path, err);
         continue;
       }
-      for (const imp of jsImports) {
-        const resolved = await resolveJsImport(imp.specifier, import_node_path16.default.dirname(file.path), service.dir, tsPaths);
-        if (!resolved) continue;
-        edgesAdded += emitImportEdge(
-          graph,
-          service.pkg.name,
-          importerFileId,
-          relFile,
-          resolved,
-          imp.line,
-          imp.snippet
-        );
+      if (defs.length === 0) continue;
+      const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
+        graph,
+        service.pkg.name,
+        service.node.id,
+        relPath
+      );
+      nodesAdded += fn;
+      edgesAdded += fe;
+      for (const { def, disambiguator } of disambiguate(defs)) {
+        const sid = (0, import_types12.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
+        if (!graph.hasNode(sid)) {
+          const node = {
+            id: sid,
+            type: import_types12.NodeType.SymbolNode,
+            kind: def.kind,
+            qualname: def.qualname,
+            span: { startLine: def.startLine, endLine: def.endLine },
+            service: service.pkg.name,
+            relPath,
+            discoveredVia: "static"
+          };
+          graph.addNode(sid, node);
+          nodesAdded++;
+        }
+        const containsId = (0, import_types12.extractedEdgeId)(fileNodeId, sid, import_types12.EdgeType.CONTAINS);
+        if (!graph.hasEdge(containsId)) {
+          const edge = {
+            id: containsId,
+            source: fileNodeId,
+            target: sid,
+            type: import_types12.EdgeType.CONTAINS,
+            provenance: import_types12.Provenance.EXTRACTED,
+            confidence: (0, import_types12.confidenceForExtracted)("structural"),
+            evidence: {
+              file: relPath,
+              line: def.startLine,
+              snippet: snippet(file.content, def.startLine)
+            }
+          };
+          graph.addEdgeWithKey(containsId, fileNodeId, sid, edge);
+          edgesAdded++;
+        }
       }
     }
   }
-  return { nodesAdded: 0, edgesAdded };
+  return { nodesAdded, edgesAdded };
 }
 
 // src/extract/symbol-edges.ts
+init_cjs_shims();
+var import_node_path17 = __toESM(require("path"), 1);
+var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
+var import_types13 = require("@neat.is/types");
 function extendsInfo(classHeritage) {
   for (let i = 0; i < classHeritage.namedChildCount; i++) {
     const child = classHeritage.namedChild(i);
@@ -5936,7 +6250,7 @@ async function addSymbolEdges(graph, services) {
       const fileDir = import_node_path17.default.dirname(file.path);
       let root;
       try {
-        root = parseSource2(parser, file.content).rootNode;
+        root = parseSource3(parser, file.content).rootNode;
       } catch (err) {
         recordExtractionError("symbol edge extraction", file.path, err);
         continue;
@@ -8388,7 +8702,7 @@ function columnsFromObject(obj) {
 }
 function drizzleEndpointsFromFile(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource2(parserForExt(import_node_path38.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt(import_node_path38.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk6 = (node) => {
@@ -15004,9 +15318,11 @@ var ALL_PHASES = [
   "services",
   "aliases",
   "files",
+  "symbols",
   "imports",
   "databases",
   "configs",
+  "routes",
   "calls",
   "infra"
 ];
@@ -15029,7 +15345,9 @@ function classifyChange(relPath) {
   }
   if (/\.(?:js|jsx|mjs|cjs|ts|tsx|py)$/.test(base)) {
     phases.add("files");
+    phases.add("symbols");
     phases.add("imports");
+    phases.add("routes");
     phases.add("calls");
   }
   if (/\.ya?ml$/.test(base) && !/^docker-compose.*\.ya?ml$/.test(base)) {
@@ -15056,6 +15374,11 @@ async function runExtractPhases(graph, scanPath, phases, project = DEFAULT_PROJE
     nodesAdded += r.nodesAdded;
     edgesAdded += r.edgesAdded;
   }
+  if (phases.has("symbols")) {
+    const r = await addSymbols(graph, services);
+    nodesAdded += r.nodesAdded;
+    edgesAdded += r.edgesAdded;
+  }
   if (phases.has("imports")) {
     const r = await addImports(graph, services);
     nodesAdded += r.nodesAdded;
@@ -15071,6 +15394,11 @@ async function runExtractPhases(graph, scanPath, phases, project = DEFAULT_PROJE
     nodesAdded += r.nodesAdded;
     edgesAdded += r.edgesAdded;
   }
+  if (phases.has("routes")) {
+    const r = await addRoutes(graph, services);
+    nodesAdded += r.nodesAdded;
+    edgesAdded += r.edgesAdded;
+  }
   if (phases.has("calls")) {
     const r = await addCallEdges(graph, services);
     nodesAdded += r.nodesAdded;