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

package/dist/neatd.cjs

@@ -61,8 +61,8 @@ function mountBearerAuth(app, opts) {
   ]);
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req2, reply, done) => {
-    const path81 = (req2.url.split("?")[0] ?? "").replace(/\/+$/, "");
-    if (exactUnauthPaths.has(path81) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path81)) {
+    const path82 = (req2.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    if (exactUnauthPaths.has(path82) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path82)) {
       done();
       return;
     }
@@ -194,8 +194,8 @@ function reshapeGrpcRequest(req2) {
   };
 }
 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();
@@ -263,13 +263,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);
@@ -415,8 +415,8 @@ function websocketChannelPathOf(attrs) {
     const v = attrs[key];
     if (typeof v === "string" && v.length > 0) {
       const q = v.indexOf("?");
-      const path81 = q === -1 ? v : v.slice(0, q);
-      if (path81.length > 0) return path81;
+      const path82 = q === -1 ? v : v.slice(0, q);
+      if (path82.length > 0) return path82;
     }
   }
   return void 0;
@@ -478,10 +478,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 }
@@ -759,12 +759,12 @@ async function listenSteppingOtlp(app, requestedPort, host) {
     }
   }
 }
-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);
@@ -788,14 +788,14 @@ __export(neatd_exports, {
 });
 module.exports = __toCommonJS(neatd_exports);
 init_cjs_shims();
-var import_node_fs43 = require("fs");
-var import_node_path81 = __toESM(require("path"), 1);
+var import_node_fs44 = require("fs");
+var import_node_path82 = __toESM(require("path"), 1);
 var import_node_module2 = require("module");
 
 // 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");
 
 // src/graph.ts
