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

package/dist/index.cjs

@@ -60,8 +60,8 @@ function mountBearerAuth(app, opts) {
   ]);
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path79 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
-    if (exactUnauthPaths.has(path79) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path79)) {
+    const path80 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    if (exactUnauthPaths.has(path80) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path80)) {
       done();
       return;
     }
@@ -193,8 +193,8 @@ function reshapeGrpcRequest(req) {
   };
 }
 function resolveProtoRoot() {
-  const here = import_node_path53.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return import_node_path53.default.resolve(here, "..", "proto");
+  const here = import_node_path54.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return import_node_path54.default.resolve(here, "..", "proto");
 }
 function loadTraceService() {
   const protoRoot = resolveProtoRoot();
@@ -262,13 +262,13 @@ async function startOtelGrpcReceiver(opts) {
     })
   };
 }
-var import_node_url, import_node_path53, import_node_crypto2, grpc, protoLoader;
+var import_node_url, import_node_path54, 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_path53 = __toESM(require("path"), 1);
+    import_node_path54 = __toESM(require("path"), 1);
     import_node_crypto2 = require("crypto");
     grpc = __toESM(require("@grpc/grpc-js"), 1);
     protoLoader = __toESM(require("@grpc/proto-loader"), 1);
@@ -414,8 +414,8 @@ function websocketChannelPathOf(attrs) {
     const v = attrs[key];
     if (typeof v === "string" && v.length > 0) {
       const q = v.indexOf("?");
-      const path79 = q === -1 ? v : v.slice(0, q);
-      if (path79.length > 0) return path79;
+      const path80 = q === -1 ? v : v.slice(0, q);
+      if (path80.length > 0) return path80;
     }
   }
   return void 0;
