@neat.is/core 0.10.1-dev.20260928 → 0.10.2

package/dist/server.cjs

@@ -59,8 +59,8 @@ function mountBearerAuth(app, opts) {
   ]);
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path77 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
-    if (exactUnauthPaths.has(path77) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path77)) {
+    const path78 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    if (exactUnauthPaths.has(path78) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path78)) {
       done();
       return;
     }
@@ -192,8 +192,8 @@ function reshapeGrpcRequest(req) {
   };
 }
 function resolveProtoRoot() {
-  const here = import_node_path55.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return import_node_path55.default.resolve(here, "..", "proto");
+  const here = import_node_path56.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return import_node_path56.default.resolve(here, "..", "proto");
 }
 function loadTraceService() {
   const protoRoot = resolveProtoRoot();
@@ -261,13 +261,13 @@ async function startOtelGrpcReceiver(opts) {
     })
   };
 }
-var import_node_url, import_node_path55, import_node_crypto2, grpc, protoLoader;
+var import_node_url, import_node_path56, import_node_crypto2, grpc, protoLoader;
 var init_otel_grpc = __esm({
   "src/otel-grpc.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_url = require("url");
-    import_node_path55 = __toESM(require("path"), 1);
+    import_node_path56 = __toESM(require("path"), 1);
     import_node_crypto2 = require("crypto");
     grpc = __toESM(require("@grpc/grpc-js"), 1);
     protoLoader = __toESM(require("@grpc/proto-loader"), 1);
@@ -413,8 +413,8 @@ function websocketChannelPathOf(attrs) {
     const v = attrs[key];
     if (typeof v === "string" && v.length > 0) {
       const q = v.indexOf("?");
-      const path77 = q === -1 ? v : v.slice(0, q);
-      if (path77.length > 0) return path77;
+      const path78 = q === -1 ? v : v.slice(0, q);
+      if (path78.length > 0) return path78;
     }
   }
   return void 0;
@@ -476,10 +476,10 @@ function parseOtlpRequest(body) {
   return out;
 }
 function loadProtoRoot() {
-  const here = import_node_path56.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  const protoRoot = import_node_path56.default.resolve(here, "..", "proto");
+  const here = import_node_path57.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  const protoRoot = import_node_path57.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
-  root.resolvePath = (_origin, target) => import_node_path56.default.resolve(protoRoot, target);
+  root.resolvePath = (_origin, target) => import_node_path57.default.resolve(protoRoot, target);
   root.loadSync(
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
@@ -741,12 +741,12 @@ async function buildOtelReceiver(opts) {
   };
   return decorated;
 }
-var import_node_path56, import_node_url2, import_node_zlib, import_fastify, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
+var import_node_path57, import_node_url2, import_node_zlib, import_fastify, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path56 = __toESM(require("path"), 1);
+    import_node_path57 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     import_node_zlib = __toESM(require("zlib"), 1);
     import_fastify = __toESM(require("fastify"), 1);
@@ -763,7 +763,7 @@ var init_otel = __esm({
 
 // src/server.ts
 init_cjs_shims();
-var import_node_path76 = __toESM(require("path"), 1);
+var import_node_path77 = __toESM(require("path"), 1);
 
 // src/graph.ts
 init_cjs_shims();
@@ -1505,8 +1505,8 @@ init_cjs_shims();
 
 // src/ingest.ts
 init_cjs_shims();
-var import_node_fs9 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
+var import_node_path11 = __toESM(require("path"), 1);
 var sourceMapJs = __toESM(require("source-map-js"), 1);
 
 // src/policy.ts
@@ -2032,7 +2032,7 @@ var import_types7 = require("@neat.is/types");
 
 // src/extract/routes.ts
 init_cjs_shims();
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_tree_sitter2 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript2 = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_python2 = __toESM(require("tree-sitter-python"), 1);
@@ -2058,6 +2058,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
@@ -2289,6 +2300,15 @@ 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 isRejectedLogEnabled() {
   const raw = process.env.NEAT_EXTRACTED_REJECTED_LOG;
   return raw === "1" || raw === "true";
@@ -2302,14 +2322,91 @@ async function writeRejectedExtracted(drops, rejectedPath) {
 
 // src/extract/calls/shared.ts
 init_cjs_shims();
+var import_node_fs8 = require("fs");
+var import_node_path8 = __toESM(require("path"), 1);
+var import_types4 = require("@neat.is/types");
+
+// src/extract/gitignore.ts
+init_cjs_shims();
 var import_node_fs7 = require("fs");
 var import_node_path7 = __toESM(require("path"), 1);
-var import_types4 = require("@neat.is/types");
+var import_ignore = __toESM(require("ignore"), 1);
+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 import_node_fs7.promises.readFile(import_node_path7.default.join(dir, ".gitignore"), "utf8");
+    layer = { dir, ig: (0, import_ignore.default)().add(raw) };
+  } catch {
+    layer = null;
+  }
+  LAYER_CACHE.set(dir, layer);
+  return layer;
+}
+async function isRepoRoot(dir) {
+  try {
+    await import_node_fs7.promises.stat(import_node_path7.default.join(dir, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadIgnoreChain(startDir) {
+  const dirs = [];
+  let current = import_node_path7.default.resolve(startDir);
+  for (; ; ) {
+    dirs.push(current);
+    if (await isRepoRoot(current)) break;
+    const parent = import_node_path7.default.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(import_node_path7.default.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 = import_node_path7.default.resolve(fullPath);
+  let ignored = false;
+  let unignoredAt = -1;
+  for (let i = 0; i < chain.length; i++) {
+    const layer = chain[i];
+    const rel = import_node_path7.default.relative(layer.dir, abs);
+    if (!rel || rel.startsWith("..") || import_node_path7.default.isAbsolute(rel)) continue;
+    const candidate = rel.split(import_node_path7.default.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 = import_node_path7.default.basename(service.dir);
+    const base = import_node_path8.default.basename(service.dir);
     knownHosts.add(base);
     knownHosts.add(service.pkg.name);
     hostToNodeId.set(base, service.node.id);
@@ -2318,33 +2415,62 @@ function buildServiceHostIndex(services) {
   return { knownHosts, hostToNodeId };
 }
 async function walkSourceFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => import_node_path7.default.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => import_node_path8.default.resolve(d)));
   const out = [];
-  async function walk11(current) {
-    const entries = await import_node_fs7.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+  const rootChain = await loadIgnoreChain(dir);
+  async function walk11(current, inherited) {
+    const entries = await import_node_fs8.promises.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 = import_node_path7.default.join(current, entry.name);
+      const full = import_node_path8.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(import_node_path7.default.resolve(full))) continue;
+        if (excluded.has(import_node_path8.default.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(import_node_path7.default.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(import_node_path8.default.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) => import_node_path8.default.resolve(l.dir) !== import_node_path8.default.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 import_node_fs7.promises.readFile(p, "utf8");
+      const content = await import_node_fs8.promises.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 {
     }
@@ -2356,15 +2482,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 (import_node_path7.default.extname(relPath).toLowerCase()) {
+  switch (import_node_path8.default.extname(relPath).toLowerCase()) {
     case ".py":
       return "python";
     case ".go":
@@ -2438,8 +2567,8 @@ function ensureFileNode(graph, serviceName, serviceNodeId, relPath) {
 
 // src/extract/imports.ts
 init_cjs_shims();
-var import_node_path8 = __toESM(require("path"), 1);
-var import_node_fs8 = require("fs");
+var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
 var import_tree_sitter = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_python = __toESM(require("tree-sitter-python"), 1);
@@ -2584,15 +2713,15 @@ function collectPyImports(node, out) {
 }
 async function fileExists2(p) {
   try {
-    await import_node_fs8.promises.access(p);
+    await import_node_fs9.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 function isWithinServiceDir(candidate, serviceDir) {
-  const rel = import_node_path8.default.relative(serviceDir, candidate);
-  return rel !== "" && !rel.startsWith("..") && !import_node_path8.default.isAbsolute(rel);
+  const rel = import_node_path9.default.relative(serviceDir, candidate);
+  return rel !== "" && !rel.startsWith("..") && !import_node_path9.default.isAbsolute(rel);
 }
 var JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 var JS_INDEX_FILES = JS_EXTENSIONS.map((ext) => `index${ext}`);
@@ -2600,22 +2729,22 @@ async function firstExistingCandidate(base, serviceDir) {
   for (const ext of JS_EXTENSIONS) {
     const candidate = base + ext;
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists2(candidate)) {
-      return toPosix(import_node_path8.default.relative(serviceDir, candidate));
+      return toPosix(import_node_path9.default.relative(serviceDir, candidate));
     }
   }
   for (const indexFile of JS_INDEX_FILES) {
-    const candidate = import_node_path8.default.join(base, indexFile);
+    const candidate = import_node_path9.default.join(base, indexFile);
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists2(candidate)) {
-      return toPosix(import_node_path8.default.relative(serviceDir, candidate));
+      return toPosix(import_node_path9.default.relative(serviceDir, candidate));
     }
   }
   return null;
 }
 async function loadTsPathConfig(serviceDir) {
-  const tsconfigPath = import_node_path8.default.join(serviceDir, "tsconfig.json");
+  const tsconfigPath = import_node_path9.default.join(serviceDir, "tsconfig.json");
   let raw;
   try {
-    raw = await import_node_fs8.promises.readFile(tsconfigPath, "utf8");
+    raw = await import_node_fs9.promises.readFile(tsconfigPath, "utf8");
   } catch {
     return null;
   }
@@ -2624,7 +2753,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 ? import_node_path8.default.resolve(serviceDir, baseUrl) : serviceDir };
+    return { paths, baseDir: baseUrl ? import_node_path9.default.resolve(serviceDir, baseUrl) : serviceDir };
   } catch (err) {
     recordExtractionError("import alias resolution", tsconfigPath, err);
     return null;
@@ -2642,11 +2771,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 = import_node_path8.default.resolve(config.baseDir, targetBase, suffix);
+      const resolvedBase = import_node_path9.default.resolve(config.baseDir, targetBase, suffix);
       const hit = await firstExistingCandidate(resolvedBase, serviceDir);
       if (hit) return hit;
       if (isWithinServiceDir(resolvedBase, serviceDir) && await fileExists2(resolvedBase)) {
-        return toPosix(import_node_path8.default.relative(serviceDir, resolvedBase));
+        return toPosix(import_node_path9.default.relative(serviceDir, resolvedBase));
       }
     }
   }
@@ -2655,18 +2784,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 = import_node_path8.default.resolve(importerDir, specifier);
-    const ext = import_node_path8.default.extname(specifier);
+    const base = import_node_path9.default.resolve(importerDir, specifier);
+    const ext = import_node_path9.default.extname(specifier);
     if (ext) {
       if (ext === ".js" || ext === ".jsx") {
         const tsExt = ext === ".jsx" ? ".tsx" : ".ts";
         const tsSibling = base.slice(0, -ext.length) + tsExt;
         if (isWithinServiceDir(tsSibling, serviceDir) && await fileExists2(tsSibling)) {
-          return toPosix(import_node_path8.default.relative(serviceDir, tsSibling));
+          return toPosix(import_node_path9.default.relative(serviceDir, tsSibling));
         }
       }
       if (isWithinServiceDir(base, serviceDir) && await fileExists2(base)) {
-        return toPosix(import_node_path8.default.relative(serviceDir, base));
+        return toPosix(import_node_path9.default.relative(serviceDir, base));
       }
       if (!JS_EXTENSIONS.includes(ext)) {
         return firstExistingCandidate(base, serviceDir);
@@ -2681,30 +2810,30 @@ async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
 async function resolvePyImport(imp, importerPath, serviceDir) {
   let baseDir;
   if (imp.level > 0) {
-    baseDir = import_node_path8.default.dirname(importerPath);
-    for (let i = 1; i < imp.level; i++) baseDir = import_node_path8.default.dirname(baseDir);
+    baseDir = import_node_path9.default.dirname(importerPath);
+    for (let i = 1; i < imp.level; i++) baseDir = import_node_path9.default.dirname(baseDir);
   } else {
     baseDir = serviceDir;
   }
-  const moduleBase = imp.modulePath ? import_node_path8.default.join(baseDir, imp.modulePath.split(".").join("/")) : baseDir;
+  const moduleBase = imp.modulePath ? import_node_path9.default.join(baseDir, imp.modulePath.split(".").join("/")) : baseDir;
   const resolved = /* @__PURE__ */ new Set();
   let needModuleFile = imp.names.length === 0;
   for (const name of imp.names) {
-    const submoduleFile = import_node_path8.default.join(moduleBase, `${name}.py`);
-    const subpackageInit = import_node_path8.default.join(moduleBase, name, "__init__.py");
+    const submoduleFile = import_node_path9.default.join(moduleBase, `${name}.py`);
+    const subpackageInit = import_node_path9.default.join(moduleBase, name, "__init__.py");
     if (isWithinServiceDir(submoduleFile, serviceDir) && await fileExists2(submoduleFile)) {
-      resolved.add(toPosix(import_node_path8.default.relative(serviceDir, submoduleFile)));
+      resolved.add(toPosix(import_node_path9.default.relative(serviceDir, submoduleFile)));
     } else if (isWithinServiceDir(subpackageInit, serviceDir) && await fileExists2(subpackageInit)) {
-      resolved.add(toPosix(import_node_path8.default.relative(serviceDir, subpackageInit)));
+      resolved.add(toPosix(import_node_path9.default.relative(serviceDir, subpackageInit)));
     } else {
       needModuleFile = true;
     }
   }
   if (needModuleFile) {
-    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, import_node_path8.default.join(moduleBase, "__init__.py")] : [import_node_path8.default.join(moduleBase, "__init__.py")];
+    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, import_node_path9.default.join(moduleBase, "__init__.py")] : [import_node_path9.default.join(moduleBase, "__init__.py")];
     for (const candidate of moduleFileCandidates) {
       if (isWithinServiceDir(candidate, serviceDir) && await fileExists2(candidate)) {
-        resolved.add(toPosix(import_node_path8.default.relative(serviceDir, candidate)));
+        resolved.add(toPosix(import_node_path9.default.relative(serviceDir, candidate)));
         break;
       }
     }
@@ -2714,11 +2843,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 = import_node_path8.default.join(serviceDir, suffix);
-  const entries = await import_node_fs8.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
-  const candidates = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".go") && !entry.name.endsWith("_test.go")).map((entry) => import_node_path8.default.join(dir, entry.name));
+  const dir = import_node_path9.default.join(serviceDir, suffix);
+  const entries = await import_node_fs9.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const candidates = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".go") && !entry.name.endsWith("_test.go")).map((entry) => import_node_path9.default.join(dir, entry.name));
   if (candidates.length !== 1) return null;
-  return toPosix(import_node_path8.default.relative(serviceDir, candidates[0]));
+  return toPosix(import_node_path9.default.relative(serviceDir, candidates[0]));
 }
 function emitImportEdge(graph, serviceName, importerFileId, importerRelPath, importeeRelPath, line, snippet2) {
   const importeeFileId = (0, import_types5.fileId)(serviceName, importeeRelPath);
@@ -2748,12 +2877,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(import_node_path8.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path9.default.relative(service.dir, file.path));
       const importerFileId = (0, import_types5.fileId)(service.pkg.name, relFile);
-      const isPython = import_node_path8.default.extname(file.path) === ".py";
-      const isGo = import_node_path8.default.extname(file.path) === ".go";
-      if (import_node_path8.default.extname(file.path) === ".rb") continue;
-      if (import_node_path8.default.extname(file.path) === ".php") continue;
+      const isPython = import_node_path9.default.extname(file.path) === ".py";
+      const isGo = import_node_path9.default.extname(file.path) === ".go";
+      if (import_node_path9.default.extname(file.path) === ".rb") continue;
+      if (import_node_path9.default.extname(file.path) === ".php") continue;
       if (isGo) {
         let goImports = [];
         try {
@@ -2763,7 +2892,7 @@ async function addImports(graph, services) {
           recordExtractionError("import extraction", file.path, err);
           continue;
         }
-        const goMod = await import_node_fs8.promises.readFile(import_node_path8.default.join(service.dir, "go.mod"), "utf8").catch(() => "");
+        const goMod = await import_node_fs9.promises.readFile(import_node_path9.default.join(service.dir, "go.mod"), "utf8").catch(() => "");
         const modulePath = goMod.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
         if (!modulePath) continue;
         for (const imp of goImports) {
@@ -2807,7 +2936,7 @@ async function addImports(graph, services) {
         continue;
       }
       for (const imp of jsImports) {
-        const resolved = await resolveJsImport(imp.specifier, import_node_path8.default.dirname(file.path), service.dir, tsPaths);
+        const resolved = await resolveJsImport(imp.specifier, import_node_path9.default.dirname(file.path), service.dir, tsPaths);
         if (!resolved) continue;
         edgesAdded += emitImportEdge(
           graph,
@@ -2932,8 +3061,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path77) {
-  return path77.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path78) {
+  return path78.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -3273,7 +3402,7 @@ function isNextPagesApiFile(relFile) {
   if (pagesIdx === -1 || segs[pagesIdx + 1] !== "api") return false;
   const base = segs[segs.length - 1] ?? "";
   if (/^_(app|document|middleware)\./.test(base)) return false;
-  return JS_ROUTE_EXTENSIONS.has(import_node_path9.default.extname(base));
+  return JS_ROUTE_EXTENSIONS.has(import_node_path10.default.extname(base));
 }
 function nextSegment(seg) {
   if (seg.startsWith("(") && seg.endsWith(")")) return null;
@@ -3605,9 +3734,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path77 = rubyLiteral(k);
-    if (path77 === null) continue;
-    return { path: path77, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path78 = rubyLiteral(k);
+    if (path78 === null) continue;
+    return { path: path78, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -4455,12 +4584,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(import_node_path9.default.extname(f.path))) continue;
+    if (!JS_ROUTE_EXTENSIONS.has(import_node_path10.default.extname(f.path))) continue;
     if (isTestPath(f.path)) continue;
-    const rel = toPosix(import_node_path9.default.relative(serviceDir, f.path));
+    const rel = toPosix(import_node_path10.default.relative(serviceDir, f.path));
     try {
       const tree = parseSource2(jsParser, f.content);
-      fileInfo.set(rel, analyzeExpressFile(tree.rootNode, import_node_path9.default.dirname(f.path)));
+      fileInfo.set(rel, analyzeExpressFile(tree.rootNode, import_node_path10.default.dirname(f.path)));
     } catch {
     }
   }
@@ -4559,14 +4688,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 = import_node_path9.default.extname(file.path);
+      const ext = import_node_path10.default.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(import_node_path9.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path10.default.relative(service.dir, file.path));
       let routes;
       try {
         if (isPhp) {
@@ -5023,7 +5152,7 @@ function languageForExt(relPath) {
 function relPathForRuntimeFile(filepath, serviceNode, scanPath) {
   let p = toPosix2(filepath).replace(/^file:\/\//, "");
   if (scanPath && scanPath.length > 0) {
-    const absRoot = toPosix2(import_node_path10.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
+    const absRoot = toPosix2(import_node_path11.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
     const anchor = absRoot.endsWith("/") ? absRoot : `${absRoot}/`;
     if (p.startsWith(anchor)) return p.slice(anchor.length);
   }
@@ -5051,10 +5180,10 @@ function resolveDistToSrc(absFilepath, line) {
     entry = null;
     const mapPath = `${absFilepath}.map`;
     try {
-      if ((0, import_node_fs9.existsSync)(mapPath)) {
-        const raw = JSON.parse((0, import_node_fs9.readFileSync)(mapPath, "utf8"));
+      if ((0, import_node_fs10.existsSync)(mapPath)) {
+        const raw = JSON.parse((0, import_node_fs10.readFileSync)(mapPath, "utf8"));
         const consumer = new sourceMapJs.SourceMapConsumer(raw);
-        entry = { consumer, dir: import_node_path10.default.dirname(mapPath) };
+        entry = { consumer, dir: import_node_path11.default.dirname(mapPath) };
       }
     } catch {
       entry = null;
@@ -5074,7 +5203,7 @@ function resolveDistToSrc(absFilepath, line) {
     }
     if (!pos || !pos.source) return null;
     const root = entry.consumer.sourceRoot ?? "";
-    const resolved = import_node_path10.default.resolve(entry.dir, root, pos.source);
+    const resolved = import_node_path11.default.resolve(entry.dir, root, pos.source);
     return { filepath: resolved, ...pos.line ? { line: pos.line } : {} };
   } catch {
     return null;
@@ -5618,8 +5747,8 @@ function emitIncidentEvent(project, ev) {
   });
 }
 async function appendErrorEvent(ctx, ev) {
-  await import_node_fs9.promises.mkdir(import_node_path10.default.dirname(ctx.errorsPath), { recursive: true });
-  await import_node_fs9.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  await import_node_fs10.promises.mkdir(import_node_path11.default.dirname(ctx.errorsPath), { recursive: true });
+  await import_node_fs10.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
   emitIncidentEvent(ctx.project ?? DEFAULT_PROJECT, ev);
 }
 async function appendConnectorIncident(errorsPath, input, project) {
@@ -5634,8 +5763,8 @@ async function appendConnectorIncident(errorsPath, input, project) {
     ...input.attributes && Object.keys(input.attributes).length > 0 ? { attributes: input.attributes } : {},
     affectedNode: input.affectedNode
   };
-  await import_node_fs9.promises.mkdir(import_node_path10.default.dirname(errorsPath), { recursive: true });
-  await import_node_fs9.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  await import_node_fs10.promises.mkdir(import_node_path11.default.dirname(errorsPath), { recursive: true });
+  await import_node_fs10.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
   if (project) emitIncidentEvent(project, ev);
 }
 function landIncidentCallSite(span, callSite, trusted, graph) {
@@ -6226,13 +6355,13 @@ async function markStaleEdges(graph, options = {}) {
   return { count: events.length, events };
 }
 async function appendStaleEvents(staleEventsPath, events) {
-  await import_node_fs9.promises.mkdir(import_node_path10.default.dirname(staleEventsPath), { recursive: true });
+  await import_node_fs10.promises.mkdir(import_node_path11.default.dirname(staleEventsPath), { recursive: true });
   const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await import_node_fs9.promises.appendFile(staleEventsPath, lines, "utf8");
+  await import_node_fs10.promises.appendFile(staleEventsPath, lines, "utf8");
 }
 async function readStaleEvents(staleEventsPath) {
   try {
-    const raw = await import_node_fs9.promises.readFile(staleEventsPath, "utf8");
+    const raw = await import_node_fs10.promises.readFile(staleEventsPath, "utf8");
     return raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
   } catch (err) {
     if (err.code === "ENOENT") return [];
@@ -6268,7 +6397,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 import_node_fs9.promises.open(errorsPath, "r");
+  const handle = await import_node_fs10.promises.open(errorsPath, "r");
   try {
     const { size } = await handle.stat();
     if (size <= maxBytes) {
@@ -6511,19 +6640,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, path77, edges) {
-    if (path77.length > best.path.length) {
-      best = { path: [...path77], edges: [...edges] };
+  function step(node, path78, edges) {
+    if (path78.length > best.path.length) {
+      best = { path: [...path78], edges: [...edges] };
     }
-    if (path77.length - 1 >= maxDepth) return;
+    if (path78.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);
-      path77.push(srcId);
+      path78.push(srcId);
       edges.push(edge);
-      step(srcId, path77, edges);
-      path77.pop();
+      step(srcId, path78, edges);
+      path78.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -6738,20 +6867,20 @@ function dominantFailingCall(graph, serviceId17, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path77 = [originServiceId];
+  const path78 = [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;
-    path77.push(hop.nextService);
+    path78.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path77, edges, culprit: current };
+  return { path: path78, edges, culprit: current };
 }
 function isStaleCallEdge(e) {
   return e.type === import_types8.EdgeType.CALLS && e.provenance === import_types8.Provenance.STALE;
@@ -6787,26 +6916,26 @@ function dominantStaleCall(graph, serviceId17, visited) {
   return best;
 }
 function followStaleCallChain(graph, originServiceId, maxDepth) {
-  const path77 = [originServiceId];
+  const path78 = [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;
-    path77.push(hop.nextService);
+    path78.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path77, edges, culprit: current };
+  return { path: path78, 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 path77 = [...chain.path];
+  const path78 = [...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));
@@ -6814,14 +6943,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path77.push(loc.fileNode);
+      path78.push(loc.fileNode);
       edgeProvenances.push(import_types8.Provenance.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return import_types8.RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path77,
+      traversalPath: path78,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -6833,7 +6962,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   return import_types8.RootCauseResultSchema.parse({
     rootCauseNode: culprit,
     rootCauseReason: `${culpritName} is failing downstream calls (${errs} observed error${errs === 1 ? "" : "s"})`,
-    traversalPath: path77,
+    traversalPath: path78,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -7486,10 +7615,10 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
     traversalPath = staleChain.path;
     edgeProvenances = staleChain.edges.map((e) => e.provenance);
   } else if (top.node !== seedNode) {
-    const path77 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
-    if (path77) {
-      traversalPath = path77.nodes;
-      edgeProvenances = path77.edges.map((e) => e.provenance);
+    const path78 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path78) {
+      traversalPath = path78.nodes;
+      edgeProvenances = path78.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
       edgeProvenances = [top.provenance ?? import_types8.Provenance.OBSERVED];
@@ -8251,16 +8380,16 @@ init_cjs_shims();
 
 // src/extract/services.ts
 init_cjs_shims();
-var import_node_fs20 = require("fs");
-var import_node_path22 = __toESM(require("path"), 1);
-var import_ignore = __toESM(require("ignore"), 1);
+var import_node_fs21 = require("fs");
+var import_node_path23 = __toESM(require("path"), 1);
+var import_ignore2 = __toESM(require("ignore"), 1);
 var import_minimatch2 = require("minimatch");
 var import_types19 = require("@neat.is/types");
 
 // src/extract/python.ts
 init_cjs_shims();
-var import_node_fs10 = require("fs");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs11 = require("fs");
+var import_node_path12 = __toESM(require("path"), 1);
 var import_smol_toml = require("smol-toml");
 var REQUIREMENT_LINE = /^\s*([A-Za-z0-9_.-]+)(?:\[[^\]]*\])?\s*(?:(==)\s*([A-Za-z0-9_.+-]+))?/;
 function parseRequirementsTxt(content) {
@@ -8293,25 +8422,25 @@ function depsFromPyProject(pyproject) {
   return out;
 }
 async function discoverPythonService(serviceDir) {
-  const pyprojectPath = import_node_path11.default.join(serviceDir, "pyproject.toml");
-  const requirementsPath = import_node_path11.default.join(serviceDir, "requirements.txt");
-  const setupPath = import_node_path11.default.join(serviceDir, "setup.py");
+  const pyprojectPath = import_node_path12.default.join(serviceDir, "pyproject.toml");
+  const requirementsPath = import_node_path12.default.join(serviceDir, "requirements.txt");
+  const setupPath = import_node_path12.default.join(serviceDir, "setup.py");
   const hasPyproject = await exists2(pyprojectPath);
   const hasRequirements = await exists2(requirementsPath);
   const hasSetup = await exists2(setupPath);
   if (!hasPyproject && !hasRequirements && !hasSetup) return null;
-  let name = import_node_path11.default.basename(serviceDir);
+  let name = import_node_path12.default.basename(serviceDir);
   let version;
   const dependencies = {};
   if (hasPyproject) {
-    const raw = await import_node_fs10.promises.readFile(pyprojectPath, "utf8");
+    const raw = await import_node_fs11.promises.readFile(pyprojectPath, "utf8");
     const pyproject = (0, import_smol_toml.parse)(raw);
     name = pyproject.project?.name ?? pyproject.tool?.poetry?.name ?? name;
     version = pyproject.project?.version ?? pyproject.tool?.poetry?.version ?? void 0;
     Object.assign(dependencies, depsFromPyProject(pyproject));
   }
   if (hasRequirements) {
-    const raw = await import_node_fs10.promises.readFile(requirementsPath, "utf8");
+    const raw = await import_node_fs11.promises.readFile(requirementsPath, "utf8");
     Object.assign(dependencies, parseRequirementsTxt(raw));
   }
   return { name, version, dependencies };
@@ -8326,8 +8455,8 @@ function pythonToPackage(service) {
 
 // src/extract/go.ts
 init_cjs_shims();
-var import_node_fs11 = require("fs");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_fs12 = require("fs");
+var import_node_path13 = __toESM(require("path"), 1);
 var import_types10 = require("@neat.is/types");
 function parseGoMod(source) {
   const module2 = source.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
@@ -8354,7 +8483,7 @@ function goFramework(deps) {
 async function discoverGoService(scanPath, dir) {
   let raw;
   try {
-    raw = await import_node_fs11.promises.readFile(import_node_path12.default.join(dir, "go.mod"), "utf8");
+    raw = await import_node_fs12.promises.readFile(import_node_path13.default.join(dir, "go.mod"), "utf8");
   } catch {
     return null;
   }
@@ -8369,7 +8498,7 @@ async function discoverGoService(scanPath, dir) {
     name,
     language: "go",
     dependencies: mod.dependencies,
-    repoPath: import_node_path12.default.relative(scanPath, dir),
+    repoPath: import_node_path13.default.relative(scanPath, dir),
     ...framework ? { framework } : {}
   };
   return { pkg, dir, node };
@@ -8377,8 +8506,8 @@ async function discoverGoService(scanPath, dir) {
 
 // src/extract/ruby.ts
 init_cjs_shims();
-var import_node_fs12 = require("fs");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs13 = require("fs");
+var import_node_path14 = __toESM(require("path"), 1);
 var import_types11 = require("@neat.is/types");
 function parseGemfile(source) {
   const dependencies = {};
@@ -8395,12 +8524,12 @@ function parseGemfile(source) {
 async function discoverRubyService(scanPath, dir) {
   let raw;
   try {
-    raw = await import_node_fs12.promises.readFile(import_node_path13.default.join(dir, "Gemfile"), "utf8");
+    raw = await import_node_fs13.promises.readFile(import_node_path14.default.join(dir, "Gemfile"), "utf8");
   } catch {
     return null;
   }
   const gemfile = parseGemfile(raw);
-  const name = import_node_path13.default.basename(dir);
+  const name = import_node_path14.default.basename(dir);
   const pkg = { name, dependencies: gemfile.dependencies };
   const node = {
     id: (0, import_types11.serviceId)(name),
@@ -8408,7 +8537,7 @@ async function discoverRubyService(scanPath, dir) {
     name,
     language: "ruby",
     dependencies: gemfile.dependencies,
-    repoPath: import_node_path13.default.relative(scanPath, dir),
+    repoPath: import_node_path14.default.relative(scanPath, dir),
     ...gemfile.dependencies["rails"] !== void 0 ? { framework: "rails" } : {}
   };
   return { pkg, dir, node };
@@ -8416,7 +8545,7 @@ async function discoverRubyService(scanPath, dir) {
 
 // src/extract/php.ts
 init_cjs_shims();
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 var import_types12 = require("@neat.is/types");
 function parseComposerJson(composer) {
   return {
@@ -8429,12 +8558,12 @@ function parseComposerJson(composer) {
 async function discoverPhpService(scanPath, dir) {
   let composer;
   try {
-    composer = await readJson(import_node_path14.default.join(dir, "composer.json"));
+    composer = await readJson(import_node_path15.default.join(dir, "composer.json"));
   } catch {
     return null;
   }
   const { dependencies } = parseComposerJson(composer);
-  const name = import_node_path14.default.basename(dir);
+  const name = import_node_path15.default.basename(dir);
   const pkg = { name, dependencies };
   const node = {
     id: (0, import_types12.serviceId)(name),
@@ -8442,7 +8571,7 @@ async function discoverPhpService(scanPath, dir) {
     name,
     language: "php",
     dependencies,
-    repoPath: import_node_path14.default.relative(scanPath, dir),
+    repoPath: import_node_path15.default.relative(scanPath, dir),
     ...dependencies["laravel/framework"] !== void 0 ? { framework: "laravel" } : {}
   };
   return { pkg, dir, node };
@@ -8450,23 +8579,23 @@ async function discoverPhpService(scanPath, dir) {
 
 // src/extract/csharp.ts
 init_cjs_shims();
-var import_node_fs13 = require("fs");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs14 = require("fs");
+var import_node_path16 = __toESM(require("path"), 1);
 var import_types13 = require("@neat.is/types");
 var CSHARP_PROJECT_EXTS = /* @__PURE__ */ new Set([".csproj", ".sln"]);
 async function projectFiles(dir) {
-  const entries = await import_node_fs13.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs14.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
   const out = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    if (CSHARP_PROJECT_EXTS.has(import_node_path15.default.extname(entry.name).toLowerCase())) out.push(entry.name);
+    if (CSHARP_PROJECT_EXTS.has(import_node_path16.default.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 = import_node_path15.default.join(dir, NESTED_PROJECT_DIR);
+  const nested = import_node_path16.default.join(dir, NESTED_PROJECT_DIR);
   if ((await projectFiles(nested)).length > 0) return nested;
   return null;
 }
@@ -8491,10 +8620,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 ? import_node_path15.default.basename(csproj, import_node_path15.default.extname(csproj)) : import_node_path15.default.basename(dir);
+  const name = csproj ? import_node_path16.default.basename(csproj, import_node_path16.default.extname(csproj)) : import_node_path16.default.basename(dir);
   let dependencies = {};
   if (csproj) {
-    const raw = await import_node_fs13.promises.readFile(import_node_path15.default.join(projectDir, csproj), "utf8").catch(() => "");
+    const raw = await import_node_fs14.promises.readFile(import_node_path16.default.join(projectDir, csproj), "utf8").catch(() => "");
     dependencies = parseCsproj(raw).dependencies;
   }
   const pkg = { name, dependencies };
@@ -8506,20 +8635,20 @@ 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: import_node_path15.default.relative(scanPath, projectDir)
+    repoPath: import_node_path16.default.relative(scanPath, projectDir)
   };
   return { pkg, dir: projectDir, node };
 }
 
 // src/extract/java.ts
 init_cjs_shims();
-var import_node_fs14 = require("fs");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs15 = require("fs");
+var import_node_path17 = __toESM(require("path"), 1);
 var import_types14 = require("@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 exists2(import_node_path16.default.join(dir, manifest))) return true;
+    if (await exists2(import_node_path17.default.join(dir, manifest))) return true;
   }
   return false;
 }
@@ -8554,19 +8683,19 @@ function parseGradle(source) {
   return { dependencies };
 }
 async function discoverJavaService(scanPath, dir) {
-  const pomPath = import_node_path16.default.join(dir, "pom.xml");
-  const gradlePath = import_node_path16.default.join(dir, "build.gradle");
-  const gradleKtsPath = import_node_path16.default.join(dir, "build.gradle.kts");
+  const pomPath = import_node_path17.default.join(dir, "pom.xml");
+  const gradlePath = import_node_path17.default.join(dir, "build.gradle");
+  const gradleKtsPath = import_node_path17.default.join(dir, "build.gradle.kts");
   let manifest = null;
   if (await exists2(pomPath)) {
-    manifest = parsePomXml(await import_node_fs14.promises.readFile(pomPath, "utf8").catch(() => ""));
+    manifest = parsePomXml(await import_node_fs15.promises.readFile(pomPath, "utf8").catch(() => ""));
   } else if (await exists2(gradlePath)) {
-    manifest = parseGradle(await import_node_fs14.promises.readFile(gradlePath, "utf8").catch(() => ""));
+    manifest = parseGradle(await import_node_fs15.promises.readFile(gradlePath, "utf8").catch(() => ""));
   } else if (await exists2(gradleKtsPath)) {
-    manifest = parseGradle(await import_node_fs14.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
+    manifest = parseGradle(await import_node_fs15.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
   }
   if (!manifest) return null;
-  const name = manifest.name?.trim() || import_node_path16.default.basename(dir);
+  const name = manifest.name?.trim() || import_node_path17.default.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -8575,15 +8704,15 @@ async function discoverJavaService(scanPath, dir) {
     name,
     language: "java",
     dependencies,
-    repoPath: import_node_path16.default.relative(scanPath, dir)
+    repoPath: import_node_path17.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/kotlin.ts
 init_cjs_shims();
-var import_node_fs15 = require("fs");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_fs16 = require("fs");
+var import_node_path18 = __toESM(require("path"), 1);
 var import_types15 = require("@neat.is/types");
 var KOTLIN_SOURCE_EXT = ".kt";
 var JAVA_SOURCE_EXT = ".java";
@@ -8593,15 +8722,15 @@ async function dominantJvmSourceLanguage(dir) {
   let java = 0;
   async function recurse(current, depth) {
     if (depth > SOURCE_PROBE_MAX_DEPTH) return;
-    const entries = await import_node_fs15.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs16.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        await recurse(import_node_path17.default.join(current, entry.name), depth + 1);
+        await recurse(import_node_path18.default.join(current, entry.name), depth + 1);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = import_node_path17.default.extname(entry.name).toLowerCase();
+      const ext = import_node_path18.default.extname(entry.name).toLowerCase();
       if (ext === KOTLIN_SOURCE_EXT) kt++;
       else if (ext === JAVA_SOURCE_EXT) java++;
     }
@@ -8612,17 +8741,17 @@ async function dominantJvmSourceLanguage(dir) {
   return void 0;
 }
 async function readJvmManifest(dir) {
-  const pomPath = import_node_path17.default.join(dir, JAVA_MANIFESTS[0]);
-  const gradlePath = import_node_path17.default.join(dir, JAVA_MANIFESTS[1]);
-  const gradleKtsPath = import_node_path17.default.join(dir, JAVA_MANIFESTS[2]);
+  const pomPath = import_node_path18.default.join(dir, JAVA_MANIFESTS[0]);
+  const gradlePath = import_node_path18.default.join(dir, JAVA_MANIFESTS[1]);
+  const gradleKtsPath = import_node_path18.default.join(dir, JAVA_MANIFESTS[2]);
   if (await exists2(pomPath)) {
-    return parsePomXml(await import_node_fs15.promises.readFile(pomPath, "utf8").catch(() => ""));
+    return parsePomXml(await import_node_fs16.promises.readFile(pomPath, "utf8").catch(() => ""));
   }
   if (await exists2(gradlePath)) {
-    return parseGradle(await import_node_fs15.promises.readFile(gradlePath, "utf8").catch(() => ""));
+    return parseGradle(await import_node_fs16.promises.readFile(gradlePath, "utf8").catch(() => ""));
   }
   if (await exists2(gradleKtsPath)) {
-    return parseGradle(await import_node_fs15.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
+    return parseGradle(await import_node_fs16.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
   }
   return null;
 }
@@ -8631,7 +8760,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() || import_node_path17.default.basename(dir);
+  const name = manifest.name?.trim() || import_node_path18.default.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -8640,20 +8769,20 @@ async function discoverKotlinService(scanPath, dir) {
     name,
     language: "kotlin",
     dependencies,
-    repoPath: import_node_path17.default.relative(scanPath, dir)
+    repoPath: import_node_path18.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/rust.ts
 init_cjs_shims();
-var import_node_fs16 = require("fs");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_fs17 = require("fs");
+var import_node_path19 = __toESM(require("path"), 1);
 var import_smol_toml2 = require("smol-toml");
 var import_types16 = require("@neat.is/types");
 var CARGO_MANIFEST = "Cargo.toml";
 async function hasRustManifest(dir) {
-  return exists2(import_node_path18.default.join(dir, CARGO_MANIFEST));
+  return exists2(import_node_path19.default.join(dir, CARGO_MANIFEST));
 }
 function parseCargoToml(source) {
   const dependencies = {};
@@ -8678,10 +8807,10 @@ function parseCargoToml(source) {
   return { name, dependencies };
 }
 async function discoverRustService(scanPath, dir) {
-  const cargoPath = import_node_path18.default.join(dir, CARGO_MANIFEST);
+  const cargoPath = import_node_path19.default.join(dir, CARGO_MANIFEST);
   if (!await exists2(cargoPath)) return null;
-  const manifest = parseCargoToml(await import_node_fs16.promises.readFile(cargoPath, "utf8").catch(() => ""));
-  const name = manifest.name?.trim() || import_node_path18.default.basename(dir);
+  const manifest = parseCargoToml(await import_node_fs17.promises.readFile(cargoPath, "utf8").catch(() => ""));
+  const name = manifest.name?.trim() || import_node_path19.default.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -8690,19 +8819,19 @@ async function discoverRustService(scanPath, dir) {
     name,
     language: "rust",
     dependencies,
-    repoPath: import_node_path18.default.relative(scanPath, dir)
+    repoPath: import_node_path19.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/cpp.ts
 init_cjs_shims();
-var import_node_fs17 = require("fs");
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_fs18 = require("fs");
+var import_node_path20 = __toESM(require("path"), 1);
 var import_types17 = require("@neat.is/types");
 var CMAKE_MANIFEST = "CMakeLists.txt";
 async function hasCppManifest(dir) {
-  return exists2(import_node_path19.default.join(dir, CMAKE_MANIFEST));
+  return exists2(import_node_path20.default.join(dir, CMAKE_MANIFEST));
 }
 function parseCMakeProjectName(source) {
   const withoutComments = source.replace(/#.*$/gm, "");
@@ -8710,10 +8839,10 @@ function parseCMakeProjectName(source) {
   return m?.[1];
 }
 async function discoverCppService(scanPath, dir) {
-  const cmakePath = import_node_path19.default.join(dir, CMAKE_MANIFEST);
+  const cmakePath = import_node_path20.default.join(dir, CMAKE_MANIFEST);
   if (!await exists2(cmakePath)) return null;
-  const source = await import_node_fs17.promises.readFile(cmakePath, "utf8").catch(() => "");
-  const name = parseCMakeProjectName(source)?.trim() || import_node_path19.default.basename(dir);
+  const source = await import_node_fs18.promises.readFile(cmakePath, "utf8").catch(() => "");
+  const name = parseCMakeProjectName(source)?.trim() || import_node_path20.default.basename(dir);
   const dependencies = {};
   const pkg = { name, dependencies };
   const node = {
@@ -8722,15 +8851,15 @@ async function discoverCppService(scanPath, dir) {
     name,
     language: "cpp",
     dependencies,
-    repoPath: import_node_path19.default.relative(scanPath, dir)
+    repoPath: import_node_path20.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/dockerfile-service.ts
 init_cjs_shims();
-var import_node_fs18 = require("fs");
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_fs19 = require("fs");
+var import_node_path21 = __toESM(require("path"), 1);
 var import_types18 = require("@neat.is/types");
 function languageForSourceExt(ext) {
   switch (ext) {
@@ -8772,12 +8901,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 import_node_fs18.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs19.promises.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 = import_node_path20.default.extname(entry.name).toLowerCase();
+    const ext = import_node_path21.default.extname(entry.name).toLowerCase();
     if (!SERVICE_FILE_EXTENSIONS.has(ext)) continue;
     const lang = languageForSourceExt(ext);
     if (!lang) continue;
@@ -8796,7 +8925,7 @@ async function inferServiceLanguage(dir) {
   return best;
 }
 async function hasLanguageManifest(dir) {
-  return await exists2(import_node_path20.default.join(dir, "package.json")) || await exists2(import_node_path20.default.join(dir, "pyproject.toml")) || await exists2(import_node_path20.default.join(dir, "requirements.txt")) || await exists2(import_node_path20.default.join(dir, "setup.py")) || await exists2(import_node_path20.default.join(dir, "go.mod")) || await exists2(import_node_path20.default.join(dir, "Gemfile")) || await exists2(import_node_path20.default.join(dir, "composer.json")) || // C#'s marker is a glob (`*.csproj` / `*.sln`), so it reads the directory
+  return await exists2(import_node_path21.default.join(dir, "package.json")) || await exists2(import_node_path21.default.join(dir, "pyproject.toml")) || await exists2(import_node_path21.default.join(dir, "requirements.txt")) || await exists2(import_node_path21.default.join(dir, "setup.py")) || await exists2(import_node_path21.default.join(dir, "go.mod")) || await exists2(import_node_path21.default.join(dir, "Gemfile")) || await exists2(import_node_path21.default.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
@@ -8806,15 +8935,15 @@ async function hasLanguageManifest(dir) {
   await hasCppManifest(dir);
 }
 async function hasDockerfileDeclaredService(dir) {
-  if (!await exists2(import_node_path20.default.join(dir, "Dockerfile"))) return false;
+  if (!await exists2(import_node_path21.default.join(dir, "Dockerfile"))) return false;
   return await inferServiceLanguage(dir) !== null;
 }
 async function discoverDockerfileService(scanPath, dir) {
-  if (!await exists2(import_node_path20.default.join(dir, "Dockerfile"))) return null;
+  if (!await exists2(import_node_path21.default.join(dir, "Dockerfile"))) return null;
   if (await hasLanguageManifest(dir)) return null;
   const language = await inferServiceLanguage(dir);
   if (!language) return null;
-  const name = import_node_path20.default.basename(dir);
+  const name = import_node_path21.default.basename(dir);
   const pkg = { name, dependencies: {} };
   const node = {
     id: (0, import_types18.serviceId)(name),
@@ -8822,24 +8951,24 @@ async function discoverDockerfileService(scanPath, dir) {
     name,
     language,
     dependencies: {},
-    repoPath: import_node_path20.default.relative(scanPath, dir)
+    repoPath: import_node_path21.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/owners.ts
 init_cjs_shims();
-var import_node_fs19 = require("fs");
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_fs20 = require("fs");
+var import_node_path22 = __toESM(require("path"), 1);
 var import_minimatch = require("minimatch");
 async function loadCodeowners(scanPath) {
   const candidates = [
-    import_node_path21.default.join(scanPath, "CODEOWNERS"),
-    import_node_path21.default.join(scanPath, ".github", "CODEOWNERS")
+    import_node_path22.default.join(scanPath, "CODEOWNERS"),
+    import_node_path22.default.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists2(file)) {
-      const raw = await import_node_fs19.promises.readFile(file, "utf8");
+      const raw = await import_node_fs20.promises.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -8857,7 +8986,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(import_node_path21.default.sep).join("/");
+  const normalized = repoPath.split(import_node_path22.default.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -8873,7 +9002,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = import_node_path21.default.join(serviceDir, "package.json");
+  const pkgPath = import_node_path22.default.join(serviceDir, "package.json");
   if (!await exists2(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -8910,36 +9039,36 @@ function workspaceGlobs(pkg) {
   return null;
 }
 async function hasPythonManifest(dir) {
-  return await exists2(import_node_path22.default.join(dir, "pyproject.toml")) || await exists2(import_node_path22.default.join(dir, "requirements.txt")) || await exists2(import_node_path22.default.join(dir, "setup.py"));
+  return await exists2(import_node_path23.default.join(dir, "pyproject.toml")) || await exists2(import_node_path23.default.join(dir, "requirements.txt")) || await exists2(import_node_path23.default.join(dir, "setup.py"));
 }
 async function hasGoManifest(dir) {
-  return exists2(import_node_path22.default.join(dir, "go.mod"));
+  return exists2(import_node_path23.default.join(dir, "go.mod"));
 }
 async function hasRubyManifest(dir) {
-  return exists2(import_node_path22.default.join(dir, "Gemfile"));
+  return exists2(import_node_path23.default.join(dir, "Gemfile"));
 }
 async function hasPhpManifest(dir) {
-  return exists2(import_node_path22.default.join(dir, "composer.json"));
+  return exists2(import_node_path23.default.join(dir, "composer.json"));
 }
 async function hasCsharpManifest(dir) {
   return hasCsharpProject(dir);
 }
 async function loadGitignore(scanPath) {
-  const gitignorePath = import_node_path22.default.join(scanPath, ".gitignore");
+  const gitignorePath = import_node_path23.default.join(scanPath, ".gitignore");
   if (!await exists2(gitignorePath)) return null;
-  const raw = await import_node_fs20.promises.readFile(gitignorePath, "utf8");
-  return (0, import_ignore.default)().add(raw);
+  const raw = await import_node_fs21.promises.readFile(gitignorePath, "utf8");
+  return (0, import_ignore2.default)().add(raw);
 }
 async function walkDirs(start, scanPath, options, visit) {
   async function recurse(current, depth) {
     if (depth > options.maxDepth) return;
-    const entries = await import_node_fs20.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs21.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path22.default.join(current, entry.name);
+      const child = import_node_path23.default.join(current, entry.name);
       if (options.ig) {
-        const rel = import_node_path22.default.relative(scanPath, child).split(import_node_path22.default.sep).join("/");
+        const rel = import_node_path23.default.relative(scanPath, child).split(import_node_path23.default.sep).join("/");
         if (rel && options.ig.ignores(rel + "/")) continue;
       }
       if (await isPythonVenvDir(child)) continue;
@@ -8955,8 +9084,8 @@ async function expandWorkspaceGlobs(scanPath, globs) {
   for (const raw of globs) {
     const pattern = raw.replace(/^\.\//, "");
     if (!pattern.includes("*")) {
-      const candidate = import_node_path22.default.join(scanPath, pattern);
-      if (await exists2(import_node_path22.default.join(candidate, "package.json"))) found.add(candidate);
+      const candidate = import_node_path23.default.join(scanPath, pattern);
+      if (await exists2(import_node_path23.default.join(candidate, "package.json"))) found.add(candidate);
       continue;
     }
     const segments = pattern.split("/");
@@ -8965,13 +9094,13 @@ async function expandWorkspaceGlobs(scanPath, globs) {
       if (seg.includes("*")) break;
       staticSegments.push(seg);
     }
-    const start = import_node_path22.default.join(scanPath, ...staticSegments);
+    const start = import_node_path23.default.join(scanPath, ...staticSegments);
     if (!await exists2(start)) continue;
     const hasDoubleStar = pattern.includes("**");
     const walkDepth = hasDoubleStar ? scanDepth : Math.max(0, segments.length - staticSegments.length - 1);
     await walkDirs(start, scanPath, { maxDepth: walkDepth, ig: null }, async (dir) => {
-      const rel = import_node_path22.default.relative(scanPath, dir).split(import_node_path22.default.sep).join("/");
-      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists2(import_node_path22.default.join(dir, "package.json"))) {
+      const rel = import_node_path23.default.relative(scanPath, dir).split(import_node_path23.default.sep).join("/");
+      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists2(import_node_path23.default.join(dir, "package.json"))) {
         found.add(dir);
       }
     });
@@ -8994,18 +9123,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 import_node_fs20.promises.readdir(dir).catch(() => []);
+  const entries = await import_node_fs21.promises.readdir(dir).catch(() => []);
   if (entries.some((name) => /^tsconfig(\..+)?\.json$/.test(name))) return "typescript";
   return "javascript";
 }
 async function discoverNodeService(scanPath, dir) {
-  const pkgPath = import_node_path22.default.join(dir, "package.json");
+  const pkgPath = import_node_path23.default.join(dir, "package.json");
   if (!await exists2(pkgPath)) return null;
   let pkg;
   try {
     pkg = await readJson(pkgPath);
   } catch (err) {
-    recordExtractionError("services", import_node_path22.default.relative(scanPath, pkgPath), err);
+    recordExtractionError("services", import_node_path23.default.relative(scanPath, pkgPath), err);
     return null;
   }
   if (!pkg.name) return null;
@@ -9018,7 +9147,7 @@ async function discoverNodeService(scanPath, dir) {
     language,
     version: pkg.version,
     dependencies: pkg.dependencies ?? {},
-    repoPath: import_node_path22.default.relative(scanPath, dir),
+    repoPath: import_node_path23.default.relative(scanPath, dir),
     ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
     ...framework ? { framework } : {}
   };
@@ -9035,12 +9164,12 @@ async function discoverPyService(scanPath, dir) {
     language: "python",
     version: py.version,
     dependencies: py.dependencies,
-    repoPath: import_node_path22.default.relative(scanPath, dir)
+    repoPath: import_node_path23.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 async function discoverServices(scanPath) {
-  const rootPkgPath = import_node_path22.default.join(scanPath, "package.json");
+  const rootPkgPath = import_node_path23.default.join(scanPath, "package.json");
   let rootPkg = null;
   if (await exists2(rootPkgPath)) {
     try {
@@ -9048,7 +9177,7 @@ async function discoverServices(scanPath) {
     } catch (err) {
       recordExtractionError(
         "services workspaces",
-        import_node_path22.default.relative(scanPath, rootPkgPath),
+        import_node_path23.default.relative(scanPath, rootPkgPath),
         err
       );
     }
@@ -9069,7 +9198,7 @@ async function discoverServices(scanPath) {
       scanPath,
       { maxDepth: parseScanDepth(), ig },
       async (dir) => {
-        if (await exists2(import_node_path22.default.join(dir, "package.json"))) {
+        if (await exists2(import_node_path23.default.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);
@@ -9097,8 +9226,8 @@ async function discoverServices(scanPath) {
     seenDirs.add(service.dir);
     const existingDir = seen.get(service.node.name);
     if (existingDir !== void 0) {
-      const a = import_node_path22.default.relative(scanPath, existingDir) || ".";
-      const b = import_node_path22.default.relative(scanPath, dir) || ".";
+      const a = import_node_path23.default.relative(scanPath, existingDir) || ".";
+      const b = import_node_path23.default.relative(scanPath, dir) || ".";
       console.warn(
         `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
       );
@@ -9112,14 +9241,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) => import_node_path22.default.resolve(s.dir));
+  const resolvedDirs = out.map((s) => import_node_path23.default.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 + import_node_path22.default.sep)) nested.push(other);
+      if (other.startsWith(self + import_node_path23.default.sep)) nested.push(other);
     }
     out[i].excludeDirs = nested;
   }
@@ -9146,8 +9275,8 @@ function addServiceNodes(graph, services) {
 
 // src/extract/aliases.ts
 init_cjs_shims();
-var import_node_path23 = __toESM(require("path"), 1);
-var import_node_fs21 = require("fs");
+var import_node_path24 = __toESM(require("path"), 1);
+var import_node_fs22 = require("fs");
 var import_yaml2 = require("yaml");
 var import_types20 = require("@neat.is/types");
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
@@ -9174,14 +9303,14 @@ function indexServicesByName(services) {
   const map = /* @__PURE__ */ new Map();
   for (const s of services) {
     map.set(s.node.name, s.node.id);
-    map.set(import_node_path23.default.basename(s.dir), s.node.id);
+    map.set(import_node_path24.default.basename(s.dir), s.node.id);
   }
   return map;
 }
 async function collectComposeAliases(graph, scanPath, serviceIndex) {
   let composePath = null;
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path23.default.join(scanPath, name);
+    const abs = import_node_path24.default.join(scanPath, name);
     if (await exists2(abs)) {
       composePath = abs;
       break;
@@ -9194,7 +9323,7 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   } catch (err) {
     recordExtractionError(
       "aliases compose",
-      import_node_path23.default.relative(scanPath, composePath),
+      import_node_path24.default.relative(scanPath, composePath),
       err
     );
     return;
@@ -9237,11 +9366,11 @@ function parseDockerfileLabels(content) {
 }
 async function collectDockerfileAliases(graph, services) {
   for (const service of services) {
-    const dockerfilePath = import_node_path23.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path24.default.join(service.dir, "Dockerfile");
     if (!await exists2(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs21.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs22.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError("aliases dockerfile", dockerfilePath, err);
       continue;
@@ -9253,15 +9382,15 @@ async function collectDockerfileAliases(graph, services) {
 async function walkYamlFiles(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await import_node_fs21.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs22.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path23.default.join(start, entry.name);
+      const child = import_node_path24.default.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles(child, depth + 1, max));
-    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path23.default.extname(entry.name))) {
-      out.push(import_node_path23.default.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path24.default.extname(entry.name))) {
+      out.push(import_node_path24.default.join(start, entry.name));
     }
   }
   return out;
@@ -9288,7 +9417,7 @@ function k8sServiceTarget(doc, byName) {
 async function collectK8sAliases(graph, scanPath, serviceIndex) {
   const files = await walkYamlFiles(scanPath);
   for (const file of files) {
-    const content = await import_node_fs21.promises.readFile(file, "utf8");
+    const content = await import_node_fs22.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml2.parseAllDocuments)(content).map((d) => d.toJSON());
@@ -9313,14 +9442,14 @@ async function addServiceAliases(graph, scanPath, services) {
 
 // src/extract/files.ts
 init_cjs_shims();
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_path25 = __toESM(require("path"), 1);
 async function addFiles(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
     const filePaths = await walkSourceFiles(service.dir, service.excludeDirs);
     for (const filePath of filePaths) {
-      const relPath = toPosix(import_node_path24.default.relative(service.dir, filePath));
+      const relPath = toPosix(import_node_path25.default.relative(service.dir, filePath));
       const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -9336,7 +9465,7 @@ async function addFiles(graph, services) {
 
 // src/extract/symbols.ts
 init_cjs_shims();
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 var import_tree_sitter3 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript3 = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_typescript = __toESM(require("tree-sitter-typescript"), 1);
@@ -10088,10 +10217,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 = import_node_path25.default.extname(file.path);
+      const ext = import_node_path26.default.extname(file.path);
       const parser = parserForExt5(ext);
       if (!parser) continue;
-      const relPath = toPosix(import_node_path25.default.relative(service.dir, file.path));
+      const relPath = toPosix(import_node_path26.default.relative(service.dir, file.path));
       let defs;
       try {
         const tree = parseSource3(parser, file.content);
@@ -10151,7 +10280,7 @@ async function addSymbols(graph, services) {
 
 // src/extract/symbol-edges.ts
 init_cjs_shims();
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
 var import_types22 = require("@neat.is/types");
 function extendsInfo(classHeritage) {
@@ -10258,10 +10387,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(import_node_path26.default.extname(file.path));
+      const parser = parserForExt5(import_node_path27.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path26.default.relative(service.dir, file.path));
-      const fileDir = import_node_path26.default.dirname(file.path);
+      const relPath = toPosix(import_node_path27.default.relative(service.dir, file.path));
+      const fileDir = import_node_path27.default.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -10396,7 +10525,7 @@ async function addSymbolEdges(graph, services) {
 
 // src/extract/actions.ts
 init_cjs_shims();
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 var import_tree_sitter5 = __toESM(require("tree-sitter"), 1);
 var import_types23 = require("@neat.is/types");
 function stringLiteralText2(node) {
@@ -10543,9 +10672,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(import_node_path27.default.extname(file.path));
+      const parser = parserForExt5(import_node_path28.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path27.default.relative(service.dir, file.path));
+      const relPath = toPosix(import_node_path28.default.relative(service.dir, file.path));
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -10606,10 +10735,10 @@ async function addServerActions(graph, services) {
     }
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(import_node_path27.default.extname(file.path));
+      const parser = parserForExt5(import_node_path28.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path27.default.relative(service.dir, file.path));
-      const fileDir = import_node_path27.default.dirname(file.path);
+      const relPath = toPosix(import_node_path28.default.relative(service.dir, file.path));
+      const fileDir = import_node_path28.default.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -10662,14 +10791,14 @@ async function addServerActions(graph, services) {
 
 // src/extract/databases/index.ts
 init_cjs_shims();
-var import_node_path36 = __toESM(require("path"), 1);
+var import_node_path37 = __toESM(require("path"), 1);
 var import_types24 = require("@neat.is/types");
 
 // src/extract/databases/db-config-yaml.ts
 init_cjs_shims();
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
 async function parse(serviceDir) {
-  const yamlPath = import_node_path28.default.join(serviceDir, "db-config.yaml");
+  const yamlPath = import_node_path29.default.join(serviceDir, "db-config.yaml");
   if (!await exists2(yamlPath)) return [];
   const raw = await readYaml(yamlPath);
   return [
@@ -10687,13 +10816,13 @@ var dbConfigYamlParser = { name: "db-config.yaml", parse };
 
 // src/extract/databases/dotenv.ts
 init_cjs_shims();
-var import_node_fs23 = require("fs");
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_fs24 = require("fs");
+var import_node_path31 = __toESM(require("path"), 1);
 
 // src/extract/databases/shared.ts
 init_cjs_shims();
-var import_node_fs22 = require("fs");
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_fs23 = require("fs");
+var import_node_path30 = __toESM(require("path"), 1);
 function schemeToEngine(scheme) {
   const s = scheme.toLowerCase().split("+")[0];
   switch (s) {
@@ -10732,18 +10861,18 @@ function parseConnectionString(url) {
 }
 async function readIfExists(filePath) {
   try {
-    return await import_node_fs22.promises.readFile(filePath, "utf8");
+    return await import_node_fs23.promises.readFile(filePath, "utf8");
   } catch {
     return null;
   }
 }
 async function resolveEnvVar(serviceDir, name) {
-  const entries = await import_node_fs22.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs23.promises.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(import_node_path29.default.join(serviceDir, fileName));
+    const content = await readIfExists(import_node_path30.default.join(serviceDir, fileName));
     if (!content) continue;
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -10762,7 +10891,7 @@ async function resolveEnvVar(serviceDir, name) {
 }
 async function findFirst(serviceDir, candidates) {
   for (const rel of candidates) {
-    const abs = import_node_path29.default.join(serviceDir, rel);
+    const abs = import_node_path30.default.join(serviceDir, rel);
     const content = await readIfExists(abs);
     if (content !== null) return abs;
   }
@@ -10820,15 +10949,15 @@ function parseDotenvLine(line) {
   return { key, value };
 }
 async function parse2(serviceDir) {
-  const entries = await import_node_fs23.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs24.promises.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 = import_node_path30.default.join(serviceDir, entry.name);
-    const content = await import_node_fs23.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path31.default.join(serviceDir, entry.name);
+    const content = await import_node_fs24.promises.readFile(filePath, "utf8");
     for (const line of content.split("\n")) {
       const parsed = parseDotenvLine(line);
       if (!parsed) continue;
@@ -10847,9 +10976,9 @@ var dotenvParser = { name: ".env", parse: parse2 };
 
 // src/extract/databases/prisma.ts
 init_cjs_shims();
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_path32 = __toESM(require("path"), 1);
 async function parse3(serviceDir) {
-  const schemaPath = import_node_path31.default.join(serviceDir, "prisma", "schema.prisma");
+  const schemaPath = import_node_path32.default.join(serviceDir, "prisma", "schema.prisma");
   const content = await readIfExists(schemaPath);
   if (!content) return [];
   const block = content.match(/datasource\s+\w+\s*\{([^}]*)\}/s);
@@ -11007,10 +11136,10 @@ var knexParser = { name: "knex", parse: parse5 };
 
 // src/extract/databases/ormconfig.ts
 init_cjs_shims();
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_path33 = __toESM(require("path"), 1);
 async function parse6(serviceDir) {
   for (const candidate of ["ormconfig.json", "ormconfig.yaml", "ormconfig.yml"]) {
-    const abs = import_node_path32.default.join(serviceDir, candidate);
+    const abs = import_node_path33.default.join(serviceDir, candidate);
     if (!await exists2(abs)) continue;
     const raw = candidate.endsWith(".json") ? await readJson(abs) : await readYaml(abs);
     const entries = Array.isArray(raw) ? raw : [raw];
@@ -11070,9 +11199,9 @@ var typeormParser = { name: "typeorm", parse: parse7 };
 
 // src/extract/databases/sequelize.ts
 init_cjs_shims();
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_path34 = __toESM(require("path"), 1);
 async function parse8(serviceDir) {
-  const configPath = import_node_path33.default.join(serviceDir, "config", "config.json");
+  const configPath = import_node_path34.default.join(serviceDir, "config", "config.json");
   if (!await exists2(configPath)) return [];
   const raw = await readJson(configPath);
   const out = [];
@@ -11099,8 +11228,8 @@ var sequelizeParser = { name: "sequelize", parse: parse8 };
 
 // src/extract/databases/csharp.ts
 init_cjs_shims();
-var import_node_fs24 = require("fs");
-var import_node_path34 = __toESM(require("path"), 1);
+var import_node_fs25 = require("fs");
+var import_node_path35 = __toESM(require("path"), 1);
 var CS_EXT = ".cs";
 var NPGSQL_GATE = /\bUseNpgsql\b|\bNpgsql\b/;
 var REDIS_GATE = /\bConnectionMultiplexer\b|\bStackExchange\.Redis\b|\bConfigurationOptions\.Parse\b|\bAddStackExchangeRedisCache\b/;
@@ -11147,12 +11276,12 @@ function parseRedisEndpoint(raw) {
   return { host, port, database: "", engine: "redis", engineVersion: "unknown" };
 }
 async function resolveEnvUpTree(startDir, name) {
-  let dir = import_node_path34.default.resolve(startDir);
+  let dir = import_node_path35.default.resolve(startDir);
   for (let depth = 0; depth < 12; depth++) {
     const value = await resolveEnvVar(dir, name);
     if (value !== null) return value;
-    const atRepoRoot = await import_node_fs24.promises.access(import_node_path34.default.join(dir, ".git")).then(() => true).catch(() => false);
-    const parent = import_node_path34.default.dirname(dir);
+    const atRepoRoot = await import_node_fs25.promises.access(import_node_path35.default.join(dir, ".git")).then(() => true).catch(() => false);
+    const parent = import_node_path35.default.dirname(dir);
     if (atRepoRoot || parent === dir) break;
     dir = parent;
   }
@@ -11207,12 +11336,12 @@ async function resolveConfigs(literals, keys, serviceDir, looksLike, parse11) {
 }
 async function parse9(serviceDir) {
   const files = (await walkSourceFiles(serviceDir).catch(() => [])).filter(
-    (f) => import_node_path34.default.extname(f) === CS_EXT
+    (f) => import_node_path35.default.extname(f) === CS_EXT
   );
   if (files.length === 0) return [];
   const sources = [];
   for (const file of files) {
-    const content = await import_node_fs24.promises.readFile(file, "utf8").catch(() => null);
+    const content = await import_node_fs25.promises.readFile(file, "utf8").catch(() => null);
     if (content !== null) sources.push({ file, content });
   }
   let pgGateFile = null;
@@ -11253,7 +11382,7 @@ var csharpParser = { name: "csharp", parse: parse9 };
 
 // src/extract/databases/docker-compose.ts
 init_cjs_shims();
-var import_node_path35 = __toESM(require("path"), 1);
+var import_node_path36 = __toESM(require("path"), 1);
 function portFromService(svc) {
   for (const raw of svc.ports ?? []) {
     const str = String(raw);
@@ -11280,7 +11409,7 @@ function databaseFromEnv(svc) {
 }
 async function parse10(serviceDir) {
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path35.default.join(serviceDir, name);
+    const abs = import_node_path36.default.join(serviceDir, name);
     if (!await exists2(abs)) continue;
     const raw = await readYaml(abs);
     if (!raw?.services) return [];
@@ -11453,7 +11582,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
           discoveredVia: mergedDiscoveredVia
         });
       }
-      const relConfigFile = toPosix(import_node_path36.default.relative(service.dir, config.sourceFile));
+      const relConfigFile = toPosix(import_node_path37.default.relative(service.dir, config.sourceFile));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -11462,7 +11591,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       );
       nodesAdded += fn;
       edgesAdded += fe;
-      const evidenceFile = toPosix(import_node_path36.default.relative(scanPath, config.sourceFile));
+      const evidenceFile = toPosix(import_node_path37.default.relative(scanPath, config.sourceFile));
       const edge = {
         id: (0, import_types3.extractedEdgeId)(fileNodeId, dbNode.id, import_types24.EdgeType.CONNECTS_TO),
         source: fileNodeId,
@@ -11483,15 +11612,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 = import_node_path36.default.relative(scanPath, primary.sourceFile);
+      const relPath = import_node_path37.default.relative(scanPath, primary.sourceFile);
       const cfgId = (0, import_types24.configId)(relPath);
       if (!graph.hasNode(cfgId)) {
         const cfgNode = {
           id: cfgId,
           type: import_types24.NodeType.ConfigNode,
-          name: import_node_path36.default.basename(primary.sourceFile),
+          name: import_node_path37.default.basename(primary.sourceFile),
           path: relPath,
-          fileType: isConfigFile(import_node_path36.default.basename(primary.sourceFile)).fileType || "config"
+          fileType: isConfigFile(import_node_path37.default.basename(primary.sourceFile)).fileType || "config"
         };
         graph.addNode(cfgId, cfgNode);
         nodesAdded++;
@@ -11532,19 +11661,19 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
 
 // src/extract/configs.ts
 init_cjs_shims();
-var import_node_fs25 = require("fs");
-var import_node_path37 = __toESM(require("path"), 1);
+var import_node_fs26 = require("fs");
+var import_node_path38 = __toESM(require("path"), 1);
 var import_types25 = require("@neat.is/types");
 async function walkConfigFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => import_node_path37.default.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => import_node_path38.default.resolve(d)));
   const out = [];
   async function walk11(current) {
-    const entries = await import_node_fs25.promises.readdir(current, { withFileTypes: true });
+    const entries = await import_node_fs26.promises.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const full = import_node_path37.default.join(current, entry.name);
+      const full = import_node_path38.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(import_node_path37.default.resolve(full))) continue;
+        if (excluded.has(import_node_path38.default.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk11(full);
       } else if (entry.isFile() && isConfigFile(entry.name).match) {
@@ -11561,19 +11690,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 = import_node_path37.default.relative(scanPath, file);
+      const relPath = import_node_path38.default.relative(scanPath, file);
       const node = {
         id: (0, import_types25.configId)(relPath),
         type: import_types25.NodeType.ConfigNode,
-        name: import_node_path37.default.basename(file),
+        name: import_node_path38.default.basename(file),
         path: relPath,
-        fileType: isConfigFile(import_node_path37.default.basename(file)).fileType
+        fileType: isConfigFile(import_node_path38.default.basename(file)).fileType
       };
       if (!graph.hasNode(node.id)) {
         graph.addNode(node.id, node);
         nodesAdded++;
       }
-      const relToService = toPosix(import_node_path37.default.relative(service.dir, file));
+      const relToService = toPosix(import_node_path38.default.relative(service.dir, file));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -11589,7 +11718,7 @@ async function addConfigNodes(graph, services, scanPath) {
         type: import_types25.EdgeType.CONFIGURED_BY,
         provenance: import_types25.Provenance.EXTRACTED,
         confidence: (0, import_types25.confidenceForExtracted)("structural"),
-        evidence: { file: relPath.split(import_node_path37.default.sep).join("/") }
+        evidence: { file: relPath.split(import_node_path38.default.sep).join("/") }
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -11602,8 +11731,8 @@ async function addConfigNodes(graph, services, scanPath) {
 
 // src/extract/proto.ts
 init_cjs_shims();
-var import_node_fs26 = require("fs");
-var import_node_path38 = __toESM(require("path"), 1);
+var import_node_fs27 = require("fs");
+var import_node_path39 = __toESM(require("path"), 1);
 var import_types26 = require("@neat.is/types");
 var PROTO_EXTENSION = ".proto";
 function packageOf(content) {
@@ -11641,18 +11770,18 @@ function grpcMethodsFromProto(content, fqPackage) {
   return out;
 }
 async function walkProtoFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => import_node_path38.default.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => import_node_path39.default.resolve(d)));
   const out = [];
   async function walk11(current) {
-    const entries = await import_node_fs26.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs27.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      const full = import_node_path38.default.join(current, entry.name);
+      const full = import_node_path39.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(import_node_path38.default.resolve(full))) continue;
+        if (excluded.has(import_node_path39.default.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk11(full);
-      } else if (entry.isFile() && import_node_path38.default.extname(entry.name) === PROTO_EXTENSION) {
+      } else if (entry.isFile() && import_node_path39.default.extname(entry.name) === PROTO_EXTENSION) {
         out.push(full);
       }
     }
@@ -11667,10 +11796,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(import_node_path38.default.relative(service.dir, protoPath));
+      const relFile = toPosix(import_node_path39.default.relative(service.dir, protoPath));
       let content;
       try {
-        content = await import_node_fs26.promises.readFile(protoPath, "utf8");
+        content = await import_node_fs27.promises.readFile(protoPath, "utf8");
       } catch (err) {
         recordExtractionError("proto extraction", protoPath, err);
         continue;
@@ -11729,7 +11858,7 @@ var import_types46 = require("@neat.is/types");
 
 // src/extract/calls/http.ts
 init_cjs_shims();
-var import_node_path39 = __toESM(require("path"), 1);
+var import_node_path40 = __toESM(require("path"), 1);
 var import_tree_sitter6 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript4 = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_typescript2 = __toESM(require("tree-sitter-typescript"), 1);
@@ -11812,7 +11941,7 @@ async function addHttpCallEdges(graph, services) {
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt(import_node_path39.default.extname(file.path), parserCache);
+      const parser = parserForExt(import_node_path40.default.extname(file.path), parserCache);
       let sites;
       try {
         sites = callsFromSource(file.content, parser, knownHosts);
@@ -11821,7 +11950,7 @@ async function addHttpCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(import_node_path39.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path40.default.relative(service.dir, file.path));
       for (const site of sites) {
         const targetId = hostToNodeId.get(site.host);
         if (!targetId || targetId === service.node.id) continue;
@@ -11875,7 +12004,7 @@ async function addHttpCallEdges(graph, services) {
 
 // src/extract/calls/route-match.ts
 init_cjs_shims();
-var import_node_path40 = __toESM(require("path"), 1);
+var import_node_path41 = __toESM(require("path"), 1);
 var import_tree_sitter7 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript5 = __toESM(require("tree-sitter-javascript"), 1);
 var import_types28 = require("@neat.is/types");
@@ -12153,7 +12282,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(import_node_path40.default.extname(file.path))) continue;
+      if (!JS_CLIENT_EXTENSIONS.has(import_node_path41.default.extname(file.path))) continue;
       let sites;
       try {
         sites = clientCallSitesFromSource(file.content, jsParser, knownHosts);
@@ -12162,7 +12291,7 @@ async function addRouteCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(import_node_path40.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path41.default.relative(service.dir, file.path));
       for (const site of sites) {
         if (site.host === null) {
           const dedupKey2 = `${relFile}|unresolved-host`;
@@ -12255,7 +12384,7 @@ async function addRouteCallEdges(graph, services) {
 
 // src/extract/calls/kafka.ts
 init_cjs_shims();
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_path42 = __toESM(require("path"), 1);
 var import_types29 = require("@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;
@@ -12343,13 +12472,13 @@ function kafkaEndpointsFromFile(file, serviceDir) {
       // call sites — verified-call-site tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path41.default.relative(serviceDir, file.path),
+        file: import_node_path42.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
     });
   };
-  if (import_node_path41.default.extname(file.path) === ".go") {
+  if (import_node_path42.default.extname(file.path) === ".go") {
     goSaramaEndpoints(file.content, make);
   } else {
     for (const { topic } of findAll(PRODUCER_TOPIC_RE, file.content)) make(topic, "PUBLISHES_TO");
@@ -12360,7 +12489,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/redis.ts
 init_cjs_shims();
-var import_node_path42 = __toESM(require("path"), 1);
+var import_node_path43 = __toESM(require("path"), 1);
 var import_types30 = require("@neat.is/types");
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
@@ -12383,7 +12512,7 @@ function redisEndpointsFromFile(file, serviceDir) {
       // support tier (ADR-066).
       confidenceKind: "url-with-structural-support",
       evidence: {
-        file: import_node_path42.default.relative(serviceDir, file.path),
+        file: import_node_path43.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12394,7 +12523,7 @@ function redisEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/aws.ts
 init_cjs_shims();
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_path44 = __toESM(require("path"), 1);
 var import_types31 = require("@neat.is/types");
 var S3_BUCKET_RE = /Bucket\s*:\s*['"`]([^'"`]+)['"`]/g;
 var DYNAMO_TABLE_RE = /TableName\s*:\s*['"`]([^'"`]+)['"`]/g;
@@ -12428,7 +12557,7 @@ function awsEndpointsFromFile(file, serviceDir) {
       // (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path43.default.relative(serviceDir, file.path),
+        file: import_node_path44.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12453,7 +12582,7 @@ function awsEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/grpc.ts
 init_cjs_shims();
-var import_node_path44 = __toESM(require("path"), 1);
+var import_node_path45 = __toESM(require("path"), 1);
 var import_types32 = require("@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;
@@ -12512,7 +12641,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path44.default.relative(serviceDir, file.path),
+        file: import_node_path45.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12523,7 +12652,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/supabase.ts
 init_cjs_shims();
-var import_node_path45 = __toESM(require("path"), 1);
+var import_node_path46 = __toESM(require("path"), 1);
 var import_types33 = require("@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['"`]/;
@@ -12582,7 +12711,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066), the same grade aws.ts / grpc.ts emit at.
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path45.default.relative(serviceDir, file.path),
+        file: import_node_path46.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12609,7 +12738,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         evidence: {
-          file: import_node_path45.default.relative(serviceDir, file.path),
+          file: import_node_path46.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -12621,7 +12750,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/firestore.ts
 init_cjs_shims();
-var import_node_path46 = __toESM(require("path"), 1);
+var import_node_path47 = __toESM(require("path"), 1);
 var import_tree_sitter8 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript6 = __toESM(require("tree-sitter-javascript"), 1);
 var import_types34 = require("@neat.is/types");
@@ -12794,7 +12923,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(import_node_path46.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt2(import_node_path47.default.extname(file.path)), file.content);
   const clientVars = firestoreClientVars(tree.rootNode);
   for (const n of importedNames) clientVars.add(n);
   const collLine = /* @__PURE__ */ new Map();
@@ -12899,7 +13028,7 @@ function firestoreEndpointsFromFile(file, serviceDir, imported) {
       ...columnSet.size > 0 ? { columns: [...columnSet] } : {},
       ...sdkWrites ? { sdkWrites } : {},
       evidence: {
-        file: import_node_path46.default.relative(serviceDir, file.path),
+        file: import_node_path47.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12959,7 +13088,7 @@ function sdkOf(content) {
   return hasClient && !hasAdmin ? "client" : hasAdmin && !hasClient ? "admin" : null;
 }
 function parseOrNull(file) {
-  const ext = import_node_path46.default.extname(file.path);
+  const ext = import_node_path47.default.extname(file.path);
   if (!(ext in GRAMMAR_BY_EXT)) return null;
   try {
     return parseSource3(parserForExt2(ext), file.content).rootNode;
@@ -12975,7 +13104,7 @@ async function firestoreCrossFileEndpoints(files, serviceDir) {
     if (!root) continue;
     const names = exportedFirestoreClients(root);
     if (names.size === 0) continue;
-    registry.set(toPosix(import_node_path46.default.relative(serviceDir, f.path)), { names, sdk: sdkOf(f.content) });
+    registry.set(toPosix(import_node_path47.default.relative(serviceDir, f.path)), { names, sdk: sdkOf(f.content) });
   }
   if (registry.size === 0) return [];
   const out = [];
@@ -12988,7 +13117,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, import_node_path46.default.dirname(f.path), serviceDir, null);
+      const rel = await resolveJsImport(b.specifier, import_node_path47.default.dirname(f.path), serviceDir, null);
       if (!rel) continue;
       const entry = registry.get(rel);
       if (!entry || !entry.names.has(b.imported)) continue;
@@ -13003,7 +13132,7 @@ async function firestoreCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/mongoose.ts
 init_cjs_shims();
-var import_node_path47 = __toESM(require("path"), 1);
+var import_node_path48 = __toESM(require("path"), 1);
 var import_types35 = require("@neat.is/types");
 var MONGOOSE_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])mongoose['"`]/;
 var MONGODB_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])mongodb['"`]/;
@@ -13154,7 +13283,7 @@ function endpoint(r, file, serviceDir, matchText) {
     kind: r.kind,
     edgeType: "CALLS",
     confidenceKind: "verified-call-site",
-    evidence: { file: import_node_path47.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+    evidence: { file: import_node_path48.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
   };
 }
 function mongooseEndpointsFromFile(file, serviceDir) {
@@ -13244,7 +13373,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(import_node_path47.default.relative(serviceDir, f.path)), fx);
+    if (fx) registry.set(toPosix(import_node_path48.default.relative(serviceDir, f.path)), fx);
   }
   if (registry.size === 0) return [];
   const out = [];
@@ -13255,7 +13384,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, import_node_path47.default.dirname(f.path), serviceDir, null);
+      const resolvedRel = await resolveJsImport(b.specifier, import_node_path48.default.dirname(f.path), serviceDir, null);
       if (!resolvedRel) continue;
       const fx = registry.get(resolvedRel);
       if (!fx) continue;
@@ -13299,7 +13428,7 @@ async function mongooseCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/sqlalchemy.ts
 init_cjs_shims();
-var import_node_path48 = __toESM(require("path"), 1);
+var import_node_path49 = __toESM(require("path"), 1);
 var import_tree_sitter9 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_python5 = __toESM(require("tree-sitter-python"), 1);
 var import_types36 = require("@neat.is/types");
@@ -13438,7 +13567,7 @@ function sqlalchemyForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: import_node_path48.default.relative(serviceDir, file.path),
+          file: import_node_path49.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -13463,7 +13592,7 @@ function sqlalchemyEndpointsFromFile(file, serviceDir) {
       confidenceKind: "verified-call-site",
       ...columns && columns.length > 0 ? { columns } : {},
       evidence: {
-        file: import_node_path48.default.relative(serviceDir, file.path),
+        file: import_node_path49.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -13570,7 +13699,7 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         evidence: {
-          file: import_node_path48.default.relative(serviceDir, file.path),
+          file: import_node_path49.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -13582,7 +13711,7 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/socket.ts
 init_cjs_shims();
-var import_node_path49 = __toESM(require("path"), 1);
+var import_node_path50 = __toESM(require("path"), 1);
 var import_tree_sitter10 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_python6 = __toESM(require("tree-sitter-python"), 1);
 var import_types37 = require("@neat.is/types");
@@ -13658,7 +13787,7 @@ function socketEndpointsFromFile(file, serviceDir) {
       // A verified `socket.socket(...)` + `.connect((host, port))` call site.
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path49.default.relative(serviceDir, file.path),
+        file: import_node_path50.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -13669,7 +13798,7 @@ function socketEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/django-orm.ts
 init_cjs_shims();
-var import_node_path50 = __toESM(require("path"), 1);
+var import_node_path51 = __toESM(require("path"), 1);
 var import_tree_sitter11 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_python7 = __toESM(require("tree-sitter-python"), 1);
 var import_types38 = require("@neat.is/types");
@@ -13739,7 +13868,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
   const tree = parseSource8(makePyParser5(), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const defaultAppLabel = import_node_path50.default.basename(import_node_path50.default.dirname(file.path));
+  const defaultAppLabel = import_node_path51.default.basename(import_node_path51.default.dirname(file.path));
   walk5(tree.rootNode, (node) => {
     if (node.type !== "class_definition") return;
     if (!extendsDjangoModel(node)) return;
@@ -13757,7 +13886,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
-      evidence: { file: import_node_path50.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+      evidence: { file: import_node_path51.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
     });
   });
   return out;
@@ -13765,7 +13894,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/drizzle.ts
 init_cjs_shims();
-var import_node_path51 = __toESM(require("path"), 1);
+var import_node_path52 = __toESM(require("path"), 1);
 var import_tree_sitter12 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript7 = __toESM(require("tree-sitter-javascript"), 1);
 var import_types39 = require("@neat.is/types");
@@ -13843,7 +13972,7 @@ function columnsFromObject(obj) {
 }
 function drizzleEndpointsFromFile(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(import_node_path51.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(import_node_path52.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk11 = (node) => {
@@ -13866,7 +13995,7 @@ function drizzleEndpointsFromFile(file, serviceDir) {
             confidenceKind: "structural",
             columns,
             evidence: {
-              file: import_node_path51.default.relative(serviceDir, file.path),
+              file: import_node_path52.default.relative(serviceDir, file.path),
               line,
               snippet: snippet(file.content, line)
             }
@@ -13932,7 +14061,7 @@ function referencesTargetVar(call) {
 }
 function drizzleForeignKeys(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(import_node_path51.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(import_node_path52.default.extname(file.path)), file.content);
   const { tables, varToTable } = collectDrizzleTables(tree.rootNode);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -13951,7 +14080,7 @@ function drizzleForeignKeys(file, serviceDir) {
               childTable: table.tableName,
               parentTable,
               evidence: {
-                file: import_node_path51.default.relative(serviceDir, file.path),
+                file: import_node_path52.default.relative(serviceDir, file.path),
                 line,
                 snippet: snippet(file.content, line)
               }
@@ -13968,7 +14097,7 @@ function drizzleForeignKeys(file, serviceDir) {
 
 // src/extract/calls/prisma.ts
 init_cjs_shims();
-var import_node_path52 = __toESM(require("path"), 1);
+var import_node_path53 = __toESM(require("path"), 1);
 var import_types40 = require("@neat.is/types");
 var SCALAR_TYPES = /* @__PURE__ */ new Set([
   "Int",
@@ -14024,7 +14153,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
       confidenceKind: "structural",
       columns: b.columns,
       evidence: {
-        file: import_node_path52.default.relative(serviceDir, file.path),
+        file: import_node_path53.default.relative(serviceDir, file.path),
         line: b.startLine,
         snippet: snippet(content, b.startLine)
       }
@@ -14085,7 +14214,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
 }
 async function prismaColumnEndpoints(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    import_node_path52.default.join("prisma", "schema.prisma"),
+    import_node_path53.default.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -14160,7 +14289,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
               childTable: current.table,
               parentTable,
               evidence: {
-                file: import_node_path52.default.relative(serviceDir, file.path),
+                file: import_node_path53.default.relative(serviceDir, file.path),
                 line: lineNo,
                 snippet: snippet(content, lineNo)
               }
@@ -14175,7 +14304,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
 }
 async function prismaForeignKeys(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    import_node_path52.default.join("prisma", "schema.prisma"),
+    import_node_path53.default.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -14186,7 +14315,7 @@ async function prismaForeignKeys(serviceDir) {
 
 // src/extract/calls/activerecord.ts
 init_cjs_shims();
-var import_node_path53 = __toESM(require("path"), 1);
+var import_node_path54 = __toESM(require("path"), 1);
 var import_tree_sitter13 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_ruby3 = __toESM(require("tree-sitter-ruby"), 1);
 var import_types41 = require("@neat.is/types");
@@ -14394,7 +14523,7 @@ function railsSchemaEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...table.columns.length > 0 ? { columns: table.columns } : {},
       evidence: {
-        file: import_node_path53.default.relative(serviceDir, file.path),
+        file: import_node_path54.default.relative(serviceDir, file.path),
         line: table.line,
         snippet: snippet(file.content, table.line)
       }
@@ -14416,7 +14545,7 @@ function railsSchemaForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: import_node_path53.default.relative(serviceDir, file.path),
+        file: import_node_path54.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14499,7 +14628,7 @@ function railsModelEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path53.default.relative(serviceDir, file.path),
+        file: import_node_path54.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14536,7 +14665,7 @@ function railsModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: import_node_path53.default.relative(serviceDir, file.path),
+          file: import_node_path54.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -14548,7 +14677,7 @@ function railsModelForeignKeys(file, serviceDir) {
 
 // src/extract/calls/eloquent.ts
 init_cjs_shims();
-var import_node_path54 = __toESM(require("path"), 1);
+var import_node_path55 = __toESM(require("path"), 1);
 var import_tree_sitter14 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_php3 = __toESM(require("tree-sitter-php"), 1);
 var import_types42 = require("@neat.is/types");
@@ -14805,7 +14934,7 @@ function laravelMigrationEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: import_node_path54.default.relative(serviceDir, file.path),
+        file: import_node_path55.default.relative(serviceDir, file.path),
         line: bp.line,
         snippet: snippet(file.content, bp.line)
       }
@@ -14827,7 +14956,7 @@ function laravelMigrationForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: import_node_path54.default.relative(serviceDir, file.path),
+        file: import_node_path55.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14947,7 +15076,7 @@ function laravelModelEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path54.default.relative(serviceDir, file.path),
+        file: import_node_path55.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14983,7 +15112,7 @@ function laravelModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: import_node_path54.default.relative(serviceDir, file.path),
+          file: import_node_path55.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -14995,7 +15124,7 @@ function laravelModelForeignKeys(file, serviceDir) {
 
 // src/extract/calls/go.ts
 init_cjs_shims();
-var import_node_path57 = __toESM(require("path"), 1);
+var import_node_path58 = __toESM(require("path"), 1);
 var import_tree_sitter15 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_go4 = __toESM(require("tree-sitter-go"), 1);
 var import_types43 = require("@neat.is/types");
@@ -15070,7 +15199,7 @@ function firstStringLiteralArg(argsNode) {
   return null;
 }
 function goSqlEndpointsFromFile(file, serviceDir) {
-  if (import_node_path57.default.extname(file.path) !== ".go") return [];
+  if (import_node_path58.default.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]));
@@ -15099,7 +15228,7 @@ function goSqlEndpointsFromFile(file, serviceDir) {
       confidenceKind: "verified-call-site",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(import_node_path57.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path58.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -15110,7 +15239,7 @@ function goSqlEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/gorm.ts
 init_cjs_shims();
-var import_node_path58 = __toESM(require("path"), 1);
+var import_node_path59 = __toESM(require("path"), 1);
 var import_tree_sitter16 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_go5 = __toESM(require("tree-sitter-go"), 1);
 var import_types44 = require("@neat.is/types");
@@ -15543,7 +15672,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
   seen.delete(struct.name);
 }
 function gormEndpointsFromFile(file, serviceDir) {
-  if (import_node_path58.default.extname(file.path) !== ".go") return [];
+  if (import_node_path59.default.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);
@@ -15565,7 +15694,7 @@ function gormEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(import_node_path58.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path59.default.relative(serviceDir, file.path)),
         line: struct.line,
         snippet: snippet(file.content, struct.line)
       }
@@ -15574,7 +15703,7 @@ function gormEndpointsFromFile(file, serviceDir) {
   return out;
 }
 function gormForeignKeys(file, serviceDir) {
-  if (import_node_path58.default.extname(file.path) !== ".go") return [];
+  if (import_node_path59.default.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);
@@ -15589,7 +15718,7 @@ function gormForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: toPosix(import_node_path58.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path59.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -15626,7 +15755,7 @@ function gormForeignKeys(file, serviceDir) {
 
 // src/extract/calls/efcore.ts
 init_cjs_shims();
-var import_node_path59 = __toESM(require("path"), 1);
+var import_node_path60 = __toESM(require("path"), 1);
 var import_tree_sitter17 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_c_sharp2 = __toESM(require("tree-sitter-c-sharp"), 1);
 var import_types45 = require("@neat.is/types");
@@ -15705,7 +15834,7 @@ function tableFromToTable(call) {
   return value ? csStringLiteral(value) : null;
 }
 function efcoreEndpointsFromFile(file, serviceDir) {
-  if (import_node_path59.default.extname(file.path) !== ".cs") return [];
+  if (import_node_path60.default.extname(file.path) !== ".cs") return [];
   if (!EFCORE_GATE.test(file.content)) return [];
   const tree = parseSource13(makeCsParser(), file.content);
   const out = [];
@@ -15720,7 +15849,7 @@ function efcoreEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "structural",
       evidence: {
-        file: toPosix(import_node_path59.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path60.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -15975,7 +16104,7 @@ init_cjs_shims();
 
 // src/extract/infra/docker-compose.ts
 init_cjs_shims();
-var import_node_path60 = __toESM(require("path"), 1);
+var import_node_path61 = __toESM(require("path"), 1);
 var import_types49 = require("@neat.is/types");
 
 // src/extract/infra/shared.ts
@@ -16046,7 +16175,7 @@ function dependsOnList(value) {
 }
 function serviceNameToServiceNode(name, services) {
   for (const s of services) {
-    if (s.node.name === name || import_node_path60.default.basename(s.dir) === name) return s.node.id;
+    if (s.node.name === name || import_node_path61.default.basename(s.dir) === name) return s.node.id;
   }
   return null;
 }
@@ -16055,7 +16184,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 = import_node_path60.default.join(scanPath, name);
+    const abs = import_node_path61.default.join(scanPath, name);
     if (await exists2(abs)) {
       composePath = abs;
       break;
@@ -16068,13 +16197,13 @@ async function addComposeInfra(graph, scanPath, services) {
   } catch (err) {
     recordExtractionError(
       "infra docker-compose",
-      import_node_path60.default.relative(scanPath, composePath),
+      import_node_path61.default.relative(scanPath, composePath),
       err
     );
     return { nodesAdded, edgesAdded };
   }
   if (!compose?.services) return { nodesAdded, edgesAdded };
-  const evidenceFile = import_node_path60.default.relative(scanPath, composePath).split(import_node_path60.default.sep).join("/");
+  const evidenceFile = import_node_path61.default.relative(scanPath, composePath).split(import_node_path61.default.sep).join("/");
   const composeNameToNodeId = /* @__PURE__ */ new Map();
   for (const [composeName, svc] of Object.entries(compose.services)) {
     const matchedServiceId = serviceNameToServiceNode(composeName, services);
@@ -16116,8 +16245,8 @@ async function addComposeInfra(graph, scanPath, services) {
 
 // src/extract/infra/dockerfile.ts
 init_cjs_shims();
-var import_node_path61 = __toESM(require("path"), 1);
-var import_node_fs27 = require("fs");
+var import_node_path62 = __toESM(require("path"), 1);
+var import_node_fs28 = require("fs");
 var import_types50 = require("@neat.is/types");
 function readDockerfile(content) {
   let image = null;
@@ -16147,15 +16276,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const dockerfilePath = import_node_path61.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path62.default.join(service.dir, "Dockerfile");
     if (!await exists2(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs27.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs28.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError(
         "infra dockerfile",
-        import_node_path61.default.relative(scanPath, dockerfilePath),
+        import_node_path62.default.relative(scanPath, dockerfilePath),
         err
       );
       continue;
@@ -16167,8 +16296,8 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const relDockerfile = toPosix(import_node_path61.default.relative(service.dir, dockerfilePath));
-    const evidenceFile = toPosix(import_node_path61.default.relative(scanPath, dockerfilePath));
+    const relDockerfile = toPosix(import_node_path62.default.relative(service.dir, dockerfilePath));
+    const evidenceFile = toPosix(import_node_path62.default.relative(scanPath, dockerfilePath));
     const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
       graph,
       service.pkg.name,
@@ -16220,23 +16349,23 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 
 // src/extract/infra/terraform.ts
 init_cjs_shims();
-var import_node_fs28 = require("fs");
-var import_node_path62 = __toESM(require("path"), 1);
+var import_node_fs29 = require("fs");
+var import_node_path63 = __toESM(require("path"), 1);
 var import_types51 = require("@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 import_node_fs28.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs29.promises.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 = import_node_path62.default.join(start, entry.name);
+      const child = import_node_path63.default.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(import_node_path62.default.join(start, entry.name));
+      out.push(import_node_path63.default.join(start, entry.name));
     }
   }
   return out;
@@ -16267,8 +16396,8 @@ async function addTerraformResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkTfFiles(scanPath);
   for (const file of files) {
-    const content = await import_node_fs28.promises.readFile(file, "utf8");
-    const evidenceFile = toPosix(import_node_path62.default.relative(scanPath, file));
+    const content = await import_node_fs29.promises.readFile(file, "utf8");
+    const evidenceFile = toPosix(import_node_path63.default.relative(scanPath, file));
     const resources = [];
     const byKey = /* @__PURE__ */ new Map();
     RESOURCE_RE.lastIndex = 0;
@@ -16325,8 +16454,8 @@ async function addTerraformResources(graph, scanPath) {
 
 // src/extract/infra/k8s.ts
 init_cjs_shims();
-var import_node_fs29 = require("fs");
-var import_node_path63 = __toESM(require("path"), 1);
+var import_node_fs30 = require("fs");
+var import_node_path64 = __toESM(require("path"), 1);
 var import_yaml3 = require("yaml");
 var import_types52 = require("@neat.is/types");
 var K8S_KIND_TO_INFRA_KIND = {
@@ -16342,15 +16471,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 import_node_fs29.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs30.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path63.default.join(start, entry.name);
+      const child = import_node_path64.default.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(import_node_path63.default.extname(entry.name))) {
-      out.push(import_node_path63.default.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path64.default.extname(entry.name))) {
+      out.push(import_node_path64.default.join(start, entry.name));
     }
   }
   return out;
@@ -16360,14 +16489,14 @@ async function addK8sResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkYamlFiles2(scanPath);
   for (const file of files) {
-    const content = await import_node_fs29.promises.readFile(file, "utf8");
+    const content = await import_node_fs30.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml3.parseAllDocuments)(content).map((d) => d.toJSON());
     } catch {
       continue;
     }
-    const relFile = toPosix(import_node_path63.default.relative(scanPath, file));
+    const relFile = toPosix(import_node_path64.default.relative(scanPath, file));
     for (const doc of docs) {
       if (!doc?.kind || !doc.metadata?.name) continue;
       const infraKind = K8S_KIND_TO_INFRA_KIND[doc.kind];
@@ -16416,16 +16545,16 @@ async function addK8sResources(graph, scanPath) {
 
 // src/extract/infra/cloudflare.ts
 init_cjs_shims();
-var import_node_fs30 = require("fs");
-var import_node_path64 = __toESM(require("path"), 1);
+var import_node_fs31 = require("fs");
+var import_node_path65 = __toESM(require("path"), 1);
 var import_smol_toml3 = require("smol-toml");
 var import_types53 = require("@neat.is/types");
 var WRANGLER_FILENAMES = ["wrangler.toml", "wrangler.jsonc", "wrangler.json"];
 async function readWranglerConfig(dir) {
   for (const filename of WRANGLER_FILENAMES) {
-    const abs = import_node_path64.default.join(dir, filename);
+    const abs = import_node_path65.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs30.promises.readFile(abs, "utf8");
+    const raw = await import_node_fs31.promises.readFile(abs, "utf8");
     const config = filename === "wrangler.toml" ? (0, import_smol_toml3.parse)(raw) : JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
@@ -16486,11 +16615,11 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     try {
       read = await readWranglerConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra cloudflare", import_node_path64.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra cloudflare", import_node_path65.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read || !read.config.name) continue;
-    const evidenceFile = toPosix(import_node_path64.default.relative(scanPath, import_node_path64.default.join(service.dir, read.relFile)));
+    const evidenceFile = toPosix(import_node_path65.default.relative(scanPath, import_node_path65.default.join(service.dir, read.relFile)));
     discovered.push({ service, config: read.config, relFile: read.relFile, raw: read.raw, evidenceFile });
   }
   for (const worker of discovered) {
@@ -16502,7 +16631,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     }
     let anchorId = service.node.id;
     if (config.main) {
-      const entryRelPath = toPosix(import_node_path64.default.normalize(config.main));
+      const entryRelPath = toPosix(import_node_path65.default.normalize(config.main));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -16649,24 +16778,24 @@ async function addCloudflareWorkers(graph, services, scanPath) {
 
 // src/extract/infra/vercel.ts
 init_cjs_shims();
-var import_node_fs31 = require("fs");
-var import_node_path65 = __toESM(require("path"), 1);
+var import_node_fs32 = require("fs");
+var import_node_path66 = __toESM(require("path"), 1);
 var import_types54 = require("@neat.is/types");
 var VERCEL_CONFIG_FILENAMES = ["vercel.json", "vercel.jsonc"];
 async function readVercelConfig(dir) {
   for (const filename of VERCEL_CONFIG_FILENAMES) {
-    const abs = import_node_path65.default.join(dir, filename);
+    const abs = import_node_path66.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs31.promises.readFile(abs, "utf8");
+    const raw = await import_node_fs32.promises.readFile(abs, "utf8");
     const config = JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
   return null;
 }
 async function readLinkedProjectName(dir) {
-  const abs = import_node_path65.default.join(dir, ".vercel", "project.json");
+  const abs = import_node_path66.default.join(dir, ".vercel", "project.json");
   if (!await exists2(abs)) return void 0;
-  const parsed = JSON.parse(await import_node_fs31.promises.readFile(abs, "utf8"));
+  const parsed = JSON.parse(await import_node_fs32.promises.readFile(abs, "utf8"));
   return typeof parsed.projectName === "string" ? parsed.projectName : void 0;
 }
 function routeSource(route) {
@@ -16682,7 +16811,7 @@ async function addVercelServices(graph, services, scanPath) {
       read = await readVercelConfig(service.dir);
       projectName = await readLinkedProjectName(service.dir);
     } catch (err) {
-      recordExtractionError("infra vercel", import_node_path65.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra vercel", import_node_path66.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read && !projectName) continue;
@@ -16698,7 +16827,7 @@ async function addVercelServices(graph, services, scanPath) {
     const anchorId = service.node.id;
     if (!read) continue;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(import_node_path65.default.relative(scanPath, import_node_path65.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path66.default.relative(scanPath, import_node_path66.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -16727,16 +16856,16 @@ async function addVercelServices(graph, services, scanPath) {
 
 // src/extract/infra/railway.ts
 init_cjs_shims();
-var import_node_fs32 = require("fs");
-var import_node_path66 = __toESM(require("path"), 1);
+var import_node_fs33 = require("fs");
+var import_node_path67 = __toESM(require("path"), 1);
 var import_smol_toml4 = require("smol-toml");
 var import_types55 = require("@neat.is/types");
 var RAILWAY_FILENAMES = ["railway.toml", "railway.json", "railway.jsonc"];
 async function readRailwayConfig(dir) {
   for (const filename of RAILWAY_FILENAMES) {
-    const abs = import_node_path66.default.join(dir, filename);
+    const abs = import_node_path67.default.join(dir, filename);
     if (!await exists2(abs)) continue;
-    const raw = await import_node_fs32.promises.readFile(abs, "utf8");
+    const raw = await import_node_fs33.promises.readFile(abs, "utf8");
     const config = filename === "railway.toml" ? (0, import_smol_toml4.parse)(raw) : JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
@@ -16750,7 +16879,7 @@ async function addRailwayServices(graph, services, scanPath) {
     try {
       read = await readRailwayConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra railway", import_node_path66.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra railway", import_node_path67.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -16760,7 +16889,7 @@ async function addRailwayServices(graph, services, scanPath) {
     }
     const anchorId = service.node.id;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(import_node_path66.default.relative(scanPath, import_node_path66.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path67.default.relative(scanPath, import_node_path67.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -16785,15 +16914,15 @@ async function addRailwayServices(graph, services, scanPath) {
 
 // src/extract/infra/supabase.ts
 init_cjs_shims();
-var import_node_fs33 = require("fs");
-var import_node_path67 = __toESM(require("path"), 1);
+var import_node_fs34 = require("fs");
+var import_node_path68 = __toESM(require("path"), 1);
 var import_smol_toml5 = require("smol-toml");
 var import_types56 = require("@neat.is/types");
 async function readSupabaseConfig(dir) {
-  const relFile = import_node_path67.default.join("supabase", "config.toml");
-  const abs = import_node_path67.default.join(dir, relFile);
+  const relFile = import_node_path68.default.join("supabase", "config.toml");
+  const abs = import_node_path68.default.join(dir, relFile);
   if (!await exists2(abs)) return null;
-  const raw = await import_node_fs33.promises.readFile(abs, "utf8");
+  const raw = await import_node_fs34.promises.readFile(abs, "utf8");
   const config = (0, import_smol_toml5.parse)(raw);
   return { config, relFile, raw };
 }
@@ -16805,7 +16934,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
     try {
       read = await readSupabaseConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra supabase", import_node_path67.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra supabase", import_node_path68.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -16820,7 +16949,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
       });
     }
     const anchorId = service.node.id;
-    const evidenceFile = toPosix(import_node_path67.default.relative(scanPath, import_node_path67.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path68.default.relative(scanPath, import_node_path68.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -16862,7 +16991,7 @@ async function addInfra(graph, scanPath, services) {
 
 // src/extract/zod-shapes.ts
 init_cjs_shims();
-var import_node_path68 = __toESM(require("path"), 1);
+var import_node_path69 = __toESM(require("path"), 1);
 var import_tree_sitter18 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript8 = __toESM(require("tree-sitter-javascript"), 1);
 var import_types57 = require("@neat.is/types");
@@ -16957,7 +17086,7 @@ function topLevelSchemas(root) {
 }
 function zodShapesFromFile(file, serviceDir) {
   if (!ZOD_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt4(import_node_path68.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt4(import_node_path69.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const { name, call } of topLevelSchemas(tree.rootNode)) {
@@ -16975,7 +17104,7 @@ function zodShapesFromFile(file, serviceDir) {
       name,
       fields,
       evidence: {
-        file: import_node_path68.default.relative(serviceDir, file.path),
+        file: import_node_path69.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -17243,12 +17372,12 @@ async function addFirestoreRules(graph, services) {
 }
 
 // src/extract/index.ts
-var import_node_path70 = __toESM(require("path"), 1);
+var import_node_path71 = __toESM(require("path"), 1);
 
 // src/extract/retire.ts
 init_cjs_shims();
-var import_node_fs34 = require("fs");
-var import_node_path69 = __toESM(require("path"), 1);
+var import_node_fs35 = require("fs");
+var import_node_path70 = __toESM(require("path"), 1);
 var import_types59 = require("@neat.is/types");
 function dropOrphanedFileNodes(graph) {
   const orphans = [];
@@ -17269,11 +17398,11 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
     if (edge.provenance !== import_types59.Provenance.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
-    if (import_node_path69.default.isAbsolute(evidenceFile)) {
-      if (!(0, import_node_fs34.existsSync)(evidenceFile)) toDrop.push(id);
+    if (import_node_path70.default.isAbsolute(evidenceFile)) {
+      if (!(0, import_node_fs35.existsSync)(evidenceFile)) toDrop.push(id);
       return;
     }
-    const found = bases.some((base) => (0, import_node_fs34.existsSync)(import_node_path69.default.join(base, evidenceFile)));
+    const found = bases.some((base) => (0, import_node_fs35.existsSync)(import_node_path70.default.join(base, evidenceFile)));
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
@@ -17285,6 +17414,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);
@@ -17329,8 +17459,9 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
     }
   }
   const droppedEntries = drainDroppedExtracted();
+  const skippedEntries = drainSkippedFiles();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
-    const rejectedPath = import_node_path70.default.join(import_node_path70.default.dirname(opts.errorsPath), "rejected.ndjson");
+    const rejectedPath = import_node_path71.default.join(import_node_path71.default.dirname(opts.errorsPath), "rejected.ndjson");
     try {
       await writeRejectedExtracted(droppedEntries, rejectedPath);
     } catch (err) {
@@ -17347,7 +17478,9 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
     errorEntries,
     ghostsRetired,
     extractedDropped: droppedEntries.length,
-    droppedEntries
+    droppedEntries,
+    skippedFiles: skippedEntries.length,
+    skippedEntries
   };
   emitNeatEvent({
     type: "extraction-complete",
@@ -18267,7 +18400,7 @@ async function askGraph(graph, question, opts = {}) {
 
 // src/diff.ts
 init_cjs_shims();
-var import_node_fs35 = require("fs");
+var import_node_fs36 = require("fs");
 async function loadSnapshotForDiff(target) {
   if (/^https?:\/\//i.test(target)) {
     const res = await fetch(target);
@@ -18276,7 +18409,7 @@ async function loadSnapshotForDiff(target) {
     }
     return await res.json();
   }
-  const raw = await import_node_fs35.promises.readFile(target, "utf8");
+  const raw = await import_node_fs36.promises.readFile(target, "utf8");
   return JSON.parse(raw);
 }
 function indexEntries(entries) {
@@ -18344,8 +18477,8 @@ function canonicalJson(value) {
 
 // src/persist.ts
 init_cjs_shims();
-var import_node_fs36 = require("fs");
-var import_node_path71 = __toESM(require("path"), 1);
+var import_node_fs37 = require("fs");
+var import_node_path72 = __toESM(require("path"), 1);
 var import_types62 = require("@neat.is/types");
 var SCHEMA_VERSION = 7;
 function migrateV1ToV2(payload) {
@@ -18400,7 +18533,43 @@ function migrateV2ToV3(payload) {
   return { ...payload, schemaVersion: 3 };
 }
 async function ensureDir(filePath) {
-  await import_node_fs36.promises.mkdir(import_node_path71.default.dirname(filePath), { recursive: true });
+  await import_node_fs37.promises.mkdir(import_node_path72.default.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);
@@ -18410,13 +18579,26 @@ async function saveGraphToDisk(graph, outPath) {
     graph: graph.export()
   };
   const tmp = `${outPath}.tmp`;
-  await import_node_fs36.promises.writeFile(tmp, JSON.stringify(payload), "utf8");
-  await import_node_fs36.promises.rename(tmp, outPath);
+  const handle = await import_node_fs37.promises.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 import_node_fs37.promises.rename(tmp, outPath);
 }
 async function loadGraphFromDisk(graph, outPath) {
   let raw;
   try {
-    raw = await import_node_fs36.promises.readFile(outPath, "utf8");
+    raw = await import_node_fs37.promises.readFile(outPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -18490,23 +18672,23 @@ function startPersistLoop(graph, outPath, opts = {}) {
 
 // src/projects.ts
 init_cjs_shims();
-var import_node_path72 = __toESM(require("path"), 1);
+var import_node_path73 = __toESM(require("path"), 1);
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: import_node_path72.default.join(baseDir, "graph.json"),
-      errorsPath: import_node_path72.default.join(baseDir, "errors.ndjson"),
-      staleEventsPath: import_node_path72.default.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: import_node_path72.default.join(baseDir, "embeddings.json"),
-      policyViolationsPath: import_node_path72.default.join(baseDir, "policy-violations.ndjson")
+      snapshotPath: import_node_path73.default.join(baseDir, "graph.json"),
+      errorsPath: import_node_path73.default.join(baseDir, "errors.ndjson"),
+      staleEventsPath: import_node_path73.default.join(baseDir, "stale-events.ndjson"),
+      embeddingsCachePath: import_node_path73.default.join(baseDir, "embeddings.json"),
+      policyViolationsPath: import_node_path73.default.join(baseDir, "policy-violations.ndjson")
     };
   }
   return {
-    snapshotPath: import_node_path72.default.join(baseDir, `${project}.json`),
-    errorsPath: import_node_path72.default.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: import_node_path72.default.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: import_node_path72.default.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: import_node_path72.default.join(baseDir, `policy-violations.${project}.ndjson`)
+    snapshotPath: import_node_path73.default.join(baseDir, `${project}.json`),
+    errorsPath: import_node_path73.default.join(baseDir, `errors.${project}.ndjson`),
+    staleEventsPath: import_node_path73.default.join(baseDir, `stale-events.${project}.ndjson`),
+    embeddingsCachePath: import_node_path73.default.join(baseDir, `embeddings.${project}.json`),
+    policyViolationsPath: import_node_path73.default.join(baseDir, `policy-violations.${project}.ndjson`)
   };
 }
 var Projects = class {
@@ -18546,20 +18728,20 @@ function parseExtraProjects(raw) {
 
 // src/registry.ts
 init_cjs_shims();
-var import_node_fs37 = require("fs");
+var import_node_fs38 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path73 = __toESM(require("path"), 1);
+var import_node_path74 = __toESM(require("path"), 1);
 var import_types63 = require("@neat.is/types");
 function neatHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path73.default.resolve(override);
-  return import_node_path73.default.join(import_node_os3.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path74.default.resolve(override);
+  return import_node_path74.default.join(import_node_os3.default.homedir(), ".neat");
 }
 function registryPath() {
-  return import_node_path73.default.join(neatHome(), "projects.json");
+  return import_node_path74.default.join(neatHome(), "projects.json");
 }
 function daemonsDir() {
-  return import_node_path73.default.join(neatHome(), "daemons");
+  return import_node_path74.default.join(neatHome(), "daemons");
 }
 function isFiniteInt(v) {
   return typeof v === "number" && Number.isFinite(v);
@@ -18592,7 +18774,7 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const dir = daemonsDir();
   let names;
   try {
-    names = await import_node_fs37.promises.readdir(dir);
+    names = await import_node_fs38.promises.readdir(dir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -18600,10 +18782,10 @@ async function discoverDaemons(probe = defaultDiscoveryProbe) {
   const out = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const file = import_node_path73.default.join(dir, name);
+    const file = import_node_path74.default.join(dir, name);
     let raw;
     try {
-      raw = await import_node_fs37.promises.readFile(file, "utf8");
+      raw = await import_node_fs38.promises.readFile(file, "utf8");
     } catch {
       continue;
     }
@@ -18631,7 +18813,7 @@ async function readRegistry() {
   const file = registryPath();
   let raw;
   try {
-    raw = await import_node_fs37.promises.readFile(file, "utf8");
+    raw = await import_node_fs38.promises.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: 1, projects: [] };
@@ -18714,8 +18896,8 @@ init_auth();
 // src/connectors-config.ts
 init_cjs_shims();
 var import_node_os4 = __toESM(require("os"), 1);
-var import_node_path74 = __toESM(require("path"), 1);
-var import_node_fs38 = require("fs");
+var import_node_path75 = __toESM(require("path"), 1);
+var import_node_fs39 = require("fs");
 var CONNECTORS_CONFIG_VERSION = 1;
 var EnvRefUnsetError = class extends Error {
   ref;
@@ -18729,17 +18911,17 @@ var EnvRefUnsetError = class extends Error {
 };
 function neatHome2() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path74.default.resolve(override);
-  return import_node_path74.default.join(import_node_os4.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path75.default.resolve(override);
+  return import_node_path75.default.join(import_node_os4.default.homedir(), ".neat");
 }
 function connectorsConfigPath(home = neatHome2()) {
-  return import_node_path74.default.join(home, "connectors.json");
+  return import_node_path75.default.join(home, "connectors.json");
 }
 var MODE_MASK_LOOSER_THAN_0600 = 63;
 async function warnIfModeLooserThan0600(file) {
   if (process.platform === "win32") return;
   try {
-    const stat = await import_node_fs38.promises.stat(file);
+    const stat = await import_node_fs39.promises.stat(file);
     if ((stat.mode & MODE_MASK_LOOSER_THAN_0600) !== 0) {
       const mode = (stat.mode & 511).toString(8).padStart(3, "0");
       console.warn(
@@ -18753,7 +18935,7 @@ async function readConnectorsConfig(home = neatHome2()) {
   const file = connectorsConfigPath(home);
   let raw;
   try {
-    raw = await import_node_fs38.promises.readFile(file, "utf8");
+    raw = await import_node_fs39.promises.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: CONNECTORS_CONFIG_VERSION, connectors: [] };
@@ -19507,10 +19689,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(path77) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path77);
+function targetFromRestPath(path78) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path78);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path77);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path78);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -20114,9 +20296,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path77 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path77) return null;
-  return { resourceName, method, path: path77 };
+  const path78 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path78) return null;
+  return { resourceName, method, path: path78 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -20154,14 +20336,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 path77 = pathFromRequestUrl(req.requestUrl);
-  if (path77 === null) return null;
+  const path78 = pathFromRequestUrl(req.requestUrl);
+  if (path78 === 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: path77 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path78 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -20186,9 +20368,9 @@ var import_types71 = require("@neat.is/types");
 function normalizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function inferServiceName(graph, resourceName, method, path77) {
+function inferServiceName(graph, resourceName, method, path78) {
   const wantedMethod = method.toUpperCase();
-  const wantedPath = normalizePathTemplate(path77);
+  const wantedPath = normalizePathTemplate(path78);
   const services = [];
   const owners = /* @__PURE__ */ new Set();
   graph.forEachNode((_id, attrs) => {
@@ -20405,7 +20587,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 path77 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path78 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -20413,7 +20595,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path77 ? { path: path77 } : {},
+    ...path78 ? { path: path78 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -20459,8 +20641,8 @@ function findTaggedWorkerFileNode(graph, workerName) {
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path77) {
-  const normalizedPath = normalizePathTemplate(path77);
+function findMatchingRouteNode(graph, serviceName, method, path78) {
+  const normalizedPath = normalizePathTemplate(path78);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
@@ -20477,10 +20659,10 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path77 } = signal;
+    const { method, path: path78 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path77) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path77) ?? wholeFileId;
+      if (!method || !path78) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path78) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
@@ -20832,9 +21014,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path77 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path77) return null;
-  return { serviceName, method, path: path77 };
+  const path78 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path78) return null;
+  return { serviceName, method, path: path78 };
 }
 
 // src/connectors/cloud-run/map.ts
@@ -20863,14 +21045,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 path77 = pathFromRequestUrl2(req.requestUrl);
-  if (path77 === null) return null;
+  const path78 = pathFromRequestUrl2(req.requestUrl);
+  if (path78 === 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: path77 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path78 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -20909,14 +21091,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: path77 } = identity;
-    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path77) ?? void 0 : void 0);
+    const { serviceName: gcpServiceName, method, path: path78 } = identity;
+    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path78) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path77)
+        normalizePathTemplate(path78)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types82.EdgeType.CALLS };
@@ -21052,9 +21234,9 @@ function parseGcpLbTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP3);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path77 = rest.slice(secondSep + 1);
-  if (!backendServiceName || !method || !path77) return null;
-  return { backendServiceName, method, path: path77 };
+  const path78 = rest.slice(secondSep + 1);
+  if (!backendServiceName || !method || !path78) return null;
+  return { backendServiceName, method, path: path78 };
 }
 
 // src/connectors/gcp-lb/map.ts
@@ -21083,14 +21265,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 path77 = pathFromRequestUrl3(req.requestUrl);
-  if (path77 === null) return null;
+  const path78 = pathFromRequestUrl3(req.requestUrl);
+  if (path78 === 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: path77 }),
+    targetName: packGcpLbTargetName({ backendServiceName, method, path: path78 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -21129,14 +21311,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: path77 } = identity;
-    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path77) ?? void 0 : void 0);
+    const { backendServiceName, method, path: path78 } = identity;
+    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path78) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode3(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path77)
+        normalizePathTemplate(path78)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types86.EdgeType.CALLS };
@@ -22398,16 +22580,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);
@@ -22419,10 +22603,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;
   }
@@ -23305,8 +23492,8 @@ init_otel_grpc();
 
 // src/search.ts
 init_cjs_shims();
-var import_node_fs39 = require("fs");
-var import_node_path75 = __toESM(require("path"), 1);
+var import_node_fs40 = require("fs");
+var import_node_path76 = __toESM(require("path"), 1);
 var import_node_crypto5 = require("crypto");
 var DEFAULT_LIMIT = 10;
 var NOMIC_DIM = 768;
@@ -23460,7 +23647,7 @@ async function pickEmbedder() {
 }
 async function readCache(cachePath) {
   try {
-    const raw = await import_node_fs39.promises.readFile(cachePath, "utf8");
+    const raw = await import_node_fs40.promises.readFile(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1) return null;
     return parsed;
@@ -23469,8 +23656,8 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, cache) {
-  await import_node_fs39.promises.mkdir(import_node_path75.default.dirname(cachePath), { recursive: true });
-  await import_node_fs39.promises.writeFile(cachePath, JSON.stringify(cache));
+  await import_node_fs40.promises.mkdir(import_node_path76.default.dirname(cachePath), { recursive: true });
+  await import_node_fs40.promises.writeFile(cachePath, JSON.stringify(cache));
 }
 var VectorIndex = class {
   constructor(embedder, cachePath) {
@@ -23684,14 +23871,14 @@ async function bootProject(registry, name, scanPath, baseDir) {
 async function main() {
   const baseDirEnv = process.env.NEAT_OUT_DIR;
   const legacyOutPath = process.env.NEAT_OUT_PATH;
-  const baseDir = baseDirEnv ? import_node_path76.default.resolve(baseDirEnv) : legacyOutPath ? import_node_path76.default.resolve(import_node_path76.default.dirname(legacyOutPath)) : import_node_path76.default.resolve("./neat-out");
-  const defaultScanPath = import_node_path76.default.resolve(process.env.NEAT_SCAN_PATH ?? "./demo");
+  const baseDir = baseDirEnv ? import_node_path77.default.resolve(baseDirEnv) : legacyOutPath ? import_node_path77.default.resolve(import_node_path77.default.dirname(legacyOutPath)) : import_node_path77.default.resolve("./neat-out");
+  const defaultScanPath = import_node_path77.default.resolve(process.env.NEAT_SCAN_PATH ?? "./demo");
   const registry = new Projects();
   await bootProject(registry, DEFAULT_PROJECT, defaultScanPath, baseDir);
   for (const name of parseExtraProjects(process.env.NEAT_PROJECTS)) {
     const envKey = `NEAT_PROJECT_SCAN_PATH_${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
     const projectScan = process.env[envKey];
-    await bootProject(registry, name, projectScan ? import_node_path76.default.resolve(projectScan) : void 0, baseDir);
+    await bootProject(registry, name, projectScan ? import_node_path77.default.resolve(projectScan) : void 0, baseDir);
   }
   const host = process.env.HOST ?? "0.0.0.0";
   const port = Number(process.env.PORT ?? 8080);