@@ -831,8 +831,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
@@ -1337,19 +1337,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, path81, edges) {
-    if (path81.length > best.path.length) {
-      best = { path: [...path81], edges: [...edges] };
+  function step(node, path82, edges) {
+    if (path82.length > best.path.length) {
+      best = { path: [...path82], edges: [...edges] };
     }
-    if (path81.length - 1 >= maxDepth) return;
+    if (path82.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);
-      path81.push(srcId);
+      path82.push(srcId);
       edges.push(edge);
-      step(srcId, path81, edges);
-      path81.pop();
+      step(srcId, path82, edges);
+      path82.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -1564,20 +1564,20 @@ function dominantFailingCall(graph, serviceId17, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path81 = [originServiceId];
+  const path82 = [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;
-    path81.push(hop.nextService);
+    path82.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path81, edges, culprit: current };
+  return { path: path82, edges, culprit: current };
 }
 function isStaleCallEdge(e) {
   return e.type === import_types.EdgeType.CALLS && e.provenance === import_types.Provenance.STALE;
@@ -1613,26 +1613,26 @@ function dominantStaleCall(graph, serviceId17, visited) {
   return best;
 }
 function followStaleCallChain(graph, originServiceId, maxDepth) {
-  const path81 = [originServiceId];
+  const path82 = [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;
-    path81.push(hop.nextService);
+    path82.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path81, edges, culprit: current };
+  return { path: path82, 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 path81 = [...chain.path];
+  const path82 = [...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));
@@ -1640,14 +1640,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path81.push(loc.fileNode);
+      path82.push(loc.fileNode);
       edgeProvenances.push(import_types.Provenance.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return import_types.RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path81,
+      traversalPath: path82,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -1659,7 +1659,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: path81,
+    traversalPath: path82,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -2312,10 +2312,10 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
     traversalPath = staleChain.path;
     edgeProvenances = staleChain.edges.map((e) => e.provenance);
   } else if (top.node !== seedNode) {
-    const path81 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
-    if (path81) {
-      traversalPath = path81.nodes;
-      edgeProvenances = path81.edges.map((e) => e.provenance);
+    const path82 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path82) {
+      traversalPath = path82.nodes;
+      edgeProvenances = path82.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
       edgeProvenances = [top.provenance ?? import_types.Provenance.OBSERVED];
@@ -2854,7 +2854,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);
@@ -2880,6 +2880,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
@@ -3111,6 +3122,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";
@@ -3124,14 +3144,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);
@@ -3140,33 +3237,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 entry2 of entries) {
-      const full = import_node_path5.default.join(current, entry2.name);
+      const full = import_node_path6.default.join(current, entry2.name);
       if (entry2.isDirectory()) {
         if (IGNORED_DIRS.has(entry2.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 (entry2.isFile() && SERVICE_FILE_EXTENSIONS.has(import_node_path5.default.extname(entry2.name)) && // Skip NEAT's own generated `otel-init.*` bootstrap — extracting it
+        await walk11(full, verdict.subtree);
+      } else if (entry2.isFile() && SERVICE_FILE_EXTENSIONS.has(import_node_path6.default.extname(entry2.name)) && // Skip NEAT's own generated `otel-init.*` bootstrap — extracting it
       // would attribute our instrumentation imports to the user's service.
-      !isNeatAuthoredSourceFile(entry2.name)) {
+      !isNeatAuthoredSourceFile(entry2.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 {
     }
@@ -3178,15 +3304,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":
@@ -3260,8 +3389,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);
@@ -3406,15 +3535,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}`);
@@ -3422,22 +3551,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;
   }
@@ -3446,7 +3575,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;
@@ -3464,11 +3593,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));
       }
     }
   }
@@ -3477,18 +3606,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);
@@ -3503,30 +3632,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;
       }
     }
@@ -3536,11 +3665,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((entry2) => entry2.isFile() && entry2.name.endsWith(".go") && !entry2.name.endsWith("_test.go")).map((entry2) => import_node_path6.default.join(dir, entry2.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((entry2) => entry2.isFile() && entry2.name.endsWith(".go") && !entry2.name.endsWith("_test.go")).map((entry2) => import_node_path7.default.join(dir, entry2.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);
@@ -3570,12 +3699,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 {
@@ -3585,7 +3714,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) {
@@ -3629,7 +3758,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,
@@ -3754,8 +3883,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path81) {
-  return path81.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path82) {
+  return path82.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -4095,7 +4224,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;
@@ -4427,9 +4556,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path81 = rubyLiteral(k);
-    if (path81 === null) continue;
-    return { path: path81, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path82 = rubyLiteral(k);
+    if (path82 === null) continue;
+    return { path: path82, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -5277,12 +5406,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 {
     }
   }
@@ -5381,14 +5510,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) {
@@ -5896,7 +6025,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);
   }
@@ -5924,10 +6053,10 @@ function resolveDistToSrc(absFilepath, line) {
     entry2 = 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);
-        entry2 = { consumer, dir: import_node_path8.default.dirname(mapPath) };
+        entry2 = { consumer, dir: import_node_path9.default.dirname(mapPath) };
       }
     } catch {
       entry2 = null;
@@ -5947,7 +6076,7 @@ function resolveDistToSrc(absFilepath, line) {
     }
     if (!pos || !pos.source) return null;
     const root = entry2.consumer.sourceRoot ?? "";
-    const resolved = import_node_path8.default.resolve(entry2.dir, root, pos.source);
+    const resolved = import_node_path9.default.resolve(entry2.dir, root, pos.source);
     return { filepath: resolved, ...pos.line ? { line: pos.line } : {} };
   } catch {
     return null;
@@ -6491,8 +6620,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) {
@@ -6507,8 +6636,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) {
@@ -6630,8 +6759,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);
   };
 }
@@ -7131,13 +7260,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 [];
@@ -7173,7 +7302,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) {
@@ -7298,16 +7427,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) {
@@ -7340,25 +7469,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 };
@@ -7373,8 +7502,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];
@@ -7401,7 +7530,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;
   }
@@ -7416,7 +7545,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 };
@@ -7424,8 +7553,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 = {};
@@ -7442,12 +7571,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),
@@ -7455,7 +7584,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 };
@@ -7463,7 +7592,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 {
@@ -7476,12 +7605,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),
@@ -7489,7 +7618,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 };
@@ -7497,23 +7626,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 entry2 of entries) {
     if (!entry2.isFile()) continue;
-    if (CSHARP_PROJECT_EXTS.has(import_node_path13.default.extname(entry2.name).toLowerCase())) out.push(entry2.name);
+    if (CSHARP_PROJECT_EXTS.has(import_node_path14.default.extname(entry2.name).toLowerCase())) out.push(entry2.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;
 }
@@ -7538,10 +7667,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 };
@@ -7553,20 +7682,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;
 }
@@ -7601,19 +7730,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 = {
@@ -7622,15 +7751,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";
@@ -7640,15 +7769,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 entry2 of entries) {
       if (entry2.isDirectory()) {
         if (IGNORED_DIRS.has(entry2.name)) continue;
-        await recurse(import_node_path15.default.join(current, entry2.name), depth + 1);
+        await recurse(import_node_path16.default.join(current, entry2.name), depth + 1);
         continue;
       }
       if (!entry2.isFile()) continue;
-      const ext = import_node_path15.default.extname(entry2.name).toLowerCase();
+      const ext = import_node_path16.default.extname(entry2.name).toLowerCase();
       if (ext === KOTLIN_SOURCE_EXT) kt++;
       else if (ext === JAVA_SOURCE_EXT) java++;
     }
@@ -7659,17 +7788,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;
 }
@@ -7678,7 +7807,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 = {
@@ -7687,20 +7816,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 = {};
@@ -7725,10 +7854,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 = {
@@ -7737,19 +7866,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, "");
@@ -7757,10 +7886,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 = {
@@ -7769,15 +7898,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) {
@@ -7819,12 +7948,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 entry2 of entries) {
     if (!entry2.isFile()) continue;
     if (isNeatAuthoredSourceFile(entry2.name)) continue;
-    const ext = import_node_path18.default.extname(entry2.name).toLowerCase();
+    const ext = import_node_path19.default.extname(entry2.name).toLowerCase();
     if (!SERVICE_FILE_EXTENSIONS.has(ext)) continue;
     const lang = languageForSourceExt(ext);
     if (!lang) continue;
@@ -7843,7 +7972,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
@@ -7853,15 +7982,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),
@@ -7869,24 +7998,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);
     }
   }
@@ -7904,7 +8033,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;
   }
@@ -7920,7 +8049,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);
@@ -7957,36 +8086,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 entry2 of entries) {
       if (!entry2.isDirectory()) continue;
       if (IGNORED_DIRS.has(entry2.name)) continue;
-      const child = import_node_path20.default.join(current, entry2.name);
+      const child = import_node_path21.default.join(current, entry2.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;
@@ -8002,8 +8131,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("/");
@@ -8012,13 +8141,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);
       }
     });
@@ -8041,18 +8170,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;
@@ -8065,7 +8194,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 } : {}
   };
@@ -8082,12 +8211,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 {
@@ -8095,7 +8224,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
       );
     }
@@ -8116,7 +8245,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);
@@ -8144,8 +8273,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}`
       );
@@ -8159,14 +8288,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;
   }
@@ -8193,8 +8322,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([
@@ -8221,14 +8350,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;
@@ -8241,7 +8370,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;
@@ -8284,11 +8413,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;
@@ -8300,15 +8429,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 entry2 of entries) {
     if (entry2.isDirectory()) {
       if (IGNORED_DIRS.has(entry2.name)) continue;
-      const child = import_node_path21.default.join(start, entry2.name);
+      const child = import_node_path22.default.join(start, entry2.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles(child, depth + 1, max));
-    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path21.default.extname(entry2.name))) {
-      out.push(import_node_path21.default.join(start, entry2.name));
+    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path22.default.extname(entry2.name))) {
+      out.push(import_node_path22.default.join(start, entry2.name));
     }
   }
   return out;
@@ -8335,7 +8464,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());
@@ -8360,14 +8489,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,
@@ -8383,7 +8512,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);
@@ -9135,10 +9264,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);
@@ -9198,7 +9327,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) {
@@ -9305,10 +9434,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;
@@ -9443,7 +9572,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) {
@@ -9590,9 +9719,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;
@@ -9653,10 +9782,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;
@@ -9709,14 +9838,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 [
@@ -9734,13 +9863,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) {
@@ -9779,18 +9908,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();
@@ -9809,7 +9938,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;
   }
@@ -9867,15 +9996,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 entry2 of entries) {
     if (!entry2.isFile()) continue;
     const match = isConfigFile(entry2.name);
     if (!match.match || match.fileType !== "env") continue;
-    const filePath = import_node_path28.default.join(serviceDir, entry2.name);
-    const content = await import_node_fs21.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path29.default.join(serviceDir, entry2.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;
@@ -9894,9 +10023,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);
@@ -10054,10 +10183,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];
@@ -10117,9 +10246,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 = [];
@@ -10146,8 +10275,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/;
@@ -10194,12 +10323,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;
   }
