npm - @neat.is/core - Versions diffs - 0.10.1 → 0.10.3-dev.20260930 - Mend

@neat.is/core 0.10.1 → 0.10.3-dev.20260930

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/dist/{chunk-AWIK6T3G.js → chunk-DLQNMU3R.js} +2 -2
package/dist/{chunk-E3YFFIHE.js → chunk-LNIVRE4L.js} +801 -569
package/dist/chunk-LNIVRE4L.js.map +1 -0
package/dist/cli.cjs +1544 -1081
package/dist/cli.cjs.map +1 -1
package/dist/cli.d.cts +5 -2
package/dist/cli.d.ts +5 -2
package/dist/cli.js +457 -224
package/dist/cli.js.map +1 -1
package/dist/index.cjs +843 -628
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +33 -1
package/dist/index.d.ts +33 -1
package/dist/index.js +2 -2
package/dist/neatd.cjs +854 -639
package/dist/neatd.cjs.map +1 -1
package/dist/neatd.js +2 -2
package/dist/server.cjs +712 -525
package/dist/server.cjs.map +1 -1
package/dist/server.js +1 -1
package/package.json +2 -2
package/dist/chunk-E3YFFIHE.js.map +0 -1
/package/dist/{chunk-AWIK6T3G.js.map → chunk-DLQNMU3R.js.map} +0 -0

package/dist/{chunk-E3YFFIHE.js → chunk-LNIVRE4L.js} RENAMED Viewed

@@ -342,8 +342,8 @@ function deprecatedApis() {
 }
 // src/ingest.ts
-import { promises as fs7, existsSync, readFileSync } from "fs";
-import path8 from "path";
+import { promises as fs8, existsSync, readFileSync } from "fs";
+import path9 from "path";
 import * as sourceMapJs from "source-map-js";
 // src/policy.ts
@@ -942,7 +942,7 @@ import {
 } from "@neat.is/types";
 // src/extract/routes.ts
-import path7 from "path";
+import path8 from "path";
 import Parser2 from "tree-sitter";
 import JavaScript2 from "tree-sitter-javascript";
 import Python2 from "tree-sitter-python";
@@ -974,6 +974,17 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "dist",
   "build",
   ".next",
+  // `_next` is the *emitted* half of the pair above — `next build`'s output as
+  // it is served or exported. `.next` was listed and `_next` wasn't, so an
+  // exported bundle walked in as first-party source: minified chunks, one file
+  // per line, hundreds of KB each (#1254).
+  "_next",
+  // Agent scratch space. `.claude/worktrees/` holds a full checkout per agent
+  // session, so walking it re-extracts the whole repo once per worktree — and
+  // pulls in whatever build output those checkouts happen to carry. It is
+  // gitignored in practice, but the file walk doesn't read .gitignore, so the
+  // name has to be listed here.
+  ".claude",
   // Python virtualenv shapes (issue #344). Walking into a venv pulls in the
   // entire CPython stdlib + every installed package as if it were first-party
   // service code — 20k+ files, none of which the user wrote. The shape names
