@neat.is/core 0.7.3 → 0.7.4

package/dist/server.cjs

@@ -1083,7 +1083,7 @@ async function rollbackExtension(ctx, args) {
 
 // src/divergences.ts
 init_cjs_shims();
-var import_types8 = require("@neat.is/types");
+var import_types9 = require("@neat.is/types");
 
 // src/columns.ts
 init_cjs_shims();
@@ -1439,8 +1439,8 @@ init_cjs_shims();
 
 // src/ingest.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 sourceMapJs = __toESM(require("source-map-js"), 1);
 
 // src/policy.ts
@@ -1903,16 +1903,16 @@ var PolicyViolationsLog = class {
 };
 
 // src/ingest.ts
-var import_types6 = require("@neat.is/types");
+var import_types7 = require("@neat.is/types");
 
 // src/extract/routes.ts
 init_cjs_shims();
-var import_node_path8 = __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_path9 = __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();
@@ -2283,7 +2283,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_path8 = __toESM(require("path"), 1);
+var import_node_fs8 = 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(
@@ -2305,153 +2313,530 @@ 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) => {
+async function fileExists2(p) {
+  try {
+    await import_node_fs8.promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isWithinServiceDir(candidate, serviceDir) {
+  const rel = import_node_path8.default.relative(serviceDir, candidate);
+  return rel !== "" && !rel.startsWith("..") && !import_node_path8.default.isAbsolute(rel);
+}
+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 fileExists2(candidate)) {
+      return toPosix(import_node_path8.default.relative(serviceDir, candidate));
+    }
+  }
+  for (const indexFile of JS_INDEX_FILES) {
+    const candidate = import_node_path8.default.join(base, indexFile);
+    if (isWithinServiceDir(candidate, serviceDir) && await fileExists2(candidate)) {
+      return toPosix(import_node_path8.default.relative(serviceDir, candidate));
+    }
+  }
+  return null;
+}
+async function loadTsPathConfig(serviceDir) {
+  const tsconfigPath = import_node_path8.default.join(serviceDir, "tsconfig.json");
+  let raw;
+  try {
+    raw = await import_node_fs8.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_path8.default.resolve(serviceDir, baseUrl) : serviceDir };
+  } catch (err) {
+    recordExtractionError("import alias resolution", tsconfigPath, err);
+    return null;
+  }
+}
+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_path8.default.resolve(config.baseDir, targetBase, suffix);
+      const hit = await firstExistingCandidate(resolvedBase, serviceDir);
+      if (hit) return hit;
+      if (isWithinServiceDir(resolvedBase, serviceDir) && await fileExists2(resolvedBase)) {
+        return toPosix(import_node_path8.default.relative(serviceDir, resolvedBase));
+      }
+    }
+  }
+  return null;
+}
+async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
+  if (!specifier) return null;
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    const base = import_node_path8.default.resolve(importerDir, specifier);
+    const ext = import_node_path8.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 fileExists2(tsSibling)) {
+          return toPosix(import_node_path8.default.relative(serviceDir, tsSibling));
+        }
+      }
+      if (isWithinServiceDir(base, serviceDir) && await fileExists2(base)) {
+        return toPosix(import_node_path8.default.relative(serviceDir, base));
+      }
+      if (!JS_EXTENSIONS.includes(ext)) {
+        return firstExistingCandidate(base, serviceDir);
+      }
+      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_path8.default.dirname(importerPath);
+    for (let i = 1; i < imp.level; i++) baseDir = import_node_path8.default.dirname(baseDir);
+  } else {
+    baseDir = serviceDir;
+  }
+  const moduleBase = imp.modulePath ? import_node_path8.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_path8.default.join(moduleBase, `${name}.py`);
+    const subpackageInit = import_node_path8.default.join(moduleBase, name, "__init__.py");
+    if (isWithinServiceDir(submoduleFile, serviceDir) && await fileExists2(submoduleFile)) {
+      resolved.add(toPosix(import_node_path8.default.relative(serviceDir, submoduleFile)));
+    } else if (isWithinServiceDir(subpackageInit, serviceDir) && await fileExists2(subpackageInit)) {
+      resolved.add(toPosix(import_node_path8.default.relative(serviceDir, subpackageInit)));
+    } else {
+      needModuleFile = true;
+    }
+  }
+  if (needModuleFile) {
+    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, import_node_path8.default.join(moduleBase, "__init__.py")] : [import_node_path8.default.join(moduleBase, "__init__.py")];
+    for (const candidate of moduleFileCandidates) {
+      if (isWithinServiceDir(candidate, serviceDir) && await fileExists2(candidate)) {
+        resolved.add(toPosix(import_node_path8.default.relative(serviceDir, candidate)));
+        break;
+      }
+    }
+  }
+  return [...resolved];
+}
+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_path8.default.join(serviceDir, suffix);
+  const entries = await import_node_fs8.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const candidates = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".go") && !entry.name.endsWith("_test.go")).map((entry) => import_node_path8.default.join(dir, entry.name));
+  if (candidates.length !== 1) return null;
+  return toPosix(import_node_path8.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_path8.default.relative(service.dir, file.path));
+      const importerFileId = (0, import_types5.fileId)(service.pkg.name, relFile);
+      const isPython = import_node_path8.default.extname(file.path) === ".py";
+      const isGo = import_node_path8.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_fs8.promises.readFile(import_node_path8.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_path8.default.dirname(file.path), service.dir, tsPaths);
+        if (!resolved) continue;
+        edgesAdded += emitImportEdge(
+          graph,
+          service.pkg.name,
+          importerFileId,
+          relFile,
+          resolved,
+          imp.line,
+          imp.snippet
+        );
+      }
+    }
+  }
+  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;
+}
+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 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) walk(child, visit);
+  }
+}
+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 "";
+  }
+  if (node.type === "template_string") {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      if (node.namedChild(i)?.type === "template_substitution") return null;
+    }
+    const raw = node.text;
+    return raw.length >= 2 ? raw.slice(1, -1) : "";
+  }
+  return null;
+}
+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 !== "import_statement") return;
     const source = node.childForFieldName("source");
     if (!source || staticStringText(source) !== "@nestjs/common") return;