@@ -10254,12 +10383,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;
@@ -10300,7 +10429,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);
@@ -10327,7 +10456,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 [];
@@ -10500,7 +10629,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,
@@ -10509,7 +10638,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,
@@ -10530,15 +10659,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++;
@@ -10579,19 +10708,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 entry2 of entries) {
-      const full = import_node_path35.default.join(current, entry2.name);
+      const full = import_node_path36.default.join(current, entry2.name);
       if (entry2.isDirectory()) {
         if (IGNORED_DIRS.has(entry2.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 (entry2.isFile() && isConfigFile(entry2.name).match) {
@@ -10608,19 +10737,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,
@@ -10636,7 +10765,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);
@@ -10649,8 +10778,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) {
@@ -10688,18 +10817,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 entry2 of entries) {
-      const full = import_node_path36.default.join(current, entry2.name);
+      const full = import_node_path37.default.join(current, entry2.name);
       if (entry2.isDirectory()) {
         if (IGNORED_DIRS.has(entry2.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 (entry2.isFile() && import_node_path36.default.extname(entry2.name) === PROTO_EXTENSION) {
+      } else if (entry2.isFile() && import_node_path37.default.extname(entry2.name) === PROTO_EXTENSION) {
         out.push(full);
       }
     }
@@ -10714,10 +10843,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;
@@ -10776,7 +10905,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);
@@ -10859,7 +10988,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);
@@ -10868,7 +10997,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;
@@ -10922,7 +11051,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");
@@ -11200,7 +11329,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);
@@ -11209,7 +11338,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`;
@@ -11302,7 +11431,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;
@@ -11390,13 +11519,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");
@@ -11407,7 +11536,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) {
@@ -11430,7 +11559,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)
       }
@@ -11441,7 +11570,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;
@@ -11475,7 +11604,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)
       }
@@ -11500,7 +11629,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;
@@ -11559,7 +11688,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)
       }
@@ -11570,7 +11699,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['"`]/;
@@ -11629,7 +11758,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)
       }
@@ -11656,7 +11785,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)
         }
@@ -11668,7 +11797,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");
@@ -11841,7 +11970,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();
@@ -11946,7 +12075,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)
       }
@@ -12006,7 +12135,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;
@@ -12022,7 +12151,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 = [];
@@ -12035,7 +12164,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 entry2 = registry.get(rel);
       if (!entry2 || !entry2.names.has(b.imported)) continue;
@@ -12050,7 +12179,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['"`]/;
@@ -12201,7 +12330,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) {
@@ -12291,7 +12420,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 = [];
@@ -12302,7 +12431,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;
@@ -12346,7 +12475,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");
@@ -12485,7 +12614,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)
         }
@@ -12510,7 +12639,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)
       }
@@ -12617,7 +12746,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)
         }
@@ -12629,7 +12758,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");
@@ -12705,7 +12834,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)
       }
@@ -12716,7 +12845,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");
@@ -12786,7 +12915,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;
@@ -12804,7 +12933,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;
@@ -12812,7 +12941,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");
@@ -12890,7 +13019,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) => {
@@ -12913,7 +13042,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)
             }
@@ -12979,7 +13108,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();
@@ -12998,7 +13127,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)
               }
@@ -13015,7 +13144,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",
@@ -13071,7 +13200,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)
       }
@@ -13132,7 +13261,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 [];
@@ -13207,7 +13336,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)
               }
@@ -13222,7 +13351,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 [];
@@ -13233,7 +13362,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");
@@ -13441,7 +13570,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)
       }
@@ -13463,7 +13592,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)
       }
@@ -13546,7 +13675,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)
       }
@@ -13583,7 +13712,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)
         }
@@ -13595,7 +13724,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");
@@ -13852,7 +13981,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)
       }
@@ -13874,7 +14003,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)
       }
@@ -13994,7 +14123,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)
       }
@@ -14030,7 +14159,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)
         }
@@ -14042,7 +14171,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");
@@ -14117,7 +14246,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]));
@@ -14146,7 +14275,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)
       }
@@ -14157,7 +14286,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");
@@ -14590,7 +14719,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);
@@ -14612,7 +14741,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)
       }