@@ -1212,6 +1223,20 @@ function noteExtractedDropped(edge) {
 function drainDroppedExtracted() {
   return droppedSink.splice(0, droppedSink.length);
 }
+var skippedSink = /* @__PURE__ */ new Map();
+function noteSkippedFile(file) {
+  if (!skippedSink.has(file.path)) skippedSink.set(file.path, file);
+}
+function drainSkippedFiles() {
+  const out = [...skippedSink.values()];
+  skippedSink.clear();
+  return out;
+}
+function formatSkippedBanner(count) {
+  if (count <= 0) return null;
+  if (count === 1) return `[neat] 1 minified file read but not parsed (FileNode kept, no symbols or calls)`;
+  return `[neat] ${count} minified files read but not parsed (FileNodes kept, no symbols or calls)`;
+}
 function isRejectedLogEnabled() {
   const raw = process.env.NEAT_EXTRACTED_REJECTED_LOG;
   return raw === "1" || raw === "true";
@@ -1228,8 +1253,8 @@ function formatPrecisionFloorBanner(count) {
 }
 // src/extract/calls/shared.ts
-import { promises as fs5 } from "fs";
-import path5 from "path";
+import { promises as fs6 } from "fs";
+import path6 from "path";
 import {
   EdgeType as EdgeType2,
   NodeType as NodeType2,
@@ -1238,11 +1263,87 @@ import {
   extractedEdgeId as extractedEdgeId2,
   fileId
 } from "@neat.is/types";
+// src/extract/gitignore.ts
+import { promises as fs5 } from "fs";
+import path5 from "path";
+import ignore from "ignore";
+var LAYER_CACHE = /* @__PURE__ */ new Map();
+async function layerFor(dir) {
+  const cached = LAYER_CACHE.get(dir);
+  if (cached !== void 0) return cached;
+  let layer = null;
+  try {
+    const raw = await fs5.readFile(path5.join(dir, ".gitignore"), "utf8");
+    layer = { dir, ig: ignore().add(raw) };
+  } catch {
+    layer = null;
+  }
+  LAYER_CACHE.set(dir, layer);
+  return layer;
+}
+async function isRepoRoot(dir) {
+  try {
+    await fs5.stat(path5.join(dir, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadIgnoreChain(startDir) {
+  const dirs = [];
+  let current = path5.resolve(startDir);
+  for (; ; ) {
+    dirs.push(current);
+    if (await isRepoRoot(current)) break;
+    const parent = path5.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  dirs.reverse();
+  const layers = [];
+  for (const dir of dirs) {
+    const layer = await layerFor(dir);
+    if (layer) layers.push(layer);
+  }
+  return layers;
+}
+async function extendIgnoreChain(chain, dir) {
+  const layer = await layerFor(path5.resolve(dir));
+  return layer ? [...chain, layer] : chain;
+}
+function isIgnored(chain, fullPath, isDir) {
+  return decide(chain, fullPath, isDir).ignored;
+}
+function decide(chain, fullPath, isDir) {
+  if (chain.length === 0) return { ignored: false, subtree: chain };
+  const abs = path5.resolve(fullPath);
+  let ignored = false;
+  let unignoredAt = -1;
+  for (let i = 0; i < chain.length; i++) {
+    const layer = chain[i];
+    const rel = path5.relative(layer.dir, abs);
+    if (!rel || rel.startsWith("..") || path5.isAbsolute(rel)) continue;
+    const candidate = rel.split(path5.sep).join("/") + (isDir ? "/" : "");
+    const result = layer.ig.test(candidate);
+    if (result.ignored) ignored = true;
+    else if (result.unignored) {
+      ignored = false;
+      unignoredAt = i;
+    }
+  }
+  return {
+    ignored,
+    subtree: unignoredAt >= 0 ? chain.slice(unignoredAt) : chain
+  };
+}
+// src/extract/calls/shared.ts
 function buildServiceHostIndex(services) {
   const knownHosts = /* @__PURE__ */ new Set();
   const hostToNodeId = /* @__PURE__ */ new Map();
   for (const service of services) {
-    const base = path5.basename(service.dir);
+    const base = path6.basename(service.dir);
     knownHosts.add(base);
     knownHosts.add(service.pkg.name);
     hostToNodeId.set(base, service.node.id);
@@ -1251,33 +1352,62 @@ function buildServiceHostIndex(services) {
   return { knownHosts, hostToNodeId };
 }
 async function walkSourceFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => path5.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => path6.resolve(d)));
   const out = [];
-  async function walk11(current) {
-    const entries = await fs5.readdir(current, { withFileTypes: true }).catch(() => []);
+  const rootChain = await loadIgnoreChain(dir);
+  async function walk11(current, inherited) {
+    const entries = await fs6.readdir(current, { withFileTypes: true }).catch(() => []);
+    const chain = entries.some((e) => e.isFile() && e.name === ".gitignore") ? await extendIgnoreChain(inherited, current) : inherited;
     for (const entry of entries) {
-      const full = path5.join(current, entry.name);
+      const full = path6.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(path5.resolve(full))) continue;
+        if (excluded.has(path6.resolve(full))) continue;
+        const verdict = decide(chain, full, true);
+        if (verdict.ignored) continue;
         if (await isPythonVenvDir(full)) continue;
-        await walk11(full);
-      } else if (entry.isFile() && SERVICE_FILE_EXTENSIONS.has(path5.extname(entry.name)) && // Skip NEAT's own generated `otel-init.*` bootstrap — extracting it
+        await walk11(full, verdict.subtree);
+      } else if (entry.isFile() && SERVICE_FILE_EXTENSIONS.has(path6.extname(entry.name)) && // Skip NEAT's own generated `otel-init.*` bootstrap — extracting it
       // would attribute our instrumentation imports to the user's service.
-      !isNeatAuthoredSourceFile(entry.name)) {
+      !isNeatAuthoredSourceFile(entry.name) && !isIgnored(chain, full, false)) {
         out.push(full);
       }
     }
   }
-  await walk11(dir);
+  await walk11(dir, rootChain.filter((l) => path6.resolve(l.dir) !== path6.resolve(dir)));
   return out;
 }
+var MINIFIED_LINE_CHARS = 5e3;
+function hasMinifiedName(filePath) {
+  return /\.min\.(js|mjs|cjs|jsx|ts|tsx)$/i.test(filePath);
+}
+function isMinifiedSource(filePath, content) {
+  if (hasMinifiedName(filePath)) return { minified: true, detail: "named *.min.js" };
+  let longest = 0;
+  let start = 0;
+  for (; ; ) {
+    const nl = content.indexOf("\n", start);
+    const len = (nl === -1 ? content.length : nl) - start;
+    if (len > longest) longest = len;
+    if (nl === -1) break;
+    start = nl + 1;
+  }
+  if (longest > MINIFIED_LINE_CHARS) {
+    return { minified: true, detail: `longest line ${longest} chars` };
+  }
+  return { minified: false, detail: "" };
+}
 async function loadSourceFiles(dir, excludeDirs = []) {
   const paths = await walkSourceFiles(dir, excludeDirs);
   const out = [];
   for (const p of paths) {
     try {
-      const content = await fs5.readFile(p, "utf8");
+      const content = await fs6.readFile(p, "utf8");
+      const verdict = isMinifiedSource(p, content);
+      if (verdict.minified) {
+        noteSkippedFile({ path: p, reason: "minified", detail: verdict.detail });
+        continue;
+      }
       out.push({ path: p, content });
     } catch {
     }
@@ -1289,15 +1419,18 @@ function lineOf(text, needle) {
   if (idx < 0) return 1;
   return text.slice(0, idx).split("\n").length;
 }
+var SNIPPET_MAX_CHARS = 120;
 function snippet(text, line) {
   const lines = text.split("\n");
-  return (lines[line - 1] ?? "").trim();
+  const raw = (lines[line - 1] ?? "").trim();
+  if (raw.length <= SNIPPET_MAX_CHARS) return raw;
+  return `${raw.slice(0, SNIPPET_MAX_CHARS)}\u2026 (+${raw.length - SNIPPET_MAX_CHARS} chars)`;
 }
 function toPosix(p) {
   return p.split("\\").join("/");
 }
 function languageForPath(relPath) {
-  switch (path5.extname(relPath).toLowerCase()) {
+  switch (path6.extname(relPath).toLowerCase()) {
     case ".py":
       return "python";
     case ".go":
@@ -1370,8 +1503,8 @@ function ensureFileNode(graph, serviceName, serviceNodeId, relPath) {
 }
 // src/extract/imports.ts
-import path6 from "path";
-import { promises as fs6 } from "fs";
+import path7 from "path";
+import { promises as fs7 } from "fs";
 import Parser from "tree-sitter";
 import JavaScript from "tree-sitter-javascript";
 import Python from "tree-sitter-python";
@@ -1522,15 +1655,15 @@ function collectPyImports(node, out) {
 }
 async function fileExists(p) {
   try {
-    await fs6.access(p);
+    await fs7.access(p);
     return true;
   } catch {
     return false;
   }
 }
 function isWithinServiceDir(candidate, serviceDir) {
-  const rel = path6.relative(serviceDir, candidate);
-  return rel !== "" && !rel.startsWith("..") && !path6.isAbsolute(rel);
+  const rel = path7.relative(serviceDir, candidate);
+  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
 }
 var JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 var JS_INDEX_FILES = JS_EXTENSIONS.map((ext) => `index${ext}`);
@@ -1538,22 +1671,22 @@ async function firstExistingCandidate(base, serviceDir) {
   for (const ext of JS_EXTENSIONS) {
     const candidate = base + ext;
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix(path6.relative(serviceDir, candidate));
+      return toPosix(path7.relative(serviceDir, candidate));
     }
   }
   for (const indexFile of JS_INDEX_FILES) {
-    const candidate = path6.join(base, indexFile);
+    const candidate = path7.join(base, indexFile);
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix(path6.relative(serviceDir, candidate));
+      return toPosix(path7.relative(serviceDir, candidate));
     }
   }
   return null;
 }
 async function loadTsPathConfig(serviceDir) {
-  const tsconfigPath = path6.join(serviceDir, "tsconfig.json");
+  const tsconfigPath = path7.join(serviceDir, "tsconfig.json");
   let raw;
   try {
-    raw = await fs6.readFile(tsconfigPath, "utf8");
+    raw = await fs7.readFile(tsconfigPath, "utf8");
   } catch {
     return null;
   }
@@ -1562,7 +1695,7 @@ async function loadTsPathConfig(serviceDir) {
     const paths = parsed.compilerOptions?.paths;
     if (!paths || Object.keys(paths).length === 0) return null;
     const baseUrl = parsed.compilerOptions?.baseUrl;
-    return { paths, baseDir: baseUrl ? path6.resolve(serviceDir, baseUrl) : serviceDir };
+    return { paths, baseDir: baseUrl ? path7.resolve(serviceDir, baseUrl) : serviceDir };
   } catch (err) {
     recordExtractionError("import alias resolution", tsconfigPath, err);
     return null;
@@ -1580,11 +1713,11 @@ async function resolveTsAlias(specifier, config, serviceDir) {
     if (suffix === null) continue;
     for (const target of targets) {
       const targetBase = target.endsWith("/*") ? target.slice(0, -2) : target.replace(/\*$/, "");
-      const resolvedBase = path6.resolve(config.baseDir, targetBase, suffix);
+      const resolvedBase = path7.resolve(config.baseDir, targetBase, suffix);
       const hit = await firstExistingCandidate(resolvedBase, serviceDir);
       if (hit) return hit;
       if (isWithinServiceDir(resolvedBase, serviceDir) && await fileExists(resolvedBase)) {
-        return toPosix(path6.relative(serviceDir, resolvedBase));
+        return toPosix(path7.relative(serviceDir, resolvedBase));
       }
     }
   }
@@ -1593,18 +1726,18 @@ async function resolveTsAlias(specifier, config, serviceDir) {
 async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
   if (!specifier) return null;
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    const base = path6.resolve(importerDir, specifier);
-    const ext = path6.extname(specifier);
+    const base = path7.resolve(importerDir, specifier);
+    const ext = path7.extname(specifier);
     if (ext) {
       if (ext === ".js" || ext === ".jsx") {
         const tsExt = ext === ".jsx" ? ".tsx" : ".ts";
         const tsSibling = base.slice(0, -ext.length) + tsExt;
         if (isWithinServiceDir(tsSibling, serviceDir) && await fileExists(tsSibling)) {
-          return toPosix(path6.relative(serviceDir, tsSibling));
+          return toPosix(path7.relative(serviceDir, tsSibling));
         }
       }
       if (isWithinServiceDir(base, serviceDir) && await fileExists(base)) {
-        return toPosix(path6.relative(serviceDir, base));
+        return toPosix(path7.relative(serviceDir, base));
       }
       if (!JS_EXTENSIONS.includes(ext)) {
         return firstExistingCandidate(base, serviceDir);
@@ -1619,30 +1752,30 @@ async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
 async function resolvePyImport(imp, importerPath, serviceDir) {
   let baseDir;
   if (imp.level > 0) {
-    baseDir = path6.dirname(importerPath);
-    for (let i = 1; i < imp.level; i++) baseDir = path6.dirname(baseDir);
+    baseDir = path7.dirname(importerPath);
+    for (let i = 1; i < imp.level; i++) baseDir = path7.dirname(baseDir);
   } else {
     baseDir = serviceDir;
   }
-  const moduleBase = imp.modulePath ? path6.join(baseDir, imp.modulePath.split(".").join("/")) : baseDir;
+  const moduleBase = imp.modulePath ? path7.join(baseDir, imp.modulePath.split(".").join("/")) : baseDir;
   const resolved = /* @__PURE__ */ new Set();
   let needModuleFile = imp.names.length === 0;
   for (const name of imp.names) {
-    const submoduleFile = path6.join(moduleBase, `${name}.py`);
-    const subpackageInit = path6.join(moduleBase, name, "__init__.py");
+    const submoduleFile = path7.join(moduleBase, `${name}.py`);
+    const subpackageInit = path7.join(moduleBase, name, "__init__.py");
     if (isWithinServiceDir(submoduleFile, serviceDir) && await fileExists(submoduleFile)) {
-      resolved.add(toPosix(path6.relative(serviceDir, submoduleFile)));
+      resolved.add(toPosix(path7.relative(serviceDir, submoduleFile)));
     } else if (isWithinServiceDir(subpackageInit, serviceDir) && await fileExists(subpackageInit)) {
-      resolved.add(toPosix(path6.relative(serviceDir, subpackageInit)));
+      resolved.add(toPosix(path7.relative(serviceDir, subpackageInit)));
     } else {
       needModuleFile = true;
     }
   }
   if (needModuleFile) {
-    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, path6.join(moduleBase, "__init__.py")] : [path6.join(moduleBase, "__init__.py")];
+    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, path7.join(moduleBase, "__init__.py")] : [path7.join(moduleBase, "__init__.py")];
     for (const candidate of moduleFileCandidates) {
       if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-        resolved.add(toPosix(path6.relative(serviceDir, candidate)));
+        resolved.add(toPosix(path7.relative(serviceDir, candidate)));
         break;
       }
     }
@@ -1652,11 +1785,11 @@ async function resolvePyImport(imp, importerPath, serviceDir) {
 async function resolveGoImport(specifier, modulePath, serviceDir) {
   if (specifier !== modulePath && !specifier.startsWith(`${modulePath}/`)) return null;
   const suffix = specifier === modulePath ? "" : specifier.slice(modulePath.length + 1);
-  const dir = path6.join(serviceDir, suffix);
-  const entries = await fs6.readdir(dir, { withFileTypes: true }).catch(() => []);
-  const candidates = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".go") && !entry.name.endsWith("_test.go")).map((entry) => path6.join(dir, entry.name));
+  const dir = path7.join(serviceDir, suffix);
+  const entries = await fs7.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const candidates = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".go") && !entry.name.endsWith("_test.go")).map((entry) => path7.join(dir, entry.name));
   if (candidates.length !== 1) return null;
-  return toPosix(path6.relative(serviceDir, candidates[0]));
+  return toPosix(path7.relative(serviceDir, candidates[0]));
 }
 function emitImportEdge(graph, serviceName, importerFileId, importerRelPath, importeeRelPath, line, snippet2) {
   const importeeFileId = fileId2(serviceName, importeeRelPath);
@@ -1686,12 +1819,12 @@ async function addImports(graph, services) {
     const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const relFile = toPosix(path6.relative(service.dir, file.path));
+      const relFile = toPosix(path7.relative(service.dir, file.path));
       const importerFileId = fileId2(service.pkg.name, relFile);
-      const isPython = path6.extname(file.path) === ".py";
-      const isGo = path6.extname(file.path) === ".go";
-      if (path6.extname(file.path) === ".rb") continue;
-      if (path6.extname(file.path) === ".php") continue;
+      const isPython = path7.extname(file.path) === ".py";
+      const isGo = path7.extname(file.path) === ".go";
+      if (path7.extname(file.path) === ".rb") continue;
+      if (path7.extname(file.path) === ".php") continue;
       if (isGo) {
         let goImports = [];
         try {
@@ -1701,7 +1834,7 @@ async function addImports(graph, services) {
           recordExtractionError("import extraction", file.path, err);
           continue;
         }
-        const goMod = await fs6.readFile(path6.join(service.dir, "go.mod"), "utf8").catch(() => "");
+        const goMod = await fs7.readFile(path7.join(service.dir, "go.mod"), "utf8").catch(() => "");
         const modulePath = goMod.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
         if (!modulePath) continue;
         for (const imp of goImports) {
@@ -1745,7 +1878,7 @@ async function addImports(graph, services) {
         continue;
       }
       for (const imp of jsImports) {
-        const resolved = await resolveJsImport(imp.specifier, path6.dirname(file.path), service.dir, tsPaths);
+        const resolved = await resolveJsImport(imp.specifier, path7.dirname(file.path), service.dir, tsPaths);
         if (!resolved) continue;
         edgesAdded += emitImportEdge(
           graph,
@@ -1870,8 +2003,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path73) {
-  return path73.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path74) {
+  return path74.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -2211,7 +2344,7 @@ function isNextPagesApiFile(relFile) {
   if (pagesIdx === -1 || segs[pagesIdx + 1] !== "api") return false;
   const base = segs[segs.length - 1] ?? "";
   if (/^_(app|document|middleware)\./.test(base)) return false;
-  return JS_ROUTE_EXTENSIONS.has(path7.extname(base));
+  return JS_ROUTE_EXTENSIONS.has(path8.extname(base));
 }
 function nextSegment(seg) {
   if (seg.startsWith("(") && seg.endsWith(")")) return null;
@@ -2543,9 +2676,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path73 = rubyLiteral(k);
-    if (path73 === null) continue;
-    return { path: path73, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path74 = rubyLiteral(k);
+    if (path74 === null) continue;
+    return { path: path74, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -3393,12 +3526,12 @@ async function expressMountPrefixes(files, serviceDir, tsPaths) {
   const jsParser = makeJsParser2();
   const fileInfo = /* @__PURE__ */ new Map();
   for (const f of files) {
-    if (!JS_ROUTE_EXTENSIONS.has(path7.extname(f.path))) continue;
+    if (!JS_ROUTE_EXTENSIONS.has(path8.extname(f.path))) continue;
     if (isTestPath(f.path)) continue;
-    const rel = toPosix(path7.relative(serviceDir, f.path));
+    const rel = toPosix(path8.relative(serviceDir, f.path));
     try {
       const tree = parseSource2(jsParser, f.content);
-      fileInfo.set(rel, analyzeExpressFile(tree.rootNode, path7.dirname(f.path)));
+      fileInfo.set(rel, analyzeExpressFile(tree.rootNode, path8.dirname(f.path)));
     } catch {
     }
   }
@@ -3497,14 +3630,14 @@ async function addRoutes(graph, services) {
     const mountPrefixes = hasExpress ? await expressMountPrefixes(files, service.dir, await loadTsPathConfig(service.dir)) : /* @__PURE__ */ new Map();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const ext = path7.extname(file.path);
+      const ext = path8.extname(file.path);
       const isPy = ext === ".py";
       const isGo = ext === ".go";
       const isRb = ext === ".rb";
       const isPhp = ext === ".php";
       const isRs = ext === ".rs";
       if (!JS_ROUTE_EXTENSIONS.has(ext) && !isPy && !isGo && !isRb && !isPhp && !isRs) continue;
-      const relFile = toPosix(path7.relative(service.dir, file.path));
+      const relFile = toPosix(path8.relative(service.dir, file.path));
       let routes;
       try {
         if (isPhp) {
@@ -4009,7 +4142,7 @@ function languageForExt(relPath) {
 function relPathForRuntimeFile(filepath, serviceNode, scanPath) {
   let p = toPosix2(filepath).replace(/^file:\/\//, "");
   if (scanPath && scanPath.length > 0) {
-    const absRoot = toPosix2(path8.resolve(scanPath, serviceNode?.repoPath ?? ""));
+    const absRoot = toPosix2(path9.resolve(scanPath, serviceNode?.repoPath ?? ""));
     const anchor = absRoot.endsWith("/") ? absRoot : `${absRoot}/`;
     if (p.startsWith(anchor)) return p.slice(anchor.length);
   }
@@ -4040,7 +4173,7 @@ function resolveDistToSrc(absFilepath, line) {
       if (existsSync(mapPath)) {
         const raw = JSON.parse(readFileSync(mapPath, "utf8"));
         const consumer = new sourceMapJs.SourceMapConsumer(raw);
-        entry = { consumer, dir: path8.dirname(mapPath) };
+        entry = { consumer, dir: path9.dirname(mapPath) };
       }
     } catch {
       entry = null;
@@ -4060,7 +4193,7 @@ function resolveDistToSrc(absFilepath, line) {
     }
     if (!pos || !pos.source) return null;
     const root = entry.consumer.sourceRoot ?? "";
-    const resolved = path8.resolve(entry.dir, root, pos.source);
+    const resolved = path9.resolve(entry.dir, root, pos.source);
     return { filepath: resolved, ...pos.line ? { line: pos.line } : {} };
   } catch {
     return null;
@@ -4604,8 +4737,8 @@ function emitIncidentEvent(project, ev) {
   });
 }
 async function appendErrorEvent(ctx, ev) {
-  await fs7.mkdir(path8.dirname(ctx.errorsPath), { recursive: true });
-  await fs7.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  await fs8.mkdir(path9.dirname(ctx.errorsPath), { recursive: true });
+  await fs8.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
   emitIncidentEvent(ctx.project ?? DEFAULT_PROJECT, ev);
 }
 async function appendConnectorIncident(errorsPath, input, project) {
@@ -4620,8 +4753,8 @@ async function appendConnectorIncident(errorsPath, input, project) {
     ...input.attributes && Object.keys(input.attributes).length > 0 ? { attributes: input.attributes } : {},
     affectedNode: input.affectedNode
   };
-  await fs7.mkdir(path8.dirname(errorsPath), { recursive: true });
-  await fs7.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  await fs8.mkdir(path9.dirname(errorsPath), { recursive: true });
+  await fs8.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
   if (project) emitIncidentEvent(project, ev);
 }
 function landIncidentCallSite(span, callSite, trusted, graph) {
@@ -4743,8 +4876,8 @@ function makeErrorSpanWriter(errorsPath, graph, scanPath, project = DEFAULT_PROJ
   return async (span) => {
     const ev = buildErrorEventForReceiver(span, graph, scanPath);
     if (!ev) return;
-    await fs7.mkdir(path8.dirname(errorsPath), { recursive: true });
-    await fs7.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+    await fs8.mkdir(path9.dirname(errorsPath), { recursive: true });
+    await fs8.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
     emitIncidentEvent(project, ev);
   };
 }
@@ -5247,13 +5380,13 @@ async function markStaleEdges(graph, options = {}) {
   return { count: events.length, events };
 }
 async function appendStaleEvents(staleEventsPath, events) {
-  await fs7.mkdir(path8.dirname(staleEventsPath), { recursive: true });
+  await fs8.mkdir(path9.dirname(staleEventsPath), { recursive: true });
   const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await fs7.appendFile(staleEventsPath, lines, "utf8");
+  await fs8.appendFile(staleEventsPath, lines, "utf8");
 }
 async function readStaleEvents(staleEventsPath) {
   try {
-    const raw = await fs7.readFile(staleEventsPath, "utf8");
+    const raw = await fs8.readFile(staleEventsPath, "utf8");
     return raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
   } catch (err) {
     if (err.code === "ENOENT") return [];
@@ -5289,7 +5422,7 @@ function startStalenessLoop(graph, options = {}) {
 var INCIDENT_READ_MAX_BYTES = 32 * 1024 * 1024;
 var INCIDENT_READ_MAX_EVENTS = 5e3;
 async function readErrorFileTail(errorsPath, maxBytes) {
-  const handle = await fs7.open(errorsPath, "r");
+  const handle = await fs8.open(errorsPath, "r");
   try {
     const { size } = await handle.stat();
     if (size <= maxBytes) {
@@ -5546,19 +5679,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, path73, edges) {
-    if (path73.length > best.path.length) {
-      best = { path: [...path73], edges: [...edges] };
+  function step(node, path74, edges) {
+    if (path74.length > best.path.length) {
+      best = { path: [...path74], edges: [...edges] };
     }
-    if (path73.length - 1 >= maxDepth) return;
+    if (path74.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);
-      path73.push(srcId);
+      path74.push(srcId);
       edges.push(edge);
-      step(srcId, path73, edges);
-      path73.pop();
+      step(srcId, path74, edges);
+      path74.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -5773,20 +5906,20 @@ function dominantFailingCall(graph, serviceId17, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path73 = [originServiceId];
+  const path74 = [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;
-    path73.push(hop.nextService);
+    path74.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path73, edges, culprit: current };
+  return { path: path74, edges, culprit: current };
 }
 function isStaleCallEdge(e) {
   return e.type === EdgeType6.CALLS && e.provenance === Provenance6.STALE;
@@ -5822,26 +5955,26 @@ function dominantStaleCall(graph, serviceId17, visited) {
   return best;
 }
 function followStaleCallChain(graph, originServiceId, maxDepth) {
-  const path73 = [originServiceId];
+  const path74 = [originServiceId];
   const edges = [];
   const visited = /* @__PURE__ */ new Set([originServiceId]);
   let current = originServiceId;
   for (let depth = 0; depth < maxDepth; depth++) {
     const hop = dominantStaleCall(graph, current, visited);
     if (!hop) break;
-    path73.push(hop.nextService);
+    path74.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path73, edges, culprit: current };
+  return { path: path74, 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 path73 = [...chain.path];
+  const path74 = [...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));
@@ -5849,14 +5982,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path73.push(loc.fileNode);
+      path74.push(loc.fileNode);
       edgeProvenances.push(Provenance6.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path73,
+      traversalPath: path74,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -5868,7 +6001,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: path73,
+    traversalPath: path74,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -6521,10 +6654,10 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
     traversalPath = staleChain.path;
     edgeProvenances = staleChain.edges.map((e) => e.provenance);
   } else if (top.node !== seedNode) {
-    const path73 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
-    if (path73) {
-      traversalPath = path73.nodes;
-      edgeProvenances = path73.edges.map((e) => e.provenance);
+    const path74 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path74) {
+      traversalPath = path74.nodes;
+      edgeProvenances = path74.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
       edgeProvenances = [top.provenance ?? Provenance6.OBSERVED];
@@ -6559,15 +6692,15 @@ function fixRecommendationForTop(top, seedNode, legacy) {
 }
 // src/extract/services.ts
-import { promises as fs18 } from "fs";
-import path20 from "path";
-import ignore from "ignore";
+import { promises as fs19 } from "fs";
+import path21 from "path";
+import ignore2 from "ignore";
 import { minimatch as minimatch2 } from "minimatch";
 import { NodeType as NodeType15, serviceId as serviceId11 } from "@neat.is/types";
 // src/extract/python.ts
-import { promises as fs8 } from "fs";
-import path9 from "path";
+import { promises as fs9 } from "fs";
+import path10 from "path";
 import { parse as parseToml } from "smol-toml";
 var REQUIREMENT_LINE = /^\s*([A-Za-z0-9_.-]+)(?:\[[^\]]*\])?\s*(?:(==)\s*([A-Za-z0-9_.+-]+))?/;
 function parseRequirementsTxt(content) {
@@ -6600,25 +6733,25 @@ function depsFromPyProject(pyproject) {
   return out;
 }
 async function discoverPythonService(serviceDir) {
-  const pyprojectPath = path9.join(serviceDir, "pyproject.toml");
-  const requirementsPath = path9.join(serviceDir, "requirements.txt");
-  const setupPath = path9.join(serviceDir, "setup.py");
+  const pyprojectPath = path10.join(serviceDir, "pyproject.toml");
+  const requirementsPath = path10.join(serviceDir, "requirements.txt");
+  const setupPath = path10.join(serviceDir, "setup.py");
   const hasPyproject = await exists(pyprojectPath);
   const hasRequirements = await exists(requirementsPath);
   const hasSetup = await exists(setupPath);
   if (!hasPyproject && !hasRequirements && !hasSetup) return null;
-  let name = path9.basename(serviceDir);
+  let name = path10.basename(serviceDir);
   let version;
   const dependencies = {};
   if (hasPyproject) {
-    const raw = await fs8.readFile(pyprojectPath, "utf8");
+    const raw = await fs9.readFile(pyprojectPath, "utf8");
     const pyproject = parseToml(raw);
     name = pyproject.project?.name ?? pyproject.tool?.poetry?.name ?? name;
     version = pyproject.project?.version ?? pyproject.tool?.poetry?.version ?? void 0;
     Object.assign(dependencies, depsFromPyProject(pyproject));
   }
   if (hasRequirements) {
-    const raw = await fs8.readFile(requirementsPath, "utf8");
+    const raw = await fs9.readFile(requirementsPath, "utf8");
     Object.assign(dependencies, parseRequirementsTxt(raw));
   }
   return { name, version, dependencies };
@@ -6632,8 +6765,8 @@ function pythonToPackage(service) {
 }
 // src/extract/go.ts
-import { promises as fs9 } from "fs";
-import path10 from "path";
+import { promises as fs10 } from "fs";
+import path11 from "path";
 import { NodeType as NodeType6, serviceId as serviceId2 } from "@neat.is/types";
 function parseGoMod(source) {
   const module = source.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
@@ -6660,7 +6793,7 @@ function goFramework(deps) {
 async function discoverGoService(scanPath, dir) {
   let raw;
   try {
-    raw = await fs9.readFile(path10.join(dir, "go.mod"), "utf8");
+    raw = await fs10.readFile(path11.join(dir, "go.mod"), "utf8");
   } catch {
     return null;
   }
@@ -6675,15 +6808,15 @@ async function discoverGoService(scanPath, dir) {
     name,
     language: "go",
     dependencies: mod.dependencies,
-    repoPath: path10.relative(scanPath, dir),
+    repoPath: path11.relative(scanPath, dir),
     ...framework ? { framework } : {}
   };
   return { pkg, dir, node };
 }
 // src/extract/ruby.ts
-import { promises as fs10 } from "fs";
-import path11 from "path";
+import { promises as fs11 } from "fs";
+import path12 from "path";
 import { NodeType as NodeType7, serviceId as serviceId3 } from "@neat.is/types";
 function parseGemfile(source) {
   const dependencies = {};
@@ -6700,12 +6833,12 @@ function parseGemfile(source) {
 async function discoverRubyService(scanPath, dir) {
   let raw;
   try {
-    raw = await fs10.readFile(path11.join(dir, "Gemfile"), "utf8");
+    raw = await fs11.readFile(path12.join(dir, "Gemfile"), "utf8");
   } catch {
     return null;
   }
   const gemfile = parseGemfile(raw);
-  const name = path11.basename(dir);
+  const name = path12.basename(dir);
   const pkg = { name, dependencies: gemfile.dependencies };
   const node = {
     id: serviceId3(name),
@@ -6713,14 +6846,14 @@ async function discoverRubyService(scanPath, dir) {
     name,
     language: "ruby",
     dependencies: gemfile.dependencies,
-    repoPath: path11.relative(scanPath, dir),
+    repoPath: path12.relative(scanPath, dir),
     ...gemfile.dependencies["rails"] !== void 0 ? { framework: "rails" } : {}
   };
   return { pkg, dir, node };
 }
 // src/extract/php.ts
-import path12 from "path";
+import path13 from "path";
 import { NodeType as NodeType8, serviceId as serviceId4 } from "@neat.is/types";
 function parseComposerJson(composer) {
   return {
@@ -6733,12 +6866,12 @@ function parseComposerJson(composer) {
 async function discoverPhpService(scanPath, dir) {
   let composer;
   try {
-    composer = await readJson(path12.join(dir, "composer.json"));
+    composer = await readJson(path13.join(dir, "composer.json"));
   } catch {
     return null;
   }
   const { dependencies } = parseComposerJson(composer);
-  const name = path12.basename(dir);
+  const name = path13.basename(dir);
   const pkg = { name, dependencies };
   const node = {
     id: serviceId4(name),
@@ -6746,30 +6879,30 @@ async function discoverPhpService(scanPath, dir) {
     name,
     language: "php",
     dependencies,
-    repoPath: path12.relative(scanPath, dir),
+    repoPath: path13.relative(scanPath, dir),
     ...dependencies["laravel/framework"] !== void 0 ? { framework: "laravel" } : {}
   };
   return { pkg, dir, node };
 }
 // src/extract/csharp.ts
-import { promises as fs11 } from "fs";
-import path13 from "path";
+import { promises as fs12 } from "fs";
+import path14 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 entries = await fs12.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);
+    if (CSHARP_PROJECT_EXTS.has(path14.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);
+  const nested = path14.join(dir, NESTED_PROJECT_DIR);
   if ((await projectFiles(nested)).length > 0) return nested;
   return null;
 }
@@ -6794,10 +6927,10 @@ async function discoverCsharpService(scanPath, 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);
+  const name = csproj ? path14.basename(csproj, path14.extname(csproj)) : path14.basename(dir);
   let dependencies = {};
   if (csproj) {
-    const raw = await fs11.readFile(path13.join(projectDir, csproj), "utf8").catch(() => "");
+    const raw = await fs12.readFile(path14.join(projectDir, csproj), "utf8").catch(() => "");
     dependencies = parseCsproj(raw).dependencies;
   }
   const pkg = { name, dependencies };
@@ -6809,19 +6942,19 @@ async function discoverCsharpService(scanPath, dir) {
     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)
+    repoPath: path14.relative(scanPath, projectDir)
   };
   return { pkg, dir: projectDir, node };
 }
 // src/extract/java.ts
-import { promises as fs12 } from "fs";
-import path14 from "path";
+import { promises as fs13 } from "fs";
+import path15 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;
+    if (await exists(path15.join(dir, manifest))) return true;
   }
   return false;
 }
@@ -6856,19 +6989,19 @@ function parseGradle(source) {
   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");
+  const pomPath = path15.join(dir, "pom.xml");
+  const gradlePath = path15.join(dir, "build.gradle");
+  const gradleKtsPath = path15.join(dir, "build.gradle.kts");
   let manifest = null;
   if (await exists(pomPath)) {
-    manifest = parsePomXml(await fs12.readFile(pomPath, "utf8").catch(() => ""));
+    manifest = parsePomXml(await fs13.readFile(pomPath, "utf8").catch(() => ""));
   } else if (await exists(gradlePath)) {
-    manifest = parseGradle(await fs12.readFile(gradlePath, "utf8").catch(() => ""));
+    manifest = parseGradle(await fs13.readFile(gradlePath, "utf8").catch(() => ""));
   } else if (await exists(gradleKtsPath)) {
-    manifest = parseGradle(await fs12.readFile(gradleKtsPath, "utf8").catch(() => ""));
+    manifest = parseGradle(await fs13.readFile(gradleKtsPath, "utf8").catch(() => ""));
   }
   if (!manifest) return null;
-  const name = manifest.name?.trim() || path14.basename(dir);
+  const name = manifest.name?.trim() || path15.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -6877,14 +7010,14 @@ async function discoverJavaService(scanPath, dir) {
     name,
     language: "java",
     dependencies,
-    repoPath: path14.relative(scanPath, dir)
+    repoPath: path15.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 // src/extract/kotlin.ts
-import { promises as fs13 } from "fs";
-import path15 from "path";
+import { promises as fs14 } from "fs";
+import path16 from "path";
 import { NodeType as NodeType11, serviceId as serviceId7 } from "@neat.is/types";
 var KOTLIN_SOURCE_EXT = ".kt";
 var JAVA_SOURCE_EXT = ".java";
@@ -6894,15 +7027,15 @@ async function dominantJvmSourceLanguage(dir) {
   let java = 0;
   async function recurse(current, depth) {
     if (depth > SOURCE_PROBE_MAX_DEPTH) return;
-    const entries = await fs13.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await fs14.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        await recurse(path15.join(current, entry.name), depth + 1);
+        await recurse(path16.join(current, entry.name), depth + 1);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path15.extname(entry.name).toLowerCase();
+      const ext = path16.extname(entry.name).toLowerCase();
       if (ext === KOTLIN_SOURCE_EXT) kt++;
       else if (ext === JAVA_SOURCE_EXT) java++;
     }
@@ -6913,17 +7046,17 @@ async function dominantJvmSourceLanguage(dir) {
   return void 0;
 }
 async function readJvmManifest(dir) {
-  const pomPath = path15.join(dir, JAVA_MANIFESTS[0]);
-  const gradlePath = path15.join(dir, JAVA_MANIFESTS[1]);
-  const gradleKtsPath = path15.join(dir, JAVA_MANIFESTS[2]);
+  const pomPath = path16.join(dir, JAVA_MANIFESTS[0]);
+  const gradlePath = path16.join(dir, JAVA_MANIFESTS[1]);
+  const gradleKtsPath = path16.join(dir, JAVA_MANIFESTS[2]);
   if (await exists(pomPath)) {
-    return parsePomXml(await fs13.readFile(pomPath, "utf8").catch(() => ""));
+    return parsePomXml(await fs14.readFile(pomPath, "utf8").catch(() => ""));
   }
   if (await exists(gradlePath)) {
-    return parseGradle(await fs13.readFile(gradlePath, "utf8").catch(() => ""));
+    return parseGradle(await fs14.readFile(gradlePath, "utf8").catch(() => ""));
   }
   if (await exists(gradleKtsPath)) {
-    return parseGradle(await fs13.readFile(gradleKtsPath, "utf8").catch(() => ""));
+    return parseGradle(await fs14.readFile(gradleKtsPath, "utf8").catch(() => ""));
   }
   return null;
 }
@@ -6932,7 +7065,7 @@ async function discoverKotlinService(scanPath, dir) {
   if (await dominantJvmSourceLanguage(dir) !== "kotlin") return null;
   const manifest = await readJvmManifest(dir);
   if (!manifest) return null;
-  const name = manifest.name?.trim() || path15.basename(dir);
+  const name = manifest.name?.trim() || path16.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -6941,19 +7074,19 @@ async function discoverKotlinService(scanPath, dir) {
     name,
     language: "kotlin",
     dependencies,
-    repoPath: path15.relative(scanPath, dir)
+    repoPath: path16.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 // src/extract/rust.ts
-import { promises as fs14 } from "fs";
-import path16 from "path";
+import { promises as fs15 } from "fs";
+import path17 from "path";
 import { parse as parseToml2 } from "smol-toml";
 import { NodeType as NodeType12, serviceId as serviceId8 } from "@neat.is/types";
 var CARGO_MANIFEST = "Cargo.toml";
 async function hasRustManifest(dir) {
-  return exists(path16.join(dir, CARGO_MANIFEST));
+  return exists(path17.join(dir, CARGO_MANIFEST));
 }
 function parseCargoToml(source) {
   const dependencies = {};
@@ -6978,10 +7111,10 @@ function parseCargoToml(source) {
   return { name, dependencies };
 }
 async function discoverRustService(scanPath, dir) {
-  const cargoPath = path16.join(dir, CARGO_MANIFEST);
+  const cargoPath = path17.join(dir, CARGO_MANIFEST);
   if (!await exists(cargoPath)) return null;
-  const manifest = parseCargoToml(await fs14.readFile(cargoPath, "utf8").catch(() => ""));
-  const name = manifest.name?.trim() || path16.basename(dir);
+  const manifest = parseCargoToml(await fs15.readFile(cargoPath, "utf8").catch(() => ""));
+  const name = manifest.name?.trim() || path17.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -6990,18 +7123,18 @@ async function discoverRustService(scanPath, dir) {
     name,
     language: "rust",
     dependencies,
-    repoPath: path16.relative(scanPath, dir)
+    repoPath: path17.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 // src/extract/cpp.ts
-import { promises as fs15 } from "fs";
-import path17 from "path";
+import { promises as fs16 } from "fs";
+import path18 from "path";
 import { NodeType as NodeType13, serviceId as serviceId9 } from "@neat.is/types";
 var CMAKE_MANIFEST = "CMakeLists.txt";
 async function hasCppManifest(dir) {
-  return exists(path17.join(dir, CMAKE_MANIFEST));
+  return exists(path18.join(dir, CMAKE_MANIFEST));
 }
 function parseCMakeProjectName(source) {
   const withoutComments = source.replace(/#.*$/gm, "");
@@ -7009,10 +7142,10 @@ function parseCMakeProjectName(source) {
   return m?.[1];
 }
 async function discoverCppService(scanPath, dir) {
-  const cmakePath = path17.join(dir, CMAKE_MANIFEST);
+  const cmakePath = path18.join(dir, CMAKE_MANIFEST);
   if (!await exists(cmakePath)) return null;
-  const source = await fs15.readFile(cmakePath, "utf8").catch(() => "");
-  const name = parseCMakeProjectName(source)?.trim() || path17.basename(dir);
+  const source = await fs16.readFile(cmakePath, "utf8").catch(() => "");
+  const name = parseCMakeProjectName(source)?.trim() || path18.basename(dir);
   const dependencies = {};
   const pkg = { name, dependencies };
   const node = {
@@ -7021,14 +7154,14 @@ async function discoverCppService(scanPath, dir) {
     name,
     language: "cpp",
     dependencies,
-    repoPath: path17.relative(scanPath, dir)
+    repoPath: path18.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 // src/extract/dockerfile-service.ts
-import { promises as fs16 } from "fs";
-import path18 from "path";
+import { promises as fs17 } from "fs";
+import path19 from "path";
 import { NodeType as NodeType14, serviceId as serviceId10 } from "@neat.is/types";
 function languageForSourceExt(ext) {
   switch (ext) {
@@ -7070,12 +7203,12 @@ function languageForSourceExt(ext) {
 }
 var LANGUAGE_PRECEDENCE = ["typescript", "javascript", "python", "go", "ruby", "php", "csharp", "java", "kotlin", "rust", "cpp"];
 async function inferServiceLanguage(dir) {
-  const entries = await fs16.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs17.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 = path18.extname(entry.name).toLowerCase();
+    const ext = path19.extname(entry.name).toLowerCase();
     if (!SERVICE_FILE_EXTENSIONS.has(ext)) continue;
     const lang = languageForSourceExt(ext);
     if (!lang) continue;
@@ -7094,7 +7227,7 @@ async function inferServiceLanguage(dir) {
   return best;
 }
 async function hasLanguageManifest(dir) {
-  return await exists(path18.join(dir, "package.json")) || await exists(path18.join(dir, "pyproject.toml")) || await exists(path18.join(dir, "requirements.txt")) || await exists(path18.join(dir, "setup.py")) || await exists(path18.join(dir, "go.mod")) || await exists(path18.join(dir, "Gemfile")) || await exists(path18.join(dir, "composer.json")) || // C#'s marker is a glob (`*.csproj` / `*.sln`), so it reads the directory
+  return await exists(path19.join(dir, "package.json")) || await exists(path19.join(dir, "pyproject.toml")) || await exists(path19.join(dir, "requirements.txt")) || await exists(path19.join(dir, "setup.py")) || await exists(path19.join(dir, "go.mod")) || await exists(path19.join(dir, "Gemfile")) || await exists(path19.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 (and its JVM sibling Kotlin, ADR-199) key on the same Maven / Gradle
   // build manifest (ADR-197), so this one check stands the Dockerfile fallback
@@ -7104,15 +7237,15 @@ async function hasLanguageManifest(dir) {
   await hasCppManifest(dir);
 }
 async function hasDockerfileDeclaredService(dir) {
-  if (!await exists(path18.join(dir, "Dockerfile"))) return false;
+  if (!await exists(path19.join(dir, "Dockerfile"))) return false;
   return await inferServiceLanguage(dir) !== null;
 }
 async function discoverDockerfileService(scanPath, dir) {
-  if (!await exists(path18.join(dir, "Dockerfile"))) return null;
+  if (!await exists(path19.join(dir, "Dockerfile"))) return null;
   if (await hasLanguageManifest(dir)) return null;
   const language = await inferServiceLanguage(dir);
   if (!language) return null;
-  const name = path18.basename(dir);
+  const name = path19.basename(dir);
   const pkg = { name, dependencies: {} };
   const node = {
     id: serviceId10(name),
@@ -7120,23 +7253,23 @@ async function discoverDockerfileService(scanPath, dir) {
     name,
     language,
     dependencies: {},
-    repoPath: path18.relative(scanPath, dir)
+    repoPath: path19.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 // src/extract/owners.ts
-import { promises as fs17 } from "fs";
-import path19 from "path";
+import { promises as fs18 } from "fs";
+import path20 from "path";
 import { minimatch } from "minimatch";
 async function loadCodeowners(scanPath) {
   const candidates = [
-    path19.join(scanPath, "CODEOWNERS"),
-    path19.join(scanPath, ".github", "CODEOWNERS")
+    path20.join(scanPath, "CODEOWNERS"),
+    path20.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists(file)) {
-      const raw = await fs17.readFile(file, "utf8");
+      const raw = await fs18.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -7154,7 +7287,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(path19.sep).join("/");
+  const normalized = repoPath.split(path20.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -7170,7 +7303,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = path19.join(serviceDir, "package.json");
+  const pkgPath = path20.join(serviceDir, "package.json");
   if (!await exists(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -7207,36 +7340,36 @@ function workspaceGlobs(pkg) {
   return null;
 }
 async function hasPythonManifest(dir) {
-  return await exists(path20.join(dir, "pyproject.toml")) || await exists(path20.join(dir, "requirements.txt")) || await exists(path20.join(dir, "setup.py"));
+  return await exists(path21.join(dir, "pyproject.toml")) || await exists(path21.join(dir, "requirements.txt")) || await exists(path21.join(dir, "setup.py"));
 }
 async function hasGoManifest(dir) {
-  return exists(path20.join(dir, "go.mod"));
+  return exists(path21.join(dir, "go.mod"));
 }
 async function hasRubyManifest(dir) {
-  return exists(path20.join(dir, "Gemfile"));
+  return exists(path21.join(dir, "Gemfile"));
 }
 async function hasPhpManifest(dir) {
-  return exists(path20.join(dir, "composer.json"));
+  return exists(path21.join(dir, "composer.json"));
 }
 async function hasCsharpManifest(dir) {
   return hasCsharpProject(dir);
 }
 async function loadGitignore(scanPath) {
-  const gitignorePath = path20.join(scanPath, ".gitignore");
+  const gitignorePath = path21.join(scanPath, ".gitignore");
   if (!await exists(gitignorePath)) return null;
-  const raw = await fs18.readFile(gitignorePath, "utf8");
-  return ignore().add(raw);
+  const raw = await fs19.readFile(gitignorePath, "utf8");
+  return ignore2().add(raw);
 }
 async function walkDirs(start, scanPath, options, visit) {
   async function recurse(current, depth) {
     if (depth > options.maxDepth) return;
-    const entries = await fs18.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await fs19.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = path20.join(current, entry.name);
+      const child = path21.join(current, entry.name);
       if (options.ig) {
-        const rel = path20.relative(scanPath, child).split(path20.sep).join("/");
+        const rel = path21.relative(scanPath, child).split(path21.sep).join("/");
         if (rel && options.ig.ignores(rel + "/")) continue;
       }
       if (await isPythonVenvDir(child)) continue;
@@ -7252,8 +7385,8 @@ async function expandWorkspaceGlobs(scanPath, globs) {
   for (const raw of globs) {
     const pattern = raw.replace(/^\.\//, "");
     if (!pattern.includes("*")) {
-      const candidate = path20.join(scanPath, pattern);
-      if (await exists(path20.join(candidate, "package.json"))) found.add(candidate);
+      const candidate = path21.join(scanPath, pattern);
+      if (await exists(path21.join(candidate, "package.json"))) found.add(candidate);
       continue;
     }
     const segments = pattern.split("/");
@@ -7262,13 +7395,13 @@ async function expandWorkspaceGlobs(scanPath, globs) {
       if (seg.includes("*")) break;
       staticSegments.push(seg);
     }
-    const start = path20.join(scanPath, ...staticSegments);
+    const start = path21.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 = path20.relative(scanPath, dir).split(path20.sep).join("/");
-      if (minimatch2(rel, pattern) && await exists(path20.join(dir, "package.json"))) {
+      const rel = path21.relative(scanPath, dir).split(path21.sep).join("/");
+      if (minimatch2(rel, pattern) && await exists(path21.join(dir, "package.json"))) {
         found.add(dir);
       }
     });
@@ -7291,18 +7424,18 @@ function detectJsFramework(pkg) {
 async function detectJsServiceLanguage(dir, pkg) {
   const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   if (deps["typescript"] !== void 0) return "typescript";
-  const entries = await fs18.readdir(dir).catch(() => []);
+  const entries = await fs19.readdir(dir).catch(() => []);
   if (entries.some((name) => /^tsconfig(\..+)?\.json$/.test(name))) return "typescript";
   return "javascript";
 }
 async function discoverNodeService(scanPath, dir) {
-  const pkgPath = path20.join(dir, "package.json");
+  const pkgPath = path21.join(dir, "package.json");
   if (!await exists(pkgPath)) return null;
   let pkg;
   try {
     pkg = await readJson(pkgPath);
   } catch (err) {
-    recordExtractionError("services", path20.relative(scanPath, pkgPath), err);
+    recordExtractionError("services", path21.relative(scanPath, pkgPath), err);
     return null;
   }
   if (!pkg.name) return null;
@@ -7315,7 +7448,7 @@ async function discoverNodeService(scanPath, dir) {
     language,
     version: pkg.version,
     dependencies: pkg.dependencies ?? {},
-    repoPath: path20.relative(scanPath, dir),
+    repoPath: path21.relative(scanPath, dir),
     ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
     ...framework ? { framework } : {}
   };
@@ -7332,12 +7465,12 @@ async function discoverPyService(scanPath, dir) {
     language: "python",
     version: py.version,
     dependencies: py.dependencies,
-    repoPath: path20.relative(scanPath, dir)
+    repoPath: path21.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 async function discoverServices(scanPath) {
-  const rootPkgPath = path20.join(scanPath, "package.json");
+  const rootPkgPath = path21.join(scanPath, "package.json");
   let rootPkg = null;
   if (await exists(rootPkgPath)) {
     try {
@@ -7345,7 +7478,7 @@ async function discoverServices(scanPath) {
     } catch (err) {
       recordExtractionError(
         "services workspaces",
-        path20.relative(scanPath, rootPkgPath),
+        path21.relative(scanPath, rootPkgPath),
         err
       );
     }
@@ -7366,7 +7499,7 @@ async function discoverServices(scanPath) {
       scanPath,
       { maxDepth: parseScanDepth(), ig },
       async (dir) => {
-        if (await exists(path20.join(dir, "package.json"))) {
+        if (await exists(path21.join(dir, "package.json"))) {
           candidateDirs.push(dir);
         } else if (await hasPythonManifest(dir) || await hasGoManifest(dir) || await hasRubyManifest(dir) || await hasPhpManifest(dir) || await hasCsharpManifest(dir) || await hasJavaManifest(dir) || await hasRustManifest(dir) || await hasCppManifest(dir)) {
           candidateDirs.push(dir);
@@ -7394,8 +7527,8 @@ async function discoverServices(scanPath) {
     seenDirs.add(service.dir);
     const existingDir = seen.get(service.node.name);
     if (existingDir !== void 0) {
-      const a = path20.relative(scanPath, existingDir) || ".";
-      const b = path20.relative(scanPath, dir) || ".";
+      const a = path21.relative(scanPath, existingDir) || ".";
+      const b = path21.relative(scanPath, dir) || ".";
       console.warn(
         `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
       );
@@ -7409,14 +7542,14 @@ async function discoverServices(scanPath) {
     const owner = await computeServiceOwner(codeowners, service.node.repoPath, service.dir);
     if (owner !== void 0) service.node.owner = owner;
   }
-  const resolvedDirs = out.map((s) => path20.resolve(s.dir));
+  const resolvedDirs = out.map((s) => path21.resolve(s.dir));
   for (let i = 0; i < out.length; i++) {
     const self = resolvedDirs[i];
     const nested = [];
     for (let j = 0; j < out.length; j++) {
       if (i === j) continue;
       const other = resolvedDirs[j];
-      if (other.startsWith(self + path20.sep)) nested.push(other);
+      if (other.startsWith(self + path21.sep)) nested.push(other);
     }
     out[i].excludeDirs = nested;
   }
@@ -7442,8 +7575,8 @@ function addServiceNodes(graph, services) {
 }
 // src/extract/aliases.ts
-import path21 from "path";
-import { promises as fs19 } from "fs";
+import path22 from "path";
+import { promises as fs20 } from "fs";
 import { parseAllDocuments } from "yaml";
 import { NodeType as NodeType16 } from "@neat.is/types";
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
@@ -7470,14 +7603,14 @@ function indexServicesByName(services) {
   const map = /* @__PURE__ */ new Map();
   for (const s of services) {
     map.set(s.node.name, s.node.id);
-    map.set(path21.basename(s.dir), s.node.id);
+    map.set(path22.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 = path21.join(scanPath, name);
+    const abs = path22.join(scanPath, name);
     if (await exists(abs)) {
       composePath = abs;
       break;
@@ -7490,7 +7623,7 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   } catch (err) {
     recordExtractionError(
       "aliases compose",
-      path21.relative(scanPath, composePath),
+      path22.relative(scanPath, composePath),
       err
     );
     return;
@@ -7533,11 +7666,11 @@ function parseDockerfileLabels(content) {
 }
 async function collectDockerfileAliases(graph, services) {
   for (const service of services) {
-    const dockerfilePath = path21.join(service.dir, "Dockerfile");
+    const dockerfilePath = path22.join(service.dir, "Dockerfile");
     if (!await exists(dockerfilePath)) continue;
     let content;
     try {
-      content = await fs19.readFile(dockerfilePath, "utf8");
+      content = await fs20.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError("aliases dockerfile", dockerfilePath, err);
       continue;
@@ -7549,15 +7682,15 @@ async function collectDockerfileAliases(graph, services) {
 async function walkYamlFiles(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await fs19.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await fs20.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = path21.join(start, entry.name);
+      const child = path22.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(path21.extname(entry.name))) {
-      out.push(path21.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(path22.extname(entry.name))) {
+      out.push(path22.join(start, entry.name));
     }
   }
   return out;
@@ -7584,7 +7717,7 @@ function k8sServiceTarget(doc, byName) {
 async function collectK8sAliases(graph, scanPath, serviceIndex) {
   const files = await walkYamlFiles(scanPath);
   for (const file of files) {
-    const content = await fs19.readFile(file, "utf8");
+    const content = await fs20.readFile(file, "utf8");
     let docs;
     try {
       docs = parseAllDocuments(content).map((d) => d.toJSON());
@@ -7608,14 +7741,14 @@ async function addServiceAliases(graph, scanPath, services) {
 }
 // src/extract/files.ts
-import path22 from "path";
+import path23 from "path";
 async function addFiles(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
     const filePaths = await walkSourceFiles(service.dir, service.excludeDirs);
     for (const filePath of filePaths) {
-      const relPath = toPosix(path22.relative(service.dir, filePath));
+      const relPath = toPosix(path23.relative(service.dir, filePath));
       const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -7630,7 +7763,7 @@ async function addFiles(graph, services) {
 }
 // src/extract/symbols.ts
-import path23 from "path";
+import path24 from "path";
 import Parser3 from "tree-sitter";
 import JavaScript3 from "tree-sitter-javascript";
 import TypeScript from "tree-sitter-typescript";
@@ -8389,10 +8522,10 @@ async function addSymbols(graph, services) {
   for (const service of services) {
     const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
-      const ext = path23.extname(file.path);
+      const ext = path24.extname(file.path);
       const parser = parserForExt5(ext);
       if (!parser) continue;
-      const relPath = toPosix(path23.relative(service.dir, file.path));
+      const relPath = toPosix(path24.relative(service.dir, file.path));
       let defs;
       try {
         const tree = parseSource3(parser, file.content);
@@ -8451,7 +8584,7 @@ async function addSymbols(graph, services) {
 }
 // src/extract/symbol-edges.ts
-import path24 from "path";
+import path25 from "path";
 import Parser4 from "tree-sitter";
 import {
   EdgeType as EdgeType8,
@@ -8565,10 +8698,10 @@ async function addSymbolEdges(graph, services) {
     const tsPaths = await loadTsPathConfig(service.dir);
     const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
-      const parser = parserForExt5(path24.extname(file.path));
+      const parser = parserForExt5(path25.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(path24.relative(service.dir, file.path));
-      const fileDir = path24.dirname(file.path);
+      const relPath = toPosix(path25.relative(service.dir, file.path));
+      const fileDir = path25.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -8702,7 +8835,7 @@ async function addSymbolEdges(graph, services) {
 }
 // src/extract/actions.ts
-import path25 from "path";
+import path26 from "path";
 import Parser5 from "tree-sitter";
 import {
   EdgeType as EdgeType9,
@@ -8856,9 +8989,9 @@ async function addServerActions(graph, services) {
     const files = await loadSourceFiles(service.dir, service.excludeDirs);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(path25.extname(file.path));
+      const parser = parserForExt5(path26.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(path25.relative(service.dir, file.path));
+      const relPath = toPosix(path26.relative(service.dir, file.path));
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -8919,10 +9052,10 @@ async function addServerActions(graph, services) {
     }
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(path25.extname(file.path));
+      const parser = parserForExt5(path26.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(path25.relative(service.dir, file.path));
-      const fileDir = path25.dirname(file.path);
+      const relPath = toPosix(path26.relative(service.dir, file.path));
+      const fileDir = path26.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -8974,7 +9107,7 @@ async function addServerActions(graph, services) {
 }
 // src/extract/databases/index.ts
-import path34 from "path";
+import path35 from "path";
 import {
   EdgeType as EdgeType10,
   NodeType as NodeType20,
@@ -8985,9 +9118,9 @@ import {
 } from "@neat.is/types";
 // src/extract/databases/db-config-yaml.ts
-import path26 from "path";
+import path27 from "path";
 async function parse(serviceDir) {
-  const yamlPath = path26.join(serviceDir, "db-config.yaml");
+  const yamlPath = path27.join(serviceDir, "db-config.yaml");
   if (!await exists(yamlPath)) return [];
   const raw = await readYaml(yamlPath);
   return [
@@ -9004,12 +9137,12 @@ async function parse(serviceDir) {
 var dbConfigYamlParser = { name: "db-config.yaml", parse };
 // src/extract/databases/dotenv.ts
-import { promises as fs21 } from "fs";
-import path28 from "path";
+import { promises as fs22 } from "fs";
+import path29 from "path";
 // src/extract/databases/shared.ts
-import { promises as fs20 } from "fs";
-import path27 from "path";
+import { promises as fs21 } from "fs";
+import path28 from "path";
 function schemeToEngine(scheme) {
   const s = scheme.toLowerCase().split("+")[0];
   switch (s) {
@@ -9048,18 +9181,18 @@ function parseConnectionString(url) {
 }
 async function readIfExists(filePath) {
   try {
-    return await fs20.readFile(filePath, "utf8");
+    return await fs21.readFile(filePath, "utf8");
   } catch {
     return null;
   }
 }
 async function resolveEnvVar(serviceDir, name) {
-  const entries = await fs20.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs21.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(path27.join(serviceDir, fileName));
+    const content = await readIfExists(path28.join(serviceDir, fileName));
     if (!content) continue;
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -9078,7 +9211,7 @@ async function resolveEnvVar(serviceDir, name) {
 }
 async function findFirst(serviceDir, candidates) {
   for (const rel of candidates) {
-    const abs = path27.join(serviceDir, rel);
+    const abs = path28.join(serviceDir, rel);
     const content = await readIfExists(abs);
     if (content !== null) return abs;
   }
@@ -9136,15 +9269,15 @@ function parseDotenvLine(line) {
   return { key, value };
 }
 async function parse2(serviceDir) {
-  const entries = await fs21.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs22.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 = path28.join(serviceDir, entry.name);
-    const content = await fs21.readFile(filePath, "utf8");
+    const filePath = path29.join(serviceDir, entry.name);
+    const content = await fs22.readFile(filePath, "utf8");
     for (const line of content.split("\n")) {
       const parsed = parseDotenvLine(line);
       if (!parsed) continue;
@@ -9162,9 +9295,9 @@ async function parse2(serviceDir) {
 var dotenvParser = { name: ".env", parse: parse2 };
 // src/extract/databases/prisma.ts
-import path29 from "path";
+import path30 from "path";
 async function parse3(serviceDir) {
-  const schemaPath = path29.join(serviceDir, "prisma", "schema.prisma");
+  const schemaPath = path30.join(serviceDir, "prisma", "schema.prisma");
   const content = await readIfExists(schemaPath);
   if (!content) return [];
   const block = content.match(/datasource\s+\w+\s*\{([^}]*)\}/s);
@@ -9319,10 +9452,10 @@ async function parse5(serviceDir) {
 var knexParser = { name: "knex", parse: parse5 };
 // src/extract/databases/ormconfig.ts
-import path30 from "path";
+import path31 from "path";
 async function parse6(serviceDir) {
   for (const candidate of ["ormconfig.json", "ormconfig.yaml", "ormconfig.yml"]) {
-    const abs = path30.join(serviceDir, candidate);
+    const abs = path31.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];
@@ -9380,9 +9513,9 @@ async function parse7(serviceDir) {
 var typeormParser = { name: "typeorm", parse: parse7 };
 // src/extract/databases/sequelize.ts
-import path31 from "path";
+import path32 from "path";
 async function parse8(serviceDir) {
-  const configPath = path31.join(serviceDir, "config", "config.json");
+  const configPath = path32.join(serviceDir, "config", "config.json");
   if (!await exists(configPath)) return [];
   const raw = await readJson(configPath);
   const out = [];
@@ -9408,8 +9541,8 @@ async function parse8(serviceDir) {
 var sequelizeParser = { name: "sequelize", parse: parse8 };
 // src/extract/databases/csharp.ts
-import { promises as fs22 } from "fs";
-import path32 from "path";
+import { promises as fs23 } from "fs";
+import path33 from "path";
 var CS_EXT = ".cs";
 var NPGSQL_GATE = /\bUseNpgsql\b|\bNpgsql\b/;
 var REDIS_GATE = /\bConnectionMultiplexer\b|\bStackExchange\.Redis\b|\bConfigurationOptions\.Parse\b|\bAddStackExchangeRedisCache\b/;
@@ -9456,12 +9589,12 @@ function parseRedisEndpoint(raw) {
   return { host, port, database: "", engine: "redis", engineVersion: "unknown" };
 }
 async function resolveEnvUpTree(startDir, name) {
-  let dir = path32.resolve(startDir);
+  let dir = path33.resolve(startDir);
   for (let depth = 0; depth < 12; depth++) {
     const value = await resolveEnvVar(dir, name);
     if (value !== null) return value;
-    const atRepoRoot = await fs22.access(path32.join(dir, ".git")).then(() => true).catch(() => false);
-    const parent = path32.dirname(dir);
+    const atRepoRoot = await fs23.access(path33.join(dir, ".git")).then(() => true).catch(() => false);
+    const parent = path33.dirname(dir);
     if (atRepoRoot || parent === dir) break;
     dir = parent;
   }
@@ -9516,12 +9649,12 @@ async function resolveConfigs(literals, keys, serviceDir, looksLike, parse11) {
 }
 async function parse9(serviceDir) {
   const files = (await walkSourceFiles(serviceDir).catch(() => [])).filter(
-    (f) => path32.extname(f) === CS_EXT
+    (f) => path33.extname(f) === CS_EXT
   );
   if (files.length === 0) return [];
   const sources = [];
   for (const file of files) {
-    const content = await fs22.readFile(file, "utf8").catch(() => null);
+    const content = await fs23.readFile(file, "utf8").catch(() => null);
     if (content !== null) sources.push({ file, content });
   }
   let pgGateFile = null;
@@ -9561,7 +9694,7 @@ async function parse9(serviceDir) {
 var csharpParser = { name: "csharp", parse: parse9 };
 // src/extract/databases/docker-compose.ts
-import path33 from "path";
+import path34 from "path";
 function portFromService(svc) {
   for (const raw of svc.ports ?? []) {
     const str = String(raw);
@@ -9588,7 +9721,7 @@ function databaseFromEnv(svc) {
 }
 async function parse10(serviceDir) {
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = path33.join(serviceDir, name);
+    const abs = path34.join(serviceDir, name);
     if (!await exists(abs)) continue;
     const raw = await readYaml(abs);
     if (!raw?.services) return [];
@@ -9761,7 +9894,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
           discoveredVia: mergedDiscoveredVia
         });
       }
-      const relConfigFile = toPosix(path34.relative(service.dir, config.sourceFile));
+      const relConfigFile = toPosix(path35.relative(service.dir, config.sourceFile));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -9770,7 +9903,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       );
       nodesAdded += fn;
       edgesAdded += fe;
-      const evidenceFile = toPosix(path34.relative(scanPath, config.sourceFile));
+      const evidenceFile = toPosix(path35.relative(scanPath, config.sourceFile));
       const edge = {
         id: extractedEdgeId(fileNodeId, dbNode.id, EdgeType10.CONNECTS_TO),
         source: fileNodeId,
@@ -9791,15 +9924,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 = path34.relative(scanPath, primary.sourceFile);
+      const relPath = path35.relative(scanPath, primary.sourceFile);
       const cfgId = configId(relPath);
       if (!graph.hasNode(cfgId)) {
         const cfgNode = {
           id: cfgId,
           type: NodeType20.ConfigNode,
-          name: path34.basename(primary.sourceFile),
+          name: path35.basename(primary.sourceFile),
           path: relPath,
-          fileType: isConfigFile(path34.basename(primary.sourceFile)).fileType || "config"
+          fileType: isConfigFile(path35.basename(primary.sourceFile)).fileType || "config"
         };
         graph.addNode(cfgId, cfgNode);
         nodesAdded++;
@@ -9839,8 +9972,8 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
 }
 // src/extract/configs.ts
-import { promises as fs23 } from "fs";
-import path35 from "path";
+import { promises as fs24 } from "fs";
+import path36 from "path";
 import {
   EdgeType as EdgeType11,
   NodeType as NodeType21,
@@ -9849,15 +9982,15 @@ import {
   confidenceForExtracted as confidenceForExtracted8
 } from "@neat.is/types";
 async function walkConfigFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => path35.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => path36.resolve(d)));
   const out = [];
   async function walk11(current) {
-    const entries = await fs23.readdir(current, { withFileTypes: true });
+    const entries = await fs24.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path35.join(current, entry.name);
+      const full = path36.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(path35.resolve(full))) continue;
+        if (excluded.has(path36.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk11(full);
       } else if (entry.isFile() && isConfigFile(entry.name).match) {
@@ -9874,19 +10007,19 @@ async function addConfigNodes(graph, services, scanPath) {
   for (const service of services) {
     const configFiles = await walkConfigFiles(service.dir, service.excludeDirs);
     for (const file of configFiles) {
-      const relPath = path35.relative(scanPath, file);
+      const relPath = path36.relative(scanPath, file);
       const node = {
         id: configId2(relPath),
         type: NodeType21.ConfigNode,
-        name: path35.basename(file),
+        name: path36.basename(file),
         path: relPath,
-        fileType: isConfigFile(path35.basename(file)).fileType
+        fileType: isConfigFile(path36.basename(file)).fileType
       };
       if (!graph.hasNode(node.id)) {
         graph.addNode(node.id, node);
         nodesAdded++;
       }
-      const relToService = toPosix(path35.relative(service.dir, file));
+      const relToService = toPosix(path36.relative(service.dir, file));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -9902,7 +10035,7 @@ async function addConfigNodes(graph, services, scanPath) {
         type: EdgeType11.CONFIGURED_BY,
         provenance: Provenance11.EXTRACTED,
         confidence: confidenceForExtracted8("structural"),
-        evidence: { file: relPath.split(path35.sep).join("/") }
+        evidence: { file: relPath.split(path36.sep).join("/") }
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -9914,8 +10047,8 @@ async function addConfigNodes(graph, services, scanPath) {
 }
 // src/extract/proto.ts
-import { promises as fs24 } from "fs";
-import path36 from "path";
+import { promises as fs25 } from "fs";
+import path37 from "path";
 import {
   EdgeType as EdgeType12,
   NodeType as NodeType22,
@@ -9960,18 +10093,18 @@ function grpcMethodsFromProto(content, fqPackage) {
   return out;
 }
 async function walkProtoFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => path36.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => path37.resolve(d)));
   const out = [];
   async function walk11(current) {
-    const entries = await fs24.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await fs25.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      const full = path36.join(current, entry.name);
+      const full = path37.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(path36.resolve(full))) continue;
+        if (excluded.has(path37.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk11(full);
-      } else if (entry.isFile() && path36.extname(entry.name) === PROTO_EXTENSION) {
+      } else if (entry.isFile() && path37.extname(entry.name) === PROTO_EXTENSION) {
         out.push(full);
       }
     }
@@ -9986,10 +10119,10 @@ async function addGrpcMethods(graph, services) {
     const protoPaths = await walkProtoFiles(service.dir, service.excludeDirs);
     for (const protoPath of protoPaths) {
       if (isTestPath(protoPath)) continue;
-      const relFile = toPosix(path36.relative(service.dir, protoPath));
+      const relFile = toPosix(path37.relative(service.dir, protoPath));
       let content;
       try {
-        content = await fs24.readFile(protoPath, "utf8");
+        content = await fs25.readFile(protoPath, "utf8");
       } catch (err) {
         recordExtractionError("proto extraction", protoPath, err);
         continue;
@@ -10052,7 +10185,7 @@ import {
 } from "@neat.is/types";
 // src/extract/calls/http.ts
-import path37 from "path";
+import path38 from "path";
 import Parser6 from "tree-sitter";
 import JavaScript4 from "tree-sitter-javascript";
 import TypeScript2 from "tree-sitter-typescript";
@@ -10140,7 +10273,7 @@ async function addHttpCallEdges(graph, services) {
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt(path37.extname(file.path), parserCache);
+      const parser = parserForExt(path38.extname(file.path), parserCache);
       let sites;
       try {
         sites = callsFromSource(file.content, parser, knownHosts);
@@ -10149,7 +10282,7 @@ async function addHttpCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(path37.relative(service.dir, file.path));
+      const relFile = toPosix(path38.relative(service.dir, file.path));
       for (const site of sites) {
         const targetId = hostToNodeId.get(site.host);
         if (!targetId || targetId === service.node.id) continue;
@@ -10202,7 +10335,7 @@ async function addHttpCallEdges(graph, services) {
 }
 // src/extract/calls/route-match.ts
-import path38 from "path";
+import path39 from "path";
 import Parser7 from "tree-sitter";
 import JavaScript5 from "tree-sitter-javascript";
 import {
@@ -10487,7 +10620,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(path38.extname(file.path))) continue;
+      if (!JS_CLIENT_EXTENSIONS.has(path39.extname(file.path))) continue;
       let sites;
       try {
         sites = clientCallSitesFromSource(file.content, jsParser, knownHosts);
@@ -10496,7 +10629,7 @@ async function addRouteCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(path38.relative(service.dir, file.path));
+      const relFile = toPosix(path39.relative(service.dir, file.path));
       for (const site of sites) {
         if (site.host === null) {
           const dedupKey2 = `${relFile}|unresolved-host`;
@@ -10588,7 +10721,7 @@ async function addRouteCallEdges(graph, services) {
 }
 // src/extract/calls/kafka.ts
-import path39 from "path";
+import path40 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;
@@ -10676,13 +10809,13 @@ function kafkaEndpointsFromFile(file, serviceDir) {
       // call sites — verified-call-site tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path39.relative(serviceDir, file.path),
+        file: path40.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
     });
   };
-  if (path39.extname(file.path) === ".go") {
+  if (path40.extname(file.path) === ".go") {
     goSaramaEndpoints(file.content, make);
   } else {
     for (const { topic } of findAll(PRODUCER_TOPIC_RE, file.content)) make(topic, "PUBLISHES_TO");
@@ -10692,7 +10825,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 }
 // src/extract/calls/redis.ts
-import path40 from "path";
+import path41 from "path";
 import { infraId as infraId3 } from "@neat.is/types";
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
@@ -10715,7 +10848,7 @@ function redisEndpointsFromFile(file, serviceDir) {
       // support tier (ADR-066).
       confidenceKind: "url-with-structural-support",
       evidence: {
-        file: path40.relative(serviceDir, file.path),
+        file: path41.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10725,7 +10858,7 @@ function redisEndpointsFromFile(file, serviceDir) {
 }
 // src/extract/calls/aws.ts
-import path41 from "path";
+import path42 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;
@@ -10759,7 +10892,7 @@ function awsEndpointsFromFile(file, serviceDir) {
       // (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path41.relative(serviceDir, file.path),
+        file: path42.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10783,7 +10916,7 @@ function awsEndpointsFromFile(file, serviceDir) {
 }
 // src/extract/calls/grpc.ts
-import path42 from "path";
+import path43 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;
@@ -10842,7 +10975,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path42.relative(serviceDir, file.path),
+        file: path43.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10852,7 +10985,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
 }
 // src/extract/calls/supabase.ts
-import path43 from "path";
+import path44 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['"`]/;
@@ -10911,7 +11044,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066), the same grade aws.ts / grpc.ts emit at.
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path43.relative(serviceDir, file.path),
+        file: path44.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -10938,7 +11071,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         evidence: {
-          file: path43.relative(serviceDir, file.path),
+          file: path44.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -10949,7 +11082,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
 }
 // src/extract/calls/firestore.ts
-import path44 from "path";
+import path45 from "path";
 import Parser8 from "tree-sitter";
 import JavaScript6 from "tree-sitter-javascript";
 import { infraId as infraId7 } from "@neat.is/types";
@@ -11122,7 +11255,7 @@ function firestoreEndpointsFromFile(file, serviceDir, imported) {
   if (!hasClient && !hasAdmin && importedNames.size === 0) return [];
   const ownSdk = hasClient && !hasAdmin ? "client" : hasAdmin && !hasClient ? "admin" : null;
   const fileSdk = !hasClient && !hasAdmin ? imported?.sdk ?? null : ownSdk;
-  const tree = parseSource3(parserForExt2(path44.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt2(path45.extname(file.path)), file.content);
   const clientVars = firestoreClientVars(tree.rootNode);
   for (const n of importedNames) clientVars.add(n);
   const collLine = /* @__PURE__ */ new Map();
@@ -11227,7 +11360,7 @@ function firestoreEndpointsFromFile(file, serviceDir, imported) {
       ...columnSet.size > 0 ? { columns: [...columnSet] } : {},
       ...sdkWrites ? { sdkWrites } : {},
       evidence: {
-        file: path44.relative(serviceDir, file.path),
+        file: path45.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11287,7 +11420,7 @@ function sdkOf(content) {
   return hasClient && !hasAdmin ? "client" : hasAdmin && !hasClient ? "admin" : null;
 }
 function parseOrNull(file) {
-  const ext = path44.extname(file.path);
+  const ext = path45.extname(file.path);
   if (!(ext in GRAMMAR_BY_EXT)) return null;
   try {
     return parseSource3(parserForExt2(ext), file.content).rootNode;
@@ -11303,7 +11436,7 @@ async function firestoreCrossFileEndpoints(files, serviceDir) {
     if (!root) continue;
     const names = exportedFirestoreClients(root);
     if (names.size === 0) continue;
-    registry.set(toPosix(path44.relative(serviceDir, f.path)), { names, sdk: sdkOf(f.content) });
+    registry.set(toPosix(path45.relative(serviceDir, f.path)), { names, sdk: sdkOf(f.content) });
   }
   if (registry.size === 0) return [];
   const out = [];
@@ -11316,7 +11449,7 @@ async function firestoreCrossFileEndpoints(files, serviceDir) {
     const names = /* @__PURE__ */ new Set();
     let sdk = null;
     for (const b of bindings) {
-      const rel = await resolveJsImport(b.specifier, path44.dirname(f.path), serviceDir, null);
+      const rel = await resolveJsImport(b.specifier, path45.dirname(f.path), serviceDir, null);
       if (!rel) continue;
       const entry = registry.get(rel);
       if (!entry || !entry.names.has(b.imported)) continue;
@@ -11330,7 +11463,7 @@ async function firestoreCrossFileEndpoints(files, serviceDir) {
 }
 // src/extract/calls/mongoose.ts
-import path45 from "path";
+import path46 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['"`]/;
@@ -11481,7 +11614,7 @@ function endpoint(r, file, serviceDir, matchText) {
     kind: r.kind,
     edgeType: "CALLS",
     confidenceKind: "verified-call-site",
-    evidence: { file: path45.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+    evidence: { file: path46.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
   };
 }
 function mongooseEndpointsFromFile(file, serviceDir) {
@@ -11571,7 +11704,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(path45.relative(serviceDir, f.path)), fx);
+    if (fx) registry.set(toPosix(path46.relative(serviceDir, f.path)), fx);
   }
   if (registry.size === 0) return [];
   const out = [];
@@ -11582,7 +11715,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, path45.dirname(f.path), serviceDir, null);
+      const resolvedRel = await resolveJsImport(b.specifier, path46.dirname(f.path), serviceDir, null);
       if (!resolvedRel) continue;
       const fx = registry.get(resolvedRel);
       if (!fx) continue;
@@ -11625,7 +11758,7 @@ async function mongooseCrossFileEndpoints(files, serviceDir) {
 }
 // src/extract/calls/sqlalchemy.ts
-import path46 from "path";
+import path47 from "path";
 import Parser9 from "tree-sitter";
 import Python5 from "tree-sitter-python";
 import { infraId as infraId9 } from "@neat.is/types";
@@ -11764,7 +11897,7 @@ function sqlalchemyForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: path46.relative(serviceDir, file.path),
+          file: path47.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -11789,7 +11922,7 @@ function sqlalchemyEndpointsFromFile(file, serviceDir) {
       confidenceKind: "verified-call-site",
       ...columns && columns.length > 0 ? { columns } : {},
       evidence: {
-        file: path46.relative(serviceDir, file.path),
+        file: path47.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11896,7 +12029,7 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         evidence: {
-          file: path46.relative(serviceDir, file.path),
+          file: path47.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -11907,7 +12040,7 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
 }
 // src/extract/calls/socket.ts
-import path47 from "path";
+import path48 from "path";
 import Parser10 from "tree-sitter";
 import Python6 from "tree-sitter-python";
 import { infraId as infraId10 } from "@neat.is/types";
@@ -11983,7 +12116,7 @@ function socketEndpointsFromFile(file, serviceDir) {
       // A verified `socket.socket(...)` + `.connect((host, port))` call site.
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path47.relative(serviceDir, file.path),
+        file: path48.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11993,7 +12126,7 @@ function socketEndpointsFromFile(file, serviceDir) {
 }
 // src/extract/calls/django-orm.ts
-import path48 from "path";
+import path49 from "path";
 import Parser11 from "tree-sitter";
 import Python7 from "tree-sitter-python";
 import { infraId as infraId11 } from "@neat.is/types";
@@ -12063,7 +12196,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
   const tree = parseSource8(makePyParser5(), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const defaultAppLabel = path48.basename(path48.dirname(file.path));
+  const defaultAppLabel = path49.basename(path49.dirname(file.path));
   walk5(tree.rootNode, (node) => {
     if (node.type !== "class_definition") return;
     if (!extendsDjangoModel(node)) return;
@@ -12081,14 +12214,14 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
-      evidence: { file: path48.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+      evidence: { file: path49.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
     });
   });
   return out;
 }
 // src/extract/calls/drizzle.ts
-import path49 from "path";
+import path50 from "path";
 import Parser12 from "tree-sitter";
 import JavaScript7 from "tree-sitter-javascript";
 import { infraId as infraId12 } from "@neat.is/types";
@@ -12166,7 +12299,7 @@ function columnsFromObject(obj) {
 }
 function drizzleEndpointsFromFile(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(path49.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(path50.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk11 = (node) => {
@@ -12189,7 +12322,7 @@ function drizzleEndpointsFromFile(file, serviceDir) {
             confidenceKind: "structural",
             columns,
             evidence: {
-              file: path49.relative(serviceDir, file.path),
+              file: path50.relative(serviceDir, file.path),
               line,
               snippet: snippet(file.content, line)
             }
@@ -12255,7 +12388,7 @@ function referencesTargetVar(call) {
 }
 function drizzleForeignKeys(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(path49.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(path50.extname(file.path)), file.content);
   const { tables, varToTable } = collectDrizzleTables(tree.rootNode);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -12274,7 +12407,7 @@ function drizzleForeignKeys(file, serviceDir) {
               childTable: table.tableName,
               parentTable,
               evidence: {
-                file: path49.relative(serviceDir, file.path),
+                file: path50.relative(serviceDir, file.path),
                 line,
                 snippet: snippet(file.content, line)
               }
@@ -12290,7 +12423,7 @@ function drizzleForeignKeys(file, serviceDir) {
 }
 // src/extract/calls/prisma.ts
-import path50 from "path";
+import path51 from "path";
 import { infraId as infraId13 } from "@neat.is/types";
 var SCALAR_TYPES = /* @__PURE__ */ new Set([
   "Int",
@@ -12346,7 +12479,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
       confidenceKind: "structural",
       columns: b.columns,
       evidence: {
-        file: path50.relative(serviceDir, file.path),
+        file: path51.relative(serviceDir, file.path),
         line: b.startLine,
         snippet: snippet(content, b.startLine)
       }
@@ -12407,7 +12540,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
 }
 async function prismaColumnEndpoints(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    path50.join("prisma", "schema.prisma"),
+    path51.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -12482,7 +12615,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
               childTable: current.table,
               parentTable,
               evidence: {
-                file: path50.relative(serviceDir, file.path),
+                file: path51.relative(serviceDir, file.path),
                 line: lineNo,
                 snippet: snippet(content, lineNo)
               }
@@ -12497,7 +12630,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
 }
 async function prismaForeignKeys(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    path50.join("prisma", "schema.prisma"),
+    path51.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -12507,7 +12640,7 @@ async function prismaForeignKeys(serviceDir) {
 }
 // src/extract/calls/activerecord.ts
-import path51 from "path";
+import path52 from "path";
 import Parser13 from "tree-sitter";
 import Ruby3 from "tree-sitter-ruby";
 import { infraId as infraId14 } from "@neat.is/types";
@@ -12715,7 +12848,7 @@ function railsSchemaEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...table.columns.length > 0 ? { columns: table.columns } : {},
       evidence: {
-        file: path51.relative(serviceDir, file.path),
+        file: path52.relative(serviceDir, file.path),
         line: table.line,
         snippet: snippet(file.content, table.line)
       }
@@ -12737,7 +12870,7 @@ function railsSchemaForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: path51.relative(serviceDir, file.path),
+        file: path52.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12820,7 +12953,7 @@ function railsModelEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path51.relative(serviceDir, file.path),
+        file: path52.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12857,7 +12990,7 @@ function railsModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: path51.relative(serviceDir, file.path),
+          file: path52.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -12868,7 +13001,7 @@ function railsModelForeignKeys(file, serviceDir) {
 }
 // src/extract/calls/eloquent.ts
-import path52 from "path";
+import path53 from "path";
 import Parser14 from "tree-sitter";
 import Php3 from "tree-sitter-php";
 import { infraId as infraId15 } from "@neat.is/types";
@@ -13125,7 +13258,7 @@ function laravelMigrationEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: path52.relative(serviceDir, file.path),
+        file: path53.relative(serviceDir, file.path),
         line: bp.line,
         snippet: snippet(file.content, bp.line)
       }
@@ -13147,7 +13280,7 @@ function laravelMigrationForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: path52.relative(serviceDir, file.path),
+        file: path53.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -13267,7 +13400,7 @@ function laravelModelEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: path52.relative(serviceDir, file.path),
+        file: path53.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -13303,7 +13436,7 @@ function laravelModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: path52.relative(serviceDir, file.path),
+          file: path53.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -13314,7 +13447,7 @@ function laravelModelForeignKeys(file, serviceDir) {
 }
 // src/extract/calls/go.ts
-import path53 from "path";
+import path54 from "path";
 import Parser15 from "tree-sitter";
 import Go4 from "tree-sitter-go";
 import { infraId as infraId16 } from "@neat.is/types";
@@ -13388,7 +13521,7 @@ function firstStringLiteralArg(argsNode) {
   return null;
 }
 function goSqlEndpointsFromFile(file, serviceDir) {
-  if (path53.extname(file.path) !== ".go") return [];
+  if (path54.extname(file.path) !== ".go") return [];
   if (!file.content.includes(DATABASE_SQL_IMPORT) && !file.content.includes(SQLX_IMPORT)) return [];
   const tree = parseSource11(makeGoParser3(), file.content);
   const importsDatabaseSql = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([DATABASE_SQL_IMPORT]));
@@ -13417,7 +13550,7 @@ function goSqlEndpointsFromFile(file, serviceDir) {
       confidenceKind: "verified-call-site",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(path53.relative(serviceDir, file.path)),
+        file: toPosix(path54.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -13427,7 +13560,7 @@ function goSqlEndpointsFromFile(file, serviceDir) {
 }
 // src/extract/calls/gorm.ts
-import path54 from "path";
+import path55 from "path";
 import Parser16 from "tree-sitter";
 import Go5 from "tree-sitter-go";
 import { infraId as infraId17 } from "@neat.is/types";
@@ -13860,7 +13993,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
   seen.delete(struct.name);
 }
 function gormEndpointsFromFile(file, serviceDir) {
-  if (path54.extname(file.path) !== ".go") return [];
+  if (path55.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
   const tree = parseSource12(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
@@ -13882,7 +14015,7 @@ function gormEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(path54.relative(serviceDir, file.path)),
+        file: toPosix(path55.relative(serviceDir, file.path)),
         line: struct.line,
         snippet: snippet(file.content, struct.line)
       }
@@ -13891,7 +14024,7 @@ function gormEndpointsFromFile(file, serviceDir) {
   return out;
 }
 function gormForeignKeys(file, serviceDir) {
-  if (path54.extname(file.path) !== ".go") return [];
+  if (path55.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
   const tree = parseSource12(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
@@ -13906,7 +14039,7 @@ function gormForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: toPosix(path54.relative(serviceDir, file.path)),
+        file: toPosix(path55.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -13942,7 +14075,7 @@ function gormForeignKeys(file, serviceDir) {
 }
 // src/extract/calls/efcore.ts
-import path55 from "path";
+import path56 from "path";
 import Parser17 from "tree-sitter";
 import CSharp2 from "tree-sitter-c-sharp";
 import { infraId as infraId18 } from "@neat.is/types";
@@ -14021,7 +14154,7 @@ function tableFromToTable(call) {
   return value ? csStringLiteral(value) : null;
 }
 function efcoreEndpointsFromFile(file, serviceDir) {
-  if (path55.extname(file.path) !== ".cs") return [];
+  if (path56.extname(file.path) !== ".cs") return [];
   if (!EFCORE_GATE.test(file.content)) return [];
   const tree = parseSource13(makeCsParser(), file.content);
   const out = [];
@@ -14036,7 +14169,7 @@ function efcoreEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "structural",
       evidence: {
-        file: toPosix(path55.relative(serviceDir, file.path)),
+        file: toPosix(path56.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14293,7 +14426,7 @@ function ensureTableNode(graph, id, name) {
 }
 // src/extract/infra/docker-compose.ts
-import path56 from "path";
+import path57 from "path";
 import { EdgeType as EdgeType17, Provenance as Provenance18, confidenceForExtracted as confidenceForExtracted15 } from "@neat.is/types";
 // src/extract/infra/shared.ts
@@ -14363,7 +14496,7 @@ function dependsOnList(value) {
 }
 function serviceNameToServiceNode(name, services) {
   for (const s of services) {
-    if (s.node.name === name || path56.basename(s.dir) === name) return s.node.id;
+    if (s.node.name === name || path57.basename(s.dir) === name) return s.node.id;
   }
   return null;
 }
@@ -14372,7 +14505,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 = path56.join(scanPath, name);
+    const abs = path57.join(scanPath, name);
     if (await exists(abs)) {
       composePath = abs;
       break;
@@ -14385,13 +14518,13 @@ async function addComposeInfra(graph, scanPath, services) {
   } catch (err) {
     recordExtractionError(
       "infra docker-compose",
-      path56.relative(scanPath, composePath),
+      path57.relative(scanPath, composePath),
       err
     );
     return { nodesAdded, edgesAdded };
   }
   if (!compose?.services) return { nodesAdded, edgesAdded };
-  const evidenceFile = path56.relative(scanPath, composePath).split(path56.sep).join("/");
+  const evidenceFile = path57.relative(scanPath, composePath).split(path57.sep).join("/");
   const composeNameToNodeId = /* @__PURE__ */ new Map();
   for (const [composeName, svc] of Object.entries(compose.services)) {
     const matchedServiceId = serviceNameToServiceNode(composeName, services);
@@ -14432,8 +14565,8 @@ async function addComposeInfra(graph, scanPath, services) {
 }
 // src/extract/infra/dockerfile.ts
-import path57 from "path";
-import { promises as fs25 } from "fs";
+import path58 from "path";
+import { promises as fs26 } from "fs";
 import { EdgeType as EdgeType18, Provenance as Provenance19, confidenceForExtracted as confidenceForExtracted16 } from "@neat.is/types";
 function readDockerfile(content) {
   let image = null;
@@ -14463,15 +14596,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const dockerfilePath = path57.join(service.dir, "Dockerfile");
+    const dockerfilePath = path58.join(service.dir, "Dockerfile");
     if (!await exists(dockerfilePath)) continue;
     let content;
     try {
-      content = await fs25.readFile(dockerfilePath, "utf8");
+      content = await fs26.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError(
         "infra dockerfile",
-        path57.relative(scanPath, dockerfilePath),
+        path58.relative(scanPath, dockerfilePath),
         err
       );
       continue;
@@ -14483,8 +14616,8 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const relDockerfile = toPosix(path57.relative(service.dir, dockerfilePath));
-    const evidenceFile = toPosix(path57.relative(scanPath, dockerfilePath));
+    const relDockerfile = toPosix(path58.relative(service.dir, dockerfilePath));
+    const evidenceFile = toPosix(path58.relative(scanPath, dockerfilePath));
     const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
       graph,
       service.pkg.name,
@@ -14535,23 +14668,23 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 }
 // src/extract/infra/terraform.ts
-import { promises as fs26 } from "fs";
-import path58 from "path";
+import { promises as fs27 } from "fs";
+import path59 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 fs26.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await fs27.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 = path58.join(start, entry.name);
+      const child = path59.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(path58.join(start, entry.name));
+      out.push(path59.join(start, entry.name));
     }
   }
   return out;
@@ -14582,8 +14715,8 @@ async function addTerraformResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkTfFiles(scanPath);
   for (const file of files) {
-    const content = await fs26.readFile(file, "utf8");
-    const evidenceFile = toPosix(path58.relative(scanPath, file));
+    const content = await fs27.readFile(file, "utf8");
+    const evidenceFile = toPosix(path59.relative(scanPath, file));
     const resources = [];
     const byKey = /* @__PURE__ */ new Map();
     RESOURCE_RE.lastIndex = 0;
@@ -14639,8 +14772,8 @@ async function addTerraformResources(graph, scanPath) {
 }
 // src/extract/infra/k8s.ts
-import { promises as fs27 } from "fs";
-import path59 from "path";
+import { promises as fs28 } from "fs";
+import path60 from "path";
 import { parseAllDocuments as parseAllDocuments2 } from "yaml";
 import { EdgeType as EdgeType20, serviceId as serviceId13 } from "@neat.is/types";
 var K8S_KIND_TO_INFRA_KIND = {
@@ -14656,15 +14789,15 @@ var WORKLOAD_KINDS = /* @__PURE__ */ new Set(["Deployment", "StatefulSet", "Daem
 async function walkYamlFiles2(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await fs27.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await fs28.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = path59.join(start, entry.name);
+      const child = path60.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(path59.extname(entry.name))) {
-      out.push(path59.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(path60.extname(entry.name))) {
+      out.push(path60.join(start, entry.name));
     }
   }
   return out;
@@ -14674,14 +14807,14 @@ async function addK8sResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkYamlFiles2(scanPath);
   for (const file of files) {
-    const content = await fs27.readFile(file, "utf8");
+    const content = await fs28.readFile(file, "utf8");
     let docs;
     try {
       docs = parseAllDocuments2(content).map((d) => d.toJSON());
     } catch {
       continue;
     }
-    const relFile = toPosix(path59.relative(scanPath, file));
+    const relFile = toPosix(path60.relative(scanPath, file));
     for (const doc of docs) {
       if (!doc?.kind || !doc.metadata?.name) continue;
       const infraKind = K8S_KIND_TO_INFRA_KIND[doc.kind];
@@ -14729,16 +14862,16 @@ async function addK8sResources(graph, scanPath) {
 }
 // src/extract/infra/cloudflare.ts
-import { promises as fs28 } from "fs";
-import path60 from "path";
+import { promises as fs29 } from "fs";
+import path61 from "path";
 import { parse as parseToml3 } from "smol-toml";
 import { EdgeType as EdgeType21, 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 = path60.join(dir, filename);
+    const abs = path61.join(dir, filename);
     if (!await exists(abs)) continue;
-    const raw = await fs28.readFile(abs, "utf8");
+    const raw = await fs29.readFile(abs, "utf8");
     const config = filename === "wrangler.toml" ? parseToml3(raw) : JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
@@ -14799,11 +14932,11 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     try {
       read = await readWranglerConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra cloudflare", path60.relative(scanPath, service.dir), err);
+      recordExtractionError("infra cloudflare", path61.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read || !read.config.name) continue;
-    const evidenceFile = toPosix(path60.relative(scanPath, path60.join(service.dir, read.relFile)));
+    const evidenceFile = toPosix(path61.relative(scanPath, path61.join(service.dir, read.relFile)));
     discovered.push({ service, config: read.config, relFile: read.relFile, raw: read.raw, evidenceFile });
   }
   for (const worker of discovered) {
@@ -14815,7 +14948,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     }
     let anchorId = service.node.id;
     if (config.main) {
-      const entryRelPath = toPosix(path60.normalize(config.main));
+      const entryRelPath = toPosix(path61.normalize(config.main));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -14961,24 +15094,24 @@ async function addCloudflareWorkers(graph, services, scanPath) {
 }
 // src/extract/infra/vercel.ts
-import { promises as fs29 } from "fs";
-import path61 from "path";
+import { promises as fs30 } from "fs";
+import path62 from "path";
 import { EdgeType as EdgeType22 } 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 = path61.join(dir, filename);
+    const abs = path62.join(dir, filename);
     if (!await exists(abs)) continue;
-    const raw = await fs29.readFile(abs, "utf8");
+    const raw = await fs30.readFile(abs, "utf8");
     const config = JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
   return null;
 }
 async function readLinkedProjectName(dir) {
-  const abs = path61.join(dir, ".vercel", "project.json");
+  const abs = path62.join(dir, ".vercel", "project.json");
   if (!await exists(abs)) return void 0;
-  const parsed = JSON.parse(await fs29.readFile(abs, "utf8"));
+  const parsed = JSON.parse(await fs30.readFile(abs, "utf8"));
   return typeof parsed.projectName === "string" ? parsed.projectName : void 0;
 }
 function routeSource(route) {
@@ -14994,7 +15127,7 @@ async function addVercelServices(graph, services, scanPath) {
       read = await readVercelConfig(service.dir);
       projectName = await readLinkedProjectName(service.dir);
     } catch (err) {
-      recordExtractionError("infra vercel", path61.relative(scanPath, service.dir), err);
+      recordExtractionError("infra vercel", path62.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read && !projectName) continue;
@@ -15010,7 +15143,7 @@ async function addVercelServices(graph, services, scanPath) {
     const anchorId = service.node.id;
     if (!read) continue;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(path61.relative(scanPath, path61.join(service.dir, relFile)));
+    const evidenceFile = toPosix(path62.relative(scanPath, path62.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -15038,16 +15171,16 @@ async function addVercelServices(graph, services, scanPath) {
 }
 // src/extract/infra/railway.ts
-import { promises as fs30 } from "fs";
-import path62 from "path";
+import { promises as fs31 } from "fs";
+import path63 from "path";
 import { parse as parseToml4 } from "smol-toml";
 import { EdgeType as EdgeType23 } 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 = path62.join(dir, filename);
+    const abs = path63.join(dir, filename);
     if (!await exists(abs)) continue;
-    const raw = await fs30.readFile(abs, "utf8");
+    const raw = await fs31.readFile(abs, "utf8");
     const config = filename === "railway.toml" ? parseToml4(raw) : JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
@@ -15061,7 +15194,7 @@ async function addRailwayServices(graph, services, scanPath) {
     try {
       read = await readRailwayConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra railway", path62.relative(scanPath, service.dir), err);
+      recordExtractionError("infra railway", path63.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -15071,7 +15204,7 @@ async function addRailwayServices(graph, services, scanPath) {
     }
     const anchorId = service.node.id;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(path62.relative(scanPath, path62.join(service.dir, relFile)));
+    const evidenceFile = toPosix(path63.relative(scanPath, path63.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -15095,15 +15228,15 @@ async function addRailwayServices(graph, services, scanPath) {
 }
 // src/extract/infra/supabase.ts
-import { promises as fs31 } from "fs";
-import path63 from "path";
+import { promises as fs32 } from "fs";
+import path64 from "path";
 import { parse as parseToml5 } from "smol-toml";
 import { EdgeType as EdgeType24 } from "@neat.is/types";
 async function readSupabaseConfig(dir) {
-  const relFile = path63.join("supabase", "config.toml");
-  const abs = path63.join(dir, relFile);
+  const relFile = path64.join("supabase", "config.toml");
+  const abs = path64.join(dir, relFile);
   if (!await exists(abs)) return null;
-  const raw = await fs31.readFile(abs, "utf8");
+  const raw = await fs32.readFile(abs, "utf8");
   const config = parseToml5(raw);
   return { config, relFile, raw };
 }
@@ -15115,7 +15248,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
     try {
       read = await readSupabaseConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra supabase", path63.relative(scanPath, service.dir), err);
+      recordExtractionError("infra supabase", path64.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -15130,7 +15263,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
       });
     }
     const anchorId = service.node.id;
-    const evidenceFile = toPosix(path63.relative(scanPath, path63.join(service.dir, relFile)));
+    const evidenceFile = toPosix(path64.relative(scanPath, path64.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -15171,7 +15304,7 @@ async function addInfra(graph, scanPath, services) {
 }
 // src/extract/zod-shapes.ts
-import path64 from "path";
+import path65 from "path";
 import Parser18 from "tree-sitter";
 import JavaScript8 from "tree-sitter-javascript";
 import {
@@ -15273,7 +15406,7 @@ function topLevelSchemas(root) {
 }
 function zodShapesFromFile(file, serviceDir) {
   if (!ZOD_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt4(path64.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt4(path65.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const { name, call } of topLevelSchemas(tree.rootNode)) {
@@ -15291,7 +15424,7 @@ function zodShapesFromFile(file, serviceDir) {
       name,
       fields,
       evidence: {
-        file: path64.relative(serviceDir, file.path),
+        file: path65.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -15558,11 +15691,11 @@ async function addFirestoreRules(graph, services) {
 }
 // src/extract/index.ts
-import path66 from "path";
+import path67 from "path";
 // src/extract/retire.ts
 import { existsSync as existsSync2 } from "fs";
-import path65 from "path";
+import path66 from "path";
 import { NodeType as NodeType29, Provenance as Provenance23 } from "@neat.is/types";
 function dropOrphanedFileNodes(graph) {
   const orphans = [];
@@ -15596,11 +15729,11 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
     if (edge.provenance !== Provenance23.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
-    if (path65.isAbsolute(evidenceFile)) {
+    if (path66.isAbsolute(evidenceFile)) {
       if (!existsSync2(evidenceFile)) toDrop.push(id);
       return;
     }
-    const found = bases.some((base) => existsSync2(path65.join(base, evidenceFile)));
+    const found = bases.some((base) => existsSync2(path66.join(base, evidenceFile)));
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
@@ -15612,6 +15745,7 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
 async function extractFromDirectory(graph, scanPath, opts = {}) {
   await ensureCompatLoaded();
   drainExtractionErrors();
+  drainSkippedFiles();
   const services = await discoverServices(scanPath);
   const phase1Nodes = addServiceNodes(graph, services);
   await addServiceAliases(graph, scanPath, services);
@@ -15656,8 +15790,9 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
     }
   }
   const droppedEntries = drainDroppedExtracted();
+  const skippedEntries = drainSkippedFiles();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
-    const rejectedPath = path66.join(path66.dirname(opts.errorsPath), "rejected.ndjson");
+    const rejectedPath = path67.join(path67.dirname(opts.errorsPath), "rejected.ndjson");
     try {
       await writeRejectedExtracted(droppedEntries, rejectedPath);
     } catch (err) {
@@ -15674,7 +15809,9 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
     errorEntries,
     ghostsRetired,
     extractedDropped: droppedEntries.length,
-    droppedEntries
+    droppedEntries,
+    skippedFiles: skippedEntries.length,
+    skippedEntries
   };
   emitNeatEvent({
     type: "extraction-complete",
@@ -16376,8 +16513,8 @@ function computeDivergences(graph, opts = {}) {
 }
 // src/persist.ts
-import { promises as fs32 } from "fs";
-import path67 from "path";
+import { promises as fs33 } from "fs";
+import path68 from "path";
 import { NodeType as NodeType31, Provenance as Provenance25, observedEdgeId as observedEdgeId2 } from "@neat.is/types";
 var SCHEMA_VERSION = 7;
 function migrateV1ToV2(payload) {
@@ -16432,7 +16569,43 @@ function migrateV2ToV3(payload) {
   return { ...payload, schemaVersion: 3 };
 }
 async function ensureDir(filePath) {
-  await fs32.mkdir(path67.dirname(filePath), { recursive: true });
+  await fs33.mkdir(path68.dirname(filePath), { recursive: true });
+}
+var WRITE_FLUSH_CHARS = 4 * 1024 * 1024;
+function jsonOrUndefined(value) {
+  return JSON.stringify(value);
+}
+function* serializeArray(items) {
+  yield "[";
+  for (let i = 0; i < items.length; i++) {
+    if (i > 0) yield ",";
+    yield jsonOrUndefined(items[i]) ?? "null";
+  }
+  yield "]";
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function* serializeObject(obj) {
+  yield "{";
+  let first = true;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    const descend = Array.isArray(value) || isPlainObject(value);
+    if (!descend && jsonOrUndefined(value) === void 0) continue;
+    if (!first) yield ",";
+    first = false;
+    yield `${JSON.stringify(key)}:`;
+    if (Array.isArray(value)) yield* serializeArray(value);
+    else if (isPlainObject(value)) yield* serializeObject(value);
+    else yield jsonOrUndefined(value);
+  }
+  yield "}";
+}
+function* serializeGraphChunks(payload) {
+  yield* serializeObject(payload);
 }
 async function saveGraphToDisk(graph, outPath) {
   await ensureDir(outPath);
@@ -16442,13 +16615,26 @@ async function saveGraphToDisk(graph, outPath) {
     graph: graph.export()
   };
   const tmp = `${outPath}.tmp`;
-  await fs32.writeFile(tmp, JSON.stringify(payload), "utf8");
-  await fs32.rename(tmp, outPath);
+  const handle = await fs33.open(tmp, "w");
+  try {
+    let buffered = "";
+    for (const chunk of serializeGraphChunks(payload)) {
+      buffered += chunk;
+      if (buffered.length >= WRITE_FLUSH_CHARS) {
+        await handle.write(buffered, null, "utf8");
+        buffered = "";
+      }
+    }
+    if (buffered.length > 0) await handle.write(buffered, null, "utf8");
+  } finally {
+    await handle.close();
+  }
+  await fs33.rename(tmp, outPath);
 }
 async function loadGraphFromDisk(graph, outPath) {
   let raw;
   try {
-    raw = await fs32.readFile(outPath, "utf8");
+    raw = await fs33.readFile(outPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -16521,7 +16707,7 @@ function startPersistLoop(graph, outPath, opts = {}) {
 }
 // src/diff.ts
-import { promises as fs33 } from "fs";
+import { promises as fs34 } from "fs";
 async function loadSnapshotForDiff(target) {
   if (/^https?:\/\//i.test(target)) {
     const res = await fetch(target);
@@ -16530,7 +16716,7 @@ async function loadSnapshotForDiff(target) {
     }
     return await res.json();
   }
-  const raw = await fs33.readFile(target, "utf8");
+  const raw = await fs34.readFile(target, "utf8");
   return JSON.parse(raw);
 }
 function indexEntries(entries) {
@@ -16597,23 +16783,23 @@ function canonicalJson(value) {
 }
 // src/projects.ts
-import path68 from "path";
+import path69 from "path";
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: path68.join(baseDir, "graph.json"),
-      errorsPath: path68.join(baseDir, "errors.ndjson"),
-      staleEventsPath: path68.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: path68.join(baseDir, "embeddings.json"),
-      policyViolationsPath: path68.join(baseDir, "policy-violations.ndjson")
+      snapshotPath: path69.join(baseDir, "graph.json"),
+      errorsPath: path69.join(baseDir, "errors.ndjson"),
+      staleEventsPath: path69.join(baseDir, "stale-events.ndjson"),
+      embeddingsCachePath: path69.join(baseDir, "embeddings.json"),
+      policyViolationsPath: path69.join(baseDir, "policy-violations.ndjson")
     };
   }
   return {
-    snapshotPath: path68.join(baseDir, `${project}.json`),
-    errorsPath: path68.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: path68.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: path68.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: path68.join(baseDir, `policy-violations.${project}.ndjson`)
+    snapshotPath: path69.join(baseDir, `${project}.json`),
+    errorsPath: path69.join(baseDir, `errors.${project}.ndjson`),
+    staleEventsPath: path69.join(baseDir, `stale-events.${project}.ndjson`),
+    embeddingsCachePath: path69.join(baseDir, `embeddings.${project}.json`),
+    policyViolationsPath: path69.join(baseDir, `policy-violations.${project}.ndjson`)
   };
 }
 var Projects = class {
@@ -16652,9 +16838,9 @@ function parseExtraProjects(raw) {
 }
 // src/registry.ts
-import { promises as fs34 } from "fs";
+import { promises as fs35 } from "fs";
 import os2 from "os";
-import path69 from "path";
+import path70 from "path";
 import {
   RegistryFileSchema
 } from "@neat.is/types";
@@ -16662,20 +16848,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 path69.resolve(override);
-  return path69.join(os2.homedir(), ".neat");
+  if (override && override.length > 0) return path70.resolve(override);
+  return path70.join(os2.homedir(), ".neat");
 }
 function registryPath() {
-  return path69.join(neatHome(), "projects.json");
+  return path70.join(neatHome(), "projects.json");
 }
 function registryLockPath() {
-  return path69.join(neatHome(), "projects.json.lock");
+  return path70.join(neatHome(), "projects.json.lock");
 }
 function daemonPidPath() {
-  return path69.join(neatHome(), "neatd.pid");
+  return path70.join(neatHome(), "neatd.pid");
 }
 function daemonsDir() {
-  return path69.join(neatHome(), "daemons");
+  return path70.join(neatHome(), "daemons");
 }
 function isFiniteInt(v) {
   return typeof v === "number" && Number.isFinite(v);
@@ -16708,7 +16894,7 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const dir = daemonsDir();
   let names;
   try {
-    names = await fs34.readdir(dir);
+    names = await fs35.readdir(dir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -16716,10 +16902,10 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const out = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const file = path69.join(dir, name);
+    const file = path70.join(dir, name);
     let raw;
     try {
-      raw = await fs34.readFile(file, "utf8");
+      raw = await fs35.readFile(file, "utf8");
     } catch {
       continue;
     }
@@ -16732,7 +16918,7 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   return out;
 }
 async function removeDaemonRecord(source) {
-  await fs34.unlink(source).catch(() => {
+  await fs35.unlink(source).catch(() => {
   });
 }
 async function listMachineProjects(probe = defaultDiscoveryProbe) {
@@ -16789,7 +16975,7 @@ function isPidAliveDefault(pid) {
 }
 async function readPidFile(file) {
   try {
-    const raw = await fs34.readFile(file, "utf8");
+    const raw = await fs35.readFile(file, "utf8");
     const pid = Number.parseInt(raw.trim(), 10);
     return Number.isInteger(pid) && pid > 0 ? pid : void 0;
   } catch {
@@ -16815,14 +17001,12 @@ async function readLockPid(lockPath) {
 async function classifyLockHolder(lockPath, probe = defaultLockHolderProbe) {
   const lockPid = await readLockPid(lockPath);
   const daemonPid = await probe.daemonPidFromFile();
-  if (daemonPid !== void 0 && daemonPid !== process.pid && probe.isPidAlive(daemonPid) && // The lock already names the daemon, or the daemon answers on its port.
-  // Either confirms a live daemon is in the picture (the second guards
-  // against a stale pidfile whose PID got reused).
-  (daemonPid === lockPid || await probe.daemonResponds())) {
-    return { kind: "daemon", pid: daemonPid };
-  }
   if (lockPid !== void 0 && lockPid !== process.pid && probe.isPidAlive(lockPid)) {
-    return { kind: "command", pid: lockPid };
+    return { kind: lockPid === daemonPid ? "daemon" : "command", pid: lockPid };
+  }
+  if (daemonPid !== void 0 && daemonPid !== process.pid && probe.isPidAlive(daemonPid) && // Guards against a stale pidfile whose PID got reused.
+  await probe.daemonResponds()) {
+    return { kind: "daemon", pid: daemonPid };
   }
   return { kind: "stale" };
 }
@@ -16833,36 +17017,36 @@ function lockHolderMessage(holder, lockPath, timeoutMs) {
     case "command":
       return `Another neat command (pid ${holder.pid}) is holding the registry lock. Wait for it to finish, or check \`ps\` if you're not sure what's running.`;
     case "stale":
-      return `neat registry: timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`;
+      return `timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`;
   }
 }
 async function normalizeProjectPath(input) {
-  const resolved = path69.resolve(input);
+  const resolved = path70.resolve(input);
   try {
-    return await fs34.realpath(resolved);
+    return await fs35.realpath(resolved);
   } catch {
     return resolved;
   }
 }
 async function writeAtomically(target, contents) {
-  await fs34.mkdir(path69.dirname(target), { recursive: true });
+  await fs35.mkdir(path70.dirname(target), { recursive: true });
   const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await fs34.open(tmp, "w");
+  const fd = await fs35.open(tmp, "w");
   try {
     await fd.writeFile(contents, "utf8");
     await fd.sync();
   } finally {
     await fd.close();
   }
-  await fs34.rename(tmp, target);
+  await fs35.rename(tmp, target);
 }
 async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaultLockHolderProbe) {
   const deadline = Date.now() + timeoutMs;
-  await fs34.mkdir(path69.dirname(lockPath), { recursive: true });
+  await fs35.mkdir(path70.dirname(lockPath), { recursive: true });
   let probedHolder = false;
   while (true) {
     try {
-      const fd = await fs34.open(lockPath, "wx");
+      const fd = await fs35.open(lockPath, "wx");
       try {
         await fd.writeFile(`${process.pid}
 `, "utf8");
@@ -16876,18 +17060,36 @@ async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaul
       if (!probedHolder) {
         probedHolder = true;
         const holder = await classifyLockHolder(lockPath, probe);
-        if (holder.kind === "daemon") throw new Error(lockHolderMessage(holder, lockPath, timeoutMs));
+        if (holder.kind === "daemon") {
+          throw new RegistryLockError(lockHolderMessage(holder, lockPath, timeoutMs));
+        }
+        if (holder.kind === "stale" && await isReclaimableLock(lockPath)) {
+          await fs35.unlink(lockPath).catch(() => {
+          });
+          continue;
+        }
       }
       if (Date.now() >= deadline) {
         const holder = await classifyLockHolder(lockPath, probe);
-        throw new Error(lockHolderMessage(holder, lockPath, timeoutMs));
+        throw new RegistryLockError(lockHolderMessage(holder, lockPath, timeoutMs));
       }
       await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
     }
   }
 }
+var LOCK_UNSTAMPED_GRACE_MS = 5e3;
+async function isReclaimableLock(lockPath) {
+  const pid = await readLockPid(lockPath);
+  if (pid !== void 0) return true;
+  try {
+    const stat = await fs35.stat(lockPath);
+    return Date.now() - stat.mtimeMs > LOCK_UNSTAMPED_GRACE_MS;
+  } catch {
+    return false;
+  }
+}
 async function releaseLock(lockPath) {
-  await fs34.unlink(lockPath).catch(() => {
+  await fs35.unlink(lockPath).catch(() => {
   });
 }
 async function withLock(fn) {
@@ -16903,7 +17105,7 @@ async function readRegistry() {
   const file = registryPath();
   let raw;
   try {
-    raw = await fs34.readFile(file, "utf8");
+    raw = await fs35.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: 1, projects: [] };
@@ -16917,10 +17119,22 @@ async function writeRegistry(reg) {
   const validated = RegistryFileSchema.parse(reg);
   await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
 }
-var ProjectNameCollisionError = class extends Error {
+var RegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryError";
+  }
+};
+var RegistryLockError = class extends RegistryError {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryLockError";
+  }
+};
+var ProjectNameCollisionError = class extends RegistryError {
   projectName;
   constructor(name) {
-    super(`neat registry: a project named "${name}" is already registered`);
+    super(`a project named "${name}" is already registered`);
     this.name = "ProjectNameCollisionError";
     this.projectName = name;
   }
@@ -16961,6 +17175,16 @@ async function getProject(name) {
   const reg = await readRegistry();
   return reg.projects.find((p) => p.name === name);
 }
+async function findProjectByPath(dir) {
+  const here = await normalizeProjectPath(dir);
+  const { projects } = await readRegistry();
+  let best;
+  for (const entry of projects) {
+    const inside = here === entry.path || here.startsWith(entry.path + path70.sep);
+    if (inside && (!best || entry.path.length > best.path.length)) best = entry;
+  }
+  return best;
+}
 async function listProjects() {
   const reg = await readRegistry();
   return reg.projects;
@@ -16969,7 +17193,7 @@ async function setStatus(name, status) {
   return withLock(async () => {
     const reg = await readRegistry();
     const entry = reg.projects.find((p) => p.name === name);
-    if (!entry) throw new Error(`neat registry: no project named "${name}"`);
+    if (!entry) throw new RegistryError(`no project named "${name}"`);
     entry.status = status;
     await writeRegistry(reg);
     return entry;
@@ -17008,7 +17232,7 @@ function pruneTtlMs() {
 }
 async function statPathStatus(p) {
   try {
-    const stat = await fs34.stat(p);
+    const stat = await fs35.stat(p);
     return stat.isDirectory() ? "present" : "unknown";
   } catch (err) {
     return err.code === "ENOENT" ? "gone" : "unknown";
@@ -17053,14 +17277,14 @@ import cors from "@fastify/cors";
 import { DivergenceTypeSchema, PoliciesCheckBodySchema, PolicySeveritySchema } from "@neat.is/types";
 // src/extend/index.ts
-import { promises as fs36 } from "fs";
-import path71 from "path";
+import { promises as fs37 } from "fs";
+import path72 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 fs35 } from "fs";
-import path70 from "path";
+import { promises as fs36 } from "fs";
+import path71 from "path";
 import { spawn } from "child_process";
 var LOCKFILE_PRIORITY = [
   { lockfile: "bun.lockb", pm: "bun", args: ["install", "--no-summary"] },
@@ -17075,29 +17299,29 @@ var LOCKFILE_PRIORITY = [
 var NPM_FALLBACK_ARGS = ["install", "--no-audit", "--no-fund", "--prefer-offline"];
 async function exists2(p) {
   try {
-    await fs35.access(p);
+    await fs36.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function detectPackageManager(serviceDir) {
-  let dir = path70.resolve(serviceDir);
+  let dir = path71.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 = path70.join(dir, candidate.lockfile);
+      const lockPath = path71.join(dir, candidate.lockfile);
       if (await exists2(lockPath)) {
         return { pm: candidate.pm, cwd: dir, args: [...candidate.args] };
       }
     }
-    const parent = path70.dirname(dir);
+    const parent = path71.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return { pm: "npm", cwd: path70.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
+  return { pm: "npm", cwd: path71.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
 }
 async function runPackageManagerInstall(cmd) {
   return new Promise((resolve) => {
@@ -17139,15 +17363,15 @@ ${err.message}`
 // src/extend/index.ts
 async function fileExists2(p) {
   try {
-    await fs36.access(p);
+    await fs37.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function readPackageJson(scanPath) {
-  const pkgPath = path71.join(scanPath, "package.json");
-  const raw = await fs36.readFile(pkgPath, "utf8");
+  const pkgPath = path72.join(scanPath, "package.json");
+  const raw = await fs37.readFile(pkgPath, "utf8");
   return JSON.parse(raw);
 }
 var HOOK_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -17161,15 +17385,15 @@ var HOOK_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
 async function findHookFiles(scanPath) {
   const found = [];
   const walk11 = async (dir) => {
-    const entries = await fs36.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await fs37.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 walk11(path71.join(dir, entry.name));
+        await walk11(path72.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 = path71.relative(scanPath, path71.join(dir, entry.name));
-          found.push(rel.split(path71.sep).join("/"));
+          const rel = path72.relative(scanPath, path72.join(dir, entry.name));
+          found.push(rel.split(path72.sep).join("/"));
         }
       }
     }
@@ -17180,7 +17404,7 @@ async function findHookFiles(scanPath) {
 async function pickPrimaryHookFile(scanPath, hookFiles, snippet2) {
   let fallback = null;
   for (const file of hookFiles) {
-    const content = await fs36.readFile(path71.join(scanPath, file), "utf8");
+    const content = await fs37.readFile(path72.join(scanPath, file), "utf8");
     const patched = splicedContent(content, snippet2);
     if (patched !== null) return { file, content, patched };
     if (fallback === null) fallback = { file, content };
@@ -17188,12 +17412,12 @@ async function pickPrimaryHookFile(scanPath, hookFiles, snippet2) {
   return { file: fallback.file, content: fallback.content, patched: null };
 }
 function extendLogPath() {
-  return process.env.NEAT_EXTEND_LOG ?? path71.join(os3.homedir(), ".neat", "extend-log.ndjson");
+  return process.env.NEAT_EXTEND_LOG ?? path72.join(os3.homedir(), ".neat", "extend-log.ndjson");
 }
 async function appendExtendLog(entry) {
   const logPath = extendLogPath();
-  await fs36.mkdir(path71.dirname(logPath), { recursive: true });
-  await fs36.appendFile(logPath, JSON.stringify(entry) + "\n", "utf8");
+  await fs37.mkdir(path72.dirname(logPath), { recursive: true });
+  await fs37.appendFile(logPath, JSON.stringify(entry) + "\n", "utf8");
 }
 function splicedContent(fileContent, snippet2) {
   if (fileContent.includes("__INSTRUMENTATION_BLOCK__")) {
@@ -17251,7 +17475,7 @@ function lookupInstrumentation(library, installedVersion) {
 }
 async function describeProjectInstrumentation(ctx) {
   const hookFiles = await findHookFiles(ctx.scanPath);
-  const envNeat = await fileExists2(path71.join(ctx.scanPath, ".env.neat"));
+  const envNeat = await fileExists2(path72.join(ctx.scanPath, ".env.neat"));
   const registryInstrPackages = new Set(
     registryList().map((e) => e.instrumentation_package).filter((p) => !!p)
   );
@@ -17273,7 +17497,7 @@ async function applyExtension(ctx, args, options) {
     );
   }
   for (const file of hookFiles) {
-    const content = await fs36.readFile(path71.join(ctx.scanPath, file), "utf8");
+    const content = await fs37.readFile(path72.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return { library: args.library, filesTouched: [], depsAdded: [], installOutput: "", alreadyApplied: true };
     }
@@ -17285,18 +17509,18 @@ async function applyExtension(ctx, args, options) {
     );
   }
   const primaryFile = primary.file;
-  const primaryPath = path71.join(ctx.scanPath, primaryFile);
+  const primaryPath = path72.join(ctx.scanPath, primaryFile);
   const filesTouched = [];
   const depsAdded = [];
-  const pkgPath = path71.join(ctx.scanPath, "package.json");
+  const pkgPath = path72.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 fs36.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    await fs37.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     filesTouched.push("package.json");
     depsAdded.push(`${args.instrumentation_package}@${args.version}`);
   }
-  await fs36.writeFile(primaryPath, primary.patched, "utf8");
+  await fs37.writeFile(primaryPath, primary.patched, "utf8");
   filesTouched.push(primaryFile);
   const cmd = await detectPackageManager(ctx.scanPath);
   const installer = options?.runInstall ?? runPackageManagerInstall;
@@ -17327,7 +17551,7 @@ async function dryRunExtension(ctx, args) {
     };
   }
   for (const file of hookFiles) {
-    const content = await fs36.readFile(path71.join(ctx.scanPath, file), "utf8");
+    const content = await fs37.readFile(path72.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return {
         library: args.library,
@@ -17362,28 +17586,28 @@ async function rollbackExtension(ctx, args) {
   if (!await fileExists2(logPath)) {
     return { undone: false, message: "no apply found for library" };
   }
-  const raw = await fs36.readFile(logPath, "utf8");
+  const raw = await fs37.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 = path71.join(ctx.scanPath, "package.json");
+  const pkgPath = path72.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 fs36.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+      await fs37.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     }
   }
   const hookFiles = await findHookFiles(ctx.scanPath);
   for (const file of hookFiles) {
-    const filePath = path71.join(ctx.scanPath, file);
-    const content = await fs36.readFile(filePath, "utf8");
+    const filePath = path72.join(ctx.scanPath, file);
+    const content = await fs37.readFile(filePath, "utf8");
     if (content.includes(match.registration_snippet)) {
       const filtered = content.split("\n").filter((line) => !line.includes(match.registration_snippet)).join("\n");
-      await fs36.writeFile(filePath, filtered, "utf8");
+      await fs37.writeFile(filePath, filtered, "utf8");
       break;
     }
   }
@@ -18399,8 +18623,8 @@ data: ${JSON.stringify(envelope.payload)}
 // src/connectors-config.ts
 import os4 from "os";
-import path72 from "path";
-import { promises as fs37 } from "fs";
+import path73 from "path";
+import { promises as fs38 } from "fs";
 var CONNECTORS_CONFIG_VERSION = 1;
 var EnvRefUnsetError = class extends Error {
   ref;
@@ -18414,17 +18638,17 @@ var EnvRefUnsetError = class extends Error {
 };
 function neatHome2() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return path72.resolve(override);
-  return path72.join(os4.homedir(), ".neat");
+  if (override && override.length > 0) return path73.resolve(override);
+  return path73.join(os4.homedir(), ".neat");
 }
 function connectorsConfigPath(home = neatHome2()) {
-  return path72.join(home, "connectors.json");
+  return path73.join(home, "connectors.json");
 }
 var MODE_MASK_LOOSER_THAN_0600 = 63;
 async function warnIfModeLooserThan0600(file) {
   if (process.platform === "win32") return;
   try {
-    const stat = await fs37.stat(file);
+    const stat = await fs38.stat(file);
     if ((stat.mode & MODE_MASK_LOOSER_THAN_0600) !== 0) {
       const mode = (stat.mode & 511).toString(8).padStart(3, "0");
       console.warn(
@@ -18438,7 +18662,7 @@ async function readConnectorsConfig(home = neatHome2()) {
   const file = connectorsConfigPath(home);
   let raw;
   try {
-    raw = await fs37.readFile(file, "utf8");
+    raw = await fs38.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: CONNECTORS_CONFIG_VERSION, connectors: [] };
@@ -18549,7 +18773,7 @@ function connectorMatchesProject(entry, project) {
 var CONNECTORS_LOCK_TIMEOUT_MS = 5e3;
 var CONNECTORS_LOCK_RETRY_MS = 50;
 function connectorsConfigLockPath(home = neatHome2()) {
-  return path72.join(home, "connectors.json.lock");
+  return path73.join(home, "connectors.json.lock");
 }
 function isEnvRef(value) {
   return value.length > 1 && value.startsWith("$");
@@ -18562,9 +18786,9 @@ function redactCredentialRef(ref) {
   return out;
 }
 async function writeConfigAtomically0600(file, contents) {
-  await fs37.mkdir(path72.dirname(file), { recursive: true });
+  await fs38.mkdir(path73.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await fs37.open(tmp, "w", 384);
+  const fd = await fs38.open(tmp, "w", 384);
   try {
     await fd.writeFile(contents, "utf8");
     await fd.chmod(384);
@@ -18572,14 +18796,14 @@ async function writeConfigAtomically0600(file, contents) {
   } finally {
     await fd.close();
   }
-  await fs37.rename(tmp, file);
+  await fs38.rename(tmp, file);
 }
 async function acquireConnectorsLock(lockPath, timeoutMs = CONNECTORS_LOCK_TIMEOUT_MS) {
   const deadline = Date.now() + timeoutMs;
-  await fs37.mkdir(path72.dirname(lockPath), { recursive: true });
+  await fs38.mkdir(path73.dirname(lockPath), { recursive: true });
   for (; ; ) {
     try {
-      const fd = await fs37.open(lockPath, "wx");
+      const fd = await fs38.open(lockPath, "wx");
       try {
         await fd.writeFile(`${process.pid}
 `, "utf8");
@@ -18599,7 +18823,7 @@ async function acquireConnectorsLock(lockPath, timeoutMs = CONNECTORS_LOCK_TIMEO
   }
 }
 async function releaseConnectorsLock(lockPath) {
-  await fs37.unlink(lockPath).catch(() => {
+  await fs38.unlink(lockPath).catch(() => {
   });
 }
 async function withConnectorsLock(home, fn) {
@@ -19339,10 +19563,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(path73) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path73);
+function targetFromRestPath(path74) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path74);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path73);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path74);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -19937,9 +20161,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path73 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path73) return null;
-  return { resourceName, method, path: path73 };
+  const path74 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path74) return null;
+  return { resourceName, method, path: path74 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -19977,14 +20201,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 path73 = pathFromRequestUrl(req.requestUrl);
-  if (path73 === null) return null;
+  const path74 = pathFromRequestUrl(req.requestUrl);
+  if (path74 === 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: path73 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path74 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -20007,9 +20231,9 @@ import { NodeType as NodeType35 } from "@neat.is/types";
 function normalizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function inferServiceName(graph, resourceName, method, path73) {
+function inferServiceName(graph, resourceName, method, path74) {
   const wantedMethod = method.toUpperCase();
-  const wantedPath = normalizePathTemplate(path73);
+  const wantedPath = normalizePathTemplate(path74);
   const services = [];
   const owners = /* @__PURE__ */ new Set();
   graph.forEachNode((_id, attrs) => {
@@ -20217,7 +20441,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 path73 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path74 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -20225,7 +20449,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path73 ? { path: path73 } : {},
+    ...path74 ? { path: path74 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -20271,8 +20495,8 @@ function findTaggedWorkerFileNode(graph, workerName) {
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path73) {
-  const normalizedPath = normalizePathTemplate(path73);
+function findMatchingRouteNode(graph, serviceName, method, path74) {
+  const normalizedPath = normalizePathTemplate(path74);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
@@ -20289,10 +20513,10 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path73 } = signal;
+    const { method, path: path74 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path73) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path73) ?? wholeFileId;
+      if (!method || !path74) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path74) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
@@ -20622,9 +20846,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path73 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path73) return null;
-  return { serviceName, method, path: path73 };
+  const path74 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path74) return null;
+  return { serviceName, method, path: path74 };
 }
 // src/connectors/cloud-run/map.ts
@@ -20653,14 +20877,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 path73 = pathFromRequestUrl2(req.requestUrl);
-  if (path73 === null) return null;
+  const path74 = pathFromRequestUrl2(req.requestUrl);
+  if (path74 === 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: path73 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path74 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -20698,14 +20922,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: path73 } = identity;
-    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path73) ?? void 0 : void 0);
+    const { serviceName: gcpServiceName, method, path: path74 } = identity;
+    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path74) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path73)
+        normalizePathTemplate(path74)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: EdgeType32.CALLS };
@@ -20833,9 +21057,9 @@ function parseGcpLbTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP3);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path73 = rest.slice(secondSep + 1);
-  if (!backendServiceName || !method || !path73) return null;
-  return { backendServiceName, method, path: path73 };
+  const path74 = rest.slice(secondSep + 1);
+  if (!backendServiceName || !method || !path74) return null;
+  return { backendServiceName, method, path: path74 };
 }
 // src/connectors/gcp-lb/map.ts
@@ -20864,14 +21088,14 @@ function mapLogEntryToSignal3(entry) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path73 = pathFromRequestUrl3(req.requestUrl);
-  if (path73 === null) return null;
+  const path74 = pathFromRequestUrl3(req.requestUrl);
+  if (path74 === 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_THRESHOLD5;
   return {
     targetKind: GCP_LB_TARGET_KIND,
-    targetName: packGcpLbTargetName({ backendServiceName, method, path: path73 }),
+    targetName: packGcpLbTargetName({ backendServiceName, method, path: path74 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -20909,14 +21133,14 @@ function createGcpLbResolveTarget(graph, config) {
     if (signal.targetKind !== GCP_LB_TARGET_KIND) return null;
     const identity = parseGcpLbTargetName(signal.targetName);
     if (!identity) return null;
-    const { backendServiceName, method, path: path73 } = identity;
-    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path73) ?? void 0 : void 0);
+    const { backendServiceName, method, path: path74 } = identity;
+    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path74) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode3(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path73)
+        normalizePathTemplate(path74)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: EdgeType33.CALLS };
@@ -22300,16 +22524,18 @@ function serializeGraph(graph) {
   });
   return { nodes, edges };
 }
-function projectFromReq(req, singleProject) {
+function projectFromReq(req, singleProject, registry) {
   const params = req.params;
   const named = params.project;
   if (singleProject) {
     return named === void 0 || named === DEFAULT_PROJECT ? singleProject : named;
   }
-  return named ?? DEFAULT_PROJECT;
+  if (named !== void 0) return named;
+  const hosted = registry?.list() ?? [];
+  return hosted.length === 1 ? hosted[0] : DEFAULT_PROJECT;
 }
 function resolveProject(registry, req, reply, bootstrap, singleProject) {
-  const name = projectFromReq(req, singleProject);
+  const name = projectFromReq(req, singleProject, registry);
   const ctx = registry.get(name);
   if (!ctx) {
     const phase = bootstrap?.status(name);
@@ -22321,10 +22547,13 @@ function resolveProject(registry, req, reply, bootstrap, singleProject) {
       void reply.code(503).send({ ready: false, project: name, status: "broken" });
       return null;
     }
+    const unnamed = req.params.project === void 0;
+    const hosted = registry.list();
+    const hint = unnamed && name === DEFAULT_PROJECT && hosted.length > 1 ? `This daemon hosts ${hosted.length} projects and none is named \`default\`: ${hosted.join(", ")}. Name one as /projects/<name>/\u2026 , or reach that project's own daemon.` : "This daemon does not host that project. GET /projects lists what it serves (see hostedHere).";
     void reply.code(404).send({
       error: "project not found",
       project: name,
-      hint: "This daemon does not host that project. GET /projects lists what it serves (see hostedHere)."
+      hint
     });
     return null;
   }
@@ -23221,6 +23450,7 @@ export {
   PolicyViolationsLog,
   isStrictExtractionEnabled,
   formatExtractionBanner,
+  formatSkippedBanner,
   formatPrecisionFloorBanner,
   addImports,
   addRoutes,
@@ -23269,9 +23499,11 @@ export {
   normalizeProjectPath,
   writeAtomically,
   readRegistry,
+  RegistryError,
   ProjectNameCollisionError,
   addProject,
   getProject,
+  findProjectByPath,
   listProjects,
   setStatus,
   touchLastSeen,
@@ -23298,4 +23530,4 @@ export {
   deprovisionConnector,
   buildApi
 };
-//# sourceMappingURL=chunk-E3YFFIHE.js.map
+//# sourceMappingURL=chunk-LNIVRE4L.js.map