@@ -2499,7 +2884,7 @@ function nestJoinedPath(prefix, leaf) {
   return canonicalizeTemplate(segments.join("/"));
 }
 function nestjsRoutesFromSource(source, parser) {
-  const tree = parseSource(parser, source);
+  const tree = parseSource2(parser, source);
   const imports = nestDecoratorImports(tree.rootNode);
   if (![...imports.values()].includes("Controller")) return [];
   const out = [];
@@ -2547,7 +2932,7 @@ function nestjsRoutesFromSource(source, parser) {
   return out;
 }
 function serverRoutesFromSource(source, parser, hasExpress, hasFastify, hasHono = false) {
-  const tree = parseSource(parser, source);
+  const tree = parseSource2(parser, source);
   const out = [];
   const framework = hasExpress ? "express" : hasFastify ? "fastify" : hasHono ? "hono" : "unknown";
   walk(tree.rootNode, (node) => {
@@ -2605,7 +2990,7 @@ function isNextPagesApiFile(relFile) {
   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));
+  return JS_ROUTE_EXTENSIONS.has(import_node_path9.default.extname(base));
 }
 function nextSegment(seg) {
   if (seg.startsWith("(") && seg.endsWith(")")) return null;
@@ -2667,7 +3052,7 @@ function nextAppMethods(root) {
 }
 function nextRoutesFromFile(source, relFile, parser) {
   if (isNextAppRouteFile(relFile)) {
-    const tree = parseSource(parser, source);
+    const tree = parseSource2(parser, source);
     const template = nextAppPathTemplate(relFile);
     return nextAppMethods(tree.rootNode).map(({ method, line }) => ({
       method,
@@ -2788,7 +3173,7 @@ function collectMountPrefixes(root, consts) {
   return mounts;
 }
 function pythonRoutesFromSource(source, parser, framework) {
-  const tree = parseSource(parser, source);
+  const tree = parseSource2(parser, source);
   const prefixes = collectPythonRouterPrefixes(tree.rootNode);
   const consts = collectStringConstants(tree.rootNode);
   const mounts = collectMountPrefixes(tree.rootNode, consts);
@@ -2828,7 +3213,7 @@ function pythonRoutesFromSource(source, parser, framework) {
   return out;
 }
 function djangoRoutesFromSource(source, parser) {
-  const tree = parseSource(parser, source);
+  const tree = parseSource2(parser, source);
   const out = [];
   walk(tree.rootNode, (node) => {
     if (node.type !== "assignment") return;
@@ -2856,10 +3241,320 @@ function djangoRoutesFromSource(source, parser) {
   });
   return out;
 }
+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_path9.default.extname(f.path))) continue;
+    if (isTestPath(f.path)) continue;
+    const rel = toPosix(import_node_path9.default.relative(serviceDir, f.path));
+    try {
+      const tree = parseSource2(jsParser, f.content);
+      fileInfo.set(rel, analyzeExpressFile(tree.rootNode, import_node_path9.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 apply = (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) apply(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 = makeJsParser();
-  const pyParser = makePyParser();
-  const goParser = makeGoParser();
+  const jsParser = makeJsParser2();
+  const pyParser = makePyParser2();
+  const goParser = makeGoParser2();
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
@@ -2879,13 +3574,14 @@ async function addRoutes(graph, services) {
     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_path8.default.extname(file.path);
+      const ext = import_node_path9.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_path8.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path9.default.relative(service.dir, file.path));
       let routes;
       try {
         if (isGo) {
@@ -2907,16 +3603,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,
@@ -2925,15 +3623,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,
@@ -3169,7 +3867,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_path9.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
+    const absRoot = toPosix2(import_node_path10.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
     const anchor = absRoot.endsWith("/") ? absRoot : `${absRoot}/`;
     if (p.startsWith(anchor)) return p.slice(anchor.length);
   }
@@ -3197,10 +3895,10 @@ function resolveDistToSrc(absFilepath, line) {
     entry = null;
     const mapPath = `${absFilepath}.map`;
     try {
-      if ((0, import_node_fs8.existsSync)(mapPath)) {
-        const raw = JSON.parse((0, import_node_fs8.readFileSync)(mapPath, "utf8"));
+      if ((0, import_node_fs9.existsSync)(mapPath)) {
+        const raw = JSON.parse((0, import_node_fs9.readFileSync)(mapPath, "utf8"));
         const consumer = new sourceMapJs.SourceMapConsumer(raw);
-        entry = { consumer, dir: import_node_path9.default.dirname(mapPath) };
+        entry = { consumer, dir: import_node_path10.default.dirname(mapPath) };
       }
     } catch {
       entry = null;
@@ -3215,7 +3913,7 @@ function resolveDistToSrc(absFilepath, line) {
     });
     if (!pos || !pos.source) return null;
     const root = entry.consumer.sourceRoot ?? "";
-    const resolved = import_node_path9.default.resolve(entry.dir, root, pos.source);
+    const resolved = import_node_path10.default.resolve(entry.dir, root, pos.source);
     return { filepath: resolved, ...pos.line ? { line: pos.line } : {} };
   } catch {
     return null;
@@ -3248,11 +3946,11 @@ function callSiteFromSpan(span, serviceNode, scanPath) {
   };
 }
 function reconcileObservedRelPath(graph, serviceName, relPath) {
-  if (graph.hasNode((0, import_types6.fileId)(serviceName, relPath))) return relPath;
+  if (graph.hasNode((0, import_types7.fileId)(serviceName, relPath))) return relPath;
   let best = null;
   graph.forEachNode((_id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types6.NodeType.FileNode || a.service !== serviceName) return;
+    if (a.type !== import_types7.NodeType.FileNode || a.service !== serviceName) return;
     if (a.discoveredVia === "otel") return;
     const p = a.path;
     if (!p) return;
@@ -3264,14 +3962,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_types6.NodeType.ServiceNode && typeof svcAttrs.name === "string" ? svcAttrs.name : serviceName;
+  const canonicalService = svcAttrs && svcAttrs.type === import_types7.NodeType.ServiceNode && typeof svcAttrs.name === "string" ? svcAttrs.name : serviceName;
   const relPath = reconcileObservedRelPath(graph, canonicalService, callSite.relPath);
-  const fileNodeId = (0, import_types6.fileId)(canonicalService, relPath);
+  const fileNodeId = (0, import_types7.fileId)(canonicalService, relPath);
   if (!graph.hasNode(fileNodeId)) {
     const language = languageForExt(relPath);
     const node = {
       id: fileNodeId,
-      type: import_types6.NodeType.FileNode,
+      type: import_types7.NodeType.FileNode,
       service: canonicalService,
       path: relPath,
       ...language ? { language } : {},
@@ -3280,14 +3978,14 @@ function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
     };
     graph.addNode(fileNodeId, node);
   }
-  const containsId = makeObservedEdgeId(import_types6.EdgeType.CONTAINS, serviceNodeId, fileNodeId);
+  const containsId = makeObservedEdgeId(import_types7.EdgeType.CONTAINS, serviceNodeId, fileNodeId);
   if (!graph.hasEdge(containsId)) {
     const edge = {
       id: containsId,
       source: serviceNodeId,
       target: fileNodeId,
-      type: import_types6.EdgeType.CONTAINS,
-      provenance: import_types6.Provenance.OBSERVED
+      type: import_types7.EdgeType.CONTAINS,
+      provenance: import_types7.Provenance.OBSERVED
     };
     graph.addEdgeWithKey(containsId, serviceNodeId, fileNodeId, edge);
   }
@@ -3311,11 +4009,11 @@ function pickContainingSymbol(candidates, fn) {
   return [...candidates].sort(bySpan)[0].id;
 }
 function ensureObservedSymbolNode(graph, fileNodeId, service, relPath, fn, line) {
-  const sid = (0, import_types6.symbolId)(service, relPath, fn);
+  const sid = (0, import_types7.symbolId)(service, relPath, fn);
   if (!graph.hasNode(sid)) {
     const node = {
       id: sid,
-      type: import_types6.NodeType.SymbolNode,
+      type: import_types7.NodeType.SymbolNode,
       kind: "function",
       qualname: fn,
       span: { startLine: line, endLine: line },
@@ -3325,14 +4023,14 @@ function ensureObservedSymbolNode(graph, fileNodeId, service, relPath, fn, line)
     };
     graph.addNode(sid, node);
   }
-  const containsId = makeObservedEdgeId(import_types6.EdgeType.CONTAINS, fileNodeId, sid);
+  const containsId = makeObservedEdgeId(import_types7.EdgeType.CONTAINS, fileNodeId, sid);
   if (!graph.hasEdge(containsId)) {
     const edge = {
       id: containsId,
       source: fileNodeId,
       target: sid,
-      type: import_types6.EdgeType.CONTAINS,
-      provenance: import_types6.Provenance.OBSERVED
+      type: import_types7.EdgeType.CONTAINS,
+      provenance: import_types7.Provenance.OBSERVED
     };
     graph.addEdgeWithKey(containsId, fileNodeId, sid, edge);
   }
@@ -3344,9 +4042,9 @@ function landObservedSymbol(graph, fileNodeId, service, relPath, callSite) {
   let sawSymbol = false;
   const candidates = [];
   graph.forEachOutboundEdge(fileNodeId, (_edge, edgeAttrs, _source, target) => {
-    if (edgeAttrs.type !== import_types6.EdgeType.CONTAINS) return;
+    if (edgeAttrs.type !== import_types7.EdgeType.CONTAINS) return;
     const t = graph.getNodeAttributes(target);
-    if (t.type !== import_types6.NodeType.SymbolNode) return;
+    if (t.type !== import_types7.NodeType.SymbolNode) return;
     sawSymbol = true;
     if (line >= t.span.startLine && line <= t.span.endLine) {
       candidates.push({ id: target, symbol: t });
@@ -3359,17 +4057,17 @@ function landObservedSymbol(graph, fileNodeId, service, relPath, callSite) {
   return fileNodeId;
 }
 function makeObservedEdgeId(type, source, target) {
-  return (0, import_types6.observedEdgeId)(source, target, type);
+  return (0, import_types7.observedEdgeId)(source, target, type);
 }
 function makeInferredEdgeId(type, source, target) {
-  return (0, import_types6.inferredEdgeId)(source, target, type);
+  return (0, import_types7.inferredEdgeId)(source, target, type);
 }
 var INFERRED_CONFIDENCE = 0.6;
 var STITCH_MAX_DEPTH = 2;
 var STITCH_EDGE_TYPES = /* @__PURE__ */ new Set([
-  import_types6.EdgeType.CALLS,
-  import_types6.EdgeType.CONNECTS_TO,
-  import_types6.EdgeType.DEPENDS_ON
+  import_types7.EdgeType.CALLS,
+  import_types7.EdgeType.CONNECTS_TO,
+  import_types7.EdgeType.DEPENDS_ON
 ]);
 var WIRE_SPAN_KIND_CLIENT = 3;
 var WIRE_SPAN_KIND_PRODUCER = 4;
@@ -3385,11 +4083,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_types6.graphqlOperationId)(serviceName, operationType, operationName);
+  const id = (0, import_types7.graphqlOperationId)(serviceName, operationType, operationName);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types6.NodeType.GraphQLOperationNode,
+    type: import_types7.NodeType.GraphQLOperationNode,
     name: operationName,
     service: serviceName,
     operationType: operationType.toLowerCase(),
@@ -3403,11 +4101,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_types6.grpcMethodId)(rpcService, rpcMethod);
+  const id = (0, import_types7.grpcMethodId)(rpcService, rpcMethod);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types6.NodeType.GrpcMethodNode,
+    type: import_types7.NodeType.GrpcMethodNode,
     name: `${rpcService}/${rpcMethod}`,
     rpcService,
     rpcMethod,
@@ -3420,11 +4118,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_types6.websocketChannelId)(serviceName, channel);
+  const id = (0, import_types7.websocketChannelId)(serviceName, channel);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types6.NodeType.WebSocketChannelNode,
+    type: import_types7.NodeType.WebSocketChannelNode,
     name: channel,
     service: serviceName,
     channel,
@@ -3437,11 +4135,11 @@ function messagingDestinationKind(system) {
   return `${system}-topic`;
 }
 function ensureMessagingDestinationNode(graph, system, destination) {
-  const id = (0, import_types6.infraId)(messagingDestinationKind(system), destination);
+  const id = (0, import_types7.infraId)(messagingDestinationKind(system), destination);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types6.NodeType.InfraNode,
+    type: import_types7.NodeType.InfraNode,
     name: destination,
     provider: "self",
     kind: messagingDestinationKind(system)
@@ -3485,9 +4183,9 @@ function lookupParentSpan(traceId, parentSpanId, now) {
   };
 }
 function resolveServiceId(graph, host, env) {
-  const envTagged = (0, import_types6.serviceId)(host, env);
+  const envTagged = (0, import_types7.serviceId)(host, env);
   if (graph.hasNode(envTagged)) return envTagged;
-  const envLess = (0, import_types6.serviceId)(host);
+  const envLess = (0, import_types7.serviceId)(host);
   if (envLess !== envTagged && graph.hasNode(envLess)) return envLess;
   let sameEnv = null;
   let envLessMatch = null;
@@ -3495,7 +4193,7 @@ function resolveServiceId(graph, host, env) {
   graph.forEachNode((id, attrs) => {
     if (sameEnv) return;
     const a = attrs;
-    if (a.type !== import_types6.NodeType.ServiceNode) return;
+    if (a.type !== import_types7.NodeType.ServiceNode) return;
     const matchesByName = a.name === host;
     const matchesByAlias = a.aliases ? a.aliases.includes(host) : false;
     if (!matchesByName && !matchesByAlias) return;
@@ -3510,14 +4208,14 @@ function resolveServiceId(graph, host, env) {
   return sameEnv ?? envLessMatch ?? anyMatch;
 }
 function frontierIdFor(host) {
-  return (0, import_types6.frontierId)(host);
+  return (0, import_types7.frontierId)(host);
 }
 function ensureServiceNode(graph, serviceName, env) {
-  const id = (0, import_types6.serviceId)(serviceName, env);
+  const id = (0, import_types7.serviceId)(serviceName, env);
   if (graph.hasNode(id)) return id;
   const wanted = serviceName.toLowerCase();
   const extractedId = graph.findNode((_nid, attrs) => {
-    if (attrs.type !== import_types6.NodeType.ServiceNode) return false;
+    if (attrs.type !== import_types7.NodeType.ServiceNode) return false;
     const svc = attrs;
     if (svc.discoveredVia === "otel") return false;
     return typeof svc.name === "string" && svc.name.toLowerCase() === wanted;
@@ -3525,7 +4223,7 @@ function ensureServiceNode(graph, serviceName, env) {
   if (extractedId) return extractedId;
   const node = {
     id,
-    type: import_types6.NodeType.ServiceNode,
+    type: import_types7.NodeType.ServiceNode,
     name: serviceName,
     language: "unknown",
     discoveredVia: "otel",
@@ -3535,11 +4233,11 @@ function ensureServiceNode(graph, serviceName, env) {
   return id;
 }
 function ensureInfraNode(graph, kind, name, provider) {
-  const id = (0, import_types6.infraId)(kind, name);
+  const id = (0, import_types7.infraId)(kind, name);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types6.NodeType.InfraNode,
+    type: import_types7.NodeType.InfraNode,
     name,
     provider,
     kind
@@ -3551,7 +4249,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_types6.NodeType.InfraNode || !node.kind || !COLUMN_BEARING_INFRA_KINDS.has(node.kind)) {
+  if (node.type !== import_types7.NodeType.InfraNode || !node.kind || !COLUMN_BEARING_INFRA_KINDS.has(node.kind)) {
     return;
   }
   graph.replaceNodeAttributes(tableNodeId, {
@@ -3560,14 +4258,14 @@ function mergeColumnsAt(graph, tableNodeId, columns, provenance, confidence) {
   });
 }
 function mergeObservedColumns(graph, tableNodeId, columns) {
-  mergeColumnsAt(graph, tableNodeId, columns, import_types6.Provenance.OBSERVED, OBSERVED_COLUMN_CONFIDENCE);
+  mergeColumnsAt(graph, tableNodeId, columns, import_types7.Provenance.OBSERVED, OBSERVED_COLUMN_CONFIDENCE);
 }
 function ensureDatabaseNode(graph, host, engine) {
-  const id = (0, import_types6.databaseId)(host);
+  const id = (0, import_types7.databaseId)(host);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types6.NodeType.DatabaseNode,
+    type: import_types7.NodeType.DatabaseNode,
     name: host,
     engine,
     engineVersion: "unknown",
@@ -3579,11 +4277,11 @@ function ensureDatabaseNode(graph, host, engine) {
   return id;
 }
 function ensureLocalDatabaseNode(graph, serviceName, name, engine) {
-  const id = (0, import_types6.localDatabaseId)(serviceName, name);
+  const id = (0, import_types7.localDatabaseId)(serviceName, name);
   if (graph.hasNode(id)) return id;
   const node = {
     id,
-    type: import_types6.NodeType.DatabaseNode,
+    type: import_types7.NodeType.DatabaseNode,
     name,
     engine,
     engineVersion: "unknown",
@@ -3598,17 +4296,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_types6.EdgeType.CONTAINS) sources.push(e.target);
+    if (e.type === import_types7.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_types6.EdgeType.CONNECTS_TO || edge.provenance !== import_types6.Provenance.EXTRACTED) continue;
+      if (edge.type !== import_types7.EdgeType.CONNECTS_TO || edge.provenance !== import_types7.Provenance.EXTRACTED) continue;
       if (!graph.hasNode(edge.target)) continue;
       const target = graph.getNodeAttributes(edge.target);
-      if (target.type !== import_types6.NodeType.DatabaseNode || target.engine !== engine) continue;
+      if (target.type !== import_types7.NodeType.DatabaseNode || target.engine !== engine) continue;
       matches.add(edge.target);
     }
   }
@@ -3623,7 +4321,7 @@ function ensureFrontierNode(graph, host, ts) {
   }
   const node = {
     id,
-    type: import_types6.NodeType.FrontierNode,
+    type: import_types7.NodeType.FrontierNode,
     name: host,
     host,
     firstObserved: ts,
@@ -3647,11 +4345,11 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     };
     const updated = {
       ...existing,
-      provenance: import_types6.Provenance.OBSERVED,
+      provenance: import_types7.Provenance.OBSERVED,
       lastObserved: ts,
       callCount: newSpanCount,
       signal: newSignal,
-      confidence: (0, import_types6.confidenceForObservedSignal)(newSignal),
+      confidence: (0, import_types7.confidenceForObservedSignal)(newSignal),
       grain
       // backfills legacy edges that predate ADR-142
     };
@@ -3668,8 +4366,8 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     source,
     target,
     type,
-    provenance: import_types6.Provenance.OBSERVED,
-    confidence: (0, import_types6.confidenceForObservedSignal)(signal),
+    provenance: import_types7.Provenance.OBSERVED,
+    confidence: (0, import_types7.confidenceForObservedSignal)(signal),
     lastObserved: ts,
     callCount: 1,
     signal,
@@ -3691,9 +4389,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_types6.Provenance.EXTRACTED) continue;
+      if (edge.provenance !== import_types7.Provenance.EXTRACTED) continue;
       if (!STITCH_EDGE_TYPES.has(edge.type)) continue;
-      if (graph.hasEdge((0, import_types6.observedEdgeId)(edge.source, edge.target, edge.type))) continue;
+      if (graph.hasEdge((0, import_types7.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);
@@ -3715,23 +4413,23 @@ function upsertInferredEdge(graph, type, source, target, ts) {
     source,
     target,
     type,
-    provenance: import_types6.Provenance.INFERRED,
+    provenance: import_types7.Provenance.INFERRED,
     confidence: INFERRED_CONFIDENCE,
     lastObserved: ts
   };
   graph.addEdgeWithKey(id, source, target, edge);
 }
 async function appendErrorEvent(ctx, ev) {
-  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");
+  await import_node_fs9.promises.mkdir(import_node_path10.default.dirname(ctx.errorsPath), { recursive: true });
+  await import_node_fs9.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
 function incidentAffectedNode(span, graph, scanPath) {
-  const sid = (0, import_types6.serviceId)(span.service, span.env);
+  const sid = (0, import_types7.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_types6.fileId)(span.service, relPath);
+    return (0, import_types7.fileId)(span.service, relPath);
   }
   return sid;
 }
@@ -3831,7 +4529,7 @@ function findRouteNodeByHttpRoute(graph, serviceName, method, httpRoute) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types6.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types7.NodeType.RouteNode || a.service !== serviceName) return;
     if (m && a.method !== "ALL" && a.method !== m) return;
     if (normalizePathTemplate(a.pathTemplate) === target) found = id;
   });
@@ -3862,7 +4560,7 @@ async function handleSpan(ctx, span) {
       let targetId;
       if (host) {
         ensureDatabaseNode(ctx.graph, host, span.dbSystem);
-        targetId = (0, import_types6.databaseId)(host);
+        targetId = (0, import_types7.databaseId)(host);
       } else {
         const declared = findDeclaredDatabaseForService(ctx.graph, sourceId, span.dbSystem);
         if (declared) {
@@ -3879,7 +4577,7 @@ async function handleSpan(ctx, span) {
       }
       const result = upsertObservedEdge(
         ctx.graph,
-        import_types6.EdgeType.CONNECTS_TO,
+        import_types7.EdgeType.CONNECTS_TO,
         observedSource(),
         targetId,
         ts,
@@ -3891,7 +4589,7 @@ async function handleSpan(ctx, span) {
         const collectionId = ensureInfraNode(ctx.graph, "mongodb-collection", span.dbCollection, "self");
         upsertObservedEdge(
           ctx.graph,
-          import_types6.EdgeType.CALLS,
+          import_types7.EdgeType.CALLS,
           observedSource(),
           collectionId,
           ts,
@@ -3903,7 +4601,7 @@ async function handleSpan(ctx, span) {
         const tableId = ensureInfraNode(ctx.graph, "sql-table", span.dbTable, "self");
         upsertObservedEdge(
           ctx.graph,
-          import_types6.EdgeType.CALLS,
+          import_types7.EdgeType.CALLS,
           observedSource(),
           tableId,
           ts,
@@ -3919,7 +4617,7 @@ async function handleSpan(ctx, span) {
       span.messagingSystem,
       span.messagingDestination
     );
-    const edgeType = span.kind === WIRE_SPAN_KIND_CONSUMER ? import_types6.EdgeType.CONSUMES_FROM : import_types6.EdgeType.PUBLISHES_TO;
+    const edgeType = span.kind === WIRE_SPAN_KIND_CONSUMER ? import_types7.EdgeType.CONSUMES_FROM : import_types7.EdgeType.PUBLISHES_TO;
     const result = upsertObservedEdge(
       ctx.graph,
       edgeType,
@@ -3939,7 +4637,7 @@ async function handleSpan(ctx, span) {
     );
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types6.EdgeType.CONTAINS,
+      import_types7.EdgeType.CONTAINS,
       observedSource(),
       targetId,
       ts,
@@ -3951,7 +4649,7 @@ async function handleSpan(ctx, span) {
     const targetId = ensureGrpcMethodNode(ctx.graph, span.rpcService, span.rpcMethod);
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types6.EdgeType.CONTAINS,
+      import_types7.EdgeType.CONTAINS,
       observedSource(),
       targetId,
       ts,
@@ -3967,7 +4665,7 @@ async function handleSpan(ctx, span) {
     );
     const result = upsertObservedEdge(
       ctx.graph,
-      import_types6.EdgeType.CONNECTS_TO,
+      import_types7.EdgeType.CONNECTS_TO,
       observedSource(),
       targetId,
       ts,
@@ -3983,7 +4681,7 @@ async function handleSpan(ctx, span) {
       if (targetId && targetId !== sourceId) {
         upsertObservedEdge(
           ctx.graph,
-          import_types6.EdgeType.CALLS,
+          import_types7.EdgeType.CALLS,
           observedSource(),
           targetId,
           ts,
@@ -3996,7 +4694,7 @@ async function handleSpan(ctx, span) {
         const frontierNodeId = ensureFrontierNode(ctx.graph, host, ts);
         upsertObservedEdge(
           ctx.graph,
-          import_types6.EdgeType.CALLS,
+          import_types7.EdgeType.CALLS,
           observedSource(),
           frontierNodeId,
           ts,
@@ -4022,7 +4720,7 @@ async function handleSpan(ctx, span) {
         } : void 0;
         upsertObservedEdge(
           ctx.graph,
-          import_types6.EdgeType.CALLS,
+          import_types7.EdgeType.CALLS,
           fallbackSource,
           sourceId,
           ts,
@@ -4041,7 +4739,7 @@ async function handleSpan(ctx, span) {
     );
     if (routeNodeId) {
       const routeSvc = ctx.graph.getNodeAttributes(routeNodeId).service;
-      upsertObservedEdge(ctx.graph, import_types6.EdgeType.CONTAINS, (0, import_types6.serviceId)(routeSvc), routeNodeId, ts, isError);
+      upsertObservedEdge(ctx.graph, import_types7.EdgeType.CONTAINS, (0, import_types7.serviceId)(routeSvc), routeNodeId, ts, isError);
     }
   }
   if (span.statusCode === 2) {
@@ -4080,7 +4778,7 @@ function promoteFrontierNodes(graph, opts = {}) {
   const aliasIndex = /* @__PURE__ */ new Map();
   graph.forEachNode((id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types6.NodeType.ServiceNode) return;
+    if (a.type !== import_types7.NodeType.ServiceNode) return;
     aliasIndex.set(a.name, id);
     if (a.aliases) {
       for (const alias of a.aliases) aliasIndex.set(alias, id);
@@ -4089,7 +4787,7 @@ function promoteFrontierNodes(graph, opts = {}) {
   const toPromote = [];
   graph.forEachNode((id, attrs) => {
     const a = attrs;
-    if (a.type !== import_types6.NodeType.FrontierNode) return;
+    if (a.type !== import_types7.NodeType.FrontierNode) return;
     const target = aliasIndex.get(a.host);
     if (!target) return;
     if (target === id) return;
@@ -4123,7 +4821,7 @@ function rewireFrontierEdges(graph, frontierId2, serviceId7) {
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
   graph.dropEdge(oldEdgeId);
-  const newId = edge.provenance === import_types6.Provenance.OBSERVED ? (0, import_types6.observedEdgeId)(newSource, newTarget, edge.type) : edge.provenance === import_types6.Provenance.INFERRED ? (0, import_types6.inferredEdgeId)(newSource, newTarget, edge.type) : (0, import_types6.extractedEdgeId)(newSource, newTarget, edge.type);
+  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);
   if (graph.hasEdge(newId)) {
     const existing = graph.getEdgeAttributes(newId);
     const merged = {
@@ -4157,12 +4855,12 @@ async function markStaleEdges(graph, options = {}) {
   const project = options.project ?? DEFAULT_PROJECT;
   graph.forEachEdge((id, attrs) => {
     const e = attrs;
-    if (e.provenance !== import_types6.Provenance.OBSERVED) return;
+    if (e.provenance !== import_types7.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_types6.Provenance.STALE, confidence: 0.3 };
+      const updated = { ...e, provenance: import_types7.Provenance.STALE, confidence: 0.3 };
       graph.replaceEdgeAttributes(id, updated);
       events.push({
         edgeId: id,
@@ -4179,8 +4877,8 @@ async function markStaleEdges(graph, options = {}) {
         project,
         payload: {
           edgeId: id,
-          from: import_types6.Provenance.OBSERVED,
-          to: import_types6.Provenance.STALE
+          from: import_types7.Provenance.OBSERVED,
+          to: import_types7.Provenance.STALE
         }
       });
     }
@@ -4191,13 +4889,13 @@ async function markStaleEdges(graph, options = {}) {
   return { count: events.length, events };
 }
 async function appendStaleEvents(staleEventsPath, events) {
-  await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(staleEventsPath), { recursive: true });
+  await import_node_fs9.promises.mkdir(import_node_path10.default.dirname(staleEventsPath), { recursive: true });
   const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await import_node_fs8.promises.appendFile(staleEventsPath, lines, "utf8");
+  await import_node_fs9.promises.appendFile(staleEventsPath, lines, "utf8");
 }
 async function readStaleEvents(staleEventsPath) {
   try {
-    const raw = await import_node_fs8.promises.readFile(staleEventsPath, "utf8");
+    const raw = await import_node_fs9.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 [];
@@ -4231,7 +4929,7 @@ function startStalenessLoop(graph, options = {}) {
 }
 async function readErrorEvents(errorsPath) {
   try {
-    const raw = await import_node_fs8.promises.readFile(errorsPath, "utf8");
+    const raw = await import_node_fs9.promises.readFile(errorsPath, "utf8");
     const events = raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
     return dedupeIncidents(events);
   } catch (err) {
@@ -4289,7 +4987,7 @@ function mergeSnapshot(graph, snapshot) {
   const validEdges = [];
   for (const node of incomingNodes) {
     if (node.attributes === void 0) continue;
-    const parsed = import_types6.GraphNodeSchema.safeParse(node.attributes);
+    const parsed = import_types7.GraphNodeSchema.safeParse(node.attributes);
     if (!parsed.success) {
       issues.push(`node "${node.key}": ${describeZodIssues(parsed.error)}`);
       continue;
@@ -4298,7 +4996,7 @@ function mergeSnapshot(graph, snapshot) {
   }
   for (const edge of incomingEdges) {
     if (edge.attributes === void 0) continue;
-    const parsed = import_types6.GraphEdgeSchema.safeParse(edge.attributes);
+    const parsed = import_types7.GraphEdgeSchema.safeParse(edge.attributes);
     if (!parsed.success) {
       const label = edge.key ?? `${edge.source}->${edge.target}`;
       issues.push(`edge "${label}": ${describeZodIssues(parsed.error)}`);
@@ -4327,29 +5025,29 @@ function mergeSnapshot(graph, snapshot) {
 }
 
 // src/traverse.ts
-var import_types7 = require("@neat.is/types");
+var import_types8 = require("@neat.is/types");
 var ROOT_CAUSE_MAX_DEPTH = 5;
 var BLAST_RADIUS_DEFAULT_DEPTH = 10;
 function isFrontierNode(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types7.NodeType.FrontierNode;
+  return attrs.type === import_types8.NodeType.FrontierNode;
 }
 function resolveOwningService(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return null;
   const attrs = graph.getNodeAttributes(nodeId);
-  if (attrs.type === import_types7.NodeType.ServiceNode) {
+  if (attrs.type === import_types8.NodeType.ServiceNode) {
     return { id: nodeId, svc: attrs };
   }
-  if (attrs.type === import_types7.NodeType.FileNode || attrs.type === import_types7.NodeType.SymbolNode) {
+  if (attrs.type === import_types8.NodeType.FileNode || attrs.type === import_types8.NodeType.SymbolNode) {
     for (const edgeId of graph.inboundEdges(nodeId)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type !== import_types7.EdgeType.CONTAINS) continue;
+      if (e.type !== import_types8.EdgeType.CONTAINS) continue;
       const owner = graph.getNodeAttributes(e.source);
-      if (owner.type === import_types7.NodeType.ServiceNode) {
+      if (owner.type === import_types8.NodeType.ServiceNode) {
         return { id: e.source, svc: owner };
       }
-      if (owner.type === import_types7.NodeType.FileNode) {
+      if (owner.type === import_types8.NodeType.FileNode) {
         return resolveOwningService(graph, e.source);
       }
     }
@@ -4362,7 +5060,7 @@ function bestEdgeBySource(graph, edgeIds) {
     const e = graph.getEdgeAttributes(id);
     if (isFrontierNode(graph, e.source)) continue;
     const cur = best.get(e.source);
-    if (!cur || import_types7.PROV_RANK[e.provenance] > import_types7.PROV_RANK[cur.provenance]) {
+    if (!cur || import_types8.PROV_RANK[e.provenance] > import_types8.PROV_RANK[cur.provenance]) {
       best.set(e.source, e);
     }
   }
@@ -4374,7 +5072,7 @@ function bestEdgeByTarget(graph, edgeIds) {
     const e = graph.getEdgeAttributes(id);
     if (isFrontierNode(graph, e.target)) continue;
     const cur = best.get(e.target);
-    if (!cur || import_types7.PROV_RANK[e.provenance] > import_types7.PROV_RANK[cur.provenance]) {
+    if (!cur || import_types8.PROV_RANK[e.provenance] > import_types8.PROV_RANK[cur.provenance]) {
       best.set(e.target, e);
     }
   }
@@ -4536,10 +5234,10 @@ function symbolRootCauseShape(graph, origin, walk6) {
   return serviceRootCauseShape(graph, owner.svc, walk6);
 }
 var rootCauseShapes = {
-  [import_types7.NodeType.DatabaseNode]: databaseRootCauseShape,
-  [import_types7.NodeType.ServiceNode]: serviceRootCauseShape,
-  [import_types7.NodeType.FileNode]: fileRootCauseShape,
-  [import_types7.NodeType.SymbolNode]: symbolRootCauseShape
+  [import_types8.NodeType.DatabaseNode]: databaseRootCauseShape,
+  [import_types8.NodeType.ServiceNode]: serviceRootCauseShape,
+  [import_types8.NodeType.FileNode]: fileRootCauseShape,
+  [import_types8.NodeType.SymbolNode]: symbolRootCauseShape
 };
 function getRootCause(graph, errorNodeId, errorEvent, incidents) {
   if (!graph.hasNode(errorNodeId)) return null;
@@ -4550,7 +5248,7 @@ function getRootCause(graph, errorNodeId, errorEvent, incidents) {
     const match = shape(graph, origin, walk6);
     if (match) {
       const reason = errorEvent ? `${match.rootCauseReason} (observed error: ${errorEvent.errorMessage})` : match.rootCauseReason;
-      return import_types7.RootCauseResultSchema.parse({
+      return import_types8.RootCauseResultSchema.parse({
         rootCauseNode: match.rootCauseNode,
         rootCauseReason: reason,
         traversalPath: walk6.path,
@@ -4560,7 +5258,7 @@ function getRootCause(graph, errorNodeId, errorEvent, incidents) {
       });
     }
   }
-  if (origin.type === import_types7.NodeType.ServiceNode) {
+  if (origin.type === import_types8.NodeType.ServiceNode) {
     const crossService = crossServiceRootCause(graph, errorNodeId, incidents, errorEvent);
     if (crossService) return crossService;
   }
@@ -4600,8 +5298,8 @@ function rootCauseFromIncidents(nodeId, incidents, errorEvent) {
   const loc = localizeFromIncidents(nodeId, incidents, errorEvent);
   if (!loc) return null;
   const traversalPath = loc.fileNode ? [nodeId, loc.fileNode] : [nodeId];
-  const edgeProvenances = loc.fileNode ? [import_types7.Provenance.OBSERVED] : [];
-  return import_types7.RootCauseResultSchema.parse({
+  const edgeProvenances = loc.fileNode ? [import_types8.Provenance.OBSERVED] : [];
+  return import_types8.RootCauseResultSchema.parse({
     rootCauseNode: loc.rootCauseNode,
     rootCauseReason: loc.rootCauseReason,
     traversalPath,
@@ -4611,21 +5309,21 @@ function rootCauseFromIncidents(nodeId, incidents, errorEvent) {
   });
 }
 function isFailingCallEdge(e) {
-  return e.type === import_types7.EdgeType.CALLS && (e.signal?.errorCount ?? 0) > 0;
+  return e.type === import_types8.EdgeType.CALLS && (e.signal?.errorCount ?? 0) > 0;
 }
 function callSourcesForService(graph, serviceId7) {
   const ids = [serviceId7];
   for (const edgeId of graph.outboundEdges(serviceId7)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type !== import_types7.EdgeType.CONTAINS) continue;
+    if (e.type !== import_types8.EdgeType.CONTAINS) continue;
     const tgt = graph.getNodeAttributes(e.target);
-    if (tgt.type !== import_types7.NodeType.FileNode) continue;
+    if (tgt.type !== import_types8.NodeType.FileNode) continue;
     ids.push(e.target);
     for (const symEdgeId of graph.outboundEdges(e.target)) {
       const se = graph.getEdgeAttributes(symEdgeId);
-      if (se.type !== import_types7.EdgeType.CONTAINS) continue;
+      if (se.type !== import_types8.EdgeType.CONTAINS) continue;
       const sym = graph.getNodeAttributes(se.target);
-      if (sym.type === import_types7.NodeType.SymbolNode) ids.push(se.target);
+      if (sym.type === import_types8.NodeType.SymbolNode) ids.push(se.target);
     }
   }
   return ids;
@@ -4634,8 +5332,8 @@ function failingCallDominates(e, id, curEdge, curId) {
   const ec = e.signal?.errorCount ?? 0;
   const cc = curEdge.signal?.errorCount ?? 0;
   if (ec !== cc) return ec > cc;
-  if (import_types7.PROV_RANK[e.provenance] !== import_types7.PROV_RANK[curEdge.provenance]) {
-    return import_types7.PROV_RANK[e.provenance] > import_types7.PROV_RANK[curEdge.provenance];
+  if (import_types8.PROV_RANK[e.provenance] !== import_types8.PROV_RANK[curEdge.provenance]) {
+    return import_types8.PROV_RANK[e.provenance] > import_types8.PROV_RANK[curEdge.provenance];
   }
   return id < curId;
 }
@@ -4684,10 +5382,10 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
       path60.push(loc.fileNode);
-      edgeProvenances.push(import_types7.Provenance.OBSERVED);
+      edgeProvenances.push(import_types8.Provenance.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
-    return import_types7.RootCauseResultSchema.parse({
+    return import_types8.RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
       traversalPath: path60,
@@ -4699,7 +5397,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   const lastEdge = chain.edges[chain.edges.length - 1];
   const errs = lastEdge.signal?.errorCount ?? 0;
   const culpritName = culprit.replace(/^service:/, "");
-  return import_types7.RootCauseResultSchema.parse({
+  return import_types8.RootCauseResultSchema.parse({
     rootCauseNode: culprit,
     rootCauseReason: `${culpritName} is failing downstream calls (${errs} observed error${errs === 1 ? "" : "s"})`,
     traversalPath: path60,
@@ -4710,7 +5408,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
 }
 function getBlastRadius(graph, nodeId, maxDepth = BLAST_RADIUS_DEFAULT_DEPTH) {
   if (!graph.hasNode(nodeId)) {
-    return import_types7.BlastRadiusResultSchema.parse({ origin: nodeId, affectedNodes: [], totalAffected: 0 });
+    return import_types8.BlastRadiusResultSchema.parse({ origin: nodeId, affectedNodes: [], totalAffected: 0 });
   }
   const seen = /* @__PURE__ */ new Map();
   const queue = [{ nodeId, distance: 0, path: [nodeId], pathEdges: [] }];
@@ -4743,7 +5441,7 @@ function getBlastRadius(graph, nodeId, maxDepth = BLAST_RADIUS_DEFAULT_DEPTH) {
   const affectedNodes = [...seen.values()].sort(
     (a, b) => a.distance - b.distance || a.nodeId.localeCompare(b.nodeId)
   );
-  return import_types7.BlastRadiusResultSchema.parse({
+  return import_types8.BlastRadiusResultSchema.parse({
     origin: nodeId,
     affectedNodes,
     totalAffected: affectedNodes.length
@@ -4753,7 +5451,7 @@ var TRANSITIVE_DEPENDENCIES_DEFAULT_DEPTH = 3;
 var TRANSITIVE_DEPENDENCIES_MAX_DEPTH = 10;
 function getTransitiveDependencies(graph, nodeId, depth = TRANSITIVE_DEPENDENCIES_DEFAULT_DEPTH) {
   if (!graph.hasNode(nodeId)) {
-    return import_types7.TransitiveDependenciesResultSchema.parse({
+    return import_types8.TransitiveDependenciesResultSchema.parse({
       origin: nodeId,
       depth,
       dependencies: [],
@@ -4765,7 +5463,7 @@ function getTransitiveDependencies(graph, nodeId, depth = TRANSITIVE_DEPENDENCIE
   const enqueued = /* @__PURE__ */ new Set([nodeId]);
   while (queue.length > 0) {
     const frame = queue.shift();
-    if (frame.distance > 0 && frame.edge && frame.edge.type !== import_types7.EdgeType.CONTAINS) {
+    if (frame.distance > 0 && frame.edge && frame.edge.type !== import_types8.EdgeType.CONTAINS) {
       seen.set(frame.nodeId, {
         nodeId: frame.nodeId,
         distance: frame.distance,
@@ -4784,7 +5482,7 @@ function getTransitiveDependencies(graph, nodeId, depth = TRANSITIVE_DEPENDENCIE
   const dependencies = [...seen.values()].sort(
     (a, b) => a.distance - b.distance || a.nodeId.localeCompare(b.nodeId)
   );
-  return import_types7.TransitiveDependenciesResultSchema.parse({
+  return import_types8.TransitiveDependenciesResultSchema.parse({
     origin: nodeId,
     depth,
     dependencies,
@@ -4793,7 +5491,7 @@ function getTransitiveDependencies(graph, nodeId, depth = TRANSITIVE_DEPENDENCIE
 }
 function getObservedDependencies(graph, nodeId) {
   if (!graph.hasNode(nodeId)) {
-    return import_types7.ObservedDependenciesResultSchema.parse({
+    return import_types8.ObservedDependenciesResultSchema.parse({
       origin: nodeId,
       dependencies: [],
       observed: false,
@@ -4803,12 +5501,12 @@ function getObservedDependencies(graph, nodeId) {
   }
   const attrs = graph.getNodeAttributes(nodeId);
   const scope = [nodeId];
-  if (attrs.type === import_types7.NodeType.ServiceNode) {
+  if (attrs.type === import_types8.NodeType.ServiceNode) {
     for (const edgeId of graph.outboundEdges(nodeId)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type !== import_types7.EdgeType.CONTAINS) continue;
+      if (e.type !== import_types8.EdgeType.CONTAINS) continue;
       const owned = graph.getNodeAttributes(e.target);
-      if (owned.type === import_types7.NodeType.FileNode) scope.push(e.target);
+      if (owned.type === import_types8.NodeType.FileNode) scope.push(e.target);
     }
   }
   const dependencies = [];
@@ -4817,13 +5515,13 @@ function getObservedDependencies(graph, nodeId) {
   for (const src of scope) {
     for (const edgeId of graph.outboundEdges(src)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type === import_types7.EdgeType.CONTAINS) continue;
-      if (e.provenance === import_types7.Provenance.OBSERVED) {
+      if (e.type === import_types8.EdgeType.CONTAINS) continue;
+      if (e.provenance === import_types8.Provenance.OBSERVED) {
         if (!seenEdge.has(e.id)) {
           seenEdge.add(e.id);
           dependencies.push(e);
         }
-      } else if (e.provenance === import_types7.Provenance.EXTRACTED) {
+      } else if (e.provenance === import_types8.Provenance.EXTRACTED) {
         hasExtractedOutbound = true;
       }
     }
@@ -4832,14 +5530,14 @@ function getObservedDependencies(graph, nodeId) {
   for (const tgt of scope) {
     for (const edgeId of graph.inboundEdges(tgt)) {
       const e = graph.getEdgeAttributes(edgeId);
-      if (e.type === import_types7.EdgeType.CONTAINS) continue;
-      if (e.provenance === import_types7.Provenance.OBSERVED) inboundObservedCount += 1;
+      if (e.type === import_types8.EdgeType.CONTAINS) continue;
+      if (e.provenance === import_types8.Provenance.OBSERVED) inboundObservedCount += 1;
     }
   }
   dependencies.sort(
     (a, b) => a.target.localeCompare(b.target) || a.source.localeCompare(b.source) || a.id.localeCompare(b.id)
   );
-  return import_types7.ObservedDependenciesResultSchema.parse({
+  return import_types8.ObservedDependenciesResultSchema.parse({
     origin: nodeId,
     dependencies,
     observed: dependencies.length > 0 || inboundObservedCount > 0,
@@ -4853,34 +5551,34 @@ function bucketKey(source, target, type) {
   return `${type}|${source}|${target}`;
 }
 function bucketSourceFor(graph, edge) {
-  if (edge.type !== import_types8.EdgeType.CONNECTS_TO) return edge.source;
-  const parsed = (0, import_types8.parseFileId)(edge.source);
+  if (edge.type !== import_types9.EdgeType.CONNECTS_TO) return edge.source;
+  const parsed = (0, import_types9.parseFileId)(edge.source);
   if (!parsed || !graph.hasNode(edge.target)) return edge.source;
   const target = graph.getNodeAttributes(edge.target);
-  if (target.type !== import_types8.NodeType.DatabaseNode) return edge.source;
-  return (0, import_types8.serviceId)(parsed.service);
+  if (target.type !== import_types9.NodeType.DatabaseNode) return edge.source;
+  return (0, import_types9.serviceId)(parsed.service);
 }
 function bucketEdges(graph) {
   const buckets2 = /* @__PURE__ */ new Map();
   graph.forEachEdge((id, attrs) => {
     const e = attrs;
-    const parsed = (0, import_types8.parseEdgeId)(id);
+    const parsed = (0, import_types9.parseEdgeId)(id);
     const provenance = parsed?.provenance ?? e.provenance;
     const source = bucketSourceFor(graph, e);
     const key = bucketKey(source, e.target, e.type);
     const cur = buckets2.get(key) ?? { source, target: e.target, type: e.type };
     switch (provenance) {
-      case import_types8.Provenance.EXTRACTED:
+      case import_types9.Provenance.EXTRACTED:
         cur.extracted = e;
         break;
-      case import_types8.Provenance.OBSERVED:
+      case import_types9.Provenance.OBSERVED:
         cur.observed = e;
         break;
-      case import_types8.Provenance.INFERRED:
+      case import_types9.Provenance.INFERRED:
         cur.inferred = e;
         break;
       default:
-        if (e.provenance === import_types8.Provenance.STALE) cur.stale = e;
+        if (e.provenance === import_types9.Provenance.STALE) cur.stale = e;
     }
     buckets2.set(key, cur);
   });
@@ -4889,17 +5587,17 @@ function bucketEdges(graph) {
 function nodeIsFrontier(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types8.NodeType.FrontierNode;
+  return attrs.type === import_types9.NodeType.FrontierNode;
 }
 function nodeIsWebsocketChannel(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types8.NodeType.WebSocketChannelNode;
+  return attrs.type === import_types9.NodeType.WebSocketChannelNode;
 }
 function nodeIsSymbol(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types8.NodeType.SymbolNode;
+  return attrs.type === import_types9.NodeType.SymbolNode;
 }
 function clampConfidence(n) {
   if (!Number.isFinite(n)) return 0;
@@ -4919,14 +5617,14 @@ function gradedConfidence(edge) {
   return clampConfidence(confidenceForEdge(edge));
 }
 var OBSERVABLE_EDGE_TYPES = /* @__PURE__ */ new Set([
-  import_types8.EdgeType.CALLS,
-  import_types8.EdgeType.CONNECTS_TO,
-  import_types8.EdgeType.PUBLISHES_TO,
-  import_types8.EdgeType.CONSUMES_FROM
+  import_types9.EdgeType.CALLS,
+  import_types9.EdgeType.CONNECTS_TO,
+  import_types9.EdgeType.PUBLISHES_TO,
+  import_types9.EdgeType.CONSUMES_FROM
 ]);
 function detectMissingDivergences(graph, bucket) {
   const out = [];
-  if (bucket.type === import_types8.EdgeType.CONTAINS) return out;
+  if (bucket.type === import_types9.EdgeType.CONTAINS) return out;
   if (nodeIsSymbol(graph, bucket.source) || nodeIsSymbol(graph, bucket.target)) return out;
   if (bucket.extracted && !bucket.observed && OBSERVABLE_EDGE_TYPES.has(bucket.type)) {
     if (!nodeIsFrontier(graph, bucket.target)) {
@@ -4968,7 +5666,7 @@ function declaredHostFor(svc) {
 function hasExtractedConfiguredBy(graph, svcId) {
   for (const edgeId of graph.outboundEdges(svcId)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type === import_types8.EdgeType.CONFIGURED_BY && e.provenance === import_types8.Provenance.EXTRACTED) {
+    if (e.type === import_types9.EdgeType.CONFIGURED_BY && e.provenance === import_types9.Provenance.EXTRACTED) {
       return true;
     }
   }
@@ -4981,10 +5679,10 @@ function detectHostMismatch(graph, svcId, svc) {
   const out = [];
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types8.EdgeType.CONNECTS_TO) continue;
-    if (edge.provenance !== import_types8.Provenance.OBSERVED) continue;
+    if (edge.type !== import_types9.EdgeType.CONNECTS_TO) continue;
+    if (edge.provenance !== import_types9.Provenance.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== import_types8.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types9.NodeType.DatabaseNode) continue;
     const observedHost = target.host?.trim();
     if (!observedHost) continue;
     if (observedHost === declaredHost) continue;
@@ -5006,10 +5704,10 @@ function detectCompatDivergences(graph, svcId, svc) {
   const deps = svc.dependencies ?? {};
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types8.EdgeType.CONNECTS_TO) continue;
-    if (edge.provenance !== import_types8.Provenance.OBSERVED) continue;
+    if (edge.type !== import_types9.EdgeType.CONNECTS_TO) continue;
+    if (edge.provenance !== import_types9.Provenance.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== import_types8.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types9.NodeType.DatabaseNode) continue;
     for (const pair of compatPairs()) {
       if (pair.engine !== target.engine) continue;
       const declared = deps[pair.driver];
@@ -5106,7 +5804,7 @@ function suppressHostMismatchHalves(all) {
   for (const d of all) {
     if (d.type !== "host-mismatch") continue;
     observedHalf.add(`${d.source}->${d.target}`);
-    declaredHalf.add((0, import_types8.databaseId)(d.extractedHost));
+    declaredHalf.add((0, import_types9.databaseId)(d.extractedHost));
   }
   if (observedHalf.size === 0) return all;
   return all.filter((d) => {
@@ -5125,13 +5823,13 @@ function computeDivergences(graph, opts = {}) {
   }
   graph.forEachNode((nodeId, attrs) => {
     const n = attrs;
-    if (n.type === import_types8.NodeType.ServiceNode) {
+    if (n.type === import_types9.NodeType.ServiceNode) {
       const svc = n;
       for (const d of detectHostMismatch(graph, nodeId, svc)) all.push(d);
       for (const d of detectCompatDivergences(graph, nodeId, svc)) all.push(d);
       return;
     }
-    if (n.type === import_types8.NodeType.InfraNode && n.kind === "sql-table") {
+    if (n.type === import_types9.NodeType.InfraNode && n.kind === "sql-table") {
       for (const d of detectColumnDrift(n)) all.push(d);
     }
   });
@@ -5167,7 +5865,7 @@ function computeDivergences(graph, opts = {}) {
     const bc = "column" in b && b.column ? b.column : "";
     return ac.localeCompare(bc);
   });
-  return import_types8.DivergenceResultSchema.parse({
+  return import_types9.DivergenceResultSchema.parse({
     divergences: filtered,
     totalAffected: filtered.length,
     computedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -5227,16 +5925,16 @@ init_cjs_shims();
 
 // src/extract/services.ts
 init_cjs_shims();
-var import_node_fs12 = require("fs");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs13 = require("fs");
+var import_node_path14 = __toESM(require("path"), 1);
 var import_ignore = __toESM(require("ignore"), 1);
 var import_minimatch2 = require("minimatch");
-var import_types10 = require("@neat.is/types");
+var import_types11 = require("@neat.is/types");
 
 // src/extract/python.ts
 init_cjs_shims();
-var import_node_fs9 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
+var import_node_path11 = __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) {
@@ -5269,25 +5967,25 @@ function depsFromPyProject(pyproject) {
   return out;
 }
 async function discoverPythonService(serviceDir) {
-  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 pyprojectPath = import_node_path11.default.join(serviceDir, "pyproject.toml");
+  const requirementsPath = import_node_path11.default.join(serviceDir, "requirements.txt");
+  const setupPath = import_node_path11.default.join(serviceDir, "setup.py");
   const hasPyproject = await exists2(pyprojectPath);
   const hasRequirements = await exists2(requirementsPath);
   const hasSetup = await exists2(setupPath);
   if (!hasPyproject && !hasRequirements && !hasSetup) return null;
-  let name = import_node_path10.default.basename(serviceDir);
+  let name = import_node_path11.default.basename(serviceDir);
   let version;
   const dependencies = {};
   if (hasPyproject) {
-    const raw = await import_node_fs9.promises.readFile(pyprojectPath, "utf8");
+    const raw = await import_node_fs10.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_fs9.promises.readFile(requirementsPath, "utf8");
+    const raw = await import_node_fs10.promises.readFile(requirementsPath, "utf8");
     Object.assign(dependencies, parseRequirementsTxt(raw));
   }
   return { name, version, dependencies };
@@ -5302,9 +6000,9 @@ function pythonToPackage(service) {
 
 // src/extract/go.ts
 init_cjs_shims();
-var import_node_fs10 = require("fs");
-var import_node_path11 = __toESM(require("path"), 1);
-var import_types9 = require("@neat.is/types");
+var import_node_fs11 = require("fs");
+var import_node_path12 = __toESM(require("path"), 1);
+var import_types10 = require("@neat.is/types");
 function parseGoMod(source) {
   const module2 = source.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
   if (!module2) return null;
@@ -5323,7 +6021,7 @@ function parseGoMod(source) {
 async function discoverGoService(scanPath, dir) {
   let raw;
   try {
-    raw = await import_node_fs10.promises.readFile(import_node_path11.default.join(dir, "go.mod"), "utf8");
+    raw = await import_node_fs11.promises.readFile(import_node_path12.default.join(dir, "go.mod"), "utf8");
   } catch {
     return null;
   }
@@ -5332,12 +6030,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_types9.serviceId)(name),
-    type: import_types9.NodeType.ServiceNode,
+    id: (0, import_types10.serviceId)(name),
+    type: import_types10.NodeType.ServiceNode,
     name,
     language: "go",
     dependencies: mod.dependencies,
-    repoPath: import_node_path11.default.relative(scanPath, dir),
+    repoPath: import_node_path12.default.relative(scanPath, dir),
     ...mod.dependencies["github.com/gin-gonic/gin"] ? { framework: "gin" } : {}
   };
   return { pkg, dir, node };
@@ -5345,17 +6043,17 @@ async function discoverGoService(scanPath, dir) {
 
 // src/extract/owners.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_minimatch = require("minimatch");
 async function loadCodeowners(scanPath) {
   const candidates = [
-    import_node_path12.default.join(scanPath, "CODEOWNERS"),
-    import_node_path12.default.join(scanPath, ".github", "CODEOWNERS")
+    import_node_path13.default.join(scanPath, "CODEOWNERS"),
+    import_node_path13.default.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists2(file)) {
-      const raw = await import_node_fs11.promises.readFile(file, "utf8");
+      const raw = await import_node_fs12.promises.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -5373,7 +6071,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(import_node_path12.default.sep).join("/");
+  const normalized = repoPath.split(import_node_path13.default.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -5389,7 +6087,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = import_node_path12.default.join(serviceDir, "package.json");
+  const pkgPath = import_node_path13.default.join(serviceDir, "package.json");
   if (!await exists2(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -5426,27 +6124,27 @@ function workspaceGlobs(pkg) {
   return null;
 }
 async function hasPythonManifest(dir) {
-  return await exists2(import_node_path13.default.join(dir, "pyproject.toml")) || await exists2(import_node_path13.default.join(dir, "requirements.txt")) || await exists2(import_node_path13.default.join(dir, "setup.py"));
+  return await exists2(import_node_path14.default.join(dir, "pyproject.toml")) || await exists2(import_node_path14.default.join(dir, "requirements.txt")) || await exists2(import_node_path14.default.join(dir, "setup.py"));
 }
 async function hasGoManifest(dir) {
-  return exists2(import_node_path13.default.join(dir, "go.mod"));
+  return exists2(import_node_path14.default.join(dir, "go.mod"));
 }
 async function loadGitignore(scanPath) {
-  const gitignorePath = import_node_path13.default.join(scanPath, ".gitignore");
+  const gitignorePath = import_node_path14.default.join(scanPath, ".gitignore");
   if (!await exists2(gitignorePath)) return null;
-  const raw = await import_node_fs12.promises.readFile(gitignorePath, "utf8");
+  const raw = await import_node_fs13.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_fs12.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs13.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path13.default.join(current, entry.name);
+      const child = import_node_path14.default.join(current, entry.name);
       if (options.ig) {
-        const rel = import_node_path13.default.relative(scanPath, child).split(import_node_path13.default.sep).join("/");
+        const rel = import_node_path14.default.relative(scanPath, child).split(import_node_path14.default.sep).join("/");
         if (rel && options.ig.ignores(rel + "/")) continue;
       }
       if (await isPythonVenvDir(child)) continue;
@@ -5462,8 +6160,8 @@ async function expandWorkspaceGlobs(scanPath, globs) {
   for (const raw of globs) {
     const pattern = raw.replace(/^\.\//, "");
     if (!pattern.includes("*")) {
-      const candidate = import_node_path13.default.join(scanPath, pattern);
-      if (await exists2(import_node_path13.default.join(candidate, "package.json"))) found.add(candidate);
+      const candidate = import_node_path14.default.join(scanPath, pattern);
+      if (await exists2(import_node_path14.default.join(candidate, "package.json"))) found.add(candidate);
       continue;
     }
     const segments = pattern.split("/");
@@ -5472,13 +6170,13 @@ async function expandWorkspaceGlobs(scanPath, globs) {
       if (seg.includes("*")) break;
       staticSegments.push(seg);
     }
-    const start = import_node_path13.default.join(scanPath, ...staticSegments);
+    const start = import_node_path14.default.join(scanPath, ...staticSegments);
     if (!await exists2(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 exists2(import_node_path13.default.join(dir, "package.json"))) {
+      const rel = import_node_path14.default.relative(scanPath, dir).split(import_node_path14.default.sep).join("/");
+      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists2(import_node_path14.default.join(dir, "package.json"))) {
         found.add(dir);
       }
     });
@@ -5501,31 +6199,31 @@ function detectJsFramework(pkg) {
 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(() => []);
+  const entries = await import_node_fs13.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");
+  const pkgPath = import_node_path14.default.join(dir, "package.json");
   if (!await exists2(pkgPath)) return null;
   let pkg;
   try {
     pkg = await readJson(pkgPath);
   } catch (err) {
-    recordExtractionError("services", import_node_path13.default.relative(scanPath, pkgPath), err);
+    recordExtractionError("services", import_node_path14.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,
+    id: (0, import_types11.serviceId)(pkg.name),
+    type: import_types11.NodeType.ServiceNode,
     name: pkg.name,
     language,
     version: pkg.version,
     dependencies: pkg.dependencies ?? {},
-    repoPath: import_node_path13.default.relative(scanPath, dir),
+    repoPath: import_node_path14.default.relative(scanPath, dir),
     ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
     ...framework ? { framework } : {}
   };
@@ -5536,18 +6234,18 @@ async function discoverPyService(scanPath, dir) {
   if (!py) return null;
   const pkg = pythonToPackage(py);
   const node = {
-    id: (0, import_types10.serviceId)(py.name),
-    type: import_types10.NodeType.ServiceNode,
+    id: (0, import_types11.serviceId)(py.name),
+    type: import_types11.NodeType.ServiceNode,
     name: py.name,
     language: "python",
     version: py.version,
     dependencies: py.dependencies,
-    repoPath: import_node_path13.default.relative(scanPath, dir)
+    repoPath: import_node_path14.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 async function discoverServices(scanPath) {
-  const rootPkgPath = import_node_path13.default.join(scanPath, "package.json");
+  const rootPkgPath = import_node_path14.default.join(scanPath, "package.json");
   let rootPkg = null;
   if (await exists2(rootPkgPath)) {
     try {
@@ -5555,7 +6253,7 @@ async function discoverServices(scanPath) {
     } catch (err) {
       recordExtractionError(
         "services workspaces",
-        import_node_path13.default.relative(scanPath, rootPkgPath),
+        import_node_path14.default.relative(scanPath, rootPkgPath),
         err
       );
     }
@@ -5576,7 +6274,7 @@ async function discoverServices(scanPath) {
       scanPath,
       { maxDepth: parseScanDepth(), ig },
       async (dir) => {
-        if (await exists2(import_node_path13.default.join(dir, "package.json"))) {
+        if (await exists2(import_node_path14.default.join(dir, "package.json"))) {
           candidateDirs.push(dir);
         } else if (await hasPythonManifest(dir) || await hasGoManifest(dir)) {
           candidateDirs.push(dir);
@@ -5592,8 +6290,8 @@ async function discoverServices(scanPath) {
     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) || ".";
+      const a = import_node_path14.default.relative(scanPath, existingDir) || ".";
+      const b = import_node_path14.default.relative(scanPath, dir) || ".";
       console.warn(
         `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
       );
@@ -5630,10 +6328,10 @@ function addServiceNodes(graph, services) {
 
 // src/extract/aliases.ts
 init_cjs_shims();
-var import_node_path14 = __toESM(require("path"), 1);
-var import_node_fs13 = require("fs");
+var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs14 = require("fs");
 var import_yaml2 = require("yaml");
-var import_types11 = require("@neat.is/types");
+var import_types12 = require("@neat.is/types");
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
   "Service",
   "Deployment",
@@ -5643,7 +6341,7 @@ var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
 function addAliases(graph, serviceId7, candidates) {
   if (!graph.hasNode(serviceId7)) return;
   const node = graph.getNodeAttributes(serviceId7);
-  if (node.type !== import_types11.NodeType.ServiceNode) return;
+  if (node.type !== import_types12.NodeType.ServiceNode) return;
   const set = new Set(node.aliases ?? []);
   for (const c of candidates) {
     if (!c) continue;
@@ -5658,14 +6356,14 @@ 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);
+    map.set(import_node_path15.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_path14.default.join(scanPath, name);
+    const abs = import_node_path15.default.join(scanPath, name);
     if (await exists2(abs)) {
       composePath = abs;
       break;
@@ -5678,7 +6376,7 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   } catch (err) {
     recordExtractionError(
       "aliases compose",
-      import_node_path14.default.relative(scanPath, composePath),
+      import_node_path15.default.relative(scanPath, composePath),
       err
     );
     return;
@@ -5721,11 +6419,11 @@ function parseDockerfileLabels(content) {
 }
 async function collectDockerfileAliases(graph, services) {
   for (const service of services) {
-    const dockerfilePath = import_node_path14.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path15.default.join(service.dir, "Dockerfile");
     if (!await exists2(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs13.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs14.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError("aliases dockerfile", dockerfilePath, err);
       continue;
@@ -5737,15 +6435,15 @@ async function collectDockerfileAliases(graph, services) {
 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(() => []);
+  const entries = await import_node_fs14.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path14.default.join(start, entry.name);
+      const child = import_node_path15.default.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles(child, depth + 1, max));
-    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path14.default.extname(entry.name))) {
-      out.push(import_node_path14.default.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path15.default.extname(entry.name))) {
+      out.push(import_node_path15.default.join(start, entry.name));
     }
   }
   return out;
@@ -5772,614 +6470,230 @@ function k8sServiceTarget(doc, byName) {
 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");
+    const content = await import_node_fs14.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_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 { nodesAdded, edgesAdded };
-}
-
-// src/extract/symbols.ts
-init_cjs_shims();
-var import_node_path16 = __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_types12 = 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);
+      docs = (0, import_yaml2.parseAllDocuments)(content).map((d) => d.toJSON());
+    } catch {
+      continue;
     }
-    return parser;
-  };
+    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_path16 = __toESM(require("path"), 1);
+async function addFiles(graph, services) {
   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_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 = 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(
+    const filePaths = await walkSourceFiles(service.dir);
+    for (const filePath of filePaths) {
+      const relPath = toPosix(import_node_path16.default.relative(service.dir, filePath));
+      const { nodesAdded: n, edgesAdded: e } = 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++;
-        }
-      }
+      nodesAdded += n;
+      edgesAdded += e;
     }
   }
   return { nodesAdded, edgesAdded };
 }
 
-// src/extract/symbol-edges.ts
-init_cjs_shims();
-var import_node_path18 = __toESM(require("path"), 1);
-var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
-var import_types14 = require("@neat.is/types");
-
-// src/extract/imports.ts
+// src/extract/symbols.ts
 init_cjs_shims();
 var import_node_path17 = __toESM(require("path"), 1);
-var import_node_fs14 = 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_tree_sitter_typescript = __toESM(require("tree-sitter-typescript"), 1);
 var import_types13 = 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)
-  );
-}
-function makeJsParser2() {
-  const p = new import_tree_sitter3.default();
-  p.setLanguage(import_tree_sitter_javascript3.default);
-  return p;
-}
-function makePyParser2() {
-  const p = new import_tree_sitter3.default();
-  p.setLanguage(import_tree_sitter_python2.default);
-  return p;
-}
-function makeGoParser2() {
-  const p = new import_tree_sitter3.default();
-  p.setLanguage(import_tree_sitter_go2.default);
-  return p;
-}
-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 clipSnippet(text) {
-  const oneLine = text.split("\n")[0] ?? text;
-  return oneLine.length > 120 ? oneLine.slice(0, 120) : oneLine;
-}
-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) collectGoImports(child, out);
-  }
-}
-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;
-  }
-  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) });
-        }
-      }
-    }
-  }
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child) collectJsImports(child, out);
-  }
-}
-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);
-  }
-}
-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) });
-    }
-  }
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child) collectPyImports(child, out);
-  }
-}
-async function fileExists2(p) {
-  try {
-    await import_node_fs14.promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isWithinServiceDir(candidate, serviceDir) {
-  const rel = import_node_path17.default.relative(serviceDir, candidate);
-  return rel !== "" && !rel.startsWith("..") && !import_node_path17.default.isAbsolute(rel);
-}
-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 fileExists2(candidate)) {
-      return toPosix(import_node_path17.default.relative(serviceDir, candidate));
-    }
-  }
-  for (const indexFile of JS_INDEX_FILES) {
-    const candidate = import_node_path17.default.join(base, indexFile);
-    if (isWithinServiceDir(candidate, serviceDir) && await fileExists2(candidate)) {
-      return toPosix(import_node_path17.default.relative(serviceDir, candidate));
-    }
-  }
-  return null;
-}
-async function loadTsPathConfig(serviceDir) {
-  const tsconfigPath = import_node_path17.default.join(serviceDir, "tsconfig.json");
-  let raw;
-  try {
-    raw = await import_node_fs14.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_path17.default.resolve(serviceDir, baseUrl) : serviceDir };
-  } catch (err) {
-    recordExtractionError("import alias resolution", tsconfigPath, err);
-    return null;
-  }
+  );
 }
-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_path17.default.resolve(config.baseDir, targetBase, suffix);
-      const hit = await firstExistingCandidate(resolvedBase, serviceDir);
-      if (hit) return hit;
-      if (isWithinServiceDir(resolvedBase, serviceDir) && await fileExists2(resolvedBase)) {
-        return toPosix(import_node_path17.default.relative(serviceDir, resolvedBase));
-      }
-    }
-  }
-  return null;
+function methodName(node) {
+  const name = node.childForFieldName("name");
+  return name ? name.text : null;
 }
-async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
-  if (!specifier) return null;
-  if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    const base = import_node_path17.default.resolve(importerDir, specifier);
-    const ext = import_node_path17.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 fileExists2(tsSibling)) {
-          return toPosix(import_node_path17.default.relative(serviceDir, tsSibling));
+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 fileExists2(base)) {
-        return toPosix(import_node_path17.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_path17.default.dirname(importerPath);
-    for (let i = 1; i < imp.level; i++) baseDir = import_node_path17.default.dirname(baseDir);
-  } else {
-    baseDir = serviceDir;
-  }
-  const moduleBase = imp.modulePath ? import_node_path17.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_path17.default.join(moduleBase, `${name}.py`);
-    const subpackageInit = import_node_path17.default.join(moduleBase, name, "__init__.py");
-    if (isWithinServiceDir(submoduleFile, serviceDir) && await fileExists2(submoduleFile)) {
-      resolved.add(toPosix(import_node_path17.default.relative(serviceDir, submoduleFile)));
-    } else if (isWithinServiceDir(subpackageInit, serviceDir) && await fileExists2(subpackageInit)) {
-      resolved.add(toPosix(import_node_path17.default.relative(serviceDir, subpackageInit)));
-    } else {
-      needModuleFile = true;
-    }
-  }
-  if (needModuleFile) {
-    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, import_node_path17.default.join(moduleBase, "__init__.py")] : [import_node_path17.default.join(moduleBase, "__init__.py")];
-    for (const candidate of moduleFileCandidates) {
-      if (isWithinServiceDir(candidate, serviceDir) && await fileExists2(candidate)) {
-        resolved.add(toPosix(import_node_path17.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_path17.default.join(serviceDir, suffix);
-  const entries = await import_node_fs14.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
-  const candidates = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".go") && !entry.name.endsWith("_test.go")).map((entry) => import_node_path17.default.join(dir, entry.name));
-  if (candidates.length !== 1) return null;
-  return toPosix(import_node_path17.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_types13.fileId)(serviceName, importeeRelPath);
-  if (!graph.hasNode(importeeFileId)) return 0;
-  const edgeId = (0, import_types13.extractedEdgeId)(importerFileId, importeeFileId, import_types13.EdgeType.IMPORTS);
-  if (graph.hasEdge(edgeId)) return 0;
-  const edge = {
-    id: edgeId,
-    source: importerFileId,
-    target: importeeFileId,
-    type: import_types13.EdgeType.IMPORTS,
-    provenance: import_types13.Provenance.EXTRACTED,
-    confidence: (0, import_types13.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_path17.default.relative(service.dir, file.path));
-      const importerFileId = (0, import_types13.fileId)(service.pkg.name, relFile);
-      const isPython = import_node_path17.default.extname(file.path) === ".py";
-      const isGo = import_node_path17.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_fs14.promises.readFile(import_node_path17.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_path17.default.extname(file.path));
+      if (!parser) continue;
+      const relPath = toPosix(import_node_path17.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_path17.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_types13.symbolId)(service.pkg.name, relPath, def.qualname, disambiguator);
+        if (!graph.hasNode(sid)) {
+          const node = {
+            id: sid,
+            type: import_types13.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_types13.extractedEdgeId)(fileNodeId, sid, import_types13.EdgeType.CONTAINS);
+        if (!graph.hasEdge(containsId)) {
+          const edge = {
+            id: containsId,
+            source: fileNodeId,
+            target: sid,
+            type: import_types13.EdgeType.CONTAINS,
+            provenance: import_types13.Provenance.EXTRACTED,
+            confidence: (0, import_types13.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_path18 = __toESM(require("path"), 1);
+var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
+var import_types14 = require("@neat.is/types");
 function extendsInfo(classHeritage) {
   for (let i = 0; i < classHeritage.namedChildCount; i++) {
     const child = classHeritage.namedChild(i);
@@ -6490,7 +6804,7 @@ async function addSymbolEdges(graph, services) {
       const fileDir = import_node_path18.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;
@@ -8942,7 +9256,7 @@ function columnsFromObject(obj) {
 }
 function drizzleEndpointsFromFile(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource2(parserForExt(import_node_path39.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt(import_node_path39.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk6 = (node) => {