@@ -14621,7 +14750,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);
@@ -14636,7 +14765,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)
       }
@@ -14673,7 +14802,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");
@@ -14752,7 +14881,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 = [];
@@ -14767,7 +14896,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)
       }
@@ -15022,7 +15151,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
@@ -15093,7 +15222,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;
 }
@@ -15102,7 +15231,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;
@@ -15115,13 +15244,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);
@@ -15163,8 +15292,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;
@@ -15194,15 +15323,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;
@@ -15214,8 +15343,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,
@@ -15267,23 +15396,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 entry2 of entries) {
     if (entry2.isDirectory()) {
       if (IGNORED_DIRS.has(entry2.name) || entry2.name === ".terraform") continue;
-      const child = import_node_path60.default.join(start, entry2.name);
+      const child = import_node_path61.default.join(start, entry2.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkTfFiles(child, depth + 1, max));
     } else if (entry2.isFile() && entry2.name.endsWith(".tf")) {
-      out.push(import_node_path60.default.join(start, entry2.name));
+      out.push(import_node_path61.default.join(start, entry2.name));
     }
   }
   return out;
@@ -15314,8 +15443,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;
@@ -15372,8 +15501,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 = {
@@ -15389,15 +15518,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 entry2 of entries) {
     if (entry2.isDirectory()) {
       if (IGNORED_DIRS.has(entry2.name)) continue;
-      const child = import_node_path61.default.join(start, entry2.name);
+      const child = import_node_path62.default.join(start, entry2.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles2(child, depth + 1, max));
-    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path61.default.extname(entry2.name))) {
-      out.push(import_node_path61.default.join(start, entry2.name));
+    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path62.default.extname(entry2.name))) {
+      out.push(import_node_path62.default.join(start, entry2.name));
     }
   }
   return out;
@@ -15407,14 +15536,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];
@@ -15463,16 +15592,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 };
   }
@@ -15533,11 +15662,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) {
@@ -15549,7 +15678,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,
@@ -15696,24 +15825,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) {
@@ -15729,7 +15858,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;
@@ -15745,7 +15874,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(
@@ -15774,16 +15903,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 };
   }
@@ -15797,7 +15926,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;
@@ -15807,7 +15936,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(
@@ -15832,15 +15961,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 };
 }
@@ -15852,7 +15981,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;
@@ -15867,7 +15996,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(
@@ -15909,7 +16038,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");
@@ -16004,7 +16133,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)) {
@@ -16022,7 +16151,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)
       }