@@ -477,10 +477,10 @@ function parseOtlpRequest(body) {
   return out;
 }
 function loadProtoRoot() {
-  const here = import_node_path54.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  const protoRoot = import_node_path54.default.resolve(here, "..", "proto");
+  const here = import_node_path55.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  const protoRoot = import_node_path55.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
-  root.resolvePath = (_origin, target) => import_node_path54.default.resolve(protoRoot, target);
+  root.resolvePath = (_origin, target) => import_node_path55.default.resolve(protoRoot, target);
   root.loadSync(
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
@@ -766,12 +766,12 @@ function logSpanHandler(span) {
     `otel: ${span.service} ${span.name} parent=${parent} status=${status2}${db}`
   );
 }
-var import_node_path54, import_node_url2, import_node_zlib, import_fastify, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody, OTLP_STEP_ATTEMPTS, OTLP_STEP_STRIDE;
+var import_node_path55, import_node_url2, import_node_zlib, import_fastify, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody, OTLP_STEP_ATTEMPTS, OTLP_STEP_STRIDE;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path54 = __toESM(require("path"), 1);
+    import_node_path55 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     import_node_zlib = __toESM(require("zlib"), 1);
     import_fastify = __toESM(require("fastify"), 1);
@@ -868,8 +868,8 @@ init_cjs_shims();
 
 // src/ingest.ts
 init_cjs_shims();
-var import_node_fs7 = require("fs");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_fs8 = require("fs");
+var import_node_path9 = __toESM(require("path"), 1);
 var sourceMapJs = __toESM(require("source-map-js"), 1);
 
 // src/policy.ts
@@ -1374,19 +1374,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, path79, edges) {
-    if (path79.length > best.path.length) {
-      best = { path: [...path79], edges: [...edges] };
+  function step(node, path80, edges) {
+    if (path80.length > best.path.length) {
+      best = { path: [...path80], edges: [...edges] };
     }
-    if (path79.length - 1 >= maxDepth) return;
+    if (path80.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);
-      path79.push(srcId);
+      path80.push(srcId);
       edges.push(edge);
-      step(srcId, path79, edges);
-      path79.pop();
+      step(srcId, path80, edges);
+      path80.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -1601,20 +1601,20 @@ function dominantFailingCall(graph, serviceId17, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path79 = [originServiceId];
+  const path80 = [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;
-    path79.push(hop.nextService);
+    path80.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path79, edges, culprit: current };
+  return { path: path80, edges, culprit: current };
 }
 function isStaleCallEdge(e) {
   return e.type === import_types.EdgeType.CALLS && e.provenance === import_types.Provenance.STALE;
@@ -1650,26 +1650,26 @@ function dominantStaleCall(graph, serviceId17, visited) {
   return best;
 }
 function followStaleCallChain(graph, originServiceId, maxDepth) {
-  const path79 = [originServiceId];
+  const path80 = [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;
-    path79.push(hop.nextService);
+    path80.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path79, edges, culprit: current };
+  return { path: path80, 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 path79 = [...chain.path];
+  const path80 = [...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));
@@ -1677,14 +1677,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path79.push(loc.fileNode);
+      path80.push(loc.fileNode);
       edgeProvenances.push(import_types.Provenance.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return import_types.RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path79,
+      traversalPath: path80,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -1696,7 +1696,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   return import_types.RootCauseResultSchema.parse({
     rootCauseNode: culprit,
     rootCauseReason: `${culpritName} is failing downstream calls (${errs} observed error${errs === 1 ? "" : "s"})`,
-    traversalPath: path79,
+    traversalPath: path80,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -2349,10 +2349,10 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
     traversalPath = staleChain.path;
     edgeProvenances = staleChain.edges.map((e) => e.provenance);
   } else if (top.node !== seedNode) {
-    const path79 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
-    if (path79) {
-      traversalPath = path79.nodes;
-      edgeProvenances = path79.edges.map((e) => e.provenance);
+    const path80 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path80) {
+      traversalPath = path80.nodes;
+      edgeProvenances = path80.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
       edgeProvenances = [top.provenance ?? import_types.Provenance.OBSERVED];
@@ -2891,7 +2891,7 @@ var import_types8 = require("@neat.is/types");
 
 // src/extract/routes.ts
 init_cjs_shims();
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var import_tree_sitter2 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript2 = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_python2 = __toESM(require("tree-sitter-python"), 1);
@@ -2917,6 +2917,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
@@ -3148,6 +3159,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";
@@ -3161,14 +3181,91 @@ async function writeRejectedExtracted(drops, rejectedPath) {
 
 // src/extract/calls/shared.ts
 init_cjs_shims();
+var import_node_fs6 = require("fs");
+var import_node_path6 = __toESM(require("path"), 1);
+var import_types4 = require("@neat.is/types");
+
+// src/extract/gitignore.ts
+init_cjs_shims();
 var import_node_fs5 = require("fs");
 var import_node_path5 = __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_fs5.promises.readFile(import_node_path5.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_fs5.promises.stat(import_node_path5.default.join(dir, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadIgnoreChain(startDir) {
+  const dirs = [];
+  let current = import_node_path5.default.resolve(startDir);
+  for (; ; ) {
+    dirs.push(current);
+    if (await isRepoRoot(current)) break;
+    const parent = import_node_path5.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_path5.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_path5.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_path5.default.relative(layer.dir, abs);
+    if (!rel || rel.startsWith("..") || import_node_path5.default.isAbsolute(rel)) continue;
+    const candidate = rel.split(import_node_path5.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_path5.default.basename(service.dir);
+    const base = import_node_path6.default.basename(service.dir);
     knownHosts.add(base);
     knownHosts.add(service.pkg.name);
     hostToNodeId.set(base, service.node.id);
@@ -3177,33 +3274,62 @@ function buildServiceHostIndex(services) {
   return { knownHosts, hostToNodeId };
 }
 async function walkSourceFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => import_node_path5.default.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => import_node_path6.default.resolve(d)));
   const out = [];
-  async function walk11(current) {
-    const entries = await import_node_fs5.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+  const rootChain = await loadIgnoreChain(dir);
+  async function walk11(current, inherited) {
+    const entries = await import_node_fs6.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_path5.default.join(current, entry.name);
+      const full = import_node_path6.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(import_node_path5.default.resolve(full))) continue;
+        if (excluded.has(import_node_path6.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_path5.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_path6.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_path6.default.resolve(l.dir) !== import_node_path6.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_fs5.promises.readFile(p, "utf8");
+      const content = await import_node_fs6.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 {
     }
@@ -3215,15 +3341,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_path5.default.extname(relPath).toLowerCase()) {
+  switch (import_node_path6.default.extname(relPath).toLowerCase()) {
     case ".py":
       return "python";
     case ".go":
@@ -3297,8 +3426,8 @@ function ensureFileNode(graph, serviceName, serviceNodeId, relPath) {
 
 // src/extract/imports.ts
 init_cjs_shims();
-var import_node_path6 = __toESM(require("path"), 1);
-var import_node_fs6 = require("fs");
+var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs7 = require("fs");
 var import_tree_sitter = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_python = __toESM(require("tree-sitter-python"), 1);
@@ -3443,15 +3572,15 @@ function collectPyImports(node, out) {
 }
 async function fileExists(p) {
   try {
-    await import_node_fs6.promises.access(p);
+    await import_node_fs7.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 function isWithinServiceDir(candidate, serviceDir) {
-  const rel = import_node_path6.default.relative(serviceDir, candidate);
-  return rel !== "" && !rel.startsWith("..") && !import_node_path6.default.isAbsolute(rel);
+  const rel = import_node_path7.default.relative(serviceDir, candidate);
+  return rel !== "" && !rel.startsWith("..") && !import_node_path7.default.isAbsolute(rel);
 }
 var JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 var JS_INDEX_FILES = JS_EXTENSIONS.map((ext) => `index${ext}`);
@@ -3459,22 +3588,22 @@ async function firstExistingCandidate(base, serviceDir) {
   for (const ext of JS_EXTENSIONS) {
     const candidate = base + ext;
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix(import_node_path6.default.relative(serviceDir, candidate));
+      return toPosix(import_node_path7.default.relative(serviceDir, candidate));
     }
   }
   for (const indexFile of JS_INDEX_FILES) {
-    const candidate = import_node_path6.default.join(base, indexFile);
+    const candidate = import_node_path7.default.join(base, indexFile);
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix(import_node_path6.default.relative(serviceDir, candidate));
+      return toPosix(import_node_path7.default.relative(serviceDir, candidate));
     }
   }
   return null;
 }
 async function loadTsPathConfig(serviceDir) {
-  const tsconfigPath = import_node_path6.default.join(serviceDir, "tsconfig.json");
+  const tsconfigPath = import_node_path7.default.join(serviceDir, "tsconfig.json");
   let raw;
   try {
-    raw = await import_node_fs6.promises.readFile(tsconfigPath, "utf8");
+    raw = await import_node_fs7.promises.readFile(tsconfigPath, "utf8");
   } catch {
     return null;
   }
@@ -3483,7 +3612,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_path6.default.resolve(serviceDir, baseUrl) : serviceDir };
+    return { paths, baseDir: baseUrl ? import_node_path7.default.resolve(serviceDir, baseUrl) : serviceDir };
   } catch (err) {
     recordExtractionError("import alias resolution", tsconfigPath, err);
     return null;
@@ -3501,11 +3630,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_path6.default.resolve(config.baseDir, targetBase, suffix);
+      const resolvedBase = import_node_path7.default.resolve(config.baseDir, targetBase, suffix);
       const hit = await firstExistingCandidate(resolvedBase, serviceDir);
       if (hit) return hit;
       if (isWithinServiceDir(resolvedBase, serviceDir) && await fileExists(resolvedBase)) {
-        return toPosix(import_node_path6.default.relative(serviceDir, resolvedBase));
+        return toPosix(import_node_path7.default.relative(serviceDir, resolvedBase));
       }
     }
   }
@@ -3514,18 +3643,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_path6.default.resolve(importerDir, specifier);
-    const ext = import_node_path6.default.extname(specifier);
+    const base = import_node_path7.default.resolve(importerDir, specifier);
+    const ext = import_node_path7.default.extname(specifier);
     if (ext) {
       if (ext === ".js" || ext === ".jsx") {
         const tsExt = ext === ".jsx" ? ".tsx" : ".ts";
         const tsSibling = base.slice(0, -ext.length) + tsExt;
         if (isWithinServiceDir(tsSibling, serviceDir) && await fileExists(tsSibling)) {
-          return toPosix(import_node_path6.default.relative(serviceDir, tsSibling));
+          return toPosix(import_node_path7.default.relative(serviceDir, tsSibling));
         }
       }
       if (isWithinServiceDir(base, serviceDir) && await fileExists(base)) {
-        return toPosix(import_node_path6.default.relative(serviceDir, base));
+        return toPosix(import_node_path7.default.relative(serviceDir, base));
       }
       if (!JS_EXTENSIONS.includes(ext)) {
         return firstExistingCandidate(base, serviceDir);
@@ -3540,30 +3669,30 @@ async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
 async function resolvePyImport(imp, importerPath, serviceDir) {
   let baseDir;
   if (imp.level > 0) {
-    baseDir = import_node_path6.default.dirname(importerPath);
-    for (let i = 1; i < imp.level; i++) baseDir = import_node_path6.default.dirname(baseDir);
+    baseDir = import_node_path7.default.dirname(importerPath);
+    for (let i = 1; i < imp.level; i++) baseDir = import_node_path7.default.dirname(baseDir);
   } else {
     baseDir = serviceDir;
   }
-  const moduleBase = imp.modulePath ? import_node_path6.default.join(baseDir, imp.modulePath.split(".").join("/")) : baseDir;
+  const moduleBase = imp.modulePath ? import_node_path7.default.join(baseDir, imp.modulePath.split(".").join("/")) : baseDir;
   const resolved = /* @__PURE__ */ new Set();
   let needModuleFile = imp.names.length === 0;
   for (const name of imp.names) {
-    const submoduleFile = import_node_path6.default.join(moduleBase, `${name}.py`);
-    const subpackageInit = import_node_path6.default.join(moduleBase, name, "__init__.py");
+    const submoduleFile = import_node_path7.default.join(moduleBase, `${name}.py`);
+    const subpackageInit = import_node_path7.default.join(moduleBase, name, "__init__.py");
     if (isWithinServiceDir(submoduleFile, serviceDir) && await fileExists(submoduleFile)) {
-      resolved.add(toPosix(import_node_path6.default.relative(serviceDir, submoduleFile)));
+      resolved.add(toPosix(import_node_path7.default.relative(serviceDir, submoduleFile)));
     } else if (isWithinServiceDir(subpackageInit, serviceDir) && await fileExists(subpackageInit)) {
-      resolved.add(toPosix(import_node_path6.default.relative(serviceDir, subpackageInit)));
+      resolved.add(toPosix(import_node_path7.default.relative(serviceDir, subpackageInit)));
     } else {
       needModuleFile = true;
     }
   }
   if (needModuleFile) {
-    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, import_node_path6.default.join(moduleBase, "__init__.py")] : [import_node_path6.default.join(moduleBase, "__init__.py")];
+    const moduleFileCandidates = imp.modulePath ? [`${moduleBase}.py`, import_node_path7.default.join(moduleBase, "__init__.py")] : [import_node_path7.default.join(moduleBase, "__init__.py")];
     for (const candidate of moduleFileCandidates) {
       if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-        resolved.add(toPosix(import_node_path6.default.relative(serviceDir, candidate)));
+        resolved.add(toPosix(import_node_path7.default.relative(serviceDir, candidate)));
         break;
       }
     }
@@ -3573,11 +3702,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_path6.default.join(serviceDir, suffix);
-  const entries = await import_node_fs6.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_path6.default.join(dir, entry.name));
+  const dir = import_node_path7.default.join(serviceDir, suffix);
+  const entries = await import_node_fs7.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const candidates = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".go") && !entry.name.endsWith("_test.go")).map((entry) => import_node_path7.default.join(dir, entry.name));
   if (candidates.length !== 1) return null;
-  return toPosix(import_node_path6.default.relative(serviceDir, candidates[0]));
+  return toPosix(import_node_path7.default.relative(serviceDir, candidates[0]));
 }
 function emitImportEdge(graph, serviceName, importerFileId, importerRelPath, importeeRelPath, line, snippet2) {
   const importeeFileId = (0, import_types5.fileId)(serviceName, importeeRelPath);
@@ -3607,12 +3736,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_path6.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path7.default.relative(service.dir, file.path));
       const importerFileId = (0, import_types5.fileId)(service.pkg.name, relFile);
-      const isPython = import_node_path6.default.extname(file.path) === ".py";
-      const isGo = import_node_path6.default.extname(file.path) === ".go";
-      if (import_node_path6.default.extname(file.path) === ".rb") continue;
-      if (import_node_path6.default.extname(file.path) === ".php") continue;
+      const isPython = import_node_path7.default.extname(file.path) === ".py";
+      const isGo = import_node_path7.default.extname(file.path) === ".go";
+      if (import_node_path7.default.extname(file.path) === ".rb") continue;
+      if (import_node_path7.default.extname(file.path) === ".php") continue;
       if (isGo) {
         let goImports = [];
         try {
@@ -3622,7 +3751,7 @@ async function addImports(graph, services) {
           recordExtractionError("import extraction", file.path, err);
           continue;
         }
-        const goMod = await import_node_fs6.promises.readFile(import_node_path6.default.join(service.dir, "go.mod"), "utf8").catch(() => "");
+        const goMod = await import_node_fs7.promises.readFile(import_node_path7.default.join(service.dir, "go.mod"), "utf8").catch(() => "");
         const modulePath = goMod.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
         if (!modulePath) continue;
         for (const imp of goImports) {
@@ -3666,7 +3795,7 @@ async function addImports(graph, services) {
         continue;
       }
       for (const imp of jsImports) {
-        const resolved = await resolveJsImport(imp.specifier, import_node_path6.default.dirname(file.path), service.dir, tsPaths);
+        const resolved = await resolveJsImport(imp.specifier, import_node_path7.default.dirname(file.path), service.dir, tsPaths);
         if (!resolved) continue;
         edgesAdded += emitImportEdge(
           graph,
@@ -3791,8 +3920,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path79) {
-  return path79.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path80) {
+  return path80.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -4132,7 +4261,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_path7.default.extname(base));
+  return JS_ROUTE_EXTENSIONS.has(import_node_path8.default.extname(base));
 }
 function nextSegment(seg) {
   if (seg.startsWith("(") && seg.endsWith(")")) return null;
@@ -4464,9 +4593,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path79 = rubyLiteral(k);
-    if (path79 === null) continue;
-    return { path: path79, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path80 = rubyLiteral(k);
+    if (path80 === null) continue;
+    return { path: path80, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -5314,12 +5443,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_path7.default.extname(f.path))) continue;
+    if (!JS_ROUTE_EXTENSIONS.has(import_node_path8.default.extname(f.path))) continue;
     if (isTestPath(f.path)) continue;
-    const rel = toPosix(import_node_path7.default.relative(serviceDir, f.path));
+    const rel = toPosix(import_node_path8.default.relative(serviceDir, f.path));
     try {
       const tree = parseSource2(jsParser, f.content);
-      fileInfo.set(rel, analyzeExpressFile(tree.rootNode, import_node_path7.default.dirname(f.path)));
+      fileInfo.set(rel, analyzeExpressFile(tree.rootNode, import_node_path8.default.dirname(f.path)));
     } catch {
     }
   }
@@ -5418,14 +5547,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_path7.default.extname(file.path);
+      const ext = import_node_path8.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_path7.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path8.default.relative(service.dir, file.path));
       let routes;
       try {
         if (isPhp) {
@@ -5933,7 +6062,7 @@ function languageForExt(relPath) {
 function relPathForRuntimeFile(filepath, serviceNode, scanPath) {
   let p = toPosix2(filepath).replace(/^file:\/\//, "");
   if (scanPath && scanPath.length > 0) {
-    const absRoot = toPosix2(import_node_path8.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
+    const absRoot = toPosix2(import_node_path9.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
     const anchor = absRoot.endsWith("/") ? absRoot : `${absRoot}/`;
     if (p.startsWith(anchor)) return p.slice(anchor.length);
   }
@@ -5961,10 +6090,10 @@ function resolveDistToSrc(absFilepath, line) {
     entry = null;
     const mapPath = `${absFilepath}.map`;
     try {
-      if ((0, import_node_fs7.existsSync)(mapPath)) {
-        const raw = JSON.parse((0, import_node_fs7.readFileSync)(mapPath, "utf8"));
+      if ((0, import_node_fs8.existsSync)(mapPath)) {
+        const raw = JSON.parse((0, import_node_fs8.readFileSync)(mapPath, "utf8"));
         const consumer = new sourceMapJs.SourceMapConsumer(raw);
-        entry = { consumer, dir: import_node_path8.default.dirname(mapPath) };
+        entry = { consumer, dir: import_node_path9.default.dirname(mapPath) };
       }
     } catch {
       entry = null;
@@ -5984,7 +6113,7 @@ function resolveDistToSrc(absFilepath, line) {
     }
     if (!pos || !pos.source) return null;
     const root = entry.consumer.sourceRoot ?? "";
-    const resolved = import_node_path8.default.resolve(entry.dir, root, pos.source);
+    const resolved = import_node_path9.default.resolve(entry.dir, root, pos.source);
     return { filepath: resolved, ...pos.line ? { line: pos.line } : {} };
   } catch {
     return null;
@@ -6528,8 +6657,8 @@ function emitIncidentEvent(project, ev) {
   });
 }
 async function appendErrorEvent(ctx, ev) {
-  await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(ctx.errorsPath), { recursive: true });
-  await import_node_fs7.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(ctx.errorsPath), { recursive: true });
+  await import_node_fs8.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
   emitIncidentEvent(ctx.project ?? DEFAULT_PROJECT, ev);
 }
 async function appendConnectorIncident(errorsPath, input, project) {
@@ -6544,8 +6673,8 @@ async function appendConnectorIncident(errorsPath, input, project) {
     ...input.attributes && Object.keys(input.attributes).length > 0 ? { attributes: input.attributes } : {},
     affectedNode: input.affectedNode
   };
-  await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(errorsPath), { recursive: true });
-  await import_node_fs7.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(errorsPath), { recursive: true });
+  await import_node_fs8.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
   if (project) emitIncidentEvent(project, ev);
 }
 function landIncidentCallSite(span, callSite, trusted, graph) {
@@ -6667,8 +6796,8 @@ function makeErrorSpanWriter(errorsPath, graph, scanPath, project = DEFAULT_PROJ
   return async (span) => {
     const ev = buildErrorEventForReceiver(span, graph, scanPath);
     if (!ev) return;
-    await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(errorsPath), { recursive: true });
-    await import_node_fs7.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+    await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(errorsPath), { recursive: true });
+    await import_node_fs8.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
     emitIncidentEvent(project, ev);
   };
 }
@@ -7171,13 +7300,13 @@ async function markStaleEdges(graph, options = {}) {
   return { count: events.length, events };
 }
 async function appendStaleEvents(staleEventsPath, events) {
-  await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(staleEventsPath), { recursive: true });
+  await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(staleEventsPath), { recursive: true });
   const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await import_node_fs7.promises.appendFile(staleEventsPath, lines, "utf8");
+  await import_node_fs8.promises.appendFile(staleEventsPath, lines, "utf8");
 }
 async function readStaleEvents(staleEventsPath) {
   try {
-    const raw = await import_node_fs7.promises.readFile(staleEventsPath, "utf8");
+    const raw = await import_node_fs8.promises.readFile(staleEventsPath, "utf8");
     return raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
   } catch (err) {
     if (err.code === "ENOENT") return [];
@@ -7213,7 +7342,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_fs7.promises.open(errorsPath, "r");
+  const handle = await import_node_fs8.promises.open(errorsPath, "r");
   try {
     const { size } = await handle.stat();
     if (size <= maxBytes) {
@@ -7338,16 +7467,16 @@ function mergeSnapshot(graph, snapshot) {
 
 // src/extract/services.ts
 init_cjs_shims();
-var import_node_fs18 = require("fs");
-var import_node_path20 = __toESM(require("path"), 1);
-var import_ignore = __toESM(require("ignore"), 1);
+var import_node_fs19 = require("fs");
+var import_node_path21 = __toESM(require("path"), 1);
+var import_ignore2 = __toESM(require("ignore"), 1);
 var import_minimatch2 = require("minimatch");
 var import_types18 = require("@neat.is/types");
 
 // src/extract/python.ts
 init_cjs_shims();
-var import_node_fs8 = require("fs");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
 var import_smol_toml = require("smol-toml");
 var REQUIREMENT_LINE = /^\s*([A-Za-z0-9_.-]+)(?:\[[^\]]*\])?\s*(?:(==)\s*([A-Za-z0-9_.+-]+))?/;
 function parseRequirementsTxt(content) {
@@ -7380,25 +7509,25 @@ function depsFromPyProject(pyproject) {
   return out;
 }
 async function discoverPythonService(serviceDir) {
-  const pyprojectPath = import_node_path9.default.join(serviceDir, "pyproject.toml");
-  const requirementsPath = import_node_path9.default.join(serviceDir, "requirements.txt");
-  const setupPath = import_node_path9.default.join(serviceDir, "setup.py");
+  const pyprojectPath = import_node_path10.default.join(serviceDir, "pyproject.toml");
+  const requirementsPath = import_node_path10.default.join(serviceDir, "requirements.txt");
+  const setupPath = import_node_path10.default.join(serviceDir, "setup.py");
   const hasPyproject = await exists(pyprojectPath);
   const hasRequirements = await exists(requirementsPath);
   const hasSetup = await exists(setupPath);
   if (!hasPyproject && !hasRequirements && !hasSetup) return null;
-  let name = import_node_path9.default.basename(serviceDir);
+  let name = import_node_path10.default.basename(serviceDir);
   let version;
   const dependencies = {};
   if (hasPyproject) {
-    const raw = await import_node_fs8.promises.readFile(pyprojectPath, "utf8");
+    const raw = await import_node_fs9.promises.readFile(pyprojectPath, "utf8");
     const pyproject = (0, import_smol_toml.parse)(raw);
     name = pyproject.project?.name ?? pyproject.tool?.poetry?.name ?? name;
     version = pyproject.project?.version ?? pyproject.tool?.poetry?.version ?? void 0;
     Object.assign(dependencies, depsFromPyProject(pyproject));
   }
   if (hasRequirements) {
-    const raw = await import_node_fs8.promises.readFile(requirementsPath, "utf8");
+    const raw = await import_node_fs9.promises.readFile(requirementsPath, "utf8");
     Object.assign(dependencies, parseRequirementsTxt(raw));
   }
   return { name, version, dependencies };
@@ -7413,8 +7542,8 @@ function pythonToPackage(service) {
 
 // src/extract/go.ts
 init_cjs_shims();
-var import_node_fs9 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
+var import_node_path11 = __toESM(require("path"), 1);
 var import_types9 = require("@neat.is/types");
 function parseGoMod(source) {
   const module2 = source.match(/^\s*module\s+(\S+)\s*$/m)?.[1];
@@ -7441,7 +7570,7 @@ function goFramework(deps) {
 async function discoverGoService(scanPath, dir) {
   let raw;
   try {
-    raw = await import_node_fs9.promises.readFile(import_node_path10.default.join(dir, "go.mod"), "utf8");
+    raw = await import_node_fs10.promises.readFile(import_node_path11.default.join(dir, "go.mod"), "utf8");
   } catch {
     return null;
   }
@@ -7456,7 +7585,7 @@ async function discoverGoService(scanPath, dir) {
     name,
     language: "go",
     dependencies: mod.dependencies,
-    repoPath: import_node_path10.default.relative(scanPath, dir),
+    repoPath: import_node_path11.default.relative(scanPath, dir),
     ...framework ? { framework } : {}
   };
   return { pkg, dir, node };
@@ -7464,8 +7593,8 @@ async function discoverGoService(scanPath, dir) {
 
 // src/extract/ruby.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_types10 = require("@neat.is/types");
 function parseGemfile(source) {
   const dependencies = {};
@@ -7482,12 +7611,12 @@ function parseGemfile(source) {
 async function discoverRubyService(scanPath, dir) {
   let raw;
   try {
-    raw = await import_node_fs10.promises.readFile(import_node_path11.default.join(dir, "Gemfile"), "utf8");
+    raw = await import_node_fs11.promises.readFile(import_node_path12.default.join(dir, "Gemfile"), "utf8");
   } catch {
     return null;
   }
   const gemfile = parseGemfile(raw);
-  const name = import_node_path11.default.basename(dir);
+  const name = import_node_path12.default.basename(dir);
   const pkg = { name, dependencies: gemfile.dependencies };
   const node = {
     id: (0, import_types10.serviceId)(name),
@@ -7495,7 +7624,7 @@ async function discoverRubyService(scanPath, dir) {
     name,
     language: "ruby",
     dependencies: gemfile.dependencies,
-    repoPath: import_node_path11.default.relative(scanPath, dir),
+    repoPath: import_node_path12.default.relative(scanPath, dir),
     ...gemfile.dependencies["rails"] !== void 0 ? { framework: "rails" } : {}
   };
   return { pkg, dir, node };
@@ -7503,7 +7632,7 @@ async function discoverRubyService(scanPath, dir) {
 
 // src/extract/php.ts
 init_cjs_shims();
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var import_types11 = require("@neat.is/types");
 function parseComposerJson(composer) {
   return {
@@ -7516,12 +7645,12 @@ function parseComposerJson(composer) {
 async function discoverPhpService(scanPath, dir) {
   let composer;
   try {
-    composer = await readJson(import_node_path12.default.join(dir, "composer.json"));
+    composer = await readJson(import_node_path13.default.join(dir, "composer.json"));
   } catch {
     return null;
   }
   const { dependencies } = parseComposerJson(composer);
-  const name = import_node_path12.default.basename(dir);
+  const name = import_node_path13.default.basename(dir);
   const pkg = { name, dependencies };
   const node = {
     id: (0, import_types11.serviceId)(name),
@@ -7529,7 +7658,7 @@ async function discoverPhpService(scanPath, dir) {
     name,
     language: "php",
     dependencies,
-    repoPath: import_node_path12.default.relative(scanPath, dir),
+    repoPath: import_node_path13.default.relative(scanPath, dir),
     ...dependencies["laravel/framework"] !== void 0 ? { framework: "laravel" } : {}
   };
   return { pkg, dir, node };
@@ -7537,23 +7666,23 @@ async function discoverPhpService(scanPath, dir) {
 
 // src/extract/csharp.ts
 init_cjs_shims();
-var import_node_fs11 = require("fs");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs12 = require("fs");
+var import_node_path14 = __toESM(require("path"), 1);
 var import_types12 = require("@neat.is/types");
 var CSHARP_PROJECT_EXTS = /* @__PURE__ */ new Set([".csproj", ".sln"]);
 async function projectFiles(dir) {
-  const entries = await import_node_fs11.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs12.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
   const out = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    if (CSHARP_PROJECT_EXTS.has(import_node_path13.default.extname(entry.name).toLowerCase())) out.push(entry.name);
+    if (CSHARP_PROJECT_EXTS.has(import_node_path14.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_path13.default.join(dir, NESTED_PROJECT_DIR);
+  const nested = import_node_path14.default.join(dir, NESTED_PROJECT_DIR);
   if ((await projectFiles(nested)).length > 0) return nested;
   return null;
 }
@@ -7578,10 +7707,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_path13.default.basename(csproj, import_node_path13.default.extname(csproj)) : import_node_path13.default.basename(dir);
+  const name = csproj ? import_node_path14.default.basename(csproj, import_node_path14.default.extname(csproj)) : import_node_path14.default.basename(dir);
   let dependencies = {};
   if (csproj) {
-    const raw = await import_node_fs11.promises.readFile(import_node_path13.default.join(projectDir, csproj), "utf8").catch(() => "");
+    const raw = await import_node_fs12.promises.readFile(import_node_path14.default.join(projectDir, csproj), "utf8").catch(() => "");
     dependencies = parseCsproj(raw).dependencies;
   }
   const pkg = { name, dependencies };
@@ -7593,20 +7722,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_path13.default.relative(scanPath, projectDir)
+    repoPath: import_node_path14.default.relative(scanPath, projectDir)
   };
   return { pkg, dir: projectDir, node };
 }
 
 // src/extract/java.ts
 init_cjs_shims();
-var import_node_fs12 = require("fs");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs13 = require("fs");
+var import_node_path15 = __toESM(require("path"), 1);
 var import_types13 = 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 exists(import_node_path14.default.join(dir, manifest))) return true;
+    if (await exists(import_node_path15.default.join(dir, manifest))) return true;
   }
   return false;
 }
@@ -7641,19 +7770,19 @@ function parseGradle(source) {
   return { dependencies };
 }
 async function discoverJavaService(scanPath, dir) {
-  const pomPath = import_node_path14.default.join(dir, "pom.xml");
-  const gradlePath = import_node_path14.default.join(dir, "build.gradle");
-  const gradleKtsPath = import_node_path14.default.join(dir, "build.gradle.kts");
+  const pomPath = import_node_path15.default.join(dir, "pom.xml");
+  const gradlePath = import_node_path15.default.join(dir, "build.gradle");
+  const gradleKtsPath = import_node_path15.default.join(dir, "build.gradle.kts");
   let manifest = null;
   if (await exists(pomPath)) {
-    manifest = parsePomXml(await import_node_fs12.promises.readFile(pomPath, "utf8").catch(() => ""));
+    manifest = parsePomXml(await import_node_fs13.promises.readFile(pomPath, "utf8").catch(() => ""));
   } else if (await exists(gradlePath)) {
-    manifest = parseGradle(await import_node_fs12.promises.readFile(gradlePath, "utf8").catch(() => ""));
+    manifest = parseGradle(await import_node_fs13.promises.readFile(gradlePath, "utf8").catch(() => ""));
   } else if (await exists(gradleKtsPath)) {
-    manifest = parseGradle(await import_node_fs12.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
+    manifest = parseGradle(await import_node_fs13.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
   }
   if (!manifest) return null;
-  const name = manifest.name?.trim() || import_node_path14.default.basename(dir);
+  const name = manifest.name?.trim() || import_node_path15.default.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -7662,15 +7791,15 @@ async function discoverJavaService(scanPath, dir) {
     name,
     language: "java",
     dependencies,
-    repoPath: import_node_path14.default.relative(scanPath, dir)
+    repoPath: import_node_path15.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/kotlin.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_types14 = require("@neat.is/types");
 var KOTLIN_SOURCE_EXT = ".kt";
 var JAVA_SOURCE_EXT = ".java";
@@ -7680,15 +7809,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_fs13.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs14.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_path15.default.join(current, entry.name), depth + 1);
+        await recurse(import_node_path16.default.join(current, entry.name), depth + 1);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = import_node_path15.default.extname(entry.name).toLowerCase();
+      const ext = import_node_path16.default.extname(entry.name).toLowerCase();
       if (ext === KOTLIN_SOURCE_EXT) kt++;
       else if (ext === JAVA_SOURCE_EXT) java++;
     }
@@ -7699,17 +7828,17 @@ async function dominantJvmSourceLanguage(dir) {
   return void 0;
 }
 async function readJvmManifest(dir) {
-  const pomPath = import_node_path15.default.join(dir, JAVA_MANIFESTS[0]);
-  const gradlePath = import_node_path15.default.join(dir, JAVA_MANIFESTS[1]);
-  const gradleKtsPath = import_node_path15.default.join(dir, JAVA_MANIFESTS[2]);
+  const pomPath = import_node_path16.default.join(dir, JAVA_MANIFESTS[0]);
+  const gradlePath = import_node_path16.default.join(dir, JAVA_MANIFESTS[1]);
+  const gradleKtsPath = import_node_path16.default.join(dir, JAVA_MANIFESTS[2]);
   if (await exists(pomPath)) {
-    return parsePomXml(await import_node_fs13.promises.readFile(pomPath, "utf8").catch(() => ""));
+    return parsePomXml(await import_node_fs14.promises.readFile(pomPath, "utf8").catch(() => ""));
   }
   if (await exists(gradlePath)) {
-    return parseGradle(await import_node_fs13.promises.readFile(gradlePath, "utf8").catch(() => ""));
+    return parseGradle(await import_node_fs14.promises.readFile(gradlePath, "utf8").catch(() => ""));
   }
   if (await exists(gradleKtsPath)) {
-    return parseGradle(await import_node_fs13.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
+    return parseGradle(await import_node_fs14.promises.readFile(gradleKtsPath, "utf8").catch(() => ""));
   }
   return null;
 }
@@ -7718,7 +7847,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_path15.default.basename(dir);
+  const name = manifest.name?.trim() || import_node_path16.default.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -7727,20 +7856,20 @@ async function discoverKotlinService(scanPath, dir) {
     name,
     language: "kotlin",
     dependencies,
-    repoPath: import_node_path15.default.relative(scanPath, dir)
+    repoPath: import_node_path16.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/rust.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_smol_toml2 = require("smol-toml");
 var import_types15 = require("@neat.is/types");
 var CARGO_MANIFEST = "Cargo.toml";
 async function hasRustManifest(dir) {
-  return exists(import_node_path16.default.join(dir, CARGO_MANIFEST));
+  return exists(import_node_path17.default.join(dir, CARGO_MANIFEST));
 }
 function parseCargoToml(source) {
   const dependencies = {};
@@ -7765,10 +7894,10 @@ function parseCargoToml(source) {
   return { name, dependencies };
 }
 async function discoverRustService(scanPath, dir) {
-  const cargoPath = import_node_path16.default.join(dir, CARGO_MANIFEST);
+  const cargoPath = import_node_path17.default.join(dir, CARGO_MANIFEST);
   if (!await exists(cargoPath)) return null;
-  const manifest = parseCargoToml(await import_node_fs14.promises.readFile(cargoPath, "utf8").catch(() => ""));
-  const name = manifest.name?.trim() || import_node_path16.default.basename(dir);
+  const manifest = parseCargoToml(await import_node_fs15.promises.readFile(cargoPath, "utf8").catch(() => ""));
+  const name = manifest.name?.trim() || import_node_path17.default.basename(dir);
   const dependencies = manifest.dependencies;
   const pkg = { name, dependencies };
   const node = {
@@ -7777,19 +7906,19 @@ async function discoverRustService(scanPath, dir) {
     name,
     language: "rust",
     dependencies,
-    repoPath: import_node_path16.default.relative(scanPath, dir)
+    repoPath: import_node_path17.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/cpp.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_types16 = require("@neat.is/types");
 var CMAKE_MANIFEST = "CMakeLists.txt";
 async function hasCppManifest(dir) {
-  return exists(import_node_path17.default.join(dir, CMAKE_MANIFEST));
+  return exists(import_node_path18.default.join(dir, CMAKE_MANIFEST));
 }
 function parseCMakeProjectName(source) {
   const withoutComments = source.replace(/#.*$/gm, "");
@@ -7797,10 +7926,10 @@ function parseCMakeProjectName(source) {
   return m?.[1];
 }
 async function discoverCppService(scanPath, dir) {
-  const cmakePath = import_node_path17.default.join(dir, CMAKE_MANIFEST);
+  const cmakePath = import_node_path18.default.join(dir, CMAKE_MANIFEST);
   if (!await exists(cmakePath)) return null;
-  const source = await import_node_fs15.promises.readFile(cmakePath, "utf8").catch(() => "");
-  const name = parseCMakeProjectName(source)?.trim() || import_node_path17.default.basename(dir);
+  const source = await import_node_fs16.promises.readFile(cmakePath, "utf8").catch(() => "");
+  const name = parseCMakeProjectName(source)?.trim() || import_node_path18.default.basename(dir);
   const dependencies = {};
   const pkg = { name, dependencies };
   const node = {
@@ -7809,15 +7938,15 @@ async function discoverCppService(scanPath, dir) {
     name,
     language: "cpp",
     dependencies,
-    repoPath: import_node_path17.default.relative(scanPath, dir)
+    repoPath: import_node_path18.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/dockerfile-service.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_types17 = require("@neat.is/types");
 function languageForSourceExt(ext) {
   switch (ext) {
@@ -7859,12 +7988,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_fs16.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs17.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_path18.default.extname(entry.name).toLowerCase();
+    const ext = import_node_path19.default.extname(entry.name).toLowerCase();
     if (!SERVICE_FILE_EXTENSIONS.has(ext)) continue;
     const lang = languageForSourceExt(ext);
     if (!lang) continue;
@@ -7883,7 +8012,7 @@ async function inferServiceLanguage(dir) {
   return best;
 }
 async function hasLanguageManifest(dir) {
-  return await exists(import_node_path18.default.join(dir, "package.json")) || await exists(import_node_path18.default.join(dir, "pyproject.toml")) || await exists(import_node_path18.default.join(dir, "requirements.txt")) || await exists(import_node_path18.default.join(dir, "setup.py")) || await exists(import_node_path18.default.join(dir, "go.mod")) || await exists(import_node_path18.default.join(dir, "Gemfile")) || await exists(import_node_path18.default.join(dir, "composer.json")) || // C#'s marker is a glob (`*.csproj` / `*.sln`), so it reads the directory
+  return await exists(import_node_path19.default.join(dir, "package.json")) || await exists(import_node_path19.default.join(dir, "pyproject.toml")) || await exists(import_node_path19.default.join(dir, "requirements.txt")) || await exists(import_node_path19.default.join(dir, "setup.py")) || await exists(import_node_path19.default.join(dir, "go.mod")) || await exists(import_node_path19.default.join(dir, "Gemfile")) || await exists(import_node_path19.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
@@ -7893,15 +8022,15 @@ async function hasLanguageManifest(dir) {
   await hasCppManifest(dir);
 }
 async function hasDockerfileDeclaredService(dir) {
-  if (!await exists(import_node_path18.default.join(dir, "Dockerfile"))) return false;
+  if (!await exists(import_node_path19.default.join(dir, "Dockerfile"))) return false;
   return await inferServiceLanguage(dir) !== null;
 }
 async function discoverDockerfileService(scanPath, dir) {
-  if (!await exists(import_node_path18.default.join(dir, "Dockerfile"))) return null;
+  if (!await exists(import_node_path19.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_path18.default.basename(dir);
+  const name = import_node_path19.default.basename(dir);
   const pkg = { name, dependencies: {} };
   const node = {
     id: (0, import_types17.serviceId)(name),
@@ -7909,24 +8038,24 @@ async function discoverDockerfileService(scanPath, dir) {
     name,
     language,
     dependencies: {},
-    repoPath: import_node_path18.default.relative(scanPath, dir)
+    repoPath: import_node_path19.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 
 // src/extract/owners.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_minimatch = require("minimatch");
 async function loadCodeowners(scanPath) {
   const candidates = [
-    import_node_path19.default.join(scanPath, "CODEOWNERS"),
-    import_node_path19.default.join(scanPath, ".github", "CODEOWNERS")
+    import_node_path20.default.join(scanPath, "CODEOWNERS"),
+    import_node_path20.default.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists(file)) {
-      const raw = await import_node_fs17.promises.readFile(file, "utf8");
+      const raw = await import_node_fs18.promises.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -7944,7 +8073,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(import_node_path19.default.sep).join("/");
+  const normalized = repoPath.split(import_node_path20.default.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -7960,7 +8089,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = import_node_path19.default.join(serviceDir, "package.json");
+  const pkgPath = import_node_path20.default.join(serviceDir, "package.json");
   if (!await exists(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -7997,36 +8126,36 @@ function workspaceGlobs(pkg) {
   return null;
 }
 async function hasPythonManifest(dir) {
-  return await exists(import_node_path20.default.join(dir, "pyproject.toml")) || await exists(import_node_path20.default.join(dir, "requirements.txt")) || await exists(import_node_path20.default.join(dir, "setup.py"));
+  return await exists(import_node_path21.default.join(dir, "pyproject.toml")) || await exists(import_node_path21.default.join(dir, "requirements.txt")) || await exists(import_node_path21.default.join(dir, "setup.py"));
 }
 async function hasGoManifest(dir) {
-  return exists(import_node_path20.default.join(dir, "go.mod"));
+  return exists(import_node_path21.default.join(dir, "go.mod"));
 }
 async function hasRubyManifest(dir) {
-  return exists(import_node_path20.default.join(dir, "Gemfile"));
+  return exists(import_node_path21.default.join(dir, "Gemfile"));
 }
 async function hasPhpManifest(dir) {
-  return exists(import_node_path20.default.join(dir, "composer.json"));
+  return exists(import_node_path21.default.join(dir, "composer.json"));
 }
 async function hasCsharpManifest(dir) {
   return hasCsharpProject(dir);
 }
 async function loadGitignore(scanPath) {
-  const gitignorePath = import_node_path20.default.join(scanPath, ".gitignore");
+  const gitignorePath = import_node_path21.default.join(scanPath, ".gitignore");
   if (!await exists(gitignorePath)) return null;
-  const raw = await import_node_fs18.promises.readFile(gitignorePath, "utf8");
-  return (0, import_ignore.default)().add(raw);
+  const raw = await import_node_fs19.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_fs18.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs19.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_path20.default.join(current, entry.name);
+      const child = import_node_path21.default.join(current, entry.name);
       if (options.ig) {
-        const rel = import_node_path20.default.relative(scanPath, child).split(import_node_path20.default.sep).join("/");
+        const rel = import_node_path21.default.relative(scanPath, child).split(import_node_path21.default.sep).join("/");
         if (rel && options.ig.ignores(rel + "/")) continue;
       }
       if (await isPythonVenvDir(child)) continue;
@@ -8042,8 +8171,8 @@ async function expandWorkspaceGlobs(scanPath, globs) {
   for (const raw of globs) {
     const pattern = raw.replace(/^\.\//, "");
     if (!pattern.includes("*")) {
-      const candidate = import_node_path20.default.join(scanPath, pattern);
-      if (await exists(import_node_path20.default.join(candidate, "package.json"))) found.add(candidate);
+      const candidate = import_node_path21.default.join(scanPath, pattern);
+      if (await exists(import_node_path21.default.join(candidate, "package.json"))) found.add(candidate);
       continue;
     }
     const segments = pattern.split("/");
@@ -8052,13 +8181,13 @@ async function expandWorkspaceGlobs(scanPath, globs) {
       if (seg.includes("*")) break;
       staticSegments.push(seg);
     }
-    const start = import_node_path20.default.join(scanPath, ...staticSegments);
+    const start = import_node_path21.default.join(scanPath, ...staticSegments);
     if (!await exists(start)) continue;
     const hasDoubleStar = pattern.includes("**");
     const walkDepth = hasDoubleStar ? scanDepth : Math.max(0, segments.length - staticSegments.length - 1);
     await walkDirs(start, scanPath, { maxDepth: walkDepth, ig: null }, async (dir) => {
-      const rel = import_node_path20.default.relative(scanPath, dir).split(import_node_path20.default.sep).join("/");
-      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists(import_node_path20.default.join(dir, "package.json"))) {
+      const rel = import_node_path21.default.relative(scanPath, dir).split(import_node_path21.default.sep).join("/");
+      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists(import_node_path21.default.join(dir, "package.json"))) {
         found.add(dir);
       }
     });
@@ -8081,18 +8210,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_fs18.promises.readdir(dir).catch(() => []);
+  const entries = await import_node_fs19.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_path20.default.join(dir, "package.json");
+  const pkgPath = import_node_path21.default.join(dir, "package.json");
   if (!await exists(pkgPath)) return null;
   let pkg;
   try {
     pkg = await readJson(pkgPath);
   } catch (err) {
-    recordExtractionError("services", import_node_path20.default.relative(scanPath, pkgPath), err);
+    recordExtractionError("services", import_node_path21.default.relative(scanPath, pkgPath), err);
     return null;
   }
   if (!pkg.name) return null;
@@ -8105,7 +8234,7 @@ async function discoverNodeService(scanPath, dir) {
     language,
     version: pkg.version,
     dependencies: pkg.dependencies ?? {},
-    repoPath: import_node_path20.default.relative(scanPath, dir),
+    repoPath: import_node_path21.default.relative(scanPath, dir),
     ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
     ...framework ? { framework } : {}
   };
@@ -8122,12 +8251,12 @@ async function discoverPyService(scanPath, dir) {
     language: "python",
     version: py.version,
     dependencies: py.dependencies,
-    repoPath: import_node_path20.default.relative(scanPath, dir)
+    repoPath: import_node_path21.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 async function discoverServices(scanPath) {
-  const rootPkgPath = import_node_path20.default.join(scanPath, "package.json");
+  const rootPkgPath = import_node_path21.default.join(scanPath, "package.json");
   let rootPkg = null;
   if (await exists(rootPkgPath)) {
     try {
@@ -8135,7 +8264,7 @@ async function discoverServices(scanPath) {
     } catch (err) {
       recordExtractionError(
         "services workspaces",
-        import_node_path20.default.relative(scanPath, rootPkgPath),
+        import_node_path21.default.relative(scanPath, rootPkgPath),
         err
       );
     }
@@ -8156,7 +8285,7 @@ async function discoverServices(scanPath) {
       scanPath,
       { maxDepth: parseScanDepth(), ig },
       async (dir) => {
-        if (await exists(import_node_path20.default.join(dir, "package.json"))) {
+        if (await exists(import_node_path21.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);
@@ -8184,8 +8313,8 @@ async function discoverServices(scanPath) {
     seenDirs.add(service.dir);
     const existingDir = seen.get(service.node.name);
     if (existingDir !== void 0) {
-      const a = import_node_path20.default.relative(scanPath, existingDir) || ".";
-      const b = import_node_path20.default.relative(scanPath, dir) || ".";
+      const a = import_node_path21.default.relative(scanPath, existingDir) || ".";
+      const b = import_node_path21.default.relative(scanPath, dir) || ".";
       console.warn(
         `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
       );
@@ -8199,14 +8328,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_path20.default.resolve(s.dir));
+  const resolvedDirs = out.map((s) => import_node_path21.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_path20.default.sep)) nested.push(other);
+      if (other.startsWith(self + import_node_path21.default.sep)) nested.push(other);
     }
     out[i].excludeDirs = nested;
   }
@@ -8233,8 +8362,8 @@ function addServiceNodes(graph, services) {
 
 // src/extract/aliases.ts
 init_cjs_shims();
-var import_node_path21 = __toESM(require("path"), 1);
-var import_node_fs19 = require("fs");
+var import_node_path22 = __toESM(require("path"), 1);
+var import_node_fs20 = require("fs");
 var import_yaml2 = require("yaml");
 var import_types19 = require("@neat.is/types");
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
@@ -8261,14 +8390,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_path21.default.basename(s.dir), s.node.id);
+    map.set(import_node_path22.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_path21.default.join(scanPath, name);
+    const abs = import_node_path22.default.join(scanPath, name);
     if (await exists(abs)) {
       composePath = abs;
       break;
@@ -8281,7 +8410,7 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   } catch (err) {
     recordExtractionError(
       "aliases compose",
-      import_node_path21.default.relative(scanPath, composePath),
+      import_node_path22.default.relative(scanPath, composePath),
       err
     );
     return;
@@ -8324,11 +8453,11 @@ function parseDockerfileLabels(content) {
 }
 async function collectDockerfileAliases(graph, services) {
   for (const service of services) {
-    const dockerfilePath = import_node_path21.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path22.default.join(service.dir, "Dockerfile");
     if (!await exists(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs19.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs20.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError("aliases dockerfile", dockerfilePath, err);
       continue;
@@ -8340,15 +8469,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_fs19.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs20.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_path21.default.join(start, entry.name);
+      const child = import_node_path22.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_path21.default.extname(entry.name))) {
-      out.push(import_node_path21.default.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path22.default.extname(entry.name))) {
+      out.push(import_node_path22.default.join(start, entry.name));
     }
   }
   return out;
@@ -8375,7 +8504,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_fs19.promises.readFile(file, "utf8");
+    const content = await import_node_fs20.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml2.parseAllDocuments)(content).map((d) => d.toJSON());
@@ -8400,14 +8529,14 @@ async function addServiceAliases(graph, scanPath, services) {
 
 // src/extract/files.ts
 init_cjs_shims();
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_path23 = __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_path22.default.relative(service.dir, filePath));
+      const relPath = toPosix(import_node_path23.default.relative(service.dir, filePath));
       const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -8423,7 +8552,7 @@ async function addFiles(graph, services) {
 
 // src/extract/symbols.ts
 init_cjs_shims();
-var import_node_path23 = __toESM(require("path"), 1);
+var import_node_path24 = __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);
@@ -9175,10 +9304,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_path23.default.extname(file.path);
+      const ext = import_node_path24.default.extname(file.path);
       const parser = parserForExt5(ext);
       if (!parser) continue;
-      const relPath = toPosix(import_node_path23.default.relative(service.dir, file.path));
+      const relPath = toPosix(import_node_path24.default.relative(service.dir, file.path));
       let defs;
       try {
         const tree = parseSource3(parser, file.content);
@@ -9238,7 +9367,7 @@ async function addSymbols(graph, services) {
 
 // src/extract/symbol-edges.ts
 init_cjs_shims();
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_path25 = __toESM(require("path"), 1);
 var import_tree_sitter4 = __toESM(require("tree-sitter"), 1);
 var import_types21 = require("@neat.is/types");
 function extendsInfo(classHeritage) {
@@ -9345,10 +9474,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_path24.default.extname(file.path));
+      const parser = parserForExt5(import_node_path25.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path24.default.relative(service.dir, file.path));
-      const fileDir = import_node_path24.default.dirname(file.path);
+      const relPath = toPosix(import_node_path25.default.relative(service.dir, file.path));
+      const fileDir = import_node_path25.default.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -9483,7 +9612,7 @@ async function addSymbolEdges(graph, services) {
 
 // src/extract/actions.ts
 init_cjs_shims();
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 var import_tree_sitter5 = __toESM(require("tree-sitter"), 1);
 var import_types22 = require("@neat.is/types");
 function stringLiteralText2(node) {
@@ -9630,9 +9759,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_path25.default.extname(file.path));
+      const parser = parserForExt5(import_node_path26.default.extname(file.path));
       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 root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -9693,10 +9822,10 @@ async function addServerActions(graph, services) {
     }
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = parserForExt5(import_node_path25.default.extname(file.path));
+      const parser = parserForExt5(import_node_path26.default.extname(file.path));
       if (!parser) continue;
-      const relPath = toPosix(import_node_path25.default.relative(service.dir, file.path));
-      const fileDir = import_node_path25.default.dirname(file.path);
+      const relPath = toPosix(import_node_path26.default.relative(service.dir, file.path));
+      const fileDir = import_node_path26.default.dirname(file.path);
       let root;
       try {
         root = parseSource3(parser, file.content).rootNode;
@@ -9749,14 +9878,14 @@ async function addServerActions(graph, services) {
 
 // src/extract/databases/index.ts
 init_cjs_shims();
-var import_node_path34 = __toESM(require("path"), 1);
+var import_node_path35 = __toESM(require("path"), 1);
 var import_types23 = require("@neat.is/types");
 
 // src/extract/databases/db-config-yaml.ts
 init_cjs_shims();
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 async function parse(serviceDir) {
-  const yamlPath = import_node_path26.default.join(serviceDir, "db-config.yaml");
+  const yamlPath = import_node_path27.default.join(serviceDir, "db-config.yaml");
   if (!await exists(yamlPath)) return [];
   const raw = await readYaml(yamlPath);
   return [
@@ -9774,13 +9903,13 @@ var dbConfigYamlParser = { name: "db-config.yaml", parse };
 
 // src/extract/databases/dotenv.ts
 init_cjs_shims();
-var import_node_fs21 = require("fs");
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_fs22 = require("fs");
+var import_node_path29 = __toESM(require("path"), 1);
 
 // src/extract/databases/shared.ts
 init_cjs_shims();
-var import_node_fs20 = require("fs");
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_fs21 = require("fs");
+var import_node_path28 = __toESM(require("path"), 1);
 function schemeToEngine(scheme) {
   const s = scheme.toLowerCase().split("+")[0];
   switch (s) {
@@ -9819,18 +9948,18 @@ function parseConnectionString(url) {
 }
 async function readIfExists(filePath) {
   try {
-    return await import_node_fs20.promises.readFile(filePath, "utf8");
+    return await import_node_fs21.promises.readFile(filePath, "utf8");
   } catch {
     return null;
   }
 }
 async function resolveEnvVar(serviceDir, name) {
-  const entries = await import_node_fs20.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs21.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_path27.default.join(serviceDir, fileName));
+    const content = await readIfExists(import_node_path28.default.join(serviceDir, fileName));
     if (!content) continue;
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -9849,7 +9978,7 @@ async function resolveEnvVar(serviceDir, name) {
 }
 async function findFirst(serviceDir, candidates) {
   for (const rel of candidates) {
-    const abs = import_node_path27.default.join(serviceDir, rel);
+    const abs = import_node_path28.default.join(serviceDir, rel);
     const content = await readIfExists(abs);
     if (content !== null) return abs;
   }
@@ -9907,15 +10036,15 @@ function parseDotenvLine(line) {
   return { key, value };
 }
 async function parse2(serviceDir) {
-  const entries = await import_node_fs21.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs22.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_path28.default.join(serviceDir, entry.name);
-    const content = await import_node_fs21.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path29.default.join(serviceDir, entry.name);
+    const content = await import_node_fs22.promises.readFile(filePath, "utf8");
     for (const line of content.split("\n")) {
       const parsed = parseDotenvLine(line);
       if (!parsed) continue;
@@ -9934,9 +10063,9 @@ var dotenvParser = { name: ".env", parse: parse2 };
 
 // src/extract/databases/prisma.ts
 init_cjs_shims();
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_path30 = __toESM(require("path"), 1);
 async function parse3(serviceDir) {
-  const schemaPath = import_node_path29.default.join(serviceDir, "prisma", "schema.prisma");
+  const schemaPath = import_node_path30.default.join(serviceDir, "prisma", "schema.prisma");
   const content = await readIfExists(schemaPath);
   if (!content) return [];
   const block = content.match(/datasource\s+\w+\s*\{([^}]*)\}/s);
@@ -10094,10 +10223,10 @@ var knexParser = { name: "knex", parse: parse5 };
 
 // src/extract/databases/ormconfig.ts
 init_cjs_shims();
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 async function parse6(serviceDir) {
   for (const candidate of ["ormconfig.json", "ormconfig.yaml", "ormconfig.yml"]) {
-    const abs = import_node_path30.default.join(serviceDir, candidate);
+    const abs = import_node_path31.default.join(serviceDir, candidate);
     if (!await exists(abs)) continue;
     const raw = candidate.endsWith(".json") ? await readJson(abs) : await readYaml(abs);
     const entries = Array.isArray(raw) ? raw : [raw];
@@ -10157,9 +10286,9 @@ var typeormParser = { name: "typeorm", parse: parse7 };
 
 // src/extract/databases/sequelize.ts
 init_cjs_shims();
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_path32 = __toESM(require("path"), 1);
 async function parse8(serviceDir) {
-  const configPath = import_node_path31.default.join(serviceDir, "config", "config.json");
+  const configPath = import_node_path32.default.join(serviceDir, "config", "config.json");
   if (!await exists(configPath)) return [];
   const raw = await readJson(configPath);
   const out = [];
@@ -10186,8 +10315,8 @@ var sequelizeParser = { name: "sequelize", parse: parse8 };
 
 // src/extract/databases/csharp.ts
 init_cjs_shims();
-var import_node_fs22 = require("fs");
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_fs23 = require("fs");
+var import_node_path33 = __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/;
@@ -10234,12 +10363,12 @@ function parseRedisEndpoint(raw) {
   return { host, port, database: "", engine: "redis", engineVersion: "unknown" };
 }
 async function resolveEnvUpTree(startDir, name) {
-  let dir = import_node_path32.default.resolve(startDir);
+  let dir = import_node_path33.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_fs22.promises.access(import_node_path32.default.join(dir, ".git")).then(() => true).catch(() => false);
-    const parent = import_node_path32.default.dirname(dir);
+    const atRepoRoot = await import_node_fs23.promises.access(import_node_path33.default.join(dir, ".git")).then(() => true).catch(() => false);
+    const parent = import_node_path33.default.dirname(dir);
     if (atRepoRoot || parent === dir) break;
     dir = parent;
   }
@@ -10294,12 +10423,12 @@ async function resolveConfigs(literals, keys, serviceDir, looksLike, parse11) {
 }
 async function parse9(serviceDir) {
   const files = (await walkSourceFiles(serviceDir).catch(() => [])).filter(
-    (f) => import_node_path32.default.extname(f) === CS_EXT
+    (f) => import_node_path33.default.extname(f) === CS_EXT
   );
   if (files.length === 0) return [];
   const sources = [];
   for (const file of files) {
-    const content = await import_node_fs22.promises.readFile(file, "utf8").catch(() => null);
+    const content = await import_node_fs23.promises.readFile(file, "utf8").catch(() => null);
     if (content !== null) sources.push({ file, content });
   }
   let pgGateFile = null;
@@ -10340,7 +10469,7 @@ var csharpParser = { name: "csharp", parse: parse9 };
 
 // src/extract/databases/docker-compose.ts
 init_cjs_shims();
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_path34 = __toESM(require("path"), 1);
 function portFromService(svc) {
   for (const raw of svc.ports ?? []) {
     const str = String(raw);
@@ -10367,7 +10496,7 @@ function databaseFromEnv(svc) {
 }
 async function parse10(serviceDir) {
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path33.default.join(serviceDir, name);
+    const abs = import_node_path34.default.join(serviceDir, name);
     if (!await exists(abs)) continue;
     const raw = await readYaml(abs);
     if (!raw?.services) return [];
@@ -10540,7 +10669,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
           discoveredVia: mergedDiscoveredVia
         });
       }
-      const relConfigFile = toPosix(import_node_path34.default.relative(service.dir, config.sourceFile));
+      const relConfigFile = toPosix(import_node_path35.default.relative(service.dir, config.sourceFile));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -10549,7 +10678,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       );
       nodesAdded += fn;
       edgesAdded += fe;
-      const evidenceFile = toPosix(import_node_path34.default.relative(scanPath, config.sourceFile));
+      const evidenceFile = toPosix(import_node_path35.default.relative(scanPath, config.sourceFile));
       const edge = {
         id: (0, import_types3.extractedEdgeId)(fileNodeId, dbNode.id, import_types23.EdgeType.CONNECTS_TO),
         source: fileNodeId,
@@ -10570,15 +10699,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_path34.default.relative(scanPath, primary.sourceFile);
+      const relPath = import_node_path35.default.relative(scanPath, primary.sourceFile);
       const cfgId = (0, import_types23.configId)(relPath);
       if (!graph.hasNode(cfgId)) {
         const cfgNode = {
           id: cfgId,
           type: import_types23.NodeType.ConfigNode,
-          name: import_node_path34.default.basename(primary.sourceFile),
+          name: import_node_path35.default.basename(primary.sourceFile),
           path: relPath,
-          fileType: isConfigFile(import_node_path34.default.basename(primary.sourceFile)).fileType || "config"
+          fileType: isConfigFile(import_node_path35.default.basename(primary.sourceFile)).fileType || "config"
         };
         graph.addNode(cfgId, cfgNode);
         nodesAdded++;
@@ -10619,19 +10748,19 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
 
 // src/extract/configs.ts
 init_cjs_shims();
-var import_node_fs23 = require("fs");
-var import_node_path35 = __toESM(require("path"), 1);
+var import_node_fs24 = require("fs");
+var import_node_path36 = __toESM(require("path"), 1);
 var import_types24 = require("@neat.is/types");
 async function walkConfigFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => import_node_path35.default.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => import_node_path36.default.resolve(d)));
   const out = [];
   async function walk11(current) {
-    const entries = await import_node_fs23.promises.readdir(current, { withFileTypes: true });
+    const entries = await import_node_fs24.promises.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const full = import_node_path35.default.join(current, entry.name);
+      const full = import_node_path36.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(import_node_path35.default.resolve(full))) continue;
+        if (excluded.has(import_node_path36.default.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk11(full);
       } else if (entry.isFile() && isConfigFile(entry.name).match) {
@@ -10648,19 +10777,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_path35.default.relative(scanPath, file);
+      const relPath = import_node_path36.default.relative(scanPath, file);
       const node = {
         id: (0, import_types24.configId)(relPath),
         type: import_types24.NodeType.ConfigNode,
-        name: import_node_path35.default.basename(file),
+        name: import_node_path36.default.basename(file),
         path: relPath,
-        fileType: isConfigFile(import_node_path35.default.basename(file)).fileType
+        fileType: isConfigFile(import_node_path36.default.basename(file)).fileType
       };
       if (!graph.hasNode(node.id)) {
         graph.addNode(node.id, node);
         nodesAdded++;
       }
-      const relToService = toPosix(import_node_path35.default.relative(service.dir, file));
+      const relToService = toPosix(import_node_path36.default.relative(service.dir, file));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -10676,7 +10805,7 @@ async function addConfigNodes(graph, services, scanPath) {
         type: import_types24.EdgeType.CONFIGURED_BY,
         provenance: import_types24.Provenance.EXTRACTED,
         confidence: (0, import_types24.confidenceForExtracted)("structural"),
-        evidence: { file: relPath.split(import_node_path35.default.sep).join("/") }
+        evidence: { file: relPath.split(import_node_path36.default.sep).join("/") }
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -10689,8 +10818,8 @@ async function addConfigNodes(graph, services, scanPath) {
 
 // src/extract/proto.ts
 init_cjs_shims();
-var import_node_fs24 = require("fs");
-var import_node_path36 = __toESM(require("path"), 1);
+var import_node_fs25 = require("fs");
+var import_node_path37 = __toESM(require("path"), 1);
 var import_types25 = require("@neat.is/types");
 var PROTO_EXTENSION = ".proto";
 function packageOf(content) {
@@ -10728,18 +10857,18 @@ function grpcMethodsFromProto(content, fqPackage) {
   return out;
 }
 async function walkProtoFiles(dir, excludeDirs = []) {
-  const excluded = new Set(excludeDirs.map((d) => import_node_path36.default.resolve(d)));
+  const excluded = new Set(excludeDirs.map((d) => import_node_path37.default.resolve(d)));
   const out = [];
   async function walk11(current) {
-    const entries = await import_node_fs24.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs25.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      const full = import_node_path36.default.join(current, entry.name);
+      const full = import_node_path37.default.join(current, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
-        if (excluded.has(import_node_path36.default.resolve(full))) continue;
+        if (excluded.has(import_node_path37.default.resolve(full))) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk11(full);
-      } else if (entry.isFile() && import_node_path36.default.extname(entry.name) === PROTO_EXTENSION) {
+      } else if (entry.isFile() && import_node_path37.default.extname(entry.name) === PROTO_EXTENSION) {
         out.push(full);
       }
     }
@@ -10754,10 +10883,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_path36.default.relative(service.dir, protoPath));
+      const relFile = toPosix(import_node_path37.default.relative(service.dir, protoPath));
       let content;
       try {
-        content = await import_node_fs24.promises.readFile(protoPath, "utf8");
+        content = await import_node_fs25.promises.readFile(protoPath, "utf8");
       } catch (err) {
         recordExtractionError("proto extraction", protoPath, err);
         continue;
@@ -10816,7 +10945,7 @@ var import_types45 = require("@neat.is/types");
 
 // src/extract/calls/http.ts
 init_cjs_shims();
-var import_node_path37 = __toESM(require("path"), 1);
+var import_node_path38 = __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);
@@ -10899,7 +11028,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_path37.default.extname(file.path), parserCache);
+      const parser = parserForExt(import_node_path38.default.extname(file.path), parserCache);
       let sites;
       try {
         sites = callsFromSource(file.content, parser, knownHosts);
@@ -10908,7 +11037,7 @@ async function addHttpCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(import_node_path37.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path38.default.relative(service.dir, file.path));
       for (const site of sites) {
         const targetId = hostToNodeId.get(site.host);
         if (!targetId || targetId === service.node.id) continue;
@@ -10962,7 +11091,7 @@ async function addHttpCallEdges(graph, services) {
 
 // src/extract/calls/route-match.ts
 init_cjs_shims();
-var import_node_path38 = __toESM(require("path"), 1);
+var import_node_path39 = __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_types27 = require("@neat.is/types");
@@ -11240,7 +11369,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_path38.default.extname(file.path))) continue;
+      if (!JS_CLIENT_EXTENSIONS.has(import_node_path39.default.extname(file.path))) continue;
       let sites;
       try {
         sites = clientCallSitesFromSource(file.content, jsParser, knownHosts);
@@ -11249,7 +11378,7 @@ async function addRouteCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix(import_node_path38.default.relative(service.dir, file.path));
+      const relFile = toPosix(import_node_path39.default.relative(service.dir, file.path));
       for (const site of sites) {
         if (site.host === null) {
           const dedupKey2 = `${relFile}|unresolved-host`;
@@ -11342,7 +11471,7 @@ async function addRouteCallEdges(graph, services) {
 
 // src/extract/calls/kafka.ts
 init_cjs_shims();
-var import_node_path39 = __toESM(require("path"), 1);
+var import_node_path40 = __toESM(require("path"), 1);
 var import_types28 = 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;
@@ -11430,13 +11559,13 @@ function kafkaEndpointsFromFile(file, serviceDir) {
       // call sites — verified-call-site tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path39.default.relative(serviceDir, file.path),
+        file: import_node_path40.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
     });
   };
-  if (import_node_path39.default.extname(file.path) === ".go") {
+  if (import_node_path40.default.extname(file.path) === ".go") {
     goSaramaEndpoints(file.content, make);
   } else {
     for (const { topic } of findAll(PRODUCER_TOPIC_RE, file.content)) make(topic, "PUBLISHES_TO");
@@ -11447,7 +11576,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/redis.ts
 init_cjs_shims();
-var import_node_path40 = __toESM(require("path"), 1);
+var import_node_path41 = __toESM(require("path"), 1);
 var import_types29 = require("@neat.is/types");
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
@@ -11470,7 +11599,7 @@ function redisEndpointsFromFile(file, serviceDir) {
       // support tier (ADR-066).
       confidenceKind: "url-with-structural-support",
       evidence: {
-        file: import_node_path40.default.relative(serviceDir, file.path),
+        file: import_node_path41.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11481,7 +11610,7 @@ function redisEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/aws.ts
 init_cjs_shims();
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_path42 = __toESM(require("path"), 1);
 var import_types30 = require("@neat.is/types");
 var S3_BUCKET_RE = /Bucket\s*:\s*['"`]([^'"`]+)['"`]/g;
 var DYNAMO_TABLE_RE = /TableName\s*:\s*['"`]([^'"`]+)['"`]/g;
@@ -11515,7 +11644,7 @@ function awsEndpointsFromFile(file, serviceDir) {
       // (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)
       }
@@ -11540,7 +11669,7 @@ function awsEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/grpc.ts
 init_cjs_shims();
-var import_node_path42 = __toESM(require("path"), 1);
+var import_node_path43 = __toESM(require("path"), 1);
 var import_types31 = 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;
@@ -11599,7 +11728,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       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)
       }
@@ -11610,7 +11739,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/supabase.ts
 init_cjs_shims();
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_path44 = __toESM(require("path"), 1);
 var import_types32 = 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['"`]/;
@@ -11669,7 +11798,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_path43.default.relative(serviceDir, file.path),
+        file: import_node_path44.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -11696,7 +11825,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
         edgeType: "CALLS",
         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)
         }
@@ -11708,7 +11837,7 @@ function supabaseEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/firestore.ts
 init_cjs_shims();
-var import_node_path44 = __toESM(require("path"), 1);
+var import_node_path45 = __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_types33 = require("@neat.is/types");
@@ -11881,7 +12010,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_path44.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt2(import_node_path45.default.extname(file.path)), file.content);
   const clientVars = firestoreClientVars(tree.rootNode);
   for (const n of importedNames) clientVars.add(n);
   const collLine = /* @__PURE__ */ new Map();
@@ -11986,7 +12115,7 @@ function firestoreEndpointsFromFile(file, serviceDir, imported) {
       ...columnSet.size > 0 ? { columns: [...columnSet] } : {},
       ...sdkWrites ? { sdkWrites } : {},
       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)
       }
@@ -12046,7 +12175,7 @@ function sdkOf(content) {
   return hasClient && !hasAdmin ? "client" : hasAdmin && !hasClient ? "admin" : null;
 }
 function parseOrNull(file) {
-  const ext = import_node_path44.default.extname(file.path);
+  const ext = import_node_path45.default.extname(file.path);
   if (!(ext in GRAMMAR_BY_EXT)) return null;
   try {
     return parseSource3(parserForExt2(ext), file.content).rootNode;
@@ -12062,7 +12191,7 @@ async function firestoreCrossFileEndpoints(files, serviceDir) {
     if (!root) continue;
     const names = exportedFirestoreClients(root);
     if (names.size === 0) continue;
-    registry.set(toPosix(import_node_path44.default.relative(serviceDir, f.path)), { names, sdk: sdkOf(f.content) });
+    registry.set(toPosix(import_node_path45.default.relative(serviceDir, f.path)), { names, sdk: sdkOf(f.content) });
   }
   if (registry.size === 0) return [];
   const out = [];
@@ -12075,7 +12204,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_path44.default.dirname(f.path), serviceDir, null);
+      const rel = await resolveJsImport(b.specifier, import_node_path45.default.dirname(f.path), serviceDir, null);
       if (!rel) continue;
       const entry = registry.get(rel);
       if (!entry || !entry.names.has(b.imported)) continue;
@@ -12090,7 +12219,7 @@ async function firestoreCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/mongoose.ts
 init_cjs_shims();
-var import_node_path45 = __toESM(require("path"), 1);
+var import_node_path46 = __toESM(require("path"), 1);
 var import_types34 = require("@neat.is/types");
 var MONGOOSE_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])mongoose['"`]/;
 var MONGODB_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])mongodb['"`]/;
@@ -12241,7 +12370,7 @@ function endpoint(r, file, serviceDir, matchText) {
     kind: r.kind,
     edgeType: "CALLS",
     confidenceKind: "verified-call-site",
-    evidence: { file: import_node_path45.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+    evidence: { file: import_node_path46.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
   };
 }
 function mongooseEndpointsFromFile(file, serviceDir) {
@@ -12331,7 +12460,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_path45.default.relative(serviceDir, f.path)), fx);
+    if (fx) registry.set(toPosix(import_node_path46.default.relative(serviceDir, f.path)), fx);
   }
   if (registry.size === 0) return [];
   const out = [];
@@ -12342,7 +12471,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_path45.default.dirname(f.path), serviceDir, null);
+      const resolvedRel = await resolveJsImport(b.specifier, import_node_path46.default.dirname(f.path), serviceDir, null);
       if (!resolvedRel) continue;
       const fx = registry.get(resolvedRel);
       if (!fx) continue;
@@ -12386,7 +12515,7 @@ async function mongooseCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/sqlalchemy.ts
 init_cjs_shims();
-var import_node_path46 = __toESM(require("path"), 1);
+var import_node_path47 = __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_types35 = require("@neat.is/types");
@@ -12525,7 +12654,7 @@ function sqlalchemyForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         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)
         }
@@ -12550,7 +12679,7 @@ function sqlalchemyEndpointsFromFile(file, serviceDir) {
       confidenceKind: "verified-call-site",
       ...columns && columns.length > 0 ? { columns } : {},
       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)
       }
@@ -12657,7 +12786,7 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
         edgeType: "CALLS",
         confidenceKind: "verified-call-site",
         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)
         }
@@ -12669,7 +12798,7 @@ function pythonOrmCrossFileEndpoints(files, serviceDir) {
 
 // src/extract/calls/socket.ts
 init_cjs_shims();
-var import_node_path47 = __toESM(require("path"), 1);
+var import_node_path48 = __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_types36 = require("@neat.is/types");
@@ -12745,7 +12874,7 @@ function socketEndpointsFromFile(file, serviceDir) {
       // A verified `socket.socket(...)` + `.connect((host, port))` call site.
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path47.default.relative(serviceDir, file.path),
+        file: import_node_path48.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -12756,7 +12885,7 @@ function socketEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/django-orm.ts
 init_cjs_shims();
-var import_node_path48 = __toESM(require("path"), 1);
+var import_node_path49 = __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_types37 = require("@neat.is/types");
@@ -12826,7 +12955,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
   const tree = parseSource8(makePyParser5(), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const defaultAppLabel = import_node_path48.default.basename(import_node_path48.default.dirname(file.path));
+  const defaultAppLabel = import_node_path49.default.basename(import_node_path49.default.dirname(file.path));
   walk5(tree.rootNode, (node) => {
     if (node.type !== "class_definition") return;
     if (!extendsDjangoModel(node)) return;
@@ -12844,7 +12973,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
-      evidence: { file: import_node_path48.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
+      evidence: { file: import_node_path49.default.relative(serviceDir, file.path), line, snippet: snippet(file.content, line) }
     });
   });
   return out;
@@ -12852,7 +12981,7 @@ function djangoOrmEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/drizzle.ts
 init_cjs_shims();
-var import_node_path49 = __toESM(require("path"), 1);
+var import_node_path50 = __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_types38 = require("@neat.is/types");
@@ -12930,7 +13059,7 @@ function columnsFromObject(obj) {
 }
 function drizzleEndpointsFromFile(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(import_node_path49.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(import_node_path50.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk11 = (node) => {
@@ -12953,7 +13082,7 @@ function drizzleEndpointsFromFile(file, serviceDir) {
             confidenceKind: "structural",
             columns,
             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)
             }
@@ -13019,7 +13148,7 @@ function referencesTargetVar(call) {
 }
 function drizzleForeignKeys(file, serviceDir) {
   if (!DRIZZLE_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt3(import_node_path49.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt3(import_node_path50.default.extname(file.path)), file.content);
   const { tables, varToTable } = collectDrizzleTables(tree.rootNode);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -13038,7 +13167,7 @@ function drizzleForeignKeys(file, serviceDir) {
               childTable: table.tableName,
               parentTable,
               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)
               }
@@ -13055,7 +13184,7 @@ function drizzleForeignKeys(file, serviceDir) {
 
 // src/extract/calls/prisma.ts
 init_cjs_shims();
-var import_node_path50 = __toESM(require("path"), 1);
+var import_node_path51 = __toESM(require("path"), 1);
 var import_types39 = require("@neat.is/types");
 var SCALAR_TYPES = /* @__PURE__ */ new Set([
   "Int",
@@ -13111,7 +13240,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
       confidenceKind: "structural",
       columns: b.columns,
       evidence: {
-        file: import_node_path50.default.relative(serviceDir, file.path),
+        file: import_node_path51.default.relative(serviceDir, file.path),
         line: b.startLine,
         snippet: snippet(content, b.startLine)
       }
@@ -13172,7 +13301,7 @@ function prismaColumnsFromSchema(file, serviceDir) {
 }
 async function prismaColumnEndpoints(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    import_node_path50.default.join("prisma", "schema.prisma"),
+    import_node_path51.default.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -13247,7 +13376,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
               childTable: current.table,
               parentTable,
               evidence: {
-                file: import_node_path50.default.relative(serviceDir, file.path),
+                file: import_node_path51.default.relative(serviceDir, file.path),
                 line: lineNo,
                 snippet: snippet(content, lineNo)
               }
@@ -13262,7 +13391,7 @@ function prismaForeignKeysFromSchema(file, serviceDir) {
 }
 async function prismaForeignKeys(serviceDir) {
   const schemaPath = await findFirst(serviceDir, [
-    import_node_path50.default.join("prisma", "schema.prisma"),
+    import_node_path51.default.join("prisma", "schema.prisma"),
     "schema.prisma"
   ]);
   if (!schemaPath) return [];
@@ -13273,7 +13402,7 @@ async function prismaForeignKeys(serviceDir) {
 
 // src/extract/calls/activerecord.ts
 init_cjs_shims();
-var import_node_path51 = __toESM(require("path"), 1);
+var import_node_path52 = __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_types40 = require("@neat.is/types");
@@ -13481,7 +13610,7 @@ function railsSchemaEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...table.columns.length > 0 ? { columns: table.columns } : {},
       evidence: {
-        file: import_node_path51.default.relative(serviceDir, file.path),
+        file: import_node_path52.default.relative(serviceDir, file.path),
         line: table.line,
         snippet: snippet(file.content, table.line)
       }
@@ -13503,7 +13632,7 @@ function railsSchemaForeignKeys(file, serviceDir) {
       childTable,
       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)
       }
@@ -13586,7 +13715,7 @@ function railsModelEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       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)
       }
@@ -13623,7 +13752,7 @@ function railsModelForeignKeys(file, serviceDir) {
         childTable,
         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)
         }
@@ -13635,7 +13764,7 @@ function railsModelForeignKeys(file, serviceDir) {
 
 // src/extract/calls/eloquent.ts
 init_cjs_shims();
-var import_node_path52 = __toESM(require("path"), 1);
+var import_node_path53 = __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_types41 = require("@neat.is/types");
@@ -13892,7 +14021,7 @@ function laravelMigrationEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: import_node_path52.default.relative(serviceDir, file.path),
+        file: import_node_path53.default.relative(serviceDir, file.path),
         line: bp.line,
         snippet: snippet(file.content, bp.line)
       }
@@ -13914,7 +14043,7 @@ function laravelMigrationForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: import_node_path52.default.relative(serviceDir, file.path),
+        file: import_node_path53.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14034,7 +14163,7 @@ function laravelModelEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path52.default.relative(serviceDir, file.path),
+        file: import_node_path53.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14070,7 +14199,7 @@ function laravelModelForeignKeys(file, serviceDir) {
         childTable,
         parentTable,
         evidence: {
-          file: import_node_path52.default.relative(serviceDir, file.path),
+          file: import_node_path53.default.relative(serviceDir, file.path),
           line,
           snippet: snippet(file.content, line)
         }
@@ -14082,7 +14211,7 @@ function laravelModelForeignKeys(file, serviceDir) {
 
 // src/extract/calls/go.ts
 init_cjs_shims();
-var import_node_path55 = __toESM(require("path"), 1);
+var import_node_path56 = __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_types42 = require("@neat.is/types");
@@ -14157,7 +14286,7 @@ function firstStringLiteralArg(argsNode) {
   return null;
 }
 function goSqlEndpointsFromFile(file, serviceDir) {
-  if (import_node_path55.default.extname(file.path) !== ".go") return [];
+  if (import_node_path56.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]));
@@ -14186,7 +14315,7 @@ function goSqlEndpointsFromFile(file, serviceDir) {
       confidenceKind: "verified-call-site",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(import_node_path55.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path56.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14197,7 +14326,7 @@ function goSqlEndpointsFromFile(file, serviceDir) {
 
 // src/extract/calls/gorm.ts
 init_cjs_shims();
-var import_node_path56 = __toESM(require("path"), 1);
+var import_node_path57 = __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_types43 = require("@neat.is/types");
@@ -14630,7 +14759,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
   seen.delete(struct.name);
 }
 function gormEndpointsFromFile(file, serviceDir) {
-  if (import_node_path56.default.extname(file.path) !== ".go") return [];
+  if (import_node_path57.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);
@@ -14652,7 +14781,7 @@ function gormEndpointsFromFile(file, serviceDir) {
       confidenceKind: "structural",
       ...columns.length > 0 ? { columns } : {},
       evidence: {
-        file: toPosix(import_node_path56.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path57.default.relative(serviceDir, file.path)),
         line: struct.line,
         snippet: snippet(file.content, struct.line)
       }
@@ -14661,7 +14790,7 @@ function gormEndpointsFromFile(file, serviceDir) {
   return out;
 }
 function gormForeignKeys(file, serviceDir) {
-  if (import_node_path56.default.extname(file.path) !== ".go") return [];
+  if (import_node_path57.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);
@@ -14676,7 +14805,7 @@ function gormForeignKeys(file, serviceDir) {
       childTable,
       parentTable,
       evidence: {
-        file: toPosix(import_node_path56.default.relative(serviceDir, file.path)),
+        file: toPosix(import_node_path57.default.relative(serviceDir, file.path)),
         line,
         snippet: snippet(file.content, line)
       }
@@ -14713,7 +14842,7 @@ function gormForeignKeys(file, serviceDir) {
 
 // src/extract/calls/efcore.ts
 init_cjs_shims();
-var import_node_path57 = __toESM(require("path"), 1);
+var import_node_path58 = __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_types44 = require("@neat.is/types");
@@ -14792,7 +14921,7 @@ function tableFromToTable(call) {
   return value ? csStringLiteral(value) : null;
 }
 function efcoreEndpointsFromFile(file, serviceDir) {
-  if (import_node_path57.default.extname(file.path) !== ".cs") return [];
+  if (import_node_path58.default.extname(file.path) !== ".cs") return [];
   if (!EFCORE_GATE.test(file.content)) return [];
   const tree = parseSource13(makeCsParser(), file.content);
   const out = [];
@@ -14807,7 +14936,7 @@ function efcoreEndpointsFromFile(file, serviceDir) {
       edgeType: "CALLS",
       confidenceKind: "structural",
       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)
       }
@@ -15062,7 +15191,7 @@ init_cjs_shims();
 
 // src/extract/infra/docker-compose.ts
 init_cjs_shims();
-var import_node_path58 = __toESM(require("path"), 1);
+var import_node_path59 = __toESM(require("path"), 1);
 var import_types48 = require("@neat.is/types");
 
 // src/extract/infra/shared.ts
@@ -15133,7 +15262,7 @@ function dependsOnList(value) {
 }
 function serviceNameToServiceNode(name, services) {
   for (const s of services) {
-    if (s.node.name === name || import_node_path58.default.basename(s.dir) === name) return s.node.id;
+    if (s.node.name === name || import_node_path59.default.basename(s.dir) === name) return s.node.id;
   }
   return null;
 }
@@ -15142,7 +15271,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_path58.default.join(scanPath, name);
+    const abs = import_node_path59.default.join(scanPath, name);
     if (await exists(abs)) {
       composePath = abs;
       break;
@@ -15155,13 +15284,13 @@ async function addComposeInfra(graph, scanPath, services) {
   } catch (err) {
     recordExtractionError(
       "infra docker-compose",
-      import_node_path58.default.relative(scanPath, composePath),
+      import_node_path59.default.relative(scanPath, composePath),
       err
     );
     return { nodesAdded, edgesAdded };
   }
   if (!compose?.services) return { nodesAdded, edgesAdded };
-  const evidenceFile = import_node_path58.default.relative(scanPath, composePath).split(import_node_path58.default.sep).join("/");
+  const evidenceFile = import_node_path59.default.relative(scanPath, composePath).split(import_node_path59.default.sep).join("/");
   const composeNameToNodeId = /* @__PURE__ */ new Map();
   for (const [composeName, svc] of Object.entries(compose.services)) {
     const matchedServiceId = serviceNameToServiceNode(composeName, services);
@@ -15203,8 +15332,8 @@ async function addComposeInfra(graph, scanPath, services) {
 
 // src/extract/infra/dockerfile.ts
 init_cjs_shims();
-var import_node_path59 = __toESM(require("path"), 1);
-var import_node_fs25 = require("fs");
+var import_node_path60 = __toESM(require("path"), 1);
+var import_node_fs26 = require("fs");
 var import_types49 = require("@neat.is/types");
 function readDockerfile(content) {
   let image = null;
@@ -15234,15 +15363,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const dockerfilePath = import_node_path59.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path60.default.join(service.dir, "Dockerfile");
     if (!await exists(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs25.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs26.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError(
         "infra dockerfile",
-        import_node_path59.default.relative(scanPath, dockerfilePath),
+        import_node_path60.default.relative(scanPath, dockerfilePath),
         err
       );
       continue;
@@ -15254,8 +15383,8 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const relDockerfile = toPosix(import_node_path59.default.relative(service.dir, dockerfilePath));
-    const evidenceFile = toPosix(import_node_path59.default.relative(scanPath, dockerfilePath));
+    const relDockerfile = toPosix(import_node_path60.default.relative(service.dir, dockerfilePath));
+    const evidenceFile = toPosix(import_node_path60.default.relative(scanPath, dockerfilePath));
     const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
       graph,
       service.pkg.name,
@@ -15307,23 +15436,23 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 
 // src/extract/infra/terraform.ts
 init_cjs_shims();
-var import_node_fs26 = require("fs");
-var import_node_path60 = __toESM(require("path"), 1);
+var import_node_fs27 = require("fs");
+var import_node_path61 = __toESM(require("path"), 1);
 var import_types50 = 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_fs26.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs27.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_path60.default.join(start, entry.name);
+      const child = import_node_path61.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_path60.default.join(start, entry.name));
+      out.push(import_node_path61.default.join(start, entry.name));
     }
   }
   return out;
@@ -15354,8 +15483,8 @@ async function addTerraformResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkTfFiles(scanPath);
   for (const file of files) {
-    const content = await import_node_fs26.promises.readFile(file, "utf8");
-    const evidenceFile = toPosix(import_node_path60.default.relative(scanPath, file));
+    const content = await import_node_fs27.promises.readFile(file, "utf8");
+    const evidenceFile = toPosix(import_node_path61.default.relative(scanPath, file));
     const resources = [];
     const byKey = /* @__PURE__ */ new Map();
     RESOURCE_RE.lastIndex = 0;
@@ -15412,8 +15541,8 @@ async function addTerraformResources(graph, scanPath) {
 
 // src/extract/infra/k8s.ts
 init_cjs_shims();
-var import_node_fs27 = require("fs");
-var import_node_path61 = __toESM(require("path"), 1);
+var import_node_fs28 = require("fs");
+var import_node_path62 = __toESM(require("path"), 1);
 var import_yaml3 = require("yaml");
 var import_types51 = require("@neat.is/types");
 var K8S_KIND_TO_INFRA_KIND = {
@@ -15429,15 +15558,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_fs27.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs28.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_path61.default.join(start, entry.name);
+      const child = import_node_path62.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_path61.default.extname(entry.name))) {
-      out.push(import_node_path61.default.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path62.default.extname(entry.name))) {
+      out.push(import_node_path62.default.join(start, entry.name));
     }
   }
   return out;
@@ -15447,14 +15576,14 @@ async function addK8sResources(graph, scanPath) {
   let edgesAdded = 0;
   const files = await walkYamlFiles2(scanPath);
   for (const file of files) {
-    const content = await import_node_fs27.promises.readFile(file, "utf8");
+    const content = await import_node_fs28.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml3.parseAllDocuments)(content).map((d) => d.toJSON());
     } catch {
       continue;
     }
-    const relFile = toPosix(import_node_path61.default.relative(scanPath, file));
+    const relFile = toPosix(import_node_path62.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];
@@ -15503,16 +15632,16 @@ async function addK8sResources(graph, scanPath) {
 
 // src/extract/infra/cloudflare.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_smol_toml3 = require("smol-toml");
 var import_types52 = 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_path62.default.join(dir, filename);
+    const abs = import_node_path63.default.join(dir, filename);
     if (!await exists(abs)) continue;
-    const raw = await import_node_fs28.promises.readFile(abs, "utf8");
+    const raw = await import_node_fs29.promises.readFile(abs, "utf8");
     const config = filename === "wrangler.toml" ? (0, import_smol_toml3.parse)(raw) : JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
@@ -15573,11 +15702,11 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     try {
       read = await readWranglerConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra cloudflare", import_node_path62.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra cloudflare", import_node_path63.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read || !read.config.name) continue;
-    const evidenceFile = toPosix(import_node_path62.default.relative(scanPath, import_node_path62.default.join(service.dir, read.relFile)));
+    const evidenceFile = toPosix(import_node_path63.default.relative(scanPath, import_node_path63.default.join(service.dir, read.relFile)));
     discovered.push({ service, config: read.config, relFile: read.relFile, raw: read.raw, evidenceFile });
   }
   for (const worker of discovered) {
@@ -15589,7 +15718,7 @@ async function addCloudflareWorkers(graph, services, scanPath) {
     }
     let anchorId = service.node.id;
     if (config.main) {
-      const entryRelPath = toPosix(import_node_path62.default.normalize(config.main));
+      const entryRelPath = toPosix(import_node_path63.default.normalize(config.main));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -15736,24 +15865,24 @@ async function addCloudflareWorkers(graph, services, scanPath) {
 
 // src/extract/infra/vercel.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_types53 = 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_path63.default.join(dir, filename);
+    const abs = import_node_path64.default.join(dir, filename);
     if (!await exists(abs)) continue;
-    const raw = await import_node_fs29.promises.readFile(abs, "utf8");
+    const raw = await import_node_fs30.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_path63.default.join(dir, ".vercel", "project.json");
+  const abs = import_node_path64.default.join(dir, ".vercel", "project.json");
   if (!await exists(abs)) return void 0;
-  const parsed = JSON.parse(await import_node_fs29.promises.readFile(abs, "utf8"));
+  const parsed = JSON.parse(await import_node_fs30.promises.readFile(abs, "utf8"));
   return typeof parsed.projectName === "string" ? parsed.projectName : void 0;
 }
 function routeSource(route) {
@@ -15769,7 +15898,7 @@ async function addVercelServices(graph, services, scanPath) {
       read = await readVercelConfig(service.dir);
       projectName = await readLinkedProjectName(service.dir);
     } catch (err) {
-      recordExtractionError("infra vercel", import_node_path63.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra vercel", import_node_path64.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read && !projectName) continue;
@@ -15785,7 +15914,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_path63.default.relative(scanPath, import_node_path63.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path64.default.relative(scanPath, import_node_path64.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -15814,16 +15943,16 @@ async function addVercelServices(graph, services, scanPath) {
 
 // src/extract/infra/railway.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_toml4 = require("smol-toml");
 var import_types54 = 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_path64.default.join(dir, filename);
+    const abs = import_node_path65.default.join(dir, filename);
     if (!await exists(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 === "railway.toml" ? (0, import_smol_toml4.parse)(raw) : JSON.parse(maskCommentsInSource(raw));
     return { config, relFile: filename, raw };
   }
@@ -15837,7 +15966,7 @@ async function addRailwayServices(graph, services, scanPath) {
     try {
       read = await readRailwayConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra railway", import_node_path64.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra railway", import_node_path65.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -15847,7 +15976,7 @@ async function addRailwayServices(graph, services, scanPath) {
     }
     const anchorId = service.node.id;
     const { config, relFile, raw } = read;
-    const evidenceFile = toPosix(import_node_path64.default.relative(scanPath, import_node_path64.default.join(service.dir, relFile)));
+    const evidenceFile = toPosix(import_node_path65.default.relative(scanPath, import_node_path65.default.join(service.dir, relFile)));
     const add = (edgeType, kind, name) => {
       if (!name) return;
       const result = emitPlatformResourceEdge(
@@ -15872,15 +16001,15 @@ async function addRailwayServices(graph, services, scanPath) {
 
 // src/extract/infra/supabase.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_smol_toml5 = require("smol-toml");
 var import_types55 = require("@neat.is/types");
 async function readSupabaseConfig(dir) {
-  const relFile = import_node_path65.default.join("supabase", "config.toml");
-  const abs = import_node_path65.default.join(dir, relFile);
+  const relFile = import_node_path66.default.join("supabase", "config.toml");
+  const abs = import_node_path66.default.join(dir, relFile);
   if (!await exists(abs)) return null;
-  const raw = await import_node_fs31.promises.readFile(abs, "utf8");
+  const raw = await import_node_fs32.promises.readFile(abs, "utf8");
   const config = (0, import_smol_toml5.parse)(raw);
   return { config, relFile, raw };
 }
@@ -15892,7 +16021,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
     try {
       read = await readSupabaseConfig(service.dir);
     } catch (err) {
-      recordExtractionError("infra supabase", import_node_path65.default.relative(scanPath, service.dir), err);
+      recordExtractionError("infra supabase", import_node_path66.default.relative(scanPath, service.dir), err);
       continue;
     }
     if (!read) continue;
@@ -15907,7 +16036,7 @@ async function addSupabaseProjects(graph, services, scanPath) {
       });
     }
     const anchorId = service.node.id;
-    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(
@@ -15949,7 +16078,7 @@ async function addInfra(graph, scanPath, services) {
 
 // src/extract/zod-shapes.ts
 init_cjs_shims();
-var import_node_path66 = __toESM(require("path"), 1);
+var import_node_path67 = __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_types56 = require("@neat.is/types");
@@ -16044,7 +16173,7 @@ function topLevelSchemas(root) {
 }
 function zodShapesFromFile(file, serviceDir) {
   if (!ZOD_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource3(parserForExt4(import_node_path66.default.extname(file.path)), file.content);
+  const tree = parseSource3(parserForExt4(import_node_path67.default.extname(file.path)), file.content);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const { name, call } of topLevelSchemas(tree.rootNode)) {
@@ -16062,7 +16191,7 @@ function zodShapesFromFile(file, serviceDir) {
       name,
       fields,
       evidence: {
-        file: import_node_path66.default.relative(serviceDir, file.path),
+        file: import_node_path67.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -16330,12 +16459,12 @@ async function addFirestoreRules(graph, services) {
 }
 
 // src/extract/index.ts
-var import_node_path68 = __toESM(require("path"), 1);
+var import_node_path69 = __toESM(require("path"), 1);
 
 // src/extract/retire.ts
 init_cjs_shims();
-var import_node_fs32 = require("fs");
-var import_node_path67 = __toESM(require("path"), 1);
+var import_node_fs33 = require("fs");
+var import_node_path68 = __toESM(require("path"), 1);
 var import_types58 = require("@neat.is/types");
 function dropOrphanedFileNodes(graph) {
   const orphans = [];
@@ -16356,11 +16485,11 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
     if (edge.provenance !== import_types58.Provenance.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
-    if (import_node_path67.default.isAbsolute(evidenceFile)) {
-      if (!(0, import_node_fs32.existsSync)(evidenceFile)) toDrop.push(id);
+    if (import_node_path68.default.isAbsolute(evidenceFile)) {
+      if (!(0, import_node_fs33.existsSync)(evidenceFile)) toDrop.push(id);
       return;
     }
-    const found = bases.some((base) => (0, import_node_fs32.existsSync)(import_node_path67.default.join(base, evidenceFile)));
+    const found = bases.some((base) => (0, import_node_fs33.existsSync)(import_node_path68.default.join(base, evidenceFile)));
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
@@ -16372,6 +16501,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);
@@ -16416,8 +16546,9 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
     }
   }
   const droppedEntries = drainDroppedExtracted();
+  const skippedEntries = drainSkippedFiles();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
-    const rejectedPath = import_node_path68.default.join(import_node_path68.default.dirname(opts.errorsPath), "rejected.ndjson");
+    const rejectedPath = import_node_path69.default.join(import_node_path69.default.dirname(opts.errorsPath), "rejected.ndjson");
     try {
       await writeRejectedExtracted(droppedEntries, rejectedPath);
     } catch (err) {
@@ -16434,7 +16565,9 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
     errorEntries,
     ghostsRetired,
     extractedDropped: droppedEntries.length,
-    droppedEntries
+    droppedEntries,
+    skippedFiles: skippedEntries.length,
+    skippedEntries
   };
   emitNeatEvent({
     type: "extraction-complete",
@@ -16451,8 +16584,8 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
 
 // src/persist.ts
 init_cjs_shims();
-var import_node_fs33 = require("fs");
-var import_node_path69 = __toESM(require("path"), 1);
+var import_node_fs34 = require("fs");
+var import_node_path70 = __toESM(require("path"), 1);
 var import_types59 = require("@neat.is/types");
 var SCHEMA_VERSION = 7;
 function migrateV1ToV2(payload) {
@@ -16507,7 +16640,43 @@ function migrateV2ToV3(payload) {
   return { ...payload, schemaVersion: 3 };
 }
 async function ensureDir(filePath) {
-  await import_node_fs33.promises.mkdir(import_node_path69.default.dirname(filePath), { recursive: true });
+  await import_node_fs34.promises.mkdir(import_node_path70.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);
@@ -16517,13 +16686,26 @@ async function saveGraphToDisk(graph, outPath) {
     graph: graph.export()
   };
   const tmp = `${outPath}.tmp`;
-  await import_node_fs33.promises.writeFile(tmp, JSON.stringify(payload), "utf8");
-  await import_node_fs33.promises.rename(tmp, outPath);
+  const handle = await import_node_fs34.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_fs34.promises.rename(tmp, outPath);
 }
 async function loadGraphFromDisk(graph, outPath) {
   let raw;
   try {
-    raw = await import_node_fs33.promises.readFile(outPath, "utf8");
+    raw = await import_node_fs34.promises.readFile(outPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -16603,15 +16785,15 @@ var import_types101 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
-var import_node_fs35 = require("fs");
-var import_node_path71 = __toESM(require("path"), 1);
+var import_node_fs36 = require("fs");
+var import_node_path72 = __toESM(require("path"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
 var import_instrumentation_registry = require("@neat.is/instrumentation-registry");
 
 // src/installers/package-manager.ts
 init_cjs_shims();
-var import_node_fs34 = require("fs");
-var import_node_path70 = __toESM(require("path"), 1);
+var import_node_fs35 = require("fs");
+var import_node_path71 = __toESM(require("path"), 1);
 var import_node_child_process = require("child_process");
 var LOCKFILE_PRIORITY = [
   { lockfile: "bun.lockb", pm: "bun", args: ["install", "--no-summary"] },
@@ -16626,29 +16808,29 @@ var LOCKFILE_PRIORITY = [
 var NPM_FALLBACK_ARGS = ["install", "--no-audit", "--no-fund", "--prefer-offline"];
 async function exists2(p) {
   try {
-    await import_node_fs34.promises.access(p);
+    await import_node_fs35.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function detectPackageManager(serviceDir) {
-  let dir = import_node_path70.default.resolve(serviceDir);
+  let dir = import_node_path71.default.resolve(serviceDir);
   const stops = /* @__PURE__ */ new Set();
   for (let i = 0; i < 64; i++) {
     if (stops.has(dir)) break;
     stops.add(dir);
     for (const candidate of LOCKFILE_PRIORITY) {
-      const lockPath = import_node_path70.default.join(dir, candidate.lockfile);
+      const lockPath = import_node_path71.default.join(dir, candidate.lockfile);
       if (await exists2(lockPath)) {
         return { pm: candidate.pm, cwd: dir, args: [...candidate.args] };
       }
     }
-    const parent = import_node_path70.default.dirname(dir);
+    const parent = import_node_path71.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return { pm: "npm", cwd: import_node_path70.default.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
+  return { pm: "npm", cwd: import_node_path71.default.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
 }
 async function runPackageManagerInstall(cmd) {
   return new Promise((resolve) => {
@@ -16690,15 +16872,15 @@ ${err.message}`
 // src/extend/index.ts
 async function fileExists2(p) {
   try {
-    await import_node_fs35.promises.access(p);
+    await import_node_fs36.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function readPackageJson(scanPath) {
-  const pkgPath = import_node_path71.default.join(scanPath, "package.json");
-  const raw = await import_node_fs35.promises.readFile(pkgPath, "utf8");
+  const pkgPath = import_node_path72.default.join(scanPath, "package.json");
+  const raw = await import_node_fs36.promises.readFile(pkgPath, "utf8");
   return JSON.parse(raw);
 }
 var HOOK_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -16712,15 +16894,15 @@ var HOOK_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
 async function findHookFiles(scanPath) {
   const found = [];
   const walk11 = async (dir) => {
-    const entries = await import_node_fs35.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs36.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || HOOK_WALK_SKIP_DIRS.has(entry.name)) continue;
-        await walk11(import_node_path71.default.join(dir, entry.name));
+        await walk11(import_node_path72.default.join(dir, entry.name));
       } else if (entry.isFile()) {
         if ((entry.name.startsWith("instrumentation") || entry.name.startsWith("otel-init")) && /\.(ts|js|cjs|mjs)$/.test(entry.name)) {
-          const rel = import_node_path71.default.relative(scanPath, import_node_path71.default.join(dir, entry.name));
-          found.push(rel.split(import_node_path71.default.sep).join("/"));
+          const rel = import_node_path72.default.relative(scanPath, import_node_path72.default.join(dir, entry.name));
+          found.push(rel.split(import_node_path72.default.sep).join("/"));
         }
       }
     }
@@ -16731,7 +16913,7 @@ async function findHookFiles(scanPath) {
 async function pickPrimaryHookFile(scanPath, hookFiles, snippet2) {
   let fallback = null;
   for (const file of hookFiles) {
-    const content = await import_node_fs35.promises.readFile(import_node_path71.default.join(scanPath, file), "utf8");
+    const content = await import_node_fs36.promises.readFile(import_node_path72.default.join(scanPath, file), "utf8");
     const patched = splicedContent(content, snippet2);
     if (patched !== null) return { file, content, patched };
     if (fallback === null) fallback = { file, content };
@@ -16739,12 +16921,12 @@ async function pickPrimaryHookFile(scanPath, hookFiles, snippet2) {
   return { file: fallback.file, content: fallback.content, patched: null };
 }
 function extendLogPath() {
-  return process.env.NEAT_EXTEND_LOG ?? import_node_path71.default.join(import_node_os2.default.homedir(), ".neat", "extend-log.ndjson");
+  return process.env.NEAT_EXTEND_LOG ?? import_node_path72.default.join(import_node_os2.default.homedir(), ".neat", "extend-log.ndjson");
 }
 async function appendExtendLog(entry) {
   const logPath = extendLogPath();
-  await import_node_fs35.promises.mkdir(import_node_path71.default.dirname(logPath), { recursive: true });
-  await import_node_fs35.promises.appendFile(logPath, JSON.stringify(entry) + "\n", "utf8");
+  await import_node_fs36.promises.mkdir(import_node_path72.default.dirname(logPath), { recursive: true });
+  await import_node_fs36.promises.appendFile(logPath, JSON.stringify(entry) + "\n", "utf8");
 }
 function splicedContent(fileContent, snippet2) {
   if (fileContent.includes("__INSTRUMENTATION_BLOCK__")) {
@@ -16802,7 +16984,7 @@ function lookupInstrumentation(library, installedVersion) {
 }
 async function describeProjectInstrumentation(ctx) {
   const hookFiles = await findHookFiles(ctx.scanPath);
-  const envNeat = await fileExists2(import_node_path71.default.join(ctx.scanPath, ".env.neat"));
+  const envNeat = await fileExists2(import_node_path72.default.join(ctx.scanPath, ".env.neat"));
   const registryInstrPackages = new Set(
     (0, import_instrumentation_registry.list)().map((e) => e.instrumentation_package).filter((p) => !!p)
   );
@@ -16824,7 +17006,7 @@ async function applyExtension(ctx, args, options) {
     );
   }
   for (const file of hookFiles) {
-    const content = await import_node_fs35.promises.readFile(import_node_path71.default.join(ctx.scanPath, file), "utf8");
+    const content = await import_node_fs36.promises.readFile(import_node_path72.default.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return { library: args.library, filesTouched: [], depsAdded: [], installOutput: "", alreadyApplied: true };
     }
@@ -16836,18 +17018,18 @@ async function applyExtension(ctx, args, options) {
     );
   }
   const primaryFile = primary.file;
-  const primaryPath = import_node_path71.default.join(ctx.scanPath, primaryFile);
+  const primaryPath = import_node_path72.default.join(ctx.scanPath, primaryFile);
   const filesTouched = [];
   const depsAdded = [];
-  const pkgPath = import_node_path71.default.join(ctx.scanPath, "package.json");
+  const pkgPath = import_node_path72.default.join(ctx.scanPath, "package.json");
   const pkg = await readPackageJson(ctx.scanPath);
   if (!(pkg.dependencies ?? {})[args.instrumentation_package]) {
     pkg.dependencies = { ...pkg.dependencies ?? {}, [args.instrumentation_package]: args.version };
-    await import_node_fs35.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    await import_node_fs36.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     filesTouched.push("package.json");
     depsAdded.push(`${args.instrumentation_package}@${args.version}`);
   }
-  await import_node_fs35.promises.writeFile(primaryPath, primary.patched, "utf8");
+  await import_node_fs36.promises.writeFile(primaryPath, primary.patched, "utf8");
   filesTouched.push(primaryFile);
   const cmd = await detectPackageManager(ctx.scanPath);
   const installer = options?.runInstall ?? runPackageManagerInstall;
@@ -16878,7 +17060,7 @@ async function dryRunExtension(ctx, args) {
     };
   }
   for (const file of hookFiles) {
-    const content = await import_node_fs35.promises.readFile(import_node_path71.default.join(ctx.scanPath, file), "utf8");
+    const content = await import_node_fs36.promises.readFile(import_node_path72.default.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return {
         library: args.library,
@@ -16913,28 +17095,28 @@ async function rollbackExtension(ctx, args) {
   if (!await fileExists2(logPath)) {
     return { undone: false, message: "no apply found for library" };
   }
-  const raw = await import_node_fs35.promises.readFile(logPath, "utf8");
+  const raw = await import_node_fs36.promises.readFile(logPath, "utf8");
   const entries = raw.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
   const match = [...entries].reverse().find((e) => e.project === ctx.project && e.library === args.library);
   if (!match) {
     return { undone: false, message: "no apply found for library" };
   }
-  const pkgPath = import_node_path71.default.join(ctx.scanPath, "package.json");
+  const pkgPath = import_node_path72.default.join(ctx.scanPath, "package.json");
   if (await fileExists2(pkgPath)) {
     const pkg = await readPackageJson(ctx.scanPath);
     if (pkg.dependencies?.[match.instrumentation_package]) {
       const { [match.instrumentation_package]: _removed, ...rest } = pkg.dependencies;
       pkg.dependencies = rest;
-      await import_node_fs35.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+      await import_node_fs36.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     }
   }
   const hookFiles = await findHookFiles(ctx.scanPath);
   for (const file of hookFiles) {
-    const filePath = import_node_path71.default.join(ctx.scanPath, file);
-    const content = await import_node_fs35.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path72.default.join(ctx.scanPath, file);
+    const content = await import_node_fs36.promises.readFile(filePath, "utf8");
     if (content.includes(match.registration_snippet)) {
       const filtered = content.split("\n").filter((line) => !line.includes(match.registration_snippet)).join("\n");
-      await import_node_fs35.promises.writeFile(filePath, filtered, "utf8");
+      await import_node_fs36.promises.writeFile(filePath, filtered, "utf8");
       break;
     }
   }
@@ -18571,7 +18753,7 @@ async function askGraph(graph, question, opts = {}) {
 
 // src/diff.ts
 init_cjs_shims();
-var import_node_fs36 = require("fs");
+var import_node_fs37 = require("fs");
 async function loadSnapshotForDiff(target) {
   if (/^https?:\/\//i.test(target)) {
     const res = await fetch(target);
@@ -18580,7 +18762,7 @@ async function loadSnapshotForDiff(target) {
     }
     return await res.json();
   }
-  const raw = await import_node_fs36.promises.readFile(target, "utf8");
+  const raw = await import_node_fs37.promises.readFile(target, "utf8");
   return JSON.parse(raw);
 }
 function indexEntries(entries) {
@@ -18648,23 +18830,23 @@ function canonicalJson(value) {
 
 // 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 {
@@ -18700,28 +18882,28 @@ var Projects = class {
 
 // 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");
 var LOCK_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_MS = 50;
 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 registryLockPath() {
-  return import_node_path73.default.join(neatHome(), "projects.json.lock");
+  return import_node_path74.default.join(neatHome(), "projects.json.lock");
 }
 function daemonPidPath() {
-  return import_node_path73.default.join(neatHome(), "neatd.pid");
+  return import_node_path74.default.join(neatHome(), "neatd.pid");
 }
 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);
@@ -18754,7 +18936,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;
@@ -18762,10 +18944,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;
     }
@@ -18791,7 +18973,7 @@ function isPidAliveDefault(pid) {
 }
 async function readPidFile(file) {
   try {
-    const raw = await import_node_fs37.promises.readFile(file, "utf8");
+    const raw = await import_node_fs38.promises.readFile(file, "utf8");
     const pid = Number.parseInt(raw.trim(), 10);
     return Number.isInteger(pid) && pid > 0 ? pid : void 0;
   } catch {
@@ -18817,14 +18999,12 @@ async function readLockPid(lockPath) {
 async function classifyLockHolder(lockPath, probe = defaultLockHolderProbe) {
   const lockPid = await readLockPid(lockPath);
   const daemonPid = await probe.daemonPidFromFile();
-  if (daemonPid !== void 0 && daemonPid !== process.pid && probe.isPidAlive(daemonPid) && // The lock already names the daemon, or the daemon answers on its port.
-  // Either confirms a live daemon is in the picture (the second guards
-  // against a stale pidfile whose PID got reused).
-  (daemonPid === lockPid || await probe.daemonResponds())) {
-    return { kind: "daemon", pid: daemonPid };
-  }
   if (lockPid !== void 0 && lockPid !== process.pid && probe.isPidAlive(lockPid)) {
-    return { kind: "command", pid: lockPid };
+    return { kind: lockPid === daemonPid ? "daemon" : "command", pid: lockPid };
+  }
+  if (daemonPid !== void 0 && daemonPid !== process.pid && probe.isPidAlive(daemonPid) && // Guards against a stale pidfile whose PID got reused.
+  await probe.daemonResponds()) {
+    return { kind: "daemon", pid: daemonPid };
   }
   return { kind: "stale" };
 }
@@ -18835,36 +19015,36 @@ function lockHolderMessage(holder, lockPath, timeoutMs) {
     case "command":
       return `Another neat command (pid ${holder.pid}) is holding the registry lock. Wait for it to finish, or check \`ps\` if you're not sure what's running.`;
     case "stale":
-      return `neat registry: timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`;
+      return `timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`;
   }
 }
 async function normalizeProjectPath(input) {
-  const resolved = import_node_path73.default.resolve(input);
+  const resolved = import_node_path74.default.resolve(input);
   try {
-    return await import_node_fs37.promises.realpath(resolved);
+    return await import_node_fs38.promises.realpath(resolved);
   } catch {
     return resolved;
   }
 }
 async function writeAtomically(target, contents) {
-  await import_node_fs37.promises.mkdir(import_node_path73.default.dirname(target), { recursive: true });
+  await import_node_fs38.promises.mkdir(import_node_path74.default.dirname(target), { recursive: true });
   const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await import_node_fs37.promises.open(tmp, "w");
+  const fd = await import_node_fs38.promises.open(tmp, "w");
   try {
     await fd.writeFile(contents, "utf8");
     await fd.sync();
   } finally {
     await fd.close();
   }
-  await import_node_fs37.promises.rename(tmp, target);
+  await import_node_fs38.promises.rename(tmp, target);
 }
 async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaultLockHolderProbe) {
   const deadline = Date.now() + timeoutMs;
-  await import_node_fs37.promises.mkdir(import_node_path73.default.dirname(lockPath), { recursive: true });
+  await import_node_fs38.promises.mkdir(import_node_path74.default.dirname(lockPath), { recursive: true });
   let probedHolder = false;
   while (true) {
     try {
-      const fd = await import_node_fs37.promises.open(lockPath, "wx");
+      const fd = await import_node_fs38.promises.open(lockPath, "wx");
       try {
         await fd.writeFile(`${process.pid}
 `, "utf8");
@@ -18878,18 +19058,36 @@ async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaul
       if (!probedHolder) {
         probedHolder = true;
         const holder = await classifyLockHolder(lockPath, probe);
-        if (holder.kind === "daemon") throw new Error(lockHolderMessage(holder, lockPath, timeoutMs));
+        if (holder.kind === "daemon") {
+          throw new RegistryLockError(lockHolderMessage(holder, lockPath, timeoutMs));
+        }
+        if (holder.kind === "stale" && await isReclaimableLock(lockPath)) {
+          await import_node_fs38.promises.unlink(lockPath).catch(() => {
+          });
+          continue;
+        }
       }
       if (Date.now() >= deadline) {
         const holder = await classifyLockHolder(lockPath, probe);
-        throw new Error(lockHolderMessage(holder, lockPath, timeoutMs));
+        throw new RegistryLockError(lockHolderMessage(holder, lockPath, timeoutMs));
       }
       await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
     }
   }
 }
+var LOCK_UNSTAMPED_GRACE_MS = 5e3;
+async function isReclaimableLock(lockPath) {
+  const pid = await readLockPid(lockPath);
+  if (pid !== void 0) return true;
+  try {
+    const stat = await import_node_fs38.promises.stat(lockPath);
+    return Date.now() - stat.mtimeMs > LOCK_UNSTAMPED_GRACE_MS;
+  } catch {
+    return false;
+  }
+}
 async function releaseLock(lockPath) {
-  await import_node_fs37.promises.unlink(lockPath).catch(() => {
+  await import_node_fs38.promises.unlink(lockPath).catch(() => {
   });
 }
 async function withLock(fn) {
@@ -18905,7 +19103,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: [] };
@@ -18919,10 +19117,22 @@ async function writeRegistry(reg) {
   const validated = import_types63.RegistryFileSchema.parse(reg);
   await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
 }
-var ProjectNameCollisionError = class extends Error {
+var RegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryError";
+  }
+};
+var RegistryLockError = class extends RegistryError {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryLockError";
+  }
+};
+var ProjectNameCollisionError = class extends RegistryError {
   projectName;
   constructor(name) {
-    super(`neat registry: a project named "${name}" is already registered`);
+    super(`a project named "${name}" is already registered`);
     this.name = "ProjectNameCollisionError";
     this.projectName = name;
   }
@@ -18971,7 +19181,7 @@ async function setStatus(name, status2) {
   return withLock(async () => {
     const reg = await readRegistry();
     const entry = reg.projects.find((p) => p.name === name);
-    if (!entry) throw new Error(`neat registry: no project named "${name}"`);
+    if (!entry) throw new RegistryError(`no project named "${name}"`);
     entry.status = status2;
     await writeRegistry(reg);
     return entry;
@@ -19010,7 +19220,7 @@ function pruneTtlMs() {
 }
 async function statPathStatus(p) {
   try {
-    const stat = await import_node_fs37.promises.stat(p);
+    const stat = await import_node_fs38.promises.stat(p);
     return stat.isDirectory() ? "present" : "unknown";
   } catch (err) {
     return err.code === "ENOENT" ? "gone" : "unknown";
@@ -19111,8 +19321,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;
@@ -19126,17 +19336,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(
@@ -19150,7 +19360,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: [] };
@@ -19946,10 +20156,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(path79) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path79);
+function targetFromRestPath(path80) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path80);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path79);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path80);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -20553,9 +20763,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path79 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path79) return null;
-  return { resourceName, method, path: path79 };
+  const path80 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path80) return null;
+  return { resourceName, method, path: path80 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -20593,14 +20803,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 path79 = pathFromRequestUrl(req.requestUrl);
-  if (path79 === null) return null;
+  const path80 = pathFromRequestUrl(req.requestUrl);
+  if (path80 === 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: path79 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path80 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -20625,9 +20835,9 @@ var import_types71 = require("@neat.is/types");
 function normalizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function inferServiceName(graph, resourceName, method, path79) {
+function inferServiceName(graph, resourceName, method, path80) {
   const wantedMethod = method.toUpperCase();
-  const wantedPath = normalizePathTemplate(path79);
+  const wantedPath = normalizePathTemplate(path80);
   const services = [];
   const owners = /* @__PURE__ */ new Set();
   graph.forEachNode((_id, attrs) => {
@@ -20844,7 +21054,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 path79 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path80 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -20852,7 +21062,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path79 ? { path: path79 } : {},
+    ...path80 ? { path: path80 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -20898,8 +21108,8 @@ function findTaggedWorkerFileNode(graph, workerName) {
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path79) {
-  const normalizedPath = normalizePathTemplate(path79);
+function findMatchingRouteNode(graph, serviceName, method, path80) {
+  const normalizedPath = normalizePathTemplate(path80);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
@@ -20916,10 +21126,10 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path79 } = signal;
+    const { method, path: path80 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path79) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path79) ?? wholeFileId;
+      if (!method || !path80) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path80) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
@@ -21271,9 +21481,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path79 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path79) return null;
-  return { serviceName, method, path: path79 };
+  const path80 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path80) return null;
+  return { serviceName, method, path: path80 };
 }
 
 // src/connectors/cloud-run/map.ts
@@ -21302,14 +21512,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 path79 = pathFromRequestUrl2(req.requestUrl);
-  if (path79 === null) return null;
+  const path80 = pathFromRequestUrl2(req.requestUrl);
+  if (path80 === 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: path79 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path80 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -21348,14 +21558,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: path79 } = identity;
-    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path79) ?? void 0 : void 0);
+    const { serviceName: gcpServiceName, method, path: path80 } = identity;
+    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path80) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path79)
+        normalizePathTemplate(path80)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types82.EdgeType.CALLS };
@@ -21491,9 +21701,9 @@ function parseGcpLbTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP3);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path79 = rest.slice(secondSep + 1);
-  if (!backendServiceName || !method || !path79) return null;
-  return { backendServiceName, method, path: path79 };
+  const path80 = rest.slice(secondSep + 1);
+  if (!backendServiceName || !method || !path80) return null;
+  return { backendServiceName, method, path: path80 };
 }
 
 // src/connectors/gcp-lb/map.ts
@@ -21522,14 +21732,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 path79 = pathFromRequestUrl3(req.requestUrl);
-  if (path79 === null) return null;
+  const path80 = pathFromRequestUrl3(req.requestUrl);
+  if (path80 === 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: path79 }),
+    targetName: packGcpLbTargetName({ backendServiceName, method, path: path80 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -21568,14 +21778,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: path79 } = identity;
-    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path79) ?? void 0 : void 0);
+    const { backendServiceName, method, path: path80 } = identity;
+    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path80) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode3(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path79)
+        normalizePathTemplate(path80)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types86.EdgeType.CALLS };
@@ -22893,16 +23103,18 @@ function serializeGraph(graph) {
   });
   return { nodes, edges };
 }
-function projectFromReq(req, singleProject) {
+function projectFromReq(req, singleProject, registry) {
   const params = req.params;
   const named2 = params.project;
   if (singleProject) {
     return named2 === void 0 || named2 === DEFAULT_PROJECT ? singleProject : named2;
   }
-  return named2 ?? DEFAULT_PROJECT;
+  if (named2 !== void 0) return named2;
+  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);
@@ -22914,10 +23126,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;
   }
@@ -23800,8 +24015,8 @@ init_otel_grpc();
 
 // src/daemon.ts
 init_cjs_shims();
-var import_node_fs41 = require("fs");
-var import_node_path79 = __toESM(require("path"), 1);
+var import_node_fs42 = require("fs");
+var import_node_path80 = __toESM(require("path"), 1);
 var import_node_module = require("module");
 init_otel();
 
@@ -23838,7 +24053,7 @@ async function reconcileFrontierSurfaces(graph, errorsPath) {
 // src/connectors/hosted.ts
 init_cjs_shims();
 var import_promises = require("fs/promises");
-var import_node_path75 = require("path");
+var import_node_path76 = require("path");
 
 // src/connectors/railway/target-ref.ts
 init_cjs_shims();
@@ -23873,13 +24088,13 @@ function decodeRailwayTargetRef(ref) {
 var CREDENTIAL_REFRESH_SKEW_MS = 6e4;
 var CP_REQUEST_TIMEOUT_MS = 1e4;
 var DEFAULT_RELIST_INTERVAL_MS = 6e4;
-async function cpGet(path79, deps) {
+async function cpGet(path80, deps) {
   const f = deps.fetchImpl ?? fetch;
-  const res = await f(`${deps.cpUrl.replace(/\/+$/, "")}${path79}`, {
+  const res = await f(`${deps.cpUrl.replace(/\/+$/, "")}${path80}`, {
     headers: { authorization: `Bearer ${deps.daemonToken}`, accept: "application/json" },
     signal: AbortSignal.timeout(CP_REQUEST_TIMEOUT_MS)
   });
-  if (!res.ok) throw new Error(`control plane ${path79} \u2192 HTTP ${res.status}`);
+  if (!res.ok) throw new Error(`control plane ${path80} \u2192 HTTP ${res.status}`);
   return await res.json();
 }
 function credentialRecord(provider, cred) {
@@ -23940,7 +24155,7 @@ function parseFirebaseServiceMap(raw) {
   }
 }
 function pushHandlesPath(projectDir) {
-  return (0, import_node_path75.join)(projectDir, "neat-out", "connectors-hosted.json");
+  return (0, import_node_path76.join)(projectDir, "neat-out", "connectors-hosted.json");
 }
 async function readPushHandles(projectDir) {
   try {
@@ -23951,14 +24166,14 @@ async function readPushHandles(projectDir) {
   }
 }
 async function writePushHandle(projectDir, provider, handle) {
-  const path79 = pushHandlesPath(projectDir);
+  const path80 = pushHandlesPath(projectDir);
   const handles = await readPushHandles(projectDir);
   handles[provider] = handle;
-  await (0, import_promises.mkdir)((0, import_node_path75.dirname)(path79), { recursive: true });
-  const tmp = `${path79}.${process.pid}.tmp`;
+  await (0, import_promises.mkdir)((0, import_node_path76.dirname)(path80), { recursive: true });
+  const tmp = `${path80}.${process.pid}.tmp`;
   await (0, import_promises.writeFile)(tmp, `${JSON.stringify(handles, null, 2)}
 `, "utf8");
-  await (0, import_promises.rename)(tmp, path79);
+  await (0, import_promises.rename)(tmp, path80);
 }
 function pushCredentialRecord(provider, cred, deps) {
   switch (provider) {
@@ -24179,7 +24394,7 @@ async function maybeStartHostedConnectors(input) {
 // src/connectors/hosted-repos.ts
 init_cjs_shims();
 var import_node_os5 = __toESM(require("os"), 1);
-var import_node_path76 = __toESM(require("path"), 1);
+var import_node_path77 = __toESM(require("path"), 1);
 var import_promises2 = require("fs/promises");
 var CP_REQUEST_TIMEOUT_MS2 = 1e4;
 var DEFAULT_SYNC_INTERVAL_MS = 5 * 6e4;
@@ -24208,7 +24423,7 @@ async function cpPostStatus(deps, owner, name, body) {
   if (!res.ok && res.status !== 404) throw new Error(`control plane status POST \u2192 HTTP ${res.status}`);
 }
 var defaultCloneRepo = async (cloneUrl, ref, destDir) => {
-  const [{ default: git }, httpMod, fs40] = await Promise.all([
+  const [{ default: git }, httpMod, fs41] = await Promise.all([
     import("isomorphic-git"),
     import("isomorphic-git/http/node"),
     import("fs")
@@ -24219,7 +24434,7 @@ var defaultCloneRepo = async (cloneUrl, ref, destDir) => {
   const username = parsed.password ? parsed.username : "x-access-token";
   const cleanUrl = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
   const clone = git.clone({
-    fs: fs40,
+    fs: fs41,
     http,
     dir: destDir,
     url: cleanUrl,
@@ -24250,7 +24465,7 @@ async function syncOneRepo(r, input) {
   const tmpRoot = input.tmpRoot ?? import_node_os5.default.tmpdir();
   let dir;
   try {
-    dir = await (0, import_promises2.mkdtemp)(import_node_path76.default.join(tmpRoot, "neat-repo-"));
+    dir = await (0, import_promises2.mkdtemp)(import_node_path77.default.join(tmpRoot, "neat-repo-"));
     await cpPostStatus(deps, r.owner, r.name, { syncStatus: "syncing", detail: "cloning" }).catch(() => {
     });
     await cloneRepo(r.cloneUrl, r.defaultBranch, dir);
@@ -24387,9 +24602,9 @@ function makeK8sFetchImpl(transport) {
     req.end();
   }));
 }
-async function listResource(transport, namespace, path79, opts = {}) {
+async function listResource(transport, namespace, path80, opts = {}) {
   const base = opts.apiUrl ?? transport.server;
-  const url = `${base.replace(/\/$/, "")}${path79}`;
+  const url = `${base.replace(/\/$/, "")}${path80}`;
   const fetchImpl = opts.fetchImpl ?? makeK8sFetchImpl(transport);
   const res = await junctionFetch(
     url,
@@ -24399,7 +24614,7 @@ async function listResource(transport, namespace, path79, opts = {}) {
     { provider: "kubernetes", accountKey: `${safeHost(transport.server)}/${namespace}`, fetchImpl }
   );
   if (!res.ok) {
-    throw new Error(`kubernetes ${path79} failed: ${res.status} ${res.statusText}`);
+    throw new Error(`kubernetes ${path80} failed: ${res.status} ${res.statusText}`);
   }
   const json = await res.json();
   return Array.isArray(json.items) ? json.items : [];
@@ -24420,14 +24635,14 @@ async function fetchPods(transport, namespace, opts = {}) {
 
 // src/connectors/kubernetes/kubeconfig.ts
 init_cjs_shims();
-var import_node_fs39 = require("fs");
+var import_node_fs40 = require("fs");
 var import_yaml4 = require("yaml");
 function pemFrom(dataField, pathField) {
   if (typeof dataField === "string" && dataField.length > 0) {
     return Buffer.from(dataField, "base64").toString("utf8");
   }
   if (typeof pathField === "string" && pathField.length > 0) {
-    return (0, import_node_fs39.readFileSync)(pathField, "utf8");
+    return (0, import_node_fs40.readFileSync)(pathField, "utf8");
   }
   return void 0;
 }
@@ -24438,7 +24653,7 @@ function named(list, name) {
 }
 function parseKubeconfig(kubeconfig) {
   const looksInline = /\n/.test(kubeconfig) || /(^|\s)clusters\s*:/.test(kubeconfig);
-  const text = looksInline ? kubeconfig : (0, import_node_fs39.readFileSync)(kubeconfig, "utf8");
+  const text = looksInline ? kubeconfig : (0, import_node_fs40.readFileSync)(kubeconfig, "utf8");
   let doc;
   try {
     doc = (0, import_yaml4.parse)(text);
@@ -24703,14 +24918,14 @@ function createK8sResolveTarget(graph) {
 init_cjs_shims();
 var import_promises3 = require("fs/promises");
 var import_node_os6 = __toESM(require("os"), 1);
-var import_node_path77 = __toESM(require("path"), 1);
+var import_node_path78 = __toESM(require("path"), 1);
 function defaultHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path77.default.resolve(override);
-  return import_node_path77.default.join(import_node_os6.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path78.default.resolve(override);
+  return import_node_path78.default.join(import_node_os6.default.homedir(), ".neat");
 }
 function k8sSubstrateConfigPath(home = defaultHome()) {
-  return import_node_path77.default.join(home, "k8s.json");
+  return import_node_path78.default.join(home, "k8s.json");
 }
 async function readK8sSubstrateConfig(home = defaultHome()) {
   let raw;
@@ -24809,8 +25024,8 @@ init_auth();
 
 // src/unrouted.ts
 init_cjs_shims();
-var import_node_fs40 = require("fs");
-var import_node_path78 = __toESM(require("path"), 1);
+var import_node_fs41 = require("fs");
+var import_node_path79 = __toESM(require("path"), 1);
 function buildUnroutedSpanRecord(serviceName, traceId, now = /* @__PURE__ */ new Date()) {
   return {
     timestamp: now.toISOString(),
@@ -24820,34 +25035,34 @@ function buildUnroutedSpanRecord(serviceName, traceId, now = /* @__PURE__ */ new
   };
 }
 async function appendUnroutedSpan(neatHome3, record) {
-  const target = import_node_path78.default.join(neatHome3, "errors.ndjson");
-  await import_node_fs40.promises.mkdir(neatHome3, { recursive: true });
-  await import_node_fs40.promises.appendFile(target, JSON.stringify(record) + "\n", "utf8");
+  const target = import_node_path79.default.join(neatHome3, "errors.ndjson");
+  await import_node_fs41.promises.mkdir(neatHome3, { recursive: true });
+  await import_node_fs41.promises.appendFile(target, JSON.stringify(record) + "\n", "utf8");
 }
 function unroutedErrorsPath(neatHome3) {
-  return import_node_path78.default.join(neatHome3, "errors.ndjson");
+  return import_node_path79.default.join(neatHome3, "errors.ndjson");
 }
 
 // src/daemon.ts
 var import_types107 = require("@neat.is/types");
 function daemonJsonPath(scanPath) {
-  return import_node_path79.default.join(scanPath, "neat-out", "daemon.json");
+  return import_node_path80.default.join(scanPath, "neat-out", "daemon.json");
 }
 function daemonsDiscoveryDir(home) {
   const base = home && home.length > 0 ? home : neatHomeFromEnv();
-  return import_node_path79.default.join(base, "daemons");
+  return import_node_path80.default.join(base, "daemons");
 }
 function daemonDiscoveryPath(project, home) {
-  return import_node_path79.default.join(daemonsDiscoveryDir(home), `${sanitizeDiscoveryName(project)}.json`);
+  return import_node_path80.default.join(daemonsDiscoveryDir(home), `${sanitizeDiscoveryName(project)}.json`);
 }
 function sanitizeDiscoveryName(project) {
   return project.replace(/[^A-Za-z0-9._-]/g, "_");
 }
 function neatHomeFromEnv() {
   const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return import_node_path79.default.resolve(env);
+  if (env && env.length > 0) return import_node_path80.default.resolve(env);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return import_node_path79.default.join(home, ".neat");
+  return import_node_path80.default.join(home, ".neat");
 }
 function resolveNeatVersion() {
   if (process.env.NEAT_LOCAL_VERSION && process.env.NEAT_LOCAL_VERSION.length > 0) {
@@ -24879,7 +25094,7 @@ async function clearDaemonRecord(record, home) {
   } catch {
   }
   try {
-    await import_node_fs41.promises.unlink(daemonDiscoveryPath(record.project, home));
+    await import_node_fs42.promises.unlink(daemonDiscoveryPath(record.project, home));
   } catch {
   }
 }
@@ -24914,11 +25129,11 @@ function teardownSlot(slot) {
   }
 }
 function neatHomeFor(opts) {
-  if (opts.neatHome && opts.neatHome.length > 0) return import_node_path79.default.resolve(opts.neatHome);
+  if (opts.neatHome && opts.neatHome.length > 0) return import_node_path80.default.resolve(opts.neatHome);
   const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return import_node_path79.default.resolve(env);
+  if (env && env.length > 0) return import_node_path80.default.resolve(env);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return import_node_path79.default.join(home, ".neat");
+  return import_node_path80.default.join(home, ".neat");
 }
 function routeSpanToProject(serviceName, projects) {
   if (!serviceName) return DEFAULT_PROJECT;
@@ -24970,9 +25185,9 @@ function spanBelongsToSingleProject(graph, project, serviceName) {
   );
 }
 async function bootstrapProject(entry, connectors = [], neatHome3) {
-  const paths = pathsForProject(entry.name, import_node_path79.default.join(entry.path, "neat-out"));
+  const paths = pathsForProject(entry.name, import_node_path80.default.join(entry.path, "neat-out"));
   try {
-    const stat = await import_node_fs41.promises.stat(entry.path);
+    const stat = await import_node_fs42.promises.stat(entry.path);
     if (!stat.isDirectory()) {
       throw new Error(`registered path ${entry.path} is not a directory`);
     }
@@ -25124,7 +25339,7 @@ async function startDaemon(opts = {}) {
   const projectArg = typeof opts.project === "string" && opts.project.length > 0 ? opts.project : process.env.NEAT_PROJECT && process.env.NEAT_PROJECT.length > 0 ? process.env.NEAT_PROJECT : null;
   const projectPathArg = opts.projectPath && opts.projectPath.length > 0 ? opts.projectPath : process.env.NEAT_PROJECT_PATH && process.env.NEAT_PROJECT_PATH.length > 0 ? process.env.NEAT_PROJECT_PATH : null;
   const singleProject = projectArg;
-  const singleProjectPath = singleProject && projectPathArg ? import_node_path79.default.resolve(projectPathArg) : null;
+  const singleProjectPath = singleProject && projectPathArg ? import_node_path80.default.resolve(projectPathArg) : null;
   if (singleProject && !singleProjectPath) {
     throw new Error(
       `neatd: project "${singleProject}" given without a projectPath; pass NEAT_PROJECT_PATH alongside NEAT_PROJECT.`
@@ -25132,14 +25347,14 @@ async function startDaemon(opts = {}) {
   }
   if (!singleProject) {
     try {
-      await import_node_fs41.promises.access(regPath);
+      await import_node_fs42.promises.access(regPath);
     } catch {
       throw new Error(
         `neatd: registry not found at ${regPath}. Run \`neat init <path>\` to register a project before starting the daemon.`
       );
     }
   }
-  const pidPath = import_node_path79.default.join(home, "neatd.pid");
+  const pidPath = import_node_path80.default.join(home, "neatd.pid");
   await writeAtomically(pidPath, `${process.pid}
 `);
   const slots = /* @__PURE__ */ new Map();
@@ -25351,7 +25566,7 @@ async function startDaemon(opts = {}) {
       }
       if (restApp) await restApp.close().catch(() => {
       });
-      await import_node_fs41.promises.unlink(pidPath).catch(() => {
+      await import_node_fs42.promises.unlink(pidPath).catch(() => {
       });
       throw new Error(
         `neatd: failed to bind REST on port ${restPort} \u2014 ${err.message}`
@@ -25529,7 +25744,7 @@ async function startDaemon(opts = {}) {
       });
       if (otlpApp) await otlpApp.close().catch(() => {
       });
-      await import_node_fs41.promises.unlink(pidPath).catch(() => {
+      await import_node_fs42.promises.unlink(pidPath).catch(() => {
       });
       throw new Error(
         `neatd: failed to bind OTLP on port ${otlpPort} \u2014 ${err.message}`
@@ -25564,7 +25779,7 @@ async function startDaemon(opts = {}) {
         });
         if (otlpApp) await otlpApp.close().catch(() => {
         });
-        await import_node_fs41.promises.unlink(pidPath).catch(() => {
+        await import_node_fs42.promises.unlink(pidPath).catch(() => {
         });
         throw new Error(
           `neatd: failed to write daemon.json for "${singleProject}" \u2014 ${err.message}`
@@ -25611,9 +25826,9 @@ async function startDaemon(opts = {}) {
   let registryWatcher = null;
   let reloadTimer = null;
   if (!singleProject) try {
-    const regDir = import_node_path79.default.dirname(regPath);
-    const regBase = import_node_path79.default.basename(regPath);
-    registryWatcher = (0, import_node_fs41.watch)(regDir, (_eventType, filename) => {
+    const regDir = import_node_path80.default.dirname(regPath);
+    const regBase = import_node_path80.default.basename(regPath);
+    registryWatcher = (0, import_node_fs42.watch)(regDir, (_eventType, filename) => {
       if (filename !== null && filename !== regBase) return;
       if (reloadTimer) clearTimeout(reloadTimer);
       reloadTimer = setTimeout(() => {
@@ -25662,7 +25877,7 @@ async function startDaemon(opts = {}) {
     if (daemonRecord) {
       await clearDaemonRecord(daemonRecord, home);
     }
-    await import_node_fs41.promises.unlink(pidPath).catch(() => {
+    await import_node_fs42.promises.unlink(pidPath).catch(() => {
     });
   };
   return {