@neat.is/core 0.8.1 → 0.8.2-dev.20260818

package/dist/{chunk-ZGZYZ33B.js → chunk-T4UGEMWN.js}

@@ -961,7 +961,7 @@ import { promises as fs3 } from "fs";
 import path3 from "path";
 import { parse as parseYaml } from "yaml";
 import { extractedEdgeId } from "@neat.is/types";
-var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rb", ".php"]);
+var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rb", ".php", ".cs", ".java"]);
 var CONFIG_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
 var JSON_CONFIG_FILENAMES = /* @__PURE__ */ new Set(["app.json", "app.config.json", "eas.json"]);
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
@@ -1301,6 +1301,10 @@ function languageForPath(relPath) {
       return "ruby";
     case ".php":
       return "php";
+    case ".cs":
+      return "csharp";
+    case ".java":
+      return "java";
     case ".ts":
     case ".tsx":
       return "typescript";
@@ -1842,8 +1846,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path64) {
-  return path64.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path67) {
+  return path67.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -2515,9 +2519,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path64 = rubyLiteral(k);
-    if (path64 === null) continue;
-    return { path: path64, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path67 = rubyLiteral(k);
+    if (path67 === null) continue;
+    return { path: path67, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -4634,29 +4638,29 @@ function promoteFrontierNodes(graph, opts = {}) {
     toPromote.push({ frontierId: id, serviceId: target });
   });
   let promoted = 0;
-  for (const { frontierId: frontierId2, serviceId: serviceId9 } of toPromote) {
+  for (const { frontierId: frontierId2, serviceId: serviceId12 } of toPromote) {
     if (opts.policies && opts.policies.length > 0 && opts.policyCtx) {
       const gate = canPromoteFrontier(graph, frontierId2, opts.policies, opts.policyCtx);
       if (!gate.allowed) {
         continue;
       }
     }
-    rewireFrontierEdges(graph, frontierId2, serviceId9);
+    rewireFrontierEdges(graph, frontierId2, serviceId12);
     graph.dropNode(frontierId2);
     promoted++;
   }
   return promoted;
 }
-function rewireFrontierEdges(graph, frontierId2, serviceId9) {
+function rewireFrontierEdges(graph, frontierId2, serviceId12) {
   const inbound = [...graph.inboundEdges(frontierId2)];
   const outbound = [...graph.outboundEdges(frontierId2)];
   for (const edgeId of inbound) {
     const edge = graph.getEdgeAttributes(edgeId);
-    rebuildEdge(graph, edge, edge.source, serviceId9, edgeId);
+    rebuildEdge(graph, edge, edge.source, serviceId12, edgeId);
   }
   for (const edgeId of outbound) {
     const edge = graph.getEdgeAttributes(edgeId);
-    rebuildEdge(graph, edge, serviceId9, edge.target, edgeId);
+    rebuildEdge(graph, edge, serviceId12, edge.target, edgeId);
   }
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
@@ -4988,19 +4992,19 @@ function confidenceFromMix(edges, now = Date.now()) {
 function longestIncomingWalk(graph, start, maxDepth) {
   let best = { path: [start], edges: [] };
   const visited = /* @__PURE__ */ new Set([start]);
-  function step(node, path64, edges) {
-    if (path64.length > best.path.length) {
-      best = { path: [...path64], edges: [...edges] };
+  function step(node, path67, edges) {
+    if (path67.length > best.path.length) {
+      best = { path: [...path67], edges: [...edges] };
     }
-    if (path64.length - 1 >= maxDepth) return;
+    if (path67.length - 1 >= maxDepth) return;
     const incoming = bestEdgeBySource(graph, graph.inboundEdges(node));
     for (const [srcId, edge] of incoming) {
       if (visited.has(srcId)) continue;
       visited.add(srcId);
-      path64.push(srcId);
+      path67.push(srcId);
       edges.push(edge);
-      step(srcId, path64, edges);
-      path64.pop();
+      step(srcId, path67, edges);
+      path67.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -5015,7 +5019,7 @@ function databaseRootCauseShape(graph, origin, walk9) {
   for (const id of walk9.path) {
     const owner = resolveOwningService(graph, id);
     if (!owner) continue;
-    const { id: serviceId9, svc } = owner;
+    const { id: serviceId12, svc } = owner;
     const deps = svc.dependencies ?? {};
     for (const pair of candidatePairs) {
       const declared = deps[pair.driver];
@@ -5028,7 +5032,7 @@ function databaseRootCauseShape(graph, origin, walk9) {
       );
       if (!result.compatible) {
         return {
-          rootCauseNode: serviceId9,
+          rootCauseNode: serviceId12,
           rootCauseReason: result.reason ?? "incompatible driver",
           ...result.minDriverVersion ? {
             fixRecommendation: `Upgrade ${svc.name} ${pair.driver} driver to >= ${result.minDriverVersion}`
@@ -5043,7 +5047,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
   for (const id of walk9.path) {
     const owner = resolveOwningService(graph, id);
     if (!owner) continue;
-    const { id: serviceId9, svc } = owner;
+    const { id: serviceId12, svc } = owner;
     const deps = svc.dependencies ?? {};
     const serviceNodeEngine = svc.nodeEngine;
     for (const constraint of nodeEngineConstraints()) {
@@ -5052,7 +5056,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
       const result = checkNodeEngineConstraint(constraint, declared, serviceNodeEngine);
       if (!result.compatible && result.reason) {
         return {
-          rootCauseNode: serviceId9,
+          rootCauseNode: serviceId12,
           rootCauseReason: result.reason,
           ...result.requiredNodeVersion ? {
             fixRecommendation: `Bump ${svc.name}'s engines.node to >= ${result.requiredNodeVersion}`
@@ -5067,7 +5071,7 @@ function serviceRootCauseShape(graph, _origin, walk9) {
       const result = checkPackageConflict(conflict, declared, requiredDeclared);
       if (!result.compatible && result.reason) {
         return {
-          rootCauseNode: serviceId9,
+          rootCauseNode: serviceId12,
           rootCauseReason: result.reason,
           fixRecommendation: `Upgrade ${svc.name}'s ${conflict.requires.name} to >= ${conflict.requires.minVersion}`
         };
@@ -5168,9 +5172,9 @@ function rootCauseFromIncidents(nodeId, incidents, errorEvent) {
 function isFailingCallEdge(e) {
   return e.type === EdgeType6.CALLS && (e.signal?.errorCount ?? 0) > 0;
 }
-function callSourcesForService(graph, serviceId9) {
-  const ids = [serviceId9];
-  for (const edgeId of graph.outboundEdges(serviceId9)) {
+function callSourcesForService(graph, serviceId12) {
+  const ids = [serviceId12];
+  for (const edgeId of graph.outboundEdges(serviceId12)) {
     const e = graph.getEdgeAttributes(edgeId);
     if (e.type !== EdgeType6.CONTAINS) continue;
     const tgt = graph.getNodeAttributes(e.target);
@@ -5194,9 +5198,9 @@ function failingCallDominates(e, id, curEdge, curId) {
   }
   return id < curId;
 }
-function dominantFailingCall(graph, serviceId9, visited) {
+function dominantFailingCall(graph, serviceId12, visited) {
   let best = null;
-  for (const src of callSourcesForService(graph, serviceId9)) {
+  for (const src of callSourcesForService(graph, serviceId12)) {
     for (const edgeId of graph.outboundEdges(src)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (!isFailingCallEdge(e)) continue;
@@ -5211,26 +5215,26 @@ function dominantFailingCall(graph, serviceId9, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path64 = [originServiceId];
+  const path67 = [originServiceId];
   const edges = [];
   const visited = /* @__PURE__ */ new Set([originServiceId]);
   let current = originServiceId;
   for (let depth = 0; depth < maxDepth; depth++) {
     const hop = dominantFailingCall(graph, current, visited);
     if (!hop) break;
-    path64.push(hop.nextService);
+    path67.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path64, edges, culprit: current };
+  return { path: path67, edges, culprit: current };
 }
 function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   const chain = followFailingCallChain(graph, originId, ROOT_CAUSE_MAX_DEPTH);
   if (!chain) return null;
   const culprit = chain.culprit;
-  const path64 = [...chain.path];
+  const path67 = [...chain.path];
   const edgeProvenances = chain.edges.map((e) => e.provenance);
   const baseConfidence = confidenceFromMix(chain.edges);
   const confidence = Math.max(0, Math.min(1, baseConfidence * INCIDENT_ROOT_CAUSE_CONFIDENCE));
@@ -5238,14 +5242,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path64.push(loc.fileNode);
+      path67.push(loc.fileNode);
       edgeProvenances.push(Provenance6.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path64,
+      traversalPath: path67,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -5257,7 +5261,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   return RootCauseResultSchema.parse({
     rootCauseNode: culprit,
     rootCauseReason: `${culpritName} is failing downstream calls (${errs} observed error${errs === 1 ? "" : "s"})`,
-    traversalPath: path64,
+    traversalPath: path67,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -5693,10 +5697,10 @@ function enrichWithNavigation(graph, errorNodeId, legacy, incidents, now) {
   let traversalPath = legacy.traversalPath;
   let edgeProvenances = legacy.edgeProvenances;
   if (top.node !== seedNode) {
-    const path64 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
-    if (path64) {
-      traversalPath = path64.nodes;
-      edgeProvenances = path64.edges.map((e) => e.provenance);
+    const path67 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path67) {
+      traversalPath = path67.nodes;
+      edgeProvenances = path67.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
       edgeProvenances = [top.provenance ?? Provenance6.OBSERVED];
@@ -5725,11 +5729,11 @@ function fixRecommendationForTop(top, seedNode, legacy) {
 }
 
 // src/extract/services.ts
-import { promises as fs12 } from "fs";
-import path14 from "path";
+import { promises as fs15 } from "fs";
+import path17 from "path";
 import ignore from "ignore";
 import { minimatch as minimatch2 } from "minimatch";
-import { NodeType as NodeType9, serviceId as serviceId5 } from "@neat.is/types";
+import { NodeType as NodeType12, serviceId as serviceId8 } from "@neat.is/types";
 
 // src/extract/python.ts
 import { promises as fs8 } from "fs";
@@ -5918,18 +5922,230 @@ async function discoverPhpService(scanPath, dir) {
   return { pkg, dir, node };
 }
 
-// src/extract/owners.ts
+// src/extract/csharp.ts
 import { promises as fs11 } from "fs";
 import path13 from "path";
+import { NodeType as NodeType9, serviceId as serviceId5 } from "@neat.is/types";
+var CSHARP_PROJECT_EXTS = /* @__PURE__ */ new Set([".csproj", ".sln"]);
+async function projectFiles(dir) {
+  const entries = await fs11.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (CSHARP_PROJECT_EXTS.has(path13.extname(entry.name).toLowerCase())) out.push(entry.name);
+  }
+  return out.sort();
+}
+var NESTED_PROJECT_DIR = "src";
+async function resolveProjectDir(dir) {
+  if ((await projectFiles(dir)).length > 0) return dir;
+  const nested = path13.join(dir, NESTED_PROJECT_DIR);
+  if ((await projectFiles(nested)).length > 0) return nested;
+  return null;
+}
+async function hasCsharpProject(dir) {
+  return await resolveProjectDir(dir) !== null;
+}
+function parseCsproj(source) {
+  const dependencies = {};
+  const re = /<PackageReference\b([^>]*?)\/?>/g;
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    const attrs = m[1] ?? "";
+    const include = attrs.match(/\bInclude\s*=\s*"([^"]+)"/)?.[1];
+    if (!include) continue;
+    const version = attrs.match(/\bVersion\s*=\s*"([^"]+)"/)?.[1];
+    dependencies[include] = version ?? "";
+  }
+  return { dependencies };
+}
+async function discoverCsharpService(scanPath, dir) {
+  const projectDir = await resolveProjectDir(dir);
+  if (projectDir === null) return null;
+  const projects = await projectFiles(projectDir);
+  const csproj = projects.find((p) => p.toLowerCase().endsWith(".csproj"));
+  const name = csproj ? path13.basename(csproj, path13.extname(csproj)) : path13.basename(dir);
+  let dependencies = {};
+  if (csproj) {
+    const raw = await fs11.readFile(path13.join(projectDir, csproj), "utf8").catch(() => "");
+    dependencies = parseCsproj(raw).dependencies;
+  }
+  const pkg = { name, dependencies };
+  const node = {
+    id: serviceId5(name),
+    type: NodeType9.ServiceNode,
+    name,
+    language: "csharp",
+    dependencies,
+    // Anchor on the directory that holds the project and its `.cs` files, so file
+    // attribution reaches the source whether it sits at the root or under `src/`.
+    repoPath: path13.relative(scanPath, projectDir)
+  };
+  return { pkg, dir: projectDir, node };
+}
+
+// src/extract/java.ts
+import { promises as fs12 } from "fs";
+import path14 from "path";
+import { NodeType as NodeType10, serviceId as serviceId6 } from "@neat.is/types";
+var JAVA_MANIFESTS = ["pom.xml", "build.gradle", "build.gradle.kts"];
+async function hasJavaManifest(dir) {
+  for (const manifest of JAVA_MANIFESTS) {
+    if (await exists(path14.join(dir, manifest))) return true;
+  }
+  return false;
+}
+function parsePomXml(source) {
+  const dependencies = {};
+  const depBlock = /<dependency\b[^>]*>([\s\S]*?)<\/dependency>/g;
+  let d;
+  while ((d = depBlock.exec(source)) !== null) {
+    const body = d[1] ?? "";
+    const groupId = body.match(/<groupId>\s*([^<]+?)\s*<\/groupId>/)?.[1];
+    const artifactId = body.match(/<artifactId>\s*([^<]+?)\s*<\/artifactId>/)?.[1];
+    if (!groupId || !artifactId) continue;
+    const version = body.match(/<version>\s*([^<]+?)\s*<\/version>/)?.[1];
+    dependencies[`${groupId}:${artifactId}`] = version ?? "";
+  }
+  const withoutBlocks = source.replace(/<parent\b[^>]*>[\s\S]*?<\/parent>/g, "").replace(/<dependencyManagement\b[^>]*>[\s\S]*?<\/dependencyManagement>/g, "").replace(/<dependencies\b[^>]*>[\s\S]*?<\/dependencies>/g, "").replace(/<build\b[^>]*>[\s\S]*?<\/build>/g, "");
+  const name = withoutBlocks.match(/<artifactId>\s*([^<]+?)\s*<\/artifactId>/)?.[1];
+  return { name, dependencies };
+}
+var GRADLE_CONFIGS = "implementation|api|compileOnly|runtimeOnly|compileOnlyApi|testImplementation|testRuntimeOnly|testCompileOnly|annotationProcessor|developmentOnly|runtimeClasspath";
+function parseGradle(source) {
+  const dependencies = {};
+  const re = new RegExp(`\\b(?:${GRADLE_CONFIGS})\\s*\\(?\\s*(['"])([^'"]+)\\1`, "g");
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    const coord = m[2] ?? "";
+    const parts = coord.split(":");
+    if (parts.length < 2 || !parts[0] || !parts[1]) continue;
+    const key = `${parts[0]}:${parts[1]}`;
+    dependencies[key] = parts.slice(2).join(":");
+  }
+  return { dependencies };
+}
+async function discoverJavaService(scanPath, dir) {
+  const pomPath = path14.join(dir, "pom.xml");
+  const gradlePath = path14.join(dir, "build.gradle");
+  const gradleKtsPath = path14.join(dir, "build.gradle.kts");
+  let manifest = null;
+  if (await exists(pomPath)) {
+    manifest = parsePomXml(await fs12.readFile(pomPath, "utf8").catch(() => ""));
+  } else if (await exists(gradlePath)) {
+    manifest = parseGradle(await fs12.readFile(gradlePath, "utf8").catch(() => ""));
+  } else if (await exists(gradleKtsPath)) {
+    manifest = parseGradle(await fs12.readFile(gradleKtsPath, "utf8").catch(() => ""));
+  }
+  if (!manifest) return null;
+  const name = manifest.name?.trim() || path14.basename(dir);
+  const dependencies = manifest.dependencies;
+  const pkg = { name, dependencies };
+  const node = {
+    id: serviceId6(name),
+    type: NodeType10.ServiceNode,
+    name,
+    language: "java",
+    dependencies,
+    repoPath: path14.relative(scanPath, dir)
+  };
+  return { pkg, dir, node };
+}
+
+// src/extract/dockerfile-service.ts
+import { promises as fs13 } from "fs";
+import path15 from "path";
+import { NodeType as NodeType11, serviceId as serviceId7 } from "@neat.is/types";
+function languageForSourceExt(ext) {
+  switch (ext) {
+    case ".py":
+      return "python";
+    case ".go":
+      return "go";
+    case ".rb":
+      return "ruby";
+    case ".php":
+      return "php";
+    case ".cs":
+      return "csharp";
+    case ".java":
+      return "java";
+    case ".ts":
+    case ".tsx":
+      return "typescript";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    default:
+      return null;
+  }
+}
+var LANGUAGE_PRECEDENCE = ["typescript", "javascript", "python", "go", "ruby", "php", "csharp", "java"];
+async function inferServiceLanguage(dir) {
+  const entries = await fs13.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (isNeatAuthoredSourceFile(entry.name)) continue;
+    const ext = path15.extname(entry.name).toLowerCase();
+    if (!SERVICE_FILE_EXTENSIONS.has(ext)) continue;
+    const lang = languageForSourceExt(ext);
+    if (!lang) continue;
+    counts.set(lang, (counts.get(lang) ?? 0) + 1);
+  }
+  if (counts.size === 0) return null;
+  let best = null;
+  let bestCount = -1;
+  for (const lang of LANGUAGE_PRECEDENCE) {
+    const c = counts.get(lang) ?? 0;
+    if (c > bestCount) {
+      best = lang;
+      bestCount = c;
+    }
+  }
+  return best;
+}
+async function hasLanguageManifest(dir) {
+  return await exists(path15.join(dir, "package.json")) || await exists(path15.join(dir, "pyproject.toml")) || await exists(path15.join(dir, "requirements.txt")) || await exists(path15.join(dir, "setup.py")) || await exists(path15.join(dir, "go.mod")) || await exists(path15.join(dir, "Gemfile")) || await exists(path15.join(dir, "composer.json")) || // C#'s marker is a glob (`*.csproj` / `*.sln`), so it reads the directory
+  // rather than probing a fixed filename (ADR-196).
+  await hasCsharpProject(dir) || // Java keys on a Maven / Gradle build manifest (ADR-197).
+  await hasJavaManifest(dir);
+}
+async function hasDockerfileDeclaredService(dir) {
+  if (!await exists(path15.join(dir, "Dockerfile"))) return false;
+  return await inferServiceLanguage(dir) !== null;
+}
+async function discoverDockerfileService(scanPath, dir) {
+  if (!await exists(path15.join(dir, "Dockerfile"))) return null;
+  if (await hasLanguageManifest(dir)) return null;
+  const language = await inferServiceLanguage(dir);
+  if (!language) return null;
+  const name = path15.basename(dir);
+  const pkg = { name, dependencies: {} };
+  const node = {
+    id: serviceId7(name),
+    type: NodeType11.ServiceNode,
+    name,
+    language,
+    dependencies: {},
+    repoPath: path15.relative(scanPath, dir)
+  };
+  return { pkg, dir, node };
+}
+
+// src/extract/owners.ts
+import { promises as fs14 } from "fs";
+import path16 from "path";
 import { minimatch } from "minimatch";
 async function loadCodeowners(scanPath) {
   const candidates = [
-    path13.join(scanPath, "CODEOWNERS"),
-    path13.join(scanPath, ".github", "CODEOWNERS")
+    path16.join(scanPath, "CODEOWNERS"),
+    path16.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists(file)) {
-      const raw = await fs11.readFile(file, "utf8");
+      const raw = await fs14.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -5947,7 +6163,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(path13.sep).join("/");
+  const normalized = repoPath.split(path16.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -5963,7 +6179,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = path13.join(serviceDir, "package.json");
+  const pkgPath = path16.join(serviceDir, "package.json");
   if (!await exists(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -6000,33 +6216,36 @@ function workspaceGlobs(pkg) {
   return null;
 }
 async function hasPythonManifest(dir) {
-  return await exists(path14.join(dir, "pyproject.toml")) || await exists(path14.join(dir, "requirements.txt")) || await exists(path14.join(dir, "setup.py"));
+  return await exists(path17.join(dir, "pyproject.toml")) || await exists(path17.join(dir, "requirements.txt")) || await exists(path17.join(dir, "setup.py"));
 }
 async function hasGoManifest(dir) {
-  return exists(path14.join(dir, "go.mod"));
+  return exists(path17.join(dir, "go.mod"));
 }
 async function hasRubyManifest(dir) {
-  return exists(path14.join(dir, "Gemfile"));
+  return exists(path17.join(dir, "Gemfile"));
 }
 async function hasPhpManifest(dir) {
-  return exists(path14.join(dir, "composer.json"));
+  return exists(path17.join(dir, "composer.json"));
+}
+async function hasCsharpManifest(dir) {
+  return hasCsharpProject(dir);
 }
 async function loadGitignore(scanPath) {
-  const gitignorePath = path14.join(scanPath, ".gitignore");
+  const gitignorePath = path17.join(scanPath, ".gitignore");
   if (!await exists(gitignorePath)) return null;
-  const raw = await fs12.readFile(gitignorePath, "utf8");
+  const raw = await fs15.readFile(gitignorePath, "utf8");
   return ignore().add(raw);
 }
 async function walkDirs(start, scanPath, options, visit) {
   async function recurse(current, depth) {
     if (depth > options.maxDepth) return;
-    const entries = await fs12.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await fs15.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = path14.join(current, entry.name);
+      const child = path17.join(current, entry.name);
       if (options.ig) {
-        const rel = path14.relative(scanPath, child).split(path14.sep).join("/");
+        const rel = path17.relative(scanPath, child).split(path17.sep).join("/");
         if (rel && options.ig.ignores(rel + "/")) continue;
       }
       if (await isPythonVenvDir(child)) continue;
@@ -6042,8 +6261,8 @@ async function expandWorkspaceGlobs(scanPath, globs) {
   for (const raw of globs) {
     const pattern = raw.replace(/^\.\//, "");
     if (!pattern.includes("*")) {
-      const candidate = path14.join(scanPath, pattern);
-      if (await exists(path14.join(candidate, "package.json"))) found.add(candidate);
+      const candidate = path17.join(scanPath, pattern);
+      if (await exists(path17.join(candidate, "package.json"))) found.add(candidate);
       continue;
     }
     const segments = pattern.split("/");
@@ -6052,13 +6271,13 @@ async function expandWorkspaceGlobs(scanPath, globs) {
       if (seg.includes("*")) break;
       staticSegments.push(seg);
     }
-    const start = path14.join(scanPath, ...staticSegments);
+    const start = path17.join(scanPath, ...staticSegments);
     if (!await exists(start)) continue;
     const hasDoubleStar = pattern.includes("**");
     const walkDepth = hasDoubleStar ? scanDepth : Math.max(0, segments.length - staticSegments.length - 1);
     await walkDirs(start, scanPath, { maxDepth: walkDepth, ig: null }, async (dir) => {
-      const rel = path14.relative(scanPath, dir).split(path14.sep).join("/");
-      if (minimatch2(rel, pattern) && await exists(path14.join(dir, "package.json"))) {
+      const rel = path17.relative(scanPath, dir).split(path17.sep).join("/");
+      if (minimatch2(rel, pattern) && await exists(path17.join(dir, "package.json"))) {
         found.add(dir);
       }
     });
@@ -6081,31 +6300,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 fs12.readdir(dir).catch(() => []);
+  const entries = await fs15.readdir(dir).catch(() => []);
   if (entries.some((name) => /^tsconfig(\..+)?\.json$/.test(name))) return "typescript";
   return "javascript";
 }
 async function discoverNodeService(scanPath, dir) {
-  const pkgPath = path14.join(dir, "package.json");
+  const pkgPath = path17.join(dir, "package.json");
   if (!await exists(pkgPath)) return null;
   let pkg;
   try {
     pkg = await readJson(pkgPath);
   } catch (err) {
-    recordExtractionError("services", path14.relative(scanPath, pkgPath), err);
+    recordExtractionError("services", path17.relative(scanPath, pkgPath), err);
     return null;
   }
   if (!pkg.name) return null;
   const framework = detectJsFramework(pkg);
   const language = await detectJsServiceLanguage(dir, pkg);
   const node = {
-    id: serviceId5(pkg.name),
-    type: NodeType9.ServiceNode,
+    id: serviceId8(pkg.name),
+    type: NodeType12.ServiceNode,
     name: pkg.name,
     language,
     version: pkg.version,
     dependencies: pkg.dependencies ?? {},
-    repoPath: path14.relative(scanPath, dir),
+    repoPath: path17.relative(scanPath, dir),
     ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
     ...framework ? { framework } : {}
   };
@@ -6116,18 +6335,18 @@ async function discoverPyService(scanPath, dir) {
   if (!py) return null;
   const pkg = pythonToPackage(py);
   const node = {
-    id: serviceId5(py.name),
-    type: NodeType9.ServiceNode,
+    id: serviceId8(py.name),
+    type: NodeType12.ServiceNode,
     name: py.name,
     language: "python",
     version: py.version,
     dependencies: py.dependencies,
-    repoPath: path14.relative(scanPath, dir)
+    repoPath: path17.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 async function discoverServices(scanPath) {
-  const rootPkgPath = path14.join(scanPath, "package.json");
+  const rootPkgPath = path17.join(scanPath, "package.json");
   let rootPkg = null;
   if (await exists(rootPkgPath)) {
     try {
@@ -6135,7 +6354,7 @@ async function discoverServices(scanPath) {
     } catch (err) {
       recordExtractionError(
         "services workspaces",
-        path14.relative(scanPath, rootPkgPath),
+        path17.relative(scanPath, rootPkgPath),
         err
       );
     }
@@ -6147,7 +6366,7 @@ async function discoverServices(scanPath) {
   } else {
     if (rootPkg && rootPkg.name) {
       candidateDirs.push(scanPath);
-    } else if (await hasPythonManifest(scanPath) || await hasGoManifest(scanPath) || await hasRubyManifest(scanPath) || await hasPhpManifest(scanPath)) {
+    } else if (await hasPythonManifest(scanPath) || await hasGoManifest(scanPath) || await hasRubyManifest(scanPath) || await hasPhpManifest(scanPath) || await hasCsharpManifest(scanPath) || await hasJavaManifest(scanPath)) {
       candidateDirs.push(scanPath);
     }
     const ig = await loadGitignore(scanPath);
@@ -6156,9 +6375,11 @@ async function discoverServices(scanPath) {
       scanPath,
       { maxDepth: parseScanDepth(), ig },
       async (dir) => {
-        if (await exists(path14.join(dir, "package.json"))) {
+        if (await exists(path17.join(dir, "package.json"))) {
           candidateDirs.push(dir);
-        } else if (await hasPythonManifest(dir) || await hasGoManifest(dir) || await hasRubyManifest(dir) || await hasPhpManifest(dir)) {
+        } else if (await hasPythonManifest(dir) || await hasGoManifest(dir) || await hasRubyManifest(dir) || await hasPhpManifest(dir) || await hasCsharpManifest(dir) || await hasJavaManifest(dir)) {
+          candidateDirs.push(dir);
+        } else if (await hasDockerfileDeclaredService(dir)) {
           candidateDirs.push(dir);
         }
       }
@@ -6166,14 +6387,17 @@ async function discoverServices(scanPath) {
   }
   candidateDirs.sort();
   const seen = /* @__PURE__ */ new Map();
+  const seenDirs = /* @__PURE__ */ new Set();
   const out = [];
   for (const dir of candidateDirs) {
-    const service = await discoverNodeService(scanPath, dir) ?? await discoverPyService(scanPath, dir) ?? await discoverGoService(scanPath, dir) ?? await discoverRubyService(scanPath, dir) ?? await discoverPhpService(scanPath, dir);
+    const service = await discoverNodeService(scanPath, dir) ?? await discoverPyService(scanPath, dir) ?? await discoverGoService(scanPath, dir) ?? await discoverRubyService(scanPath, dir) ?? await discoverPhpService(scanPath, dir) ?? await discoverCsharpService(scanPath, dir) ?? await discoverJavaService(scanPath, dir) ?? await discoverDockerfileService(scanPath, dir);
     if (!service) continue;
+    if (seenDirs.has(service.dir)) continue;
+    seenDirs.add(service.dir);
     const existingDir = seen.get(service.node.name);
     if (existingDir !== void 0) {
-      const a = path14.relative(scanPath, existingDir) || ".";
-      const b = path14.relative(scanPath, dir) || ".";
+      const a = path17.relative(scanPath, existingDir) || ".";
+      const b = path17.relative(scanPath, dir) || ".";
       console.warn(
         `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
       );
@@ -6209,20 +6433,20 @@ function addServiceNodes(graph, services) {
 }
 
 // src/extract/aliases.ts
-import path15 from "path";
-import { promises as fs13 } from "fs";
+import path18 from "path";
+import { promises as fs16 } from "fs";
 import { parseAllDocuments } from "yaml";
-import { NodeType as NodeType10 } from "@neat.is/types";
+import { NodeType as NodeType13 } from "@neat.is/types";
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
   "Service",
   "Deployment",
   "StatefulSet",
   "DaemonSet"
 ]);
-function addAliases(graph, serviceId9, candidates) {
-  if (!graph.hasNode(serviceId9)) return;
-  const node = graph.getNodeAttributes(serviceId9);
-  if (node.type !== NodeType10.ServiceNode) return;
+function addAliases(graph, serviceId12, candidates) {
+  if (!graph.hasNode(serviceId12)) return;
+  const node = graph.getNodeAttributes(serviceId12);
+  if (node.type !== NodeType13.ServiceNode) return;
   const set = new Set(node.aliases ?? []);
   for (const c of candidates) {
     if (!c) continue;
@@ -6231,20 +6455,20 @@ function addAliases(graph, serviceId9, candidates) {
   }
   if (set.size === 0) return;
   const updated = { ...node, aliases: [...set].sort() };
-  graph.replaceNodeAttributes(serviceId9, updated);
+  graph.replaceNodeAttributes(serviceId12, updated);
 }
 function indexServicesByName(services) {
   const map = /* @__PURE__ */ new Map();
   for (const s of services) {
     map.set(s.node.name, s.node.id);
-    map.set(path15.basename(s.dir), s.node.id);
+    map.set(path18.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 = path15.join(scanPath, name);
+    const abs = path18.join(scanPath, name);
     if (await exists(abs)) {
       composePath = abs;
       break;
@@ -6257,19 +6481,19 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   } catch (err) {
     recordExtractionError(
       "aliases compose",
-      path15.relative(scanPath, composePath),
+      path18.relative(scanPath, composePath),
       err
     );
     return;
   }
   if (!compose?.services) return;
   for (const [composeName, svc] of Object.entries(compose.services)) {
-    const serviceId9 = serviceIndex.get(composeName);
-    if (!serviceId9) continue;
+    const serviceId12 = serviceIndex.get(composeName);
+    if (!serviceId12) continue;
     const aliases = /* @__PURE__ */ new Set([composeName]);
     if (svc.container_name) aliases.add(svc.container_name);
     if (svc.hostname) aliases.add(svc.hostname);
-    addAliases(graph, serviceId9, aliases);
+    addAliases(graph, serviceId12, aliases);
   }
 }
 var LABEL_KEYS = /* @__PURE__ */ new Set([
@@ -6300,11 +6524,11 @@ function parseDockerfileLabels(content) {
 }
 async function collectDockerfileAliases(graph, services) {
   for (const service of services) {
-    const dockerfilePath = path15.join(service.dir, "Dockerfile");
+    const dockerfilePath = path18.join(service.dir, "Dockerfile");
     if (!await exists(dockerfilePath)) continue;
     let content;
     try {
-      content = await fs13.readFile(dockerfilePath, "utf8");
+      content = await fs16.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError("aliases dockerfile", dockerfilePath, err);
       continue;
@@ -6316,15 +6540,15 @@ async function collectDockerfileAliases(graph, services) {
 async function walkYamlFiles(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await fs13.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await fs16.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = path15.join(start, entry.name);
+      const child = path18.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(path15.extname(entry.name))) {
-      out.push(path15.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(path18.extname(entry.name))) {
+      out.push(path18.join(start, entry.name));
     }
   }
   return out;
@@ -6351,7 +6575,7 @@ function k8sServiceTarget(doc, byName) {
 async function collectK8sAliases(graph, scanPath, serviceIndex) {
   const files = await walkYamlFiles(scanPath);
   for (const file of files) {
-    const content = await fs13.readFile(file, "utf8");
+    const content = await fs16.readFile(file, "utf8");
     let docs;
     try {
       docs = parseAllDocuments(content).map((d) => d.toJSON());
@@ -6375,14 +6599,14 @@ async function addServiceAliases(graph, scanPath, services) {
 }
 
 // src/extract/files.ts
-import path16 from "path";
+import path19 from "path";
 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(path16.relative(service.dir, filePath));
+      const relPath = toPosix(path19.relative(service.dir, filePath));
       const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -6397,13 +6621,19 @@ async function addFiles(graph, services) {
 }
 
 // src/extract/symbols.ts
-import path17 from "path";
+import path20 from "path";
 import Parser3 from "tree-sitter";
 import JavaScript3 from "tree-sitter-javascript";
 import TypeScript from "tree-sitter-typescript";
+import Python3 from "tree-sitter-python";
+import Go3 from "tree-sitter-go";
+import Ruby2 from "tree-sitter-ruby";
+import Php2 from "tree-sitter-php";
+import CSharp from "tree-sitter-c-sharp";
+import Java from "tree-sitter-java";
 import {
   EdgeType as EdgeType7,
-  NodeType as NodeType11,
+  NodeType as NodeType14,
   Provenance as Provenance7,
   confidenceForExtracted as confidenceForExtracted4,
   extractedEdgeId as extractedEdgeId6,
@@ -6418,6 +6648,15 @@ var GRAMMAR_BY_EXT = {
   ".mjs": JavaScript3,
   ".cjs": JavaScript3
 };
+var SYMBOL_GRAMMAR_BY_EXT = {
+  ...GRAMMAR_BY_EXT,
+  ".py": Python3,
+  ".go": Go3,
+  ".rb": Ruby2,
+  ".php": Php2.php_only,
+  ".cs": CSharp,
+  ".java": Java
+};
 function parseSource3(parser, source) {
   return parser.parse(
     (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK3)
@@ -6486,6 +6725,367 @@ function collectSymbolDefs(root) {
   visit(root, void 0);
   return out;
 }
+function collectPythonSymbolDefs(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_definition": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) {
+          if (classCtx) {
+            const kind = name === "__init__" ? "constructor" : "method";
+            push(kind, `${classCtx}.${name}`, node);
+          } else {
+            push("function", 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, void 0);
+          }
+        }
+        return;
+      }
+      case "class_definition": {
+        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 "decorated_definition": {
+        const def = node.childForFieldName("definition");
+        if (def) visit(def, classCtx);
+        return;
+      }
+    }
+    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 goReceiverType(node) {
+  const receiver = node.childForFieldName("receiver");
+  if (!receiver) return void 0;
+  for (let i = 0; i < receiver.namedChildCount; i++) {
+    const param = receiver.namedChild(i);
+    if (param?.type !== "parameter_declaration") continue;
+    let typeNode = param.childForFieldName("type");
+    if (typeNode?.type === "pointer_type") typeNode = typeNode.namedChild(0) ?? typeNode;
+    if (typeNode?.type === "generic_type") {
+      typeNode = typeNode.childForFieldName("type") ?? typeNode.namedChild(0) ?? typeNode;
+    }
+    if (typeNode?.type === "type_identifier") return typeNode.text;
+    return typeNode?.text;
+  }
+  return void 0;
+}
+function collectGoSymbolDefs(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) => {
+    switch (node.type) {
+      case "function_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("function", name, node);
+        break;
+      }
+      case "method_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) {
+          const recv = goReceiverType(node);
+          push("method", recv ? `${recv}.${name}` : name, node);
+        }
+        break;
+      }
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) visit(child);
+    }
+  };
+  visit(root);
+  return out;
+}
+function collectRubySymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const nameText = (node) => node.childForFieldName("name")?.text.replace(/::/g, ".");
+  const walkBody = (node, ctx) => {
+    const body = node.childForFieldName("body");
+    if (!body) return;
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const child = body.namedChild(i);
+      if (child) visit(child, ctx);
+    }
+  };
+  const visit = (node, classCtx) => {
+    switch (node.type) {
+      case "method":
+      case "singleton_method": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) {
+          if (classCtx) {
+            const kind = node.type === "method" && name === "initialize" ? "constructor" : "method";
+            push(kind, `${classCtx}.${name}`, node);
+          } else {
+            push("function", name, node);
+          }
+        }
+        walkBody(node, void 0);
+        return;
+      }
+      case "class":
+      case "module": {
+        const name = nameText(node);
+        if (name) push("class", classCtx ? `${classCtx}.${name}` : name, node);
+        walkBody(node, name ? classCtx ? `${classCtx}.${name}` : name : classCtx);
+        return;
+      }
+    }
+    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 collectPhpSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const dot = (s) => s.replace(/\\/g, ".").replace(/::/g, ".").replace(/^\.+/, "");
+  const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
+  const walkChildren = (container, nsCtx, classCtx) => {
+    let ns = nsCtx;
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const child = container.namedChild(i);
+      if (!child) continue;
+      if (child.type === "namespace_definition" && !child.childForFieldName("body")) {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) ns = dot(nameNode.text);
+        continue;
+      }
+      visit(child, ns, classCtx);
+    }
+  };
+  const walkBody = (node, nsCtx, classCtx) => {
+    const body = node.childForFieldName("body");
+    if (body) walkChildren(body, nsCtx, classCtx);
+  };
+  const visit = (node, nsCtx, classCtx) => {
+    switch (node.type) {
+      case "function_definition": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("function", join(nsCtx, name), node);
+        walkBody(node, nsCtx, void 0);
+        return;
+      }
+      case "class_declaration":
+      case "trait_declaration":
+      case "interface_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(nsCtx, name) : classCtx;
+        if (name) push("class", full, node);
+        walkBody(node, nsCtx, full);
+        return;
+      }
+      case "method_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) {
+          const kind = name === "__construct" ? "constructor" : "method";
+          push(kind, join(classCtx ?? nsCtx, name), node);
+        }
+        return;
+      }
+      case "namespace_definition": {
+        const nameNode = node.childForFieldName("name");
+        const ns = nameNode ? dot(nameNode.text) : nsCtx;
+        walkBody(node, ns, classCtx);
+        return;
+      }
+    }
+    walkChildren(node, nsCtx, classCtx);
+  };
+  walkChildren(root, void 0, void 0);
+  return out;
+}
+function collectCsharpSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
+  const walkChildren = (container, nsCtx, classCtx) => {
+    let ns = nsCtx;
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const child = container.namedChild(i);
+      if (!child) continue;
+      if (child.type === "file_scoped_namespace_declaration") {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) ns = join(nsCtx, nameNode.text);
+        continue;
+      }
+      visit(child, ns, classCtx);
+    }
+  };
+  const walkBody = (node, nsCtx, classCtx) => {
+    const body = node.childForFieldName("body");
+    if (body) walkChildren(body, nsCtx, classCtx);
+  };
+  const visit = (node, nsCtx, classCtx) => {
+    switch (node.type) {
+      case "namespace_declaration": {
+        const nameNode = node.childForFieldName("name");
+        const ns = nameNode ? join(nsCtx, nameNode.text) : nsCtx;
+        walkBody(node, ns, classCtx);
+        return;
+      }
+      case "class_declaration":
+      case "interface_declaration":
+      case "struct_declaration":
+      case "record_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(classCtx ?? nsCtx, name) : classCtx;
+        if (name) push("class", full, node);
+        walkBody(node, nsCtx, full);
+        return;
+      }
+      case "method_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("method", join(classCtx ?? nsCtx, name), node);
+        return;
+      }
+      case "constructor_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("constructor", join(classCtx ?? nsCtx, name), node);
+        return;
+      }
+    }
+    walkChildren(node, nsCtx, classCtx);
+  };
+  walkChildren(root, void 0, void 0);
+  return out;
+}
+function collectJavaSymbolDefs(root) {
+  const out = [];
+  const push = (kind, qualname, node) => {
+    out.push({
+      kind,
+      qualname,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1
+    });
+  };
+  const join = (prefix, name) => prefix ? `${prefix}.${name}` : name;
+  let pkg;
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const child = root.namedChild(i);
+    if (child?.type === "package_declaration") {
+      pkg = child.namedChild(0)?.text;
+      break;
+    }
+  }
+  const walkChildren = (container, classCtx) => {
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const child = container.namedChild(i);
+      if (child) visit(child, classCtx);
+    }
+  };
+  const walkBody = (node, classCtx) => {
+    const body = node.childForFieldName("body");
+    if (body) walkChildren(body, classCtx);
+  };
+  const visit = (node, classCtx) => {
+    switch (node.type) {
+      case "class_declaration":
+      case "interface_declaration":
+      case "enum_declaration":
+      case "record_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        const full = name ? join(classCtx ?? pkg, name) : classCtx;
+        if (name) push("class", full, node);
+        walkBody(node, full);
+        return;
+      }
+      case "method_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("method", join(classCtx ?? pkg, name), node);
+        return;
+      }
+      case "constructor_declaration": {
+        const name = node.childForFieldName("name")?.text;
+        if (name) push("constructor", join(classCtx ?? pkg, name), node);
+        return;
+      }
+    }
+    walkChildren(node, classCtx);
+  };
+  walkChildren(root, void 0);
+  return out;
+}
+function collectSymbolDefsForExt(ext, root) {
+  switch (ext) {
+    case ".py":
+      return collectPythonSymbolDefs(root);
+    case ".go":
+      return collectGoSymbolDefs(root);
+    case ".rb":
+      return collectRubySymbolDefs(root);
+    case ".php":
+      return collectPhpSymbolDefs(root);
+    case ".cs":
+      return collectCsharpSymbolDefs(root);
+    case ".java":
+      return collectJavaSymbolDefs(root);
+    default:
+      return collectSymbolDefs(root);
+  }
+}
 function disambiguate(defs) {
   const counts = /* @__PURE__ */ new Map();
   for (const def of defs) counts.set(def.qualname, (counts.get(def.qualname) ?? 0) + 1);
@@ -6500,7 +7100,7 @@ function disambiguate(defs) {
 async function addSymbols(graph, services) {
   const parsers = /* @__PURE__ */ new Map();
   const parserForExt5 = (ext) => {
-    const grammar = GRAMMAR_BY_EXT[ext];
+    const grammar = SYMBOL_GRAMMAR_BY_EXT[ext];
     if (!grammar) return null;
     let parser = parsers.get(ext);
     if (!parser) {
@@ -6515,13 +7115,14 @@ async function addSymbols(graph, services) {
   for (const service of services) {
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
-      const parser = parserForExt5(path17.extname(file.path));
+      const ext = path20.extname(file.path);
+      const parser = parserForExt5(ext);
       if (!parser) continue;
-      const relPath = toPosix(path17.relative(service.dir, file.path));
+      const relPath = toPosix(path20.relative(service.dir, file.path));
       let defs;
       try {
         const tree = parseSource3(parser, file.content);
-        defs = collectSymbolDefs(tree.rootNode);
+        defs = collectSymbolDefsForExt(ext, tree.rootNode);
       } catch (err) {
         recordExtractionError("symbol extraction", file.path, err);
         continue;
@@ -6540,7 +7141,7 @@ async function addSymbols(graph, services) {
         if (!graph.hasNode(sid)) {
           const node = {
             id: sid,
-            type: NodeType11.SymbolNode,
+            type: NodeType14.SymbolNode,
             kind: def.kind,
             qualname: def.qualname,
             span: { startLine: def.startLine, endLine: def.endLine },
@@ -6576,11 +7177,11 @@ async function addSymbols(graph, services) {
 }
 
 // src/extract/symbol-edges.ts
-import path18 from "path";
+import path21 from "path";
 import Parser4 from "tree-sitter";
 import {
   EdgeType as EdgeType8,
-  NodeType as NodeType12,
+  NodeType as NodeType15,
   Provenance as Provenance8,
   confidenceForExtracted as confidenceForExtracted5,
   extractedEdgeId as extractedEdgeId7,
@@ -6690,10 +7291,10 @@ async function addSymbolEdges(graph, services) {
     const tsPaths = await loadTsPathConfig(service.dir);
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
-      const parser = parserForExt5(path18.extname(file.path));
+      const parser = parserForExt5(path21.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(path18.relative(service.dir, file.path));
-      const fileDir = path18.dirname(file.path);
+      const relPath = toPosix(path21.relative(service.dir, file.path));
+      const fileDir = path21.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -6735,7 +7336,7 @@ async function addSymbolEdges(graph, services) {
           const candidate = symbolId3(serviceName, imp.targetRelPath, imp.importedName);
           if (graph.hasNode(candidate)) {
             const node = graph.getNodeAttributes(candidate);
-            if (node.type === NodeType12.SymbolNode && node.kind === wantKind) return candidate;
+            if (node.type === NodeType15.SymbolNode && node.kind === wantKind) return candidate;
           }
         }
         return null;
@@ -6827,11 +7428,11 @@ async function addSymbolEdges(graph, services) {
 }
 
 // src/extract/actions.ts
-import path19 from "path";
+import path22 from "path";
 import Parser5 from "tree-sitter";
 import {
   EdgeType as EdgeType9,
-  NodeType as NodeType13,
+  NodeType as NodeType16,
   Provenance as Provenance9,
   confidenceForExtracted as confidenceForExtracted6,
   extractedEdgeId as extractedEdgeId8,
@@ -6981,9 +7582,9 @@ async function addServerActions(graph, services) {
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(path19.extname(file.path));
+      const parser = parserForExt5(path22.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(path19.relative(service.dir, file.path));
+      const relPath = toPosix(path22.relative(service.dir, file.path));
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -7010,7 +7611,7 @@ async function addServerActions(graph, services) {
         if (!graph.hasNode(aid)) {
           const node = {
             id: aid,
-            type: NodeType13.ServerActionNode,
+            type: NodeType16.ServerActionNode,
             name: action.exportName,
             service: service.pkg.name,
             module: relPath,
@@ -7044,10 +7645,10 @@ async function addServerActions(graph, services) {
     }
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(path19.extname(file.path));
+      const parser = parserForExt5(path22.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(path19.relative(service.dir, file.path));
-      const fileDir = path19.dirname(file.path);
+      const relPath = toPosix(path22.relative(service.dir, file.path));
+      const fileDir = path22.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -7099,10 +7700,10 @@ async function addServerActions(graph, services) {
 }
 
 // src/extract/databases/index.ts
-import path27 from "path";
+import path30 from "path";
 import {
   EdgeType as EdgeType10,
-  NodeType as NodeType14,
+  NodeType as NodeType17,
   Provenance as Provenance10,
   configId,
   databaseId as databaseId2,
@@ -7110,9 +7711,9 @@ import {
 } from "@neat.is/types";
 
 // src/extract/databases/db-config-yaml.ts
-import path20 from "path";
+import path23 from "path";
 async function parse(serviceDir) {
-  const yamlPath = path20.join(serviceDir, "db-config.yaml");
+  const yamlPath = path23.join(serviceDir, "db-config.yaml");
   if (!await exists(yamlPath)) return [];
   const raw = await readYaml(yamlPath);
   return [
@@ -7129,12 +7730,12 @@ async function parse(serviceDir) {
 var dbConfigYamlParser = { name: "db-config.yaml", parse };
 
 // src/extract/databases/dotenv.ts
-import { promises as fs15 } from "fs";
-import path22 from "path";
+import { promises as fs18 } from "fs";
+import path25 from "path";
 
 // src/extract/databases/shared.ts
-import { promises as fs14 } from "fs";
-import path21 from "path";
+import { promises as fs17 } from "fs";
+import path24 from "path";
 function schemeToEngine(scheme) {
   const s = scheme.toLowerCase().split("+")[0];
   switch (s) {
@@ -7173,18 +7774,18 @@ function parseConnectionString(url) {
 }
 async function readIfExists(filePath) {
   try {
-    return await fs14.readFile(filePath, "utf8");
+    return await fs17.readFile(filePath, "utf8");
   } catch {
     return null;
   }
 }
 async function resolveEnvVar(serviceDir, name) {
-  const entries = await fs14.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs17.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
   const envNames = entries.filter((e) => e.isFile() && (e.name === ".env" || e.name.startsWith(".env."))).map((e) => e.name);
   const rank = (n) => n === ".env.local" ? 0 : n === ".env" ? 1 : 2;
   envNames.sort((a, b) => rank(a) - rank(b) || a.localeCompare(b));
   for (const fileName of envNames) {
-    const content = await readIfExists(path21.join(serviceDir, fileName));
+    const content = await readIfExists(path24.join(serviceDir, fileName));
     if (!content) continue;
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -7203,7 +7804,7 @@ async function resolveEnvVar(serviceDir, name) {
 }
 async function findFirst(serviceDir, candidates) {
   for (const rel of candidates) {
-    const abs = path21.join(serviceDir, rel);
+    const abs = path24.join(serviceDir, rel);
     const content = await readIfExists(abs);
     if (content !== null) return abs;
   }
@@ -7261,15 +7862,15 @@ function parseDotenvLine(line) {
   return { key, value };
 }
 async function parse2(serviceDir) {
-  const entries = await fs15.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs18.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
   const configs = [];
   const seen = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const match = isConfigFile(entry.name);
     if (!match.match || match.fileType !== "env") continue;
-    const filePath = path22.join(serviceDir, entry.name);
-    const content = await fs15.readFile(filePath, "utf8");
+    const filePath = path25.join(serviceDir, entry.name);
+    const content = await fs18.readFile(filePath, "utf8");
     for (const line of content.split("\n")) {
       const parsed = parseDotenvLine(line);
       if (!parsed) continue;
@@ -7287,9 +7888,9 @@ async function parse2(serviceDir) {
 var dotenvParser = { name: ".env", parse: parse2 };
 
 // src/extract/databases/prisma.ts
-import path23 from "path";
+import path26 from "path";
 async function parse3(serviceDir) {
-  const schemaPath = path23.join(serviceDir, "prisma", "schema.prisma");
+  const schemaPath = path26.join(serviceDir, "prisma", "schema.prisma");
   const content = await readIfExists(schemaPath);
   if (!content) return [];
   const block = content.match(/datasource\s+\w+\s*\{([^}]*)\}/s);
@@ -7444,10 +8045,10 @@ async function parse5(serviceDir) {
 var knexParser = { name: "knex", parse: parse5 };
 
 // src/extract/databases/ormconfig.ts
-import path24 from "path";
+import path27 from "path";
 async function parse6(serviceDir) {
   for (const candidate of ["ormconfig.json", "ormconfig.yaml", "ormconfig.yml"]) {
-    const abs = path24.join(serviceDir, candidate);
+    const abs = path27.join(serviceDir, candidate);
     if (!await exists(abs)) continue;
     const raw = candidate.endsWith(".json") ? await readJson(abs) : await readYaml(abs);
     const entries = Array.isArray(raw) ? raw : [raw];
@@ -7505,9 +8106,9 @@ async function parse7(serviceDir) {
 var typeormParser = { name: "typeorm", parse: parse7 };
 
 // src/extract/databases/sequelize.ts
-import path25 from "path";
+import path28 from "path";
 async function parse8(serviceDir) {
-  const configPath = path25.join(serviceDir, "config", "config.json");
+  const configPath = path28.join(serviceDir, "config", "config.json");
   if (!await exists(configPath)) return [];
   const raw = await readJson(configPath);
   const out = [];
@@ -7533,7 +8134,7 @@ async function parse8(serviceDir) {
 var sequelizeParser = { name: "sequelize", parse: parse8 };
 
 // src/extract/databases/docker-compose.ts
-import path26 from "path";
+import path29 from "path";
 function portFromService(svc) {
   for (const raw of svc.ports ?? []) {
     const str = String(raw);
@@ -7560,7 +8161,7 @@ function databaseFromEnv(svc) {
 }
 async function parse9(serviceDir) {
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = path26.join(serviceDir, name);
+    const abs = path29.join(serviceDir, name);
     if (!await exists(abs)) continue;
     const raw = await readYaml(abs);
     if (!raw?.services) return [];
@@ -7602,7 +8203,7 @@ function compatibleDriversFor(engine) {
 function toDatabaseNode(config) {
   return {
     id: databaseId2(config.host),
-    type: NodeType14.DatabaseNode,
+    type: NodeType17.DatabaseNode,
     name: config.database || config.host,
     engine: config.engine,
     engineVersion: config.engineVersion,
@@ -7732,7 +8333,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
           discoveredVia: mergedDiscoveredVia
         });
       }
-      const relConfigFile = toPosix(path27.relative(service.dir, config.sourceFile));
+      const relConfigFile = toPosix(path30.relative(service.dir, config.sourceFile));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -7741,7 +8342,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       );
       nodesAdded += fn;
       edgesAdded += fe;
-      const evidenceFile = toPosix(path27.relative(scanPath, config.sourceFile));
+      const evidenceFile = toPosix(path30.relative(scanPath, config.sourceFile));
       const edge = {
         id: extractedEdgeId(fileNodeId, dbNode.id, EdgeType10.CONNECTS_TO),
         source: fileNodeId,
@@ -7759,15 +8360,15 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
     if (allConfigs.length === 1) {
       const primary = allConfigs[0];
       service.node.dbConnectionTarget = primary.port ? `${primary.host}:${primary.port}` : primary.host;
-      const relPath = path27.relative(scanPath, primary.sourceFile);
+      const relPath = path30.relative(scanPath, primary.sourceFile);
       const cfgId = configId(relPath);
       if (!graph.hasNode(cfgId)) {
         const cfgNode = {
           id: cfgId,
-          type: NodeType14.ConfigNode,
-          name: path27.basename(primary.sourceFile),
+          type: NodeType17.ConfigNode,
+          name: path30.basename(primary.sourceFile),
           path: relPath,
-          fileType: isConfigFile(path27.basename(primary.sourceFile)).fileType || "config"
+          fileType: isConfigFile(path30.basename(primary.sourceFile)).fileType || "config"
         };
         graph.addNode(cfgId, cfgNode);
         nodesAdded++;
@@ -7807,11 +8408,11 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
 }
 
 // src/extract/configs.ts
-import { promises as fs16 } from "fs";
-import path28 from "path";
+import { promises as fs19 } from "fs";
+import path31 from "path";
 import {
   EdgeType as EdgeType11,
-  NodeType as NodeType15,
+  NodeType as NodeType18,
   Provenance as Provenance11,
   configId as configId2,
   confidenceForExtracted as confidenceForExtracted8
@@ -7819,9 +8420,9 @@ import {
 async function walkConfigFiles(dir) {
   const out = [];
   async function walk9(current) {
-    const entries = await fs16.readdir(current, { withFileTypes: true });
+    const entries = await fs19.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path28.join(current, entry.name);
+      const full = path31.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         if (await isPythonVenvDir(full)) continue;
@@ -7840,19 +8441,19 @@ async function addConfigNodes(graph, services, scanPath) {
   for (const service of services) {
     const configFiles = await walkConfigFiles(service.dir);
     for (const file of configFiles) {
-      const relPath = path28.relative(scanPath, file);
+      const relPath = path31.relative(scanPath, file);
       const node = {
         id: configId2(relPath),
-        type: NodeType15.ConfigNode,
-        name: path28.basename(file),
+        type: NodeType18.ConfigNode,
+        name: path31.basename(file),
         path: relPath,
-        fileType: isConfigFile(path28.basename(file)).fileType
+        fileType: isConfigFile(path31.basename(file)).fileType
       };
       if (!graph.hasNode(node.id)) {
         graph.addNode(node.id, node);
         nodesAdded++;
       }
-      const relToService = toPosix(path28.relative(service.dir, file));
+      const relToService = toPosix(path31.relative(service.dir, file));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -7868,7 +8469,7 @@ async function addConfigNodes(graph, services, scanPath) {
         type: EdgeType11.CONFIGURED_BY,
         provenance: Provenance11.EXTRACTED,
         confidence: confidenceForExtracted8("structural"),
-        evidence: { file: relPath.split(path28.sep).join("/") }
+        evidence: { file: relPath.split(path31.sep).join("/") }
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -7880,11 +8481,11 @@ async function addConfigNodes(graph, services, scanPath) {
 }
 
 // src/extract/proto.ts
-import { promises as fs17 } from "fs";
-import path29 from "path";
+import { promises as fs20 } from "fs";
+import path32 from "path";
 import {
   EdgeType as EdgeType12,
-  NodeType as NodeType16,
+  NodeType as NodeType19,
   Provenance as Provenance12,
   confidenceForExtracted as confidenceForExtracted9,
   extractedEdgeId as extractedEdgeId9,
@@ -7928,14 +8529,14 @@ function grpcMethodsFromProto(content, fqPackage) {
 async function walkProtoFiles(dir) {
   const out = [];
   async function walk9(current) {
-    const entries = await fs17.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await fs20.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      const full = path29.join(current, entry.name);
+      const full = path32.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk9(full);
-      } else if (entry.isFile() && path29.extname(entry.name) === PROTO_EXTENSION) {
+      } else if (entry.isFile() && path32.extname(entry.name) === PROTO_EXTENSION) {
         out.push(full);
       }
     }
@@ -7950,10 +8551,10 @@ async function addGrpcMethods(graph, services) {
     const protoPaths = await walkProtoFiles(service.dir);
     for (const protoPath of protoPaths) {
       if (isTestPath(protoPath)) continue;
-      const relFile = toPosix(path29.relative(service.dir, protoPath));
+      const relFile = toPosix(path32.relative(service.dir, protoPath));
       let content;
       try {
-        content = await fs17.readFile(protoPath, "utf8");
+        content = await fs20.readFile(protoPath, "utf8");
       } catch (err) {
         recordExtractionError("proto extraction", protoPath, err);
         continue;
@@ -7971,7 +8572,7 @@ async function addGrpcMethods(graph, services) {
         if (!graph.hasNode(mid)) {
           const node = {
             id: mid,
-            type: NodeType16.GrpcMethodNode,
+            type: NodeType19.GrpcMethodNode,
             name: `${method.rpcService}/${method.rpcMethod}`,
             rpcService: method.rpcService,
             rpcMethod: method.rpcMethod,
@@ -8009,18 +8610,18 @@ async function addGrpcMethods(graph, services) {
 // src/extract/calls/index.ts
 import {
   EdgeType as EdgeType15,
-  NodeType as NodeType18,
+  NodeType as NodeType21,
   Provenance as Provenance15,
   confidenceForExtracted as confidenceForExtracted12,
   passesExtractedFloor as passesExtractedFloor3
 } from "@neat.is/types";
 
 // src/extract/calls/http.ts
-import path30 from "path";
+import path33 from "path";
 import Parser6 from "tree-sitter";
 import JavaScript4 from "tree-sitter-javascript";
 import TypeScript2 from "tree-sitter-typescript";
-import Python3 from "tree-sitter-python";
+import Python4 from "tree-sitter-python";
 import {
   EdgeType as EdgeType13,
   Provenance as Provenance13,
@@ -8082,7 +8683,7 @@ var GRAMMAR_BY_EXT2 = {
   ".jsx": JavaScript4,
   ".mjs": JavaScript4,
   ".cjs": JavaScript4,
-  ".py": Python3
+  ".py": Python4
 };
 function parserForExt(ext, cache) {
   const grammar = GRAMMAR_BY_EXT2[ext] ?? JavaScript4;
@@ -8104,7 +8705,7 @@ async function addHttpCallEdges(graph, services) {
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt(path30.extname(file.path), parserCache);
+      const parser = parserForExt(path33.extname(file.path), parserCache);
       let sites;
       try {
         sites = callsFromSource(file.content, parser, knownHosts);
@@ -8113,7 +8714,7 @@ async function addHttpCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(path30.relative(service.dir, file.path));
+      const relFile = toPosix(path33.relative(service.dir, file.path));
       for (const site of sites) {
         const targetId = hostToNodeId.get(site.host);
         if (!targetId || targetId === service.node.id) continue;
@@ -8166,16 +8767,16 @@ async function addHttpCallEdges(graph, services) {
 }
 
 // src/extract/calls/route-match.ts
-import path31 from "path";
+import path34 from "path";
 import Parser7 from "tree-sitter";
 import JavaScript5 from "tree-sitter-javascript";
 import {
   EdgeType as EdgeType14,
-  NodeType as NodeType17,
+  NodeType as NodeType20,
   Provenance as Provenance14,
   confidenceForExtracted as confidenceForExtracted11,
   passesExtractedFloor as passesExtractedFloor2,
-  serviceId as serviceId6
+  serviceId as serviceId9
 } from "@neat.is/types";
 var PARSE_CHUNK5 = 16384;
 function parseSource5(parser, source) {
@@ -8341,9 +8942,9 @@ function buildRouteIndex(graph) {
   const index = /* @__PURE__ */ new Map();
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== NodeType17.RouteNode) return;
+    if (node.type !== NodeType20.RouteNode) return;
     const route = attrs;
-    const owner = serviceId6(route.service);
+    const owner = serviceId9(route.service);
     const entry = {
       method: route.method.toUpperCase(),
       normalizedPath: normalizePathTemplate(route.pathTemplate),
@@ -8372,7 +8973,7 @@ async function addRouteCallEdges(graph, services) {
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      if (!JS_CLIENT_EXTENSIONS.has(path31.extname(file.path))) continue;
+      if (!JS_CLIENT_EXTENSIONS.has(path34.extname(file.path))) continue;
       let sites;
       try {
         sites = clientCallSitesFromSource(file.content, jsParser, knownHosts);
@@ -8381,7 +8982,7 @@ async function addRouteCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(path31.relative(service.dir, file.path));
+      const relFile = toPosix(path34.relative(service.dir, file.path));
       for (const site of sites) {
         const serverServiceId = hostToNodeId.get(site.host);
         if (!serverServiceId || serverServiceId === service.node.id) continue;
@@ -8441,7 +9042,7 @@ async function addRouteCallEdges(graph, services) {
 }
 
 // src/extract/calls/kafka.ts
-import path32 from "path";
+import path35 from "path";
 import { infraId as infraId2 } from "@neat.is/types";
 var PRODUCER_TOPIC_RE = /(?:producer|kafkaProducer)[\s\S]{0,40}?\.send\s*\(\s*\{[\s\S]{0,200}?topic\s*:\s*['"`]([^'"`]+)['"`]/g;
 var CONSUMER_TOPIC_RE = /(?:consumer|kafkaConsumer)[\s\S]{0,40}?\.(?:subscribe|run)\s*\(\s*\{[\s\S]{0,200}?topic[s]?\s*:\s*(?:\[\s*)?['"`]([^'"`]+)['"`]/g;
@@ -8472,7 +9073,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path32.relative(serviceDir, file.path),
+        file: path35.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -8484,7 +9085,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 }
 
 // src/extract/calls/redis.ts
-import path33 from "path";
+import path36 from "path";
 import { infraId as infraId3 } from "@neat.is/types";
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
@@ -8507,7 +9108,7 @@ function redisEndpointsFromFile(file, serviceDir) {
       // support tier (ADR-066).
       confidenceKind: "url-with-structural-support",
       evidence: {
-        file: path33.relative(serviceDir, file.path),
+        file: path36.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -8517,7 +9118,7 @@ function redisEndpointsFromFile(file, serviceDir) {
 }
 
 // src/extract/calls/aws.ts
-import path34 from "path";
+import path37 from "path";
 import { infraId as infraId4 } from "@neat.is/types";
 var S3_BUCKET_RE = /Bucket\s*:\s*['"`]([^'"`]+)['"`]/g;
 var DYNAMO_TABLE_RE = /TableName\s*:\s*['"`]([^'"`]+)['"`]/g;
@@ -8551,7 +9152,7 @@ function awsEndpointsFromFile(file, serviceDir) {
       // (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path34.relative(serviceDir, file.path),
+        file: path37.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -8575,7 +9176,7 @@ function awsEndpointsFromFile(file, serviceDir) {
 }
 
 // src/extract/calls/grpc.ts
-import path35 from "path";
+import path38 from "path";
 import { infraId as infraId5 } from "@neat.is/types";
 var GRPC_CLIENT_RE = /new\s+([A-Z][A-Za-z0-9_]*)Client\s*\(\s*['"`]?([^,'"`)]+)?/g;
 var AWS_SDK_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@aws-sdk\/client-([a-z0-9-]+)['"`]/g;
@@ -8634,7 +9235,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path35.relative(serviceDir, file.path),
+        file: path38.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -8644,7 +9245,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
 }
 
 // src/extract/calls/supabase.ts
-import path36 from "path";
+import path39 from "path";
 import { infraId as infraId6 } from "@neat.is/types";
 var SUPABASE_JS_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@supabase\/supabase-js['"`]/;
 var SUPABASE_SSR_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@supabase\/ssr['"`]/;
@@ -8703,7 +9304,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066), the same grade aws.ts / grpc.ts emit at.
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path36.relative(serviceDir, file.path),
+        file: path39.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -8730,7 +9331,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         evidence: {
-          file: path36.relative(serviceDir, file.path),
+          file: path39.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -8741,7 +9342,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
 }
 
 // src/extract/calls/firestore.ts
-import path37 from "path";
+import path40 from "path";
 import Parser8 from "tree-sitter";
 import JavaScript6 from "tree-sitter-javascript";
 import { infraId as infraId7 } from "@neat.is/types";
@@ -8912,7 +9513,7 @@ function firestoreEndpointsFromFile(file, serviceDir) {
   const hasAdmin = FIRESTORE_ADMIN_IMPORT_RE.test(file.content);
   if (!hasClient && !hasAdmin) return [];
   const fileSdk = hasClient && !hasAdmin ? "client" : hasAdmin && !hasClient ? "admin" : null;
-  const tree = parseSource3(parserForExt2(path37.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt2(path40.extname(file.path)), file.content);
   const clientVars = firestoreClientVars(tree.rootNode);
   const collLine = /* @__PURE__ */ new Map();
   const writes = /* @__PURE__ */ new Map();
@@ -9016,7 +9617,7 @@ function firestoreEndpointsFromFile(file, serviceDir) {
       ...columnSet.size > 0 ? { columns: [...columnSet] } : {},
       ...sdkWrites ? { sdkWrites } : {},
       evidence: {
-        file: path37.relative(serviceDir, file.path),
+        file: path40.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -9026,7 +9627,7 @@ function firestoreEndpointsFromFile(file, serviceDir) {
 }
 
 // src/extract/calls/mongoose.ts
-import path38 from "path";
+import path41 from "path";
 import { infraId as infraId8 } from "@neat.is/types";
 var MONGOOSE_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])mongoose['"`]/;
 var MONGODB_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])mongodb['"`]/;
@@ -9177,7 +9778,7 @@ function endpoint(r, file, serviceDir, matchText) {
     kind: r.kind,
     edgeType: "CALLS",
     confidenceKind: "verified-call-site",
-    evidence: { file: path38.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+    evidence: { file: path41.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
   };
 }
 function mongooseEndpointsFromFile(file, serviceDir) {
@@ -9267,7 +9868,7 @@ async function mongooseCrossFileEndpoints(files, serviceDir) {
   const registry = /* @__PURE__ */ new Map();
   for (const f of mongooseFiles) {
     const fx = fileExportsOf(f.content, pluralizeOn);
-    if (fx) registry.set(toPosix(path38.relative(serviceDir, f.path)), fx);
+    if (fx) registry.set(toPosix(path41.relative(serviceDir, f.path)), fx);
   }
   if (registry.size === 0) return [];
   const out = [];
@@ -9278,7 +9879,7 @@ async function mongooseCrossFileEndpoints(files, serviceDir) {
     const directColl = /* @__PURE__ */ new Map();
     const nsExports = /* @__PURE__ */ new Map();
     for (const b of bindings) {
-      const resolvedRel = await resolveJsImport(b.specifier, path38.dirname(f.path), serviceDir, null);
+      const resolvedRel = await resolveJsImport(b.specifier, path41.dirname(f.path), serviceDir, null);
       if (!resolvedRel) continue;
       const fx = registry.get(resolvedRel);
       if (!fx) continue;
@@ -9321,15 +9922,15 @@ async function mongooseCrossFileEndpoints(files, serviceDir) {
 }
 
 // src/extract/calls/sqlalchemy.ts
-import path39 from "path";
+import path42 from "path";
 import Parser9 from "tree-sitter";
-import Python4 from "tree-sitter-python";
+import Python5 from "tree-sitter-python";
 import { infraId as infraId9 } from "@neat.is/types";
 var SQLALCHEMY_IMPORT_RE = /(?:from|import)\s+(?:flask_sqlalchemy|sqlalchemy)\b/;
 var PARSE_CHUNK6 = 16384;
 function makePyParser3() {
   const p = new Parser9();
-  p.setLanguage(Python4);
+  p.setLanguage(Python5);
   return p;
 }
 function parseSource6(parser, source) {
@@ -9460,7 +10061,7 @@ function sqlalchemyForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: path39.relative(serviceDir, file.path),
+          file: path42.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -9485,7 +10086,7 @@ function sqlalchemyEndpointsFromFile(file, serviceDir) {
       confidenceKind: "verified-call-site",
       ...columns && columns.length > 0 ? { columns } : {},
       evidence: {
-        file: path39.relative(serviceDir, file.path),
+        file: path42.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -9592,7 +10193,7 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         evidence: {
-          file: path39.relative(serviceDir, file.path),
+          file: path42.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -9603,15 +10204,15 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
 }
 
 // src/extract/calls/django-orm.ts
-import path40 from "path";
+import path43 from "path";
 import Parser10 from "tree-sitter";
-import Python5 from "tree-sitter-python";
+import Python6 from "tree-sitter-python";
 import { infraId as infraId10 } from "@neat.is/types";
 var DJANGO_IMPORT_RE = /(?:from|import)\s+django\b/;
 var PARSE_CHUNK7 = 16384;
 function makePyParser4() {
   const p = new Parser10();
-  p.setLanguage(Python5);
+  p.setLanguage(Python6);
   return p;
 }
 function parseSource7(parser, source) {
@@ -9673,7 +10274,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
   const tree = parseSource7(makePyParser4(), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const defaultAppLabel = path40.basename(path40.dirname(file.path));
+  const defaultAppLabel = path43.basename(path43.dirname(file.path));
   walk4(tree.rootNode, (node) => {
     if (node.type !== "class_definition") return;
     if (!extendsDjangoModel(node)) return;
@@ -9691,14 +10292,14 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
-      evidence: { file: path40.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+      evidence: { file: path43.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
     });
   });
   return out;
 }
 
 // src/extract/calls/drizzle.ts
-import path41 from "path";
+import path44 from "path";
 import Parser11 from "tree-sitter";
 import JavaScript7 from "tree-sitter-javascript";
 import { infraId as infraId11 } from "@neat.is/types";
@@ -9776,7 +10377,7 @@ function columnsFromObject(obj) {
 }
 function drizzleEndpointsFromFile(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(path41.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(path44.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk9 = (node) => {
@@ -9799,7 +10400,7 @@ function drizzleEndpointsFromFile(file, serviceDir) {
             confidenceKind: "structural",
             columns,
             evidence: {
-              file: path41.relative(serviceDir, file.path),
+              file: path44.relative(serviceDir, file.path),
               line,
               snippet: snippet(file.content, line)
             }
@@ -9865,7 +10466,7 @@ function referencesTargetVar(call) {
 }
 function drizzleForeignKeys(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(path41.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(path44.extname(file.path)), file.content);
   const { tables, varToTable } = collectDrizzleTables(tree.rootNode);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -9884,7 +10485,7 @@ function drizzleForeignKeys(file, serviceDir) {
               childTable: table.tableName,
               parentTable,
               evidence: {
-                file: path41.relative(serviceDir, file.path),
+                file: path44.relative(serviceDir, file.path),
                 line,
                 snippet: snippet(file.content, line)
               }
@@ -9900,7 +10501,7 @@ function drizzleForeignKeys(file, serviceDir) {
 }
 
 // src/extract/calls/prisma.ts
-import path42 from "path";
+import path45 from "path";
 import { infraId as infraId12 } from "@neat.is/types";
 var SCALAR_TYPES = /* @__PURE__ */ new Set([
   "Int",
@@ -9956,7 +10557,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
       confidenceKind: "structural",
       columns: b.columns,
       evidence: {
-        file: path42.relative(serviceDir, file.path),
+        file: path45.relative(serviceDir, file.path),
         line: b.startLine,
         snippet: snippet(content, b.startLine)
       }
@@ -10017,7 +10618,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
 }
 async function prismaColumnEndpoints(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    path42.join("prisma", "schema.prisma"),
+    path45.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -10092,7 +10693,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
               childTable: current.table,
               parentTable,
               evidence: {
-                file: path42.relative(serviceDir, file.path),
+                file: path45.relative(serviceDir, file.path),
                 line: lineNo,
                 snippet: snippet(content, lineNo)
               }
@@ -10107,7 +10708,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
 }
 async function prismaForeignKeys(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    path42.join("prisma", "schema.prisma"),
+    path45.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -10117,15 +10718,15 @@ async function prismaForeignKeys(serviceDir) {
 }
 
 // src/extract/calls/activerecord.ts
-import path43 from "path";
+import path46 from "path";
 import Parser12 from "tree-sitter";
-import Ruby2 from "tree-sitter-ruby";
+import Ruby3 from "tree-sitter-ruby";
 import { infraId as infraId13 } from "@neat.is/types";
 var AR_SCHEMA_RE = /ActiveRecord::Schema/;
 var PARSE_CHUNK8 = 16384;
 function makeRubyParser2() {
   const p = new Parser12();
-  p.setLanguage(Ruby2);
+  p.setLanguage(Ruby3);
   return p;
 }
 function parseSource8(parser, source) {
@@ -10325,7 +10926,7 @@ function railsSchemaEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...table.columns.length > 0 ? { columns: table.columns } : {},
       evidence: {
-        file: path43.relative(serviceDir, file.path),
+        file: path46.relative(serviceDir, file.path),
         line: table.line,
         snippet: snippet(file.content, table.line)
       }
@@ -10347,7 +10948,7 @@ function railsSchemaForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: path43.relative(serviceDir, file.path),
+        file: path46.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10430,7 +11031,7 @@ function railsModelEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path43.relative(serviceDir, file.path),
+        file: path46.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10467,7 +11068,7 @@ function railsModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: path43.relative(serviceDir, file.path),
+          file: path46.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -10478,15 +11079,15 @@ function railsModelForeignKeys(file, serviceDir) {
 }
 
 // src/extract/calls/eloquent.ts
-import path44 from "path";
+import path47 from "path";
 import Parser13 from "tree-sitter";
-import Php2 from "tree-sitter-php";
+import Php3 from "tree-sitter-php";
 import { infraId as infraId14 } from "@neat.is/types";
 var LARAVEL_SCHEMA_RE = /\bSchema::(create|createIfNotExists|table)\b/;
 var PARSE_CHUNK9 = 16384;
 function makePhpParser2() {
   const p = new Parser13();
-  p.setLanguage(Php2.php_only);
+  p.setLanguage(Php3.php_only);
   return p;
 }
 function parseSource9(parser, source) {
@@ -10735,7 +11336,7 @@ function laravelMigrationEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: path44.relative(serviceDir, file.path),
+        file: path47.relative(serviceDir, file.path),
         line: bp.line,
         snippet: snippet(file.content, bp.line)
       }
@@ -10757,7 +11358,7 @@ function laravelMigrationForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: path44.relative(serviceDir, file.path),
+        file: path47.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10877,7 +11478,7 @@ function laravelModelEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path44.relative(serviceDir, file.path),
+        file: path47.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10913,7 +11514,7 @@ function laravelModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: path44.relative(serviceDir, file.path),
+          file: path47.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -10924,9 +11525,9 @@ function laravelModelForeignKeys(file, serviceDir) {
 }
 
 // src/extract/calls/go.ts
-import path45 from "path";
+import path48 from "path";
 import Parser14 from "tree-sitter";
-import Go3 from "tree-sitter-go";
+import Go4 from "tree-sitter-go";
 import { infraId as infraId15 } from "@neat.is/types";
 var PARSE_CHUNK10 = 16384;
 var DATABASE_SQL_METHODS = /* @__PURE__ */ new Set([
@@ -10955,7 +11556,7 @@ var DATABASE_SQL_IMPORT = "database/sql";
 var SQLX_IMPORT = "github.com/jmoiron/sqlx";
 function makeGoParser3() {
   const p = new Parser14();
-  p.setLanguage(Go3);
+  p.setLanguage(Go4);
   return p;
 }
 function parseSource10(parser, source) {
@@ -10998,7 +11599,7 @@ function firstStringLiteralArg(argsNode) {
   return null;
 }
 function goSqlEndpointsFromFile(file, serviceDir) {
-  if (path45.extname(file.path) !== ".go") return [];
+  if (path48.extname(file.path) !== ".go") return [];
   if (!file.content.includes(DATABASE_SQL_IMPORT) && !file.content.includes(SQLX_IMPORT)) return [];
   const tree = parseSource10(makeGoParser3(), file.content);
   const importsDatabaseSql = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([DATABASE_SQL_IMPORT]));
@@ -11027,7 +11628,7 @@ function goSqlEndpointsFromFile(file, serviceDir) {
       confidenceKind: "verified-call-site",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(path45.relative(serviceDir, file.path)),
+        file: toPosix(path48.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11037,15 +11638,15 @@ function goSqlEndpointsFromFile(file, serviceDir) {
 }
 
 // src/extract/calls/gorm.ts
-import path46 from "path";
+import path49 from "path";
 import Parser15 from "tree-sitter";
-import Go4 from "tree-sitter-go";
+import Go5 from "tree-sitter-go";
 import { infraId as infraId16 } from "@neat.is/types";
 var GORM_IMPORT_RE = /gorm\.io\/gorm/;
 var PARSE_CHUNK11 = 16384;
 function makeGoParser4() {
   const p = new Parser15();
-  p.setLanguage(Go4);
+  p.setLanguage(Go5);
   return p;
 }
 function parseSource11(parser, source) {
@@ -11470,7 +12071,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
   seen.delete(struct.name);
 }
 function gormEndpointsFromFile(file, serviceDir) {
-  if (path46.extname(file.path) !== ".go") return [];
+  if (path49.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
   const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
@@ -11492,7 +12093,7 @@ function gormEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(path46.relative(serviceDir, file.path)),
+        file: toPosix(path49.relative(serviceDir, file.path)),
         line: struct.line,
         snippet: snippet(file.content, struct.line)
       }
@@ -11501,7 +12102,7 @@ function gormEndpointsFromFile(file, serviceDir) {
   return out;
 }
 function gormForeignKeys(file, serviceDir) {
-  if (path46.extname(file.path) !== ".go") return [];
+  if (path49.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
   const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
@@ -11516,7 +12117,7 @@ function gormForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: toPosix(path46.relative(serviceDir, file.path)),
+        file: toPosix(path49.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11619,7 +12220,7 @@ async function addExternalEndpointEdges(graph, services) {
       if (!graph.hasNode(ep.infraId)) {
         const node = {
           id: ep.infraId,
-          type: NodeType18.InfraNode,
+          type: NodeType21.InfraNode,
           name: ep.name,
           // #238 — `aws-*` covers AWS-SDK client kinds (aws-s3, aws-dynamodb,
           // aws-cognito-identity-provider, …); `s3-` / `dynamodb-` cover the
@@ -11632,7 +12233,7 @@ async function addExternalEndpointEdges(graph, services) {
       }
       if (ep.columns && ep.columns.length > 0) {
         const node = graph.getNodeAttributes(ep.infraId);
-        if (node.type === NodeType18.InfraNode) {
+        if (node.type === NodeType21.InfraNode) {
           graph.replaceNodeAttributes(ep.infraId, {
             ...node,
             columns: foldColumns(
@@ -11646,7 +12247,7 @@ async function addExternalEndpointEdges(graph, services) {
       }
       if (ep.sdkWrites && Object.keys(ep.sdkWrites).length > 0) {
         const node = graph.getNodeAttributes(ep.infraId);
-        if (node.type === NodeType18.InfraNode) {
+        if (node.type === NodeType21.InfraNode) {
           graph.replaceNodeAttributes(ep.infraId, {
             ...node,
             columns: foldSdkWrites(node.columns, ep.sdkWrites)
@@ -11708,7 +12309,7 @@ async function addCallEdges(graph, services) {
 // src/extract/table-edges.ts
 import {
   EdgeType as EdgeType16,
-  NodeType as NodeType19,
+  NodeType as NodeType22,
   Provenance as Provenance16,
   confidenceForExtracted as confidenceForExtracted13,
   extractedEdgeId as extractedEdgeId10,
@@ -11767,7 +12368,7 @@ function ensureTableNode(graph, id, name) {
   if (graph.hasNode(id)) return 0;
   const node = {
     id,
-    type: NodeType19.InfraNode,
+    type: NodeType22.InfraNode,
     name,
     provider: "self",
     kind: "sql-table"
@@ -11777,15 +12378,15 @@ function ensureTableNode(graph, id, name) {
 }
 
 // src/extract/infra/docker-compose.ts
-import path47 from "path";
+import path50 from "path";
 import { EdgeType as EdgeType17, Provenance as Provenance18, confidenceForExtracted as confidenceForExtracted15 } from "@neat.is/types";
 
 // src/extract/infra/shared.ts
-import { NodeType as NodeType20, Provenance as Provenance17, confidenceForExtracted as confidenceForExtracted14, infraId as infraId18 } from "@neat.is/types";
+import { NodeType as NodeType23, Provenance as Provenance17, confidenceForExtracted as confidenceForExtracted14, infraId as infraId18 } from "@neat.is/types";
 function makeInfraNode(kind, name, provider = "self", extras) {
   return {
     id: infraId18(kind, name),
-    type: NodeType20.InfraNode,
+    type: NodeType23.InfraNode,
     name,
     provider,
     kind,
@@ -11847,7 +12448,7 @@ function dependsOnList(value) {
 }
 function serviceNameToServiceNode(name, services) {
   for (const s of services) {
-    if (s.node.name === name || path47.basename(s.dir) === name) return s.node.id;
+    if (s.node.name === name || path50.basename(s.dir) === name) return s.node.id;
   }
   return null;
 }
@@ -11856,7 +12457,7 @@ async function addComposeInfra(graph, scanPath, services) {
   let edgesAdded = 0;
   let composePath = null;
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = path47.join(scanPath, name);
+    const abs = path50.join(scanPath, name);
     if (await exists(abs)) {
       composePath = abs;
       break;
@@ -11869,13 +12470,13 @@ async function addComposeInfra(graph, scanPath, services) {
   } catch (err) {
     recordExtractionError(
       "infra docker-compose",
-      path47.relative(scanPath, composePath),
+      path50.relative(scanPath, composePath),
       err
     );
     return { nodesAdded, edgesAdded };
   }
   if (!compose?.services) return { nodesAdded, edgesAdded };
-  const evidenceFile = path47.relative(scanPath, composePath).split(path47.sep).join("/");
+  const evidenceFile = path50.relative(scanPath, composePath).split(path50.sep).join("/");
   const composeNameToNodeId = /* @__PURE__ */ new Map();
   for (const [composeName, svc] of Object.entries(compose.services)) {
     const matchedServiceId = serviceNameToServiceNode(composeName, services);
@@ -11916,8 +12517,8 @@ async function addComposeInfra(graph, scanPath, services) {
 }
 
 // src/extract/infra/dockerfile.ts
-import path48 from "path";
-import { promises as fs18 } from "fs";
+import path51 from "path";
+import { promises as fs21 } from "fs";
 import { EdgeType as EdgeType18, Provenance as Provenance19, confidenceForExtracted as confidenceForExtracted16 } from "@neat.is/types";
 function readDockerfile(content) {
   let image = null;
@@ -11947,15 +12548,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const dockerfilePath = path48.join(service.dir, "Dockerfile");
+    const dockerfilePath = path51.join(service.dir, "Dockerfile");
     if (!await exists(dockerfilePath)) continue;
     let content;
     try {
-      content = await fs18.readFile(dockerfilePath, "utf8");
+      content = await fs21.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError(
         "infra dockerfile",
-        path48.relative(scanPath, dockerfilePath),
+        path51.relative(scanPath, dockerfilePath),
         err
       );
       continue;
@@ -11967,8 +12568,8 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const relDockerfile = toPosix(path48.relative(service.dir, dockerfilePath));
-    const evidenceFile = toPosix(path48.relative(scanPath, dockerfilePath));
+    const relDockerfile = toPosix(path51.relative(service.dir, dockerfilePath));
+    const evidenceFile = toPosix(path51.relative(scanPath, dockerfilePath));
     const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
       graph,
       service.pkg.name,
@@ -12019,23 +12620,23 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 }
 
 // src/extract/infra/terraform.ts
-import { promises as fs19 } from "fs";
-import path49 from "path";
+import { promises as fs22 } from "fs";
+import path52 from "path";
 import { EdgeType as EdgeType19, Provenance as Provenance20, confidenceForExtracted as confidenceForExtracted17 } from "@neat.is/types";
 var RESOURCE_RE = /resource\s+"(aws_[A-Za-z0-9_]+)"\s+"([A-Za-z0-9_-]+)"/g;
 var REFERENCE_RE = /(?<![\w.])(aws_[A-Za-z0-9_]+)\.([A-Za-z0-9_-]+)/g;
 async function walkTfFiles(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await fs19.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await fs22.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name) || entry.name === ".terraform") continue;
-      const child = path49.join(start, entry.name);
+      const child = path52.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkTfFiles(child, depth + 1, max));
     } else if (entry.isFile() && entry.name.endsWith(".tf")) {
-      out.push(path49.join(start, entry.name));
+      out.push(path52.join(start, entry.name));
     }
   }
   return out;
@@ -12066,8 +12667,8 @@ async function addTerraformResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkTfFiles(scanPath);
   for (const file of files) {
-    const content = await fs19.readFile(file, "utf8");
-    const evidenceFile = toPosix(path49.relative(scanPath, file));
+    const content = await fs22.readFile(file, "utf8");
+    const evidenceFile = toPosix(path52.relative(scanPath, file));
     const resources = [];
     const byKey = /* @__PURE__ */ new Map();
     RESOURCE_RE.lastIndex = 0;
@@ -12123,8 +12724,8 @@ async function addTerraformResources(graph, scanPath) {
 }
 
 // src/extract/infra/k8s.ts
-import { promises as fs20 } from "fs";
-import path50 from "path";
+import { promises as fs23 } from "fs";
+import path53 from "path";
 import { parseAllDocuments as parseAllDocuments2 } from "yaml";
 var K8S_KIND_TO_INFRA_KIND = {
   Service: "k8s-service",
@@ -12138,15 +12739,15 @@ var K8S_KIND_TO_INFRA_KIND = {
 async function walkYamlFiles2(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await fs20.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await fs23.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = path50.join(start, entry.name);
+      const child = path53.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles2(child, depth + 1, max));
-    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(path50.extname(entry.name))) {
-      out.push(path50.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(path53.extname(entry.name))) {
+      out.push(path53.join(start, entry.name));
     }
   }
   return out;
@@ -12155,7 +12756,7 @@ async function addK8sResources(graph, scanPath) {
   let nodesAdded = 0;
   const files = await walkYamlFiles2(scanPath);
   for (const file of files) {
-    const content = await fs20.readFile(file, "utf8");
+    const content = await fs23.readFile(file, "utf8");
     let docs;
     try {
       docs = parseAllDocuments2(content).map((d) => d.toJSON());
@@ -12178,16 +12779,16 @@ async function addK8sResources(graph, scanPath) {
 }
 
 // src/extract/infra/cloudflare.ts
-import { promises as fs21 } from "fs";
-import path51 from "path";
+import { promises as fs24 } from "fs";
+import path54 from "path";
 import { parse as parseToml2 } from "smol-toml";
 import { EdgeType as EdgeType20, Provenance as Provenance21, confidenceForExtracted as confidenceForExtracted18 } from "@neat.is/types";
 var WRANGLER_FILENAMES = ["wrangler.toml", "wrangler.jsonc", "wrangler.json"];
 async function readWranglerConfig(dir) {
   for (const filename of WRANGLER_FILENAMES) {
-    const abs = path51.join(dir, filename);
+    const abs = path54.join(dir, filename);
     if (!await exists(abs)) continue;
-    const raw = await fs21.readFile(abs, "utf8");
+    const raw = await fs24.readFile(abs, "utf8");
     const config = filename === "wrangler.toml" ? parseToml2(raw) : JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
@@ -12248,11 +12849,11 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     try {
       read = await readWranglerConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra cloudflare", path51.relative(scanPath, service.dir), err);
+      recordExtractionError("infra cloudflare", path54.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read || !read.config.name) continue;
-    const evidenceFile = toPosix(path51.relative(scanPath, path51.join(service.dir, read.relFile)));
+    const evidenceFile = toPosix(path54.relative(scanPath, path54.join(service.dir, read.relFile)));
     discovered.push({ service, config: read.config, relFile: read.relFile, raw: read.raw, evidenceFile });
   }
   for (const worker of discovered) {
@@ -12264,7 +12865,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     }
     let anchorId = service.node.id;
     if (config.main) {
-      const entryRelPath = toPosix(path51.normalize(config.main));
+      const entryRelPath = toPosix(path54.normalize(config.main));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -12410,24 +13011,24 @@ async function addCloudflareWorkers(graph, services, scanPath) {
 }
 
 // src/extract/infra/vercel.ts
-import { promises as fs22 } from "fs";
-import path52 from "path";
+import { promises as fs25 } from "fs";
+import path55 from "path";
 import { EdgeType as EdgeType21 } from "@neat.is/types";
 var VERCEL_CONFIG_FILENAMES = ["vercel.json", "vercel.jsonc"];
 async function readVercelConfig(dir) {
   for (const filename of VERCEL_CONFIG_FILENAMES) {
-    const abs = path52.join(dir, filename);
+    const abs = path55.join(dir, filename);
     if (!await exists(abs)) continue;
-    const raw = await fs22.readFile(abs, "utf8");
+    const raw = await fs25.readFile(abs, "utf8");
     const config = JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
   return null;
 }
 async function readLinkedProjectName(dir) {
-  const abs = path52.join(dir, ".vercel", "project.json");
+  const abs = path55.join(dir, ".vercel", "project.json");
   if (!await exists(abs)) return void 0;
-  const parsed = JSON.parse(await fs22.readFile(abs, "utf8"));
+  const parsed = JSON.parse(await fs25.readFile(abs, "utf8"));
   return typeof parsed.projectName === "string" ? parsed.projectName : void 0;
 }
 function routeSource(route) {
@@ -12443,7 +13044,7 @@ async function addVercelServices(graph, services, scanPath) {
       read = await readVercelConfig(service.dir);
       projectName = await readLinkedProjectName(service.dir);
     } catch (err) {
-      recordExtractionError("infra vercel", path52.relative(scanPath, service.dir), err);
+      recordExtractionError("infra vercel", path55.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read && !projectName) continue;
@@ -12459,7 +13060,7 @@ async function addVercelServices(graph, services, scanPath) {
     const anchorId = service.node.id;
     if (!read) continue;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(path52.relative(scanPath, path52.join(service.dir, relFile)));
+    const evidenceFile = toPosix(path55.relative(scanPath, path55.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -12487,16 +13088,16 @@ async function addVercelServices(graph, services, scanPath) {
 }
 
 // src/extract/infra/railway.ts
-import { promises as fs23 } from "fs";
-import path53 from "path";
+import { promises as fs26 } from "fs";
+import path56 from "path";
 import { parse as parseToml3 } from "smol-toml";
 import { EdgeType as EdgeType22 } from "@neat.is/types";
 var RAILWAY_FILENAMES = ["railway.toml", "railway.json", "railway.jsonc"];
 async function readRailwayConfig(dir) {
   for (const filename of RAILWAY_FILENAMES) {
-    const abs = path53.join(dir, filename);
+    const abs = path56.join(dir, filename);
     if (!await exists(abs)) continue;
-    const raw = await fs23.readFile(abs, "utf8");
+    const raw = await fs26.readFile(abs, "utf8");
     const config = filename === "railway.toml" ? parseToml3(raw) : JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
@@ -12510,7 +13111,7 @@ async function addRailwayServices(graph, services, scanPath) {
     try {
       read = await readRailwayConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra railway", path53.relative(scanPath, service.dir), err);
+      recordExtractionError("infra railway", path56.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -12520,7 +13121,7 @@ async function addRailwayServices(graph, services, scanPath) {
     }
     const anchorId = service.node.id;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(path53.relative(scanPath, path53.join(service.dir, relFile)));
+    const evidenceFile = toPosix(path56.relative(scanPath, path56.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -12544,15 +13145,15 @@ async function addRailwayServices(graph, services, scanPath) {
 }
 
 // src/extract/infra/supabase.ts
-import { promises as fs24 } from "fs";
-import path54 from "path";
+import { promises as fs27 } from "fs";
+import path57 from "path";
 import { parse as parseToml4 } from "smol-toml";
 import { EdgeType as EdgeType23 } from "@neat.is/types";
 async function readSupabaseConfig(dir) {
-  const relFile = path54.join("supabase", "config.toml");
-  const abs = path54.join(dir, relFile);
+  const relFile = path57.join("supabase", "config.toml");
+  const abs = path57.join(dir, relFile);
   if (!await exists(abs)) return null;
-  const raw = await fs24.readFile(abs, "utf8");
+  const raw = await fs27.readFile(abs, "utf8");
   const config = parseToml4(raw);
   return { config, relFile, raw };
 }
@@ -12564,7 +13165,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
     try {
       read = await readSupabaseConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra supabase", path54.relative(scanPath, service.dir), err);
+      recordExtractionError("infra supabase", path57.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -12579,7 +13180,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
       });
     }
     const anchorId = service.node.id;
-    const evidenceFile = toPosix(path54.relative(scanPath, path54.join(service.dir, relFile)));
+    const evidenceFile = toPosix(path57.relative(scanPath, path57.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -12620,12 +13221,12 @@ async function addInfra(graph, scanPath, services) {
 }
 
 // src/extract/zod-shapes.ts
-import path55 from "path";
+import path58 from "path";
 import Parser16 from "tree-sitter";
 import JavaScript8 from "tree-sitter-javascript";
 import {
   EdgeType as EdgeType24,
-  NodeType as NodeType21,
+  NodeType as NodeType24,
   Provenance as Provenance22,
   confidenceForExtracted as confidenceForExtracted19,
   extractedEdgeId as extractedEdgeId11,
@@ -12722,7 +13323,7 @@ function topLevelSchemas(root) {
 }
 function zodShapesFromFile(file, serviceDir) {
   if (!ZOD_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt4(path55.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt4(path58.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const { name, call } of topLevelSchemas(tree.rootNode)) {
@@ -12740,7 +13341,7 @@ function zodShapesFromFile(file, serviceDir) {
       name,
       fields,
       evidence: {
-        file: path55.relative(serviceDir, file.path),
+        file: path58.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12771,7 +13372,7 @@ async function addZodShapes(graph, services) {
         if (!graph.hasNode(shape.infraId)) {
           const node = {
             id: shape.infraId,
-            type: NodeType21.InfraNode,
+            type: NodeType24.InfraNode,
             name: shape.name,
             provider: "self",
             kind: "zod-schema"
@@ -12781,7 +13382,7 @@ async function addZodShapes(graph, services) {
         }
         if (shape.fields.length > 0) {
           const node = graph.getNodeAttributes(shape.infraId);
-          if (node.type === NodeType21.InfraNode) {
+          if (node.type === NodeType24.InfraNode) {
             graph.replaceNodeAttributes(shape.infraId, {
               ...node,
               columns: foldColumns(
@@ -12823,7 +13424,7 @@ async function addZodShapes(graph, services) {
 }
 
 // src/extract/firestore-rules.ts
-import { NodeType as NodeType22 } from "@neat.is/types";
+import { NodeType as NodeType25 } from "@neat.is/types";
 var FIRESTORE_COLLECTION_KIND = "firestore-collection";
 var WRITE_METHODS = /* @__PURE__ */ new Set(["write", "create", "update"]);
 function stripComments(src) {
@@ -12963,7 +13564,7 @@ async function addFirestoreRules(graph, services) {
   if (guards.size === 0) return { nodesAdded: 0, edgesAdded: 0 };
   graph.forEachNode((id, attrs) => {
     const node = attrs;
-    if (node.type !== NodeType22.InfraNode) return;
+    if (node.type !== NodeType25.InfraNode) return;
     if (node.kind !== FIRESTORE_COLLECTION_KIND) return;
     const fields = guards.get(collectionKeyFromName(node.name));
     if (!fields || fields.size === 0) return;
@@ -12976,16 +13577,16 @@ async function addFirestoreRules(graph, services) {
 }
 
 // src/extract/index.ts
-import path57 from "path";
+import path60 from "path";
 
 // src/extract/retire.ts
 import { existsSync as existsSync2 } from "fs";
-import path56 from "path";
-import { NodeType as NodeType23, Provenance as Provenance23 } from "@neat.is/types";
+import path59 from "path";
+import { NodeType as NodeType26, Provenance as Provenance23 } from "@neat.is/types";
 function dropOrphanedFileNodes(graph) {
   const orphans = [];
   graph.forEachNode((id, attrs) => {
-    if (attrs.type !== NodeType23.FileNode) return;
+    if (attrs.type !== NodeType26.FileNode) return;
     if (graph.inboundEdges(id).length === 0 && graph.outboundEdges(id).length === 0) {
       orphans.push(id);
     }
@@ -13014,11 +13615,11 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
     if (edge.provenance !== Provenance23.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
-    if (path56.isAbsolute(evidenceFile)) {
+    if (path59.isAbsolute(evidenceFile)) {
       if (!existsSync2(evidenceFile)) toDrop.push(id);
       return;
     }
-    const found = bases.some((base) => existsSync2(path56.join(base, evidenceFile)));
+    const found = bases.some((base) => existsSync2(path59.join(base, evidenceFile)));
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
@@ -13075,7 +13676,7 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
   }
   const droppedEntries = drainDroppedExtracted();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
-    const rejectedPath = path57.join(path57.dirname(opts.errorsPath), "rejected.ndjson");
+    const rejectedPath = path60.join(path60.dirname(opts.errorsPath), "rejected.ndjson");
     try {
       await writeRejectedExtracted(droppedEntries, rejectedPath);
     } catch (err) {
@@ -13112,11 +13713,11 @@ import {
   databaseId as databaseId3,
   DivergenceResultSchema,
   EdgeType as EdgeType25,
-  NodeType as NodeType24,
+  NodeType as NodeType27,
   parseEdgeId,
   parseFileId,
   Provenance as Provenance24,
-  serviceId as serviceId7
+  serviceId as serviceId10
 } from "@neat.is/types";
 function bucketKey(source, target, type) {
   return `${type}|${source}|${target}`;
@@ -13126,8 +13727,8 @@ function bucketSourceFor(graph, edge) {
   const parsed = parseFileId(edge.source);
   if (!parsed || !graph.hasNode(edge.target)) return edge.source;
   const target = graph.getNodeAttributes(edge.target);
-  if (target.type !== NodeType24.DatabaseNode) return edge.source;
-  return serviceId7(parsed.service);
+  if (target.type !== NodeType27.DatabaseNode) return edge.source;
+  return serviceId10(parsed.service);
 }
 function bucketEdges(graph) {
   const buckets2 = /* @__PURE__ */ new Map();
@@ -13158,22 +13759,22 @@ function bucketEdges(graph) {
 function nodeIsFrontier(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === NodeType24.FrontierNode;
+  return attrs.type === NodeType27.FrontierNode;
 }
 function nodeIsWebsocketChannel(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === NodeType24.WebSocketChannelNode;
+  return attrs.type === NodeType27.WebSocketChannelNode;
 }
 function nodeIsServerAction(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === NodeType24.ServerActionNode;
+  return attrs.type === NodeType27.ServerActionNode;
 }
 function nodeIsSymbol(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === NodeType24.SymbolNode;
+  return attrs.type === NodeType27.SymbolNode;
 }
 function clampConfidence(n) {
   if (!Number.isFinite(n)) return 0;
@@ -13258,7 +13859,7 @@ function detectHostMismatch(graph, svcId, svc) {
     if (edge.type !== EdgeType25.CONNECTS_TO) continue;
     if (edge.provenance !== Provenance24.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== NodeType24.DatabaseNode) continue;
+    if (target.type !== NodeType27.DatabaseNode) continue;
     const observedHost = target.host?.trim();
     if (!observedHost) continue;
     if (observedHost === declaredHost) continue;
@@ -13283,7 +13884,7 @@ function detectCompatDivergences(graph, svcId, svc) {
     if (edge.type !== EdgeType25.CONNECTS_TO) continue;
     if (edge.provenance !== Provenance24.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== NodeType24.DatabaseNode) continue;
+    if (target.type !== NodeType27.DatabaseNode) continue;
     for (const pair of compatPairs()) {
       if (pair.engine !== target.engine) continue;
       const declared = deps[pair.driver];
@@ -13399,13 +14000,13 @@ function computeDivergences(graph, opts = {}) {
   }
   graph.forEachNode((nodeId, attrs) => {
     const n = attrs;
-    if (n.type === NodeType24.ServiceNode) {
+    if (n.type === NodeType27.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 === NodeType24.InfraNode && n.kind === "sql-table") {
+    if (n.type === NodeType27.InfraNode && n.kind === "sql-table") {
       for (const d of detectColumnDrift(n)) all.push(d);
     }
   });
@@ -13449,9 +14050,9 @@ function computeDivergences(graph, opts = {}) {
 }
 
 // src/persist.ts
-import { promises as fs25 } from "fs";
-import path58 from "path";
-import { NodeType as NodeType25, Provenance as Provenance25, observedEdgeId as observedEdgeId2 } from "@neat.is/types";
+import { promises as fs28 } from "fs";
+import path61 from "path";
+import { NodeType as NodeType28, Provenance as Provenance25, observedEdgeId as observedEdgeId2 } from "@neat.is/types";
 var SCHEMA_VERSION = 7;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
@@ -13475,7 +14076,7 @@ function migrateV5ToV6(payload) {
   if (Array.isArray(nodes)) {
     for (const node of nodes) {
       const attrs = node.attributes;
-      if (!attrs || attrs.type !== NodeType25.InfraNode) continue;
+      if (!attrs || attrs.type !== NodeType28.InfraNode) continue;
       if (attrs.kind !== "sql-table" && attrs.kind !== "supabase-table") continue;
       if (!Array.isArray(attrs.columns)) attrs.columns = [];
     }
@@ -13505,7 +14106,7 @@ function migrateV2ToV3(payload) {
   return { ...payload, schemaVersion: 3 };
 }
 async function ensureDir(filePath) {
-  await fs25.mkdir(path58.dirname(filePath), { recursive: true });
+  await fs28.mkdir(path61.dirname(filePath), { recursive: true });
 }
 async function saveGraphToDisk(graph, outPath) {
   await ensureDir(outPath);
@@ -13515,13 +14116,13 @@ async function saveGraphToDisk(graph, outPath) {
     graph: graph.export()
   };
   const tmp = `${outPath}.tmp`;
-  await fs25.writeFile(tmp, JSON.stringify(payload), "utf8");
-  await fs25.rename(tmp, outPath);
+  await fs28.writeFile(tmp, JSON.stringify(payload), "utf8");
+  await fs28.rename(tmp, outPath);
 }
 async function loadGraphFromDisk(graph, outPath) {
   let raw;
   try {
-    raw = await fs25.readFile(outPath, "utf8");
+    raw = await fs28.readFile(outPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -13594,7 +14195,7 @@ function startPersistLoop(graph, outPath, opts = {}) {
 }
 
 // src/diff.ts
-import { promises as fs26 } from "fs";
+import { promises as fs29 } from "fs";
 async function loadSnapshotForDiff(target) {
   if (/^https?:\/\//i.test(target)) {
     const res = await fetch(target);
@@ -13603,7 +14204,7 @@ async function loadSnapshotForDiff(target) {
     }
     return await res.json();
   }
-  const raw = await fs26.readFile(target, "utf8");
+  const raw = await fs29.readFile(target, "utf8");
   return JSON.parse(raw);
 }
 function indexEntries(entries) {
@@ -13670,23 +14271,23 @@ function canonicalJson(value) {
 }
 
 // src/projects.ts
-import path59 from "path";
+import path62 from "path";
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: path59.join(baseDir, "graph.json"),
-      errorsPath: path59.join(baseDir, "errors.ndjson"),
-      staleEventsPath: path59.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: path59.join(baseDir, "embeddings.json"),
-      policyViolationsPath: path59.join(baseDir, "policy-violations.ndjson")
+      snapshotPath: path62.join(baseDir, "graph.json"),
+      errorsPath: path62.join(baseDir, "errors.ndjson"),
+      staleEventsPath: path62.join(baseDir, "stale-events.ndjson"),
+      embeddingsCachePath: path62.join(baseDir, "embeddings.json"),
+      policyViolationsPath: path62.join(baseDir, "policy-violations.ndjson")
     };
   }
   return {
-    snapshotPath: path59.join(baseDir, `${project}.json`),
-    errorsPath: path59.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: path59.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: path59.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: path59.join(baseDir, `policy-violations.${project}.ndjson`)
+    snapshotPath: path62.join(baseDir, `${project}.json`),
+    errorsPath: path62.join(baseDir, `errors.${project}.ndjson`),
+    staleEventsPath: path62.join(baseDir, `stale-events.${project}.ndjson`),
+    embeddingsCachePath: path62.join(baseDir, `embeddings.${project}.json`),
+    policyViolationsPath: path62.join(baseDir, `policy-violations.${project}.ndjson`)
   };
 }
 var Projects = class {
@@ -13725,9 +14326,9 @@ function parseExtraProjects(raw) {
 }
 
 // src/registry.ts
-import { promises as fs27 } from "fs";
+import { promises as fs30 } from "fs";
 import os2 from "os";
-import path60 from "path";
+import path63 from "path";
 import {
   RegistryFileSchema
 } from "@neat.is/types";
@@ -13735,20 +14336,20 @@ var LOCK_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_MS = 50;
 function neatHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return path60.resolve(override);
-  return path60.join(os2.homedir(), ".neat");
+  if (override && override.length > 0) return path63.resolve(override);
+  return path63.join(os2.homedir(), ".neat");
 }
 function registryPath() {
-  return path60.join(neatHome(), "projects.json");
+  return path63.join(neatHome(), "projects.json");
 }
 function registryLockPath() {
-  return path60.join(neatHome(), "projects.json.lock");
+  return path63.join(neatHome(), "projects.json.lock");
 }
 function daemonPidPath() {
-  return path60.join(neatHome(), "neatd.pid");
+  return path63.join(neatHome(), "neatd.pid");
 }
 function daemonsDir() {
-  return path60.join(neatHome(), "daemons");
+  return path63.join(neatHome(), "daemons");
 }
 function isFiniteInt(v) {
   return typeof v === "number" && Number.isFinite(v);
@@ -13781,7 +14382,7 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const dir = daemonsDir();
   let names;
   try {
-    names = await fs27.readdir(dir);
+    names = await fs30.readdir(dir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -13789,10 +14390,10 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const out = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const file = path60.join(dir, name);
+    const file = path63.join(dir, name);
     let raw;
     try {
-      raw = await fs27.readFile(file, "utf8");
+      raw = await fs30.readFile(file, "utf8");
     } catch {
       continue;
     }
@@ -13805,7 +14406,7 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   return out;
 }
 async function removeDaemonRecord(source) {
-  await fs27.unlink(source).catch(() => {
+  await fs30.unlink(source).catch(() => {
   });
 }
 async function listMachineProjects(probe = defaultDiscoveryProbe) {
@@ -13862,7 +14463,7 @@ function isPidAliveDefault(pid) {
 }
 async function readPidFile(file) {
   try {
-    const raw = await fs27.readFile(file, "utf8");
+    const raw = await fs30.readFile(file, "utf8");
     const pid = Number.parseInt(raw.trim(), 10);
     return Number.isInteger(pid) && pid > 0 ? pid : void 0;
   } catch {
@@ -13910,32 +14511,32 @@ function lockHolderMessage(holder, lockPath, timeoutMs) {
   }
 }
 async function normalizeProjectPath(input) {
-  const resolved = path60.resolve(input);
+  const resolved = path63.resolve(input);
   try {
-    return await fs27.realpath(resolved);
+    return await fs30.realpath(resolved);
   } catch {
     return resolved;
   }
 }
 async function writeAtomically(target, contents) {
-  await fs27.mkdir(path60.dirname(target), { recursive: true });
+  await fs30.mkdir(path63.dirname(target), { recursive: true });
   const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await fs27.open(tmp, "w");
+  const fd = await fs30.open(tmp, "w");
   try {
     await fd.writeFile(contents, "utf8");
     await fd.sync();
   } finally {
     await fd.close();
   }
-  await fs27.rename(tmp, target);
+  await fs30.rename(tmp, target);
 }
 async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaultLockHolderProbe) {
   const deadline = Date.now() + timeoutMs;
-  await fs27.mkdir(path60.dirname(lockPath), { recursive: true });
+  await fs30.mkdir(path63.dirname(lockPath), { recursive: true });
   let probedHolder = false;
   while (true) {
     try {
-      const fd = await fs27.open(lockPath, "wx");
+      const fd = await fs30.open(lockPath, "wx");
       try {
         await fd.writeFile(`${process.pid}
 `, "utf8");
@@ -13960,7 +14561,7 @@ async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaul
   }
 }
 async function releaseLock(lockPath) {
-  await fs27.unlink(lockPath).catch(() => {
+  await fs30.unlink(lockPath).catch(() => {
   });
 }
 async function withLock(fn) {
@@ -13976,7 +14577,7 @@ async function readRegistry() {
   const file = registryPath();
   let raw;
   try {
-    raw = await fs27.readFile(file, "utf8");
+    raw = await fs30.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: 1, projects: [] };
@@ -14081,7 +14682,7 @@ function pruneTtlMs() {
 }
 async function statPathStatus(p) {
   try {
-    const stat = await fs27.stat(p);
+    const stat = await fs30.stat(p);
     return stat.isDirectory() ? "present" : "unknown";
   } catch (err) {
     return err.code === "ENOENT" ? "gone" : "unknown";
@@ -14126,14 +14727,14 @@ import cors from "@fastify/cors";
 import { DivergenceTypeSchema, PoliciesCheckBodySchema, PolicySeveritySchema } from "@neat.is/types";
 
 // src/extend/index.ts
-import { promises as fs29 } from "fs";
-import path62 from "path";
+import { promises as fs32 } from "fs";
+import path65 from "path";
 import os3 from "os";
 import { resolve as registryResolve, list as registryList } from "@neat.is/instrumentation-registry";
 
 // src/installers/package-manager.ts
-import { promises as fs28 } from "fs";
-import path61 from "path";
+import { promises as fs31 } from "fs";
+import path64 from "path";
 import { spawn } from "child_process";
 var LOCKFILE_PRIORITY = [
   { lockfile: "bun.lockb", pm: "bun", args: ["install", "--no-summary"] },
@@ -14148,29 +14749,29 @@ var LOCKFILE_PRIORITY = [
 var NPM_FALLBACK_ARGS = ["install", "--no-audit", "--no-fund", "--prefer-offline"];
 async function exists2(p) {
   try {
-    await fs28.access(p);
+    await fs31.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function detectPackageManager(serviceDir) {
-  let dir = path61.resolve(serviceDir);
+  let dir = path64.resolve(serviceDir);
   const stops = /* @__PURE__ */ new Set();
   for (let i = 0; i < 64; i++) {
     if (stops.has(dir)) break;
     stops.add(dir);
     for (const candidate of LOCKFILE_PRIORITY) {
-      const lockPath = path61.join(dir, candidate.lockfile);
+      const lockPath = path64.join(dir, candidate.lockfile);
       if (await exists2(lockPath)) {
         return { pm: candidate.pm, cwd: dir, args: [...candidate.args] };
       }
     }
-    const parent = path61.dirname(dir);
+    const parent = path64.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return { pm: "npm", cwd: path61.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
+  return { pm: "npm", cwd: path64.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
 }
 async function runPackageManagerInstall(cmd) {
   return new Promise((resolve) => {
@@ -14212,15 +14813,15 @@ ${err.message}`
 // src/extend/index.ts
 async function fileExists2(p) {
   try {
-    await fs29.access(p);
+    await fs32.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function readPackageJson(scanPath) {
-  const pkgPath = path62.join(scanPath, "package.json");
-  const raw = await fs29.readFile(pkgPath, "utf8");
+  const pkgPath = path65.join(scanPath, "package.json");
+  const raw = await fs32.readFile(pkgPath, "utf8");
   return JSON.parse(raw);
 }
 var HOOK_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -14234,15 +14835,15 @@ var HOOK_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
 async function findHookFiles(scanPath) {
   const found = [];
   const walk9 = async (dir) => {
-    const entries = await fs29.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await fs32.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || HOOK_WALK_SKIP_DIRS.has(entry.name)) continue;
-        await walk9(path62.join(dir, entry.name));
+        await walk9(path65.join(dir, entry.name));
       } else if (entry.isFile()) {
         if ((entry.name.startsWith("instrumentation") || entry.name.startsWith("otel-init")) && /\.(ts|js|cjs|mjs)$/.test(entry.name)) {
-          const rel = path62.relative(scanPath, path62.join(dir, entry.name));
-          found.push(rel.split(path62.sep).join("/"));
+          const rel = path65.relative(scanPath, path65.join(dir, entry.name));
+          found.push(rel.split(path65.sep).join("/"));
         }
       }
     }
@@ -14253,7 +14854,7 @@ async function findHookFiles(scanPath) {
 async function pickPrimaryHookFile(scanPath, hookFiles, snippet2) {
   let fallback = null;
   for (const file of hookFiles) {
-    const content = await fs29.readFile(path62.join(scanPath, file), "utf8");
+    const content = await fs32.readFile(path65.join(scanPath, file), "utf8");
     const patched = splicedContent(content, snippet2);
     if (patched !== null) return { file, content, patched };
     if (fallback === null) fallback = { file, content };
@@ -14261,12 +14862,12 @@ async function pickPrimaryHookFile(scanPath, hookFiles, snippet2) {
   return { file: fallback.file, content: fallback.content, patched: null };
 }
 function extendLogPath() {
-  return process.env.NEAT_EXTEND_LOG ?? path62.join(os3.homedir(), ".neat", "extend-log.ndjson");
+  return process.env.NEAT_EXTEND_LOG ?? path65.join(os3.homedir(), ".neat", "extend-log.ndjson");
 }
 async function appendExtendLog(entry) {
   const logPath = extendLogPath();
-  await fs29.mkdir(path62.dirname(logPath), { recursive: true });
-  await fs29.appendFile(logPath, JSON.stringify(entry) + "\n", "utf8");
+  await fs32.mkdir(path65.dirname(logPath), { recursive: true });
+  await fs32.appendFile(logPath, JSON.stringify(entry) + "\n", "utf8");
 }
 function splicedContent(fileContent, snippet2) {
   if (fileContent.includes("__INSTRUMENTATION_BLOCK__")) {
@@ -14324,7 +14925,7 @@ function lookupInstrumentation(library, installedVersion) {
 }
 async function describeProjectInstrumentation(ctx) {
   const hookFiles = await findHookFiles(ctx.scanPath);
-  const envNeat = await fileExists2(path62.join(ctx.scanPath, ".env.neat"));
+  const envNeat = await fileExists2(path65.join(ctx.scanPath, ".env.neat"));
   const registryInstrPackages = new Set(
     registryList().map((e) => e.instrumentation_package).filter((p) => !!p)
   );
@@ -14346,7 +14947,7 @@ async function applyExtension(ctx, args, options) {
     );
   }
   for (const file of hookFiles) {
-    const content = await fs29.readFile(path62.join(ctx.scanPath, file), "utf8");
+    const content = await fs32.readFile(path65.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return { library: args.library, filesTouched: [], depsAdded: [], installOutput: "", alreadyApplied: true };
     }
@@ -14358,18 +14959,18 @@ async function applyExtension(ctx, args, options) {
     );
   }
   const primaryFile = primary.file;
-  const primaryPath = path62.join(ctx.scanPath, primaryFile);
+  const primaryPath = path65.join(ctx.scanPath, primaryFile);
   const filesTouched = [];
   const depsAdded = [];
-  const pkgPath = path62.join(ctx.scanPath, "package.json");
+  const pkgPath = path65.join(ctx.scanPath, "package.json");
   const pkg = await readPackageJson(ctx.scanPath);
   if (!(pkg.dependencies ?? {})[args.instrumentation_package]) {
     pkg.dependencies = { ...pkg.dependencies ?? {}, [args.instrumentation_package]: args.version };
-    await fs29.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    await fs32.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     filesTouched.push("package.json");
     depsAdded.push(`${args.instrumentation_package}@${args.version}`);
   }
-  await fs29.writeFile(primaryPath, primary.patched, "utf8");
+  await fs32.writeFile(primaryPath, primary.patched, "utf8");
   filesTouched.push(primaryFile);
   const cmd = await detectPackageManager(ctx.scanPath);
   const installer = options?.runInstall ?? runPackageManagerInstall;
@@ -14400,7 +15001,7 @@ async function dryRunExtension(ctx, args) {
     };
   }
   for (const file of hookFiles) {
-    const content = await fs29.readFile(path62.join(ctx.scanPath, file), "utf8");
+    const content = await fs32.readFile(path65.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return {
         library: args.library,
@@ -14435,28 +15036,28 @@ async function rollbackExtension(ctx, args) {
   if (!await fileExists2(logPath)) {
     return { undone: false, message: "no apply found for library" };
   }
-  const raw = await fs29.readFile(logPath, "utf8");
+  const raw = await fs32.readFile(logPath, "utf8");
   const entries = raw.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
   const match = [...entries].reverse().find((e) => e.project === ctx.project && e.library === args.library);
   if (!match) {
     return { undone: false, message: "no apply found for library" };
   }
-  const pkgPath = path62.join(ctx.scanPath, "package.json");
+  const pkgPath = path65.join(ctx.scanPath, "package.json");
   if (await fileExists2(pkgPath)) {
     const pkg = await readPackageJson(ctx.scanPath);
     if (pkg.dependencies?.[match.instrumentation_package]) {
       const { [match.instrumentation_package]: _removed, ...rest } = pkg.dependencies;
       pkg.dependencies = rest;
-      await fs29.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+      await fs32.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     }
   }
   const hookFiles = await findHookFiles(ctx.scanPath);
   for (const file of hookFiles) {
-    const filePath = path62.join(ctx.scanPath, file);
-    const content = await fs29.readFile(filePath, "utf8");
+    const filePath = path65.join(ctx.scanPath, file);
+    const content = await fs32.readFile(filePath, "utf8");
     if (content.includes(match.registration_snippet)) {
       const filtered = content.split("\n").filter((line) => !line.includes(match.registration_snippet)).join("\n");
-      await fs29.writeFile(filePath, filtered, "utf8");
+      await fs32.writeFile(filePath, filtered, "utf8");
       break;
     }
   }
@@ -14567,8 +15168,8 @@ data: ${JSON.stringify(envelope.payload)}
 
 // src/connectors-config.ts
 import os4 from "os";
-import path63 from "path";
-import { promises as fs30 } from "fs";
+import path66 from "path";
+import { promises as fs33 } from "fs";
 var CONNECTORS_CONFIG_VERSION = 1;
 var EnvRefUnsetError = class extends Error {
   ref;
@@ -14582,17 +15183,17 @@ var EnvRefUnsetError = class extends Error {
 };
 function neatHome2() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return path63.resolve(override);
-  return path63.join(os4.homedir(), ".neat");
+  if (override && override.length > 0) return path66.resolve(override);
+  return path66.join(os4.homedir(), ".neat");
 }
 function connectorsConfigPath(home = neatHome2()) {
-  return path63.join(home, "connectors.json");
+  return path66.join(home, "connectors.json");
 }
 var MODE_MASK_LOOSER_THAN_0600 = 63;
 async function warnIfModeLooserThan0600(file) {
   if (process.platform === "win32") return;
   try {
-    const stat = await fs30.stat(file);
+    const stat = await fs33.stat(file);
     if ((stat.mode & MODE_MASK_LOOSER_THAN_0600) !== 0) {
       const mode = (stat.mode & 511).toString(8).padStart(3, "0");
       console.warn(
@@ -14606,7 +15207,7 @@ async function readConnectorsConfig(home = neatHome2()) {
   const file = connectorsConfigPath(home);
   let raw;
   try {
-    raw = await fs30.readFile(file, "utf8");
+    raw = await fs33.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: CONNECTORS_CONFIG_VERSION, connectors: [] };
@@ -14717,7 +15318,7 @@ function connectorMatchesProject(entry, project) {
 var CONNECTORS_LOCK_TIMEOUT_MS = 5e3;
 var CONNECTORS_LOCK_RETRY_MS = 50;
 function connectorsConfigLockPath(home = neatHome2()) {
-  return path63.join(home, "connectors.json.lock");
+  return path66.join(home, "connectors.json.lock");
 }
 function isEnvRef(value) {
   return value.length > 1 && value.startsWith("$");
@@ -14730,9 +15331,9 @@ function redactCredentialRef(ref) {
   return out;
 }
 async function writeConfigAtomically0600(file, contents) {
-  await fs30.mkdir(path63.dirname(file), { recursive: true });
+  await fs33.mkdir(path66.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await fs30.open(tmp, "w", 384);
+  const fd = await fs33.open(tmp, "w", 384);
   try {
     await fd.writeFile(contents, "utf8");
     await fd.chmod(384);
@@ -14740,14 +15341,14 @@ async function writeConfigAtomically0600(file, contents) {
   } finally {
     await fd.close();
   }
-  await fs30.rename(tmp, file);
+  await fs33.rename(tmp, file);
 }
 async function acquireConnectorsLock(lockPath, timeoutMs = CONNECTORS_LOCK_TIMEOUT_MS) {
   const deadline = Date.now() + timeoutMs;
-  await fs30.mkdir(path63.dirname(lockPath), { recursive: true });
+  await fs33.mkdir(path66.dirname(lockPath), { recursive: true });
   for (; ; ) {
     try {
-      const fd = await fs30.open(lockPath, "wx");
+      const fd = await fs33.open(lockPath, "wx");
       try {
         await fd.writeFile(`${process.pid}
 `, "utf8");
@@ -14767,7 +15368,7 @@ async function acquireConnectorsLock(lockPath, timeoutMs = CONNECTORS_LOCK_TIMEO
   }
 }
 async function releaseConnectorsLock(lockPath) {
-  await fs30.unlink(lockPath).catch(() => {
+  await fs33.unlink(lockPath).catch(() => {
   });
 }
 async function withConnectorsLock(home, fn) {
@@ -14892,7 +15493,7 @@ function getConnectorStatus(id, now = Date.now(), thresholdMs = CONNECTOR_STALE_
 }
 
 // src/connectors/index.ts
-import { NodeType as NodeType26, parseFileId as parseFileId2, Provenance as Provenance26 } from "@neat.is/types";
+import { NodeType as NodeType29, parseFileId as parseFileId2, Provenance as Provenance26 } from "@neat.is/types";
 var NO_ENV = "unknown";
 function staticCallSiteFor(graph, serviceName, targetNodeId) {
   if (!graph.hasNode(targetNodeId)) return void 0;
@@ -14911,7 +15512,7 @@ function staticCallSiteFor(graph, serviceName, targetNodeId) {
 function routeCallSiteFor(graph, targetNodeId) {
   if (!graph.hasNode(targetNodeId)) return void 0;
   const attrs = graph.getNodeAttributes(targetNodeId);
-  if (attrs.type !== NodeType26.RouteNode || !attrs.path) return void 0;
+  if (attrs.type !== NodeType29.RouteNode || !attrs.path) return void 0;
   const site = { relPath: attrs.path };
   if (attrs.line !== void 0) site.line = attrs.line;
   return site;
@@ -15396,10 +15997,10 @@ var SUPABASE_RPC_TARGET_KIND = "supabase-rpc";
 // src/connectors/supabase/map.ts
 var REST_RPC_PATH_RE = /^\/rest\/v1\/rpc\/([^/?]+)/;
 var REST_TABLE_PATH_RE = /^\/rest\/v1\/([^/?]+)/;
-function targetFromRestPath(path64) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path64);
+function targetFromRestPath(path67) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path67);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path64);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path67);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -15616,7 +16217,7 @@ function createSupabaseConnector(graph, config, deps = {}) {
 }
 
 // src/connectors/railway/index.ts
-import { EdgeType as EdgeType27, NodeType as NodeType27, serviceId as serviceId8 } from "@neat.is/types";
+import { EdgeType as EdgeType27, NodeType as NodeType30, serviceId as serviceId11 } from "@neat.is/types";
 
 // src/connectors/railway/client.ts
 var DEFAULT_RAILWAY_API_URL = "https://backboard.railway.com/graphql/v2";
@@ -15766,7 +16367,7 @@ function buildRailwayRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== NodeType27.RouteNode) return;
+    if (node.type !== NodeType30.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -15875,7 +16476,7 @@ function createRailwayResolveTarget(config) {
     if (signal.targetKind === PEER_SERVICE_TARGET_KIND) {
       const peerName = config.serviceNameById[signal.targetName];
       if (!peerName) return null;
-      return { targetNodeId: serviceId8(peerName), serviceName, edgeType: EdgeType27.CONNECTS_TO };
+      return { targetNodeId: serviceId11(peerName), serviceName, edgeType: EdgeType27.CONNECTS_TO };
     }
     return null;
   };
@@ -15994,9 +16595,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path64 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path64) return null;
-  return { resourceName, method, path: path64 };
+  const path67 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path67) return null;
+  return { resourceName, method, path: path67 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -16034,14 +16635,14 @@ function mapLogEntryToSignal(entry) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path64 = pathFromRequestUrl(req.requestUrl);
-  if (path64 === null) return null;
+  const path67 = pathFromRequestUrl(req.requestUrl);
+  if (path67 === null) return null;
   const timestamp = entry.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD2;
   return {
     targetKind: resourceType,
-    targetName: packFirebaseTargetName({ resourceName, method, path: path64 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path67 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -16057,7 +16658,7 @@ function mapLogEntriesToSignals(entries) {
 }
 
 // src/connectors/firebase/resolve.ts
-import { NodeType as NodeType28, EdgeType as EdgeType28 } from "@neat.is/types";
+import { NodeType as NodeType31, EdgeType as EdgeType28 } from "@neat.is/types";
 function neatServiceNameFor(resourceType, resourceName, serviceMap) {
   switch (resourceType) {
     case "cloud_function":
@@ -16072,7 +16673,7 @@ function routeEntriesFor(graph, serviceName) {
   const entries = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== NodeType28.RouteNode) return;
+    if (node.type !== NodeType31.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     entries.push({
@@ -16127,7 +16728,7 @@ function createFirebaseConnector(graph, serviceMap) {
 }
 
 // src/connectors/cloudflare/connector.ts
-import { EdgeType as EdgeType29, NodeType as NodeType29, fileId as fileId5, infraId as infraId21 } from "@neat.is/types";
+import { EdgeType as EdgeType29, NodeType as NodeType32, fileId as fileId5, infraId as infraId21 } from "@neat.is/types";
 
 // src/connectors/cloudflare/client.ts
 import { randomUUID } from "crypto";
@@ -16238,7 +16839,7 @@ function mapEventToSignal(event) {
   if (Number.isNaN(observedAt.getTime())) return null;
   const statusCode = metadata?.statusCode;
   const isError = typeof statusCode === "number" && statusCode >= ERROR_STATUS_THRESHOLD3;
-  const path64 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path67 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -16246,7 +16847,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path64 ? { path: path64 } : {},
+    ...path67 ? { path: path67 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -16286,19 +16887,19 @@ function findTaggedWorkerFileNode(graph, workerName) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type === NodeType29.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
+    if (a.type === NodeType32.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
       found = id;
     }
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path64) {
-  const normalizedPath = normalizePathTemplate(path64);
+function findMatchingRouteNode(graph, serviceName, method, path67) {
+  const normalizedPath = normalizePathTemplate(path67);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== NodeType29.RouteNode || a.service !== serviceName) return;
+    if (a.type !== NodeType32.RouteNode || a.service !== serviceName) return;
     if (!a.pathTemplate || normalizePathTemplate(a.pathTemplate) !== normalizedPath) return;
     const routeMethod = (a.method ?? "").toUpperCase();
     if (routeMethod !== "ALL" && routeMethod !== method) return;
@@ -16310,10 +16911,10 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path64 } = signal;
+    const { method, path: path67 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path64) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path64) ?? wholeFileId;
+      if (!method || !path67) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path67) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
@@ -16643,9 +17244,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path64 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path64) return null;
-  return { serviceName, method, path: path64 };
+  const path67 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path67) return null;
+  return { serviceName, method, path: path67 };
 }
 
 // src/connectors/cloud-run/map.ts
@@ -16674,14 +17275,14 @@ function mapLogEntryToSignal2(entry) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path64 = pathFromRequestUrl2(req.requestUrl);
-  if (path64 === null) return null;
+  const path67 = pathFromRequestUrl2(req.requestUrl);
+  if (path67 === null) return null;
   const timestamp = entry.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD4;
   return {
     targetKind: CLOUD_RUN_TARGET_KIND,
-    targetName: packCloudRunTargetName({ serviceName, method, path: path64 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path67 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -16697,14 +17298,14 @@ function mapLogEntriesToSignals2(entries) {
 }
 
 // src/connectors/cloud-run/resolve.ts
-import { EdgeType as EdgeType31, NodeType as NodeType30, infraId as infraId23 } from "@neat.is/types";
+import { EdgeType as EdgeType31, NodeType as NodeType33, infraId as infraId23 } from "@neat.is/types";
 var CLOUD_RUN_SERVICE_INFRA_KIND = "cloud-run-service";
 function findMatchingRouteNode2(graph, serviceName, method, normalizedPath) {
   let found = null;
   graph.forEachNode((_id, attrs) => {
     if (found) return;
     const node = attrs;
-    if (node.type !== NodeType30.RouteNode) return;
+    if (node.type !== NodeType33.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -16719,14 +17320,14 @@ function createCloudRunResolveTarget(graph, config) {
     if (signal.targetKind !== CLOUD_RUN_TARGET_KIND) return null;
     const identity = parseCloudRunTargetName(signal.targetName);
     if (!identity) return null;
-    const { serviceName: gcpServiceName, method, path: path64 } = identity;
+    const { serviceName: gcpServiceName, method, path: path67 } = identity;
     const mappedService = config.serviceMap?.[gcpServiceName];
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path64)
+        normalizePathTemplate(path67)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: EdgeType31.CALLS };
@@ -16775,7 +17376,7 @@ function createCloudRunConnector(graph, config = {}) {
 }
 
 // src/connectors/render/index.ts
-import { EdgeType as EdgeType32, NodeType as NodeType31 } from "@neat.is/types";
+import { EdgeType as EdgeType32, NodeType as NodeType34 } from "@neat.is/types";
 
 // src/connectors/render/types.ts
 function readRenderToken(credentials) {
@@ -16851,7 +17452,7 @@ function buildRenderRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== NodeType31.RouteNode) return;
+    if (node.type !== NodeType34.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -17335,7 +17936,7 @@ function mapBuildsToSignals(builds, serviceName) {
 }
 
 // src/connectors/eas/resolve.ts
-import { EdgeType as EdgeType34, NodeType as NodeType32, parseFileId as parseFileId3 } from "@neat.is/types";
+import { EdgeType as EdgeType34, NodeType as NodeType35, parseFileId as parseFileId3 } from "@neat.is/types";
 var NO_ENV2 = "unknown";
 var EAS_JSON_PHASES = /* @__PURE__ */ new Set(["READ_EAS_JSON"]);
 var APP_CONFIG_PHASES = /* @__PURE__ */ new Set([
@@ -17363,7 +17964,7 @@ function findConfigNode(graph, basenames, serviceName) {
   graph.forEachNode((id, attrs) => {
     if (scoped) return;
     const node = attrs;
-    if (node.type !== NodeType32.ConfigNode) return;
+    if (node.type !== NodeType35.ConfigNode) return;
     if (typeof node.name !== "string" || !basenames.includes(node.name)) return;
     if (anyMatch === null) anyMatch = id;
     if (configNodeService(graph, id) === serviceName) scoped = id;
@@ -18975,4 +19576,4 @@ export {
   deprovisionConnector,
   buildApi
 };
-//# sourceMappingURL=chunk-ZGZYZ33B.js.map
+//# sourceMappingURL=chunk-T4UGEMWN.js.map