@@ -16290,12 +16419,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 = [];
@@ -16316,11 +16445,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);
@@ -16332,6 +16461,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);
@@ -16376,8 +16506,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) {
@@ -16394,7 +16525,9 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
     errorEntries,
     ghostsRetired,
     extractedDropped: droppedEntries.length,
-    droppedEntries
+    droppedEntries,
+    skippedFiles: skippedEntries.length,
+    skippedEntries
   };
   emitNeatEvent({
     type: "extraction-complete",
@@ -16411,8 +16544,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) {
@@ -16467,7 +16600,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);
@@ -16477,13 +16646,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;
@@ -16557,23 +16739,23 @@ function startPersistLoop(graph, outPath, opts = {}) {
 
 // src/projects.ts
 init_cjs_shims();
-var import_node_path70 = __toESM(require("path"), 1);
+var import_node_path71 = __toESM(require("path"), 1);
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: import_node_path70.default.join(baseDir, "graph.json"),
-      errorsPath: import_node_path70.default.join(baseDir, "errors.ndjson"),
-      staleEventsPath: import_node_path70.default.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: import_node_path70.default.join(baseDir, "embeddings.json"),
-      policyViolationsPath: import_node_path70.default.join(baseDir, "policy-violations.ndjson")
+      snapshotPath: import_node_path71.default.join(baseDir, "graph.json"),
+      errorsPath: import_node_path71.default.join(baseDir, "errors.ndjson"),
+      staleEventsPath: import_node_path71.default.join(baseDir, "stale-events.ndjson"),
+      embeddingsCachePath: import_node_path71.default.join(baseDir, "embeddings.json"),
+      policyViolationsPath: import_node_path71.default.join(baseDir, "policy-violations.ndjson")
     };
   }
   return {
-    snapshotPath: import_node_path70.default.join(baseDir, `${project}.json`),
-    errorsPath: import_node_path70.default.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: import_node_path70.default.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: import_node_path70.default.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: import_node_path70.default.join(baseDir, `policy-violations.${project}.ndjson`)
+    snapshotPath: import_node_path71.default.join(baseDir, `${project}.json`),
+    errorsPath: import_node_path71.default.join(baseDir, `errors.${project}.ndjson`),
+    staleEventsPath: import_node_path71.default.join(baseDir, `stale-events.${project}.ndjson`),
+    embeddingsCachePath: import_node_path71.default.join(baseDir, `embeddings.${project}.json`),
+    policyViolationsPath: import_node_path71.default.join(baseDir, `policy-violations.${project}.ndjson`)
   };
 }
 var Projects = class {
@@ -16615,15 +16797,15 @@ var import_types101 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
-var import_node_fs35 = require("fs");
-var import_node_path72 = __toESM(require("path"), 1);
+var import_node_fs36 = require("fs");
+var import_node_path73 = __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_path71 = __toESM(require("path"), 1);
+var import_node_fs35 = require("fs");
+var import_node_path72 = __toESM(require("path"), 1);
 var import_node_child_process = require("child_process");
 var LOCKFILE_PRIORITY = [
   { lockfile: "bun.lockb", pm: "bun", args: ["install", "--no-summary"] },
@@ -16638,29 +16820,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_path71.default.resolve(serviceDir);
+  let dir = import_node_path72.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_path71.default.join(dir, candidate.lockfile);
+      const lockPath = import_node_path72.default.join(dir, candidate.lockfile);
       if (await exists2(lockPath)) {
         return { pm: candidate.pm, cwd: dir, args: [...candidate.args] };
       }
     }
-    const parent = import_node_path71.default.dirname(dir);
+    const parent = import_node_path72.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return { pm: "npm", cwd: import_node_path71.default.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
+  return { pm: "npm", cwd: import_node_path72.default.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
 }
 async function runPackageManagerInstall(cmd) {
   return new Promise((resolve) => {
@@ -16702,15 +16884,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_path72.default.join(scanPath, "package.json");
-  const raw = await import_node_fs35.promises.readFile(pkgPath, "utf8");
+  const pkgPath = import_node_path73.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([
@@ -16724,15 +16906,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 entry2 of entries) {
       if (entry2.isDirectory()) {
         if (entry2.name.startsWith(".") || HOOK_WALK_SKIP_DIRS.has(entry2.name)) continue;
-        await walk11(import_node_path72.default.join(dir, entry2.name));
+        await walk11(import_node_path73.default.join(dir, entry2.name));
       } else if (entry2.isFile()) {
         if ((entry2.name.startsWith("instrumentation") || entry2.name.startsWith("otel-init")) && /\.(ts|js|cjs|mjs)$/.test(entry2.name)) {
-          const rel = import_node_path72.default.relative(scanPath, import_node_path72.default.join(dir, entry2.name));
-          found.push(rel.split(import_node_path72.default.sep).join("/"));
+          const rel = import_node_path73.default.relative(scanPath, import_node_path73.default.join(dir, entry2.name));
+          found.push(rel.split(import_node_path73.default.sep).join("/"));
         }
       }
     }
@@ -16743,7 +16925,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_path72.default.join(scanPath, file), "utf8");
+    const content = await import_node_fs36.promises.readFile(import_node_path73.default.join(scanPath, file), "utf8");
     const patched = splicedContent(content, snippet2);
     if (patched !== null) return { file, content, patched };
     if (fallback === null) fallback = { file, content };
@@ -16751,12 +16933,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_path72.default.join(import_node_os2.default.homedir(), ".neat", "extend-log.ndjson");
+  return process.env.NEAT_EXTEND_LOG ?? import_node_path73.default.join(import_node_os2.default.homedir(), ".neat", "extend-log.ndjson");
 }
 async function appendExtendLog(entry2) {
   const logPath = extendLogPath();
-  await import_node_fs35.promises.mkdir(import_node_path72.default.dirname(logPath), { recursive: true });
-  await import_node_fs35.promises.appendFile(logPath, JSON.stringify(entry2) + "\n", "utf8");
+  await import_node_fs36.promises.mkdir(import_node_path73.default.dirname(logPath), { recursive: true });
+  await import_node_fs36.promises.appendFile(logPath, JSON.stringify(entry2) + "\n", "utf8");
 }
 function splicedContent(fileContent, snippet2) {
   if (fileContent.includes("__INSTRUMENTATION_BLOCK__")) {
@@ -16814,7 +16996,7 @@ function lookupInstrumentation(library, installedVersion) {
 }
 async function describeProjectInstrumentation(ctx) {
   const hookFiles = await findHookFiles(ctx.scanPath);
-  const envNeat = await fileExists2(import_node_path72.default.join(ctx.scanPath, ".env.neat"));
+  const envNeat = await fileExists2(import_node_path73.default.join(ctx.scanPath, ".env.neat"));
   const registryInstrPackages = new Set(
     (0, import_instrumentation_registry.list)().map((e) => e.instrumentation_package).filter((p) => !!p)
   );
@@ -16836,7 +17018,7 @@ async function applyExtension(ctx, args, options) {
     );
   }
   for (const file of hookFiles) {
-    const content = await import_node_fs35.promises.readFile(import_node_path72.default.join(ctx.scanPath, file), "utf8");
+    const content = await import_node_fs36.promises.readFile(import_node_path73.default.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return { library: args.library, filesTouched: [], depsAdded: [], installOutput: "", alreadyApplied: true };
     }
@@ -16848,18 +17030,18 @@ async function applyExtension(ctx, args, options) {
     );
   }
   const primaryFile = primary.file;
-  const primaryPath = import_node_path72.default.join(ctx.scanPath, primaryFile);
+  const primaryPath = import_node_path73.default.join(ctx.scanPath, primaryFile);
   const filesTouched = [];
   const depsAdded = [];
-  const pkgPath = import_node_path72.default.join(ctx.scanPath, "package.json");
+  const pkgPath = import_node_path73.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;
@@ -16890,7 +17072,7 @@ async function dryRunExtension(ctx, args) {
     };
   }
   for (const file of hookFiles) {
-    const content = await import_node_fs35.promises.readFile(import_node_path72.default.join(ctx.scanPath, file), "utf8");
+    const content = await import_node_fs36.promises.readFile(import_node_path73.default.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return {
         library: args.library,
@@ -16925,28 +17107,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_path72.default.join(ctx.scanPath, "package.json");
+  const pkgPath = import_node_path73.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_path72.default.join(ctx.scanPath, file);
-    const content = await import_node_fs35.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path73.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;
     }
   }
@@ -18583,7 +18765,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);
@@ -18592,7 +18774,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) {
@@ -18660,28 +18842,28 @@ function canonicalJson(value) {
 
 // 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);
@@ -18714,7 +18896,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;
@@ -18722,10 +18904,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;
     }
@@ -18751,7 +18933,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 {
@@ -18795,28 +18977,28 @@ 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 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");
@@ -18830,18 +19012,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) {
@@ -18857,7 +19057,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: [] };
@@ -18871,6 +19071,18 @@ async function writeRegistry(reg) {
   const validated = import_types63.RegistryFileSchema.parse(reg);
   await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
 }
+var RegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryError";
+  }
+};
+var RegistryLockError = class extends RegistryError {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryLockError";
+  }
+};
 async function getProject(name) {
   const reg = await readRegistry();
   return reg.projects.find((p) => p.name === name);
@@ -18883,7 +19095,7 @@ async function setStatus(name, status2) {
   return withLock(async () => {
     const reg = await readRegistry();
     const entry2 = reg.projects.find((p) => p.name === name);
-    if (!entry2) throw new Error(`neat registry: no project named "${name}"`);
+    if (!entry2) throw new RegistryError(`no project named "${name}"`);
     entry2.status = status2;
     await writeRegistry(reg);
     return entry2;
@@ -18912,7 +19124,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";
@@ -19013,8 +19225,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;
@@ -19028,17 +19240,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(
@@ -19052,7 +19264,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: [] };
@@ -19848,10 +20060,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(path81) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path81);
+function targetFromRestPath(path82) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path82);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path81);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path82);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -20455,9 +20667,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path81 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path81) return null;
-  return { resourceName, method, path: path81 };
+  const path82 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path82) return null;
+  return { resourceName, method, path: path82 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -20495,14 +20707,14 @@ function mapLogEntryToSignal(entry2) {
   if (!req2) return null;
   if (typeof req2.requestMethod !== "string" || req2.requestMethod.length === 0) return null;
   const method = req2.requestMethod.toUpperCase();
-  const path81 = pathFromRequestUrl(req2.requestUrl);
-  if (path81 === null) return null;
+  const path82 = pathFromRequestUrl(req2.requestUrl);
+  if (path82 === null) return null;
   const timestamp = entry2.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req2.status === "number" && req2.status >= ERROR_STATUS_THRESHOLD2;
   return {
     targetKind: resourceType,
-    targetName: packFirebaseTargetName({ resourceName, method, path: path81 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path82 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -20527,9 +20739,9 @@ var import_types71 = require("@neat.is/types");
 function normalizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function inferServiceName(graph, resourceName, method, path81) {
+function inferServiceName(graph, resourceName, method, path82) {
   const wantedMethod = method.toUpperCase();
-  const wantedPath = normalizePathTemplate(path81);
+  const wantedPath = normalizePathTemplate(path82);
   const services = [];
   const owners = /* @__PURE__ */ new Set();
   graph.forEachNode((_id, attrs) => {
@@ -20746,7 +20958,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 path81 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path82 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -20754,7 +20966,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path81 ? { path: path81 } : {},
+    ...path82 ? { path: path82 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -20800,8 +21012,8 @@ function findTaggedWorkerFileNode(graph, workerName) {
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path81) {
-  const normalizedPath = normalizePathTemplate(path81);
+function findMatchingRouteNode(graph, serviceName, method, path82) {
+  const normalizedPath = normalizePathTemplate(path82);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
@@ -20818,10 +21030,10 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path81 } = signal;
+    const { method, path: path82 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path81) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path81) ?? wholeFileId;
+      if (!method || !path82) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path82) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
@@ -21173,9 +21385,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path81 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path81) return null;
-  return { serviceName, method, path: path81 };
+  const path82 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path82) return null;
+  return { serviceName, method, path: path82 };
 }
 
 // src/connectors/cloud-run/map.ts
@@ -21204,14 +21416,14 @@ function mapLogEntryToSignal2(entry2) {
   if (!req2) return null;
   if (typeof req2.requestMethod !== "string" || req2.requestMethod.length === 0) return null;
   const method = req2.requestMethod.toUpperCase();
-  const path81 = pathFromRequestUrl2(req2.requestUrl);
-  if (path81 === null) return null;
+  const path82 = pathFromRequestUrl2(req2.requestUrl);
+  if (path82 === null) return null;
   const timestamp = entry2.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req2.status === "number" && req2.status >= ERROR_STATUS_THRESHOLD4;
   return {
     targetKind: CLOUD_RUN_TARGET_KIND,
-    targetName: packCloudRunTargetName({ serviceName, method, path: path81 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path82 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -21250,14 +21462,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: path81 } = identity;
-    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path81) ?? void 0 : void 0);
+    const { serviceName: gcpServiceName, method, path: path82 } = identity;
+    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path82) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path81)
+        normalizePathTemplate(path82)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types82.EdgeType.CALLS };
@@ -21393,9 +21605,9 @@ function parseGcpLbTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP3);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path81 = rest.slice(secondSep + 1);
-  if (!backendServiceName || !method || !path81) return null;
-  return { backendServiceName, method, path: path81 };
+  const path82 = rest.slice(secondSep + 1);
+  if (!backendServiceName || !method || !path82) return null;
+  return { backendServiceName, method, path: path82 };
 }
 
 // src/connectors/gcp-lb/map.ts
@@ -21424,14 +21636,14 @@ function mapLogEntryToSignal3(entry2) {
   if (!req2) return null;
   if (typeof req2.requestMethod !== "string" || req2.requestMethod.length === 0) return null;
   const method = req2.requestMethod.toUpperCase();
-  const path81 = pathFromRequestUrl3(req2.requestUrl);
-  if (path81 === null) return null;
+  const path82 = pathFromRequestUrl3(req2.requestUrl);
+  if (path82 === null) return null;
   const timestamp = entry2.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req2.status === "number" && req2.status >= ERROR_STATUS_THRESHOLD5;
   return {
     targetKind: GCP_LB_TARGET_KIND,
-    targetName: packGcpLbTargetName({ backendServiceName, method, path: path81 }),
+    targetName: packGcpLbTargetName({ backendServiceName, method, path: path82 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -21470,14 +21682,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: path81 } = identity;
-    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path81) ?? void 0 : void 0);
+    const { backendServiceName, method, path: path82 } = identity;
+    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path82) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode3(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path81)
+        normalizePathTemplate(path82)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types86.EdgeType.CALLS };
@@ -22795,16 +23007,18 @@ function serializeGraph(graph) {
   });
   return { nodes, edges };
 }
-function projectFromReq(req2, singleProject) {
+function projectFromReq(req2, singleProject, registry) {
   const params = req2.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, req2, reply, bootstrap, singleProject) {
-  const name = projectFromReq(req2, singleProject);
+  const name = projectFromReq(req2, singleProject, registry);
   const ctx = registry.get(name);
   if (!ctx) {
     const phase = bootstrap?.status(name);
@@ -22816,10 +23030,13 @@ function resolveProject(registry, req2, reply, bootstrap, singleProject) {
       void reply.code(503).send({ ready: false, project: name, status: "broken" });
       return null;
     }
+    const unnamed = req2.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;
   }
@@ -23732,7 +23949,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();
@@ -23767,13 +23984,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(path81, deps) {
+async function cpGet(path82, deps) {
   const f = deps.fetchImpl ?? fetch;
-  const res = await f(`${deps.cpUrl.replace(/\/+$/, "")}${path81}`, {
+  const res = await f(`${deps.cpUrl.replace(/\/+$/, "")}${path82}`, {
     headers: { authorization: `Bearer ${deps.daemonToken}`, accept: "application/json" },
     signal: AbortSignal.timeout(CP_REQUEST_TIMEOUT_MS)
   });
-  if (!res.ok) throw new Error(`control plane ${path81} \u2192 HTTP ${res.status}`);
+  if (!res.ok) throw new Error(`control plane ${path82} \u2192 HTTP ${res.status}`);
   return await res.json();
 }
 function credentialRecord(provider, cred) {
@@ -23834,7 +24051,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 {
@@ -23845,14 +24062,14 @@ async function readPushHandles(projectDir) {
   }
 }
 async function writePushHandle(projectDir, provider, handle) {
-  const path81 = pushHandlesPath(projectDir);
+  const path82 = pushHandlesPath(projectDir);
   const handles = await readPushHandles(projectDir);
   handles[provider] = handle;
-  await (0, import_promises.mkdir)((0, import_node_path75.dirname)(path81), { recursive: true });
-  const tmp = `${path81}.${process.pid}.tmp`;
+  await (0, import_promises.mkdir)((0, import_node_path76.dirname)(path82), { recursive: true });
+  const tmp = `${path82}.${process.pid}.tmp`;
   await (0, import_promises.writeFile)(tmp, `${JSON.stringify(handles, null, 2)}
 `, "utf8");
-  await (0, import_promises.rename)(tmp, path81);
+  await (0, import_promises.rename)(tmp, path82);
 }
 function pushCredentialRecord(provider, cred, deps) {
   switch (provider) {
@@ -24073,7 +24290,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;
@@ -24102,7 +24319,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, fs41] = await Promise.all([
+  const [{ default: git }, httpMod, fs42] = await Promise.all([
     import("isomorphic-git"),
     import("isomorphic-git/http/node"),
     import("fs")
@@ -24113,7 +24330,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: fs41,
+    fs: fs42,
     http,
     dir: destDir,
     url: cleanUrl,
@@ -24144,7 +24361,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);
@@ -24281,9 +24498,9 @@ function makeK8sFetchImpl(transport) {
     req2.end();
   }));
 }
-async function listResource(transport, namespace, path81, opts = {}) {
+async function listResource(transport, namespace, path82, opts = {}) {
   const base = opts.apiUrl ?? transport.server;
-  const url = `${base.replace(/\/$/, "")}${path81}`;
+  const url = `${base.replace(/\/$/, "")}${path82}`;
   const fetchImpl = opts.fetchImpl ?? makeK8sFetchImpl(transport);
   const res = await junctionFetch(
     url,
@@ -24293,7 +24510,7 @@ async function listResource(transport, namespace, path81, opts = {}) {
     { provider: "kubernetes", accountKey: `${safeHost(transport.server)}/${namespace}`, fetchImpl }
   );
   if (!res.ok) {
-    throw new Error(`kubernetes ${path81} failed: ${res.status} ${res.statusText}`);
+    throw new Error(`kubernetes ${path82} failed: ${res.status} ${res.statusText}`);
   }
   const json = await res.json();
   return Array.isArray(json.items) ? json.items : [];
@@ -24314,14 +24531,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;
 }
@@ -24332,7 +24549,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);
@@ -24597,14 +24814,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;
@@ -24703,8 +24920,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(),
@@ -24714,34 +24931,34 @@ function buildUnroutedSpanRecord(serviceName, traceId, now = /* @__PURE__ */ new
   };
 }
 async function appendUnroutedSpan(neatHome4, record) {
-  const target = import_node_path78.default.join(neatHome4, "errors.ndjson");
-  await import_node_fs40.promises.mkdir(neatHome4, { recursive: true });
-  await import_node_fs40.promises.appendFile(target, JSON.stringify(record) + "\n", "utf8");
+  const target = import_node_path79.default.join(neatHome4, "errors.ndjson");
+  await import_node_fs41.promises.mkdir(neatHome4, { recursive: true });
+  await import_node_fs41.promises.appendFile(target, JSON.stringify(record) + "\n", "utf8");
 }
 function unroutedErrorsPath(neatHome4) {
-  return import_node_path78.default.join(neatHome4, "errors.ndjson");
+  return import_node_path79.default.join(neatHome4, "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) {
@@ -24773,7 +24990,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 {
   }
 }
@@ -24782,12 +24999,12 @@ function reconcileDaemonRecordSync(record, home) {
     const stopped = { ...record, status: "stopped" };
     const target = daemonJsonPath(record.projectPath);
     const tmp = `${target}.${process.pid}.tmp`;
-    (0, import_node_fs41.writeFileSync)(tmp, JSON.stringify(stopped, null, 2) + "\n");
-    (0, import_node_fs41.renameSync)(tmp, target);
+    (0, import_node_fs42.writeFileSync)(tmp, JSON.stringify(stopped, null, 2) + "\n");
+    (0, import_node_fs42.renameSync)(tmp, target);
   } catch {
   }
   try {
-    (0, import_node_fs41.unlinkSync)(daemonDiscoveryPath(record.project, home));
+    (0, import_node_fs42.unlinkSync)(daemonDiscoveryPath(record.project, home));
   } catch {
   }
 }
@@ -24822,11 +25039,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;
@@ -24878,9 +25095,9 @@ function spanBelongsToSingleProject(graph, project, serviceName) {
   );
 }
 async function bootstrapProject(entry2, connectors = [], neatHome4) {
-  const paths = pathsForProject(entry2.name, import_node_path79.default.join(entry2.path, "neat-out"));
+  const paths = pathsForProject(entry2.name, import_node_path80.default.join(entry2.path, "neat-out"));
   try {
-    const stat = await import_node_fs41.promises.stat(entry2.path);
+    const stat = await import_node_fs42.promises.stat(entry2.path);
     if (!stat.isDirectory()) {
       throw new Error(`registered path ${entry2.path} is not a directory`);
     }
@@ -25032,7 +25249,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.`
@@ -25040,14 +25257,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();
@@ -25259,7 +25476,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}`
@@ -25437,7 +25654,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}`
@@ -25472,7 +25689,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}`
@@ -25519,9 +25736,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(() => {
@@ -25570,7 +25787,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 {
@@ -25593,9 +25810,9 @@ init_auth();
 // src/web-spawn.ts
 init_cjs_shims();
 var import_node_child_process2 = require("child_process");
-var import_node_fs42 = require("fs");
+var import_node_fs43 = require("fs");
 var import_node_net = __toESM(require("net"), 1);
-var import_node_path80 = __toESM(require("path"), 1);
+var import_node_path81 = __toESM(require("path"), 1);
 var DEFAULT_WEB_PORT = 6328;
 var DEFAULT_REST_PORT = 8080;
 function asValidPort(value) {
@@ -25604,11 +25821,11 @@ function asValidPort(value) {
 }
 function projectRoot() {
   const fromEnv = process.env.NEAT_SCAN_PATH;
-  return import_node_path80.default.resolve(fromEnv && fromEnv.length > 0 ? fromEnv : process.cwd());
+  return import_node_path81.default.resolve(fromEnv && fromEnv.length > 0 ? fromEnv : process.cwd());
 }
 async function readDaemonPorts(root) {
   try {
-    const raw = await import_node_fs42.promises.readFile(import_node_path80.default.join(root, "neat-out", "daemon.json"), "utf8");
+    const raw = await import_node_fs43.promises.readFile(import_node_path81.default.join(root, "neat-out", "daemon.json"), "utf8");
     const parsed = JSON.parse(raw);
     const ports = parsed?.ports ?? {};
     return { web: asValidPort(ports.web), rest: asValidPort(ports.rest) };
@@ -25653,10 +25870,10 @@ function resolveWebPackageDir() {
     eval("require")
   );
   const pkgJsonPath = req.resolve("@neat.is/web/package.json");
-  return import_node_path80.default.dirname(pkgJsonPath);
+  return import_node_path81.default.dirname(pkgJsonPath);
 }
 function resolveStandaloneServerEntry(webDir) {
-  return import_node_path80.default.join(webDir, ".next/standalone/packages/web/server.js");
+  return import_node_path81.default.join(webDir, ".next/standalone/packages/web/server.js");
 }
 async function pickInternalPort() {
   return new Promise((resolve, reject) => {
@@ -25709,7 +25926,7 @@ async function spawnWebUI(restPort, opts = {}) {
         NEAT_API_URL: apiUrl
       };
       child = (0, import_node_child_process2.spawn)(process.execPath, [serverEntry], {
-        cwd: import_node_path80.default.dirname(serverEntry),
+        cwd: import_node_path81.default.dirname(serverEntry),
         env,
         stdio: ["ignore", "inherit", "inherit"],
         detached: false
@@ -25885,14 +26102,14 @@ function localVersion() {
 }
 function neatHome3() {
   if (process.env.NEAT_HOME && process.env.NEAT_HOME.length > 0) {
-    return import_node_path81.default.resolve(process.env.NEAT_HOME);
+    return import_node_path82.default.resolve(process.env.NEAT_HOME);
   }
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return import_node_path81.default.join(home, ".neat");
+  return import_node_path82.default.join(home, ".neat");
 }
 async function readPid() {
   try {
-    const raw = await import_node_fs43.promises.readFile(import_node_path81.default.join(neatHome3(), "neatd.pid"), "utf8");
+    const raw = await import_node_fs44.promises.readFile(import_node_path82.default.join(neatHome3(), "neatd.pid"), "utf8");
     const n = Number.parseInt(raw.trim(), 10);
     return Number.isFinite(n) ? n : null;
   } catch {